Aufbau eines schlussfolgernden KI-Agenten mit LlamaIndex: ReAct und Function Agent in Python
Workshop für Mid-Level-Entwickler, die Schritt für Schritt in Python einen schlussfolgernden Agenten in LlamaIndex aufbauen, ReActAgent und FunctionAgent vergleichen, Tool-Design, Debugging und Guardrails lernen und am Ende ein vollständiges Listing eines funktionierenden Agenten zusammenstellen möchten.
Ein praxisorientierter Workshop-Kurs, der zeigt, wie man von Grund auf einen schlussfolgernden KI-Agenten mit der Bibliothek LlamaIndex entwirft, implementiert und ausführt. Die Teilnehmenden durchlaufen den gesamten Prozess: von der Wahl der Agentenarchitektur über die Definition von Tools in Python, das Design von Systemanweisungen sowie die Handhabung von Speicher und Zustand bis hin zu Tests, Fehlerdiagnose und dem Zusammenfügen einer vollständigen End-to-End-Lösung. Der Kurs stellt bewusst zwei Ansätze gegenüber, die von der aktuellen LlamaIndex-Dokumentation unterstützt werden: FunctionAgent, bevorzugt für Modelle mit nativem Function-/Tool-Calling, und ReActAgent, nützlich, wenn ein expliziter Reason-Act-Zyklus gewünscht ist oder mit Modellen ohne natives Function Calling gearbeitet wird. Der Workshop basiert auf aktuellen Mustern aus der LlamaIndex-Dokumentation, in der Agenten aus dem workflow-Paket aufgebaut werden, Tools einfache Python-Funktionen oder QueryEngineTool sein können und der breitere architektonische Kontext in event-driven Workflows eingebettet ist. Neben dem Code selbst erklärt der Kurs, warum bestimmte Designentscheidungen korrekt sind, welche Fehler am häufigsten auftreten und wie man sie in der Praxis vermeidet.
Was Sie lernen
- Du erklärst die Unterschiede zwischen ReActAgent und FunctionAgent und wählst den passenden Agententyp entsprechend den Fähigkeiten des LLM-Modells aus.
- Du baust in Python einen funktionierenden LlamaIndex-Agenten auf Basis eigener Funktions-Tools sowie korrekt beschriebener Signaturen und Docstrings.
- Du entwirfst eine Systemanweisung, Tool-Beschreibungen und den Input-/Output-Vertrag so, dass der Agent häufiger die richtigen Aktionen auswählt.
- Du ergänzt Gesprächszustand und Ausführungskontext mithilfe von Workflow-Mechanismen und lernst, den Ablauf mehrstufigen Schlussfolgerns zu steuern.
- Du diagnostizierst die häufigsten Fehler: falsche Tool-Wahl, halluzinierte Argumente, Agenten-Schleifen, zu breite Prompts und unklare Funktionsbeschreibungen.
- Du vergleichst vollständige Before/After-Artefakte: schlecht und gut gestaltete Tools, Prompts sowie Entscheidungsabläufe des Agenten.
- Du integrierst Funktions-Tools mit auf QueryEngineTool basierenden Tools, damit der Agent sowohl Anwendungslogik als auch die Wissensschicht nutzen kann.
- Du führst manuelle und szenariobasierte Tests des Agenten durch, fügst Ereignis-Logging hinzu und erstellst eine Qualitäts-Checkliste vor dem Deployment.
- Du stellst am Ende des Kurses ein vollständiges, komplettes Listing des gesamten Agenten zusammen, inklusive Erläuterung jedes Codeabschnitts und der architektonischen Gründe dahinter.
Voraussetzungen
Kenntnisse in Python auf mittlerem Niveau, Grundlagen der Arbeit mit LLM-API-Modellen, die Fähigkeit, Projekte in virtualenv oder uv auszuführen, grundlegende Kenntnisse von JSON und Funktions-Typisierung. Nützlich sind Erfahrungen mit Prompt Engineering sowie grundlegendes Wissen über RAG, aber der Kurs führt auch bei architektonischen Entscheidungen Schritt für Schritt durch den Prozess. Die Teilnehmenden sollten eine Python-3.10+-Umgebung sowie einen API-Schlüssel für den gewählten Modellanbieter eingerichtet haben.
Kursprogramm
- Wie das API für Agenten in LlamaIndex heute aussieht: `llama_index.core.agent.workflow` ohne Architektur-Raten
- ReActAgent vs FunctionAgent bei einer Aufgabe: Vergleich des Ablaufs reasoning -> tool -> answer
- Warum FunctionAgent meist die erste Wahl für Modelle mit Function Calling ist und ReActAgent nur Plan B bleibt
- Arbeitsumgebung: Python 3.10+, Installation von `llama-index`, LLM-Provider und minimaler Projekt-Bootstrap
- Quiz: Auswahl des Agententyps passend zu Modell, Werkzeugen und Art der Flusskontrolle
- Der erste funktionierende Tool aus einer Python-Funktion: Typen, Docstring und Daten zurückgeben ohne Chaos
- `FunctionTool` und automatische Schema-Ableitung: was LlamaIndex aus der Signatur nimmt und was es nicht erraten kann
- Schwache vs. gute Tool-Beschreibung: vollständige Beispiele für Namen, Argumente und Docstrings, die die Entscheidungen des Agents verändern
- Die häufigsten Fehler bei Tools: versteckte Seiteneffekte, implizit erforderliche Felder, zu breiter Verantwortungsbereich
- Projekt mini-Werkzeugsatzes für einen operativen Agenten: Berechnung, Validierung, Suche und Fallback
- Quiz: Erkennen schlecht gestalteter Werkzeuge und ihre Verbesserung
- Minimalistischer `FunctionAgent` mit zwei Tools: erster End-to-End-Durchlauf in Python
- System-Prompt, der den Agenten steuert, statt nur ein Wunsch zu sein: Regeln, Anti-Patterns und Korrekturen
- Wie man die korrekte Nutzung von Tools erzwingt: Entscheidungsanweisungen, wann man selbst antwortet und wann man ein Tool aufruft
- Fehlerbehandlung bei Funktionsaufrufen: Argumentvalidierung, Ausnahmen und Rückmeldungen für das Modell
- Streaming und Beobachtung des Agentenablaufs: Was man loggen sollte, um die Entscheidungen des Modells zu sehen und nicht nur die finale Antwort
- Vergleichs-Workshop before/after: derselbe Agent vor dem Refactoring und nach dem Refactoring von Prompt und Tools
- Quiz: Ist dieser FunctionAgent bereit für die Nutzung durch den Benutzer?
- Minimaler `ReActAgent` mit denselben Tools: Was sich im Vergleich zum FunctionAgent ändert
- Lesen von Reasoning/Action/Observation-Spuren: Wie man einen fehlerhaften Denkprozess Schritt für Schritt diagnostiziert
- Schleifen, Overthinking und falsche Folgeaktionen: Guardrails für ReActAgent
- Wann ReActAgent besser sein kann als FunctionAgent: Modelle ohne Function Calling und Szenarien mit expliziter Planung
- Vergleichsübung: dieselbe Aufgabe gelöst von FunctionAgent und ReActAgent mit Analyse der Antwortqualität
- Quiz: Auswahl einer Agentenstrategie auf Basis von Logs und Projektanforderungen
- Agentensitzung und `Context`: wie man Gesprächszustand speichert, ohne den Verlauf manuell zusammenzukleben
- Hinzufügen von `QueryEngineTool` zum Agenten: wann ein Tool rechnen soll und wann es den Index befragen soll
- Verknüpfung von Funktions-Tools und Wissenswerkzeugen in einem Agenten ohne Entscheidungskonflikte
- Die häufigsten Fehler bei Zustand und Speicher: Kontextleck, zu viel Verlauf, implizite Abhängigkeiten zwischen Schritten
- Einführung in Workflows und event-driven Orchestration: Warum man diese API kennen sollte, selbst bei einem einfachen Agenten
- Quiz: Auswahl des Werkzeugs passend zu Daten, Zustand und Art der Benutzeranfrage
- Abschlussprojekt: Agent zur Lösung mehrstufiger Aufgaben mit Tools und Wissensquelle
- End-to-End-Implementierung: Dateistruktur, Modellkonfiguration, Tool-Definitionen und Agenteninitialisierung
- Szenariotests des Agents: vollständige Benutzereingaben, erwartete Tool-Aktionen und Bestehensbedingungen
- Produktions-Checkliste: Observierbarkeit, Timeouts, Validierung, Fallbacks und Begrenzung der Aufrufkosten
- Vollständiger Listing des gesamten Agents mit Zeile-für-Zeile-Kommentar: warum jeder Codeabschnitt genau so aussieht
- Abschließendes Quiz: Fehlerdiagnose im fertigen Agenten und Plan für die weitere Entwicklung
Häufig gestellte Fragen
Du lernst von Grund auf, einen schlussfolgernden KI-Agenten in Python mit LlamaIndex zu bauen: von der Wahl der Architektur über die Definition von Tools und System-Prompts bis hin zu Speicher, Zustand, Debugging und dem Start einer vollständigen End-to-End-Lösung.
Weil beide Ansätze in der Praxis wichtig sind. Die aktuelle LlamaIndex-Dokumentation empfiehlt FunctionAgent für Modelle mit nativer Unterstützung für Function Calling, während ReActAgent sehr nützlich bleibt, wenn größere Modell-Universalität und ein expliziter Handlungsablauf gefragt sind. So hilft der Kurs nicht nur zu verstehen, wie man einen Agenten baut, sondern auch, wann man welchen Ansatz wählen sollte.
Ja. Der Markt bewegt sich schnell in Richtung agentischer Systeme: Gartner prognostizierte, dass bis Ende 2026 40 % der Enterprise-Anwendungen spezialisierte KI-Agenten enthalten werden, während es 2025 noch weniger als 5 % waren. Dadurch wird die praktische Fähigkeit, Agenten mit Tools, Speicher und Flow-Kontrolle zu bauen, immer wertvoller.
Für Python-Entwickler, AI/ML-Ingenieure, Personen, die LLM-Anwendungen bauen, sowie Praktiker, die von einfachen Chatbots zu Agenten übergehen möchten, die Aufgaben mithilfe von Tools, Schlussfolgerungslogik und Zustandskontrolle ausführen.
Nein. Der Kurs führt Schritt für Schritt durch die wichtigsten Elemente des Ökosystems, die für den Bau eines Agenten benötigt werden. Hilfreich sind jedoch grundlegende Python-Kenntnisse und ein allgemeines Verständnis dafür, wie Sprachmodelle funktionieren.
Es ist ein Workshop-Kurs mit Fokus auf Implementierung statt Theorie. Statt eines allgemeinen Überblicks erhältst du einen Designprozess, konkrete architektonische Entscheidungen, die Arbeit mit Tools in Python, Speicher und Zustand des Agenten sowie Methoden zur Fehlerdiagnose in einer realen Lösung.
- 8 Stunden
- Fortgeschritten
- Zertifikat nach Abschluss
- Sofortiger Zugang nach Kauf