LangGraph Tutorial — Build Multi-Step AI Agents with State Management

LangGraph is the framework that makes AI agents production-ready. Unlike simple agent loops, it gives you explicit state management, conditional branching, and human-in-the-loop checkpoints.

Core Concepts

Graph: Your agent is a directed graph. Each node is a function. Edges define what happens next.

State: A typed dictionary flowing through the graph. Every node reads and writes to state. No hidden context.

Conditional edges: Route to different nodes based on current state. This is how you build if/else branching.

Installation

pip install langgraph langchain-anthropic

Step 1: Define State

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

class ResearchState(TypedDict):
    task: str
    search_results: List[str]
    draft: str
    revision_count: int
    messages: Annotated[list, add_messages]

Step 2: Define Nodes

from langchain_anthropic import ChatAnthropic
from langchain_core.messages import HumanMessage

llm = ChatAnthropic(model="claude-opus-4-6")

def research_node(state: ResearchState):
    results = search_web(state["task"])
    return {"search_results": results}

def write_node(state: ResearchState):
    prompt = f"Write a report on: {state['task']}

Sources:
" + "
".join(state["search_results"])
    response = llm.invoke([HumanMessage(content=prompt)])
    return {"draft": response.content, "revision_count": state.get("revision_count",0)+1}

Step 3: Build the Graph

from langgraph.graph import StateGraph, END

def should_revise(state: ResearchState) -> str:
    if len(state.get("draft","")) < 300:
        return "write"
    return END

builder = StateGraph(ResearchState)
builder.add_node("research", research_node)
builder.add_node("write", write_node)
builder.set_entry_point("research")
builder.add_edge("research", "write")
builder.add_conditional_edges("write", should_revise, {"write":"write", END:END})
graph = builder.compile()

Human-in-the-Loop

from langgraph.checkpoint.memory import MemorySaver
memory = MemorySaver()
graph = builder.compile(checkpointer=memory, interrupt_before=["write"])
config = {"configurable": {"thread_id": "run-1"}}
graph.invoke(initial_state, config=config)
# Human reviews, then:
graph.invoke(None, config=config)

The graph pauses, saves state, and waits. On the second call it resumes exactly where it stopped.

When to Use LangGraph vs Claude SDK

Use LangGraph for conditional branching, human checkpoints, parallel nodes, and persistent state across runs. Use Claude Agent SDK for simple linear tasks where you want to move fast.

Need a production LangGraph agent for your business? Power Digital builds AI agents for Singapore companies.