LangGraph简介

如果你刚接触 AI 应用开发，可能会被一堆名词绕晕：LangChain、LangGraph、LangSmith、Agent……别慌，这一篇就用最直白的话讲清楚 LangGraph 到底是什么、为什么需要它、以及它能帮你做什么。

一、LangGraph 是什么

LangGraph 是 LangChain 团队推出的低层工作流编排引擎，专门用来构建有状态、可循环、可控的 AI 应用。

关键词拆解：

• 低层：它不替你做太多决策，把控制权交给你。这点和"开箱即用"的高层框架不同。
• 工作流编排：你把多个"步骤"（节点）连成一张图，让数据按你的规则在节点之间流动。
• 有状态：图在执行过程中维护一个共享的"状态"对象，所有节点都能读写它。
• 可循环：节点之间不仅能线性串联，还能形成循环（这对智能体至关重要）。
• 可控：支持人机交互（HITL）、断点、回放、流式输出，每一步都能插手。

一句话定位：LangChain 给你工具箱，LangGraph 帮你把工具编排成可控的流程。

二、为什么需要 LangGraph

先看一个朴素问题：让大模型回答一个简单问题，一行 llm.invoke("你好") 就够了。但真实场景往往复杂得多：

用户提问 → 检索知识库 → 判断是否够用
                ↑            ↓ 不够
                └──── 重新检索/换关键词
                             ↓ 够
                        生成回答 → 输出

这种"判断-回头重做"的循环，纯链式 Chain 表达不了。Chain 是单向链表，走完就结束。

LangGraph 把流程抽象成一张有向图，节点之间可以循环、可以分叉、可以条件跳转，正好契合这种需求。

场景	纯 Chain 够用吗	LangGraph 更合适
单轮问答	✅ 够用	杀鸡用牛刀
ReAct 智能体（思考-行动-观察循环）	❌ 表达不了循环	✅ 天然支持
RAG 带自我纠错	❌ 难	✅ 可循环重检索
多智能体协作	❌ 难	✅ 节点即智能体
需要"人在回路"审核	❌ 难	✅ interrupt 内建

三、LangGraph 与 LangChain 的关系

很多新手会问："我都用 LangChain 了，还要 LangGraph 吗？"

答案是：两者定位不同，互补而非替代。

graph LR
    A[LangChain 生态] --> B[LangChain 工具箱]
    A --> C[LangGraph 编排引擎]
    A --> D[LangSmith 可观测]

    B --> B1[模型封装 Chat Models]
    B --> B2[提示模板 Prompts]
    B --> B3[输出解析 Output Parsers]
    B --> B4[文档加载/切分]
    B --> B5[向量库集成]

    C --> C1[StateGraph 图]
    C --> C2[节点 Node]
    C --> C3[边 Edge]
    C --> C4[检查点 Checkpoint]
    C --> C5[预置 create_react_agent]

• LangChain 提供"积木"：模型封装、提示模板、工具、文档加载器、向量库集成等。
• LangGraph 提供"图纸"：把这些积木编排成可控的流程。
• LangSmith 提供"监控"：观测、调试、评测（本教程不深入）。

值得注意的是，像 create_react_agent（开箱即用的 ReAct 智能体）这样的预置组件，已经迁移到 langgraph.prebuilt 包，而不是放在 LangChain 里。这正说明 LangGraph 是构建智能体的"主舞台"。

四、与 LangGraph4j 的对应

如果你有 Java 背景，可能用过 LangGraph4j——它是 LangGraph 的 Java 移植版，API 设计高度相似：

LangGraph (Python)	LangGraph4j (Java)
StateGraph(State)	StateGraph.of(State.class)
graph.add_node("a", fn)	graph.addNode("a", fn)
graph.add_edge("a", "b")	graph.addEdge("a", "b")
graph.compile()	graph.compile()
app.invoke(input)	app.invoke(input)
add_conditional_edges	addConditionalEdges
MemorySaver	MemorySaver

核心概念一一对应，迁移成本低。主要差异在 Python 的函数是一等公民（节点直接传函数对象），Java 则需要实现接口或 lambda。Python 版本因语言特性更灵活，本教程重点讲 Python 版。

五、适用场景

LangGraph 适合这些场景：

1. 智能体 Agent：ReAct 模式（思考-行动-观察循环）、Plan-and-Execute。
2. RAG 与检索增强：带自我纠错、查询重写、多跳检索的 RAG。
3. 复杂工作流：多步骤、有分支判断、需要循环的业务流程。
4. 多智能体协作：多个 Agent 分工合作（如"写手 Agent + 审稿 Agent"）。
5. 需要人机交互的流程：审核、确认、人工纠偏。
6. 需要持久化的长任务：断点续跑、回放、状态恢复。

不适合：单轮简单问答、纯线性无分支的链式调用——那种用 LangChain Chain 或直接调 API 更轻量。

六、核心特性一览

LangGraph 的六大核心特性：

mindmap
  root((LangGraph 核心特性))
    循环图 Cycle
      节点可成环
      支持迭代式智能体
    状态管理 State
      TypedDict/Pydantic
      Reducer 合并策略
    持久化 Checkpoint
      MemorySaver 内存
      SQLite/Postgres 持久
    人机交互 HITL
      interrupt 中断
      审核后继续
    流式 Streaming
      逐步输出
      多种 stream_mode
    容错 Fault Tolerance
      节点重试
      状态可回放

每个特性的含义：

• 循环图 Cycle：节点之间可以成环，支持"思考-行动-观察"这种迭代式智能体。
• 状态管理 State：用 TypedDict 或 Pydantic 定义状态，reducer 控制字段合并策略。
• 持久化 Checkpoint：MemorySaver 存内存、SQLite/Postgres 存磁盘，配合 thread_id 实现多轮记忆。
• 人机交互 HITL：interrupt() 在节点中暂停，等用户审核/输入后用 Command 恢复。
• 流式 Streaming：stream / astream 逐步输出，支持 values / updates / messages 等多种模式。
• 容错 Fault Tolerance：节点可重试，状态可回放，长任务断点续跑。

后续章节会逐一深入。本篇先建立整体印象。

七、Chain vs Graph 代码对比

直观感受两者差异。同样是"检索 + 生成"，纯 Chain 写法：

# 纯 LangChain Chain（线性，不能循环）
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import StrOutputParser

# 一条直线走到底，没法"质量不够回头重检索"
chain = (
    {"question": lambda x: x["question"]}
    | ChatPromptTemplate.from_template("基于通用知识回答：{question}")
    | ChatOpenAI()
    | StrOutputParser()
)
print(chain.invoke({"question": "LangGraph 是什么"}))

LangGraph 写法（能循环、能条件分支）：

# LangGraph（支持循环：检索质量不够就回头重检索）
from typing import TypedDict
from langgraph.graph import StateGraph, START, END

class State(TypedDict):
    question: str
    docs: list
    answer: str
    good_enough: bool

def retrieve(state): return {"docs": ["..."]}
def grade(state):    return {"good_enough": True}      # 评估检索质量
def generate(state): return {"answer": "..."}

def route(state):
    return "generate" if state["good_enough"] else "retrieve"  # 不够就回头

g = StateGraph(State)
g.add_node("retrieve", retrieve)
g.add_node("grade", grade)
g.add_node("generate", generate)
g.add_edge(START, "retrieve")
g.add_edge("retrieve", "grade")
g.add_conditional_edges("grade", route, {"generate": "generate", "retrieve": "retrieve"})
g.add_edge("generate", END)
app = g.compile()

区别一目了然：Chain 是直线，Graph 是网。前者写起来短，后者能表达"质量不够就回头"这类循环逻辑。

八、版本约定

本教程基于 langgraph 0.2+（截至写作时的稳定主线）。安装命令：

# Windows / macOS / Linux 通用
pip install "langgraph>=0.2" langchain-openai -i https://pypi.tuna.tsinghua.edu.cn/simple

如果你的代码用到了某些 API 和教程不一致，请先确认版本：

pip show langgraph

注意 LangGraph 迭代较快，0.2 到 0.3 之间可能有少量 API 变动（如 interrupt 替代旧版 human_in_loop 参数）。本教程以 0.2+ 的稳定写法为准。

九、学习路线图

建议按以下顺序学习：

graph LR
    A[01 快速入门] --> B[02 核心概念]
    B --> C[03 基础教程]
    C --> D[04 进阶特性]
    D --> E[05 智能体]
    E --> F[06 模型集成]
    F --> G[07 RAG 与检索]
    G --> H[08 实战项目]
    H --> I[09 部署与运维]

• 快速入门：先把环境跑通，写出第一个程序。
• 核心概念：State / Node / Edge / Reducer / 编译运行——这是地基。
• 基础教程：把这些概念拼装成常见模式。
• 进阶特性：持久化、HITL、流式、子图等"高级零件"。
• 智能体 / RAG / 实战：把零件组合成真实项目。

十、小结

• LangGraph 是 LangChain 团队出品的低层工作流编排引擎，适合构建有状态、可循环、可控的 AI 应用。
• 它和 LangChain 互补：LangChain 给积木，LangGraph 给图纸。
• 与 LangGraph4j 概念一一对应，Java 背景迁移友好。
• 核心特性：循环图、状态管理、持久化、人机交互、流式、容错。
• 本教程基于 langgraph 0.2+。

下一篇我们开始搭建 Python 环境——这是新手最容易踩坑的地方，务必走一遍。Python环境管理 →