Advanced LangGraph Patterns

LangGraph: Advanced Patterns 🧩

The Story of the Master Architect

Imagine you’re building the world’s most amazing theme park. You started with simple rides, but now you want:

• Rides that talk to each other 🎢
• Workers who ask visitors for permission before doing scary things 🎟️
• Multiple teams working together on huge attractions 👷‍♀️👷‍♂️
• Emergency systems when things go wrong 🚨
• A control room to watch everything 📺

That’s exactly what Advanced LangGraph Patterns give you for AI apps!

1. LangGraph Functional API 🔧

The Simple Way to Build

Think of the Functional API like LEGO instructions — step-by-step, easy to follow.

Instead of creating complex classes, you just write simple functions and connect them.

Before (Class-based):

class MyNode:
    def __call__(self, state):
        return {"data": "result"}

After (Functional API):

@task
def my_task(input):
    return "result"

@entrypoint()
def my_graph(input):
    result = my_task(input)
    return result

Key Parts

Why Use It?

• ✅ Simpler code — less typing
• ✅ Easier to read — looks like normal Python
• ✅ Same power — does everything the old way could

graph TD
    A["Start: entrypoint"] --> B["Task 1"]
    B --> C["Task 2"]
    C --> D["Return Result"]

2. Subgraphs 🏗️

Graphs Inside Graphs!

Remember our theme park? A subgraph is like having a mini-park inside the main park.

The water park area has its own rides, but it’s still part of the big park!

Real Example

# Mini-graph for research
research_graph = StateGraph(...)
research_graph.add_node("search", search_web)
research_graph.add_node("summarize", summarize)

# Main graph uses the mini-graph
main_graph = StateGraph(...)
main_graph.add_node("research",
    research_graph.compile())
main_graph.add_node("write", write_report)

When to Use Subgraphs

The Magic Flow

graph TD
    A["Main Graph Start"] --> B["Subgraph"]
    B --> C["Sub-step 1"]
    C --> D["Sub-step 2"]
    D --> E["Back to Main"]
    E --> F["Continue Main"]

Key Insight: The main graph doesn’t know (or care) what happens inside the subgraph. It just waits for the result!

3. Prebuilt ReAct Agent 🤖

The Ready-Made Robot Helper

Building an AI agent from scratch is like building a car from raw metal. But what if someone already built the car for you?

ReAct = Reason + Act

The agent thinks, then does, then thinks again!

Using the Prebuilt Agent

from langgraph.prebuilt import create_react_agent

# Your tools (things the agent can do)
tools = [search_tool, calculator_tool]

# Create agent in ONE line!
agent = create_react_agent(
    model=my_llm,
    tools=tools
)

# Run it
result = agent.invoke({
    "messages": [
        ("user", "What is 25 * 4?")
    ]
})

What Happens Inside

graph TD
    A["Get Question"] --> B{Need a Tool?}
    B -->|Yes| C["Pick Tool"]
    C --> D["Use Tool"]
    D --> E["Get Result"]
    E --> B
    B -->|No| F["Give Final Answer"]

Built-in Superpowers

4. Human-in-the-Loop Patterns 👋

Asking Permission First

Some AI decisions are too important to make alone. Like asking a parent before buying something expensive!

The Three Patterns

Pattern 1: Approve Before Action

from langgraph.types import interrupt

def risky_action(state):
    # Pause and ask human
    human_says = interrupt(
        "Should I delete this file?"
    )

    if human_says == "yes":
        delete_file()
    return state

Pattern 2: Edit the Plan

def make_plan(state):
    plan = ai_makes_plan()

    # Human can change it
    edited_plan = interrupt(plan)

    return {"plan": edited_plan}

Pattern 3: Review Output

def generate_email(state):
    email = ai_writes_email()

    # Human approves or edits
    final = interrupt(email)

    return {"email": final}

Visual Flow

graph TD
    A["AI Does Work"] --> B["PAUSE"]
    B --> C{Human Reviews}
    C -->|Approve| D["Continue"]
    C -->|Edit| E["AI Gets Edits"]
    E --> D
    C -->|Reject| F["Try Again"]
    F --> A

The Command Object

from langgraph.types import Command

# Resume with approval
graph.invoke(
    Command(resume="approved"),
    config=thread_config
)

5. Multi-Agent Systems 🤝

A Team of AI Helpers

One robot is good. But a team of specialized robots? Unstoppable!

Types of Multi-Agent Setups

Type A: Supervisor Pattern

One boss agent tells others what to do.

def supervisor(state):
    # Decide who works next
    if need_research:
        return "researcher"
    elif need_writing:
        return "writer"
    else:
        return "end"

graph TD
    S["Supervisor"] --> R["Researcher"]
    S --> W["Writer"]
    S --> E["Editor"]
    R --> S
    W --> S
    E --> S

Type B: Network Pattern

Agents talk to each other freely.

def researcher(state):
    findings = do_research()
    # Pass directly to writer
    return Command(
        goto="writer",
        update={"research": findings}
    )

Type C: Hierarchical Pattern

Teams with their own supervisors!

graph TD
    CEO["Top Supervisor"] --> TL1["Team Lead 1"]
    CEO --> TL2["Team Lead 2"]
    TL1 --> W1["Worker 1"]
    TL1 --> W2["Worker 2"]
    TL2 --> W3["Worker 3"]
    TL2 --> W4["Worker 4"]

Sharing Information

# Shared state all agents can see
class SharedState(TypedDict):
    messages: list
    current_task: str
    results: dict

6. Error Handling in Graphs 🚨

When Things Go Wrong

Even the best theme parks have problems. The key is handling them gracefully!

Strategy 1: Try-Catch in Nodes

def risky_node(state):
    try:
        result = call_external_api()
        return {"data": result}
    except APIError:
        return {"error": "API failed"}

Strategy 2: Retry Logic

from tenacity import retry, stop_after_attempt

@retry(stop=stop_after_attempt(3))
def api_node(state):
    return call_flaky_api()

Strategy 3: Fallback Nodes

def router(state):
    if state.get("error"):
        return "fallback_node"
    return "normal_node"

Strategy 4: Error State

class State(TypedDict):
    data: str
    error: Optional[str]
    retry_count: int

Error Flow

graph TD
    A["Try Action"] --> B{Success?}
    B -->|Yes| C["Continue"]
    B -->|No| D{Retries Left?}
    D -->|Yes| A
    D -->|No| E["Fallback"]
    E --> F["Graceful End"]

Best Practices

7. LangGraph Studio Debugging 🔍

Your Theme Park Control Room

LangGraph Studio is like having cameras and controls for every ride in your park!

What You Can See

• 📊 Graph visualization — See all nodes and edges
• 🔄 Live execution — Watch data flow in real-time
• ⏸️ Breakpoints — Pause at any node
• 📝 State inspection — See what’s in state
• ⏪ Time travel — Go back to any step

Starting Studio

# Install
pip install langgraph-cli

# Run in your project folder
langgraph dev

The Interface

┌─────────────────────────────────────┐
│  📊 GRAPH VIEW                      │
│  [Node A] → [Node B] → [Node C]     │
├─────────────────────────────────────┤
│  📋 STATE                           │
│  messages: [...]                    │
│  current_node: "Node B"             │
├─────────────────────────────────────┤
│  ▶️ CONTROLS                         │
│  [Step] [Continue] [Reset]          │
└─────────────────────────────────────┘

Debugging Tips

Tip 1: Use Thread IDs

config = {"configurable": {"thread_id": "debug-123"}}
result = graph.invoke(input, config)

Tip 2: Add Checkpoints

from langgraph.checkpoint.memory import MemorySaver

graph = builder.compile(
    checkpointer=MemorySaver()
)

Tip 3: Inspect State

# Get state at any point
state = graph.get_state(config)
print(state.values)
print(state.next)  # What runs next?

Common Bugs & Fixes

graph TD
    A["Bug Found!"] --> B["Open Studio"]
    B --> C["Find the Node"]
    C --> D["Check State"]
    D --> E["Fix Code"]
    E --> F["Test Again"]

Putting It All Together 🎯

Here’s how all these patterns work in a real app:

from langgraph.prebuilt import create_react_agent
from langgraph.graph import StateGraph
from langgraph.checkpoint.memory import MemorySaver

# 1. Create specialized agents
researcher = create_react_agent(model, research_tools)
writer = create_react_agent(model, writing_tools)

# 2. Build main graph with subgraphs
builder = StateGraph(State)
builder.add_node("research", researcher)
builder.add_node("write", writer)
builder.add_node("review", human_review)  # Human-in-loop

# 3. Add error handling
builder.add_node("error_handler", handle_errors)

# 4. Connect with routing
builder.add_conditional_edges(
    "research",
    route_after_research
)

# 5. Compile with checkpointing for Studio
graph = builder.compile(
    checkpointer=MemorySaver()
)

Quick Reference Card 📋

You Did It! 🎉

You now understand the advanced patterns that power production LangGraph apps:

1. ✅ Functional API — Simple, clean code
2. ✅ Subgraphs — Organize complex flows
3. ✅ ReAct Agent — Ready-made intelligence
4. ✅ Human-in-Loop — Safe, supervised AI
5. ✅ Multi-Agent — Teams of AI helpers
6. ✅ Error Handling — Graceful failures
7. ✅ Studio — See everything, fix anything

You’re ready to build amazing AI applications! 🚀