„Der Chatbot gibt mal wieder wirre Antworten, weil er den Kontext verloren hat“ – ein Satz, den ihr vermutlich schon mehr als einmal gehört habt. Die Entwicklung von KI-Agenten, die tatsächlich komplexe, mehrstufige Aufgaben zuverlässig erledigen können, ist eine echte Herausforderung. Mit LangGraph gibt es ein Open-Source-Framework, das genau dieses Problem löst: Es ermöglicht euch, robuste KI-Workflows als gerichtete Graphen zu modellieren, mit vollständiger Kontrolle über den Zustandsfluss.
Bei Never Code Alone beschäftigen wir uns seit über 15 Jahren mit Softwarequalität, Open Source und Remote Consulting. In diesem Artikel zeigen wir euch, wie ihr LangGraph effektiv einsetzt, welche Fallstricke ihr vermeiden solltet und wie ihr eure ersten produktionsreifen KI-Agenten entwickelt.
Warum graphbasierte Agenten für komplexe Workflows unverzichtbar sind
Klassische LLM-Anwendungen stoßen schnell an ihre Grenzen, wenn es um mehrstufige Entscheidungen, Schleifen oder bedingte Verzweigungen geht. Ein Chatbot, der nicht nur antwortet, sondern eigenständig recherchiert, Daten validiert und bei Bedarf nachfragt, braucht eine strukturierte Ablaufsteuerung. LangGraph bietet genau das: eine deklarative Möglichkeit, komplexe Agenten-Workflows als Zustandsmaschinen zu modellieren.
1. Was ist LangGraph und wofür wird es verwendet?
LangGraph ist ein Python-Framework von LangChain, das euch ermöglicht, Large Language Model-Anwendungen als gerichtete Graphen zu strukturieren. Statt linearer Prompts definiert ihr Nodes (Verarbeitungsschritte) und Edges (Übergänge), die den Datenfluss steuern. Der entscheidende Vorteil: Ihr behaltet die volle Kontrolle über jeden Schritt eures Agenten und könnt komplexe Entscheidungslogik abbilden.
from langgraph.graph import StateGraph, START, END
from typing import TypedDict
class AgentState(TypedDict):
messages: list
current_step: str
# Graph erstellen
workflow = StateGraph(AgentState)
workflow.add_node("analyze", analyze_input)
workflow.add_node("respond", generate_response)
workflow.add_edge(START, "analyze")
workflow.add_edge("analyze", "respond")
workflow.add_edge("respond", END)
app = workflow.compile()Mit diesem Ansatz könnt ihr Agenten bauen, die nicht einfach nur reagieren, sondern aktiv planen und ihre Strategie bei Bedarf anpassen.
2. Wie unterscheidet sich LangGraph von LangChain?
Diese Frage kommt in fast jedem Consulting-Gespräch. LangChain ist ein allgemeines Framework für LLM-Anwendungen mit Fokus auf Chains und Prompts. LangGraph erweitert LangChain um einen graphbasierten Ansatz, der speziell für Agenten optimiert ist. Der Hauptunterschied: LangChain-Chains sind linear, LangGraph-Graphen können Schleifen, Verzweigungen und parallele Ausführung abbilden.
In der Praxis bedeutet das: Nutzt LangChain für einfache RAG-Pipelines und Prompt-Chains. Sobald euer Agent Entscheidungen treffen, auf Ergebnisse reagieren oder mehrere Schritte iterativ durchlaufen muss, ist LangGraph die bessere Wahl.
3. Wie erstellt man einen einfachen Graphen mit LangGraph?
Der Einstieg in LangGraph beginnt mit der Installation und der Definition eures State-Schemas. Hier ein vollständiges Beispiel für einen Recherche-Agenten:
pip install langgraph langchain-openaifrom langgraph.graph import StateGraph, START, END
from typing import TypedDict, Annotated
from operator import add
class ResearchState(TypedDict):
query: str
sources: Annotated[list, add]
answer: str
def search_sources(state: ResearchState) -> dict:
# Hier eure Suchlogik
return {"sources": ["Quelle 1", "Quelle 2"]}
def synthesize_answer(state: ResearchState) -> dict:
sources = state["sources"]
# LLM-Aufruf zur Synthese
return {"answer": f"Basierend auf {len(sources)} Quellen..."}
# Graph aufbauen
graph = StateGraph(ResearchState)
graph.add_node("search", search_sources)
graph.add_node("synthesize", synthesize_answer)
graph.add_edge(START, "search")
graph.add_edge("search", "synthesize")
graph.add_edge("synthesize", END)
agent = graph.compile()
result = agent.invoke({"query": "Was ist LangGraph?"})4. Was sind Nodes und Edges in LangGraph und wie definiere ich sie?
Nodes sind die Verarbeitungseinheiten eures Graphen – Funktionen, die einen Teil des States lesen und einen neuen Teilzustand zurückgeben. Edges definieren die Übergänge zwischen Nodes. LangGraph unterscheidet zwischen normalen Edges (feste Übergänge) und conditional Edges (bedingte Übergänge basierend auf dem State).
from langgraph.graph import StateGraph
def router(state: dict) -> str:
"""Entscheidet, welcher Node als nächstes ausgeführt wird."""
if state.get("needs_clarification"):
return "ask_user"
elif state.get("has_tools"):
return "execute_tools"
return "respond"
graph = StateGraph(MyState)
graph.add_conditional_edges(
"analyze",
router,
{
"ask_user": "clarification_node",
"execute_tools": "tool_node",
"respond": "response_node"
}
)Diese Flexibilität ermöglicht euch, komplexe Entscheidungsbäume abzubilden, ohne in verschachtelten if-else-Strukturen zu versinken.
5. Wie funktioniert State Management in LangGraph?
Das State Management ist das Herzstück von LangGraph. Der State ist ein typisiertes Dictionary, das zwischen allen Nodes geteilt wird. Jeder Node empfängt den aktuellen State und gibt einen Partial-State zurück, der mit dem bestehenden State gemergt wird.
from typing import TypedDict, Annotated
from operator import add
class ConversationState(TypedDict):
messages: Annotated[list, add] # Wird appendiert
context: str # Wird überschrieben
step_count: int # Wird überschrieben
def process_message(state: ConversationState) -> dict:
# Nur die Felder zurückgeben, die sich ändern
return {
"messages": [{"role": "assistant", "content": "Antwort"}],
"step_count": state["step_count"] + 1
}Besonders wichtig: Der Annotated-Typ mit Reducern wie add ermöglicht es, Listen-States zu akkumulieren statt zu überschreiben – essentiell für Conversation-Histories.
6. Wie implementiere ich Human-in-the-Loop mit LangGraph?
Human-in-the-Loop ist einer der häufigsten Anwendungsfälle in Enterprise-Projekten. LangGraph bietet hierfür Interrupts und Checkpoints. Der Agent pausiert an definierten Stellen, wartet auf menschliche Eingabe und setzt dann fort.
from langgraph.checkpoint.memory import MemorySaver
from langgraph.graph import StateGraph, END
def should_continue(state: dict) -> str:
if state.get("needs_approval"):
return "human_approval"
return "execute"
graph = StateGraph(MyState)
graph.add_node("analyze", analyze_task)
graph.add_node("human_approval", lambda s: s) # Pause-Node
graph.add_node("execute", execute_task)
graph.add_conditional_edges("analyze", should_continue)
graph.add_edge("human_approval", "execute")
# Mit Checkpointing kompilieren
checkpointer = MemorySaver()
app = graph.compile(checkpointer=checkpointer, interrupt_before=["human_approval"])
# Erste Ausführung
config = {"configurable": {"thread_id": "task-123"}}
result = app.invoke({"task": "Daten löschen"}, config)
# Nach menschlicher Genehmigung fortsetzen
app.invoke({"approved": True}, config)7. Wie funktioniert die Checkpoint-Persistenz für langlebige Agenten?
Für produktionsreife Anwendungen braucht ihr persistente Checkpoints. LangGraph unterstützt verschiedene Backends, von In-Memory für Tests bis PostgreSQL für Produktionsumgebungen.
from langgraph.checkpoint.postgres import PostgresSaver
# PostgreSQL-Verbindung
DB_URI = "postgresql://user:pass@localhost/langgraph"
checkpointer = PostgresSaver.from_conn_string(DB_URI)
# Graph mit Persistenz kompilieren
app = graph.compile(checkpointer=checkpointer)
# Jede Conversation hat eine eindeutige Thread-ID
config = {"configurable": {"thread_id": "user-session-abc123"}}
# Gespräch nach Serverrestart fortsetzen
state = app.get_state(config)
print(f"Letzter Schritt: {state.values.get('current_step')}")So könnt ihr Agenten bauen, die über Tage oder Wochen an komplexen Aufgaben arbeiten, ohne den Kontext zu verlieren.
8. Was sind die Best Practices für parallele Tool-Ausführung?
Ein häufiges Pattern in LangGraph-Projekten: Der Agent muss mehrere Tools gleichzeitig aufrufen. LangGraph unterstützt parallele Ausführung über den ToolNode und Map-Reduce-Patterns.
from langgraph.prebuilt import ToolNode
from langchain_core.tools import tool
@tool
def search_web(query: str) -> str:
"""Durchsucht das Web nach Informationen."""
return f"Ergebnis für: {query}"
@tool
def search_database(query: str) -> str:
"""Durchsucht die interne Datenbank."""
return f"DB-Ergebnis für: {query}"
# ToolNode führt Tools parallel aus
tools = [search_web, search_database]
tool_node = ToolNode(tools)
graph = StateGraph(AgentState)
graph.add_node("agent", agent_node)
graph.add_node("tools", tool_node)
graph.add_edge("agent", "tools")
graph.add_conditional_edges("tools", should_continue)Wichtig: Bei paralleler Ausführung mit Interrupts können identische IDs entstehen – ein bekanntes Issue, das ihr durch explizite ID-Vergabe lösen könnt.
9. Wie debugge ich LangGraph-Workflows effektiv?
Debugging ist bei komplexen Agenten-Workflows entscheidend. LangGraph bietet Streaming und LangGraph Studio für Visualisierung.
# Streaming für Echtzeit-Debugging
for event in app.stream({"query": "Test"}, config, stream_mode="values"):
print(f"Node: {event.get('current_node')}")
print(f"State: {event}")
# Detailliertes Logging
import logging
logging.getLogger("langgraph").setLevel(logging.DEBUG)
# Graph visualisieren
from IPython.display import Image
Image(app.get_graph().draw_mermaid_png())Für lokale Entwicklung empfehlen wir LangGraph Studio – eine Desktop-App, die euren Graphen visualisiert und Step-by-Step-Debugging ermöglicht.
10. Wie deploye ich einen LangGraph-Agenten in der Produktion?
Der Weg in die Produktion führt über LangGraph Platform oder Self-Hosting. Hier ein Docker-basierter Ansatz:
# langgraph.json
{
"graphs": {
"agent": "./agent.py:app"
},
"env": ".env"
}# Dockerfile
FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["langgraph", "serve", "--host", "0.0.0.0", "--port", "8000"]# Lokaler Test mit langgraph-cli
pip install langgraph-cli
langgraph dev
# Produktion
docker build -t my-agent .
docker run -p 8000:8000 my-agentLangGraph Platform bietet zusätzlich Managed Hosting mit automatischer Skalierung – ideal für Teams, die sich auf die Agentenlogik konzentrieren wollen.
Fazit: LangGraph als Fundament für produktionsreife KI-Agenten
LangGraph löst ein fundamentales Problem der KI-Entwicklung: die strukturierte Orchestrierung komplexer Agenten-Workflows. Mit dem graphbasierten Ansatz behaltet ihr die Kontrolle über jeden Schritt, könnt Human-in-the-Loop sauber implementieren und eure Agenten zuverlässig in Produktion betreiben.
Das Framework hat sich mit über 23.000 GitHub-Stars als Standard für anspruchsvolle LLM-Anwendungen etabliert. Die Lernkurve ist überschaubar, wenn ihr bereits Erfahrung mit Python und LangChain habt.
Unterstützung für euer LangGraph-Projekt
Ihr plant einen KI-Agenten mit LangGraph und braucht Unterstützung bei Architektur, Implementierung oder Code-Review? Bei Never Code Alone begleiten wir euch von der ersten Idee bis zum produktionsreifen Deployment. Mit über 15 Jahren Erfahrung in Softwarequalität und Open-Source-Projekten wissen wir, worauf es ankommt.
Schreibt einfach eine E-Mail an roland@nevercodealone.de – wir melden uns zeitnah bei euch.
