Werk:AI mit Arnie/Unser erster KI Agent
In diesem Video basteln wir unseren ersten KI-Agenten, und ich zeige dir ganz, ganz kurz, wie das aufgebaut ist.
Wir sind natürlich in unserem KI-Agenten-Framework noch von vorhin, und wir klicken „+“. Und bei diesem + siehst du jetzt, dass wir diese Multi-Agents haben. Wir haben immer einen Supervisor – das ist das Ding, das wir immer, immer brauchen werden – und wir haben diese Arbeiter. Die werden hier „Worker“ genannt, und die können wir auch mit reinziehen, zumindest sowas solltest du eigentlich immer verwenden, wenn du einen KI-Agenten bauen willst.
Was ist das Ganze? Wie funktioniert das? Wir haben diesen Supervisor, und dieser Supervisor wird entscheiden, welcher Arbeiter hier tatsächlich arbeiten muss. Das heißt, wir haben zwei Arbeiter und einen, der sozusagen die Aufsicht hat. Und was machen wir? Wir können diese Dinge hier verbinden. Der Supervisor wird natürlich verbunden mit dem Arbeiter, und zwar genau bei diesem Supervisor-Dings hier. Und überall, wo du das rote Sternchen siehst, überall dort musst du Sachen einstöpseln. Das heißt, unser Supervisor wird natürlich verbunden mit beiden Arbeitern.
Sobald die Dinge verbunden sind, gehen wir noch mal ganz hier zurück an diesen Anfang. Und du siehst auch, dass da „Tool Calling Chat Model“. Das heißt, wir brauchen hier tatsächlich ein Modell – ein LLM, das am besten auch „Function Calling“ mit dabei hat. Denn wir können auch jeden dieser Arbeiter mit Tools ausstatten. In diesem Video halten wir das jedoch noch so einfach wie möglich.
Ich klicke daher auf „+“. Aber was wir brauchen, ist unbedingt dieses Chatmodell, und hier können wir verschiedene Modelle einbauen. Du siehst hier OpenAI, Mistral, Anthropic ChatGoogle Generative, GroqChat und so weiter. Die besten Resultate bekommen wir natürlich mit den GPT-4-Modellen, aber wir wollen das natürlich mit lokalen KI-Agenten machen.
Dementsprechend gehen wir hier rüber. Und was brauchen wir? Wir brauchen natürlich die Chatmodels. Dementsprechend klicken wir auf die Chatmodels, und hier haben wir viele verschiedene Dinge, die wir machen können. Wir könnten die Anthropic-Dinge verwenden, die von Google und so weiter. Jedoch, wie gesagt, wir machen das natürlich mit lokalen LLMs, und wir haben natürlich Ollama installiert und haben Ollama schon laufen. Wir ziehen das rein.
Du siehst übrigens, dass wir hier das normale Ollama haben und dass wir auch das da haben: „Chat Ollama Function“ – „Run open source function calling compatibilies LLM on Ollama.“ Das heißt, ja, wir können auch Function Calling mit Ollama machen, das weißt du bereits. Ich will j“edoch erst mal mit dem normalen Chatmodell von Llama hier beginnen. Wir ziehen das rein, und ich habe das auch vorhin schon reingezogen. Wenn du irgendwas übrig hast, dann kannst du es löschen.
Dementsprechend verbinde ich jetzt natürlich Ollama hier mit unserem Modell. Und du siehst auch, dass da schon... wir haben bereits einen Localhost hier reingebaut: http/localhost und so weiter. Und wir können ja natürlich auch einfach mal schauen, ob dieser Localhost immer noch aktiv ist oder nicht. Das machen wir, indem wir einfach mal diese Seite hier kopieren, und wir schmeißen die in einen leeren Browser. Dann sehen wir uns an, ob Ollama immer noch läuft. Also, kopieren. Und du siehst, Ollama ist running. Das heißt, das funktioniert natürlich immer noch perfekt. Das wurde schon automatisch hier eingefügt. Das heißt, Ollama funktioniert, und wir müssen natürlich dem Modell den Namen geben und wir verwenden hierfür natürlich Llama 3. Die Temperatur vom Modell, die lass ich einfach mal auf 0,9.
Wir haben jetzt also unseren Anführer hier, den Supervisor, verbunden mit Ollama, und dieses Modell wird jetzt natürlich den Supervisor und unsere Arbeiter betreiben. Wir könnten die Arbeiter auch betreiben mit anderen LLMs, jedoch ist das jetzt nicht wirklich nötig. Und jetzt müssen wir natürlich rausfinden, was unsere Arbeiter machen.
Und es ist wichtig, dass, wenn wir hier mehrere separate Arbeiter verwenden, die alle einzeln eine Task machen, dann wird der Output insgesamt besser. Dementsprechend musst du jetzt natürlich rausfinden, was diese zwei Arbeiter machen sollten, was zwei Arbeiter besser können als ein Arbeiter.
Ich gebe dir mal ein Beispiel, und im nächsten Video bauen wir das noch weiter aus, sobald wir Tools reinholen und wirklich einen mächtigen Agenten machen.
Unser erster Arbeiter ist z. B. der Codeagent. Und im Prompt will ich jetzt angeben, was er machen kann. Ich kann das groß machen, und ich zeig dir jetzt, was wir hier dazuschreiben. Wir können das hier auf Englisch machen, da Code eigentlich natürlich in Englisch geschrieben wird. Und der zweite Agent, der sollte danach Code sprechen – „Your are a Python Expert“. Ich sag diesem Agenten ganz einfach, dass er Python-Experte ist und er macht Code. Sein Output ist ein einziger Codeblock, so einfach wie möglich. Wir klicken hier „Save“. Das heißt, wir haben jetzt unseren Codeagenten.
Und der nächste Arbeiter, das wäre jetzt z. B. das Ding, das die Beschreibung für diesen Code macht. Ich schreibe ganz einfach mal „Code-Dokumentation“ hier mit rein, und jetzt öffne ich hier diesen Prompt wieder. Und hier schreiben wir jetzt sowas rein: „Du bist ein Experte im Schreiben von Dokumentationen auf Deutsch. Du beschreibst so einfach wie möglich, wie man Code laufen lässt in Replit und was der Code macht.“ Und ja, die Rechtschreibung ist mir hier egal. Wir könnten „Replit“ auch groß schreiben, wir könnten einige Dinge umändern, aber ich mache das schnell. Ich klicke einfach mal „Save“.
Und was sollte jetzt passieren? Unser Supervisor wird jetzt Ollama verwenden, bzw. Llama 3, und er wird die Aufgaben aufteilen. Die erste Aufgabe ist es natürlich, den Code zu entwerfen, und das macht dieser Arbeiter. Nachdem der Code entworfen ist, sollte danach unser zweiter Arbeiter hergehen und unsere kleine Dokumentation schreiben, wie wir das Ding in Replit laufen lassen können. Damit das funktioniert, müssen wir den Chatflow erstmal natürlich speichern und dem Ding einen Namen geben. Ich nenne das Ding einfach mal „Open Source Code“. Ich klicke auf „Save“.
Wir können jetzt hier drauf klicken. Auch das können wir natürlich groß machen, und wir können hier jetzt einfach mal nachfragen. Und Entschuldigung, ich habe das etwas unübersichtlich. So, wir lassen das jetzt einfach mal klein: „Mache ein Snake-Spiel.“ Ich schick das ab.
Und es tut mir leid, also, ich war richtig, richtig dumm. Ich sagte dir vorhin, ja, wir können auch das normale Ollama-Modell verwenden. Das ist hier tatsächlich eine Fehlinformation. Ich will solche Fehler extra mit drinnen lassen. All diese Dinge sind natürlich immer zum Probieren da.
Also, wir löschen natürlich noch mal Ollama. Ich klicke noch mal auf „+“. Wir müssen hier natürlich das damit reinnehmen: Ollama Function Calling. Auch wenn wir aktuell nicht Function Calling machen, das ist mir gerade selbst wieder eingefallen. Auch wenn wir Function Calling nicht machen, müssen wir dennoch Ollama Function Calling hier verwenden. Der Rest ist natürlich gleich: Llama 3. Boom. Jetzt sollte das Ganze passen. Ich will das jetzt noch mal speichern, und jetzt gehen wir hier drauf, und jetzt sollte das Ganze klappen: „Mache ein simples Snake Spiel“ Jetzt siehst du, wird der Supervisor getriggert, und der Supervisor sagt jetzt natürlich, sowas wie „Moment, Start possibilities of a simple Snake Game“.
Danach sagt uns der Codeagent hier einige Dinge zurück. Danach spricht er wieder natürlich mit dem Supervisor, und es geht so weiter. Und am Ende sollten wir hier natürlich alles so zurückbekommen.
Okay, ich hatte minimale Probleme, und ich konnte die Probleme lösen durch viel, viel, viel bessere Prompts. Wenn ich das da groß mache, siehst du, dass ich den Prompt mittlerweile sehr, sehr spezifisch und sehr, sehr massiv habe. Und ich will dir das da zeigen. Beim zweiten Worker habe ich den Prompt auch viel, viel, viel besser gemacht.
Und jetzt will ich dir erstmal zeigen, wie man richtig, richtig starke Prompts schreiben kann. Ich dachte zuerst, hey, meine Prompts reichen aus. Es stellte sich raus, dass das nicht ausgereicht hat. Das heißt, ich speichere das jetzt einfach mal, und ich zeige dir, wie man perfekte Prompts für diese Arbeit schreiben kann.
Du kannst hier zurückgehen und danach kannst du auf den Marketplace gehen. Und hier schreibst du Folgendes rein: „Prompt Engineering Team“. Hier hast du einen KI-Agenten, der für dich Prompt Engineering macht. Du klickst auf das Ding, du klickst „Use Template“. Du musst hier ein Modell verwenden. Hier würde ich dir tatsächlich raten, eventuell mal die OpenAI-Modelle zu verwenden, denn die funktionieren hier tatsächlich am besten. Das heißt, GPT-4 Omni ist perfekt. Das Ding schreibt nur Prompts für uns. Das ist also perfekt.
Wir müssen hier die Credentials einfügen. Ich habe bereits Credentials, ich füge hier also Flowwise 2 ein, und ich klicke danach einfach „Speichern“. Und wir nennen das jetzt einfach mal „Prompts für Agenten“, und wir klicken „Speichern“.
Jetzt zeige ich dir, was hier funktioniert. Wir haben hier dasselbe Prinzip, jedoch wird dir hier beschrieben, wie das Ganze funktioniert. Du beschreibst einfach nur hier drinnen in diesem Chat, was du gerne haben willst, und diese Credentials, die holst du natürlich im Playground, wie du es schon gelernt hast. Das heißt, „Create New Secret Key“. Du gibst dem Ganzen einen Namen, du kopierst deinen API-Key, und den kannst du danach hier einfügen, indem du ganz einfach hier den Namen gibst und unten den API-Key mit einfügst. Und danach kannst du dieser Application beschreiben, was du gerne machen willst.
In unserem Beispiel: „Ich will zwei Experten, einer soll Python-Code machen, der zweite soll den Code beschreiben – auf Deutsch.“ Und wir schicken das Ganze raus. Und was macht jetzt dieses Ding? Erstmal geht der Supervisor her, er verwendet den Prompt-Creator, und wir werden jetzt Prompts bekommen. Danach geht der Supervisor wieder her, wir verwenden wieder den Prompt-Creator. Das heißt, erstmal hat er sich hier tatsächlich etwas Überblick aufgeworfen. Danach sagt er, wir brauchen eine CSV-Datei. Wir werden wieder den Prompt-Creator verwenden.
Das heißt, hier gehen diese KI-Agenten jetzt hin und her, und zwar so lange, bis sie perfekte Prompts haben – und zwar für unsere zwei KI-Agenten. Das kann hier zwei, drei Iterationen dauern, aber danach haben wir etwas, das richtig, richtig gut funktioniert. Nach ein paar Mal hin und her habe ich diesen Output bekommen, und den habe ich mir in eine Textfile gespeichert.
Das heißt, der Name von unserem ersten Agenten ist „Python Developer“. Das ist hier der System-Prompt und die Instructions, und die kopieren wir und schmeißen sie in unseren Prompt. Danach den Agenten 2: „Documentation Specialist“, der System-Prompt, und danach die Instructions. Und die Dinge kopieren wir einfach in unsere Application. Das heißt, wir gehen wieder zurück in die Agent-Flows. Wir haben hier den Open Source Code, und hier haben wir natürlich unsere kleinen Arbeiter.
Und hier kopieren wir genau die Dinge rein. Das heißt, „Python Developer“ ist unser erster Agent. Siehst du ja: „Python Developer“. Danach kopiere ich das da bis hier runter, und das schmeiße ich genau hier rein. Und danach dasselbe natürlich. Also „Save“. Und danach dasselbe natürlich beim zweiten Arbeiter: „Documentation Specialist“. Also hier der „Documentation Specialist“. Danach kopiere ich das bis hier runter, bis zum nächsten Step. Das heißt, ich kopiere auch das da, und das schmeißen wir hier rein – tatsächlich. Und wir haben hier alles mit dabei, und du siehst, es sollte hier eigentlich perfekt funktionieren, und er sollte die Antwort auch auf Deutsch geben.
Das heißt, jetzt haben wir hier zwei perfekte Prompts und zwei perfekte Namen für unsere KI-Agenten. Ich muss gestehen, ja, das ist ab und zu ein kleiner Krampf, damit wir das gut laufen haben. Aber jetzt können wir hier drauf klicken. Ich habe das bereits probiert. Ich kläre den Chat noch mal, damit du sehen kannst, wie das Ganze funktioniert.
Wir klicken hier drauf, und jetzt kann ich z. B. sowas machen: „Erstelle ein Snake-Spiel.“ Ich schick das raus, und jetzt geht der Supervisor her. Er gibt die Anweisung an den Python Developer, also an das Ding hier, und der sollte jetzt den Code schreiben für Snake, und zwar in einem einzelnen File. Das sollte danach perfekt funktionieren.
Wir haben jetzt also den Code. Der Supervisor kommt wieder ins Spiel, und er sagt zum Documentation Specialist, dass wir die Dokumentation haben wollen. Und wir sollten danach die Dokumentation bekommen – höchstwahrscheinlich oder hoffentlich auch auf Deutsch.
Und jap, das sieht so aus, als ob wir die Dokumentation auch auf Deutsch bekommen haben. Ich mache das Ganze noch mal groß. Wir sehen uns all das jetzt noch mal an. Also, wir gehen hier hoch. Ich schreibe: „Erstelle ein Snake-Spiel.“ Der Supervisor geht her, verwendet den Python Developer. Der Python Developer gibt uns tatsächlich unseren ganzen Code. Das sieht schon sehr gut aus, zumindest auf den ersten Blick. Eine klitzekleine Code-Erklärung, jedoch ist das nicht genug.
Wir brauchen natürlich die gesamte. Dementsprechend geht der Supervisor her, er sagt zum Dokumentenspezialisten, wir brauchen die gesamte Dokumentation. Und wir bekommen hier die Übersicht: „Dieses Python-Script implementiert ein einfaches Snake-Spiel unter Verwendung der Pygame-Bibliothek. Das Ziel des Spiels ist es, die Schlange zu steuern, um die Nahrung zu fressen …“ und so weiter. Du kannst dir das selbst durchlesen.
Danach haben wir hier die ganzen Zeilen auch spezifiziert. Das heißt, was heißt „pip install pygame“? Was heißt „Python Snakegame“? Danach das Python-Script an sich. Das wurde hier reinkopiert. Die Funktionserklärungen sind dabei, die Fehlerbehebungen, und zum Schluss haben wir „finished“ und einen kleinen Überblick. Also Respekt hier. Alles, was uns hier noch übrig bleibt, ist natürlich, das Script zu testen. Das heißt, ich gehe noch mal hoch. Ich will das Script jetzt in Replit testen, um zu sehen, ob das auch tatsächlich funktioniert. Das heißt, „Import pygame“. Ja, wir brauchen nur das Kopieren, denn „pip install pygame“ sollte in Replit eigentlich schon dabei sein.
Das heißt, ich gehe jetzt auf Replit. Wir kreieren eine Python-Umgebung: „Open Source Snake“, „Create Repl“. Ich füge hier den Code ein, ich klicke jetzt „Run“. „Loading Environment“. Bis jetzt sieht das Ganze sehr gut aus, muss ich sagen. Der Code hat auf den ersten Blick auch richtig gut ausgesehen. Lass uns das etwas größer machen. Und Boom, es sieht so aus, als ob ich hier ein Snake-Spiel hätte. Und ja, die Schlange fährt sogar. Ich wachse, wenn ich die Teile fresse. Ja, sieht wirklich sehr gut aus. Die Steuerung ist etwas schwierig. Ich will mal in die Wand düsen, um zu sehen... Ja, perfekt.
Wenn ich „Q“ klicke, dann mache ich „Quit“, und bei „C“: „Play Again“.... Ja, ich kann noch mal spielen. Ich fahre in die Wand, sollte sterben. Perfekt. Und mit „Q“ ist das Spiel vorbei. Exzellente Aufgabe!
In diesem Video haben wir uns angesehen, wie wir KI-Agenten basteln können mit Open-Source-Modellen. Wir können das in Flowwise machen. Wir brauchen einen Supervisor und mindestens zwei Arbeiter. Function Calling haben wir noch nicht eingebaut.
Es ist wichtig, gute Prompts für die Arbeiter zu schreiben. Diese Prompts können wir tatsächlich schreiben mit unserer separaten Application, und der beschreiben wir ganz einfach, was wir gerne haben wollen. Wir fügen die Prompts ein, wir müssen natürlich ein Modell hinzufügen. Wir haben Ollama verwendet. Wichtig ist, dass wir Ollama Function Calling mit dabei haben, auch wenn wir noch nicht Function Calling machen. Und du hast deinen ersten KI-Agenten laufen, der nacheinander Tasks ausführt.
Und im nächsten Video wollen wir einen Schritt weitergehen. Wir brauchen einen KI-Agenten, der mehrere Tasks macht und der auch Function Calling mit eingebaut hat. Wir können diesem Agenten Internetzugriff geben und vieles, vieles mehr. Wir sehen uns im nächsten Video.
Und ich muss noch dazu sagen: Diese Open-Source-Modelle, die haben es ein klein wenig schwer. Wenn du hier ein Q4-Modell von Llama verwendest, dann wird das nicht immer sofort perfekt klappen. Das Q8-Modell von Llama ist natürlich viel, viel, viel besser.
Open-Source-Modelle als KI-Agenten sind leider noch nicht ganz auf dem Level von den OpenAI-Modellen. Das heißt, diese KI-Agenten funktionieren natürlich noch besser mit den Modellen von OpenAI. Wir wollen aber alles komplett lokal laufen lassen. Dementsprechend sind wir halt ein klein wenig limitiert mit diesen Agenten. Die können sogar noch intelligenter sein mit den stärksten Modellen. Also sei nicht verzagt, wenn dein kleines Llama-Modell eventuell etwas schwach ist. Viel Spaß beim Testen!