LangChain 与 LangGraph 完全解析：从“流水线”到“智能流程图”

LangChain 与 LangGraph 完全解析：从"流水线"到"智能流程图"

关键词：LangChain、LangGraph、大模型应用开发、AI Agent、LCEL

📑 目录

1. 从两个装修队的故事说起
2. LangChain：大模型时代的"积木工具箱"
3. LangGraph：让AI"会拐弯"的流程图引擎
4. 一张图看懂 LangChain 与 LangGraph 的关系
5. 实战代码：从 LangChain 到 LangGraph
6. 什么时候该用谁？选型决策指南
7. 2025年最新动态：1.0 时代来了
8. 总结与学习路线

1. 从两个装修队的故事说起

想象你最近买了新房，需要做全屋装修。你找了两个装修队：

装修队 A 的工头是个"流程大师"。他会把装修拆成一系列固定步骤：水电改造 → 贴砖 → 刷墙 → 装柜子 → 铺地板。每一步做完才能做下一步，顺序清晰、有条不紊。如果你中途想"先铺地板再刷墙"，他会说："不行，流程不是这么设计的。"------这就是 LangChain 的风格：线性、有序、按部就班。

装修队 B 的工头是个"灵活调度员"。他不会死守固定顺序，而是根据现场情况动态决策：如果今天下雨不能刷外墙，他就先做室内；如果墙面没干透，他就先去铺地板；他甚至会同时让木工和电工一起进场干活。遇到复杂情况，他还会停下来问你："这个柜子要什么颜色？"------这就是 LangGraph 的风格：图结构、有状态、能循环、能分支、能等人。

两个装修队都能把房子装好，但适合的场景完全不同。LangChain 适合"流程明确、步骤固定"的任务，LangGraph 适合"需要动态决策、反复调整、多个角色协作"的复杂场景。

💡 一句话总结：LangChain 是"流水线"，LangGraph 是"流程图"。流水线适合重复性工作，流程图适合需要不断调整的复杂任务。

2. LangChain：大模型时代的"积木工具箱"

2.1 LangChain 是什么？

LangChain 是一个开源框架，专门用来帮助开发者构建基于大语言模型（LLM）的应用程序。它的核心思想是：把AI应用的各个组件像积木一样拼装起来。

框架的名字"LangChain"是"Language"（语言）和"Chain"（链）的组合，反映了它的核心设计理念------通过将模块化的组件串联（Chain）在一起来构建复杂的应用。

2.2 LangChain 的核心组件

LangChain 提供了七大类组件：

组件类别	作用	举例
Models（模型）	对接各种大语言模型	OpenAI GPT、Claude、DeepSeek
Prompts（提示词）	管理和格式化提示词	PromptTemplate
Chains（链）	将多个步骤串联成工作流	先总结、再翻译
Memory（记忆）	记住对话历史	ConversationBufferMemory
Tools（工具）	让AI调用外部能力	搜索、计算器、数据库查询
Agents（智能体）	让AI自主决定用哪个工具	ReAct Agent
Indexes（索引）	处理和检索文档	文档加载器、向量存储

2.3 LCEL：LangChain 的"胶水语言"

LangChain 最核心的创新是 LCEL（LangChain Expression Language，LangChain表达式语言） 。它用管道操作符 | 把各个组件串联起来，写法极其简洁：

from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI

# 定义提示词模板
prompt = PromptTemplate.from_template("用中文总结以下内容：{text}")

# 定义模型
model = ChatOpenAI(model="gpt-4o-mini")

# 用 | 串联成链
chain = prompt | model

# 执行
result = chain.invoke({"text": "Artificial intelligence is transforming..."})

是不是很像 Unix 的管道命令？prompt | model 的意思是：把 prompt 的输出（格式化后的提示词）直接传给 model。

更复杂的多步骤链也是同样的写法：

# 先总结 → 再翻译成西班牙语
summarize_prompt = PromptTemplate.from_template("总结：{text}")
translate_prompt = PromptTemplate.from_template("翻译成西班牙语：{summary}")

summarize_chain = summarize_prompt | model
translate_chain = translate_prompt | model

# 组合成两步流水线
full_chain = summarize_chain | (lambda x: {"summary": x.content}) | translate_chain

💡 LCEL 的核心优势 ：声明式、可组合、易调试。你不需要写一堆 if/else 和循环，只需要用 | 把组件"拼"在一起。

2.4 LangChain 适合做什么？

• RAG（检索增强生成） ：从文档库中检索相关信息，再让LLM基于这些信息回答
• 文档处理流水线：加载 → 分割 → 向量化 → 存储 → 检索 → 生成
• 简单的问答机器人
• 文本摘要、翻译、分类等一次性任务

一句话：如果你的任务流程是"线性的、步骤固定的"，LangChain 是你的不二之选。

3. LangGraph：让AI"会拐弯"的流程图引擎

3.1 LangGraph 是什么？

LangGraph 是 LangChain 生态系统中的一个专门库，用于构建有状态的、多步骤的、图结构的工作流。

如果说 LangChain 是"流水线"（一条直路走到头），那 LangGraph 就是"流程图"------有分支、有循环、有回退、有并行。

LangGraph 被 Replit、Uber、LinkedIn、GitLab、Klarna、J.P. Morgan 等公司用于生产环境。2025年10月，LangGraph 发布了 1.0 正式版，成为"持久化智能体框架"领域的第一个稳定大版本。

3.2 LangGraph 的核心概念

LangGraph 把工作流抽象成一张有向图（Graph） ：

概念	含义	类比
节点（Node）	一个执行步骤	流程图里的一个方框
边（Edge）	节点之间的流转路径	方框之间的箭头
条件边（Conditional Edge）	根据状态决定走哪条路	"如果下雨走A路，否则走B路"
状态（State）	在整个流程中传递和共享的数据	一个所有人都在上面写字的共享白板

节点 可以是一个LLM调用、一个工具调用、一个函数、甚至是一个人机交互的暂停点。状态则在节点之间传递，每个节点都能读取和修改它。

3.3 LangGraph 的四大核心能力

LangGraph 提供了四个传统线性流程难以实现的核心能力：

① 持久化执行（Durable Execution）

想象一下：一个AI智能体正在执行一个需要运行 10 分钟的复杂任务，跑到第 8 分钟时服务器崩溃了。传统方案：从头再来。LangGraph：从崩溃的地方接着跑------因为每一步的状态都被自动保存了。

② 人机协作（Human-in-the-Loop）

AI在执行过程中可以停下来等人类审批。比如一个金融交易智能体准备下单时，可以暂停并询问："这笔交易金额较大，请确认是否执行？"这在传统线性流程中几乎无法实现。

③ 循环与分支（Loops & Branching）

AI可以反复执行某个步骤直到条件满足。比如"写代码 → 运行测试 → 如果失败就修改代码 → 再运行测试"这个循环，在 LangGraph 中就是一个带条件边的图。

④ 全面的记忆（Comprehensive Memory）

不仅支持短期记忆 （当前对话的上下文），还支持长期记忆（跨会话的持久化存储）。

3.4 LangGraph 适合做什么？

• 复杂的 AI Agent（智能体） ：需要多轮思考、调用工具、根据结果调整策略
• 多智能体协作系统：多个AI角色分工合作
• 需要人工审批的业务流程：金融交易、医疗诊断、合同审核
• 长时间运行的任务：需要断点续跑、状态持久化
• 研究型 Agent：自主规划、执行、反思、再规划

💡 一句话：如果你的任务"会拐弯、会循环、需要等人、需要记住很多事"，LangGraph 是你的最佳选择。

4. 一张图看懂 LangChain 与 LangGraph 的关系

很多初学者会问："LangGraph 是 LangChain 的替代品吗？"不是。

LangGraph 构建在 LangChain 之上 ，是 LangChain 生态系统的一部分。你可以把 LangGraph 想象成 LangChain 的"高级扩展包"------它用了 LangChain 的所有组件（模型、提示词、工具等），但加了一层图结构编排引擎。

两者的关系可以这样理解：

	LangChain	LangGraph
定位	组件库 + 线性编排	图结构编排引擎
核心抽象	Chain（链）	Graph（图）
流程控制	线性顺序	分支、循环、并行、条件跳转
状态管理	简单（Memory组件）	强大（中央状态管理）
人工干预	不支持	原生支持
断点续跑	不支持	原生支持
学习曲线	平缓	较陡
代码量	少（LCEL 很简洁）	多（需要定义图结构）

💡 最重要的区别 ：LangChain 的 Chain 是线性 的------A→B→C→D，一条路走到底。LangGraph 的 Graph 是网状 的------可以从A到B或C，B可以回到A，C可以到D也可以到E。LangChain 版本的代码写起来更快，LangGraph 版本能在服务器崩溃后断点续跑，还能在节点之间暂停等待人工审批。

5. 实战代码：从 LangChain 到 LangGraph

5.1 安装

# 安装 LangChain
pip install langchain langchain_openai

# 安装 LangGraph
pip install langgraph

5.2 LangChain 版本：一个简单的问答链

from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI

# 定义提示词
prompt = PromptTemplate.from_template("请回答以下问题：{question}")

# 定义模型
model = ChatOpenAI(model="gpt-4o-mini")

# 用 LCEL 创建链
chain = prompt | model

# 执行
result = chain.invoke({"question": "什么是人工智能？"})
print(result.content)

这就是一个典型的 LangChain 应用：线性 、简单 、一次性执行。

5.3 LangGraph 版本：一个带"反思循环"的智能体

同样的"回答问题"任务，用 LangGraph 可以做得更智能------让AI先回答，再自己检查答案质量，不满意就重新回答：

from langgraph.graph import StateGraph, MessagesState, START, END
from langchain_openai import ChatOpenAI
from typing import Literal

model = ChatOpenAI(model="gpt-4o-mini")

# 定义状态（在节点之间共享的数据）
class AgentState(MessagesState):
    attempt: int          # 尝试次数
    best_answer: str      # 当前最佳答案
    quality_score: int    # 质量评分

# 节点1：生成答案
def generate_answer(state: AgentState):
    response = model.invoke(state["messages"])
    return {
        "messages": [response],
        "attempt": state.get("attempt", 0) + 1,
        "best_answer": response.content,
    }

# 节点2：评估答案质量
def evaluate_answer(state: AgentState):
    eval_prompt = f"请给以下答案打分（1-10）：{state['best_answer']}"
    eval_response = model.invoke(eval_prompt)
    # 简单模拟评分逻辑
    score = 8 if "好" in eval_response.content else 5
    return {"quality_score": score}

# 条件边：根据评分决定下一步
def should_continue(state: AgentState) -> Literal["generate", END]:
    if state["quality_score"] < 7 and state["attempt"] < 3:
        return "generate"  # 评分低且未达上限 → 重新生成
    return END  # 评分达标或已达上限 → 结束

# 构建图
graph = StateGraph(AgentState)
graph.add_node("generate", generate_answer)
graph.add_node("evaluate", evaluate_answer)
graph.add_edge(START, "generate")
graph.add_edge("generate", "evaluate")
graph.add_conditional_edges("evaluate", should_continue)  # 条件分支！
graph.add_edge("generate", END)

# 编译并执行
app = graph.compile()
result = app.invoke({"messages": [{"role": "user", "content": "什么是人工智能？"}]})
print(result["best_answer"])

看到了吗？ 这个流程会：

1. 生成一个答案
2. 评估这个答案的质量
3. 如果质量不行（<7分）且尝试次数不到3次 → 回到第1步重新生成
4. 如果质量达标或尝试了3次 → 结束

这就是 LangGraph 的"循环"能力------在 LangChain 的线性链中无法实现。

5.4 一个更真实的例子：多智能体协作

LangGraph 最强大的场景是多智能体协作。想象一个"AI 研究助手"系统：

# 伪代码示意架构
# 三个智能体分工协作：
# - 研究员 Agent：负责搜索和收集信息
# - 分析师 Agent：负责分析和总结
# - 撰稿人 Agent：负责撰写最终报告

# 工作流：
# 用户提问 → 研究员搜索 → 分析师总结 → 撰稿人撰写 → 研究员补充 → 分析师优化 → 撰稿人定稿
#                    ↑_______________↓（可以循环多次直到满意）

每个 Agent 都是一个节点，节点之间的流转由条件边根据当前状态动态决定。这种架构在 LangChain 中几乎无法实现，但在 LangGraph 中却是"天生就会"的。

6. 什么时候该用谁？选型决策指南

6.1 决策树

#mermaid-svg-zs9UD6cGR41wLl7j{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-zs9UD6cGR41wLl7j .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-zs9UD6cGR41wLl7j .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-zs9UD6cGR41wLl7j .error-icon{fill:#552222;}#mermaid-svg-zs9UD6cGR41wLl7j .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-zs9UD6cGR41wLl7j .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-zs9UD6cGR41wLl7j .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-zs9UD6cGR41wLl7j .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-zs9UD6cGR41wLl7j .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-zs9UD6cGR41wLl7j .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-zs9UD6cGR41wLl7j .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-zs9UD6cGR41wLl7j .marker{fill:#333333;stroke:#333333;}#mermaid-svg-zs9UD6cGR41wLl7j .marker.cross{stroke:#333333;}#mermaid-svg-zs9UD6cGR41wLl7j svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-zs9UD6cGR41wLl7j p{margin:0;}#mermaid-svg-zs9UD6cGR41wLl7j .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-zs9UD6cGR41wLl7j .cluster-label text{fill:#333;}#mermaid-svg-zs9UD6cGR41wLl7j .cluster-label span{color:#333;}#mermaid-svg-zs9UD6cGR41wLl7j .cluster-label span p{background-color:transparent;}#mermaid-svg-zs9UD6cGR41wLl7j .label text,#mermaid-svg-zs9UD6cGR41wLl7j span{fill:#333;color:#333;}#mermaid-svg-zs9UD6cGR41wLl7j .node rect,#mermaid-svg-zs9UD6cGR41wLl7j .node circle,#mermaid-svg-zs9UD6cGR41wLl7j .node ellipse,#mermaid-svg-zs9UD6cGR41wLl7j .node polygon,#mermaid-svg-zs9UD6cGR41wLl7j .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-zs9UD6cGR41wLl7j .rough-node .label text,#mermaid-svg-zs9UD6cGR41wLl7j .node .label text,#mermaid-svg-zs9UD6cGR41wLl7j .image-shape .label,#mermaid-svg-zs9UD6cGR41wLl7j .icon-shape .label{text-anchor:middle;}#mermaid-svg-zs9UD6cGR41wLl7j .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-zs9UD6cGR41wLl7j .rough-node .label,#mermaid-svg-zs9UD6cGR41wLl7j .node .label,#mermaid-svg-zs9UD6cGR41wLl7j .image-shape .label,#mermaid-svg-zs9UD6cGR41wLl7j .icon-shape .label{text-align:center;}#mermaid-svg-zs9UD6cGR41wLl7j .node.clickable{cursor:pointer;}#mermaid-svg-zs9UD6cGR41wLl7j .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-zs9UD6cGR41wLl7j .arrowheadPath{fill:#333333;}#mermaid-svg-zs9UD6cGR41wLl7j .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-zs9UD6cGR41wLl7j .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-zs9UD6cGR41wLl7j .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-zs9UD6cGR41wLl7j .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-zs9UD6cGR41wLl7j .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-zs9UD6cGR41wLl7j .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-zs9UD6cGR41wLl7j .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-zs9UD6cGR41wLl7j .cluster text{fill:#333;}#mermaid-svg-zs9UD6cGR41wLl7j .cluster span{color:#333;}#mermaid-svg-zs9UD6cGR41wLl7j div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-zs9UD6cGR41wLl7j .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-zs9UD6cGR41wLl7j rect.text{fill:none;stroke-width:0;}#mermaid-svg-zs9UD6cGR41wLl7j .icon-shape,#mermaid-svg-zs9UD6cGR41wLl7j .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-zs9UD6cGR41wLl7j .icon-shape p,#mermaid-svg-zs9UD6cGR41wLl7j .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-zs9UD6cGR41wLl7j .icon-shape .label rect,#mermaid-svg-zs9UD6cGR41wLl7j .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-zs9UD6cGR41wLl7j .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-zs9UD6cGR41wLl7j .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-zs9UD6cGR41wLl7j :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 线性、步骤固定
有分支/循环/回退
是
否
是
否
开始选型
你的任务流程是

线性还是图状？
✅ LangChain
✅ LangGraph
场景：RAG、文档处理、

简单问答、文本摘要
需要人工审批

或断点续跑吗？
✅ LangGraph
需要多个AI

协作吗？
✅ LangGraph
✅ LangGraph

（复杂单Agent也值得）

6.2 详细场景对照表

你的需求	推荐	原因
做一个 RAG 问答系统（检索 → 生成）	LangChain	流程线性，LCEL 写起来极其简洁
批量文档摘要翻译	LangChain	固定流水线，无需复杂控制流
一个会调用工具的 AI 助手（单轮）	LangChain	Agent 功能足够
一个会"思考-行动-观察-再思考"的 AI 助手（多轮）	LangGraph	需要循环和状态管理
需要人工审批的金融交易系统	LangGraph	原生支持 Human-in-the-Loop
多智能体协作（研究员+分析师+撰稿人）	LangGraph	天生为多智能体设计
长时间运行、可能中断的任务	LangGraph	持久化执行，断点续跑
快速原型验证	LangChain	代码量少，上手快
生产级复杂系统	LangGraph	更可控、更健壮

6.3 一个重要的提醒

两者不是互斥的。你可以（也应该）在 LangGraph 的节点内部使用 LangChain 的组件。比如：

• 用 LangChain 的 PromptTemplate 来管理提示词
• 用 LangChain 的 ChatOpenAI 来调用模型
• 用 LangChain 的 Tool 来定义工具
• 用 LangGraph 来编排这些组件之间的流转逻辑

💡 最佳实践：用 LangChain 处理"每个步骤内部怎么做"，用 LangGraph 处理"步骤之间怎么跳转"。

7. 2025年最新动态：1.0 时代来了

2025年是 LangChain 和 LangGraph 的里程碑之年。

2025年9月 ：LangChain 和 LangGraph 同时发布 1.0 alpha 版本。

2025年10月 ：LangGraph 1.0 正式版 正式发布。这是"持久化智能体框架"领域的第一个稳定大版本。LangChain 也同步发布了 1.0 版本。

1.0 版本的重要变化：

• Python 3.9 支持被移除 ，要求 Python 3.10+
• create_react_agent 被标记为弃用，推荐使用新的 create_agent API
• 两个框架都进入了生产级稳定阶段

对于开发者来说，这意味着：

• ✅ 可以放心在生产环境中使用
• ✅ API 将更加稳定，不会频繁变动
• ✅ 社区生态更加成熟

8. 总结与学习路线

核心知识点回顾

✅ LangChain = 大模型应用的"积木工具箱" + "流水线编排器"

✅ LCEL = 用 | 串联组件的声明式语法，简洁高效

✅ LangGraph = 图结构的智能体编排引擎，支持循环、分支、状态、持久化

✅ 两者关系 = LangGraph 构建在 LangChain 之上，不是替代而是增强

✅ 选型原则 = 线性流程用 LangChain，复杂控制流用 LangGraph

学习路线图

阶段	目标	实践任务
第 1 天	理解基本概念	读完本文，用手画出你的任务流程图------是线性的还是带分支的？
第 3 天	上手 LangChain	用 LCEL 搭建一个简单的 RAG 问答系统
第 1 周	理解 LangGraph 核心	运行 5.3 节的"反思循环"代码，理解状态和条件边
第 2 周	构建第一个 Agent	用 LangGraph 构建一个"能调用工具、能自我反思"的智能体
第 3 周	多智能体系统	实现"研究员 + 分析师 + 撰稿人"的协作系统

推荐资源

• LangChain 官方文档
• LangGraph 官方文档
• LangGraph 免费课程
• LangSmith（调试和观测工具）