LangChain 与 LangGraph 入门
·
本文不假设你懂 AI、不假设你写过 Python LLM 代码，只要你写过几行代码、知道"调用 API"是什么意思，就能看懂。
看完这篇，你应该能：
- 说清楚 LangChain 是干嘛的
- 说清楚 LangGraph 是干嘛的
- 知道两者的关系和差异
- 看懂别人写的 LangChain / LangGraph 代码大致在做什么
一、先搞懂背景：为什么会有这两个框架？
1.1 调用大模型其实很简单
调用 ChatGPT、通义千问这类大模型（LLM），本质上就是一次 HTTP 请求：
import openai
response = openai.ChatCompletion.create(
model="gpt-4",
messages=[{"role": "user", "content": "你好"}]
)
print(response.choices[0].message.content)
就这么几行，AI 应用的"心脏"就有了。那为什么还需要框架？
1.2 因为真实业务远比"调一次 API"复杂
实际做产品时，你会遇到这些麻烦事：
| 麻烦事 | 例子 |
|---|---|
| Prompt 管理 | 上百个 Prompt 散落在代码里，难维护 |
| 多模型切换 | 今天用 OpenAI、明天换通义千问，不想全改一遍 |
| 结合业务数据 | 让 AI 基于公司内部文档回答（RAG） |
| 调用工具 | 让 AI 能查数据库、订机票、发邮件 |
| 多步骤决策 | 先查 A，根据结果决定查 B 还是 C |
| 记忆上下文 | 多轮对话不能每次都重头说 |
| 流程控制 | 失败重试、人工审批、并行执行… |
如果每次都从零写，重复工作量极大。LangChain 和 LangGraph 就是来帮你解决这些问题的"脚手架"。
二、LangChain：LLM 应用的"瑞士军刀"
2.1 一句话定义
LangChain 是一套围绕"调用大模型"的工具箱，把开发 AI 应用要用到的零件（Prompt、模型、工具、记忆、检索）都封装好，让你像搭积木一样组合。
2.2 核心组件（记住这 6 个就够入门）
┌─────────────────────────────────────────────────┐
│ LangChain 六大核心组件 │
├─────────────────────────────────────────────────┤
│ 1. Models —— 大模型的统一封装 │
│ 2. Prompts —— Prompt 模板化 │
│ 3. Output Parsers —— 把 LLM 输出解析成结构化数据│
│ 4. Tools —— 让 LLM 能调用外部能力 │
│ 5. Memory —— 多轮对话的记忆 │
│ 6. Retrievers —— 从知识库检索（RAG 的核心） │
└─────────────────────────────────────────────────┘
2.3 一个最小例子：从"裸调 API"到"用 LangChain"
裸调 OpenAI：
import openai
text = "Spring Boot 是什么？"
prompt = f"用一句话解释：{text}"
response = openai.ChatCompletion.create(
model="gpt-4",
messages=[{"role": "user", "content": prompt}]
)
print(response.choices[0].message.content)
用 LangChain：
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
# 1. 定义 Prompt 模板（占位符 {text}）
prompt = ChatPromptTemplate.from_template("用一句话解释：{text}")
# 2. 选择模型（换通义千问只改这一行）
llm = ChatOpenAI(model="gpt-4")
# 3. 用管道符 | 串起来（这就是 "Chain"）
chain = prompt | llm
# 4. 调用
result = chain.invoke({"text": "Spring Boot 是什么？"})
print(result.content)
好处一眼可见：
- Prompt 模板化，可复用、可管理
- 换模型只改一行
|管道符让流程一目了然
2.4 升级例子：让 LLM 调用工具
from langchain.tools import tool
from langchain.agents import create_tool_calling_agent, AgentExecutor
# 定义工具：用 @tool 装饰器，注释会被 LLM 看到
@tool
def get_weather(city: str) -> str:
"""查询指定城市的当前天气"""
return f"{city} 今天晴天，25°C"
@tool
def get_time(timezone: str) -> str:
"""获取指定时区的当前时间"""
return "2024-03-01 15:30"
# 把工具交给 Agent，LLM 自己决定调哪个
tools = [get_weather, get_time]
agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools)
# 用户问问题，LLM 自动决定调用哪些工具
executor.invoke({"input": "杭州现在天气怎么样？几点了？"})
LLM 内部的思考过程：
LLM："用户问天气和时间 → 我需要调 get_weather 和 get_time"
→ 调用 get_weather("杭州") → "晴天 25°C"
→ 调用 get_time("Asia/Shanghai") → "15:30"
→ 综合回答："杭州现在晴天 25°C，时间是 15:30"
2.5 LangChain 的局限
LangChain 的 Chain 本质是线性管道：A → B → C → 输出。
但真实场景常常需要：
- 分支：根据中间结果走不同路径
- 循环：失败了重试、不满意了重做
- 多 Agent 协作：研究员 → 写手 → 编辑
- 人工介入：关键节点需要人确认
LangChain 的 AgentExecutor 虽然能让 LLM “自主决策”，但完全交给 LLM 不可控、不稳定。这时候就需要 LangGraph 了。
三、LangGraph：Agent 工作流的"编排引擎"
3.1 一句话定义
LangGraph 是一个用"有向图"编排 AI Agent 工作流的框架，开发者画好流程图，LLM 在每个节点里干活，整个流程可控、可分支、可循环、可暂停。
3.2 核心三概念
1. State（状态） —— 整个流程共享的数据，每个节点可读可写
2. Node（节点） —— 一个函数，负责干一件事（可以调 LLM、可以纯代码）
3. Edge（边） —— 节点之间的连接，决定执行顺序
└─ 普通边：A → B
└─ 条件边：根据 State 决定走 A 还是 B
3.3 一个完整例子：智能客服 Bot
需求：用户提问 → 判断是闲聊还是技术问题 → 闲聊直接回答，技术问题先查知识库再回答。
┌─────────┐
│ 开始 │
└────┬────┘
▼
┌──────────────┐
│ ① 意图分类 │
└──────┬───────┘
│
┌────┴────┐
│条件分支 │
▼ ▼
┌──────┐ ┌────────────┐
│②闲聊 │ │③ 检索知识库 │
└──┬───┘ └──────┬─────┘
│ ▼
│ ┌──────────────┐
│ │ ④ 生成回答 │
│ └──────┬───────┘
└──────┬──────┘
▼
┌─────────┐
│ END │
└─────────┘
代码：
from langgraph.graph import StateGraph, END
from typing import TypedDict
# 1. 定义共享状态
class State(TypedDict):
question: str # 用户问题
intent: str # 意图分类结果
docs: list # 检索到的文档
answer: str # 最终答案
# 2. 定义节点（每个节点都是一个函数）
def classify_intent(state):
"""① 用 LLM 分类意图"""
intent = llm.invoke(f"判断是闲聊还是技术问题：{state['question']}")
return {"intent": intent}
def chitchat(state):
"""② 闲聊：直接让 LLM 回答"""
answer = llm.invoke(state["question"])
return {"answer": answer}
def retrieve(state):
"""③ 从向量库检索相关文档"""
docs = vector_store.search(state["question"], k=3)
return {"docs": docs}
def generate(state):
"""④ 基于检索结果生成答案"""
prompt = f"参考资料：{state['docs']}\n问题：{state['question']}"
answer = llm.invoke(prompt)
return {"answer": answer}
# 3. 构建图
graph = StateGraph(State)
graph.add_node("classify", classify_intent)
graph.add_node("chitchat", chitchat)
graph.add_node("retrieve", retrieve)
graph.add_node("generate", generate)
# 4. 画边
graph.set_entry_point("classify")
# 条件边：根据 intent 字段决定走哪条路
graph.add_conditional_edges(
"classify",
lambda state: state["intent"], # 路由函数
{
"闲聊": "chitchat",
"技术问题": "retrieve",
}
)
graph.add_edge("retrieve", "generate")
graph.add_edge("generate", END)
graph.add_edge("chitchat", END)
# 5. 编译并运行
app = graph.compile()
result = app.invoke({"question": "Spring Boot 怎么配置数据源？"})
print(result["answer"])
3.4 LangGraph 的杀手锏
| 能力 | 说明 |
|---|---|
| 条件分支 | add_conditional_edges 实现 if-else 流程 |
| 循环 | 边可以指回之前的节点，实现重试/迭代 |
| 并行 | 一个节点可以连接多个下游节点同时执行 |
| 人工介入 | interrupt_before=["confirm"] 在某节点暂停等人 |
| 状态持久化 | State 可存到 Redis/PG，支持断点续跑 |
| 可视化 | 自动生成流程图，方便调试 |
| 多 Agent | 每个 Node 可以是一个独立 Agent，实现协作 |
四、LangChain vs LangGraph：核心对比
4.1 关系图
┌─────────────────────────────────────────────┐
│ LangChain（基础层） │
│ 提供模型封装、Prompt、Tools、RAG 组件... │
└──────────────────┬──────────────────────────┘
│ LangGraph 建立在它之上
▼
┌─────────────────────────────────────────────┐
│ LangGraph（编排层） │
│ 用图来组织复杂的多步骤 Agent 工作流 │
└─────────────────────────────────────────────┘
4.2 对比表
| 维度 | LangChain | LangGraph |
|---|---|---|
| 定位 | 工具箱（组件库） | 编排引擎（工作流） |
| 执行模型 | 线性 Chain | 有向图 |
| 流程控制 | 固定顺序 | 分支 + 循环 + 并行 |
| 状态管理 | 简单 Memory | 显式 State 对象 |
| 多 Agent | 不擅长 | ✅ 原生支持 |
| 人工介入 | 不支持 | ✅ 节点级暂停 |
| 学习曲线 | 低 | 中 |
| 适用场景 | 简单问答、RAG、单工具调用 | 复杂 Agent、多步决策、审批流 |
4.3 类比
| 类比 | |
|---|---|
| LangChain | 一条流水线：原料进 → 产品出，只能一条路 |
| LangGraph | 一张地图：有岔路、红绿灯、掉头点、收费站 |
4.4 什么时候用哪个？
用 LangChain 就够了：
- 单轮问答机器人
- 简单 RAG 知识库问答
- Prompt + LLM + 输出解析的固定流程
- LLM 自动调用 1-2 个工具
该上 LangGraph：
- 多步骤工作流（先 A 后 B 再 C）
- 需要分支判断
- 需要失败重试 / 循环优化
- 需要人工审批节点
- 多 Agent 协作（研究员+写手+审核）
- 长流程需要持久化、断点续跑
五、给初学者的学习路径建议
5.1 学习顺序
第 1 步：先调通一次 OpenAI / 通义千问 API
└─ 理解"调大模型"本质是 HTTP 请求
第 2 步：学 LangChain 基础
├─ Prompt Template
├─ ChatModel（统一接口）
├─ 用 | 串起来跑通一个 Chain
└─ Output Parser（解析 JSON 输出）
第 3 步：学 LangChain 进阶
├─ Tools（让 LLM 调函数）
├─ Memory（多轮对话）
└─ RAG（向量库 + Retriever）
第 4 步：学 LangGraph
├─ State / Node / Edge 三大概念
├─ 条件边、循环
├─ 人工介入（interrupt）
└─ 多 Agent 协作
第 5 步：做一个综合项目
└─ 比如"AI 旅行助手"、"智能客服"
5.2 推荐资源
- 官方文档（首选）：python.langchain.com、langchain-ai.github.io/langgraph
- LangSmith：LangChain 官方的可视化调试工具，强烈建议接入
- 官方示例仓库：GitHub
langchain-ai/langchain的cookbook目录
5.3 初学者常见误区
| 误区 | 正解 |
|---|---|
| “LangChain 是模型” | ❌ LangChain 只是脚手架，模型还是要调 OpenAI/通义千问 |
| “用了框架性能更好” | ❌ 框架只是组织代码，性能取决于底层模型和数据 |
| “Chain 越长越好” | ❌ 能用 1 步搞定就别用 3 步，越长越慢、越贵、越易错 |
| “LangGraph 替代 LangChain” | ❌ LangGraph 依赖 LangChain，是补充不是替代 |
| “AI 框架就只有 LangChain” | ❌ 还有 LlamaIndex（偏 RAG）、Spring AI（Java）、Semantic Kernel（微软）等 |
六、总结：一图记住
┌──────────────────────────────────────────────────┐
│ LangChain = LLM 应用的"积木块" │
│ （Prompt + 模型 + 工具 + 记忆 + 检索）│
│ │
│ LangGraph = 把积木块组装成复杂工作流的"图纸引擎" │
│ （状态 + 节点 + 边 + 分支 + 循环） │
└──────────────────────────────────────────────────┘
简单场景 → LangChain
复杂场景 → LangChain + LangGraph
最重要的一句话：
LangChain 让你优雅地调用大模型，LangGraph 让你优雅地编排大模型。
前者解决"怎么用 LLM"，后者解决"怎么把 LLM 串成一个完整业务流程"。
作者注：这篇文档是我自己学习过程中的整理，难免有疏漏。如果你发现错误，或者希望我深入讲某个点（比如 RAG 详解、Agent 实战、与 Spring AI 对比等），欢迎继续讨论。
AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。
更多推荐
9
0- 0
已为社区贡献4条内容
所有评论(0)