Keine Maus, keine Tastatur: Wie KI trotzdem deine Programme bedient

Season 8· 6. September 2026· 2716

Episode cover: Keine Maus, keine Tastatur: Wie KI trotzdem deine Programme bedient
0:002716
  • Dr. Theo SteiningerCo-Founder & CEO at Erium
  • Dr. Maksim GreinerCo-Founder & CTO at Erium

Overview

In this episode, Theo Steininger and Maksim Greiner take apart the technical engine room behind AI agents: How can a language model that only generates text still trigger web searches, query databases, or send emails? The two explain tool calling, APIs, MCP servers, and authentication in an accessible and practical way - including concrete security risks that can arise when deploying AI agents in an enterprise context.

Summary

Tool Calling: How an LLM Communicates with the Outside World

A large language model can fundamentally only generate text - it has neither a mouse nor a keyboard. Nevertheless, it can interact with the real world by embedding specially encoded function calls within its text output. The infrastructure surrounding the model detects these calls, executes the corresponding function, and sends the result back to the model as text. The model itself only sees which functions it has been permitted to use and responds to the returned results - what happens in the background remains hidden from it.

This ping-pong between model and infrastructure repeats until no further function call is needed and the final response can be delivered to the user.

From Passive RAG to Active Tool Calling

Before tool calling existed as a standard, the runtime environment itself - without consulting the model - performed a semantic search based on the user's prompt and supplied the model with relevant context snippets. The model had no choice and no influence over the search.

With tool calling, this relationship is reversed: the model decides for itself whether and how to search, can issue follow-up queries, try different search terms, or retrieve specific pages. This is the core of agentic behavior - the model iterates independently until it is satisfied.

Why Specialized Tools Are Safer Than Open Code Access

In theory, one could simply give an LLM access to a terminal so it can execute arbitrary code. That would be extremely powerful, but also dangerous: the model could delete files, send emails, or access confidential data - limited only by its own 'good behavior,' not by structural constraints.

Specialized tools solve this problem: they define exactly which inputs are permitted and what happens with them. This creates security (no unwanted actions possible), reproducibility (behavior is predictable), and cost efficiency. Instead of hoping for the model to behave well, the scope of action is technically restricted.

A concrete risk with overly broad database access: if an LLM deletes a customer record directly at the database level without going through the application's business logic, inconsistent data records result - orphaned entries, broken references, and chain reactions that are difficult to debug.

APIs: The Contract Between Machines

An API (Application Programming Interface) is a clearly defined interface that specifies which requests may be made to a system, in what format data is transmitted, and what responses to expect. This 'contract' enables reliable machine-to-machine communication - and has long been the foundation of every modern web application, even without AI.

For AI agents, direct API integration is far superior to browser control: while an LLM can only operate a virtualized browser clumsily through screenshot interpretation and simulated mouse clicks, it communicates via APIs directly in machine-readable text formats such as JSON - faster, cheaper, and more reliably. Browser automation is therefore only recommended for legacy systems without an API or for automated usability testing.

MCP: The USB-C Standard for AI Agents

MCP (Model Context Protocol) is an open standard developed specifically for communication between LLMs and external services. It solves a practical problem: without a common standard, every combination of AI agent and backend system would need to build its own bridge. With MCP, it is sufficient for agents and servers to each 'speak' MCP once - after that, all combinations are compatible.

Compared to classic REST APIs, MCP additionally offers standardized discoverability of all available functions, leaner response formats (which do not overload the LLM's context), and cleaner handling of authentication. Anyone who already has a REST API can add an MCP adapter with manageable effort.

Authentication and Access Rights: Who Is Actually Acting Here?

When an AI agent accesses Outlook, a CRM, or other systems on behalf of a user, this happens via tokens - time-limited, encrypted keys that are passed to the infrastructure without the LLM itself ever seeing the token. Depending on the configuration, the agent acts either under the user's identity (personal token) or under its own service role.

A common mistake in practice: prototypes start with overpowered service tokens that can access all data across the entire organization. The principle of least privilege - a token may only do exactly what is necessary for the specific task - is critical for secure AI agents. Ideally, the agent inherits the access rights of the respective user, so that it is structurally not permitted to do more than the person on whose behalf it is acting.

Long-Term Memory and Infrastructure: What Lies Behind the Chatbot

An LLM alone has no memory beyond a single session. For a chatbot to remember earlier conversations, the surrounding infrastructure must store chat histories, summarize them, and selectively reintroduce them with new requests. This does not happen through the model itself, but through the computer programs around it - databases, schedulers, summarization jobs.

This infrastructure is also the reason why it is technically complex to keep agent sessions open when the browser is closed. Features such as persistent chats, recurring automated tasks, or user-specific memory require considerable backend effort - and are therefore far more than a pure model feature.

Key takeaways

  • An LLM can only generate text - all interactions with the outside world run through specially encoded function calls that are executed by the surrounding infrastructure.
  • Tool calling makes AI agents active: the model decides for itself when and how to invoke external functions, rather than passively receiving pre-prepared context.
  • Specialized tools are safer than open code access because they structurally limit the model's scope of action - independent of the model's behavior.
  • Direct database access by LLMs is risky because business logic and consistency rules can be bypassed; routing through defined APIs with business logic is significantly safer.
  • MCP is an open standard that standardizes the integration of AI agents with external services and drastically reduces the effort required for individual bridge solutions.
  • Authentication tokens should follow the principle of least privilege: the agent is structurally not permitted to do more than the person on whose behalf it is acting.
  • Long-term memory and persistent sessions are not model features but infrastructure services - an LLM alone is barely capable of acting without the programs surrounding it.
  • Browser automation by AI agents is slow, error-prone, and expensive - only useful for legacy systems without an API or for automated usability testing.

Conclusion

The episode makes clear that there is far more behind an AI agent than a language model: tool calling, APIs, MCP standards, authentication logic, and infrastructure for memory and recurring jobs together form the actual system. Anyone who wants to deploy AI agents productively and securely must understand these layers - and must approach the topic of access rights carefully from the very beginning, rather than starting with master keys.

For Leaders and Decision-Makers

AI agents are not a plug-and-play solution: secure and reliable systems require well-thought-out infrastructure, clear access rights, and clean API integrations. Taking this into account from the start avoids costly rework and security risks.

For Technical Implementers and Developers

The episode provides a solid conceptual foundation for tool calling, MCP, and token-based authentication - including concrete guidance on why direct database access by LLMs should be avoided and API layers with business logic should be preferred instead.

For AI-Curious Beginners

Anyone who wants to understand how ChatGPT, Copilot, and similar tools actually interact with other programs will find a clear explanation here that requires no prior knowledge - from the basic idea of tool calling to the question of who is actually acting when a bot sends an email.

Show full transcript

Speaker0: Ich hab son Standardthema bei meinen Schulungen. Ich referenzier immer wieder auf meine Schulungen, stell fest. Und zwar ist es das Thema der Konnektivität. Wir hatten's ja beim letzten Mal schon die Dreifaltigkeit, prompt, Kontext, Tooling und vor allem das Toolingthema. Das ist so was, das ist vor allem von allen Themen die schwärzste Blackbox, hab ich den Eindruck. Mhm. Und deswegen lass uns da mal genauer einsteigen. Wir haben Zeit für Hamuse und lass uns das Thema mal auseinandernehmen. Und eine Sache, die mal so ganz fundamental ist, sone KI hat ja weder Maus noch Tastatur. Das ist 'n Sprachmodell, das kann mit Text antworten. Ja. Wie zum Geier ist es dann möglich, dass, Beispiel, eine KI eine Websearch durchführt. Hol uns da mal ganz kurz ab und erklär das mal bitte, was da eigentlich im Hintergrund passiert. Okay,

Speaker1: dann erklären wir's, was ist Tool Calling? Also wie kann ein Large Language Modell, also ein KI Modell mit der echten Welt damit irgendwie interagieren? Wie Du gesagt hast, es kann ja eigentlich nur Text ausspucken. Also alles, was ein LLL möglich kann, ist Generieren von Zeichenketten. So, jetzt kann man aber in soner Zeichenkette ja quasi wie eine Botschaft verstecken, die nicht gedacht ist als hallo Theo, wie geht es dir? Sondern stell dir so was vor wie, ich würde sagen, okay, 4 spitze Klammern, so funktioniert's nicht, ich mach's nur mal vorstellbar, aber 4 spitze Klammern und dann steht da Theo Doppelpunkt bestelle Pizza, 4 spitze Klammern. So und dann weißt Du Theo, okay, das ist jetzt nicht mein Gespräch mit dir, sondern es ist eine Instruktion. Und solche, also speziell quasi mit speziellen Zeichen eingebettet Instruktionen, generieren diese LLMs und es ist dann an der Umgebung, also dem Computer, auf dem das LLM läuft und der Computer, der mit dem LLM initial spricht Also wenn Du jetzt 'n Chatbot hast, dann schickt ja deinen Browser, also dein dein dein Internetfenster. Dein Browser schickt quasi den Text, den Du abgesendet hast, an irgendeinen Server. Und dieser Server wird dann wiederum mit dem mit der mit dem dicken GPU Server, auf dem das Sprachmodell läuft, kommunizieren und dem quasi Text schicken und Text empfangen. Auf diesem dicken GPU Server passiert also nichts außer Textgeneration. Mhm. Und der Server, der der jetzt dazwischen ist, ist dann typischerweise der, der diese speziellen kodierten Botschaften empfängt und sagt, aha, hier ist ein Funktionsaufruf gefragt, beispielsweise eine Websuche. Wichtig ist noch, vorher schickt er auch diesen dicken Server mit, hey, folgende Funktionen kann ich dir bieten. Mhm. Damit das LLM hara weiß, okay, Websuche Suche existiert, aber Code ausführen beispielsweise nicht. Ja, das kann man definieren in diesen Maschinen Maschinenkommunikation, welche Funktionen darf das LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL und dann in Anführungszeichen beliebteste Hunderasse in Großbritannien. Spitze Klammer, Spitze Klammer. Und dann empfängt das dieser Server dazwischen, ah, okay. Und dann macht der eine Websuche. Wie auch immer der jetzt die implementiert hat, das muss das LLM gar nicht wissen. Also das heißt, da passiert unter Umständen noch viel mehr, als was das LLM weiß. Also vielleicht passieren 10 Websuchen, die dann aggregiert werden und dann wieder nur dem LLM das Ergebnis zurückgeschickt wird. Das heißt, da ist sone Abstraktion. Das LLM sieht nur, ich darf Folgendes tun. Ich tue es, ich kriege ein Ergebnis und reagiere dann irgendwie darauf. Und dann Ping Punkt, dass im Prinzip dieser Server und der dicke LLM Server hin und her, bis kein kein Funktionsaufruf mehr da ist und dann kriegst Du deine finale Antwort vor der, der Du vor deinem Browser sitzt. Aber das heißt, diese ganze Interaktion 1 LLMs mit dem Rest der Welt passiert durch quasi eine, wie sagt man auf Deutsch, also quasi eine Liste an erlaubten Funktionsaufrufen, die jemand anderes, also ein anderer Computer für das Large Language Modell ausführen muss. So, langer Rede, kurzer Sinn. LLM schreibt immer nur Text, kann aber diesen Text spezielle Funktionsaufrufe kodieren und die Infrastruktur drum rum kümmert sich dann darum, dass die ausgeführt werden. Und schickt das Ergebnis als LLM zurück, damit es dann quasi auch was davon hat.

Speaker0: Was ja da viele gar nicht im Schirm haben, ist, dass es 2 verschiedene Varianten ja von gibt oder also es gibt bestimmt noch viel mehr Spielarten, aber das sind so die die die beiden Hauptarten von, also, nämlich die eine, bei der das Modell genau diese Entscheidung trifft, wie Du sie grad beschrieben hast. Ja. Dass das LLM sagt, okay, ich such jetzt in einem Wiki, in 'nem Conflience SharePoint, wie auch immer über genau son Tool Call. Bevor das ging, ich geh noch die Variante, dass die Laufzeitumgebung,

Speaker1: ohne dass das Modell drum gebeten hat, quasi immer diese semantische Suche anhand der aktuellen Prompt durchgeführt hat und dem Modell, ob's wollte oder nicht, eben noch zusätzlichen Kontext mit reingestopft hatte. Genau, lass uns das einmal runterbrechen, weil ich glaub, das ist dann noch mal Mhm. Vielleicht holt noch mal die Leute ab, die ich grad verloren hab mit meiner längeren Erklärung. Also wenn ich früher als diese als die LLMs dieses Tool Calling noch nicht konnten, weil's noch keinen Standard gab für dieses spitze Klammer oder was auch immer, also wie ich signalisieren kann, ich möchte was eine Funktion aufrufen. Wie hat man dann quasi sone also, das heißt eine Antwort, die mehr Text beinhaltet? Beispielsweise, ich möchte hier, ich hab meinen tausendseitigen Schinken, also irgendein langes Buch und ich stell dazu eine Frage, wie hat das dann früher funktioniert? Bevor meine Frage an das Large Language Modell geschickt wurde, hat die Laufzeitumgebung drum rum, also der Server, von dem wir grad gesprochen haben, meine prompt in eine semantische Suche übersetzt, diese Suche auf die 1000 Seiten ausgeführt, dann vielleicht die 5 besten Treffer mitgenommen und dann quasi meine prompt an das Lodge Language Modell erweitert. Dass da steht irgendwie so was wie, User hat gefragt, Doppelpunkt, was ist Harry Potters erster Zauberspruch? Ja. Und hier sind die 5 wichtigsten Seiten dafür und dann ist da, keine Ahnung, Seite 30, Seite 35 und so weiter, dann halt als kompletter Text. Das kriegt dann das Large Language Modell und muss damit leben. Es kann nur diesen Text, hat diesen Text empfangen und kann auch nur mit Text antworten. So. Und mit dem Tool Calling konnte das dann umgedreht werden, sodass quasi der Server erst mal nur meine Frage an das Large Language Modell geschickt hat, aber in den quasi Zusatzdaten, hey, Du hast noch die folgende Funktion Suche in Harry Potter. Ja, Ah, und dann kann das konnte das Modell entscheiden. Bevor ich antworte, mach ich eben diesen Funktionsaufruf. Ich suche nach, keine Ahnung, Zauberspruch Komma Harry. Krieg dann vielleicht genau diese selben 5 Seiten zurück wie vorher, aber es war jetzt die Entscheidung des Models und das könnte dann auch entscheiden und heutzutage machen die das dann auch, ah, bin noch nicht zufrieden. Ich such mal jetzt noch nach Zauberstab. Ja. Oder Allein schon Folgeseiten, ne. Wenn's fest die spannende Passage käme eigentlich jetzt auf die nächsten Seite, Stichwort Handbücher. Genau, wenn das diese Funktion Suchparameter erlauben, okay, ja, ich möcht dabei explizit noch mal Seiten 15 bis 20 sehen. Und dann antwortet das das erst. Dann kann's halt dieses, da sind wir wieder bei diesem Agentischen, wenn's dann halt hin und her iteriert und selber entscheidet, was das als Nächstes macht. Ja, aber so ging's quasi von der von dem passiven zum aktiven, würd ich's mal sagen. Ja, ja, ja. Und

Speaker0: wieso gibt's überhaupt verschiedene Tools und Tool Calls? Weil man könnte ja sagen, also die, die aufmerksam lauschen, man kann 'ner KI einfach eine virtuelle Maschine oder auch 'n Zugang zum eigenen Computer in die Hände drücken. Passt doch. Also warum braucht's denn überhaupt unterschiedliche Tools? Vielleicht erst mal kurz, was heißt das Zugang zum eigenen

Speaker1: Computer? In die Hand drücken heißt am Ende des Tages, Du gibst dir meine Funktion. Mhm. Und in diese diese Funktion akzeptiert als Argument Code. Das heißt, damit kann das large Language Modell jetzt nicht mehr nur sagen, hey, ich suche nach Harry Komma Zauberspruch, sondern ich sag, ich führe Code aus, typischerweise in also so Konsolensprache. Und da kann es dann zum Beispiel schreiben, Mateprogramm x in, oder macht eine File Dateisystemsuche oder, oder, oder. Also es kann, wenn Du einen einen, einen, wenn Du eine Funktion hast, die quasi vollständigen Code Touring vollständig Mhm. Ist da das Stichwort? Pixel. Ja, dann kann damit das Large Language Modell alles dort machen, was nicht durch irgendwelche weiteren Rechte dieser dieses Terminals begrenzt ist. Mhm. Supermächtig, aber auch gefährlich, ne. Also sagen wir mal, dein, diese Funktion läuft auf deinem Computer und da sind Dateien, die sind vielleicht vertraulich. Oder was hindert das Large Language Modell daran, deine Festplatte zu löschen, ja? Oder E-Mails an alle deine Verwandten zu verschicken mit Beleidigungen und so was. Da hindert es dann quasi nur, dass die die die Gutmütigkeit vom large Language Modell selbst, ja, aber kann nichts Strukturelles. Und wenn Du und und deswegen können Tools im Vergleich zu beliebigen Code diese strukturelle Sicherheit anbieten. Weil wenn zum Beispiel das Tool ist, nicht beschreibe irgendwelchen Codes, sondern Du darfst nur suchen und nur lesen, dann kann er immer noch wahnsinnig viel, aber er kann halt keine E-Mail verschicken, er kann nix löschen. Das war das eine und das andere ist, Du möchtest vielleicht mehr Zuverlässigkeit. Wenn das Modell Code schreibt, kann es den noch mal so, mal so, mal so, mal so schreiben. Und wenn Du in der Funktion gesagt, hey, folgende Eingabeparameter akzeptiere ich und dann passiert genau das damit, dann hast Du's festgelegt. Heißt diese Themen Sicherheit und Reproduzierbarkeit, bisschen auch Kosteffizienz, aber Sicherheit und Reproduzierbarkeit sind eigentlich der Grund, warum Du nicht nur ein Tool, alles zu beherrschen hast, sondern mehrere.

Speaker0: Beim Thema Sicherheit, was sich da sehr häufig bei den Leuten jetzt die Co Work Features ausprobieren, eben vor allem aufm eigenen Computer, das ist das Erwachen, wenn festgestellt wird, dass wenn man beliebig in Dateien oder vielleicht dann sogar eine Datenbank reinschreiben kann, Mhm. Dass das dann auch Dinge kaputtmachen kann von der von der von der semantischen Ebene. Also was mein ich damit? Der Klassiker ist, wenn wir auf eine, nehmen wir mal CRM Datenbank, ja, also Customer Relationship Management Datenbank hergehen, dann ist es ja auch technologisch total easy, dass eine KI 'n kleines Datenbankfile anlegt und dann Ja. Daten arbeitet. Oder nehmen wir Excel, ja. Excel einfach mit verschiedenen Tabellenblättern. Und dann passiert's aber total schnell, dass wenn ich sag, okay, ich lösche jetzt beispielsweise einen Kunden Mhm. Dass dann 'n inkonsistenter Datensatz entsteht. Weil sozusagen in dem Tabellenblatt für Kunde, Ja. Wurde der Eintrag gelöscht. Und das Model Language Modell hat aber vergessen oder hat er grad nicht am Schirm, dass es noch Personen und Deals gibt, die auf diesen Eintrag referenzieren und dann sind die verweist. Du sprichst im Prinzip von Kettenreaktionen.

Speaker1: Ja, genau. Die ja in 'ner typischen Software, die ich als User benutzen würde, wo ich Buttons hätte, Ja. Die irgendwas mit der Datenbank machen, dann haben diese Buttons häufig dahinter eine Das ist klar. Ja, genau. Businesslogik. Ganz genau. Wenn Du das anlegst, musst Du auch das anlegen. Wenn Du das löscht, musst Du auch das löschen und so weiter und so weiter. Oder zumindest fragen, ja? Was sollen wir jetzt mit den Leuten machen? Sollen wir die irgendwie auf auf auf auf setzen oder sollen wir die auch weglöschen, ja? Genau, genau. Ja. Und das funktioniert dann eben auch wunderbar, wenn es in den Tools, in den Funktionen, also kurz, Funktionen und Tools meint bei Models Language Models das Gleiche. Ja. Dass dann da halt abgelegt ist, sodass quasi entweder passiert die ganze Kaskade oder nix, aber wenn das direkten Datenbank Zugriff hat, was es per Code dann erst mal hätte, Mhm. Dann liegt's halt am Large Language Modell, ob's diese Kaskade einhält oder nicht. Ja, ja. Und genau daran kann das passieren. Die vergessen mal was. Und dann hast Du eben zum Beispiel son eine verwaiste Karteileiche, die vielleicht gar nicht mehr dir sichtbar ist. Oder Du hast irgendwo 'n Datensatz, der, wenn Du ihn aufrufst, 'n Fehler wirft. Genau.

Speaker0: Und das bringt mich zur nächsten Frage, weil im Idealfall pflegt man ja vor allem Businesslogik auch nur an einem Ort. Ja. Und das ist, wenn man jetzt sagt, okay, man hat, bleiben wir beim Beispiel CRM, eine Web App, die implementiert die ganze Businesslogik. Und dann ist der logische Schritt ja, dass man hergeht und sagt, okay, der KI Agent, der operiert jetzt nicht low Level auf der Datenbank, Ja. Sondern über eine API, also eine Schnittstelle, die die CRM Applikation zur Verfügung stellt, von extern mit anderen Diensten, zum Beispiel KI Agenten Genau. Interagieren zu können. Und dann werd ich dann sofort auch immer mit Hundeaugen angeguckt und das kriegt die Frage, ah okay, aber was ist eine API?

Speaker1: Was eine, okay, was ist eine API? Ich hab ja vorhin gesagt, wenn jemand, also wenn der Server an an den dicken LLM Server schickt, hey, folgende Userfrage und, folgende Funktionen darfst Du aufrufen. Er schickt ihm also Spezifikationen, was für Funktionen er akzeptiert. Und das haben die sich nicht extra für die l l ms ausgedacht, sondern das ist genau das Wesen 1 API. Das heißt also 1 Schnittstelle, das heißt, hey, es gibt hier eine Spezifikation, gerne wird man noch gesagt, das ist quasi wie ein Vertrag. Mhm. Wenn Du mir folgende Zeichenkette schickst, dann werde ich in folgender Art und Weise antworten. Also Beispiel ist, typischerweise, also was wär jetzt zum Beispiel vorm, nehmen wir mal, also nehmen wir mal wirklich halt, fangen wir mal mit mit dem Browser, ja? Also wenn wenn Du in irgendeinem Programm einen Knopf hast, der der heißt zum Beispiel Kunde anlegen in deinem Browser, dann steckt dahinter eine API, eine Schnittstelle. Und der Button wird so was bauen wie, okay, ich schicke an folgende Adresse folgende Daten wie Kunde Doppelpunkt so und so, Besitzer Doppelpunkt so und so und Zeitstempel mal als Beispiel. Und dass das Besitzer heißt und nicht ohne oder

Speaker2: keine Ahnung,

Speaker1: oder so was und dass das ein Text ist und nicht eine Zahl Mhm. Und dass das Datum ein Datum ist und nicht ein war falsch oder so was, das sind diese Sachen, die in der Spezifikation der API festgelegt sind, damit es in der Maschine zu Maschine Kommunikation nicht ständig zu Fehlern kommt. Und gleichzeitig weiß dein Browser auch aus der API, wenn ich also diesen Knopf drücke, dann hab ich mit folgendem Ergebnis zu rechnen wie beispielsweise ein okay Doppelpunkt. Mhm. Ja? Dann weiß der, wenn ich ein Ergebnis kriege, dann such ich da drinnen nach dem Schlüssel okay und schau, ob da dann rauskommt und dann kann ich dem User ein grünes Häkchen anzeigen. Das sind so das sind Schnittstellen, ja. Also das heißt, wir definieren, was was, wenn was darf wohin auf welche Art und Weise gesendet werden? Und was kommt dann, was ist die Blumenstrauß an Antwortmöglichkeiten, der zurückkommt? Und alles eben eben so maschinenlesbaren Formaten, typischerweise JSON. Also das ist einfach 1 1 1 Struktur Struktur. Das heißt, ich kann da 'n gewissen Schlüssel suchen und krieg ich da irgend einen Wert und der hat vielleicht wieder in sich Schlüssel. Aber wenn das alles halt vorher ausgehandelt ist, dann kann ein Computer wunderbar das Ding, Parson heißt das, also das Ding interpretieren.

Speaker0: Ja. Wer dann auch suchen möchte, schreibt man JS0N, nicht Jason. Wer ist Jason und welche E-Mail-Adresse hat er? Genau,

Speaker1: also genau, nicht Freddy versus Jason, sondern API und Jason. Ja. Und

Speaker0: also was vielleicht da auch noch mal klargemacht werden muss, Du hast jetzt grad 2 Systeme beschrieben, die miteinander kommunizieren. Das ist bei den Webanwendungen alleine das, was ich im Frontend, also bei mir im Browser hab und dann das Backend der gleichen Applikationen, ne. Also sogar, wenn ich sage, ich hab Salesforce, HubSpot oder was für immer für CRM,

Speaker1: da gibt's schon 2 Instanzen, die miteinander sprechen. Genau, der in deinen Browser Ja. Und der Server, das hinter dem Programm. Und wenn der Server dann mit 'nem anderen Server spricht, wieder APIs. Und also die ganze ganze Computerwelt ist voller Schnittstellen, damit immer, wenn ein Computer von einem anderen Information braucht. Und dein Computer auf deinem Schreibtisch ist nicht der Computer, auf dem bei einem typischen Cloudsystem die Daten liegen. Und deswegen sprechen die mit API miteinander. Ja.

Speaker0: Und das ist auch der Grund, warum das eigentlich so absurd ist, wenn man jetzt einen Agenten wie ChatGPT oder Manus war, der auch 1 der ersten Anbieter, auf einen virtualisierten Browser loslässt, dann in diesem virtualisierten Browser Knöpfe zu drücken, also virtuelle Knöpfe zu drücken. Weil das ja im Wesentlichen nur eine Hilfe dafür ist oder 'n Fix dafür ist, dass man keine proper API vom eigentlichen Anbieter kriegt, ne. Und dann muss man sich sozusagen darüber behelfen, dass man noch mal diesen zusätzlichen Hopp auf sich nimmt, über den Browser zu arbeiten. Genau. Wir haben ja gesagt, die

Speaker1: Modelle kommunizieren über Text in, Text out. Ja. Muss man ergänzen, sie können auch Bild Bilder Input schlucken und dann quasi ähnlich wie Texte einfach prozessieren. Das heißt, son Screenshot von 'nem Browser, das ist denen relativ naheliegend. Aber hey, ich bewege die Maus dahin und ich klicke dann dort, ist dann total durch von hinten durch die Brust ins Auge, weil dafür müssen die in solchen Tool Calls im Prinzip codieren. Ich möchte gerne klicken auf den Knopf, auf dem senden steht oder so was, ja? Also das müssen die dann quasi in 1 Art von speziellen Textsprache ausspucken. Und deswegen funktioniert das auch nicht so cool. Ja. Also die LLMs können mittlerweile son Browser so halbwegs bedienen, aber stolpern ständig. Weil's halt nicht, ja, die haben halt keine Hand und eine Maus, mit der sie klicken können, sondern die kommunizieren über Text. Und deswegen ist es für 'n Large Language Modell viel, viel, viel, viel effizienter, direkt über diese API zu kommunizieren. Weil dieses Schnittstellenformat, was ich vorhin angesprochen hab, so was wie das Json Format, das ist eigentlich nur spezieller Text, der 1 bestimmten Syntax folgt. Und dementsprechend wunderbar für das Modell interpretierbar und auch schreibbar und damit viel effizienter. Deswegen bieten ja Sachen wie, also wie beispielsweise ein Jira Cloud bietet dann ja auch externen einen MCP Server an, damit Du einen damit Du eine Möglichkeit hast, deinen deinen Agenten direkt mit Jira sprechen zu lassen und nicht über einen Browser da rum rumklicken zu müssen, was Mhm. Zehnmal langsamer, teurer und fehleranfälliger

Speaker0: wär. Ja, ja, ja, ja. Also generell würd ich da gern noch mal festhalten, wer auch immer mit der Idee spielt, großgalig, also 1. Experimente mal beiseitegelegt, aber wirklich regulär und regelmäßig eine KI übern Browser mit 'ner Applikation arbeiten zu lassen. Da gibt's maximal 2 Anwendungsfälle meines Erachtens. Und zwar das eine ist das Anbinden von absoluter Legacy Software Mhm. Die keine Schnittstelle hat. Die keine Schnittstelle hat und bei die Entwicklerinnen und Entwickler tot sind. Ja. Ja. Und der Sourcecode gelöscht und man hat nur noch das kompilierte Ding. Also das ist der eine Case und der andere Case, das sind virtualisierte Usability Tests, wo man ja genau testen oder simulieren möchte, wie geht's Ja. Denn 'nem Nutzer, 'ner Nutzer denn jetzt auf dieser Homepage oder Webapplikation? Also das ist ja genau die Idee davon, jemanden auf die Seite zu lassen. Ansonsten ist alles andere zu teuer, zu langsam, zu brüchig, Richtig. Zu unzuverlässig. Richtig. Ja. Und Du hast jetzt grad schon ein Wort erwähnt, MCP Server. Ja.

Speaker1: Wenn ich mich nicht irre. Und geht einfach darum, ich hab ja vorhin gesagt, der am Anfang hatten die LLMs keine Möglichkeit, Funktionen aufzurufen, weil's auch keinen Standard gab, wie der Text auszusehen hat, zu sagen, hey, der wird jetzt als Funktionsaufruf interpretiert. Gleichzeitig hab ich gesagt, und damit man einen damit das Modell überhaupt einen gültigen Funktionsaufruf schicken kann, Mhm. Muss ich ihm vorher sagen, hey, folgende Funktionen sind erlaubt und folgende Argumente und Parameter unterstützen die. Der nächste Schritt ist dann, okay, was ist denn, wenn ich, Maxim, dir, Theo, die Möglichkeit geben will? Ich hab hier zum Beispiel meine coole Applikation und ich hab da eine Schnittstelle Und ich möchte dir es jetzt einfach machen, dass Du deinem KI Agenten mit dieser Schnittstelle kommunizieren können, also kommunizieren lässt. Und aber dein der Server, der hinter deinen Chatbot steht, der muss ja quasi diese Funktionsdefinition

Speaker2: korrekt Mhm.

Speaker1: An deinen schicken, damit das überhaupt diese Funktionsaufrufe generieren kann. Und da ist halt MCP ein Protokoll, also letztendlich wieder nur ein Standard, wie man sich geeinigt hat. Wie kann ich jetzt die Sachen, die ich dir anbiete, so aufschreiben, sodass Du das ohne, dass Du's selber noch mal umschreiben musst oder so was, direkt quasi an dein Large Language Modell weitergeben kannst, sodass da gültige Aufrufe kommen, die deinen Computer oder ein Computer zumindest in der in der in der Kette dazwischen direkt an meinen Server senden kann und dann gültige Antworten kriegt. Das macht's einfach deutlich einfacher, dass nicht jeder eine eigene Brücke bauen muss, Mhm. Sondern es gibt quasi einen eine Sprache, die dann die modernen alle interpretieren können. Und wenn ich mich an die halte, dann hab ich meine Brücke. Ja, dann brauch ich nicht, wenn ich 5 Chatbots hab und 10 Serversysteme, dann brauch ich nicht 50 50 fünfmal 10 Übersetzungslayer, sondern ich brauch eigentlich dann nur, sagen wir mal, 15 im Sinne von die 5 Agenten müssen natürlich alle MCP können. Ja. Und meine 10 Server müssen alle MCP können. Aber nachdem die LLMs das mittlerweile alle standardmäßig, dann brauch ich eigentlich nur von meinen 10 Servern, also eigentlich nur 10 MCP Adapter und danach ist der ist die Sache gegessen. Ja, ja. Also es ist genau das Gleiche, was wir in Haleri mit den Capabilities Mhm. Groups haben. Wir wir haben's dann nur anders benannt, weil's MCP damals noch nicht so etabliert war. Aber es ist genau das Gleiche, es gibt eine Sprache, die dann die ganzen KI KI Agenten sprechen können. Und Du musst nur dahin übersetzen

Speaker0: und dann flutscht alles. Ja. Jetzt könnten wir aber nicht picky sein und sagen, na ja, wenn's gibt, warum brauch ich dann überhaupt nur MCP? Also weil man könnt ja doch auch einfach die die anstecken oder andersrum gefragt. Bei mir war mal die Frage aufm Tisch von jemandem, der gesagt okay, ich würd gern die und die und die Anwendung anbinden, aber die hat nur, aber kein MCP, ist das jetzt schlimm? Mhm.

Speaker1: Aus meiner Sicht ist man, also 1, da da müsst ich jetzt auch noch mal über die die Details genau nachdenken, aber aus meiner Sicht ist im Prinzip eine Rest API, es ist ja anderes als, hey, hier ist ein klar definierter Standard, wie Du deine Aufrufe zu formulieren hast. Was aber bei Rest APIs nicht zwingend standardisiert ist, ist, wo finde ich denn die Übersicht aller gültigen Kommandos? Mhm. Ja, also mittlerweile gibt's mit Open API Ja. Da die Konvention bis hin zum Standard, hey, wenn Du da und da hingehst, dann findest Du für eine bestimmte Seite alle gültigen Aufrufe. Aber Bist Du denn zu formalisiert, ne? Genau, ist halt, da hat sich noch nicht ganz durchgesetzt. Dann hat man das bei MCP halt gesagt, na ja, das standardisieren wir jetzt einmal für die large Language Modelle. Und dann gibt's noch son paar Kleinigkeiten, wie das Rest APIs typischerweise typischerweise sehr ausführlich sind in dem, was sie dir auch zurückgeben. Mhm. Also das würde halt den Kontext von sonem Large Language Modell meistens total überfrachten. Das heißt, da hat man dann noch mal so bisschen die Entscheidung getroffen, wie machen wir's quasi effizienter fürs Large Language Modell? Und das und dann das Letzte ist dann noch Authentifizierung. Also typischerweise ist es so, wenn Du einen hast, also eine Anfrage bei 1 schickst, dann schickst Du einen mit und in dem steht zum Beispiel dein Authentifizierungsschlüssel, Mhm. Der dann wieder verschlüsselt ist, sodass es niemand dazwischenlesen kann. Aber damit weiß dann der Server, h, diese Anfrage kommt von dir, Theo. Und das ist zum Beispiel was, was bei 'nem MCP Server nicht dann dem LLM aufgebürdet wird, einen gültigen Schlüssel mit in den in die Anfrage zu schreiben, sondern das macht dann der LMCP Server für dich, muss dafür natürlich einmal entsprechend eingerichtet werden. Mhm. Aber damit schlägt man quasi die, auch die Frage oder auch das Problem, na na ja, man will ja vielleicht gar nicht, dass das Model language Modell diesen Schlüssel kennt. Und das heißt, das ist son bisschen Optimierung, bisschen Standardisierung und Authentifizierung, würd ich sagen, unterscheidet am Ende des Tages MCP von von REST. Mhm. Da kann man jetzt können mich jetzt 100 Leute mit Kommentaren erschlagen und die wahrscheinlich alle richtig sind.

Speaker0: Ja, aber Aber nichtsdestotrotz, REST APIs gibt's schon deutlich länger als LLMs. Und LLMs haben sich dann rausgestellt, dass die gut damit umgehen können. Und MCP wurde spezifisch für LLMs, die sind auch, ne. Genau. Und wenn Du schon eine Rest API hast, dann ist quasi ein MCP

Speaker1: drum rum zu machen. Ja, ist ist billig, ja. Ja, ist im Prinzip keine große Aufgabe. Mhm,

Speaker0: Mhm, mhm. Das heißt, wenn man jetzt einen Chatbot nutzt, sei das ChatGPT, vielleicht 'n Co Piloten. Ja. Und dann gibt's ja meistens die Drop downs, wo man zusätzlich Funktionen anhaken kann. Ja. Dann passiert im Hintergrund was genau.

Speaker1: Was passiert das bei dem, also sagen wir mal, ich ich setz, bleiben wir da bei der Websuche. Ich setz das Häkchen meinem Chatbot irgendwie, Du hast jetzt Websuche. Dann wird bei der, ob da jetzt MCP Server dann dazwischen ist oder nicht, ist eigentlich egal. Sondern es wird am Ende des Tages bei dem bei der bei der Instruktion, die an das LLM mitgeschickt wird, die am Ende des Tages irgendwo nur text ist, wird mitcodiert. Du hast jetzt hier folgenden Zugriff auf eine Funktion, die heißt Websearch und die hat vielleicht 2 Parameter. Der eine ist der Suchstream und der andere ist Anzahl der Ergebnisse. Mhm. Und zurückkriegen wirst Du eine Liste mit den Ergebnissen als Text und den zugehörigen Adressen beispielsweise. Und dann weiß das LLM, also weiß in Anführungszeichen, kann das LLM quasi in 'nem speziellen String antworten. Ich mach jetzt den Toolcall Websearch mit, beliebteste Hunderasse Großbritannien, bitte 3 Ergebnisse. Mhm. Mhm. Das ist das, was passiert. Und wenn ich das Häkchen weggesetzt hätte oder sagen wir mal, ich im Follow-up Mhm. Setz ich das Häkchen jetzt weg. Bin in meinem gleichen Chat. Ja. Dann geht das jetzt an das Lodge Language Modell, was ja dann noch diese Chathistorie hat, ah, ich habe ja grade eine Websuche gemacht. Aber in dem neuen in der neuen Anfrage steht dann nicht dabei, Du hast das Tool Websuche und das und und so und so funktioniert es. Und dann ist es auch ganz interessant, manche Modelle halten sich dann strikt daran, okay, dieses Tool ist jetzt weg, ich kann das nicht mehr aufrufen. Manche sind da optimistisch und sagen, na ja, probieren wir's halt noch mal. Ja, ja, die Klotenmodelle, ne? Genau. Aber dann scheitert das, weil der Server, der diesen Anfall geschickt hat, der kriegt dann quasi zurück Websuche, aber er selber hat ja die Websuche nicht mehr angeboten, Mhm. Wird sie also nicht ausführen und dann nur wieder irgend eine Fehlermeldung. Typischerweise sieht dann also Claude die Fehlermeldung, das Tool bla bla bla Ja. Existiert nicht und dann korrigiert er sich. Ja. Aber das ist so was, was man dann manchmal sieht, wenn wenn man so in 'nem Chat bisschen wilder hin und her die Sachen anklickt und abhakt. Mhm.

Speaker0: Jetzt hast Du vorhin 'n Thema erwähnt, Authentifizierung. Mhm. Das heißt jetzt mal angenommen, wir haben nicht nur die einfache Websearch, sondern ich aktivier den Connector zu meinem Outlook in Office 3 65. Mhm. Wer das mal ausprobiert hat, dem wird aufgefallen sein, da ploppt dann der Log in Screen von Microsoft auf und man gibt seine Zugangsdaten ein. Genau. Ja. Was passiert da genau? Weil die Frage, die sich ja dann stellt, ist, also Moment mal, ist das dann in meinem Namen, was ab da passiert? Also operiert der Chatbot dann da als Theo und als Maxim oder ist das dann Co Pilot und man erkennt es dann auch als solchen? Wie funktioniert da genau diese Authentifizierung? Ist das das Gleiche wie die Tokens oder ist das noch mal was Unterschiedliches?

Speaker1: Ja, am Ende des Tages ist es, find ich, sehr ähnlich wie die Tokens. Die Frage ist nur, wie kommt man zum Token? Mhm. Fangen wir jetzt erst mal mit dem mit dem Token Fall an, weil der ist einfacher zu verstehen. Was ist 'n Token? Token ist wie 'n Passwort. Man halt nicht irgendwie mein Passwort, hier 1, 2, 3 Passwort, sondern irgend eine zufällig generierte 64 Character oder oder irgendwas in der Länge Zeichenkette. Mhm. Die schick ich verschlüsselt mit mit meiner Anfrage an den Server. Und der Server sieht halt dann, ah, okay, da ist folgender Token drin und kann dann auch identifizieren, dieser Token hat Zugriff auf das, was er angefordert hat, ja oder nein und macht's halt oder verweigert es. Und wir haben ja vorhin gesagt, wenn das Modell jetzt nicht rein einfach codebasiert arbeiten soll, sondern mit Funktionen, Mhm. Dann hast Du zum Beispiel den Vorteil, dass dieses Einsetzen dieses Tokens in der Funktion versteckt sein kann, sodass das Model niemals den Token sieht, sondern das sieht halt nur sende E-Mail, ja. Sende E-Mail und schreib da den E-Mail-Text, aber was es halt nicht sieht, ist, dass da quasi die Funktion im Prinzip dein E-Mail-passwort, wenn wir's jetzt mal salopp formulieren wollen, reinpatcht. Mhm. Nirgendwo wird's dann weiter gespeichert und dein Bot hat's nie gesehen. Ja. Und dann hängt das jetzt davon ab, was ist 'n das fürn Token? War das 1, den Du als quasi, das hängt jetzt zum Beispiel von dem von den von dem Programm, was Du mit dem Du jetzt interagierst, deinem E-Mail-Post was und so weiter. Und es kann sein, dass es ein Token ist, also quasi mit dem signalisiert wird, das war jetzt Theo Steininger selbst. Oder was es häufig auch gibt, sind so irgendwelche Servicetokens, wo dann heißt, nein, das war nicht Theo Steininger, sondern das war eine extra erzeugte Rolle, die mit dem Namen, keine Ahnung, Theos KI Assistent hinterlegt wurde. Ja, aber das ist dann wie eine Buchhaltung, welcher Token gehört wozu? Und ähnlich ist das dann bei 'nem Outlook. Das heißt, wenn Du, also dann dieses O-Auf-Prinzip, wo noch mal 'n bissel Pingpong hin- und hergemacht wird, bis der Token steht, aber am Ende des Tages ist das Gleiche. Das heißt, dein dein Bot will eine E-Mail versenden, die in in Halerium würd dann dann die sagen, ah okay, das ist jetzt hier eine, die braucht eine o auf. Ich mach jetzt mal das Pop-up. Du authentifizierst dich als Theo Steininger. Dann kriegt der Bot einen Token, also nicht der Bot selbst, sondern die Funktion kriegt, denn der Bot sieht den Token nie. Und dieser Token ist halt aber 'n son Wegwerf Token aufgrund dieses ORFs. Der wurde sie durch deinen Zustimmendklick oder deinen deinen deine Passworteingabe einmal erzeugt und ist morgen nicht mehr gültig. Aber das ist dann zum Beispiel immer noch ein Personal Token, wo dann quasi bis auf vielleicht in ganz tiefen Logs bei Microsoft nicht hinterlegt ist, war diese Ausführung Theo Steininger persönlich oder wär anders? Also der Token trägt deine Rolle.

Speaker0: Ist ja auch E-Mail-Klient am Handy, wird sich ja auch mit dem Backend verbinden über den Workflow.

Speaker1: Ja, genau, genau. Ob jetzt ich auf senden drück oder Genau, also Du Du drückst ja nie selber auf auf, Du Du Du rennst ja nie zum Server von Microsoft und drückst auf senden, sondern ist ja immer irgendwie dein Handy, dein Computer, dein dein Outlook Programm, immer 'n Programm dazwischen. So ist es ja auch für, beim LLM ist auch 'n Programm dazwischen, korrekt. Also es ist immer irgendwo 'n Token dazwischen. Und dann ist halt nur die Frage, ist dieser Token 1, der so aussieht wie Du, also unter unterscheidbar von, wenn's deinen Outlook gemacht hat oder dein deinen Outlook am Handy oder so was. Oder ist es eben ein Token, der in soner Servicerolle erzeugt wurde, womit dann halt damit immer nachvollziehbar ist, das war jetzt nicht Theo persönlich, sondern das war Theos KI Assistent. Mhm. Aber das sind dann quasi nur Fragen, wie diese Tokens erzeugt wurden und und und welche Rolle die dann haben, wenn das also wenn der Server sie dann interpretiert.

Speaker0: Find ich's extrem wichtiges Thema, vor allem, weil ich's viel zu häufig seh, dass die Leute beim ersten Prototypen mit einem viel zu mächtigen Servicethoken starten. Mhm. Ne, der alles dann erlaubt. Und das ist jetzt schon mehr als einmal vorgekommen, dass dann die Leute dann 'n Chatbot zum Beispiel ausrollen ans ans Team. Mhm. Nehmen wir mal den ganzen einfachen Wiki Chatbot und der Chatbot hat dann auf einmal Leserichte

Speaker1: auf Bereiche, auf die der Nutzer gar nicht zugreifen dürfte, ja. Und das, also das Genau, das wär vielleicht auch noch mal was Gutes zu zu erwähnen, weil Du gesagt, weil Du grad was Wichtiges gesagt hast. Die Servicetokins sind häufig, also bei dieser Outlook Welt zumindest, mächtiger als son persönlicher Token. Mhm. Weil sie dann ja, also man kann da alles mögliche konfigurieren, ja. Aber typischerweise, man fängt da irgendwie so an und der kann dann erst mal einfach alles. Ganz zum Beispiel von jedem in der Firma die E-Mails lesen oder so was. Ja. Ja. Oder versenden in dessen Namen. Ja, genau. Nur irgendwo in den Log steht dann das Warnservice darüber. Ja. Viel Spaß, das auszugraben. Und da sind die persönlichen Tokens quasi sicherer und das ist grad bei diesen Microsoft Konnektoren dann eine typischerweise sone Kombination aus, hey, dieser Token agiert als Theo Steininger, darf aber nur folgende Sachen machen. Darf zum Beispiel nur E-Mail senden, E-Mail lesen, darf aber nicht Kalendereinträge löschen oder solche Sachen, ne. Also das heißt, da ist so diese Kombination aus, das ist auch son wichtiges Prinzip, wenn diese Tokens, das Du hast vorhin mal, glaub ich, Tokens gesagt. Mhm. Wenn diese Tokens für grad eine Applikation oder eben noch wichtiger bei einem Large Language Modell erzeugt werden, dass die einen haben. Was heißt, ist quasi ein 1, muss sagen, ein Umfang. Ja. Im Sinne von, hey, dieser Token agiert als der und der User, kann aber nur folgende 3 Funktionen. Und damit hast Du dann eine ziemlich hohe Sicherheit, 'n ziemlich gutes Korsett und hast nicht diese Touringvollständigkeit, dass das LLM alles machen kann und Du hoffst, es benimmt sich.

Speaker0: Ja. Und letztlich, also das wär eine Folge für sich, aber geht es ja durchaus runter bis zur Datenbankebene. Ja. Wo ich ja im Idealfall auf wirklich Datenpunktebene hinterlege, wer hat da welche Zugriffsrechte und und und wo werden die vielleicht auch her geerbt. Und Mhm. Das ist da bissel auch der diametral diametral Gegenentwurf zu, wir haben hier eine App, die läuft auf 'nem Computer, da ist die installiert. Und wir geben nur den Leuten den Schlüssel zu diesem Raum, die mit der App arbeiten dürfen. Also so ne, dieses Generalschlüsselprinzip versus in der Datenbank steht drin, auf diesen Kunden hat nur der Herr Müller Zugriff, ja. Und wenn dann der Herr Müller mit 'nem Chatbot arbeitet, der Chatbot muss sich seine Zugriffsrechte über den Herrn Müller besorgen, dann kann's auch nicht aus Versehen passieren, dass der Herr Müller aus Versehen den Chatbot in die Finger bekommt, der mehr darf als Herr Müller. Richtig. Also das ist so das das das umgedrehte Prinzip, dass Du die Zugriffsrechte auf Personenebene definierst. Und dann dann werden die delegiert und nicht andersrum, ne. Über implizite Berechtigungen mit wer hat jetzt Zugriff auf den und den Chatbot. Und da seh ich aber noch 'n weiten Weg. Die wenigsten unserer Zuhörer werden wahrscheinlich eine Firma haben, bei der alles sauber über diese Ebene Nein. Abgefrühstückt ist. Da ist einfach noch viel zu viel Legacy Code drin.

Speaker1: Aber all dieses Handling von quasi so, sag ich mal, spezifischen und vergänglichen Schlüsseln sozusagen und so. Das ist wie quasi, Du kriegst jetzt 'n Schlüssel zu dem Raum, aber in dem Raum ist wiederum eine, sind wiederum 10 Kabinen und Du kriegst nur den Schlüssel zur Kabine 3. Son bisschen kann man sich das vorstellen. Und der Schlüssel löst sich bis heute Abend 18 Uhr selber auf, ja. So son bisschen sind diese Tokens. Und das Ganze erzeugen und so weiter, Handling davon, das das überlässt man nicht dem Large Language Modell, sondern das macht die Computerinfrastruktur drum rum, sodass damit das Large Language Modell nie in Versuchung kommt, da was anderes machen zu können. Weil sonst bist Du halt dem ausgeliefert, dass es sich benimmt. Und das ist keine gute Idee.

Speaker0: Jetzt hast Du grad den Punkt erwähnt, der die perfekte Brücke zu meiner letzten Frage bringt, nämlich Computersystem außen drumrum, Infrastruktur außen drumrum. Kannst Du uns das noch mal zerlegen, so was wie 'n Langzeitgedächtnis, ja? Also das ist ja mittlerweile auch, Gott sei Dank, 'n Standardfeature bei den meisten Anbietern, dass der Chatbot von 1 Session zur nächsten sich merken kann. Mhm. Idealfall kann man's deaktivieren. Was wurde in den vorherigen Sessions gesprochen? Ja. Oder so was wie, erledige die und jene Aufgabe jeden Freitag 8 Uhr morgens, ja. Was mein ich mit Aufgabe? Das Abfeiern von 'ner bestimmten Prompt, sodass der Agent dann eine 1 Aufgabe durchführt. Kannst Du uns das noch mal auseinandernehmen? Wir haben jetzt viel über Token und Zugriffsrechte und Schnittstellen gesprochen. Ja. Was ist für das nötig, dass es dann auch wirklich ins ins kommt, das ganze System? Also was meinst Du mit Laufzeitumgebung, mit mit mit Server außen drumrum?

Speaker1: Na ja, es es es braucht jede Menge Computerprogramm oder Programme drum rum, solche Sachen, wie ich sie grad geschildert hab, ja auch zuverlässig zu managen. Also bleiben wir bei diesem Thema Memories, also des, also dann ganz kurz noch mal, wie entsteht, was ist 'n Chat? 'N Chat ist ein Chatverlauf plus eine aktuelle Prompt wird dann das Large Language Modell geschickt und Du kriegst eine Antwort. Wenn Du dich nicht darum kümmerst, also das macht dein Computer für dich, aber wenn wenn dein Computer sich nicht darum kümmert, die Antworten und deine, also das das Pingpong zwischen Frage Antwort mit dir und dem Chatbot zu speichern und mitzusenden bei der nächsten an vor Anfrage, dann dann ist wird deine Konversation ziemlich schnell inkohärent werden. Mhm. Ja. Dann hättest Du nach, dann stellst Du dich halt in der ersten Nachricht einmal vor, sagst hallo, ich bin Maxim. Und dann fragst Du in der dritten Nachricht, wie heiß ich? Und dann sagt es, ja, Du hast mir noch nie verraten, wie Du heißt. Also das passiert nicht, weil alle Chatbotapplikationen immer diese, also den den Gesprächsfaden mitschicken. So. Aber wenn ich jetzt eine neue Session mache, da dann ist es bei Design ja erst mal leer. So. Wie wie kann jetzt dazwischen eine Brücke entstehen? Es muss ja dafür was mitgeschickt werden oder eine Funktion dem Large Language Modell zur Verfügung gestellt werden, diesen Kontext abzurufen. Und dann sind wir wieder genau bei dem, was wir am Anfang geschrieben beschrieben haben. Und das muss, da muss sich dann die Infrastruktur drum rum kümmern. Das heißt, beispielsweise könnte es sein, dass das System diesen Chat drum rum programmatisch, also nicht durchs LLM getriggert, so was auslöst wie jeder Chatverlauf wird nach, keine Ahnung, 30 Minuten der Inaktivität zusammengefasst. Das heißt, der Chatverlauf wird zusammen über wieder an ein LLM geschickt mit, fasse wir das in 3 Absätzen zusammen. Und dann hörst Du quasi Zusammenfassung deines Chats. Und die könnten wiederum alle dann, das wär jetzt bisschen extrem, so passiert das dann nicht, aber mal 'n Beispiel, bei jeder Anfrage, die Du schickst, könnte dann quasi deine aktuelle Konversation plus die Zusammenfassung aller Chats der letzten Woche, die Du Theo Steininger mit dem Hach Language Modell hattest, geschickt werden. Aber nicht die, die ich, Maxim Greiner, geschickt hatte, ja? Also das dann das ist wieder die Infrastruktur drum rum, also die Programme drum rum, die sich dann kümmern. Ich rufe jetzt, weil Theo chattet, nur die History von Theo ab und nur die Zusammenfassung davon und schicke die dann halt mit. Oder umgekehrt, man sagt, dass man schickt dem LLM eine Funktion mit, wo er sagt, hey, mit dieser Funktion kannst Du in der History der bisherigen Chatverläufe mit Theo suchen, aber nicht in den mit Maxim, weil Du gar nicht mit Maxim jattest. Das ist dann das, was die Infrastruktur drum rum macht, die die Programme drum rum. Das heißt, 'n large Language Modell alleine ist eigentlich ohne die Programme drumrum, die das alles managen,

Speaker0: nicht viel wert. Mhm. Find das ja krass. Das hat erstaunlich lange gedauert, bis die Modellanbieter oder die die Chatbotanbieter, muss man ganz genau unterscheiden, das auch ermöglicht haben, dass die Chatbots weiter antworten können, wenn man das Browserfenster schließt. Ja. Also ich weiß nicht, ob das den den meisten unserer Zuhörer so bewusst ist, aber das ist relativ neu. Und sone Firma wie Manus hatte das als die. US p, ja. Ja, den US p, hey, bei uns laufen die Chats weiter, auch wenn Du das Browserfenster schließt. Ja, okay. Die auch mal mit werben sollen, haben wir ja von Anfang an gehabt. Ja, aber der der Computeraufwand im Hintergrund ist natürlich beachtlich, weil der Unterschied ist schon da, ne, ob ich jetzt quasi leichtgewichtig ins Feld geh, so wie's ChatGPT und OpenAI gemacht haben. Der Browser schickt die nächste Antwort oder die nächste die nächste prompt quasi unmittelbar an das Model und kümmert sich so alle paar Zyklen drum, dass der der Chatverlauf dann langfristig gespeichert wird Ja. Versus mein Browser kommuniziert eigentlich noch mal mit 'nem Server dazwischen, der diese Session managt, offen hält und so weiter verwaltet, das 'n deutlichen Overhead erzeugt eben zu dieser reichgewichtigen Variante im Vergleich. Ja. Und das, was Du beschreibst, das sind ja Datenbanken, die da laufen müssen. Korrekt. Es sind virtuelle Maschinen, auf denen ausgeführt wird, Mhm. Die vielleicht sogar eben sonen virtuellen Browser auch offenhalten, ne. Ja. Ja, auf den wir vorhin so geschimpft haben. Es sind Schnittstellendhematiken, es sind Server, bei denen nur permanent eine Uhr abläuft,

Speaker1: diese wiederkehrenden Jobs zu managen. Also es ist schon schon einiges mehr mittlerweile. Genau, also beispielsweise das zusammenfassen wär auch son Klassiker für, ne, das ist halt 'n wiederkehrender Job, der ausgelöst wird von wiederum einem Computerprogramm.

Speaker2: Mhm, mhm,

Speaker0: mhm. Maxim, nächste Folge gehen wir eine Flughöhe höher, nachdem wir jetzt halt heute noch mal im Maschinenraum die Ja, heut waren wir 'n bisschen im Rabbitol, ne. USB-C-Stecker der LLMs auseinandergenommen haben. Ja, aber ich hab schon 'n bissel das Gefühl, das MCP ist so bissel USB-C-Schnittstelle

Speaker1: ist nur definiert. Man kann alles zusammenstecken. Ob's dann funktioniert, weiß ich nicht. Ja, genau, das ist, ich wollt sagen, das ist bei USB-C ja berüchtigt. Ah ja, genau. Dieser MCP Server lädt nur. Ja, ja, ja. Man transportiert keine Daten. Ja, genau, ganz Nee, aber natürlich, es ist zwar irgendwo 'n Standard, aber Du kannst den MCP Server so verunzen, wie Du willst. Hier nimmt dich keiner drin. Ja.

Speaker0: Ich Ich wollt verhunzen. Ich freu mich auf die nächste Folge. Mach's gut, hau rein. Mach's gut.

More episodes from season 8 →