langgraph-state-graph

langgraph-state-graph

Build stateful agent workflows using LangGraph's StateGraph pattern. Design state schemas, create nodes, define edges with conditional routing, and enable persistence.

Overview

LangGraph is a library for building stateful, multi-actor applications with LLMs. The StateGraph is the core abstraction that enables:

• Cyclical computation graphs (unlike DAGs)
• State persistence and checkpointing
• Human-in-the-loop interaction patterns
• Conditional branching and routing
• Multi-agent coordination

Capabilities

State Schema Design

• Define typed state schemas with TypedDict or Pydantic
• Configure state channels for message passing
• Set up reducer functions for state updates
• Design accumulator patterns for conversation history

Graph Construction

• Create nodes as functions or runnables
• Define edges (normal, conditional, entry points)
• Configure start and end nodes
• Implement routing logic for conditional edges

Persistence & Checkpointing

• Configure checkpoint backends (SQLite, PostgreSQL, Redis)
• Enable state snapshots at each step
• Support for resuming interrupted workflows
• Thread-based conversation persistence

Human-in-the-Loop

• Insert interrupt points in workflows
• Collect human feedback before continuing
• Support approval gates and input collection
• Resume from interrupt with updated state

Usage

Basic StateGraph Pattern

from typing import TypedDict, Annotated
from langgraph.graph import StateGraph, END
from langgraph.graph.message import add_messages

# Define state schema
class AgentState(TypedDict):
    messages: Annotated[list, add_messages]
    current_step: str
    iteration: int

# Create nodes
def agent_node(state: AgentState) -> AgentState:
    # Process state and return updates
    return {"current_step": "processed", "iteration": state["iteration"] + 1}

def tool_node(state: AgentState) -> AgentState:
    # Execute tools based on agent decisions
    return {"current_step": "tools_executed"}

# Build graph
graph = StateGraph(AgentState)
graph.add_node("agent", agent_node)
graph.add_node("tools", tool_node)

# Define edges
graph.set_entry_point("agent")
graph.add_edge("agent", "tools")
graph.add_conditional_edges(
    "tools",
    lambda state: "end" if state["iteration"] >= 3 else "continue",
    {"end": END, "continue": "agent"}
)

# Compile
app = graph.compile()