Multi-Agent mit LangGraph

LangGraph ist nicht nur für einzelne Agents — es ist das mächtigste Framework für Multi-Agent-Orchestration. Mehrere spezialisierte Agents arbeiten koordiniert zusammen, gesteuert durch einen State Graph.

Supervisor Pattern

Das häufigste Multi-Agent-Pattern: Ein Supervisor-Agent entscheidet, welcher Worker als nächstes aktiv wird:

from langgraph.graph import StateGraph, END

def supervisor_node(state: AgentState) -> dict:
    # LLM entscheidet, welcher Agent als nächstes dran ist
    response = supervisor_llm.invoke(
        f"Aktuelle Aufgabe: {state['task']}\n"
        f"Bisherige Ergebnisse: {state['results']}\n"
        f"Verfügbare Agents: researcher, analyst, writer\n"
        f"Welcher Agent soll als nächstes arbeiten? (oder FINISH)"
    )
    return {"next_agent": response.content}

Supervisor-Routing

graph = StateGraph(AgentState)
graph.add_node("supervisor", supervisor_node)
graph.add_node("researcher", researcher_node)
graph.add_node("analyst", analyst_node)
graph.add_node("writer", writer_node)

graph.add_conditional_edges("supervisor", route_to_agent, {
    "researcher": "researcher",
    "analyst": "analyst",
    "writer": "writer",
    "FINISH": END
})
# Jeder Worker geht zurück zum Supervisor
for worker in ["researcher", "analyst", "writer"]:
    graph.add_edge(worker, "supervisor")

Agent Handoffs

Bei Handoffs übergibt ein Agent die Kontrolle direkt an einen anderen, ohne Supervisor:

Shared State

Alle Agents teilen sich einen gemeinsamen State. Wichtige Design-Entscheidungen:

State-Schema definieren

class MultiAgentState(TypedDict):
    messages: Annotated[list, add_messages]
    task: str
    research_data: list[dict]
    analysis: dict
    draft: str
    next_agent: str
    iteration_count: int

State-Konflikte vermeiden

• Jeder Agent schreibt nur in seine eigenen State-Felder
• Shared Fields (z. B. messages) nutzen Reducer-Funktionen
• Iteration-Counter verhindert endlose Zyklen

Tool Delegation

Agents können Tools an andere Agents delegieren:

def researcher_node(state: MultiAgentState) -> dict:
    tools = [web_search, arxiv_search, database_query]
    agent = create_react_agent(llm, tools)
    result = agent.invoke({"messages": state["messages"]})
    return {"research_data": extract_data(result)}

Parallele Agent-Execution

LangGraph unterstützt parallele Ausführung über Fan-Out-Nodes:

graph.add_node("parallel_research", parallel_research_node)
# Mehrere Agents arbeiten gleichzeitig
# Ergebnisse werden im State zusammengeführt

Praxis-Tipp: Begrenzen Sie die Iteration-Tiefe (z. B. max 5 Zyklen). Ohne Limit kann ein Multi-Agent-System endlos kreisen — mit entsprechenden Kosten. Definieren Sie klare Exit-Bedingungen.