The compile() Method Explained

app = graph.compile(
    checkpointer: BaseCheckpointSaver | None = None,
    interrupt_before: list[str] | None = None,
    interrupt_after: list[str] | None = None,
    debug: bool = False,
)

1. Graph Validation – Checks nodes, edges, and connections
2. Node Validation – Ensures every node is callable and accepts state
3. Edge Validation – Verifies all conditional routes point to valid nodes
4. START/END Validation – Ensures the graph has proper entry and exit points
5. Execution Engine Setup – Builds the internal runner
6. Runnable Conversion – Turns the graph into a LangChain Runnable

• Missing connection from START
• Node referenced in edge but never added
• Invalid return value from router
• No path to END

• Every node is a callable (function, class with __call__, or Runnable)
• The node can accept the state schema
• Return values are compatible with the state reducers

Edge Validation

• Every graph must have at least one path starting from START
• Every graph must eventually reach END (unless using interrupts)
• You cannot create a node named START or END

graph.add_edge(START, "agent")
graph.add_edge("final_node", END)

• The router function returns valid node names or END
• All possible return values from the router are mapped in the path_map
• No unreachable or dangling routes

def route_tools(state):
    if state["messages"][-1].tool_calls:
        return "tools"
    return "END"

graph.add_conditional_edges(
    "agent",
    route_tools,
    {
        "tools": "tools",   # Must match router return values
        "END": END
    }
)

• All nodes can accept and return the defined state
• Reducers are properly defined for each field
• Default values are compatible (especially with Pydantic)

• A node is referenced in an edge but never added with add_node()
• There is no path from START to some nodes
• There are nodes with no incoming or outgoing edges (except in special cases)

ValueError: Node 'tools' is referenced in an edge but was not added to the graph.

1. Input → START
2. Node execution (with state + config)
3. Reducer merges updates
4. Edge evaluation (fixed or conditional)
5. Repeat until END or interrupt
6. Return final state

Invoking a Compiled Graph

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

# Basic invoke
result = app.invoke({
    "messages": [HumanMessage(content="Hello, how are you?")]
})

# With config (thread_id for memory)
config = {"configurable": {"thread_id": "user_456"}}
result = app.invoke(inputs, config)

Streaming a Compiled Graph

# Stream all state updates
for chunk in app.stream(inputs, stream_mode="values"):
    print(chunk)

# Stream only messages (most popular)
for chunk in app.stream(inputs, stream_mode="messages"):
    if isinstance(chunk, tuple) and chunk[1]:   # (node_name, message)
        print(chunk[1].content)

# Stream updates per node
for chunk in app.stream(inputs, stream_mode="updates"):
    print(chunk)

Async Execution After Compilation

# Async invoke
result = await app.ainvoke(inputs, config)

# Async stream
async for chunk in app.astream(inputs, stream_mode="values"):
    print(chunk)

Checkpointing and Compilation

from langgraph.checkpoint.memory import MemorySaver
from langgraph.checkpoint.sqlite import SqliteSaver

checkpointer = SqliteSaver.from_conn_string("checkpoints.db")

app = graph.compile(checkpointer=checkpointer)   # Required for persistence

Without a checkpointer, you lose all memory between runs.

Memory Integration During Compilation

config = {"configurable": {"thread_id": "conversation_789"}}

# First run
app.invoke(initial_input, config)

# Later continuation (memory is restored)
app.invoke(follow_up_input, config)

Interrupts and Breakpoints

app = graph.compile(
    checkpointer=MemorySaver(),
    interrupt_before=["human_approval", "sensitive_action"],
    interrupt_after=["tools"]
)

# Run until interrupt
result = app.invoke(inputs, config)

# Provide human input and resume
result2 = app.invoke(
    {"messages": [HumanMessage(content="Approved. Proceed.")]},
    config
)

graph = StateGraph(AgentState)
# ... add nodes and edges

# Visualize the builder
graph.get_graph().draw_mermaid()           # Returns Mermaid syntax
graph.get_graph().draw_mermaid_png()       # Saves as image

app = graph.compile()

# You can still visualize the compiled graph
app.get_graph().draw_mermaid()
app.get_graph().draw_ascii()               # Terminal-friendly view

from langgraph.graph import StateGraph, START, END

graph = StateGraph(AgentState)
# ... build your graph

# Generate Mermaid syntax
mermaid_code = graph.get_graph().draw_mermaid()
print(mermaid_code)

# Save as PNG (requires matplotlib or similar)
graph.get_graph().draw_mermaid_png(output_file_path="graph.png")

# 1. Create and compile a subgraph
research_subgraph = create_research_subgraph()  # returns compiled graph

# 2. Add compiled subgraph as a normal node
main_graph = StateGraph(AgentState)
main_graph.add_node("research_team", research_subgraph)   # ← Compiled subgraph

main_graph.add_edge(START, "research_team")
main_graph.add_edge("research_team", "final_answer")

# Compile individual agent subgraphs
researcher = create_researcher().compile()
coder = create_coder().compile()

# Main supervisor graph
supervisor_graph = StateGraph(AgentState)
supervisor_graph.add_node("supervisor", supervisor_node)
supervisor_graph.add_node("researcher", researcher)
supervisor_graph.add_node("coder", coder)

supervisor_graph.add_conditional_edges("supervisor", supervisor_router)

app = supervisor_graph.compile(checkpointer=MemorySaver())

def create_dynamic_graph(agent_type: str):
    graph = StateGraph(AgentState)
    
    if agent_type == "research":
        graph.add_node("research", research_node)
    else:
        graph.add_node("general", general_node)
    
    graph.add_edge(START, "research" if agent_type == "research" else "general")
    graph.add_edge("research", END)
    
    return graph.compile()   # Compile on demand

graph = StateGraph(AgentState)
graph.add_node("agent", agent_node)
app = graph.compile()          # First compilation

# Add new node later
graph.add_node("new_feature", new_node)
graph.add_edge("agent", "new_feature")

app = graph.compile()          # Recompile with changes

# 1. Enable debug mode
app = graph.compile(debug=True)

# 2. Visualize before compiling
print(graph.get_graph().draw_mermaid())

# 3. Check graph structure
print(graph.get_graph().nodes.keys())
print(graph.get_graph().edges)

# 4. Common fixes for compilation errors:
# - Make sure all nodes referenced in edges are added
# - Ensure router returns valid node names
# - Check that START and END are properly connected

graph.add_edge(START, "agent")        # Correct
# or
graph.set_entry_point("agent")        # For MessageGraph

graph.add_conditional_edges(
    "agent",
    route_after_agent,
    {
        "tools": "tools",
        "research": "research_node",
        "END": END          # ← Must include this
    }
)

def route_after_agent(state):
    if state["messages"][-1].tool_calls:
        return "tools"          # Must exist as a node
    return "END"                # Must be mapped or used directly

class AgentState(TypedDict):
    messages: Annotated[list, add_messages]
    iterations: int          # Must be updated consistently

def agent_node(state: AgentState):
    return {
        "messages": [response],
        "iterations": state.get("iterations", 0) + 1
    }

class AgentState(TypedDict):
    messages: Annotated[list, add_messages]
    documents: list[dict]
    iterations: int

# Validate early
graph = StateGraph(AgentState)

# Good structure
graph.add_node("agent", agent_node)
graph.add_node("tools", tool_node)
graph.add_node("retriever", retriever_node)

graph.add_edge(START, "agent")
# ... edges

# Test router logic
test_state = {"messages": [AIMessage(content="I need to search something", tool_calls=[...])]}
print(route_tools(test_state))   # Should return "tools"

# Build complete graph first
graph = StateGraph(AgentState)
# ... add ALL nodes and edges

# Then compile once
app = graph.compile(
    checkpointer=MemorySaver(),
    interrupt_before=["human_review"]
)

# Visualize builder
print(graph.get_graph().draw_mermaid())

# Or save as image
graph.get_graph().draw_mermaid_png("graph.png")