Um komplexe Probleme mit künstlicher Intelligenz zu
lösen, sind der neueste Schrei im Moment AI Agents.
Dabei werden viele kleine, hochspezialisierte AIS gebaut,
die dann untereinander chatten, um Probleme zu lösen und dabei
sogar Code aufrufen oder auch selber schreiben können.
Wie das funktioniert und wie man solche Agents baut, darum geht
es in dieser Folge. Und damit herzlich willkommen zu
Folge 92 des to do Developer Podcast mit Robin Manuel Thiel
und mir malte lantin ich freue mich, dass wir wieder zum Thema
künstliche Intelligenz zusammenkommen.
Wir haben es in den letzten Folgen immer wieder gehabt, aber
man kommt aktuell kaum drum herum und ich meine das Thema
Agents hatten wir ja schon hier und dort erwähnt, von daher
freue ich mich darauf, dass wir es heute mal ein bisschen im
Detail. Diskutieren können.
Aber bevor wir ins Thema einsteigen, natürlich erst mal
hier unsere Hausnotizen. Zu Beginn der Folge, und da
wollen wir uns natürlich es nicht nehmen lassen, uns zu
bedanken für diejenigen, die uns einen Kaffee ausgegeben haben,
und das sind heute Hendrik mit einem Kaffee und Norman mit 3
Kaffee. Vielen.
Auch von meiner Seite. Wir freuen uns immer sehr, in
der letzten Folge ging es um offline first.
Das hat euch gut gefallen. Ich war auch ein bisschen
unterwegs letzte Woche. Ich war in der Schweiz und
demnach muss man da immer 2 Kaffee zusammenrechnen um sich
einen echten Kaffee in der Schweiz leisten zu können.
Ich hab sie dann aber trotzdem genutzt, also ganz lieben dank,
ich hab an euch gedacht, als ich im café saß, haben wir uns sehr
gefreut, Dankeschön. Ja, und gerade in dieser Woche
hab ich mir dann auch das erste Mal in diesem Jahr einen eiscafé
dann gegönnt und von daher vielen Dank auch von meiner
Seite. Dafür hilft uns auf jeden Fall
die Motivation ganz hochzuhalten, diesen Bereich
Höhen Kopf zu bewahren und jede zweite Woche eine neue Folge des
Podcasts zu produzieren. Und ja, die Themen gehen uns
nicht aus und Ai lässt uns nicht los und dementsprechend heute
das Thema. Agents und da ist du Robin,
Manu, dich ein bisschen intensiver mit beschäftigt, von
daher bin ich froh heute von dir was lernen zu können, aber
vielleicht zum Einstieg in das Thema einfach mal so mein
Verständnis warum man das Ganze braucht und korrigiere mich
gerne und dann führen wir das Ganze zusammen und zwar gibt es
ja schon viele KI basierte Chatsysteme, wir kennen alle
Chat GPS, wir kennen spezialisierte Systeme für zum
Beispiel du hattest gerade erwähnt die Software Entwicklung
dort wahrscheinlich das Problem. Beispiel github copilot wo wir
ein Chat Interface haben, wo wir mit einer KI interagieren und
diese KI basiert in der Regel auf Large Language Models, die
eigentlich General Purpose Modelle sind, die auf extrem
viel Sprachen trainiert wurden, natürlicher Sprache,
Programmiersprache und damit ganz viele Aufgaben sehr gut
erledigen können. Die Modelle werden natürlich
immer besser, wir haben ja vor kurzem das Release zum Beispiel
von Gptv gesehen, welches? Welches in einer sehr hohen
Geschwindigkeit viele Aufgaben sehr gut erledigen kann.
Aber natürlich stößt das Ganze teilweise an Grenzen, wenn es um
Spezialwissen geht, wenn es um bestimmte Aufgaben geht, wo man
vielleicht erstmal in Echtzeit wissen abrufen muss.
In manchen Bereichen geht das mittlerweile.
Wenn man jetzt Chat GPT hat, kann Chat GPT ja zum Beispiel
schon aufs Internet zugreifen, dort Informationen abrufen, aber
es gibt natürlich viele Szenarien, gerade im
Unternehmenskontext, oder? Wenn es um spezielle Szenarien
wie die Softwareentwicklung geht, wo ich vielleicht aus
dritt systeminformationen brauche, von denen das Modell
nichts weiß und wo ich letzten Endes viele verschiedene
Informationen zusammenbringen muss, um eine gute Antwort zu
kriegen. Und zum anderen habe ich die
Herausforderung, dass ich häufig immer komplexer werdende
Szenarien habe, wo ich die Herausforderung habe, dass
vielleicht meine Prompts immer länger werden und auch da das
Modell an die Grenzen gerät. Wirklich eine gute Antwort zu
liefern, insbesondere weil diese Antworten ja immer länger
werden. Wir haben halt einen immer
größeren. Kontext zur Verfügung.
Das heißt, wir können immer mehr Reingeben und auch die Antwort
wird immer größer, aber an bestimmten Stellen gerät man
dann natürlich an die Grenzen, wenn es darum geht,
Informationen hereinzuliefern und daher brauchen wir
spezielle. Plugins oder Agents?
Die es uns ermöglichen, diese spezialisierten Informationen
reinzuholen und auch aus verschiedenen Quellen aus zu
verschiedenen Themen Informationen zusammenzustellen,
wie die dann wiederum am Ende als Gesamtantwort zu mir
zurückkommen, das ist mein Verständnis der Herausforderung
und warum man diese Systeme braucht.
Ist das aus deinem aus deiner Sicht so weit korrekt oder
würdest du es bisschen anders einordnen oder fehlen da noch
Aspekte? Nee, das gehört schon alles in
in diese Welt der Ages. Zu was du gesagt hast, ne, also
klar, dass man auch über externe Daten in so n Modell reinbringen
muss, da haben wir auch schon mal in Folge 80 als er zu Rack,
also Retrieval Augmented Generation gesprochen haben.
Ne ganze Folge zugemacht. Also es gibt immer wieder so
Techniken und Tools, wie man auch mehr wissen in solche Large
Language Models hereinbringt. Aber Agents würde ich gar nicht
sagen, das sind diese ganzen Tools, sondern Agents nutzen
eher diese ganzen Tools und Mechanismen.
Um dann autonom, und das ist ganz, ganz wichtig, Aufgaben zu
lösen. Also ich definier mir ja agents
immer so n bisschen so, das sind quasi so Software Bausteine, die
autonom mit Hilfe von Large Language Models wie zum Beispiel
GPT 4. Aufgaben erledigen also anders
als traditionelle Software, die immer einem bestimmten Ablauf
folgt, den, den die Software Entwicklerin, der
Softwareentwickler ja dann irgendwie gebaut hat, lösen
Agents eben autonome Workflows. Also das läuft so n bisschen so,
dass ich quasi für so einen Gruppenchat mehr oder weniger so
die definiere, was für AI Gesprächspartner es gibt und
dann lasse ich aber auch in diesem Chat eine andere AI zum
Beispiel entscheiden, welcher Gesprächspartner denn wann zu
Wort kommt und basierend auf ihrem Verständnis von der Welt
entscheiden diese Agents dann unter sich, wie sie Probleme
lösen und ich habe dann da eben in diesem Chat.
Da kann auch da können auch Menschen mitwirken, also human
in The Loop nennt man das. Das ist auf jeden Fall auch ein
Bestandteil davon, aber. In diesem Chat habe ich dann
eben ganz viele oder ganz viele, weiß ich gar nicht, aber mehrere
spezialisierte Chat Teilnehmer, also diese AI Agents eben, die
durch ihren ihren Meta prompt durch die Tools die
Wissensdatenbanken, die Sie zur Verfügung haben durch das Modell
was sie benutzen. Für eine ganz bestimmte Aufgabe
eben Hochspezialisiert sind. Und meine Software, die letzten
Endes dazwischen steht, die weiß basierend vielleicht auf
irgendwelchen Keywords oder triggern, welcher Agent an
welcher Stelle zum Tragen kommt oder entscheidet das das Large
Language Model, also wie hieß der Datenfluss, weil im
einfachsten Fall, wenn ich mit so etwas wie Chpt oder Copilot
rede, dann geht ja mein Input an das Large changles Model und da
kommt eine Antwort zurück, also. Das ist ja ein relativ einfacher
Mechanismus. An welcher Stelle klingt denn
dann mit welcher Logik die Agents ein und soweit ich das
gesehen habe, gibt es da ja auch dann 2 Varianten, einmal die
Variante wo das völlig im Hintergrund passiert, das heißt
ich kriege da als User vielleicht gar nichts von mit,
sondern ich habe quasi nur einen Gesprächspartner und die
Variante, wo ich tatsächlich entweder einfach markiert habe,
wo kommt diese Antwort her, quasi dort hat sich jetzt quasi
ein Spezialistin Spezialist eingeklinkt oder ich bekomme die
Antwort zurück und sagt Hey, die Informationen stammt da und da.
Wo klinken sich diese Agents in diese ganze Kommunikation ein?
Ja, da gibt es mehrere. Also das entscheidet am am Ende
der Developer ne. Also da gibt es mehrere
Herangehensweisen. Ich kann entweder sagen, das
folgt einem ganz festen Flow. Oder die Variante, die du gerade
gesagt hast. Ich lasse den den menschlichen
User entscheiden, wann welcher Agent hinzugezogen werden soll.
Oder ich lasse komplett noch mal ne AI entscheiden, wann welcher
Agent hinzugezogen werden soll. Ich geb dir mal n Beispiel, wir
haben vor n paar folgen und ich mein ne niemand kennt es besser
als du malte ich hab du bist einer der wenigen Menschen ich
kenn die schon Zugriff darauf haben wir haben vor n paar
folgen über github Copilot Workspace gesprochen, ganz kurz
als Reminder gerne die ganze Folge nochmal anhören aber ganz
kurz als Reminder man stellt einen Issue ein bei github und
dann folgt dann wird ein bestimmter Workflow getriggert
der dieses dann automatisiert lösen soll da geht der erste
Agent hin und sagt Pass auf ich erstelle.
Dir jetzt mal ein Verständnis davon im ist Zustand, denn dein
Projekt hat und dem soll Zustand denn dein Projekt erreichen
soll. Das macht ein Agent, das heißt
da ist irgendein Large Language Model zusammen mit einem prompt
zusammen mit Zugriff auf dein Reporsutorial.
Was genau für diese Aufgabe getrimmt wurde und da wirst du
als Mensch ja gefragt, ob du da Feedback zu hast oder ob das so
passt. Und dann ergibst du, dann gibst
du das quasi weiter an den zweiten Agent, der dann diesen
Plan erstellt und. Und dieser Plan sagt dann
wirklich OK, um dann diesen Sollzustand zu erreichen,
müssten wir folgende Codedateien anfassen und in denen Logik
hinzufügen oder löschen, die ich jetzt mal wie folgt beschreibe
und auch dann wirst du als als Human in The Loop wieder
gefragt. Passt das so?
Und dann wird das in den dritten Agent übergeben, der
Hochspezialisiert darauf ist, Code zu schreiben.
Und vielleicht nutzt er ja n ganz anderes Modell ne,
vielleicht nutzt er ja wie Codex im Hintergrund und die anderen
nutzen GPT 4 oder vielleicht hat man die Erfahrung gemacht, dass
dieser ist Zustand mit Lama wahnsinnig gut abzubilden.
Es ist ist um mit ner bestimmten Promptanweisung und und und so
weiter. Das heißt, bei Gitter Copilen
Workspace oder auch bei Devil AI folgt das ja einem ganz klaren
Ablauf. Jetzt gibt es aber auch Gitarre,
copalle, Chat ja zum Beispiel, wo ich einfach in der IDI mit
meinem Code chatten kann und dann könnte ich ja sagen, hey,
ich müsste jetzt, ich brauch jetzt keine Ahnung.
Was wäre denn der beste Ort, um diese Datenstruktur zu
speichern? Und dann sagt die Guitar Copilot
ja, das wäre am besten in der Post resk Datenbank und dann
könntest du dir den den Agent von Deinem Cloud Provider, also
wie Abs oder sowas mit Dazuziehen und dann sagen sagst
du einfach in deinem Chat at aws hey kannst du mir so eine
Postkreisdatenbank dann mal deployen und diese AWS Agent ist
dann halt der kennt dann halt deine deinen Cloud Zugang und
der weiß dann der ist dann halt hoch drauf spezialisiert solche
Deployments in die Cloud zu machen, das heißt da sagst da
fügst du als Mensch hinzu wann welcher Agent gecallt werden
soll. Es gibt doch noch eine dritte
Variante wenn ich jetzt sage keine Ahnung ich.
Möchte. Ich habe jetzt einen Kalender
planner geschrieben und ich möchte zwischen deinem und
meinem Kalender. Irgendwie nen nen Termin finden
der beiden passt. Dann geb ich das in in so n Chat
rein und da ist vielleicht eine Agent drin der der der der
Zugriff auf auf auf Kalender hat und sich die Kalendertermine
Fedgt das ist n zweiter Agent drin der der diese diese diese
Vergleiche hat, da ist n dritter A.
Agent drin, der vielleicht checken kann, dass es keine gute
Idee ist, dass wir um 23:00 Uhr irgendwie n Call haben, es sei
denn, wir müssen, wir müssen die letzte Folge kurz vor knapp dem
Podcast aufnehmen, aber ne, du verstehst glaub ich was ich
meine. Also es gibt alle 3 Varianten wo
das nen festen Workflow folgt wo ich als user entscheide wann ich
da vielleicht welchen Agent hinzufüge oder wo ne AI
entscheidet unter dem Wissen welche Agents es denn so gibt,
wann was oder wann wann welcher Agent mit in diese Konversation
reingebracht werden soll und der liest dann und die lesen dann
natürlich auch die bestehende Chat Historie mit.
Ja, aus dieser dritten Variante. 2 Beispiele, so aus meinem
Alltag. Zum einen, wenn ich irgendwie in
Chat GP t eine URL hinterlasse, dann erkennt das System, dass es
einen Abruf dieser Seite machen muss, um dort Informationen
einzusammeln oder auch wenn ich mit github Copilot Interagiere
auf github.com auf der Webseite und dann nach einem issue Inhalt
frage, dann wird unter der Haube ein spezieller Agent verwendet
um halt über die Github API die Informationen zu zielen.
Was halt in den entsprechenden Issues drin steht und für mich
als User ist das nur ein Interface, mit dem ich dort
agiere. Also das ist ja auch im
Hintergrund, dass dort verschiedene Agents zum Einsatz
kommen, aber wie du gesagt hattest, basierend auf.
Irgendeine Art von Entscheidungsimplementierung?
Das kann ja einfach irgendwie ne ganz einfache Erkennung von
Keywords sein. Es kann aber auch wieder n
anderes Sprachmodell sein, was basierend auf bestimmte
bestimmte Informationen eine Klassifizierung vornimmt.
Genau. Und es muss auch kein Agent
sein, der da aufgerufen wird. Wenn du in chatsybutton url
eingibst. Vielleicht kann Jgpt das Modell
oder die Anwendung einfach die Fähigkeiten URL aufzurufen und
den Content dann sich reinzuziehen, aber es kann sein,
dass es unter der Haube auch noch andere Agent weitergeben
wird, das heißt, das wird ja dann mir als Developer meiner
Anwendung überlassen, ob ich diese.
Diese verschiedenen Agency unter sich dann eine Problemlösung
ausmachen, ob ich das an den User hoch Bubble lasse und dem
das überhaupt visualisiere oder ob ich vielleicht am Ende, wenn
da 34 Agents irgendwie eine coole Lösung gebaut haben, ob
ich dann einfach eine Summary von diesem ganzen Chat Historie
generiere und das an den User Weiterleite, das bleibt mir
überlassen. Aber erstmal ist diese Technik
verschiedene kleine AI Bausteine zu haben die Hochspezialisiert
sind und die miteinander reden zu lassen, das sind Agents und
warum macht man das? Weil man einfach gemerkt hat,
dass das bessere Ergebnisse bringt.
Also wenn man, wenn ich jetzt das Beispiel Podcaster hinnehme,
wir hören ja gerade diesen Podcast und jetzt könnt ich
jetzt zum Beispiel die eine neue Folge von diesem Podcast hier
komplett von einer AI skrippen lassen.
Das heißt ich würde dann nen nen langen prompt schreiben wo ich
beschreibe wer ist der malte, was kann der alles, was weiß der
alles und wie ist so seine Persönlichkeit, wer ist der
Robin Manuel, was kann der alles, was weiß der alles, wie
ist seine Persönlichkeit, worum geht es im Podcast allgemein,
worum soll es in dieser Folge gehen, wie lang soll die Folge
sein, was gibt es denn für Audioeinspielungen, wie viele
Sprecherwechsel, was hat was für Komponenten hat der Podcast und
so weiter das heißt sehr viele Informationen in einem großen
prompt, das würde gehen, aber das gibt am Ende schlechtere
Ergebnisse als. Wenn man den kleinen LMS ganz
klare Anweisungen gibt, das heißt, ich könnte zum Beispiel
folgende Agents erstellen, einmal den Agent malte mit einem
personifizierten prompt darüber, wie du bist, wie deine
Persönlichkeit bist, was du weißt, vielleicht auch mit ner
RAG Komponente für maltes wissen und vielleicht irgendwie sogar
kann ich Code generieren für die Programmiersprachen, die du
beherrschst. Dasselbe mache ich für mich,
dann könnte es doch ein Agent geben, der wäre so der
Audiomixer, das heißt, der erkennt, wenn vielleicht das
Intro eingespielt werden soll oder diese Yeah, die wir haben,
wenn uns jemand einen Kaffee ausgibt und der.
Bekommt dann Zugriff auf eine Audiolibrary und der kann dann
wirklich nur das. Das heißt der Scan.
War alles den Chat, der bisher passiert und sagt, Boah jetzt
bin glaub ich ich dran und spiel das das Intro ein und da gibt es
bestimmt noch nen vierten Agent so n bisschen diesen Orchestra
oder kann man im Podcast Umfeld auch wenn man den auch irgendwie
Moderator nennen der dann nach mehr oder weniger freiem Willen
diese Agency called und entscheidet wann ist denn der
Zeitpunkt wann ich weiß ich nicht sag ich mal den den
Redestab an Robin Manuel oder an den Malte übergebe oder?
Möchte ich hier nochmal weiter nachhaken und wenn und dem Malte
Agent vielleicht noch mal einen weiteren prompt geben, weil ich
das Gefühl habe, dass das Thema noch tiefer erläutert werden
soll und so weiter und diese 4 Agents, die würden sich wie in
so whatsapp Gruppen Chat dann im Prinzip eigentlich unterhalten
und was am Ende rauskommt die Chat Historie, das wäre dann
eigentlich dieses Podcast Skript, was man dann eventuell
sogar irgendeine AI geben kann, die das dann laut vorliest.
Wir haben ja schon mal gesagt, Ai wird vielleicht irgendwann
alle unsere Jobs ersetzen, wird also unsere podcaster Jobs
werden, wenn dann von diesen Agenturen.
Setzt aber wie gesagt, was Agent Frameworks eigentlich lösen,
sind es eben mit kleineren Proms und spezialisierteren Proms
bessere Ergebnisse zu liefern. Und vielleicht ist es ja
wirklich so, dass keine Ahnung maltes Persönlichkeit von einem
Lama Model viel besser abgebildet wird oder diese.
Audiomixer Agent der hat, der hinter dem steckt, vielleicht
gar kein Large Language Model, sondern der hat einfach nur die
Möglichkeit, wenn man dem sagt. Jo Jo, das war jetzt da das
Intro Spiel mal die Intromusik ein, dann hat der kann der
einfach auf auf irgend ne Audiolibry zugreifen oder
irgendwas. Das heißt, man kann eben auch
verschiedene Modelle kombinieren.
Vielleicht ist 1 ja gefinet und so weiter das heißt, man man
guckt wirklich, dass man Aufgaben bisschen kleiner macht
und dann ja diese Agents, wieso n kleine Mini Menschen oder
wirklich ne künstliche Intelligenzen?
Miteinander chatten lässt. Letzten Endes sind ja auch die
du gerade gesagt hast, die verschiedenen Charaktere, die
verschiedenen Fähigkeiten völlig unterschiedlich und wenn ich mir
das wirklich vorstelle, ich muss in einen System prompt alle
diese Informationen reinbringen, dann.
Schränkt das natürlich auch den den Raum sehr stark ein von dem,
was ich letzten Endes mit dieser Applikation tun.
Kann auch ja. Genau und ich.
Mir fällt es natürlich sehr schwer, angenommen, wir machen
jetzt wirklich diesen KI generierten Podcast wirklich dem
Sprachmodell die Informationen zu geben, die es braucht um
wirklich so zu sprechen, deine Wortwahl zu übernehmen etc.
Das ist ja wirklich spezialisiert und natürlich kann
man jetzt hingehen und schauen okay ist das jetzt auch
vielleicht schon Teil des Trainingsets gewesen oder hat
man ein speziell trainiertes Modell oder gibt man diese
Information? Über den System prompt irgendwie
rein und da brauche ich natürlich relativ viel Input,
damit das Sprachmodell dann am Ende genauso spricht, wie du es
tun würdest. Wir haben das ja mal
spaßeshalber für so eine Podcast Folge in Chat GPT ausprobiert
und da sieht man dann auch am Ende, dass vielleicht wir beide
eigentlich genau gleich oder sehr ähnlich sprechen oder
zumindest nicht so, wo wir, wie wir es in der Realität tun
würden. Und wenn wir jetzt alle diese
Informationen schon am Anfang auf einmal reingeben muss, wird
das von der Qualität offensichtlich schlecht.
Einfach ähnlicher ne, weil ich in denselben prompt sowohl deine
als auch meine charakterlichen Eigenschaften reinfüge.
Und ne, wenn man so n bisschen versteht, wieso n Large Angry
funktioniert, dann wird eben alles was in dem prompt ist dazu
genommen, um die Wahrscheinlichkeit des nächsten
Tokens der ausgespuckt wird zu berechnen.
Und ne wenn ich da 3 verschiedene Persönlichkeiten
reinfüge, dann werden die halt schon auch alle sich angeschaut
um diesen ersten Token zu rechnen, das heißt es hat schon
auch einen Einfluss, auch wenn ich natürlich sagen kann, immer
abwechselnd Persönlichkeit a Persönlichkeit b, aber man hat
einfach bessere Ergebnisse gesehen, wenn man das eben diese
2 komplett individuellen Prompts aufteilt und das vielleicht wie
gesagt auch sogar noch von anderen Modellen.
Lässt aber diese Agents haben eben nicht nur andere Modelle,
sondern vielleicht einfach auch Zugriff auf andere
Wissensdatenbanken. Auf andere Tools, können Code
ausführen oder vielleicht generieren und solche Sachen.
Ich glaube, das ist insoweit alles nachvollziehbar, wenn es
um die einzelnen Agents geht. Aber die große Herausforderung,
glaube ich, liegt dann am Ende in dieser Orchestrierung.
Wie führe ich das Ganze zusammen und wie Sorge ich dafür, dass
bei einem bestimmten Input ein bestimmter Plan ausgeführt wird.
Planen muss man sich jetzt nicht unbedingt.
Vorstellen, wie es bei bei Devon oder bei bei Workspace ist,
sondern tatsächlich ein Plan im Sinne von wenn ich jetzt Input
gebe, welche Agents werden wann aufgerufen und wenn wir jetzt
noch mal an uns, an das Podcast Beispiel zurückerinnern, du hast
ja auch über diesen Orchestra gesprochen, also wie ruft der
Orchestra dann die einzelnen Chat Teilnehmer auf um dann halt
wirklich so ein Skript zu erstellen und ich denke mal da
liegt in der Implementierung eigentlich die größte
Herausforderung nicht. In diesen spezialisierten Agent,
die ja sehr kleinteilig sein können, sondern wie kriege ich
das Ganze so zusammen gebunden, dass am Ende eine nahtlose User
Experience daraus entsteht. Ja, im Idealfall wissen diese
Agents ja gar nicht, dass es noch ganz viele andere gibt,
sondern vielleicht werden die auch irgendwie so Microservices
von verschiedenen Teams gebaut und für diese Orchestrierung, da
kommen dann halt so Agent Frameworks ins Spiel.
Also ich habe mir jetzt in Vorbereitung zu dieser Folge
Auto gen angeguckt, das ist ein Python Framework, es gibt aber
ganz viele, also ich habe gesehen, also gerade poppen so
Agentur Agent Framework. Aus dem Boden wie javascript
Frameworks. Also es gibt autodef, meta, GPT.
Langchain hat ne Möglichkeit Agents zu bauen.
Open AI hat mit der Assistance API was was eigenes gebaut, aber
wie das eigentlich, wie alt diese Frameworks unter der Haube
funktionieren ist die bieten wir dann eben halt an sowas wie
einen Agent zu definieren, aber auch was wie ein Orchestrator zu
definieren und eben mal zu sagen wie der wie der Gesprächs wieder
wie der Redestab übergeben werden soll und wie das aber
eigentlich technisch funktioniert ist, dass ich
zusammen mit zusammen mit dem Agent den, den ich als Developer
irgendwie bauen muss, auch eine Beschreibung.
Diesen Agent generiere also was kann der, was ist der, wann soll
der zu Wort kommen, was sind die Fähigkeiten die er besitzt usw.
Und dann gebe ich, das ist einer der vielen, vielen Prompts, die
in so einer Agent Konversation am Ende gegen einen Large
Language Model geschickt werden, gebe ich quasi nach jeder
Antwort von jedem Agent wieder in ein neues Large Language
Model und das ist 1 was relativ. Performant also, wer relativ
mächtig sein sein sollte, also GPT 4 oder sowas geb ich in das
Ding rein, pass auf das hier war die war die bisherige Chat
Historie, die geb ich in den Pomp mit rein an wen möchtest du
als nächstes? Die das Wort wenden.
Und dann gebe ich eine Liste in mit in den prompt 3 mit du hast
folgende Optionen, du könntest den Malte Agent Fragen, der weiß
das und das der der hat die und die Persönlichkeit, der kann auf
die und die Tools zugreifen, der hat das und das Wissen.
Du könntest einen Robin Manuel Agent übergeben, der weiß, dass
und das hat er kann auch die Tools zugreifen, das und das
Wissen. Du könntest an den Audiomixer
Agent übergeben oder du könntest sagen wir sind fertig und dann.
Wird das wird dieses Large Ding gefordert?
Wahrscheinlich einfach sagen, ich würde gerne an den Malte
übergeben und den Fragen, was was kommt denn als nächstes und
diese Frameworks, die gehen dann hin und nehmen diese Antwort und
senden dann was kommt denn als nächstes an den Agent malte, das
heißt die interpretieren dann die Antwort wieder, die von dem
Lutsch Language Model kommen, was in dem Fall die Entscheidung
getroffen hat, welcher Agent als nächstes kommt.
Diese Agent Frameworks haben aber natürlich auch die
Möglichkeit deshalb, dass sie sagen an der Stelle möchte ich
den den User befragen an wen weitergegeben werden soll oder?
An der Stelle möchte ich entscheiden, dass die
Unterhaltung vorbei ist, denn das ist ja auch auch eine
Challenge, auch eine Challenge, die diese Frameworks lösen.
Aber dieses Thema, wenn das in dieser Welt termination, also
wann ist denn die Unterhaltung vorbei, also wie erkenne ich
denn, dass das Problem gelöst wurde oder dass man vielleicht
nicht weiter kommt, und das muss ja auch irgendwie mit
implementiert sein, und das kann ich in diesen Framings dann halt
irgendwie direkt sagen, wenn wir uns in den Kreis sehen oder wenn
es ein Ping Pong Spiel dreimal zwischen den gleichen Agent gab
und das Large Language Model, wenn ich es befrage, nicht der
Meinung ist, dass das Problem schon gelöst wird oder dass die
Folge vorbei ist oder so weiter oder man sagt, ich möchte jetzt
doch human Human Feedback bekommen, man kann.
Diesen Agent Frameworks natürlich, aber auch sagen, dass
für diesen, für diesen Anwendungsfall man sich nie
human Feedback holen soll oder kann, weil es vielleicht gar
nicht möglich ist. Und so weiter.
Wir als Menschen haben ja n relativ guten Zwischenspeicher,
das heißt, ich kann mich eigentlich an alles erinnern,
was wir jetzt in den letzten 20 Minuten besprochen haben und
kann darauf zurückgreifen, um jetzt meine Antwort zu
formulieren. Wie mache ich das, wenn ich
solche Orchestrater habe, wo ich vielleicht n relativ großes
mächtiges Modell hab, wo ich viele Informationen reingeben
kann? Aber wie mache ich das jetzt mit
solchen kleinen spezialisierten Modellen, die müssten ja auch.
Den Kontext haben des gesamten Gesprächs.
Wenn ich jetzt um in unserem Podcast Beispiel zu bleiben, den
Robin Manuel Agent Frage, Was kommt als nächstes, muss ja an
der Stelle der komplette Kontext unseres Gespräches bisher zu
Verfügung stehen. Gibt es da bestimmte
Technologien, die man da einsetzen kann um halt das nicht
zu groß werden zu lassen, weil sonst kann ich mir vorstellen,
dass irgendwann so ein gewisser Gedächtnisverlust einsetzt, wenn
dann irgendwann das Gespräch. Oder es muss ja kein wirkliches
Gespräch sein, aber in Anführungsstrichen das Gespräch.
Wenn wir jetzt hier bei dart Language Modus reden zu lang
wird. Ja klar, es kann ja auch sein,
dass wir einer unserer Modelle ein ganz, ganz kleines Modell
ist, was gar nicht den den Rahmen hat, den sag ich mal, die
komplette, also die komplette Kontextgröße hat er sich da
jetzt die komplette Chat Historie mit Reingeben, kann die
Frameworks die ich mir angeschaut haben das Problem
alle schon gelöst, indem ich einfach wirklich pro Agent den
ich da definiere? Man kann sich vorstellen Agency
wie eine Klasse oder wie eine Instanz von einer Klasse, die
ich dann so ein bisschen beschreibe, wo ich dann
Properties mit Reingebe und denen kann ich dann sagen, wie
sollen die den Kontext von der bisherigen Unterhaltung bekommen
kann. Sagen gib mir einfach die
komplette bisherige Chat Historie rein.
Manche können das, manche nicht, für manche ist das vielleicht
auch sogar. Ja, quasi kontraproduktiv.
Ich kann sagen, gib nur die letzte Nachricht mit rein, ich
könnte sagen gib die letzten 3 Nachrichten mit rein und alles
was und von unten ist summary von allem was was vorher
passiert ist. Das heißt da wird noch mal kurz
n mal gefragt fassen wir mal diesen Chat zusammen in weiß ich
nicht maximal 100 Wörtern und dann packe ich das mit rein, das
heißt auch das muss ich als developer steuern bis ich also
du merkst schon bis ich dahin komme, dass ich eine
funktionierende Konversation zwischen mehr als 2 Parteien
habe ist das ganz schön viel testen und ausprobieren und
schauen, wie was was funktioniert denn da für diese
Unterhaltung oder für diesen Agent am besten.
Manche sind vielleicht total verwirrt davon, wenn sie 50 Chat
Nachrichten bekommen, kommt aber auch auf Newscase an, wenn ich
jetzt den Summary Agent habe, dann will ich dem natürlich so
viele Details wie möglich reingeben können und so weiter.
Wo du gerade sagst, testen wir sprechen ja jetzt hier über
irgendwelche statistischen Systeme zufallsbasiert oder
zumindest nicht zufallsbasiert, aber zumindest wahrscheinlich.
Als basiert werden dort Informationen zurückgegeben und
bei dem gleichen Beginn oder bei der gleichen Anfrage kann ja der
Verlauf unterschiedlich durchgeführt werden.
Wie teste ich sowas denn sinnvoll?
Ja, das ist die große Frage, weil es ist halt nicht mehr
deterministisch. Ne, ich hab ja normalerweise in
der Softwareentwicklung, kann ich ja den Code testen, weil es
immer den gleichen Ablauf folgt, hier weniger ich kann.
Für die Testphase n bisschen mit Parametern umspielen und sagen
sei mal weniger kreativ, da gibt es sowas wie wie Temperatur und
Top P. Das sind so Werte mit denen man
spielen kann, die könnte man ganz niedrig schalten, da kriegt
man nen halbwegs deterministischen Ablauf, aber
kann natürlich auch nur den einen Test.
In der Regel ist es aber so, dass man in diesen, dass wenn
man für diese Tests dann stand heute, es gibt auch keine
richtig gute Lösung dafür, zumindest keinen, die mir
bekannt ist. So bisschen Custom Logik
schreibt, dass man so grob absteckt, ob das was das
sinnvoll ist, was rausgekommen ist und dann aber auch fürs
Testen wieder. Large language Model befragt.
Man kann ja sagen, Pass auf, das war jetzt das Ergebnis von
diesen, wie diese Agents sich unterhalten haben.
Bewerte doch mal selber wie wie wie findest du das Ergebnis und
da sind Lautstänke eigentlich ziemlich gut da drin.
Wenn ich jetzt irgendwie keine Ahnung ich hab n paar Agents und
die machen meinen nächsten Urlaub aus weil dir der eine ist
gut in Flüge buchen, der andere kann Hotels planen der der der
vierte hat tolle Wanderrouten was weiß ich dass man im
Längshotel fragen kann Hey das Ergebnis ist das ein Reiseplan
und wenn die jetzt komplett Müll erzählt haben dann sind
Solarstellungen ganz gut da drin das zu erkennen und sagen nee
also da sehe ich gerade keinen Reiz oder der Fehler komplett
die Flügel. Oder du sagst natürlich,
idealerweise ist es ein Reiseplan, was sowohl Flüge als
auch Hotel als auch Aktivitäten beinhaltet.
Mindestens so und so viel Tage ist wie der User Reingegeben
hat, die können sich ganz gut selber überprüfen, aber du
merkst schon so richtig knackig boolean Yes no Test bestanden,
Test nicht bestanden, mäßig ist das stand heute nicht, also das
ist schon noch sehr viel manuelles menschliches Testen
und das wird vor allem dann schwierig, wenn ich noch
weitergehe und diese Agents eben nicht nur chatten lasse.
Sondern also ne. Also chatten heißt die können
einfach auf ihr Large Angriff Model Hinzugreifen zugreifen,
sondern Agents werden ja dann cool wenn sie selber noch
irgendwie knowledge irgendwo abrufen können.
Über RAG Das war das Thema was wir in Folge 80 mal gesprochen
haben auf den eigenen Daten, aber was man so Agents heute
auch mitgibt ist die Möglichkeit nativen Code aufzurufen, das
nennt man zum Beispiel Function Calling, das heißt ich kann ja
sagen, also wenn ich diesen Flug Buche oder einen Reiseplan
mache, dann ist eine AI natürlich gänzlich ungeeignet
dafür Flüge nach weiß ich nicht nach Südfrankreich zu buchen,
weil das Trainingsset ja vielleicht im September 2023
aufgehört hat und wenn ich jetzt GPT 4 Frage, buchen wir einen
Flug nächste Woche nach nach Südfrankreich.
Kann das also. Woher soll das wissen, welche
Flüge das hat? Wenn ich aber eine kleine native
Funktion schreibe, wo ich jetzt, ich sage mal die skyscanner API
mit Abfrage, dann kann ich sowas machen wie function calling, das
heißt ich sag dem Modell wo. Auf der Robin Manuel hat gesagt
Buchen wir einen Flug nach von München nach Südfrankreich zur
Beantwortung der Frage könntest du entweder ganz normal aus dem
Large Language Model heraus, die die Antwort generieren und ins
Plaudern kommen, oder du kannst mir auch Bescheid sagen, also
mir als die Runtime dir gerade Code diesen Code hier aufruft,
du könntest nämlich auch einen der folgenden Funktionen
aufrufen und dann ist in dieser Liste dieser Funktion eine von
den Funktionen die ich geschrieben habe, nämlich Call
Skyscanner API und die nimmt folgende Parameter entgegen und
dann kann das Large Language Model entscheiden, ob es diese
Funktion braucht zur Beantwortung der Frage und wenn
es sagt Ja. Dann.
Dann sag mir das Bescheid, mit welchen Parametern die Funktion
aufgerufen soll. Ich führe dann die Runtime,
führt dann diese Funktion aus, gibt das Ergebnis wieder in
diese Chat Historie in den Chat mit rein, sagt ja Pass auf habe
ich ausgeführt das und das ist das json was zurückkommt wenn
man Flüge am 21 Oktober von München nach Nizza oder so was
weiß ich bucht und da kann das Nudeln Modell mir darauf jetzt
eine Antwort generieren weil das wissen was die skyscanner API
geliefert hat plus natürlich sehr gut darin ist Menschen
lesbare Antworten zu zu generieren, das heißt es ist so
ein Ping Pong Spiel. In dieser Chat Historie, das
heißt das wurde sagt Ja führ mal lieber diese Funktion aus.
Auf das sind Funktionen die ich als Developer geschrieben und
dann am Large Language Model mehr oder weniger registriert
habe. Auch das übernehmen natürlich in
Wahrheit diese Frameworks, also alles was ich sage so
registriert aufrufen, das sind am Ende ist alles.
Wird das irgendwie in prompt gegossen?
Da wird dann einfach eine Liste, hey, du könntest auch eine
dieser folgenden Tools, wenn das auf Tools diese Functions tools
hier aufrufen, das wäre die Funktion, die heißt get flights
from Skyscanner und die möchte einen String für den From einen
String für den to Code und ein Date Time für from und 2 haben.
Musste aber nicht aufrufen, könntest du aber und da kann das
Large Language Model mir damit antworten.
Die können aber auch selber Code generieren, also Large Language
Modelle können auch selber Code generieren, weil die sind zum
Beispiel ja super schlecht da drin Sachen zu brechen.
Aber ich könnte sagen Hey du die bei Agent du hast die
Funktionalität wenn du ne Berechnung machen willst dann
generiere mir einfach ein bisschen, ich sag mal Python
Code, schick mir den und wenn du willst fürchten für dich aus, da
wird es natürlich dann kommen dann komplett verrückt, denn das
ist dann fast gar nicht mehr Testbar, das heißt das nennt man
dann Code executions, das heißt in der AI generiert Quellcode.
Um den um die Aufgabe zu lösen, die die, die ich ihm gestellt
habe und dann brauche ich irgendwo eine Execution
Umgebung, entweder die lokale Runtime, die gerade ohnehin
meinen Code ausführt, das ist natürlich hoch unsicher, das
heißt, würde ich nur in dev testszenarien machen, oder ich
stelle solche sowieso wegwerfdocker Umgebungen bereit,
ich könnte ja sagen, wenn das lutsch Englisch wurde mir Python
Code generiert, dann ziehe ich hier irgendwo mal kurz ein
Docker Container hoch, der komplett im Netzwerk isoliert
ist, der vielleicht auch gar nicht ins Internet raus kann für
den Code aus und. Füttert die Ergebnisse von
dieser Code Execution wieder in in unsere Chat Historie mit dem
Models rein und löscht dann diesen Docker Container wieder,
dass er gar kein Schadcode auch irgendwie ausgeführt werden
kann. Und so komme ich dann durch
diese ganzen Tools. Also entweder ich hab schon Code
geschrieben, die das Modell aufrufen will, oder dass ich
lass das Modell selber Code schreiben.
Ganz ganz spannend, aber auch irgendwie ganz ganz also klingt
natürlich auch super gefährlich. Aber aber funktioniert, oder?
Ich lass das Modell ne Anfrage an meine Wissensdatenbank
stellen oder ich mach wie du eben bei Chips ne Internet
request und so kann ich eben jedem Agent sagen, ja du darfst
Code generieren, du brauchst keinen Code generieren, du.
Passende also, wenn du Code generierst, gibt das wieder
diesen Chat rein, da kann der Orcus Trader sagen, ah ich sehe
hier Code den den übergeb ich mal dem Code Execution Agent,
weil der vielleicht irgendwie ne sichere Umgebung bereitstellen
kann und so komm ich dann irgendwann in diesen Gruppenchat
ganz am Ende. An mein Ergebnis, was
hoffentlich der aux Twitter erkennt.
Und dann hab ich durch sehr viel Kontext ne sehr lange
Konversation, was gut ist, weil diese brauchen lange brauchen
Tokens um zu denken je kürzer die Antwort ist, desto dümmer
ist die Antwort oft auch. Und kann das dann natürlich eben
wieder zusammenfassen. Da sind Agent ja sehr, sehr, da
sind ja sehr, sehr gut drin und hab dann irgendwie mein Ergebnis
oder je nachdem wenn ich jetzt vielleicht n Podcast Skript
haben will, dann muss ich ja dazu, dann dann schmeiß ich
dazwischen irgendwie all diese Code executions raus und liefer
am Ende nur nur noch das finale Skript.
Und das machen Agents und ihr man.
Man merkt schon, wenn man darüber spricht, dass es
eigentlich wahnsinnig mächtig ist, auch so n bisschen.
Also mir macht es auch n bisschen Angst, aber auch
irgendwie genauso faszinierend ist das, wie die meisten Dinge
die Angst machen. Und eigentlich auch ziemlich
cool. Ja, ich glaub das Faszinierende
daran ist halt, dass ne gewisse Autonomität dann nachher
stattfindet. Das heißt diese Agents, die
reden irgendwie miteinander, generieren Code gegebenenfalls
ausgeführt wird, ohne dass es da.
Kann man natürlich machen, aber ohne dass es da gezwungenermaßen
noch einen menschlichen Einfluss hat.
Ne, also wir haben jetzt gegebenenfalls human in the Loop
und wir können halt die einzelnen Prozessschritte noch
irgendwie überwachen, wir kennen es halt von den Tools, die wir
in den vergangenen Folgen besprochen haben rund um das
Thema Softwareentwicklung, das ist da auch die Möglichkeit
gibt, in jedem Schritt als Mensch ein Review zu machen,
aber man kann das natürlich auch komplett autark durchlaufen
lassen und dort auch verschiedene Iterationen und
Loops machen, bis man dann zu diesem Endergebnis kommt und ich
glaube, das ist das, was so ein bisschen gruselig macht, weil
man das Gefühl hat, da passiert so viel, was man am Ende
vielleicht gar nicht mehr so 111 zu 1 nachvollziehen kann.
Natürlich, man kann ganz viel loggen, aber da ist halt
irgendwie nicht deterministisch, kann das natürlich in jedem
Ablauf unter. Sein und was ich jetzt aus
diesem Gespräch mitnehme, ist, dass wenn wir über das Thema
Agents reden, wir vor allen Dingen über das Thema Agent,
Frameworks und Orchestrierung reden, weil da eigentlich.
Die Magie drinsteckt, also die Magie, die steckt dann weniger
in den einzelnen Agents. Ich glaub, das ist für uns, die
wir uns mit Softwareentwicklung beschäftigen, irgendwo noch
nachvollziehbar, das ist irgendwie ne ganz bekanntes
Pattern. Du hattest auch vorhin gesagt,
du bist mein Microservice, das heißt?
Wir haben einzelne Dienste, die werden irgendwie aufgerufen,
aber dann nicht wie in der Vergangenheit ganz.
Klar, deterministisch, algorithmisch.
Wir wissen, wann welcher Service aufgerufen wird, sondern es gibt
halt irgendwie diesen Orchestra davor, der dann die Entscheidung
am Ende relativ autark treffen kann, wann welcher Agent dort
genutzt wird, zu Wort kommt und ich glaube, da steckt halt viel
in Anführungsstrichen der Magie drin und das ist, glaube ich das
Thema, mit dem man sich dann am meisten auseinandersetzen muss,
wie funktioniert das alles, wie baut man sowas, weil ich denke,
das ist etwas, was sich wirklich auch von klassischer Software
Entwicklung, wie wir sie alle kennengelernt haben, entscheidet
unterscheidet. Weil wir halt dort keine.
Klar deterministischen Ablauffluss mehr haben.
Klar, wir schreiben immer noch Code, der irgendwie klar
deterministisch ist, aber das was halt dann an den Stellen
jeweils durch das KI Modell entschieden wird, das wissen wir
zum Zeitpunkt. Der Entwicklung noch nicht.
Wir können uns da eine gewisse Hypothese drüber bilden, weil
wir wissen ja. Wie wir zum Beispiel so einen
prompt zusammenbauen, aber am Ende, was das Ergebnis ist, das
wissen wir erst, wenn wir das ganze letzten Endes ausführen
mit dem Inputdaten Befüttern. Und dann beobachten, wie sich
das wirklich im realen Betrieb verhält?
Genau. Wir können natürlich so n
bisschen in den Rahmen setzen. Ne wenn ich jetzt sage Ey dieses
generieren und ausführen von eigenem Code, das lass ich mal
komplett weg aus meiner Agent Landschaft, das ist mir zu
gruselig oder ich ne also dann mach ich das halt nicht.
Ich kann mir natürlich in den Rahmen setzen aber du Grad das
die Magie ist eigentlich da drin, dass entweder der Oxfator
auswählt welcher Agent gerade zu Wort kommt, Magie ist aber auch
innerhalb des Agents, dass der Agent selber entscheidet welche
seiner Tools die ihm zur Verfügung stehen.
Also function Calling oder wie Wreck, in dem es halt
irgendwelche Daten, Daten noch mit Hinzuzieht oder AP is
aufrufen, also welche dieser Tools denn verwendet werden
sollen um die Frage zu beantworten, auch das wissen wir
nicht, das heißt überall wenn wir eine AI entscheiden lassen,
wie geht's weiter? Du hast folgende Optionen, sag
mir mal wie du bestehend auf allem was du weißt über die Welt
und über diese Agents die du hast und was diese Agency
können. Sag mal wie es weitergehen soll.
Das ist ja auch schon Magic ne. Also selbst wenn ich die Sorge
ist heute weglasse und jetzt wie bei github Pilot Workspace, wo
die Abfolge der Agents völlig klar ist.
Oder wenn oder wenn ich einfach so n so n so n Chat mache und
dann irgendwie den Azure Agent mit dazu hole und sag hey,
kannst du mir hier mal so n kubaniertes Cluster anlegen,
auch dann weiß ich ja nicht wie der auf diese von mir
formulierte Frage ey, kannst du mir mal n Kobold Cluster
anlegen, was der dann intern macht, der hat ja dann alle
möglichen Tools in meinem Namen mit der Azure API zu
interagieren. Schafft das überhaupt einen
richtigen API Request zu bauen oder muss ich da noch mal
nachhelfen über einen guten prompt oder über fertige
Funktionen? Und das ist ja auch schon die
Magie. Also selbst wenn ich diese Magie
der Orchestrierung weglasse und sage, es hat einen ganz klaren
Ablauf oder der User bestimmt, welcher Agent jetzt gerade den
Ball aufnehmen soll. Auch dann ist also ganz viel
Magie. Kleine Zaubershow.
Hier der Podcast. Absolut ja.
Vielleicht können wir in einer der kommenden Folgen nicht
unbedingt in einer der direkt nächsten, aber uns mal so ein 2
von diesen Frameworks rauspicken und so ein bisschen darüber
sprechen, wie sind die aufgebaut, wie arbeite ich
damit, ich glaube, es interessiert jetzt einige, wie
man dann auch wirklich loslegt. Ich habe es wie gesagt auch noch
nicht selber. Ausprobiert von daher auch für
mich n super spannendes Thema, einfach auch zu verstehen.
Wie sieht das dann in der Praxis aus, also wie kann man so etwas
dann auch vielleicht erstmal im kleinen Rahmen umsetzen, die
ersten Schritte damit machen und dann so n bisschen die erste
Hello World komplexe KI Applikation bauen, die einen
sinnvollen Use Case erfüllt finde ich auf jeden Fall super
interessant und das ist glaube ich etwas was jetzt.
Glaub ich in diesem Jahr gerade so startet ne ich glaub wir
hatten in den letzten ein 2 Jahren hatten wir das Thema erst
mal irgendwie mächtige Large Language Models und natürlich
diverse andere. KI Modelle, generative AI et
cetera. Aber jetzt kommen wir glaube ich
in die nächste Stufe, wo wir verschiedene Spezialfähigkeiten
zusammenbringen und dann halt immer näher an solche.
Intelligenzen rankommen, die halt verschiedene Fähigkeiten
nutzen sowie auch Menschen es tun.
Ne, wir greifen natürlich auch auf verschiedene Werkzeuge
zurück um verschiedene Probleme zu lösen und genauso kann eine
Applikation letzten Endes dann auch.
Mehr oder weniger autark entscheiden was ist jetzt das
richtige Werkzeug, um diesen Job zu erledigen und kann dann über
das, was es vielleicht von Haus aus an Fähigkeiten mitbringt,
dann noch ganz andere Spezialisierungen mit reinholen,
um dann auch ein Problem zu lösen, wie in deinem Beispiel
jetzt die Flugbuchung, die vielleicht einen.
Cheti Pitti nicht kann, aber wenn ich jetzt dann vielleicht
nen speziellen vielleicht gibt es das auch, ich hab noch nicht
reingeguckt, speziellen Agent von Skyscanner gibt, den ich
direkt dort in meinen Chat mit dazu holen kann, dann kann ich
das plötzlich und das macht die Sachen natürlich viel mächtiger.
Wer sich das mal anschauen möchte, wie gesagt, ich hab mir
Auto gen angeguckt, das ist ein Python Framework, aber diese
Python zu jeder der ein bisschen Code schreiben kann kann
zumindest Python Code lesen, die haben ganz coole Tutorials wo
man wirklich wirklich so Hello World Like sich mal
durchprobieren kann, die haben mir jetzt sehr gut gefallen,
dass man auch so in ein 2 Stunden durch.
Werde sich die Zeit nehmen möchte, ansonsten werde einfach
mit mal ein bisschen rumklicken möchte es gibt von Open Ai die
Assistance API, das die nennen ihre Agencystens.
Da kann man während Open ein Open Air Account hat, der kann
dann diesen Playground reingehen und sie einfach mal so einen
Assistant erstellen und dem kann man dann sagen Pass auf, du hast
Zugriff auf folgende Daten, das ist dein prompt.
Also dein bei Metapromp oder ein System prompt den du irgendwie
hast. Du könntest auch folgende
Funktion. Aufrufen und so weiter und dann
kann man einfach mal mit diesem Assistant chatten, das ist dann
halt erstmal nur ein Agent, aber da kann man zumindest schon mal
diesen Gedankenprozess so n bisschen folgen, der dann sagt,
Jo um die Frage zu beantworten würd ich gerne ne Funktion
aufrufen. Sag mal, sag mir doch mal bitte
was dabei rausgekommen ist. Da muss man zwar selber diesen
Code aufrufen, weil das macht Openay nicht für einen, das ist
denen auch zu heiß, aber man könnte das Ergebnis dieser
Funktion dann quasi wieder da rein füttern und da muss man gar
keinen Code für schreiben, das kann man zusammenklicken.
Also Assistance heißt das bei open AI und Auto gen ist das
Framework was ich mir angeguckt habe, gibt aber noch 12 andere
Frameworks, die würde ich einfach mal verlinken unten in
den Shownotes von diesem Podcast.
Cool, damit sind wir, glaube ich, eine Ende dieser am Ende
dieser Folge angekommen. Wir haben, glaube ich, ein
bisschen länger geredet, als wir eigentlich geplant hatten, von
daher eine lange Folge heute aber zu einem sehr spannenden
Thema. Ich hoffe für euch war es
genauso interessant wie für uns sich zu dem Thema so ein
bisschen weiterzubilden, auszutauschen und wie immer,
wenn euch diese Folge gefallen hat, dann lasst uns gerne eine
Bewertung da entweder auf Spotify oder bei Apple Podcasts
und wir freuen uns natürlich auch, wenn ihr uns über bei mir
Coffee ein. Kaffee ausgibt und dann werdet
ihr natürlich wie immer in der nächsten Folge auch namentlich
erwähnt. Genau, oder wenn ihr zu eurem
eigenen Kaffee die passende Nerd Tasse haben wollt, dann schaut
auch gern mal in unserem kleinen Shop vorbei.
Auch da gibt's den Link in der Beschreibung und nochmal sorry,
dass es ein bisschen länger gedauert hat diese Folge, aber
es war schließlich die letzte Folge, die malte und ich hier
selber aufnehmen. Ab heute übernehmen natürlich
die Agency, ihr sitzt natürlich im Hintergrund schon daran den
perfekten Podcast zu bauen. Und jetzt kommen nie wieder
folgen zu spät und der Walter und ich haben ein entspannteres
Wochenende. Ist auch schon trainiert, von
daher läuft. Nein.
Wir bleiben natürlich so lange es geht hier menschlich und
handgemacht. Das ist noch ein ehrlicher
Podcast. Deswegen freuen wir uns ganz
toll, wenn ihr in 2 Wochen auch wieder mit dabei seid.
Bis dahin schreibt viel Code und habt eine gute Zeit.
Bis dann.