LangGraph 简介 #
什么是 AI Agent？ #
在了解 LangGraph 之前，我们需要先理解"AI Agent"（AI 代理）的概念。AI Agent 是一种能够自主感知环境、做出决策并执行动作的智能系统。与传统的 LLM 应用不同，Agent 具有更强的自主性和目标导向性。
text
┌─────────────────────────────────────────────────────────────┐
│ AI Agent 的本质 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 传统 LLM 应用： │
│ 用户提问 ───> LLM 回答 ───> 结束 │
│ │
│ AI Agent： │
│ 用户目标 ───> Agent 思考 ───> 使用工具 ───> 观察结果 │
│ │ │
│ └──── 循环直到完成目标 ────┘ │
│ │
│ 核心能力： │
│ - 自主决策：根据目标选择行动 │
│ - 工具使用：调用外部工具完成任务 │
│ - 记忆管理：记住历史交互和知识 │
│ - 自我反思：评估结果并调整策略 │
│ │
└─────────────────────────────────────────────────────────────┘
传统 LLM 应用的局限 #
text
┌─────────────────────────────────────────────────────────────┐
│ 传统 LLM 应用的问题 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 问题 1：无状态 │
│ ❌ 每次请求独立，无法记住上下文 │
│ ❌ 无法处理多轮复杂对话 │
│ │
│ 问题 2：无工具 │
│ ❌ 无法访问外部数据源 │
│ ❌ 无法执行实际操作 │
│ │
│ 问题 3：无循环 │
│ ❌ 无法自主迭代改进 │
│ ❌ 无法处理复杂的多步骤任务 │
│ │
│ 问题 4：无控制 │
│ ❌ 执行过程不可控 │
│ ❌ 无法人工干预 │
│ │
└─────────────────────────────────────────────────────────────┘
什么是 LangGraph？ #
LangGraph 是由 LangChain 团队开发的低级编排框架和运行时，专门用于构建、管理和部署长时间运行的有状态 Agent。它基于图结构来定义 Agent 的工作流程，提供了精确的控制和高度的可定制性。
核心定位 #
text
┌─────────────────────────────────────────────────────────────┐
│ LangGraph │
├─────────────────────────────────────────────────────────────┤
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ 状态管理 │ │ 循环工作流 │ │ 持久化 │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ 人机交互 │ │ 流式输出 │ │ 可视化 │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
└─────────────────────────────────────────────────────────────┘
LangGraph 的历史 #
发展历程 #
text
2024年1月 ─── LangGraph 项目启动
│
│ LangChain 团队开发
│ 解决 Agent 编排问题
│
2024年3月 ─── 开源发布
│
│ 基于 Pregel 图计算模型
│ 支持循环和分支
│
2024年6月 ─── LangGraph Cloud
│
│ 托管服务发布
│ 生产级部署支持
│
2024年9月 ─── 重大更新
│
│ 增强的持久化
│ 人机交互改进
│
2025年 ─── 持续发展
│
│ 更多预构建组件
│ 性能优化
│ 企业级功能
里程碑版本 #
| 版本 | 时间 | 重要特性 |
|---|---|---|
| 0.0.1 | 2024.01 | 初始发布，核心图结构 |
| 0.1.0 | 2024.03 | 状态管理、检查点 |
| 0.2.0 | 2024.06 | LangGraph Cloud |
| 0.3.0 | 2024.09 | 人机交互增强 |
| 1.0.0 | 2025.01 | 稳定版发布 |
为什么选择 LangGraph？ #
传统 Agent 框架的痛点 #
在没有 LangGraph 之前，构建 Agent 面临以下问题：
python
# 传统方式：难以控制循环和状态
def agent_loop(user_input):
messages = [{"role": "user", "content": user_input}]
while True:
response = llm.invoke(messages)
messages.append(response)
if should_stop(response): # 何时停止？
break
tool_result = use_tool(response) # 如何管理工具？
messages.append(tool_result)
# 如何持久化？如何人工干预？
# 如何处理错误？如何调试？
LangGraph 的解决方案 #
python
# LangGraph：清晰的结构化定义
from langgraph.graph import StateGraph, MessagesState, START, END
def agent_node(state: MessagesState):
response = llm.invoke(state["messages"])
return {"messages": [response]}
def should_continue(state: MessagesState):
if state["messages"][-1].tool_calls:
return "tools"
return END
graph = StateGraph(MessagesState)
graph.add_node("agent", agent_node)
graph.add_node("tools", tool_node)
graph.add_edge(START, "agent")
graph.add_conditional_edges("agent", should_continue)
graph.add_edge("tools", "agent")
app = graph.compile() # 自动处理状态、持久化、调试
LangGraph 的核心特点 #
1. 基于图的工作流 #
text
┌─────────────────────────────────────────────────────────────┐
│ 图结构工作流 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────┐ │
│ │ START │ │
│ └────┬────┘ │
│ │ │
│ ▼ │
│ ┌─────────┐ 条件判断 ┌─────────┐ │
│ │ Agent │ ───────────────> │ Tools │ │
│ └────┬────┘ └────┬────┘ │
│ │ │ │
│ │ 完成任务 │ 继续处理 │
│ ▼ │ │
│ ┌─────────┐ │ │
│ │ END │ <─────────────────────┘ │
│ └─────────┘ │
│ │
│ 优势： │
│ ✅ 清晰的控制流 │
│ ✅ 支持循环和分支 │
│ ✅ 易于理解和调试 │
│ │
└─────────────────────────────────────────────────────────────┘
2. 状态管理 #
text
┌─────────────────────────────────────────────────────────────┐
│ 状态管理机制 │
├─────────────────────────────────────────────────────────────┤
│ │
│ State（状态）： │
│ { │
│ "messages": [...], // 对话历史 │
│ "documents": [...], // 检索的文档 │
│ "current_step": "...", // 当前步骤 │
│ "results": {...} // 中间结果 │
│ } │
│ │
│ 特点： │
│ ✅ 类型安全（TypedDict/Pydantic） │
│ ✅ 自动合并更新 │
│ ✅ 支持自定义 Reducer │
│ │
└─────────────────────────────────────────────────────────────┘
3. 持久化执行 #
text
┌─────────────────────────────────────────────────────────────┐
│ 持久化机制 │
├─────────────────────────────────────────────────────────────┤
│ │
│ Checkpoint（检查点）： │
│ │
│ 执行过程 ───> 自动保存状态 ───> 可随时恢复 │
│ │
│ 应用场景： │
│ ✅ 长时间运行的任务 │
│ ✅ 故障恢复 │
│ ✅ 暂停和继续 │
│ ✅ 人工审核后继续 │
│ │
└─────────────────────────────────────────────────────────────┘
4. 人机交互（Human-in-the-Loop） #
text
┌─────────────────────────────────────────────────────────────┐
│ 人机交互模式 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────┐ │
│ │ Agent │ │
│ └────┬────┘ │
│ │ │
│ │ 需要人工确认 │
│ ▼ │
│ ┌─────────────┐ │
│ │ Interrupt │ ───> 暂停执行 │
│ └──────┬──────┘ │
│ │ │
│ │ 人工审核/修改 │
│ ▼ │
│ ┌─────────────┐ │
│ │ Resume │ ───> 继续执行 │
│ └─────────────┘ │
│ │
│ 应用场景： │
│ - 敏感操作确认 │
│ - 结果审核 │
│ - 错误修正 │
│ │
└─────────────────────────────────────────────────────────────┘
5. 流式输出 #
text
┌─────────────────────────────────────────────────────────────┐
│ 流式输出 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 传统方式：等待全部完成 │
│ [等待...] ───> [完整结果] │
│ │
│ LangGraph 流式： │
│ [token1] ───> [token2] ───> [token3] ───> ... │
│ │
│ 支持多种流模式： │
│ - values：完整状态 │
│ - updates：增量更新 │
│ - messages：消息流 │
│ - custom：自定义流 │
│ │
└─────────────────────────────────────────────────────────────┘
LangGraph 与其他框架对比 #
LangGraph vs LangChain Agent #
| 特性 | LangGraph | LangChain Agent |
|---|---|---|
| 控制粒度 | 低级、精细 | 高级、抽象 |
| 循环支持 | 原生支持 | 有限支持 |
| 状态管理 | 内置 | 需要额外处理 |
| 持久化 | 内置 | 需要额外实现 |
| 人机交互 | 原生支持 | 有限支持 |
| 学习曲线 | 较陡 | 平缓 |
| 适用场景 | 复杂 Agent | 简单任务 |
LangGraph vs AutoGPT #
| 特性 | LangGraph | AutoGPT |
|---|---|---|
| 架构 | 图结构 | 自主循环 |
| 可定制性 | 极高 | 中等 |
| 控制能力 | 精确控制 | 自动化 |
| 生产就绪 | 是 | 实验性 |
| 部署方式 | 灵活 | 有限 |
LangGraph vs CrewAI #
| 特性 | LangGraph | CrewAI |
|---|---|---|
| 定位 | 低级框架 | 多 Agent 框架 |
| 灵活性 | 极高 | 中等 |
| 多 Agent | 需要构建 | 内置支持 |
| 学习成本 | 较高 | 较低 |
| 生产部署 | 成熟 | 发展中 |
LangGraph 的核心组件 #
1. StateGraph #
python
from langgraph.graph import StateGraph
# 定义状态
class State(TypedDict):
messages: list
documents: list
# 创建图
graph = StateGraph(State)
2. Nodes（节点） #
python
def agent_node(state: State):
# 处理逻辑
return {"messages": [response]}
graph.add_node("agent", agent_node)
3. Edges（边） #
python
# 普通边
graph.add_edge("agent", "tools")
# 条件边
graph.add_conditional_edges(
"agent",
should_continue,
{"continue": "tools", "end": END}
)
4. Checkpointer（检查点） #
python
from langgraph.checkpoint.memory import MemorySaver
checkpointer = MemorySaver()
app = graph.compile(checkpointer=checkpointer)
LangGraph 的应用场景 #
1. 智能客服 #
text
┌─────────────────────────────────────────────────────────────┐
│ 智能客服系统 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 流程： │
│ 用户问题 ───> 意图识别 ───> 知识检索 ───> 生成回答 │
│ │ │
│ └──> 需要人工 ───> 转人工客服 │
│ │
│ 特点： │
│ ✅ 多轮对话记忆 │
│ ✅ 知识库检索 │
│ ✅ 人工接管 │
│ ✅ 会话持久化 │
│ │
└─────────────────────────────────────────────────────────────┘
2. 代码助手 #
text
应用场景：
- 代码生成
- 代码审查
- Bug 修复
- 文档生成
特点：
✅ 理解代码上下文
✅ 多文件处理
✅ 迭代优化
✅ 结果验证
3. 数据分析 #
text
┌─────────────────────────────────────────────────────────────┐
│ AI 数据分析 Agent │
├─────────────────────────────────────────────────────────────┤
│ │
│ 输入：自然语言查询 │
│ "分析上季度销售数据，找出增长最快的产品" │
│ │
│ Agent 执行： │
│ 1. 理解查询意图 │
│ 2. 查询数据库 │
│ 3. 分析数据 │
│ 4. 生成可视化 │
│ 5. 撰写报告 │
│ │
│ 输出：分析报告 + 图表 │
│ │
└─────────────────────────────────────────────────────────────┘
4. 研究助手 #
text
应用场景：
- 文献调研
- 信息收集
- 报告撰写
- 数据整理
特点：
✅ 多源信息整合
✅ 自主搜索
✅ 内容验证
✅ 结构化输出
5. 工作流自动化 #
text
┌─────────────────────────────────────────────────────────────┐
│ 工作流自动化 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 示例：审批流程 │
│ │
│ 提交申请 ───> 自动审核 ───> 条件判断 │
│ │ │
│ ┌────────────────┼────────────────┐ │
│ ▼ ▼ ▼ │
│ 自动通过 人工审核 自动拒绝 │
│ │ │ │ │
│ └────────────────┴────────────────┘ │
│ │ │
│ ▼ │
│ 通知用户 │
│ │
└─────────────────────────────────────────────────────────────┘
LangGraph 的核心优势 #
优势总结 #
text
✅ 精确控制
- 完全控制 Agent 行为
- 灵活的流程定义
- 支持复杂逻辑
✅ 状态管理
- 内置状态管理
- 类型安全
- 自动合并
✅ 持久化
- 自动保存状态
- 故障恢复
- 暂停/继续
✅ 人机交互
- 原生支持
- 灵活的干预点
- 状态修改
✅ 可观测性
- 完整的执行追踪
- 可视化调试
- LangSmith 集成
✅ 生产就绪
- 可扩展架构
- 错误处理
- LangGraph Cloud
局限性 #
text
⚠️ 学习曲线
- 低级 API 需要更多学习
- 需要理解图结构概念
⚠️ 代码量
- 需要更多代码定义流程
- 相比高级框架更复杂
⚠️ 设计要求
- 需要提前规划流程
- 状态设计需要考虑周全
LangGraph 生态系统 #
text
┌─────────────────────────────────────────────────────────────┐
│ LangGraph 生态系统 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 核心组件： │
│ ├── langgraph - Python 核心库 │
│ ├── langgraph-js - JavaScript 版本 │
│ └── langgraph-sdk - SDK 和 CLI │
│ │
│ 部署平台： │
│ └── LangGraph Cloud - 托管服务 │
│ │
│ 集成工具： │
│ ├── LangChain - 模型和工具 │
│ ├── LangSmith - 可观测性 │
│ └── LangServe - API 服务 │
│ │
│ 预构建组件： │
│ ├── ToolNode - 工具执行节点 │
│ ├── MessageState - 消息状态 │
│ └── 预构建 Agent - 常见 Agent 模板 │
│ │
└─────────────────────────────────────────────────────────────┘
学习路径 #
text
入门阶段
├── LangGraph 简介（本文）
├── 快速开始
└── 核心概念
进阶阶段
├── 状态管理
├── 节点与边
├── 工具使用
└── 记忆与持久化
高级阶段
├── 人机交互
├── 高级模式
├── 多 Agent 系统
└── 部署与生产
实战阶段
├── 智能客服系统
├── 代码助手
├── 数据分析 Agent
└── 最佳实践
下一步 #
现在你已经了解了 LangGraph 的基本概念，接下来学习 快速开始，开始构建你的第一个 Agent！
最后更新：2026-03-30