Wie man einen KI-Agenten mit LangChain erstellt: Schritt-für-Schritt-Anleitung

Erstelle ein sicheres, temporäres Arbeitsverzeichnis

Wie man einen KI-Agenten mit LangChain erstellt: Schritt-für-Schritt-Anleitung

Der Wandel von großen Sprachmodellen (LLMs), die lediglich Text generieren, hin zu KI-Agenten, die handeln können, ist eine der bedeutendsten Entwicklungen in der modernen Softwareentwicklung. Ein agentisches System nimmt seine Umgebung wahr, trifft Entscheidungen und nutzt Werkzeuge, um bestimmte Ziele zu erreichen – und geht damit weit über einfache Frage-Antwort-Chatbots hinaus. LangChain, ein Open-Source-Framework, hat sich als Standard für die Entwicklung dieser anspruchsvollen Anwendungen etabliert, indem es LLMs mit externen Daten, Werkzeugen und anderen LLMs verbindet.

Dieses Tutorial bietet eine umfassende, Schritt-für-Schritt-Anleitung, wie man einen KI-Agenten mit LangChain erstellt. Du lernst die grundlegenden Konzepte kennen und gehst eine praktische Implementierung durch, sodass du in der Lage bist, eigene autonome Agenten zu erschaffen, die reale Aufgaben ausführen können.

Was du lernen wirst

Am Ende dieses Tutorials verstehst du die Kernprinzipien der agentischen KI und des LangChain-Frameworks. Du wirst in der Lage sein, eine Entwicklungsumgebung einzurichten, eine Verbindung zu einem LLM herzustellen, benutzerdefinierte Werkzeuge zu definieren und einen funktionsfähigen Agenten mit der modernen create_agent-API zu erstellen. Du wirst einen vollständigen KI-Agenten bauen und ausführen, der basierend auf natürlichsprachlichen Befehlen mit einem lokalen Dateisystem interagieren kann – eine praktische Grundlage für die Erstellung komplexerer Automatisierungen.

1. LangChain-Grundlagen und Schlüsselkonzepte

Bevor wir in den Code eintauchen, ist es wichtig zu verstehen, was ein KI-Agent ist und wie LangChain seine Erstellung ermöglicht. Im Kern ist ein Agent ein System, das ein LLM als seine Denkmaschine nutzt. Der Agent empfängt eine Benutzeranfrage, fordert das LLM auf, eine Aktion zu beschließen, führt diese Aktion aus (oft durch Aufruf eines Werkzeugs) und verarbeitet dann das Ergebnis, um eine Antwort zu formulieren. Dieser Kreislauf wiederholt sich, bis die Aufgabe erledigt ist.

LangChain bietet ein standardisiertes Framework zur Implementierung dieser Denkschleife, insbesondere durch seine Unterstützung für das ReAct (Reason + Act)-Framework. LangChain ist ein High-Level-Werkzeug, das auf LangGraph aufbaut, einem Low-Level-Orchestrierungsframework, das dir eine granulare Kontrolle über den Workflow und den Zustand des Agenten gibt.

Um einen Agenten mit LangChain zu erstellen, benötigst du vier Hauptkomponenten:

1. Ein LLM: Die Denkmaschine deines Agenten.
2. Werkzeuge: Funktionen, die es dem Agenten ermöglichen, mit der Außenwelt zu interagieren, wie APIs, Datenbanken oder ein Dateisystem.
3. Die Agentenschleife: Die Orchestrierungsschicht (das „Gehirn"), die das LLM, die Werkzeuge und den Zustand verwaltet.
4. Speicher (Checkpointing): Die Fähigkeit, den Zustand des Agenten zu persistieren, sodass er sich an vergangene Interaktionen innerhalb eines Gesprächsfadens erinnern kann.

2. Einrichten deiner Entwicklungsumgebung

Um loszulegen, musst du LangChain und seine Kernabhängigkeiten installieren. Dieses Tutorial demonstriert den Prozess in Python, aber die Konzepte und übergeordneten Muster sind für TypeScript-Benutzer ähnlich.

Stelle zunächst sicher, dass Python 3 und Pip auf deinem System installiert sind. Für Debian/Ubuntu-basierte Systeme kannst du die folgenden Befehle verwenden. Für andere Betriebssysteme folge bitte der entsprechenden Installationsmethode.

sudo apt update
sudo apt install python3 python3-pip

Installiere als Nächstes die primären LangChain-Pakete. Das Paket langchain ist das Kernframework. langchain-community enthält von der Community gepflegte Werkzeuge, und langgraph wird für die moderne API zur Agentenerstellung benötigt.

pip install langchain langgraph langchain-community

3. Einbinden eines großen Sprachmodells

Der erste Schritt beim Bau deines Agenten ist die Verbindung mit einem LLM. LangChain unterstützt Dutzende von Modellanbietern, darunter Google Gemini, OpenAI, Anthropic und andere. Für dieses Tutorial verwenden wir Googles Gemini-Modell.

Du benötigst einen API-Schlüssel aus der Gemini-Konsole. Sobald du ihn hast, kannst du das Google GenAI-Integrationspaket installieren und deine Umgebung einrichten.

pip install -qU "langchain[google-genai]"

Jetzt kannst du den Python-Code schreiben, um das Modell zu initialisieren. Das Modul getpass wird verwendet, um sicher nach deinem API-Schlüssel zu fragen.

import getpass
import os
from langchain.chat_models import init_chat_model
from langchain_core.messages import HumanMessage, SystemMessage

if not os.environ.get("GOOGLE_API_KEY"):
    os.environ["GOOGLE_API_KEY"] = getpass.getpass("API-Schlüssel für Google Gemini eingeben: ")

model = init_chat_model("gemini-2.0-flash", model_provider="google_genai")

Du kannst die Einrichtung testen, indem du das Modell mit einer einfachen Abfrage aufrufst.

response = model.invoke("Wann begann die Französische Revolution?")
print(response.content)

4. Definieren von Werkzeugen für deinen Agenten

Werkzeuge sind das, was Agenten leistungsstark macht. Sie ermöglichen es dem LLM, Aktionen über die Texterzeugung hinaus auszuführen. In diesem Tutorial werden wir einen Agenten bauen, der Dateien auf deinem lokalen Computer mit LangChains FileManagementToolkit verwalten kann.

Das FileManagementToolkit ist Teil des langchain-community-Pakets, das du bereits installiert hast. Dieses Toolkit ermöglicht es dir, festzulegen, welche Dateioperationen der Agent ausführen kann, wie z. B. Lesen, Schreiben und Auflisten von Dateien.

Importiere die notwendigen Module und definiere die Werkzeuge. Es ist eine kritische Sicherheitsmaßnahme, den Agenten auf ein temporäres Verzeichnis zu beschränken, anstatt ihm freien Zugriff auf dein gesamtes Dateisystem zu gewähren.

from langchain_community.agent_toolkits import FileManagementToolkit
from tempfile import TemporaryDirectory

working_directory = TemporaryDirectory()

# Initialisiere das Toolkit mit ausgewählten Werkzeugen und einem Stammverzeichnis
tools = FileManagementToolkit(
    root_dir=str(working_directory.name),
    selected_tools=["read_file", "write_file", "list_directory"],
).get_tools()

5. Erstellen des Agenten mit create_agent

Nachdem das LLM und die Werkzeuge bereit sind, kannst du nun den Agenten erstellen. Die moderne und empfohlene Methode zum Erstellen von Agenten in LangChain ist die Verwendung der create_agent-Funktion.

Diese Funktion nimmt dein Modell und eine Liste von Werkzeugen entgegen und erstellt einen Agenten-Executor, der die Denkschleife verwaltet. Sie vereinfacht den Prozess, sodass du keinen ReAct-Agenten und Executor manuell erstellen musst.

from langchain.agents import create_agent

# Die Variablen "model" und "tools" stammen aus den vorherigen Schritten.
agent = create_agent(
    model=model,
    tools=tools
)

Diese einzelne Codezeile erstellt einen anspruchsvollen Agenten. Der Agent verwendet das Modell, um basierend auf der Benutzereingabe zu entscheiden, welches Werkzeug aufgerufen werden soll. Er kann mehrere Werkzeugaufrufe miteinander verketten, um eine komplexe Aufgabe zu erfüllen.

⚠️ Wichtig: Obwohl LangChain mit älteren Methoden zur Agentenerstellung wie create_react_agent verwendet werden kann, ist die create_agent-API der moderne, empfohlene Ansatz und sollte deine Standardwahl für die Erstellung neuer Agenten sein.

6. Ausführen deines ersten Agenten

Nachdem der Agent erstellt ist, kannst du ihn ausführen, indem du ihn mit einer Benutzernachricht aufrufst. Die folgenden Befehle demonstrieren die Fähigkeit des Agenten, mit dem Dateisystem zu interagieren.

Beginne damit, den Agenten zu bitten, die Dateien im aktuellen Arbeitsverzeichnis aufzulisten. Zu diesem Zeitpunkt ist das Verzeichnis leer.

input_message = {"role": "user", "content": "Liste die Dateien im aktuellen Arbeitsverzeichnis auf"}
response = agent.invoke({"messages": [input_message]})

for message in response["messages"]:
    message.pretty_print()

Weise den Agenten als Nächstes an, eine Datei namens sample-file.txt zu erstellen.

input_message = {"role": "user", "content": "Erstelle eine Datei namens sample-file.txt"}
response = agent.invoke({"messages": [input_message]})

for message in response["messages"]:
    message.pretty_print()

Bitte den Agenten schließlich, die Dateien erneut aufzulisten. Es wird nun angezeigt, dass sample-file.txt existiert.

input_message = {"role": "user", "content": "Liste die Dateien im aktuellen Arbeitsverzeichnis auf"}
response = agent.invoke({"messages": [input_message]})

for message in response["messages"]:
    message.pretty_print()

Wie du siehst, hat der Agent die natürlichsprachlichen Befehle erfolgreich interpretiert, die entsprechenden Werkzeuge aufgerufen (list_directory, write_file) und Rückmeldung zu den ausgeführten Aktionen gegeben. Dies ist eine grundlegende, aber leistungsstarke Demonstration, wie man einen KI-Agenten mit LangChain erstellt.

7. Hinzufügen von Speicher für deinen Agenten

Eine der wichtigsten Einschränkungen eines zustandslosen Agenten ist, dass er nach Abschluss eines Aufrufs den gesamten Kontext vergisst. Um einen konversationsfähigen Agenten zu erstellen, der sich an vergangene Interaktionen erinnert, musst du Speicher hinzufügen. Dies wird durch einen „Checkpointer" erreicht, der den Zustand des Agenten speichert.

LangGraph bietet eine MemorySaver-Klasse, einen einfachen In-Memory-Checkpointer. In einer Produktionsumgebung würdest du eine robustere Option wie PostgresSaver oder den MongoDB-basierten Checkpointer verwenden, aber MemorySaver ist perfekt zum Testen und für die Entwicklung.

Importiere und initialisiere zunächst den Checkpointer.

from langgraph.checkpoint.memory import MemorySaver

checkpointer = MemorySaver()

Erstelle als Nächstes deinen Agenten neu und übergib den checkpointer als Argument.

agent_with_memory = create_agent(
    model=model,
    tools=tools,
    checkpointer=checkpointer
)

Um den Speicher zu nutzen, musst du in der Konfiguration eine thread_id angeben. Diese thread_id fungiert als Gesprächs-ID und ermöglicht es dem Agenten, für jedes einzelne Gespräch einen separaten Speicher zu führen.

config = {"configurable": {"thread_id": "user-123"}}

agent_with_memory.invoke(
    {"messages": [{"role": "user", "content": "Mein Name ist Alice"}]},
    config=config
)

result = agent_with_memory.invoke(
    {"messages": [{"role": "user", "content": "Wie ist mein Name?"}]},
    config=config
)
# Der Agent antwortet: "Dein Name ist Alice."
print(result["messages"][-1].content)

Diese einfache Ergänzung ermöglicht es deinem Agenten, kontextbezogene Gespräche zu führen, was ihn viel intelligenter und nützlicher erscheinen lässt.

8. Jenseits der Grundlagen: Multi-Agenten-Systeme

Mit zunehmender Erfahrung wirst du auf Aufgaben stoßen, die für einen einzelnen Agenten zu komplex sind. LangChain unterstützt den Aufbau anspruchsvoller Multi-Agenten-Systeme, bei denen spezialisierte Agenten zusammenarbeiten, um Probleme zu lösen. Dies ist ein leistungsstarkes Architekturmuster für komplexe Workflows.

Subagenten ist ein Kern-Multi-Agenten-Muster, bei dem ein Haupt-Supervisor-Agent mehrere spezialisierte Subagenten koordiniert und sie als Werkzeuge aufruft. Ein Subagent könnte beispielsweise für die Recherche zuständig sein, ein anderer für die Inhaltserstellung und ein dritter für die Überprüfung der Arbeit.

Muster	Funktionsweise
Subagenten	Ein Hauptagent koordiniert Subagenten als Werkzeuge. Das gesamte Routing erfolgt über den Hauptagenten, der entscheidet, wann welcher Subagent aufgerufen wird.
Übergaben	Das Verhalten ändert sich dynamisch basierend auf dem Zustand, wobei ein Werkzeugaufruf einen Wechsel zu einem anderen Agenten oder einer anderen Konfiguration auslöst.
Fähigkeiten	Spezialisierte Prompts und Wissen werden bei Bedarf in den Kontext eines einzelnen Agenten geladen.
Router	Ein Routing-Schritt klassifiziert die Eingabe und leitet sie zur Verarbeitung an einen oder mehrere spezialisierte Agenten weiter.

Die Wahl des richtigen Musters ist entscheidend. Beispielsweise eignet sich eine Subagenten-Architektur hervorragend für die parallele Ausführung und verteilte Entwicklung, während ein Übergabemuster für wiederholte Benutzeranfragen in einem einzelnen Gespräch effizienter ist. Die Verwendung des Subagenten-Musters in einer persönlichen Assistentenanwendung ermöglicht eine Kontextisolierung – jeder Subagent arbeitet an einer Aufgabe in einem sauberen Kontextfenster, wodurch verhindert wird, dass der Speicher des Hauptagenten aufgebläht wird.

Quellen

1. Chris Tozzi. „Build an AI agent with LangChain in this beginner tutorial." TechTarget, Sep 2025.
2. „Quickstart" LangChain Offizielle Dokumentation.
3. „Multi-agent" LangChain Offizielle Dokumentation.
4. „Workflows and agents" LangChain Offizielle Dokumentation.
5. „langchain-fundamentals" LangChain Skills Dokumentation, GitHub.
6. „How to Build an AI Agent with LangChain and LangGraph: Build an Autonomous Starbucks Agent." freeCodeCamp, Dez 2025.
7. „Subagents" LangChain Offizielle Dokumentation.
8. „LangChain Python Tutorial: A Complete Guide for 2026." The JetBrains Blog, Mär 2026.

— Editorial Team