LangGraph

1---
2name: langgraph
3description: "Expert in LangGraph - the production-grade framework for building stateful, multi-actor AI applications. Covers graph construction, state management, cycles and branches, persistence with checkpointers, human-in-the-loop patterns, and the ReAct agent pattern. Used in production at LinkedIn, Uber, and 400+ companies. This is LangChain's recommended approach for building agents. Use when: langgraph, langchain agent, stateful agent, agent graph, react agent."
4source: vibeship-spawner-skills (Apache 2.0)
5---
6 
7# LangGraph
8 
9**Role**: LangGraph Agent Architect
10 
11You are an expert in building production-grade AI agents with LangGraph. You
12understand that agents need explicit structure - graphs make the flow visible
13and debuggable. You design state carefully, use reducers appropriately, and
14always consider persistence for production. You know when cycles are needed
15and how to prevent infinite loops.
16 
17## Capabilities
18 
19- Graph construction (StateGraph)
20- State management and reducers
21- Node and edge definitions
22- Conditional routing
23- Checkpointers and persistence
24- Human-in-the-loop patterns
25- Tool integration
26- Streaming and async execution
27 
28## Requirements
29 
30- Python 3.9+
31- langgraph package
32- LLM API access (OpenAI, Anthropic, etc.)
33- Understanding of graph concepts
34 
35## Patterns
36 
37### Basic Agent Graph
38 
39Simple ReAct-style agent with tools
40 
41**When to use**: Single agent with tool calling
42 
43```python
44from typing import Annotated, TypedDict
45from langgraph.graph import StateGraph, START, END
46from langgraph.graph.message import add_messages
47from langgraph.prebuilt import ToolNode
48from langchain_openai import ChatOpenAI
49from langchain_core.tools import tool
50 
51# 1. Define State
52class AgentState(TypedDict):
53    messages: Annotated[list, add_messages]
54    # add_messages reducer appends, doesn't overwrite
55 
56# 2. Define Tools
57@tool
58def search(query: str) -> str:
59    """Search the web for information."""
60    # Implementation here
61    return f"Results for: {query}"
62 
63@tool
64def calculator(expression: str) -> str:
65    """Evaluate a math expression."""
66    return str(eval(expression))
67 
68tools = [search, calculator]
69 
70# 3. Create LLM with tools
71llm = ChatOpenAI(model="gpt-4o").bind_tools(tools)
72 
73# 4. Define Nodes
74def agent(state: AgentState) -> dict:
75    """The agent node - calls LLM."""
76    response = llm.invoke(state["messages"])
77    return {"messages": [response]}
78 
79# Tool node handles tool execution
80tool_node = ToolNode(tools)
81 
82# 5. Define Routing
83def should_continue(state: AgentState) -> str:
84    """Route based on whether tools were called."""
85    last_message = state["messages"][-1]
86    if last_message.tool_calls:
87        return "tools"
88    return END
89 
90# 6. Build Graph
91graph = StateGraph(AgentState)
92 
93# Add nodes
94graph.add_node("agent", agent)
95graph.add_node("tools", tool_node)
96 
97# Add edges
98graph.add_edge(START, "agent")
99graph.add_conditional_edges("agent", should_continue, ["tools", END])
100graph.add_edge("tools", "agent")  # Loop back
101 
102# Compile
103app = graph.compile()
104 
105# 7. Run
106result = app.invoke({
107    "messages": [("user", "What is 25 * 4?")]
108})
109```
110 
111### State with Reducers
112 
113Complex state management with custom reducers
114 
115**When to use**: Multiple agents updating shared state
116 
117```python
118from typing import Annotated, TypedDict
119from operator import add
120from langgraph.graph import StateGraph
121 
122# Custom reducer for merging dictionaries
123def merge_dicts(left: dict, right: dict) -> dict:
124    return {**left, **right}
125 
126# State with multiple reducers
127class ResearchState(TypedDict):
128    # Messages append (don't overwrite)
129    messages: Annotated[list, add_messages]
130 
131    # Research findings merge
132    findings: Annotated[dict, merge_dicts]
133 
134    # Sources accumulate
135    sources: Annotated[list[str], add]
136 
137    # Current step (overwrites - no reducer)
138    current_step: str
139 
140    # Error count (custom reducer)
141    errors: Annotated[int, lambda a, b: a + b]
142 
143# Nodes return partial state updates
144def researcher(state: ResearchState) -> dict:
145    # Only return fields being updated
146    return {
147        "findings": {"topic_a": "New finding"},
148        "sources": ["source1.com"],
149        "current_step": "researching"
150    }
151 
152def writer(state: ResearchState) -> dict:
153    # Access accumulated state
154    all_findings = state["findings"]
155    all_sources = state["sources"]
156 
157    return {
158        "messages": [("assistant", f"Report based on {len(all_sources)} sources")],
159        "current_step": "writing"
160    }
161 
162# Build graph
163graph = StateGraph(ResearchState)
164graph.add_node("researcher", researcher)
165graph.add_node("writer", writer)
166# ... add edges
167```
168 
169### Conditional Branching
170 
171Route to different paths based on state
172 
173**When to use**: Multiple possible workflows
174 
175```python
176from langgraph.graph import StateGraph, START, END
177 
178class RouterState(TypedDict):
179    query: str
180    query_type: str
181    result: str
182 
183def classifier(state: RouterState) -> dict:
184    """Classify the query type."""
185    query = state["query"].lower()
186    if "code" in query or "program" in query:
187        return {"query_type": "coding"}
188    elif "search" in query or "find" in query:
189        return {"query_type": "search"}
190    else:
191        return {"query_type": "chat"}
192 
193def coding_agent(state: RouterState) -> dict:
194    return {"result": "Here's your code..."}
195 
196def search_agent(state: RouterState) -> dict:
197    return {"result": "Search results..."}
198 
199def chat_agent(state: RouterState) -> dict:
200    return {"result": "Let me help..."}
201 
202# Routing function
203def route_query(state: RouterState) -> str:
204    """Route to appropriate agent."""
205    query_type = state["query_type"]
206    return query_type  # Returns node name
207 
208# Build graph
209graph = StateGraph(RouterState)
210 
211graph.add_node("classifier", classifier)
212graph.add_node("coding", coding_agent)
213graph.add_node("search", search_agent)
214graph.add_node("chat", chat_agent)
215 
216graph.add_edge(START, "classifier")
217 
218# Conditional edges from classifier
219graph.add_conditional_edges(
220    "classifier",
221    route_query,
222    {
223        "coding": "coding",
224        "search": "search",
225        "chat": "chat"
226    }
227)
228 
229# All agents lead to END
230graph.add_edge("coding", END)
231graph.add_edge("search", END)
232graph.add_edge("chat", END)
233 
234app = graph.compile()
235```
236 
237## Anti-Patterns
238 
239### ❌ Infinite Loop Without Exit
240 
241**Why bad**: Agent loops forever.
242Burns tokens and costs.
243Eventually errors out.
244 
245**Instead**: Always have exit conditions:
246- Max iterations counter in state
247- Clear END conditions in routing
248- Timeout at application level
249 
250def should_continue(state):
251    if state["iterations"] > 10:
252        return END
253    if state["task_complete"]:
254        return END
255    return "agent"
256 
257### ❌ Stateless Nodes
258 
259**Why bad**: Loses LangGraph's benefits.
260State not persisted.
261Can't resume conversations.
262 
263**Instead**: Always use state for data flow.
264Return state updates from nodes.
265Use reducers for accumulation.
266Let LangGraph manage state.
267 
268### ❌ Giant Monolithic State
269 
270**Why bad**: Hard to reason about.
271Unnecessary data in context.
272Serialization overhead.
273 
274**Instead**: Use input/output schemas for clean interfaces.
275Private state for internal data.
276Clear separation of concerns.
277 
278## Limitations
279 
280- Python-only (TypeScript in early stages)
281- Learning curve for graph concepts
282- State management complexity
283- Debugging can be challenging
284 
285## Related Skills
286 
287Works well with: `crewai`, `autonomous-agents`, `langfuse`, `structured-output`
288