LangChain Agent 完全指南
·
LangChain Agent 完全指南
从零到一理解 AI 智能体
目录
- 第一章：为什么需要 Agent？
- 第二章：create_agent 是什么？
- 第三章：ReAct 模式——Agent 的核心循环
- 第四章：技术架构——三层理解
- 第五章：LCEL vs LangGraph
- 第六章：动手实践——从零构建 Agent
- 第七章：技术选型指南
- 第八章：核心概念速查表
- 第九章：学习路线建议
- 第十章：总结与展望
第一章：为什么需要 Agent？
1.1 AI 的"囚笼困境"
想象一下，你有一个超级聪明的助手——它博览群书、思维敏捷，能回答各种复杂问题。但它有一个致命的缺陷：
它被困在一个"知识囚笼"里。
具体来说：
| 缺陷 | 说明 | 例子 |
|---|---|---|
| 📅 知识截止 | 知识停留在训练完成那一刻 | GPT-4 不知道 2025 年之后的事 |
| 🚫 无法行动 | 只能"说"，不能"做" | 能告诉你如何订票，但无法真正帮你订 |
| 🔒 信息孤岛 | 无法主动获取外部信息 | 不知道实时天气、股价、新闻 |
1.2 Agent 就是"给 AI 装上手和脚"
Agent（智能体） 的出现，就是为了打破这个囚笼：
┌─────────────────────────────────────────────────────────┐
│ 传统 LLM │
│ │
│ 用户提问 ──→ 模型推理 ──→ 输出答案 │
│ │
│ ⚠️ 只能基于训练数据回答，无法获取新信息 │
└─────────────────────────────────────────────────────────┘
⬇️ 升级为 Agent
┌─────────────────────────────────────────────────────────┐
│ Agent（智能体） │
│ │
│ 用户提问 ──→ 模型思考 ──→ 需要查资料？ │
│ │ │
│ ┌──────┴──────┐ │
│ ▼ ▼ │
│ 调用工具 直接回答 │
│ │ │
│ ▼ │
│ 获取最新信息 │
│ │ │
│ ▼ │
│ 再次思考 ──→ 输出答案 │
│ │
│ ✅ 可以主动查询外部信息、执行实际操作 │
└─────────────────────────────────────────────────────────┘
1.3 Agent 的核心能力
一个完整的 Agent 具备三种核心能力：
- 推理能力（Reasoning）：分析问题，制定计划
- 行动能力（Acting）：调用工具，获取信息
- 记忆能力（Memory）：记住之前说过什么、做过什么
这三种能力的结合，让 Agent 能够像人类一样边思考边行动，直到解决问题。
第二章：create_agent 是什么？
2.1 最简单的理解
create_agent 是 LangChain 提供的一个工厂函数，用一行代码就能创建一个功能完整的 AI 智能体：
from langchain.agents import create_agent
from langchain_openai import ChatOpenAI
# 准备"大脑"
model = ChatOpenAI(model="gpt-4")
# 准备"工具"
def get_weather(city: str) -> str:
return f"{city} 今天晴天，25°C"
tools = [get_weather]
# 一行代码创建 Agent
agent = create_agent(
model=model,
tools=tools,
system_prompt="你是一个有用的助手"
)
# 使用 Agent
result = agent.invoke({
"messages": [("user", "北京今天天气怎么样？")]
})
print(result["messages"][-1].content)
# 输出: 北京今天晴天，25°C
看起来很简单，对吧？但背后发生的事情非常精彩！
2.2 create_agent 的本质
create_agent本质上构建了一个在 Model 和 Tools 节点之间循环的 LangGraph 状态图。
用一张图来理解：
┌─────────────────────────────────────────────────────────────────────┐
│ LangGraph 状态图 │
│ │
│ ┌──────────┐ │
│ │ START │ │
│ └────┬─────┘ │
│ │ │
│ ▼ │
│ ┌──────────┐ │
│ │ MODEL │ │
│ │ 节点 │ │
│ └────┬─────┘ │
│ │ │
│ │ 有 tool_calls? │
│ ┌────┴────┐ │
│ │ │ │
│ ▼ ▼ │
│ ┌─────────┐ ┌─────────┐ │
│ │ TOOLS │ │ END │ │
│ │ 节点 │ └─────────┘ │
│ └────┬────┘ │
│ │ │
│ │ 执行完毕 │
│ │ │
│ ▼ │
│ ┌─────────┐ │
│ │ 回到 │ │
│ │ MODEL │────────────────────┐ │
│ └─────────┘ │ │
│ ▲ │ │
│ └─────────────────────────┘ │
│ │
│ 流转规则： │
│ 1. START → MODEL（开始执行） │
│ 2. MODEL 判断是否有 tool_calls │
│ • 有 → TOOLS 节点执行 │
│ • 无 → END（结束） │
│ 3. TOOLS 执行完毕 → 回到 MODEL（形成闭环） │
│ 4. 回到第 2 步，重复判断 │
└─────────────────────────────────────────────────────────────────────┘
2.3 源码级别的理解
create_agent 的源码简化版：
def create_agent(model, tools, system_prompt=None):
# 1. 创建状态图
graph = StateGraph(AgentState)
# 2. 添加两个核心节点
graph.add_node("model", _create_model_node(model, system_prompt))
graph.add_node("tools", ToolNode(tools))
# 3. 设置入口
graph.add_edge(START, "model")
# 4. 添加条件边：决定是否调用工具
def should_continue(state):
last_message = state["messages"][-1]
if last_message.tool_calls:
return "tools"
return END
graph.add_conditional_edges("model", should_continue)
# 5. 添加闭环边：工具执行完回到模型
graph.add_edge("tools", "model")
# 6. 编译并返回
return graph.compile()
2.4 关键洞察
使用
create_agent，你实际上已经在使用 LangGraph 作为底层运行时。
create_agent 不是一个独立的实现，而是 LangGraph 能力的"门面"（Facade）。
第三章：ReAct 模式——Agent 的核心循环
3.1 什么是 ReAct？
ReAct = Reasoning + Acting（推理 + 行动）
这是由 Yao 等人在 2022 年发表的论文 “ReAct: Synergizing Reasoning and Acting in Language Models” 中提出的模式。
核心思想：让 AI 像人类一样，“边想边做”。
3.2 用通俗的话解释 ReAct
人类解决问题的方式：
看到问题 → 想一想 → 发现缺信息 → 去查资料 → 看到结果 → 再想一想 → 得出结论
ReAct Agent 的工作方式完全一样：
收到问题 → 模型推理 → 调用工具 → 观察结果 → 再次推理 → 调用更多工具 → ... → 输出答案
3.3 完整的执行流程示例
假设用户问：“特斯拉股票今天表现如何？值得买入吗？”
第一轮循环
| 阶段 | 发生什么 | 具体内容 |
|---|---|---|
| Thought（思考） | LLM 分析问题 | “需要先查特斯拉今天的股价” |
| Action（行动） | LLM 决定调用工具 | 调用 get_stock_price("TSLA") |
| Observation（观察） | 工具执行返回 | {"price": 245.3, "change": "+2.1%"} |
第二轮循环
| 阶段 | 发生什么 | 具体内容 |
|---|---|---|
| Thought（思考） | LLM 分析已有信息 | “价格涨了，但需要了解原因” |
| Action（行动） | LLM 决定调用新工具 | 调用 search_news("特斯拉 今日 新闻") |
| Observation（观察） | 工具执行返回 | ["特斯拉宣布新工厂投产"] |
第三轮循环
| 阶段 | 发生什么 | 具体内容 |
|---|---|---|
| Thought（思考） | LLM 综合所有信息 | “股价上涨+积极新闻，整体向好” |
| Action（行动） | LLM 决定不再调用工具 | 没有 tool_calls |
| Answer（回答） | 直接输出给用户 | “特斯拉今天上涨 2.1% 至 $245.3…” |
3.4 决定"何时停止"的逻辑
这个决策完全由 LLM 自己判断，代码层面只有一个判断条件：
def should_continue(state):
last_message = state["messages"][-1]
# 只要 LLM 返回了 tool_calls，就继续循环
if last_message.tool_calls:
return "tools"
else:
return END # 没有 tool_calls 就终止
3.5 安全保护机制
虽然理论上是"直到信息足够为止"，但为了防止无限循环，系统内置了两个保护机制：
3.5.1 递归限制（Recursion Limit）
- 默认是 25 步（即
model+tools节点总共执行不超过 25 次） - 如果超过这个次数还没结束，LangGraph 会抛出异常强制终止
- 可以通过
config={"recursion_limit": 50}调整
3.5.2 模型自身的"主动终止"能力
- 好的 LLM（如 GPT-4、Claude 3.5）会在工具调用几次后自动判断"信息差不多了"
- 弱的模型可能会"工具调用上瘾"，需要靠递归限制兜底
3.6 关键要点
Agent 会一直调用工具，直到它自己觉得"信息够了"为止。这个"够了"的判断标准完全由 LLM 自己决定。
第四章：技术架构——三层理解
4.1 概述
理解 Agent 的技术架构，可以从三个层次来看：
┌─────────────────────────────────────────────────────────┐
│ 第 1 层：用户 API 层 │
│ create_agent() 一行代码创建 Agent │
│ ↓ │
│ 第 2 层：图执行层（LangGraph） │
│ StateGraph 管理节点、边、状态流转 │
│ ↓ │
│ 第 3 层：状态管理层 │
│ AgentState 管理消息历史、工具调用记录 │
└─────────────────────────────────────────────────────────┘
4.2 第 1 层：用户 API 层（最上层）
这是你写代码时直接接触的层面：
from langchain.agents import create_agent
agent = create_agent(model, tools)
result = agent.invoke({"messages": [("user", "你好")]})
特点：
- ✅ 接口简单，一行代码创建
- ✅ 适合快速开发
- ❌ 定制化能力有限
4.3 第 2 层：图执行层（中间层）
当你调用 create_agent 时，它内部构建了这样一个 LangGraph 状态图：
┌─────────────────────────────────────────────────────────────────────┐
│ LangGraph 状态图 │
│ │
│ ┌──────────┐ │
│ │ START │ │
│ └────┬─────┘ │
│ │ │
│ ▼ │
│ ┌──────────┐ │
│ │ MODEL │ │
│ │ 节点 │ │
│ └────┬─────┘ │
│ │ │
│ │ 有 tool_calls? │
│ ┌────┴────┐ │
│ │ │ │
│ ▼ ▼ │
│ ┌─────────┐ ┌─────────┐ │
│ │ TOOLS │ │ END │ │
│ │ 节点 │ └─────────┘ │
│ └────┬────┘ │
│ │ │
│ │ 执行完毕 │
│ │ │
│ ▼ │
│ ┌─────────┐ │
│ │ 回到 │ │
│ │ MODEL │────────────────────┐ │
│ └─────────┘ │ │
│ ▲ │ │
│ └─────────────────────────┘ │
│ │
│ 流转规则： │
│ 1. START → MODEL（开始执行） │
│ 2. MODEL 判断是否有 tool_calls │
│ • 有 → TOOLS 节点执行 │
│ • 无 → END（结束） │
│ 3. TOOLS 执行完毕 → 回到 MODEL（形成闭环） │
│ 4. 回到第 2 步，重复判断 │
└─────────────────────────────────────────────────────────────────────┘
图中只有两个核心节点：
| 节点 | 角色 | 职责 |
|---|---|---|
| MODEL 节点 | 大脑 | 接收所有信息 → 决定是否调用工具 → 输出指令 |
| TOOLS 节点 | 手脚 | 接收指令 → 实际执行函数 → 返回结果 |
4.4 第 3 层：状态管理层（最底层）
Agent 还有一个"记忆本"——状态（State）：
class AgentState(TypedDict):
messages: Annotated[list, add_messages] # 存储所有对话和工具调用记录
每轮循环都会把新内容追加到这个"记忆本"里：
初始状态: [用户问: "特斯拉今天怎么样？"]
第1轮后: [用户问, AI说"我要查股价", 工具返回"245.3"]
第2轮后: [用户问, AI说"我要查新闻", 工具返回"新工厂投产"]
第3轮后: [用户问, AI说"股价上涨，建议关注"]
最终的返回大概如下（包括了整个循环的内容）：
{
"messages": [
{
"role": "user",
"content": "特斯拉股票今天表现如何？值得买入吗？"
},
{
"role": "assistant",
"content": null,
"tool_calls": [
{
"id": "call_abc123",
"name": "get_stock_price",
"args": {
"symbol": "TSLA"
}
}
]
},
{
"role": "tool",
"tool_call_id": "call_abc123",
"content": "{\"price\": 245.3, \"change\": \"+2.1%\", \"volume\": 15200000}"
},
{
"role": "assistant",
"content": null,
"tool_calls": [
{
"id": "call_def456",
"name": "search_news",
"args": {
"query": "特斯拉 今日 新闻"
}
}
]
},
{
"role": "tool",
"tool_call_id": "call_def456",
"content": "[\"特斯拉宣布新工厂在德州投产\", \"分析师上调目标价至300美元\"]"
},
{
"role": "assistant",
"content": "特斯拉今日股价上涨 2.1%，收盘价 $245.3。利好因素包括新工厂投产消息以及分析师上调目标价至 $300。整体来看短期走势积极，但投资需结合自身风险承受能力综合判断。"
}
]
}
MODEL 节点每次"思考"时，都会看完整个记忆本再做决定。
4.5 三层架构总结
| 层次 | 内容 | 作用 |
|---|---|---|
| API 层 | create_agent() |
提供简单的用户接口 |
| 图执行层 | LangGraph StateGraph | 管理节点流转、循环控制 |
| 状态管理层 | AgentState + messages | 存储对话历史、工具结果 |
第五章：LCEL vs LangGraph
5.1 LCEL 是什么？
LCEL = LangChain Expression Language（LangChain 表达式语言）
一句话定义：用
|管道符号把步骤串起来的"流水线"语法。
# 像工厂流水线一样，一步步往下走
chain = prompt | model | parser
# ①提示词 → ②模型 → ③解析器
5.2 LCEL 的核心特点
| 特点 | 说明 |
|---|---|
| ✅ 声明式语法 | 用 ` |
| ✅ 并行执行 | 自动优化可并行的分支 |
| ✅ 流式支持 | 原生支持 .stream() 逐 token 输出 |
| ✅ 错误处理 | 支持 .with_retry() 自动重试 |
| ❌ 不支持循环 | 有向无环图（DAG），无法回头 |
5.3 LCEL 适用场景
- 翻译一段话
- 总结一篇文章
- 回答一个不需要查资料的问题
- RAG（检索增强生成）的简单实现
5.4 LangGraph 是什么？
一句话定义：像"流程图"一样，可以循环、可以条件跳转的图执行引擎。
# 像流程图，可以画圈圈、可以走分支
workflow = StateGraph(State)
workflow.add_node("model", model_func)
workflow.add_node("tools", tools_func)
workflow.add_conditional_edges("model", decide_next)
workflow.add_edge("tools", "model") # 画个圈！从工具回到模型
5.5 LangGraph 的核心特点
| 特点 | 说明 |
|---|---|
| ✅ 支持循环 | Agent 的核心需求 |
| ✅ 状态管理 | 有"记忆"，可以记住历史 |
| ✅ 条件分支 | 根据状态动态决定下一步 |
| ✅ 持久化 | 支持对话保存和恢复 |
| ✅ 人机协同 | 支持暂停等待人工输入 |
| ❌ 代码稍复杂 | 相比 LCEL 需要更多配置 |
5.6 LangGraph 适用场景
- 需要反复查资料的 Agent
- 多步骤决策系统
- 多 Agent 协作
- 需要人工介入的审批流程
- 复杂的对话管理
5.7 LCEL vs LangGraph 详细对比
| 维度 | LCEL | LangGraph |
|---|---|---|
| 推出时间 | 2023年8月 | 2024年 |
| 控制流 | 有向无环图（DAG） | 有向循环图 |
| 是否支持循环 | ❌ 不支持 | ✅ 支持 |
| 状态管理 | 简单传递 | 持久化、可检查点 |
| 复杂度 | 低 | 中高 |
| 典型任务 | 单次推理、线性任务 | 多轮交互、复杂决策 |
| 学习曲线 | 平缓 | 较陡 |
5.8 两者关系（非常重要！）
它们是合作关系，不是替代关系！
┌────────────────────────────────────────────────────────┐
│ 你的整个应用 │
│ │
│ ┌──────────────────────────────────────────────┐ │
│ │ LangGraph（导演） │ │
│ │ 控制整个流程：循环、条件、状态 │ │
│ │ │ │
│ │ 节点A: 用 LCEL 做翻译 → 节点B: 人工审核 │ │
│ │ ↑ ↓ │ │
│ │ └────── 循环 ────────┘ │ │
│ └──────────────────────────────────────────────┘ │
│ │
│ 简单理解：LangGraph 负责"大循环" │
│ LCEL 负责"小步骤" │
└────────────────────────────────────────────────────────┘
5.9 混合使用示例
# 外层：LangGraph 控制流程
workflow = StateGraph(AgentState)
workflow.add_node("model", call_model)
workflow.add_node("retrieve", retrieve_node)
# 内层：LCEL 实现具体的线性子任务
def retrieve_node(state):
# 这里使用 LCEL 构建一个检索链
retriever_chain = retriever | prompt | model | parser
docs = retriever_chain.invoke({"query": state["question"]})
return {"context": docs}
第六章：动手实践——从零构建 Agent
6.1 场景设定
创建一个"旅行规划助手"，需要能查天气、查航班、推荐景点。
6.2 准备工具
# 模拟的三个工具函数
def get_weather(city: str) -> str:
return f"{city} 今天晴天，25°C"
def search_flights(from_city: str, to_city: str) -> str:
return f"从 {from_city} 到 {to_city} 的机票 ¥800 起"
def recommend_attractions(city: str) -> str:
return f"{city} 推荐景点：故宫、长城、天安门"
tools = [get_weather, search_flights, recommend_attractions]
6.3 方式一：使用 create_agent（简单）
from langchain.agents import create_agent
from langchain_openai import ChatOpenAI
# 创建 Agent
agent = create_agent(
model=ChatOpenAI(model="gpt-4"),
tools=tools,
system_prompt="你是一个旅行规划助手，帮助用户规划旅行"
)
# 使用
result = agent.invoke({
"messages": [("user", "我想去北京旅游三天，帮我规划一下")]
})
print(result["messages"][-1].content)
6.4 方式二：手动构建 LangGraph（更灵活）
from langgraph.graph import StateGraph, END
from langgraph.graph.message import add_messages
from langgraph.prebuilt import ToolNode
from typing import TypedDict, Annotated
# 1. 定义"记忆本"
class TravelState(TypedDict):
messages: Annotated[list, add_messages]
# 2. 准备模型
model = ChatOpenAI(model="gpt-4").bind_tools(tools)
# 3. 定义"大脑"节点
def call_model(state: TravelState):
response = model.invoke(state["messages"])
return {"messages": [response]}
# 4. 创建"手脚"节点
tool_node = ToolNode(tools)
# 5. 构建流程图
workflow = StateGraph(TravelState)
workflow.add_node("model", call_model)
workflow.add_node("tools", tool_node)
workflow.set_entry_point("model")
# 6. 决定下一步去哪
def should_continue(state: TravelState):
last = state["messages"][-1]
if last.tool_calls:
return "tools" # 去执行工具
return END # 结束
workflow.add_conditional_edges("model", should_continue)
workflow.add_edge("tools", "model") # 执行完回到大脑
# 7. 编译
my_agent = workflow.compile()
# 8. 使用
result = my_agent.invoke({
"messages": [("user", "我想去北京旅游三天")]
})
6.5 两种方式对比
| 对比项 | create_agent | 手动 LangGraph |
|---|---|---|
| 代码量 | 少（~10行） | 多（~30行） |
| 灵活性 | 有限 | 极高 |
| 理解成本 | 低 | 中高 |
| 定制能力 | 有限 | 任意定制 |
| 适用场景 | 快速开发 | 复杂生产应用 |
这两种方式创建出来的 Agent 行为完全一样！ 手动构建能让你更深入理解底层原理。
第七章：技术选型指南
7.1 快速决策流程图
开始
│
▼
你的任务需要查资料或调用外部工具吗？
│
├── 否 ──→ 使用 LCEL（线性链即可）
│
▼ 是
任务需要多轮思考（查了再查）吗？
│
├── 否 ──→ 使用 LCEL + 单次工具调用
│
▼ 是
需要精细控制流程（条件分支、人工介入）吗？
│
├── 否 ──→ 使用 create_agent
│
▼ 是
使用 LangGraph StateGraph（完全自定义）
7.2 场景推荐表
| 你的需求 | 推荐方案 | 理由 |
|---|---|---|
| 想快速体验 Agent | create_agent |
一行代码搞定 |
| 只需要翻译、摘要等简单任务 | LCEL | 轻量、高效 |
| 需要反复查资料的 Agent | create_agent 或 LangGraph |
需要循环能力 |
| Agent 需要人工审核 | 直接 LangGraph | 可以暂停等待人工 |
| 多个 Agent 协作完成任务 | 直接 LangGraph | 需要复杂的状态管理 |
| 生产级复杂应用 | 混合使用 | 各取所长 |
7.3 实战场景举例
场景 1：智能客服机器人
- 推荐：
create_agent - 原因：需要查订单、查物流、查产品信息，标准的 ReAct 模式
场景 2：自动写周报
- 推荐：LCEL
- 原因：从数据库取数据 → 格式化 → 生成报告，线性流程
场景 3：金融风控审批
- 推荐：LangGraph
- 原因：需要多步审核、人工介入、条件分支
场景 4：跨部门协作机器人
- 推荐：LangGraph + LCEL 混合
- 原因：外层协调多个部门，每个部门内部用 LCEL 处理特定任务
7.4 当前技术趋势（2026年）
create_agent已成为官方推荐的统一入口，底层统一基于 LangGraph 实现。
| 趋势 | 说明 |
|---|---|
| 统一 API | create_agent 是创建 Agent 的标准方式 |
| 底层统一 | 无论用哪种方式，底层都是 LangGraph |
| 生态融合 | LCEL 和 LangGraph 各司其职，协同工作 |
第八章：核心概念速查表
8.1 概念速记卡
| 概念 | 一句话解释 | 关键词 |
|---|---|---|
| Agent | 会自己查资料的 AI | 自主、智能 |
| ReAct | 先想再做，做了再想 | 循环、思考-行动 |
| create_agent | 一键创建 AI 智能体 | 简单、封装 |
| LangGraph | Agent 的"发动机" | 循环、状态 |
| LCEL | 串联步骤的"管道" | 线性、流水线 |
| Model 节点 | Agent 的"大脑" | 推理、决策 |
| Tools 节点 | Agent 的"手脚" | 执行、行动 |
| 状态 (State) | Agent 的"记忆本" | 存储、追加 |
| 条件边 | 根据状态决定下一步 | 分支、路由 |
| ToolNode | 工具执行节点 | 调用、返回 |
8.2 技术演进时间线
2022.10 LangChain 首次开源
↓
2023.08 LCEL 发布（声明式链语法）
↓
2024 LangGraph 加入生态（图式编排）
↓
2025-2026 create_agent 统一 API，底层基于 LangGraph
↓
今天 根据场景灵活选择
8.3 核心公式
create_agent() = LangGraph StateGraph + ReAct 模式
LCEL = 线性流水线（无循环）
LangGraph = 循环流程图（有状态）
Agent = 模型 + 工具 + 循环决策
第九章：学习路线建议
9.1 入门路径
第 1 步：学 LCEL
↓
理解 | 管道操作符，掌握 Chain 的概念
↓
第 2 步：用 create_agent
↓
快速体验 Agent 的能力，建立感性认识
↓
第 3 步：学 LangGraph
↓
理解 StateGraph、节点、边、状态管理
↓
第 4 步：从零构建
↓
用 StateGraph 手动实现自己的 Agent
9.2 深入生产应用
掌握以下高级特性：
-
状态管理
add_messages归约器的工作原理- 自定义状态字段
-
条件边
add_conditional_edges的使用- 多条件分支
-
检查点（Checkpointer）
- 对话持久化
- 对话恢复
-
人机协同（Human-in-the-loop）
interrupt机制- 等待人工输入
-
流式输出
.astream()使用- 实时反馈
9.3 推荐学习资源
| 资源 | 说明 |
|---|---|
| LangChain 官方文档 | 最权威的参考 |
| LangGraph 官方文档 | 深入理解图执行 |
| ReAct 原论文 | 理解理论基础 |
| 官方 Cookbook | 实战代码示例 |
第十章：总结与展望
10.1 核心要点
create_agent不是 LangGraph 的替代品，而是 LangGraph 能力的封装。
理解这个关系，你就掌握了当前 LangChain Agent 生态的核心脉络：
| 层次 | 内容 | 角色 |
|---|---|---|
| 底层引擎 | LangGraph | 提供循环、状态、持久化 |
| 高层 API | create_agent |
开箱即用的 ReAct Agent |
| 线性工具 | LCEL | 简单任务的高效编排 |
| 实践建议 | 混合使用 | 灵活应对各类场景 |
10.2 一句话记住每个概念
| 概念 | 一句话 |
|---|---|
| LCEL | 用 ` |
| LangGraph | 支持循环的"流程图"引擎 |
| create_agent | 封装好的 ReAct Agent |
| ReAct | 先想再做，做了再想 |
10.3 未来展望
随着 LangChain 和 LangGraph 生态的持续发展：
- API 将进一步统一：
create_agent会成为更多高级功能的入口 - 抽象层次提高：开发者可以更关注业务逻辑，而非底层实现
- 混合架构成为主流：根据场景灵活组合 LCEL 和 LangGraph
10.4 最终建议
- 快速开发：用
create_agent - 复杂场景：用 LangGraph StateGraph
- 简单任务：用 LCEL
- 生产应用：混合使用，各取所长
附录：代码汇总
A.1 快速创建 Agent
from langchain.agents import create_agent
from langchain_openai import ChatOpenAI
agent = create_agent(
model=ChatOpenAI(model="gpt-4"),
tools=[get_weather, search_flights],
system_prompt="你是一个有用的助手"
)
result = agent.invoke({"messages": [("user", "北京天气怎么样？")]})
A.2 手动构建 LangGraph Agent
from langgraph.graph import StateGraph, END
from langgraph.graph.message import add_messages
from langgraph.prebuilt import ToolNode
from typing import TypedDict, Annotated
class AgentState(TypedDict):
messages: Annotated[list, add_messages]
def call_model(state: AgentState):
response = llm.invoke(state["messages"])
return {"messages": [response]}
tool_node = ToolNode(tools)
workflow = StateGraph(AgentState)
workflow.add_node("model", call_model)
workflow.add_node("tools", tool_node)
workflow.set_entry_point("model")
def should_continue(state: AgentState):
last = state["messages"][-1]
if last.tool_calls:
return "tools"
return END
workflow.add_conditional_edges("model", should_continue)
workflow.add_edge("tools", "model")
agent = workflow.compile()
A.3 LCEL 简单链
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_template("用一句话解释：{topic}")
chain = prompt | model | StrOutputParser()
result = chain.invoke({"topic": "量子计算"})
中国智能体开发者社区，聚焦智能体与大模型开发，提供前沿资讯、实用工具链、开源项目及行业案例。通过技术沙龙、开发者大赛等活动，促进经验交流与协作，助力开发者快速构建创新智能应用。
更多推荐
0
0- 0
已为社区贡献1条内容
所有评论(0)