Build Stateful AI Agents with LangGraph

This skill provides expert guidance for LangGraph - the production-grade framework for building stateful, multi-actor AI applications, described as used in production at LinkedIn, Uber, and 400+ companies, and as LangChain's recommended approach for building agents. It covers graph construction, state management, cycles and branches, persistence with checkpointers, human-in-the-loop patterns, and the ReAct agent pattern. The role framing is a "LangGraph Agent Architect" who designs state carefully, uses reducers appropriately, always considers persistence for production, and knows when cycles are needed versus how to prevent infinite loops.

Its expertise spans graph topology design, state schema patterns, conditional branching, persistence strategies, human-in-the-loop, tool integration, and error handling/recovery, with matching capabilities: StateGraph construction, state management and reducers, node/edge definitions, conditional routing, checkpointers and persistence, human-in-the-loop patterns, tool integration, and streaming/async execution. Prerequisites are Python 3.9+, the langgraph package, and LLM API access (OpenAI, Anthropic, etc.); the skill notes it is currently Python-only (TypeScript support is in early stages), and flags state-management complexity and debugging difficulty as real learning-curve costs. Its ecosystem centers on LangGraph, LangChain, and LangSmith for observability, with common integrations for OpenAI/Anthropic/Google, Tavily for search, SQLite/PostgreSQL for persistence, and Redis as a state store, deployed as Python applications, FastAPI/Flask backends, or cloud deployments.

Six concrete patterns are covered. A Basic Agent Graph implements a ReAct-style single agent with tool calling, using an add_messages reducer, a ToolNode for tool execution, and conditional routing back to the agent node until no more tool calls are pending. State with Reducers shows multi-agent shared-state management: an add_messages reducer for messages, a custom merge_dicts reducer for findings, an add reducer to accumulate sources, an overwriting field for the current step, and a custom lambda reducer to sum an error count. Conditional Branching classifies a query and routes it to a coding, search, or chat agent via add_conditional_edges. Persistence with Checkpointer uses SqliteSaver (in-memory or file-backed) for development and PostgresSaver for production, compiling the graph with a checkpointer and a thread_id so multi-turn conversations retain context, plus APIs to inspect state and checkpoint history. Human-in-the-Loop pauses the graph before a sensitive action using interrupt_before, letting a human inspect the pending action via get_state and resume execution with update_state once approved. Parallel Execution (Map-Reduce) fans out research across topics using LangGraph's Send construct and conditional edges from START, then reduces the parallel results in a summarize node.

The skill also defines delegation triggers to hand off to other skills: crewai for role-based multi-agent approaches, langfuse for LLM observability/tracing, structured-output for JSON-schema-constrained responses, and agent-evaluation for benchmarking agent performance. It documents three composed workflows: a Production Agent Stack (LangGraph plus structured outputs plus Langfuse observability), a Multi-Agent System (LangGraph subgraphs plus CrewAI-style role design plus inter-agent communication under a supervisor pattern), and an Evaluated Agent (LangGraph plus an evaluation suite plus Langfuse monitoring, iterating on metrics).

Use when a user mentions or implies LangGraph, a LangChain agent, a stateful agent, an agent graph, a ReAct agent, an agent workflow, or a multi-step agent. Delegate to a different skill when the actual need is role-based multi-agent orchestration (crewai), LLM observability/tracing (langfuse), structured/JSON-schema output (structured-output), or agent performance evaluation (agent-evaluation) rather than the graph architecture itself.

Inputs are a Python 3.9+ environment with the langgraph package and LLM API access; outputs are compiled LangGraph StateGraph applications - agent graphs with typed state schemas, reducers, conditional routing, and optionally a checkpointer for persistence across a thread_id.

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()

LangChain and LangSmith as primary ecosystem partners; OpenAI, Anthropic, and Google for LLM access; Tavily for search; SQLite and PostgreSQL for checkpoint persistence; Redis as a state store; and companion skills crewai, langfuse, structured-output, agent-evaluation, autonomous-agents, and agent-communication.

Engineers building stateful, multi-actor AI agents - single ReAct-style agents, multi-agent research pipelines, or production systems needing human approval gates and durable conversation memory - who want an explicit, debuggable graph structure instead of an implicit agent loop.