Einen AI Agent mit LangGraph bauen: Ein Tutorial Schritt für Schritt

LangGraph ist das Low-Level-Framework von LangChain, um zustandsbehaftete AI agents als expliziten Graphen aus Nodes und Edges zu bauen. Es gibt Ihnen direkte Kontrolle darüber, wie ein agent verzweigt, pausiert und den State über eine lang laufende Aufgabe hinweg bewahrt. Es ist der Code-Weg, zu dem Teams greifen, sobald eine Aufgabe bedingte Logik, mehrstufige Freigabeabläufe oder ein Memory braucht, das Tage statt eines einzelnen Gesprächs überdauert. Dieser Leitfaden behandelt, was LangGraph eigentlich ist, wie Sie es installieren, eine vollständige Build-Anleitung mit zwei funktionierenden Beispielen und wann es die richtige Plattform ist und wann eine Alternative.

Was LangGraph eigentlich ist

LangGraph ist ein Low-Level-Orchestrierungsframework und eine Runtime, um lang laufende, zustandsbehaftete agents zu bauen, zu verwalten und bereitzustellen. Es ist getrennt von den übergeordneten Abstraktionen von LangChain: LangChain liefert Modelle, Tools und vorgefertigte agent-Muster, LangGraph liefert die graphenbasierte Runtime darunter, in der Sie Nodes als Rechenschritte, Edges als Pfade dazwischen und ein gemeinsames State-Objekt definieren, das durch den gesamten Lauf fließt. Das ist eine bewusste Designentscheidung: vernünftige Standardwerte, wenn Sie wenig Kontrolle brauchen, ein expliziter Graph, wenn Sie mehr brauchen.

Der reale Produktiveinsatz untermauert das Angebot. Der eigene Beitrag von LangChain zu LangGraph in Produktion nennt Uber (großflächige Code-Migrationen auf seiner Entwicklerplattform), LinkedIn (ein AI-Recruiter, der Kandidatensuche und Ansprache automatisiert), Replit (ein Multi-Agent-System mit Human-in-the-Loop-Prüfung) und Elastic (Orchestrierung eines Netzwerks von agents zur Bedrohungserkennung in Echtzeit) als Produktivnutzer. Der Property-Management-Copilot von AppFolio, ebenfalls auf LangGraph gebaut, sparte seinen Property Managern mehr als 10 Stunden pro Woche und verdoppelte die Genauigkeit ihrer Entscheidungen, ein konkretes Ergebnis statt einer vagen Verbreitungsbehauptung.

Solche Einsätze werden zur Norm, nicht zur Ausnahme. Gartner prognostiziert, dass 40 % der Unternehmensanwendungen bis Ende 2026 aufgabenspezifische AI agents enthalten werden, gegenüber weniger als 5 % im Jahr 2025, und ein erheblicher Teil dieser Verschiebung findet in Frameworks statt, die speziell für Multi-Agent-Systeme gebaut sind, wie LangGraph. Dort kann ein Graph einen Orchestrator abbilden, der Arbeit an mehrere spezialisierte Nodes übergibt, statt dass ein Modell alles in einem einzigen Durchgang erledigt.

Das Vokabular von LangGraph, zugeordnet zu den 6 Bausteinen

Wenn Sie Wie Sie einen AI Agent bauen gelesen haben, kennen Sie die sechs Bausteine, die jeder agent braucht: Rolle, Tools, Regeln, Szenario-Playbook, Entscheidungslogik und Guardrails. LangGraph gibt jedem davon ein konkretes Zuhause im Code.

Nichts davon ist konzeptionell einzigartig an LangGraph. LangGraph ergänzt einen expliziten, einsehbaren Graphen statt einer Black-Box-Schleife, genau die Art von Kontrolle, nach der Sie laut No-code vs. Code bei AI agents greifen sollten, sobald die Logik einer Aufgabe wirklich individuell wird.

LangGraph installieren

pip install -U langgraph langchain

langgraph ist die Kernbibliothek für Graph und Runtime. langchain ergänzt create_agent, den aktuellen High-Level-Einstiegspunkt für einen Standard-agent mit Tool-Calling, der unter der Haube auf LangGraph läuft. Setzen Sie als Umgebungsvariable einen API-Schlüssel für Ihren Modellanbieter, und Sie können loslegen.

Der schnelle Weg: create_agent

Für einen einzelnen agent, der nur ein Modell, ein paar Tools und einen System-Prompt braucht, müssen Sie den Graphen nicht direkt anfassen:

from langchain.agents import create_agent

def get_account_status(company: str) -> str:
    """Look up a customer account's status by company name."""
    return f"{company}: active, plan tier Growth, renewal in 45 days."

agent = create_agent(
    model="claude-sonnet-4-6",
    tools=[get_account_status],
    system_prompt="You are a support assistant. Answer only from tool results, never guess.",
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "What's the status of Acme Corp's account?"}]}
)
print(result["messages"][-1].content)

Das ist dieselbe Mechanik wie in Wie AI agents Tools nutzen, auf die sich jede Plattform stützt: eine Funktion beschreiben, das Modell entscheiden lassen, wann es sie aufruft, und das Ergebnis zurückspeisen. create_agent hat den älteren Helfer create_react_agent von LangGraph als empfohlenen Startpunkt abgelöst, dieselbe Idee, sauberere API.

Eine Ebene tiefer: Ein eigener Graph mit bedingtem Routing

Der schnelle Weg deckt viel ab, kann aber nicht ausdrücken: „Tue X und verzweige dann nur zu einer menschlichen Prüfung, wenn ein Risiko markiert wird." Dafür bauen Sie den Graphen direkt. Hier ist ein vereinfachter Ablauf zur Vertragsprüfung, nah am Blueprint AI Contract Review Agent: einen Vertrag analysieren und dann je nach Ergebnis der Analyse an eine menschliche Prüfung weiterleiten oder automatisch freigeben.

from typing import TypedDict
from langgraph.graph import StateGraph, START, END
from langgraph.checkpoint.memory import InMemorySaver

class ReviewState(TypedDict):
    contract_text: str
    risk_flagged: bool
    summary: str

def analyze_contract(state: ReviewState) -> dict:
    # call the model here to extract terms and set risk_flagged
    return {"risk_flagged": True, "summary": "Non-standard liability cap on page 4."}

def route_on_risk(state: ReviewState) -> str:
    return "human_review" if state["risk_flagged"] else "auto_approve"

def human_review(state: ReviewState) -> dict:
    return {"summary": state["summary"] + " Routed to legal for review."}

def auto_approve(state: ReviewState) -> dict:
    return {"summary": state["summary"] + " Auto-approved, no flags."}

graph = StateGraph(ReviewState)
graph.add_node("analyze", analyze_contract)
graph.add_node("human_review", human_review)
graph.add_node("auto_approve", auto_approve)

graph.add_edge(START, "analyze")
graph.add_conditional_edges("analyze", route_on_risk, {
    "human_review": "human_review",
    "auto_approve": "auto_approve",
})
graph.add_edge("human_review", END)
graph.add_edge("auto_approve", END)

app = graph.compile(checkpointer=InMemorySaver())

add_conditional_edges ist der Baustein Entscheidungslogik, wörtlich umgesetzt: Nachdem analyze gelaufen ist, prüft route_on_risk den State und schickt die Ausführung auf einen von zwei benannten Pfaden. Das ist eine Verzweigung, die eine einzelne lineare Tool-Calling-Schleife nicht sauber ausdrücken kann, und der Grund, warum Teams zu LangGraph greifen, sobald Multi-Agent-Systeme oder mehrstufige Freigabeabläufe ins Spiel kommen.

Persistenz und Memory

Das Argument checkpointer bei compile() macht einen Graphen wiederaufnehmbar statt zustandslos. InMemorySaver, oben gezeigt, genügt für lokale Tests, verschwindet aber beim Neustart des Prozesses. Produktive Graphen nutzen stattdessen ein persistentes Backend: SQLite- oder Postgres-Checkpoint-Saver gibt es als separat installierbare Pakete, geschlüsselt über eine thread_id, sodass der State eines bestimmten Laufs Tage später neu geladen und fortgesetzt werden kann. Das ist dieselbe Unterscheidung zwischen Arbeits-Memory und persistentem Memory, die allgemein in AI agent Memory behandelt wird: Ein Checkpointer ist die konkrete Antwort von LangGraph auf persistentes Memory.

Human-in-the-Loop mit Interrupts

Die Funktion interrupt() von LangGraph pausiert die Graph-Ausführung an einer bestimmten Stelle und wartet auf externe Eingaben, bevor sie fortfährt. Genau das braucht der Node human_review oben in einer echten Implementierung statt der gezeigten Platzhalterlogik. Eine Person (oder ein anderes System) prüft den pausierten State und antwortet, und der Graph setzt genau an dieser Stelle mit dem Checkpoint-State fort, statt von vorn zu beginnen. Das ist der konkrete Mechanismus hinter den Freigabe-Gates, die allgemein in Human-in-the-Loop für AI agents behandelt werden: Der Graph rät nicht, wann ein Mensch eingreifen sollte, Sie verdrahten diese Entscheidung direkt in die Routing-Logik.

Guardrails und Tests vor dem Livegang

Eine bedingte Edge ist nur so gut wie die Logik, die entscheidet, wohin geroutet wird. Validieren Sie diese Logik also, bevor sie echte Verträge, Tickets oder Datensätze berührt. Fügen Sie explizite Prüfungen innerhalb eines Nodes ein (eine Ausgabe ablehnen oder wiederholen, die eine von Ihnen definierte Regel verletzt), statt allein dem Urteil des Modells zu vertrauen, die Disziplin aus AI agent Guardrails. Und erklären Sie einen Graphen nicht nach einem sauberen Testlauf für fertig. Wie Sie AI agents evaluieren und testen zeigt, wie Sie aus historischen Fällen ein echtes Test-Set aufbauen, auch aus den unübersichtlichen, die an eine menschliche Prüfung gehen sollten, bevor irgendein LangGraph-agent produktives Volumen berührt.

Kosten und Grenzen

LangGraph selbst ist kostenlos und Open Source. Bezahlen müssen Sie die Nutzung der LLM-API, und ein Graph mit mehr Nodes und mehr Verzweigungen macht mehr Modellaufrufe als ein einzelner, gut abgegrenzter agent bei derselben Aufgabe, derselbe Kompromiss wie in Multi-Agent-Systeme. Wenn Sie den Graphen lieber nicht selbst hosten und überwachen möchten, bietet LangChain auch LangGraph Platform an, eine kostenpflichtige gehostete Bereitstellungsoption mit integrierter Persistenz und Observability. Der Eigenbetrieb kostet nichts außer Ihrer eigenen Infrastruktur und den Modellaufrufen.

Die eigentliche Grenze ist nicht der Preis, sondern dass LangGraph weder einen visuellen Builder noch vorgefertigte App-Konnektoren mitbringt. Jede Integration, jede Retry-Richtlinie, jede Fehlerbehandlung ist Code, den Sie schreiben, der direkte Preis für die Kontrolle, die ein Graph gegenüber der begrenzten Logik einer No-code-Plattform bietet.

Wann LangGraph, wann die Alternativen

Key Facts

• LangGraph ist ein Low-Level-Orchestrierungsframework und eine Runtime unter Open-Source-Lizenz für zustandsbehaftete agents, getrennt von den übergeordneten Abstraktionen von LangChain, aber ergänzend dazu.
• Dokumentierte Produktivnutzer sind Uber, LinkedIn, Replit und Elastic. Der mit LangGraph gebaute Copilot von AppFolio sparte Property Managern mehr als 10 Stunden pro Woche und verdoppelte die Entscheidungsgenauigkeit.
• create_agent im Paket langchain ist der aktuell empfohlene High-Level-Einstiegspunkt, löst den älteren Helfer create_react_agent ab und läuft auf LangGraph.
• StateGraph mit add_conditional_edges lässt einen agent anhand seiner eigenen Ausgabe verzweigen, die Mechanik hinter Freigabeabläufen und mehrstufiger Entscheidungslogik.
• Ein checkpointer (In-Memory zum Testen, SQLite oder Postgres in Produktion) macht einen Graphen über Sitzungen hinweg wiederaufnehmbar, geschlüsselt über thread_id.

Wie es weitergeht

LangGraph ist ein Code-Weg zu einem funktionierenden agent, nicht der einzige. Einen AI Agent mit CrewAI bauen behandelt ein stärker rollenbasiertes Framework für Multi-Agent-Arbeit, und wenn Sie noch grundsätzlich zwischen Code und einem visuellen Builder entscheiden, führt Die Wahl einer AI-agent-Plattform direkt durch diese Entscheidung über No-code-, Framework- und Managed-Optionen. Sobald ein Graph im Test zuverlässig läuft, behandelt AI agents in die Produktion bringen den Rollout und den Rollback-Plan, bevor er echtes Volumen berührt. Die Übersicht zu Dev-Tools und der Kaufleitfaden für AI-Coding-Assistenten sind sinnvolle nächste Stationen, um den Code selbst schneller zu schreiben und zu pflegen.