LangGraph: Detailed Introduction

[ikaijua]

LangGraph: Detailed Introduction

LangGraph is a low-level orchestration framework for building stateful, multi-step AI agents modeled as graphs. Maintained by LangChain, it is one of the most widely adopted graph-based agent frameworks and integrates tightly with LangChain and LangSmith.

中文版：LangGraph 入门介绍

Table of Contents

• What is LangGraph?
• Core concepts
• Why use a graph?
• Persistence and human-in-the-loop
• LangGraph Platform and Studio
• A minimal example
• When to use it
• Links

What is LangGraph?

LangGraph lets you express an agent's control flow as a state graph: nodes are functions or LLM calls, edges define how control moves between them, and a shared state object is passed along and updated at each step. This makes loops, branching, and multi-agent hand-offs explicit and debuggable, unlike a single linear prompt chain where the flow is buried inside one loop.

Core concepts

• State: a typed, shared object (Pydantic or TypedDict) that accumulates information as the graph runs.
• Nodes: units of work — usually an LLM call, a tool call, or a plain Python function.
• Edges: transitions between nodes, including conditional edges that route based on the current state.
• Checkpointer: persists the state after every step so a run can be paused, resumed, forked, or replayed.
• Cycles: graphs can loop back to earlier nodes, enabling reflection, retry, and iterative planning.

Why use a graph?

Plain agent loops are easy to start but hard to control. LangGraph makes the flow explicit and inspectable: you can see every node executed, replay from any checkpoint, and add guardrails (max steps, approval gates) without rewriting the whole agent. It supports any model provider (OpenAI, Anthropic, Google, local models) and runs in both Python and JavaScript/TypeScript.

Persistence and human-in-the-loop

Because state is checkpointed, you can interrupt a graph, ask a human for input, and resume exactly where it stopped (via interrupt()). This is the foundation for approval steps, form filling, and safe autonomous workflows. LangGraph also offers long-term memory through store backends.

LangGraph Platform and Studio

• LangGraph Studio: a local visual debugger to draw, step through, and inspect graphs.
• LangGraph Platform: a managed service for deploying, scaling, and persisting graphs in production, with streaming, background runs, and auth.

A minimal example

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

class State(TypedDict):
    count: int

def inc(state: State) -> State:
    return {"count": state["count"] + 1}

builder = StateGraph(State)
builder.add_node("inc", inc)
builder.add_edge(START, "inc")
builder.add_edge("inc", END)
graph = builder.compile()
print(graph.invoke({"count": 0}))

When to use it

Choose LangGraph when you need durable, controllable, multi-step agents — loops, branching, human approval, or multi-agent coordination — and want the flow to be observable and replayable rather than a black-box loop. For a quick one-shot chain, a simpler tool may be enough.

Links

Resource	Link
GitHub	https://github.com/langchain-ai/langgraph
Docs	https://langchain-ai.github.io/langgraph/
Website	https://www.langchain.com/langgraph