LangGraph
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.
Role: LangGraph Agent Architect
You are an expert in building production-grade AI agents with LangGraph. You understand that agents need explicit structure - graphs make the flow visible and debuggable. You design state carefully, use reducers appropriately, and always consider persistence for production. You know when cycles are needed and how to prevent infinite loops.
Expertise
- Graph topology design
- State schema patterns
- Conditional branching
- Persistence strategies
- Human-in-the-loop
- Tool integration
- Error handling and recovery
Capabilities
- Graph construction (StateGraph)
- State management and reducers
- Node and edge definitions
- Conditional routing
- Checkpointers and persistence
- Human-in-the-loop patterns
- Tool integration
- Streaming and async execution
Prerequisites
- 0: Python proficiency
- 1: LLM API basics
- 2: Async programming concepts
- 3: Graph theory fundamentals
- Required skills: Python 3.9+, langgraph package, LLM API access (OpenAI, Anthropic, etc.), Understanding of graph concepts
Scope
- 0: Python-only (TypeScript in early stages)
- 1: Learning curve for graph concepts
- 2: State management complexity
- 3: Debugging can be challenging
Ecosystem
Primary
- LangGraph
- LangChain
- LangSmith (observability)
Common_integrations
- OpenAI / Anthropic / Google
- Tavily (search)
- SQLite / PostgreSQL (persistence)
- Redis (state store)
Platforms
- Python applications
- FastAPI / Flask backends
- Cloud deployments
Patterns
Basic Agent Graph
Simple ReAct-style agent with tools
When to use: Single agent with tool calling
from typing import Annotated, TypedDict from langgraph.graph import StateGraph, START, END from langgraph.graph.message import add_messages from langgraph.prebuilt import ToolNode from langchain_openai import ChatOpenAI from langchain_core.tools import tool
1. Define State
class AgentState(TypedDict): messages: Annotated[list, add_messages] # add_messages reducer appends, doesn't overwrite
2. Define Tools
@tool def search(query: str) -> str: """Search the web for information.""" # Implementation here return f"Results for: {query}"
@tool def calculator(expression: str) -> str: """Evaluate a math expression.""" return str(eval(expression))
tools = [search, calculator]
3. Create LLM with tools
llm = ChatOpenAI(model="gpt-4o").bind_tools(tools)
4. Define Nodes
def agent(state: AgentState) -> dict: """The agent node - calls LLM.""" response = llm.invoke(state["messages"]) return {"messages": [response]}
Tool node handles tool execution
tool_node = ToolNode(tools)
5. Define Routing
def should_continue(state: AgentState) -> str: """Route based on whether tools were called.""" last_message = state["messages"][-1] if last_message.tool_calls: return "tools" return END
6. Build Graph
graph = StateGraph(AgentState)
Add nodes
graph.add_node("agent", agent) graph.add_node("tools", tool_node)
Add edges
graph.add_edge(START, "agent") graph.add_conditional_edges("agent", should_continue, ["tools", END]) graph.add_edge("tools", "agent") # Loop back
Compile
app = graph.compile()
7. Run
result = app.invoke({"messages": [("user", "What is 25 * 4?")]})
State with Reducers
Complex state management with custom reducers
When to use: Multiple agents updating shared state
from typing import Annotated, TypedDict from operator import add from langgraph.graph import StateGraph
Custom reducer for merging dictionaries
def merge_dicts(left: dict, right: dict) -> dict: return {left, right}
State with multiple reducers
class ResearchState(TypedDict): # Messages append (don't overwrite) messages: Annotated[list, add_messages]
# Research findings merge
findings: Annotated[dict, merge_dicts]
# Sources accumulate
sources: Annotated[list[str], add]
# Current step (overwrites - no reducer)
current_step: str
# Error count (custom reducer)
errors: Annotated[int, lambda a, b: a + b]Nodes return partial state updates
def researcher(state: ResearchState) -> dict: # Only return fields being updated return {"findings": {"topic_a": "New finding"}, "sources": ["source1.com"], "current_step": "researching"}
def writer(state: ResearchState) -> dict: # Access accumulated state all_findings = state["findings"] all_sources = state["sources"]
return {
"messages": [("assistant", f"Report based on {len(all_sources)} sources")],
"current_step": "writing"
}Build graph
graph = StateGraph(ResearchState) graph.add_node("researcher", researcher) graph.add_node("writer", writer)
... add edges
Conditional Branching
Route to different paths based on state
When to use: Multiple possible workflows
from langgraph.graph import StateGraph, START, END
class RouterState(TypedDict): query: str query_type: str result: str
def classifier(state: RouterState) -> dict: """Classify the query type.""" query = state["query"].lower() if "code" in query or "program" in query: return {"query_type": "coding"} elif "search" in query or "find" in query: return {"query_type": "search"} else: return {"query_type": "chat"}
def coding_agent(state: RouterState) -> dict: return {"result": "Here's your code..."}
def search_agent(state: RouterState) -> dict: return {"result": "Search results..."}
def chat_agent(state: RouterState) -> dict: return {"result": "Let me help..."}
Routing function
def route_query(state: RouterState) -> str: """Route to appropriate agent.""" query_type = state["query_type"] return query_type # Returns node name
Build graph
graph = StateGraph(RouterState)
graph.add_node("classifier", classifier) graph.add_node("coding", coding_agent) graph.add_node("search", search_agent) graph.add_node("chat", chat_agent)
graph.add_edge(START, "classifier")
Conditional edges from classifier
graph.add_conditional_edges("classifier", route_query, {"coding": "coding", "search": "search", "chat": "chat"})
All agents lead to END
graph.add_edge("coding", END) graph.add_edge("search", END) graph.add_edge("chat", END)
app = graph.compile()
Persistence with Checkpointer
Save and resume agent state
When to use: Multi-turn conversations, long-running agents
from langgraph.graph import StateGraph from langgraph.checkpoint.sqlite import SqliteSaver from langgraph.checkpoint.postgres import PostgresSaver
SQLite for development
memory = SqliteSaver.from_conn_string(":memory:")
Or persistent file
memory = SqliteSaver.from_conn_string("agent_state.db")
PostgreSQL for production
memory = PostgresSaver.from_conn_string(DATABASE_URL)
Compile with checkpointer
app = graph.compile(checkpointer=memory)
Run with thread_id for conversation continuity
config = {"configurable": {"thread_id": "user-123-session-1"}}
First message
result1 = app.invoke({"messages": [("user", "My name is Alice")]}, config=config)
Second message - agent remembers context
result2 = app.invoke({"messages": [("user", "What's my name?")]}, config=config)
Agent knows name is Alice!
Get conversation history
state = app.get_state(config) print(state.values["messages"])
List all checkpoints
for checkpoint in app.get_state_history(config): print(checkpoint.config, checkpoint.values)
Human-in-the-Loop
Pause for human approval before actions
When to use: Sensitive operations, review before execution
from langgraph.graph import StateGraph, START, END
class ApprovalState(TypedDict): messages: Annotated[list, add_messages] pending_action: dict | None approved: bool
def agent(state: ApprovalState) -> dict: # Agent decides on action action = {"type": "send_email", "to": "user@example.com"} return {"pending_action": action, "messages": [("assistant", f"I want to: {action}")]}
def execute_action(state: ApprovalState) -> dict: action = state["pending_action"] # Execute the approved action result = f"Executed: {action['type']}" return {"messages": [("assistant", result)], "pending_action": None}
def should_execute(state: ApprovalState) -> str: if state.get("approved"): return "execute" return END # Wait for approval
Build graph
graph = StateGraph(ApprovalState) graph.add_node("agent", agent) graph.add_node("execute", execute_action)
graph.add_edge(START, "agent") graph.add_conditional_edges("agent", should_execute, ["execute", END]) graph.add_edge("execute", END)
Compile with interrupt_before for human review
app = graph.compile(checkpointer=memory, interrupt_before=["execute"] # Pause before execution)
Run until interrupt
config = {"configurable": {"thread_id": "approval-flow"}} result = app.invoke({"messages": [("user", "Send report")]}, config)
Agent paused - get pending state
state = app.get_state(config) pending = state.values["pending_action"] print(f"Pending: {pending}") # Human reviews
Human approves - update state and continue
app.update_state(config, {"approved": True}) result = app.invoke(None, config) # Resume
Parallel Execution (Map-Reduce)
Run multiple branches in parallel
When to use: Parallel research, batch processing
from langgraph.graph import StateGraph, START, END, Send from langgraph.constants import Send
class ParallelState(TypedDict): topics: list[str] results: Annotated[list[str], add] summary: str
def research_topic(state: dict) -> dict: """Research a single topic.""" topic = state["topic"] result = f"Research on {topic}..." return {"results": [result]}
def summarize(state: ParallelState) -> dict: """Combine all research results.""" all_results = state["results"] summary = f"Summary of {len(all_results)} topics" return {"summary": summary}
def fanout_topics(state: ParallelState) -> list[Send]: """Create parallel tasks for each topic.""" return [Send("research", {"topic": topic}) for topic in state["topics"]]
Build graph
graph = StateGraph(ParallelState) graph.add_node("research", research_topic) graph.add_node("summarize", summarize)
Fan out to parallel research
graph.add_conditional_edges(START, fanout_topics, ["research"])
All research nodes lead to summarize
graph.add_edge("research", "summarize") graph.add_edge("summarize", END)
app = graph.compile()
result = app.invoke({"topics": ["AI", "Climate", "Space"], "results": []})
Research runs in parallel, then summarizes
Collaboration
Delegation Triggers
- crewai|role-based|crew -> crewai (Need role-based multi-agent approach)
- observability|tracing|langsmith -> langfuse (Need LLM observability)
- structured output|json schema -> structured-output (Need structured LLM responses)
- evaluate|benchmark|test agent -> agent-evaluation (Need to evaluate agent performance)
Production Agent Stack
Skills: langgraph, langfuse, structured-output
Workflow:
1. Design agent graph with LangGraph
2. Add structured outputs for tool responses
3. Integrate Langfuse for observability
4. Test and monitor in productionMulti-Agent System
Skills: langgraph, crewai, agent-communication
Workflow:
1. Design agent roles (CrewAI patterns)
2. Implement as LangGraph with subgraphs
3. Add inter-agent communication
4. Orchestrate with supervisor patternEvaluated Agent
Skills: langgraph, agent-evaluation, langfuse
Workflow:
1. Build agent with LangGraph
2. Create evaluation suite
3. Monitor with Langfuse
4. Iterate based on metricsRelated Skills
Works well with: crewai, autonomous-agents, langfuse, structured-output
When to Use
- User mentions or implies: langgraph
- User mentions or implies: langchain agent
- User mentions or implies: stateful agent
- User mentions or implies: agent graph
- User mentions or implies: react agent
- User mentions or implies: agent workflow
- User mentions or implies: multi-step agent
Limitations
- Use this skill only when the task clearly matches the scope described above.
- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.