Werk:AI mit Arnie/RAG KI-Agent
In diesem Video sprechen wir über die RAG-Technologie. Es kann ja sein, dass du einen Agenten zum Beispiel trainieren willst, meinetwegen an deinem Schreibstil oder an speziellen Daten von deinem Unternehmen oder an was weiß ich welchen Daten. Generell ist es relativ egal, welche Daten du verwenden willst.
Ich hoffe, du weißt natürlich noch, wie die RAG-Technologie funktioniert. Diese technischen Daten haben wir natürlich am Anfang schon geklärt. Erinnere dich daran: Vektordatenbank, RAG-Technologie, Chunks, Size und so weiter.
In diesem Video wollen wir erstmal eine kleine RAG-Application bauen. Die wird wirklich wahnsinnig einfach aufgebaut sein. Vielleicht zwei, drei Arbeiter. Und ein Arbeiter ist mit der RAG-Technologie trainiert, an einem PDF.
Und über die nächsten zwei Videos will ich dir zeigen, wie wir die RAG-Technologie verbessern können. Denn wir haben bei der RAG-Technologie ein riesengroßes Problem mit dem Aufbereiten der Daten. Leider sprechen ganz wenige Leute darüber. Die meisten Leute sprechen bei der RAG-Technologie einfach immer nur davon, dass man einen Link geben soll zu einer Webseite oder ein PDF hochziehen. Um ehrlich zu sein, das werden wir in diesem Video auch machen. Aber wie gesagt, im nächsten Video sprechen wir darüber, wie wir die Dinge besser machen können.
Also erstmal: Wir sind wieder in Flowise. Wir starten mit einem Agent Flow. Dementsprechend: Add New. Und natürlich machen wir bis jetzt alles gleich wie immer. Mit der Zeit wird es auch etwas komplexer, sobald wir mit den Custom Tools beginnen.
Wir starten natürlich mit einem einzigen Supervisor. Und wir machen... wir machen das einfach jetzt. Sagen wir einfach mal drei Arbeiter. Den will ich noch kopieren. Wir verbinden die Dinge wieder. Also, die Dinge bis jetzt sehen natürlich ganz genau gleich aus. Und anach sollten wir natürlich rausfinden, was die Dinge machen. Aber zuvor will ich natürlich noch ein Chatmodell hinzufügen.
Und wir nehmen das Ding mal wieder von OpenAI. Dementsprechend verbinden wir natürlich auch das hier. Wir geben natürlich wieder unseren API-Key. Ich will das GPT-4 Omni-Modell haben. GPT-4 Mini ist mir zu schwach für das Ding. Und ich denke, mittlerweile sind hier die Basics tatsächlich schon geschehen.
Als nächstes starten wir mit den Prompts. Das machen wir natürlich im Prompting-Agenten. Zuvor will ich das speichern. Wir nennen das einfach mal RAG. Wir gehen zurück, wir gehen natürlich auf unsere Agent Flows, wir gehen auf das Prompting. Hier natürlich klicken wir drauf. Ich kann das auch groß machen. Und jetzt beschreiben wir, was unsere RAG-Application machen sollte.
Wir starten ganz einfach, und bitte beachte nicht die Rechtschreibung. Ich will drei Agenten:
Der erste Agent soll hochgeladenes Wissen durchsuchen und ein Tool namens DocReader verwenden.
Der zweite Agent soll vom hochgeladenen Wissen einen Blogartikel schreiben und fünf kurze Tweets.
Der dritte Agent soll alles gut strukturieren und zusammenfassen und am Ende ein Tool verwenden, das meine Daten lokal abspeichern kann.
Ich schick das Ganze los. Und wir werden natürlich unsere Prompts bekommen, und die füge ich danach ein. Dabei musst du mir nicht mal zusehen.
Unsere Prompts sind jetzt drinnen. Wir haben den Knowledge Explorer, den Content Creator und den Data Organizer. Hier sagen wir ganz einfach, dass wir die RAG-Technologie anwenden und dass wir natürlich unser spezielles Tool verwenden, das wir gleich noch einfügen, und zwar das Tool DocReader. Danach der Content Creator. Der sieht sich einfach nur die Dinge von vorhin an und macht daraus was Hübsches. Und zum Schluss dieser Prompt vom dritten Arbeiter: Der sagt ganz einfach, dass all die Dinge gut strukturiert werden sollen, gut zusammengefasst werden sollen und dass er zum Schluss das Local Storage Tool verwendet. Also bis jetzt alles kein Hexenwerk.
Jetzt fangen wir natürlich an, ein paar Dinge dazu zu bauen. Und wie gesagt, wir machen das jetzt so einfach wie möglich. Und über die nächsten zwei Videos zeige ich dir danach, wie du die Dinge noch besser machen kannst.
Wir verwenden dafür ein PDF, und wir starten jetzt die Dinge zu implementieren, die wir brauchen. Wir klicken auf Plus. Denn jetzt wollen wir die Dinge reinbringen, die für unsere RAG-Technologie da sind. Wir brauchen also ein Tool.
Und was brauchen wir hier wohl? Ja, genau, wir brauchen das da: Das Retriever Tool. Und das Retriever Tool, das schließen wir jetzt natürlich an, an unseren Arbeiter, der hier Zugriff braucht. Und das sollten wir jetzt natürlich so nennen, wie wir es hier im Prompt angegeben haben.
Und wenn man das vergisst, dann kann man das natürlich öffnen, und wir können uns diesen Namen hier einfach nur kopieren. Denn wie gesagt, es ist wichtig, dass wir hier die Dinge richtig benennen.
Danach eine kurze Beschreibung: Also, was soll das Ding machen? „Use this tool …“ Du kannst hier auch Deutsch sprechen, aber meiner Meinung nach funktioniert es etwas besser in Englisch: „Use this tool searches info about dogs“, weil ich hier eine PDF habe, wo es um Hundetraining geht. Ja, ich verwende diese PDF ab und zu als Spiel, einfach weil ich es witzig finde. Und ja, ich muss jetzt schon sagen, diese PDF ist absolut nicht optimal für die RAG-Technologie. Aber ich zeig dir später noch, wie wir die besser aufbereiten können. Erstmal starten wir hier einfach.
Was brauchen wir als Nächstes? Beim Retriever Tool brauchen wir natürlich auch noch unseren Retriever. Wir klicken also +, wir gehen runter, und wir brauchen natürlich Vector Stores. Erinnerlich daran: Verwende nicht die „Depreciating Nodes“, sondern die Neuen. Du kannst Chroma verwenden, Astra, du kannst verwenden, was auch immer du willst. Pinecone ist auch stark. Ich verwende hier den In-Memory Vector Store, weil wir hierfür keine API hinzufügen müssen. Und dieses Ding, das können wir natürlich anschließen auf unseren Retriever.
Und jetzt haben wir die meisten Dinge, aber leider noch nicht alles. Wir brauchen Embeddings. Das heißt, wir brauchen ein Embedding-Modell. Ich hoffe, du weißt noch, was Embeddings sind. Wir klicken +, wir klicken natürlich auf Embeddings. Und ich verwende hierfür natürlich die OpenAI Embeddings, weil die am stärksten sind. Also OpenAI Embeddings. Wir schmeißen diese hier rein. Wir stöpseln das an, hier auf die Embeddings. Und jetzt natürlich die Credentials – wieder mal unsere Credentials – und das Embedding-Modell: Text Embeddings Ada002. Das Modell ist hier gut genug für uns. Das Modell passt also
Als nächstes müssen unsere Dokumente hinzu. Und dafür brauchen wir natürlich Document Loaders. Wir scrollen dementsprechend zu den Document Loaders. Die sind hier tatsächlich schon. Und in unserem Beispiel ist das jetzt eine PDF.
Aber bitte sieh dir an, was du alles verwenden kannst. Du kannst verwenden, was du willst. Du kannst Airtables verwenden, API Loader, Website Content Crawler, Crawler, WebScraper, Confluence, CSV Files, also Tabellen, Custom Document Loaders, wenn du was selbst bauen willst, DocumentSores, Sigma-Folder with Files. Also hast du einen Ordner, kannst du gerne auch Folder with Files verwenden. GitBook, GitHub, JSON Files, JSON Line Files, also du kannst wahnsinnig viele Dinge nehmen. Sogar Notion Pages.
Das da: PDF File. Das ist für uns natürlich „Plain Text“, wenn du ganz normalen Flißtext hast. Danach verschiedene andere WebScraper, S3 Buckets – hier muss ich tatsächlich gestehen, bin ich selbst überfordert, was das Ding ist – danach verschiedene APIs, die Dinge von der Server-API, normale Textfiles und so weiter.
Wie gesagt, ich verwende das PDF File. Ich schmeiß das hier hoch, und wir connecten jetzt auch dieses hier mit unseren Dokumenten. Und jetzt zeige ich dir, was wir als Nächstes machen. Wir sollten natürlich unser PDF hochladen. Also: Upload PDF. Und danach können wir natürlich noch einen Textsplitter einbauen.
Also, ich klicke erst hierauf. Ich habe jetzt das Dogo.pdf ausgewählt. Also, das Dogo.pdf ist jetzt hier hochgeladen. Jetzt können wir den Usage anpassen und den Textsplitter. Ich empfehle dir, das auch jetzt zu machen, und mehr Informationen im nächsten Video darüber. Wir verwenden hier „One Document per File“. Und danach verwenden wir jetzt einen Textsplitter. Wir klicken also +: Textsplitters, Recursive Character Textsplitter. Das ist eigentlich das Ding, das am besten funktioniert. Und den Textsplitter verbinden wir hier hiermit.
Ich erkläre dir im Schnelldurchlauf, was ein Textsplitter ist. LLMs haben ja immer ein Token-Limit, und es ist natürlich unterschiedlich, wie groß das Token-Limit ist. Wir haben das Problem, dass, wenn wir eine komplette PDF hochladen, das Ganze schwammig wird. Die Dinge von der Mitte werden nicht gut erkannt. Anfang und Schluss wird halbwegs gut erkannt. Das macht Probleme. Dieser Textsplitter zerteilt das Dokument in ein paar kleinere Stücke. Und wenn wir danach unsere Suche machen in der Vektordatenbank, dann werden nur diese Chunks – das nennt sich Chunk Size – nur diese Chunks rausgesucht, die relevant für uns sind. Und so funktioniert das besser. Und mehr Informationen darüber im nächsten Video, wie du das besser anpassen kannst.
Für uns lassen wir die Chunk Size jetzt einfach mal auf 1000, weil wir ein großes, starkes Modell haben. Und den Chunk Overlap: 200 ist mir persönlich eher zu hoch. Ich gebe dir natürlich noch ein paar Infos, wie du hier die Chunk Size besser anpassen kannst. Ich verwende hier beim Overlap einfach mal 100 und die Chunk Size 1000. Wie gesagt, mehr Infos kommen noch.
Und im Groben haben wir jetzt unsere RAG-Application stehen. Also, ich zeige dir ganz kurz, was wir hier haben. Ich mache das noch etwas kleiner, damit wir näher reinzoomen können. Dann haben wir das besser im Überblick.
Also, dieser Arbeiter wird natürlich zum Retriever Tool zugreifen können. Das Retriever Tool hat eine Vektordatenbank angeschlossen. Die Vektordatenbank hängt natürlich an unserem PDF File. Das PDF File wird durch die Embeddings-Modelle gejagt und danach in der Vektordatenbank eingespeichert. Und unser Recursive Character Textsplitter macht Chunks daraus. Das ist im Groben, was hier passiert.
Dementsprechend kann dieser Arbeiter einfach unser Dogo.pdf durchsuchen und findet die besten Informationen raus, weil wir die Dinge hier gut eingegeben haben. Lassen wir es einfach so stehen.
Der letzte Worker braucht jetzt nur noch irgendwas, damit er unseren Output auch am Ende auf unseren PC speichern kann. Das heißt, wir klicken jetzt +, wir gehen natürlich runter zu den Tools: Write File to Disk. Das da schließen wir jetzt an. Und dieses Write File hier, da müssen wir jetzt natürlich einen Ordner angeben. Ich mache kurz einen Ordner auf meinen Desktop. Ganz einfach: Neuer Ordner. Ich nenne das Ding jetzt einfach mal „Flowise“.
Und ich zeige dir kurz, was ich mache. Bei „Flowise“ klicken wir jetzt natürlich drauf, mit Rechtsklick, und wir klicken hier jetzt „Pfad kopieren“. Also, „Als Pfad kopieren“. Und jetzt gehen wir hier rein, und wir müssen das hier einfügen. Unter diese Anführungszeichen kann ich weglöschen, und danach sollte das Ganze tatsächlich schon funktionieren. Und schwups,.
Und jetzt sehen wir uns mal an, wie das Ganze funktioniert. Und um zu sehen, ob wir die Dinge von der Dogo.pdf rausfinden können, scrollen wir einfach mal runter. Und wir suchen uns irgendwas raus, das unser LLM sonst nicht wissen soll, zum Beispiel: „Welche drei Kategorien von Hundetrainern gibt es?“ Also speichern, und wir fragen das: „Welche drei Kategorien von Hundetrainern gibt es?“
Und hoppla, jetzt haben wir hier das Problem, dass unser Data Organizer ausgelassen wurde. Und jetzt zeige ich dir wieder mal einen coolen Trick, wie wir das umgehen können. Das heißt, unser letzter Arbeiter wurde hier ausgelassen. Ich habe hier schon den Prompt was verändert. Also, wir schreiben hier zum Schluss noch dazu: „You output to the Data Organizer.“ Dann funktioniert das jetzt schon besser.
Aber wir können auch das da machen: Wir gehen zu unserem Supervisor, und hier geben wir ihm zusätzliche Informationen. Also, wir klicken hier das da, und wir schreiben jetzt dazu: „You start with the Knowledge Explorer, then you pass it to the Content Creator, and lastly you pass it to the Data Organizer.“ Und jetzt sollte das Ganze besser funktionieren. Das heißt, das speichern wir jetzt natürlich alles nochmal speichern.
Und wir fragen jetzt natürlich nochmal, und dann sollte unsere Application besser funktionieren. Wir klicken nochmal darauf. Ich will den gleichen Starter-Prompt nochmal kopieren. Wir machen das Ganze groß, damit wir es besser verfolgen können. Also, ich lösch das nochmal.
Wichtig ist ja auch, dass wir hier klicken, bevor ich das vergesse. Also, wir haben unsere Vektordatenbank hier natürlich dazu. Und wir klicken hier drauf, damit all das hier natürlich hochgeladen wird. Unser Recursive Textsplitter mit den Open Embeddings und unsere In-Memory Vector Database – die werden jetzt trainiert an diesem PDF File, aber erst, nachdem wir „Absurd“ klicken. Das ist wichtig. Das dürfen wir nicht vergessen.
Und hier siehst du: Jetzt haben wir die ganzen Dinge hochgeladen. Und siehst auch hier die Chunks. Das heißt, das sind die Chunks. Das hat unser Textsplitter gemacht. Und genauso sollte das Ganze laufen. Ich klicke jetzt „Close“. Jetzt speichern wir das Ding nochmal. Und jetzt sollte es aber besser funktionieren.
Natürlich sollten wir jetzt viel, viel besseren Antworten bekommen. „Welche drei Kategorien von Hundetrainern gibt es?“ Wir schicken es los, und ich hoffe, ich bekomme jetzt gute Antworten.
Der Supervisor startet beim Knowledge Explorer. Und der hat das Read Document Tool verwendet. Und beim Read Document Tool siehst du hier: Kategorien von Hundetrainern. Und er zeigt uns hier auch auf, welche Chunks er verwendet hat.
Als nächstes geht unser Supervisor her und verwendet den Content Creator. Der Content Creator hat hier jetzt unseren Content gemacht: die Tweets und so weiter. Der Supervisor geht weiter, verwendet jetzt den Data Organizer. Und der Data Organizer sollte jetzt alles hübsch strukturiert haben und das Ganze hier gespeichert haben, unter meinem lokalen PC. Das heißt, ich hoffe, das funktioniert. Ich schließe das mal.
Ich gehe in Flowwise. Dort drinnen haben wir jetzt ein Textfile. Ja, das haben wir schon. Also ein Textfile und die Tweets. Wenn ich hier auf den Blogartikel klicke – das wurde jetzt hier drüben geöffnet – dann haben wir hier den ganzen Blogartikel. Sieht wunderbar aus. Und die Tweets, die haben wir auch hier, wunderbar strukturiert. Alles hat perfekt funktioniert. Dementsprechend können wir jetzt natürlich von unserer PDF Blogartikel und Tweets schreiben, und zwar für 0, nichts.
Dank dieser Vektor-Datenbank und dem Textsplitter und den ganzen Dingen kannst du wirklich eine Application bauen, die Sinn macht. Dementsprechend haben wir eine wirklich praktische Application gebaut.
Und ich will jetzt sehen, ob auch die Dinge richtig sind oder nicht. Also, wir haben den belohnungsbasierten Trainer. Das ist die erste Kategorie. Die zweite Kategorie: der zwangsbasierte Trainer. Und die dritte Kategorie sind die flexiblen Trainer. Und wenn ich mir das Dogo.pdf öffne, dann siehst du hier, dass wir unter der ersten Kategorie... die sind hier tatsächlich auf „Reward“ aus. Also passt. Die nächste Kategorie sind die „Yank and Crank“-Trainer. Also, die zwingen die Hunde dazu. Und die dritte Kategorie sind hier die Mittelstufe. Eigentlich genauso, wie es unsere Application hier sagt: also nach Belohnungen, nach Zwang und der flexible Trainer. Perfekt umgesetzt. Alles übersetzt auf Deutsch. Alles macht Sinn. Unsere RAG-Application funktioniert perfekt.
Ich zeige dir nochmal kurz, wie wir das Ganze gemacht haben. Wir gehen dementsprechend nochmal hier rein. Also, wir starten natürlich mit einem Supervisor, dem Modell, und drei Arbeitern. Wir machen unsere Prompts, die Sinn machen. Der erste Arbeiter verwendet hier die RAG-Technologie. Dafür brauchen wir das Retriever Tool. Wir geben ihm einen Namen und erwähnen den Namen auch im Prompt. Wir sagen, dass er natürlich zum Beispiel getriggert wird, wenn wir Dinge über Hunde fragen.
Dann brauchen wir einen In-Memory Vector Store oder welche Vektordatenbank du auch immer verwenden willst. Als nächstes brauchen wir ein Embedding-Modell, um die Dinge einzubetten in die Vektordatabase. Und wir müssen die Dinge hochladen.
Und zum Schluss brauchen wir noch unseren Recursive Character Splitter, damit wir Chunks machen. Und wir brauchen zusätzlich noch einen Chunk Overlap. Zum Schluß oder als nächstes haben wir den zweiten Arbeiter, der was Hübsches schreibt von all diesem Output. Und unser dritter Arbeiter fasst alles gut zusammen und speichert die Dinge danach lokal auf unserem PC ab, damit wir alles perfekt zusammen haben.
Lange Rede, kurzer Sinn: Du kannst wahnsinnig coole Agenten hier bauen, die trainiert sind an deinem eigenen Wissen, die was auch immer daraus schreiben, und die es sogar für dich lokal abspeichern. Das ist eine coole RAG-Application.
Und über die nächsten zwei Videos zeige ich dir, wie man eine RAG-Application verbessern kann. Denn gute Daten sind das Allerwichtigste, das du brauchst, wenn du gute Outputs bekommst.
Ich muss gestehen: Diese Dinge hier, die funktionieren von alleine relativ gut. Aber wenn du sicher gehen willst, dass deine RAG-Application noch besser funktioniert, dann brauchst du gute Daten.