langgraph-agent-patterns
Implement multi-agent coordination patterns (supervisor-subagent, router, orchestrator-worker, handoffs) for LangGraph applications. Use when users want to (1) implement multi-agent systems, (2) coordinate multiple specialized agents, (3) choose between coordination patterns, (4) set up supervisor-subagent workflows, (5) implement router-based agent selection, (6) create parallel orchestrator-worker patterns, (7) implement agent handoffs, (8) design state schemas for multi-agent systems, or (9) debug multi-agent coordination issues.
soba-labs · 已有 AI 审核记录
安装与使用
运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。
npx skills add soba-labs/langchain-agent-skills --skill langgraph-agent-patterns技能说明
name: langgraph-agent-patterns description: Implement multi-agent coordination patterns (supervisor-subagent, router, orchestrator-worker, handoffs) for LangGraph applications. Use when users want to (1) implement multi-agent systems, (2) coordinate multiple specialized agents, (3) choose between coordination patterns, (4) set up supervisor-subagent workflows, (5) implement router-based agent selection, (6) create parallel orchestrator-worker patterns, (7) implement agent handoffs, (8) design state schemas for multi-agent systems, or (9) debug multi-agent coordination issues.
LangGraph Agent Patterns
Implement and configure multi-agent coordination patterns for LangGraph applications.
Pattern Selection
Choose the right pattern based on your coordination needs:
| Pattern | Best For | When to Use |
|---|---|---|
| Supervisor | Complex workflows, dynamic routing | Agents need to collaborate, routing is context-dependent |
| Router | Simple categorization, independent tasks | One-time routing, deterministic decisions |
| Orchestrator-Worker | Parallel execution, high throughput | Independent subtasks, results need aggregation |
| Handoffs | Sequential workflows, context preservation | Clear sequence, each agent builds on previous |
Quick Decision:
- Dynamic routing needed? → Supervisor
- Tasks can run in parallel? → Orchestrator-Worker
- Simple categorization? → Router
- Linear sequence? → Handoffs
For detailed comparison: See references/pattern-comparison.md
Pattern Implementation Guides
Supervisor-Subagent Pattern
Overview: Central coordinator delegates to specialized subagents based on context.
Quick Start:
# Generate supervisor graph boilerplate
uv run scripts/generate_supervisor_graph.py my-team \
--subagents "researcher,writer,reviewer"
# TypeScript
uv run scripts/generate_supervisor_graph.py my-team \
--subagents "researcher,writer,reviewer" \
--typescript
Key Components:
- State with routing:
nextfield for routing decisions - Supervisor node: Makes routing decisions based on context
- Subagent nodes: Specialized agents with distinct capabilities
- Conditional edges: Route from supervisor to subagents
Example Flow:
User Request → Supervisor → Researcher → Supervisor → Writer → Supervisor → FINISH
For complete implementation: See references/supervisor-subagent.md
Router Pattern
Overview: One-time routing to specialized agents based on initial request.
Key Components:
- State with route: Single routing decision field
- Router node: Categorizes request (keyword, LLM, or semantic)
- Specialized agents: Independent agents for each category
- Conditional routing: Route to agent, then END
Example Flow:
User Request → Router → Sales Agent → END
├→ Support Agent → END
└→ Billing Agent → END
Routing Strategies:
- Keyword-based: Fast, simple string matching
- LLM-based: Semantic understanding, flexible
- Embedding-based: Similarity matching
- Model-based: Fine-tuned classifier
For complete implementation: See references/router-pattern.md
Orchestrator-Worker Pattern
Overview: Decompose task into parallel subtasks, aggregate results.
Key Components:
- State with subtasks: Task decomposition and results accumulation
- Orchestrator node: Splits task into independent subtasks
- Worker nodes: Process subtasks in parallel
- Aggregator node: Synthesizes results
- Send fan-out: Return
Send(...)objects from conditional edges and use a list reducer (for exampleAnnotated[list[dict], operator.add]) so worker outputs accumulate
Example Flow:
Task → Orchestrator → Worker 1 ┐
→ Worker 2 ├→ Aggregator → Result
→ Worker 3 ┘
Best Practices:
- Ensure subtasks are independent
- Handle worker failures gracefully
- Limit concurrent workers for resource management
- Use LLM for result synthesis
For complete implementation: See references/orchestrator-worker.md
Handoffs Pattern
Overview: Sequential agent handoffs with context preservation.
Key Components:
- State with context: Shared context across handoffs
- Agent nodes: Each agent hands off to next
- Handoff logic: Explicit or conditional handoffs
- Context management: Preserve and pass information
Example Flow:
Request → Researcher → Writer → Editor → FINISH
(with context preservation)
Handoff Strategies:
- Explicit: Agent declares next agent
- Conditional: Based on completion criteria
- Circular: Agents can hand back for revisions
For complete implementation: See references/handoffs.md
Examples
Runnable mini-projects (Python + JavaScript):
assets/examples/supervisor-example/assets/examples/router-example/assets/examples/orchestrator-example/assets/examples/handoff-example/
State Design for Multi-Agent Patterns
Each pattern requires specific state schema design:
Supervisor Pattern:
class SupervisorState(TypedDict):
messages: Annotated[list[BaseMessage], add_messages]
next: Literal["agent1", "agent2", "FINISH"]
current_agent: str
Router Pattern:
class RouterState(TypedDict):
messages: list[BaseMessage]
route: Literal["category1", "category2"]
Orchestrator-Worker:
import operator
class OrchestratorState(TypedDict):
task: str
subtasks: list[dict]
results: Annotated[list[dict], operator.add]
Handoffs:
class HandoffState(TypedDict):
messages: Annotated[list[BaseMessage], add_messages]
next_agent: str
context: dict
For detailed state patterns: See references/state-management-patterns.md
Validation and Visualization
Validate Graph Structure
# Validate
阅读完整来源 ↗