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, lernen, Tools zu entwerfen, zu debuggen und Guardrails einzusetzen, und am Ende ein vollständiges Listing eines funktionierenden Agenten zusammenstellen möchten.
Praktischer Workshopkurs, 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, die Handhabung von Speicher und Zustand bis hin zum Testen, zur Fehlerdiagnose und zum 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, sowie 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 verankert 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 einen Ein-/Ausgabe-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-Auswahl, 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 funktionale 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-Schnittstellen, die Fähigkeit, Projekte in virtualenv oder uv auszuführen, grundlegende Kenntnisse in 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
- Anwendungsfall des Kurses: ein Developer-Agent, der ein Tool auswählt, eine API aufruft und das Ergebnis begründet
- Der aktuelle LlamaIndex-Stack für Agenten: Tools, Context, Workflow und Instrumentierung
- ReActAgent vs FunctionAgent in der Praxis: Entscheidungstabelle, Modellgrenzen und die Kosten falscher Entscheidungen
- Arbeitsartefakt: Auswahlmatrix ReAct vs. FunctionAgent für 6 Aufgabentypen
- Quiz: Erkennen der passenden Agentenarchitektur anhand der Systemanforderungen
- Von einer gewöhnlichen Python-Funktion zu FunctionTool: Signatur, Docstring, Typen und Eingabekontrakt
- Schwache vs. starke Tool-Beschreibung: Vergleich vollständiger Tool-Definitionen before/after
- JSON-Argumente ohne Fallen entwerfen: Enums, Standardwerte, optionale Felder und Validierung
- Return_direct, Antwortformat und wann ein Tool Rohdaten statt Narration zurückgeben soll
- Workshop: Erstellung einer Qualitäts-Checkliste für Tools und einer Spezifikationsvorlage für das Repository
- Quiz: Fehleridentifikation in Definitionen von Tools, die zu fehlerhaftem Tool Calling führen
- Projekt-Setup: virtualenv oder uv, Verzeichnisstruktur, Abhängigkeiten und API-Schlüssel-Konfiguration
- Implementierung eines gemeinsamen Tool-Sets: Berechnung, Abruf von Daten aus einer API und einfacher lokaler Lookup
- Wir bauen ReActAgent: Steuerungs-Prompt, Thought/Action-Schritte und Kontrolle der Endantwort
- Wir bauen FunctionAgent: natives Tool Calling, Context und Zustandsverwaltung zwischen Aufrufen
- Dasselbe Problem, zwei Agenten: vollständiges Worked Example vom Input bis zum Output mit Kritik der Antwort
- Quiz: Welcher Teil der Implementierung ist für die Auswahl des Tools, den Zustand und das Antwortformat verantwortlich
- Wie man Events streamt und den Ablauf eines Agents loggt: AgentInput, ToolCall, ToolCallResult und Output
- Typische ReActAgent-Fehler: Denkschleifen, falsche Tool-Auswahl und Überschreiben der Systemanweisung
- Typische FunctionAgent-Fehler: inkonsistentes Schema, falsche Argumente und fragile Datenserialisierung
- Debug-Notebook: 5 End-to-End-Ausfälle und ihre Behebung Schritt für Schritt mit Before/After-Logs
- Team-Artefakt: Scorecard zur Bewertung von Agentenantworten, Tool-Aufrufen und der Qualität von Begründungen
- Quiz: Diagnose der Fehlerquelle anhand des Ausführungsprotokolls
- Grenzen der Verantwortung des Agents: Was das Modell entscheiden soll und was der harte Anwendungscode
- Gedächtnis und Zustand in LlamaIndex: wann man Context verwendet und wann man Sitzungen isoliert und den Verlauf zurücksetzt
- Guardrails für Tools und Antworten: Validierung, Retry, Timeouts, Fallbacks und sichere Fehlermeldungen
- Kosten und Latenz: Wie man die Anzahl von Modell- und Tool-Aufrufen ohne Qualitätsverlust reduziert
- Architekturvergleich: Einzelagent, Agent mit Workflow und leichter Agent über RAG
- Quiz: Auswahl von Hardening-Mechanismen für konkrete Produktionsszenarien
- Projektbrief: ein Python-Agent zur Bearbeitung operativer Anfragen über APIs und lokale Tools
- Auswahl der Architektur und Implementierungsplan: Mermaid-Diagramm des Ablaufs, Tool-Liste und Erfolgskriterien
- Implementierung eines MVP: der vollständige Ablauf vom ersten Prompt bis zur funktionierenden Antwort des Agents
- Szenariotests und Regressionstests: Fallset, erwartete Ergebnisse und Bewertungstabelle
- Hardening-Review: Checkliste vor der Produktion, technische Schulden und Plan für weitere Iterationen
- Abschlusstest: Auswahl architektonischer Verbesserungen auf Grundlage der Symptome aus dem Mini-Projekt
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 zur Handhabung von 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 nativem Function Calling zu bevorzugen, während ReActAgent dort sehr nützlich bleibt, wo größere Modell-Universalität und ein expliziter Handlungsablauf zählen. 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 Ablaufkontrolle zu bauen, immer wertvoller.
Für Python-Entwickler, AI/ML-Ingenieure, Personen, die LLM-Anwendungen entwickeln, 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 Workshopkurs mit Fokus auf Implementierung statt Theorie. Statt eines allgemeinen Überblicks erhältst du einen Designprozess, konkrete architektonische Entscheidungen, 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