LangGraph Development Skill

Quick Reference

LangGraph is LangChain's framework for building stateful, multi-actor applications with LLMs. It enables cyclic graphs, conditional branching, persistent state management, and human-in-the-loop workflows.

Key capabilities: StateGraph for workflow orchestration, checkpointers for persistence, prebuilt ReAct agents, streaming at multiple granularities, and LangGraph Platform for managed deployment.

Table of Contents

1. When to Use
2. Package Ecosystem
3. Quick Start - Python
4. Quick Start - TypeScript
5. Core Concepts
6. Prebuilt Components
7. Common Patterns
8. Quick Persistence Setup
9. CLI Commands
10. Error Quick Reference
11. When to Use REFERENCE.md
12. Agent Integration
13. See Also

When to Use

This skill is loaded by

backend-developer

• langgraph

  in

  requirements.txt

  ,

  pyproject.toml

  , or

  setup.py

• @langchain/langgraph

  in

  package.json

  dependencies
• Python imports:

  from langgraph.graph import StateGraph

• Environment variables

  LANGSMITH_API_KEY

  ,

  LANGGRAPH_API_URL

  , or

  LANGCHAIN_API_KEY

  present
• User mentions "LangGraph", "StateGraph", "agent workflow", "cyclic agent", or "multi-agent graph"

Package Ecosystem

langgraph

langgraph-checkpoint-postgres

langgraph-checkpoint-sqlite

langgraph-sdk

@langchain/langgraph

Compatibility: LangGraph 0.2.x requires

langchain-core>=0.3.0

Quick Start - Python

"""LangGraph Quick Start - Python"""
from langgraph.graph import StateGraph, START, END
from typing import TypedDict

# 1. Define state schema
class State(TypedDict):
    messages: list[str]
    count: int

# 2. Define node functions
def process(state: State) -> dict:
    """Process node - increments counter."""
    return {"count": state["count"] + 1}

def respond(state: State) -> dict:
    """Response node - adds message to state."""
    return {"messages": state["messages"] + [f"Processed {state['count']} times"]}

# 3. Build graph
graph = StateGraph(State)
graph.add_node("process", process)
graph.add_node("respond", respond)

graph.add_edge(START, "process")
graph.add_edge("process", "respond")
graph.add_edge("respond", END)

# 4. Compile and run
app = graph.compile()
result = app.invoke({"messages": [], "count": 0})
# {'messages': ['Processed 1 times'], 'count': 1}

With LLM and Tools

"""LangGraph with ChatOpenAI and tools."""
from langgraph.graph import StateGraph, START, MessagesState
from langgraph.prebuilt import ToolNode, tools_condition
from langchain_openai import ChatOpenAI
from langchain_core.tools import tool

@tool
def get_weather(city: str) -> str:
    """Get weather for a city."""
    return f"Weather in {city}: 72F, sunny"

llm = ChatOpenAI(model="gpt-4o")
tools = [get_weather]
llm_with_tools = llm.bind_tools(tools)

def agent(state: MessagesState) -> dict:
    response = llm_with_tools.invoke(state["messages"])
    return {"messages": [response]}

graph = StateGraph(MessagesState)
graph.add_node("agent", agent)
graph.add_node("tools", ToolNode(tools))

graph.add_edge(START, "agent")
graph.add_conditional_edges("agent", tools_condition)
graph.add_edge("tools", "agent")

app = graph.compile()
result = app.invoke({"messages": [("user", "What's the weather in NYC?")]})

Quick Start - TypeScript

import { StateGraph, START, END, Annotation } from "@langchain/langgraph";

const State = Annotation.Root({
  messages: Annotation<string[]>({
    default: () => [],
    reducer: (curr, update) => [...curr, ...update],
  }),
  count: Annotation<number>({ default: () => 0 }),
});

const process = (state: typeof State.State) => ({
  count: state.count + 1,
});

const respond = (state: typeof State.State) => ({
  messages: [`Processed ${state.count} times`],
});

const graph = new StateGraph(State)
  .addNode("process", process)
  .addNode("respond", respond)
  .addEdge(START, "process")
  .addEdge("process", "respond")
  .addEdge("respond", END);

const app = graph.compile();
const result = await app.invoke({ messages: [], count: 0 });

Core Concepts

StateGraph

The core abstraction - a directed graph where nodes read and write to shared state.

from langgraph.graph import StateGraph

graph = StateGraph(State)  # State is a TypedDict

State Schema

Defines the shape of data flowing through the graph.

from typing import TypedDict, Annotated
from langgraph.graph import add_messages

class State(TypedDict):
    messages: Annotated[list, add_messages]  # With reducer
    context: str                              # Simple overwrite

Nodes

Functions that receive state and return partial updates.

def my_node(state: State) -> dict:
    return {"context": f"{state['context']} - processed"}

Edges

Connections between nodes - unconditional or conditional.

# Unconditional
graph.add_edge("node_a", "node_b")

# Conditional
graph.add_conditional_edges("router", routing_function)

Special Nodes

START

END

Prebuilt Components

create_react_agent

langgraph.prebuilt

ToolNode

langgraph.prebuilt

tools_condition

langgraph.prebuilt

MessagesState

langgraph.graph

create_react_agent

from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI
from langchain_core.tools import tool

@tool
def search(query: str) -> str:
    """Search the web."""
    return f"Results for: {query}"

llm = ChatOpenAI(model="gpt-4o")
agent = create_react_agent(llm, [search])
result = agent.invoke({"messages": [("user", "Search for LangGraph")]})

Common Patterns

Linear Pipeline

graph.add_edge(START, "extract")
graph.add_edge("extract", "transform")
graph.add_edge("transform", "load")
graph.add_edge("load", END)

Conditional Routing

def router(state: State) -> str:
    if state["intent"] == "search":
        return "search_node"
    return "default_node"

graph.add_conditional_edges("classifier", router)

Cycle with Exit

def check_done(state):
    return END if state["done"] else "process"

graph.add_edge(START, "process")
graph.add_edge("process", "check")
graph.add_conditional_edges("check", check_done)

Quick Persistence Setup

from langgraph.checkpoint.memory import MemorySaver

# Development - in-memory (lost on restart)
memory = MemorySaver()
app = graph.compile(checkpointer=memory)

config = {"configurable": {"thread_id": "user-123"}}
result = app.invoke({"messages": [("user", "Hi")]}, config)

For production persistence, see REFERENCE.md for PostgreSQL/SQLite setup.

CLI Commands

# Install
pip install langgraph langgraph-checkpoint-postgres

# Verify
python -c "import langgraph; print(langgraph.__version__)"

# LangGraph Platform
langgraph init      # Initialize project
langgraph dev       # Start dev server
langgraph build     # Build for deployment
langgraph up        # Deploy with Docker

Environment Variables

export LANGSMITH_API_KEY="ls-..."
export LANGCHAIN_TRACING_V2="true"
export OPENAI_API_KEY="sk-..."

Error Quick Reference

InvalidUpdateError

GraphRecursionError

recursion_limit

ValueError: Checkpointer required

compile()

When to Use REFERENCE.md

Load REFERENCE.md for:

• Full checkpointer setup (PostgreSQL, SQLite, async)
• Human-in-the-loop patterns with interrupts
• Multi-agent patterns (supervisor, hierarchical)
• Streaming modes and event handling
• Subgraph composition
• Production deployment with LangGraph Platform
• Tool integration patterns
• Time travel debugging
• Best practices and anti-patterns

Agent Integration

backend-developer

deep-debugger

tech-lead-orchestrator

code-reviewer

See Also

• REFERENCE.md - Full patterns and advanced usage
• LangGraph Documentation
• LangGraph GitHub
• LangSmith

Progressive Disclosure: Start here for quick implementation. Load REFERENCE.md for comprehensive patterns, production setup, and advanced features.