Master StateGraph in 5 Minutes: Visualizing Agent Logic with LangGraph

LangChain vs LangGraph

LangChain provides high‑level APIs (Model, Prompt, Chain, Agent) for rapid prototyping, but the workflow logic is hidden inside code, making changes hard when requirements evolve.

LangGraph adopts a graph‑based approach where the workflow is expressed as a visual graph, exposing the logic explicitly.

Abstraction level: LangChain – high‑level API; LangGraph – low‑level graph.

State management: LangChain – implicit; LangGraph – explicit State.

Execution control: LangChain – limited; LangGraph – supports checkpoints.

Typical use case: LangChain – quick prototypes; LangGraph – production‑grade complex workflows.

StateGraph Core Elements

State : shared state across the graph (similar to React state).

Node : a processing function that receives the current state and returns updates.

Edge : connects nodes and determines execution order.

Basic Python Example

from typing import TypedDict
from langgraph.graph import StateGraph, START, END

class WorkflowState(TypedDict):
    message: str

def first_node(state: WorkflowState) -> dict:
    return {"message": f"处理: {state['message']}"}

def second_node(state: WorkflowState) -> dict:
    return {"message": f"输出: {state['message']}"}

builder = StateGraph(WorkflowState)
builder.add_node("first", first_node)
builder.add_node("second", second_node)
builder.add_edge(START, "first")
builder.add_edge("first", "second")
builder.add_edge("second", END)

graph = builder.compile()
result = graph.invoke({"message": "Hello LangGraph!"})
print(result)  # {'message': '输出: 处理: Hello LangGraph!'}

The execution flow is START → first → second → END, producing the final merged state.

Special Nodes START and END

START : automatically provided entry point.

END : automatically provided exit point.

# Adding edges for entry and exit
builder.add_edge(START, "first_node")  # entry → first node
builder.add_edge("last_node", END)      # last node → exit

Node Function Details

Each node receives the current state (read‑only) and returns a dict of fields to update; the returned fields are merged into the existing state rather than overwriting it.

Only the specified fields are updated.

Updates are merged with the existing state.

Why Graph Structure Beats Plain Code

Visualizable: the workflow can be rendered as a graph.

Debuggable: each node can be tested in isolation.

Extensible: adding new nodes only requires adding edges, not changing core logic.

Persistable: supports checkpoints for fault‑tolerant execution.

Minimal Runnable Script

from typing import TypedDict
from langgraph.graph import StateGraph, START, END

class WorkflowState(TypedDict):
    message: str

def first_node(state: WorkflowState) -> dict:
    return {"message": f"处理: {state['message']}"}

def second_node(state: WorkflowState) -> dict:
    return {"message": f"输出: {state['message']}"}

builder = StateGraph(WorkflowState)
builder.add_node("first", first_node)
builder.add_node("second", second_node)
builder.add_edge(START, "first")
builder.add_edge("first", "second")
builder.add_edge("second", END)

graph = builder.compile()
if __name__ == "__main__":
    result = graph.invoke({"message": "Hello!"})
    print(result)  # {'message': '输出: 处理: Hello!'}

Conditional Edges

To branch based on state, define a decision function returning a literal edge name and add conditional edges.

from typing import Literal

def decide_path(state: WorkflowState) -> Literal["node_a", "node_b"]:
    if len(state["message"]) > 10:
        return "node_a"
    return "node_b"

builder.add_conditional_edges(
    "decide",
    decide_path,
    {"node_a": "path_a_node", "node_b": "path_b_node"}
)

Day 1 Recap

StateGraph : container that defines the workflow skeleton.

State : shared mutable data accessible to all nodes.

Node : processing function that receives state and returns updates.

Edge : directs execution order.

START/END : built‑in entry and exit nodes.

add_conditional_edges : creates branches based on runtime conditions.