📖 本章学习目标
- 解释 Agent 的 ReAct 推理循环,理解它与标准 RAG 和 Self-RAG 的本质区别
- 将检索器封装为 LangChain Tool,让模型通过 Function Calling 自主决定何时检索
- 实现一个完整的 RAG Agent,支持多工具组合和多步推理
- 设计 Router Agent 实现多 Agent 协作,并掌握 Agent 的选型决策框架
在《第14章:高级 RAG 技术》关于Self-RAG章节的结尾,我们提到 Self-RAG 的重试循环本质上是一个简化版的 Agent 推理循环。这句话展开来讲就是Self-RAG 的决策树是硬编码的,它的基本逻辑是相关性不足就改写查询,信息不充分就扩大 k 值,忠实度不够就重新生成。这几个分支在代码里已经写死。而Agent 要做的则是把决策权交给模型本身,而不是写死分支。
回想一下第14章的五种高级模式,它们都在管道的特定环节插入了判断逻辑,但判断的分支数量是有限的。当问题需要类似"先查 A,根据 A 的结果决定是查 B 还是查 C,再综合回答"这种动态路径时,任何预定义的分支都覆盖不全。Agent 通过"观察 → 思考 → 行动"的循环,让每一步都由模型自主决策,路径空间从有限分支扩展到了任意组合。
Agent RAG是一个能理解需求、主动寻找信息、综合判断的智能助手。
一、为什么需要 Agent RAG
标准 RAG 和高级 RAG 共享的一个前提是检索流程在编码阶段就已经确定。无论是一次检索还是 Self-RAG 的"检索 → 判断 → 重试"循环,执行路径不会超出代码中预设的范围。这个前提在以下三类场景中会失效。
(1)多跳推理。问题需要从第一个检索结果中提取线索,再用这个线索进行第二次检索。比如"对比 React 18 和 Vue 3 的状态管理方案,哪个更适合大型项目",需要先分别检索两个框架的方案,再综合对比。标准 RAG 一次检索只能覆盖一个方向,Multi-Query 虽然能并行检索多个查询,但查询列表本身是事先写好的,无法根据中间结果动态调整。
(2)条件决策。检索结果的内容决定了下一步做什么,而"下一步"的可能性太多,无法事先枚举。比如"如果预发环境部署失败,应该怎么处理"这个问题,步骤取决于检索到的故障排查文档是否存在,存在则用内部文档,不存在则需要切换到外部搜索,这种分支逻辑在第14章的 CRAG 中已经有了雏形,但 CRAG 的质量判断仍然是代码写死的三档切换。Agent 则可以让模型根据检索结果的具体内容决定下一步,而不是按固定阈值跳转。
(3)多工具协作。问题需要同时用到检索、计算、外部搜索等不同能力,且调用顺序取决于中间结果。比如"如果服务器从 10 台增加到 15 台,每台每月 500 元,成本增加多少"这个问题,第一步检索配置信息,第二步根据检索到的单价计算,两步之间是串行依赖关系。
这三种场景的共同特征是无法事先写死检索流程,而这正是 Agent 擅长的事情。
二、ReAct 模式:推理与行动的交织
1. 核心思想
ReAct(Reasoning + Acting)由 Yao(姚顺雨) 等人于 2022 年提出,是 Agent 领域的基础模式。它的核心是一个简单的循环:Thought(思考)→ Action(行动)→ Observation(观察)→ Thought → ...,直到模型判断信息足够,给出最终答案。
graph LR
A[用户输入] --> B[Thought<br/>我需要知道什么?]
B --> C[Action<br/>调用工具获取信息]
C --> D[Observation<br/>观察工具返回结果]
D --> E{信息是否足够?}
E -->|否| B
E -->|是| F[Final Answer<br/>综合所有信息输出答案]
要理解 ReAct 为什么重要,可以对比三种推理模式:
| 模式 | 流程 | 特点 |
|---|---|---|
| 标准 RAG | 检索 → 生成 | 单步,无推理 |
| Chain-of-Thought | 思考 → 思考 → 答案 | 纯推理,无外部信息获取 |
| ReAct | 思考 → 行动 → 观察 → 思考... | 推理与行动交替,边想边查 |
Chain-of-Thought 能让模型把复杂问题拆成多步推理,但它依赖模型内部知识,没有获取外部信息的能力,一旦内部知识不足或过时就会出错。ReAct 在推理的每一步都可以调用外部工具获取新信息,将推理建立在实时获取的事实之上。
2. 与 Self-RAG 的对比
这里和第14章的 Self-RAG 做一个对比,有助于理解 Agent 到底智能在哪里。Self-RAG 的循环是这样的:
检索 → 判断是否相关 → 不相关则改写查询重试
→ 判断是否充分 → 不充分则扩大 k 值重试
→ 生成答案 → 判断是否忠实 → 不忠实则重新生成
每一步判断的走向在代码中已经固定,它是有限状态机,不是开放式的推理。Agent 的 ReAct 循环则没有预定义的状态转移图,模型自己决定每一步做什么,比如:
用户: 对比 React 18 和 Vue 3 的状态管理方案
Thought: 我需要先了解 React 18 的状态管理方案
Action: search_knowledge_base("React 18 状态管理方案")
Observation: [返回 Redux Toolkit、Zustand、Jotai 等方案介绍]
Thought: 有了 React 侧的信息,现在需要查 Vue 3 的方案
Action: search_knowledge_base("Vue 3 状态管理方案")
Observation: [返回 Pinia、Vuex 4 等方案介绍]
Thought: 两边信息都有了,可以直接对比给出结论
Final Answer: React 18 推荐 Redux Toolkit、Zustand、Jotai...
模型自己判断需要两次检索,而不是代码预设对比类问题要检索两次。如果检索到的 Vue 方案中提到了某个 React 方案中没有的维度,模型还可以主动发起第三次检索来补齐信息,这种灵活性是预定义分支做不到的。
三、将检索器封装为 Tool
在实践中,我们一般会把检索作为一个工具提供给Agent。这里以Langchain为例,实现一个检索器Tool。
在 LangChain 的 Agent 框架中,Tool 是模型可以调用的函数单元。Agent 不会直接操作检索器,而是通过 Tool 的抽象层来调用。封装 Tool 有三个关键设计要素:name 是模型识别工具的唯一标识,description 是模型决定是否调用该工具的核心依据,schema 用 Zod 定义参数类型,保证模型传参的正确性。
更多Langchain工具的使用,可以阅读《深入浅出Langchain专栏》的《工具系统》章节。
import { tool } from "@langchain/core/tools";
import { z } from "zod";
import { VectorStoreRetriever } from "@langchain/core/vectorstores";
function createRetrieveTool(retriever: VectorStoreRetriever) {
return tool(
async ({ query }: { query: string }) => {
const docs = await retriever.invoke(query);
if (docs.length === 0) return "未找到相关文档";
return docs
.map((doc, i) => {
const source = doc.metadata.source || "未知来源";
return `[文档 ${i + 1}] (${source})\n${doc.pageContent.slice(0, 300)}`;
})
.join("\n\n---\n\n");
},
{
name: "search_knowledge_base",
description:
"在公司内部知识库中搜索相关信息。适用于产品文档、部署流程、" +
"技术规范类问题。输入应该是具体的搜索查询字符串。",
schema: z.object({
query: z.string().describe("搜索查询字符串,应该具体明确"),
}),
}
);
}
description 的设计值得单独强调。模型是通过阅读描述文本来判断当前问题是否应该调用这个工具的,所以描述必须说清楚三件事:这个工具能做什么(搜索内部知识库),适用于什么问题(产品文档、部署流程、技术规范),以及输入应该是什么格式(具体的搜索查询字符串)。描述写得模糊,模型的工具选择就会失准。
四、使用 Function Calling 实现 RAG Agent
1. Function Calling 的工作机制
Function Calling 是很多LLM提供商原生提供的 API 能力,允许模型在生成文本的同时,返回一个结构化的工具调用请求。它工作流程是应用向 LLM 发送用户消息和可用工具列表,LLM 决定是直接回答还是返回一个工具调用。如果返回工具调用,应用执行该工具并将结果发回 LLM,LLM 再根据结果决定继续调用工具还是给出最终答案,直到 LLM 判定不需要再调用工具为止。
sequenceDiagram
participant U as 用户
participant A as Agent
participant L as LLM
participant T as Tool
U->>A: 提问
A->>L: 发送消息 + 可用工具列表
L->>A: 决定调用工具 / 直接回答
alt 调用工具
A->>T: 执行工具
T->>A: 返回结果
A->>L: 发送工具结果
L->>A: 最终答案(或继续调用工具)
else 直接回答
L->>A: 直接输出答案
end
A->>U: 返回答案
2. 基础实现
下面将 RAGAgent 类拆分为三个部分,分别对应初始化、主循环和工具执行。先定义类型和构造函数。
import { ChatOpenAI } from "@langchain/openai";
import { HumanMessage, SystemMessage, ToolMessage } from "@langchain/core/messages";
interface AgentResult {
answer: string;
iterations: number;
toolCalls: Array<{ name: string; args: any; result: string }>;
}
class RAGAgent {
private llm: ReturnType<ChatOpenAI["bindTools"]>;
private tools: Array<any>;
private maxIterations = 5; // 迭代上限
constructor(llm: ChatOpenAI, tools: Array<any>) {
this.llm = llm.bindTools(tools);
this.tools = tools;
}
核心的 run 方法维护一个消息数组作为对话历史,在 while 循环中反复调用 LLM,每次检查返回结果是否包含工具调用请求。如果有,执行工具并将结果追加到消息历史中;如果没有,说明模型已经准备好输出最终答案。
async run(userQuery: string): Promise<AgentResult> {
const messages: Array<any> = [
new SystemMessage(
"你是一个专业的企业知识库助手。遇到需要查资料的问题时," +
"先使用 search_knowledge_base 工具检索相关信息。" +
"当你有足够信息时,直接给出最终答案,不要再调用工具。"
),
new HumanMessage(userQuery),
];
let iterations = 0;
const toolCalls: AgentResult["toolCalls"] = [];
while (iterations < this.maxIterations) {
iterations++;
const response = await this.llm.invoke(messages);
messages.push(response);
if (response.tool_calls && response.tool_calls.length > 0) {
for (const toolCall of response.tool_calls) {
const toolResult = await this.executeTool(toolCall);
toolCalls.push({
name: toolCall.name, args: toolCall.args, result: toolResult,
});
messages.push(new ToolMessage({
content: toolResult, tool_call_id: toolCall.id!,
}));
}
} else {
return { answer: response.content as string, iterations, toolCalls };
}
}
return {
answer: "Agent 达到最大推理步数限制,无法完成回答。",
iterations, toolCalls,
};
}
executeTool 根据工具名称查找对应的工具实例并执行,兜底处理工具未找到和调用异常的情况。
private async executeTool(toolCall: any): Promise<string> {
const tool = this.tools.find(t => t.name === toolCall.name);
if (!tool) return `错误: 未找到工具 "${toolCall.name}"`;
try {
return await tool.invoke(toolCall.args);
} catch (error) {
return `错误: ${error instanceof Error ? error.message : "未知错误"}`;
}
}
}
使用方式很简单,创建 Agent 实例并调用 run。
const agent = new RAGAgent(
new ChatOpenAI({ modelName: "gpt-4o", temperature: 0 }),
[retrieveTool]
);
const result = await agent.run("如何配置数据库连接池?");
典型的两轮执行流程是第一轮 LLM 返回 search_knowledge_base 工具调用,Agent 执行检索并将结果发回;第二轮 LLM 判断信息足够,直接输出最终答案。
3. 迭代上限与死循环防护
maxIterations 的默认值设为 5,对于一个正常的多步推理任务,2 到 3 次迭代通常足够。如果频繁达到上限,通常说明工具描述不够清晰导致模型反复尝试,或者问题确实超出了系统能力范围。应该通过优化工具描述和 System Prompt 来解决,而不是简单地提高上限。
五、多工具组合
单个检索工具可能只能覆盖内部知识库,实际场景经常需要多工具配合。以下为 Agent 增加网络搜索和数学计算两个工具。
const webSearchTool = tool(
async ({ query }: { query: string }) => {
// 实际项目中替换为 Google Search API 或 Bing API 调用
return "网络搜索结果...";
},
{
name: "web_search",
description: "在互联网上搜索最新信息。适用于内部知识库中没有的" +
"最新技术、新闻、外部资源等问题。",
schema: z.object({
query: z.string().describe("搜索查询字符串"),
}),
}
);
计算工具需要特别说明:示例中使用了表达式求值来演示流程,生产环境应该替换为 mathjs 等安全的数学库,或者只支持白名单内的简单运算,避免任意代码执行风险。
const calculatorTool = tool(
async ({ expression }: { expression: string }) => {
// 生产环境建议使用 mathjs 等安全的表达式求值库
return String(eval(expression));
},
{
name: "calculator",
description: "执行数学计算。适用于成本估算、性能计算等需要数值运算的场景。",
schema: z.object({
expression: z.string().describe("数学表达式,如 '10 * 5 + 3'"),
}),
}
);
三个工具注册到同一个 Agent 后,模型会根据问题的性质自主选择。比如"如果服务器从 10 台增加到 15 台,每台每月 500 元,成本增加多少"这个问题,模型会先调用 search_knowledge_base 确认当前服务器的配置信息,然后调用 calculator 进行乘法运算,最后综合输出结果。整个过程模型自行编排,不需要人工预设步骤。
六、多 Agent 协作架构
1. Router Agent 模式
单个 Agent 承载过多工具时,模型在工具列表中做选择的准确率会下降。当系统需要区分多个知识域时,Router Agent 是一种轻量且有效的方案:先由一个路由 Agent 判断问题类型,再转发给对应领域的子 Agent。
graph LR
A[用户] --> B[Router Agent<br/>判断问题类型]
B -->|技术问题| C[Tech Agent<br/>技术文档检索工具]
B -->|业务问题| D[Biz Agent<br/>业务流程检索工具]
B -->|通用问题| E[General Agent<br/>多工具组合]
C --> F[答案汇总]
D --> F
E --> F
F --> A
2. 实现
Router Agent 的核心逻辑分两步,先让 LLM 判断问题类别,再根据类别将请求转发给对应的子 Agent。
class RouterAgent {
private routerLLM: ChatOpenAI;
private agents = new Map<string, RAGAgent>();
constructor() {
this.routerLLM = new ChatOpenAI({ modelName: "gpt-4o", temperature: 0 });
}
registerAgent(name: string, agent: RAGAgent) {
this.agents.set(name, agent);
}
async run(userQuery: string): Promise<string> {
const category = await this.classify(userQuery);
const targetAgent = this.agents.get(category) ?? this.agents.get("general")!;
const result = await targetAgent.run(userQuery);
return result.answer;
}
private async classify(query: string): Promise<string> {
const prompt = [
"请判断以下问题属于哪个类别,只输出类别名称。",
"可选类别:technical(API、部署、代码、架构等)",
"business(流程、政策、人事等)",
"general(通用问题或其他)",
"",
`问题: ${query}`,
].join("\n");
const response = await this.routerLLM.invoke(prompt);
return (response.content as string).trim().toLowerCase();
}
}
注册和使用 Router Agent。
const router = new RouterAgent();
router.registerAgent("tech", new RAGAgent(llm, [techRetrieveTool]));
router.registerAgent("biz", new RAGAgent(llm, [bizRetrieveTool]));
router.registerAgent("general", new RAGAgent(llm, [retrieveTool, webSearchTool]));
const answer = await router.run("如何配置数据库连接池?");
// Router 判断为 technical → 转发给 Tech Agent → 返回技术文档中的配置说明
3. 架构对比
| 架构 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|
| 单 Agent + 多工具 | 实现简单,延迟低 | 工具超过 5 个时模型选择容易失准 | 3~5 个工具以内 |
| 多 Agent 路由 | 职责清晰,各 Agent 的 Prompt 可独立优化 | 路由本身可能误判,增加一跳延迟 | 知识域差异大的企业系统 |
| 多 Agent 协作 | 可处理极复杂的多步任务 | 延迟高,Token 消耗大,调试困难 | 需要多角色协作的复杂推理 |
Router Agent 模式是多 Agent 协作的起点,更复杂的模式(如 Agent 之间的层级调用、并行协作)会在后续章节的生产级架构中进一步展开。
七、何时使用 Agent
引入 Agent 会增加 2 到 5 倍的 LLM 调用次数和相应的延迟,不是越智能就越好。判断标准可以归结为一句话:能不能事先写死检索流程?
graph TD
A[用户需求] --> B{能不能事先写死检索流程?}
B -->|能| C{单次检索能否解决?}
C -->|能| D[标准 RAG]
C -->|不能| E[高级 RAG<br/>HyDE / Self-RAG / CRAG]
B -->|不能| F{核心复杂度在哪?}
F -->|多步检索| G[Agent RAG<br/>单 Agent + 检索工具]
F -->|动态工具选择| H[Agent RAG<br/>单 Agent + 多工具]
F -->|多知识域协作| I[Agent RAG<br/>多 Agent 路由]
落实到具体场景举例:
| 场景 | 推荐方案 | 理由 |
|---|---|---|
| 部署流程是什么? | 标准 RAG | 单次检索即可 |
| 对比 A 和 B 的优缺点 | Multi-Query 或 Agent | 需要多次检索,取决于对比维度是否固定 |
| 如果部署失败怎么办?" | Agent | 需要根据检索到的故障类型动态决定后续步骤 |
| 计算扩容 5 台的总成本 | Agent + 计算工具 | 需要检索 + 计算两种能力 |
| 最新的技术趋势" | CRAG 或 Agent + 网络搜索 | 内部知识库覆盖不足,需要外部数据源 |
需要注意的是,Agent RAG 不是标准 RAG 的替代品,而是标准 RAG 和高级 RAG 在特定场景下的补充。当标准 RAG 和高级 RAG 已经能胜任时,则不要为了"技术上更先进"而引入 Agent,额外成本不会带来对应的收益。
从下一章开始,我们将跳出具体算法的范畴,进入生产级系统的工程实践,讨论如何让 RAG 系统在生产环境中稳定、高效、可维护地运行,无论底层是标准 RAG、高级 RAG 还是 Agent RAG。
FAQ
Q1:Agent 和标准 RAG 的边界在哪里?
判断标准是"能不能事先写死检索流程"。如果检索路径在编码阶段就可以确定(包括重试次数和分支),用标准 RAG 或高级 RAG。如果需要根据中间结果动态决定下一步做什么,用 Agent。实践中的另一个信号:如果你的代码里开始出现大量 if-else 来处理不同的检索分支,说明逻辑复杂度已经在向 Agent 靠拢。
Q2:Agent 会不会陷入死循环?
会,这就是 maxIterations 的必要性。一个正常的多步推理很少超过 5 次迭代,如果频繁触及上限,优先检查工具描述是否清晰、System Prompt 中是否明确了"信息足够就直接回答"的指令。另一个常见的死循环原因是工具返回结果为空或格式异常,导致模型无法判断任务已完成。
Q3:Function Calling 和 LangChain 的 Agent 封装有什么区别?
Function Calling 是 LLM 原生的 API 能力,LangChain Agent 是框架层的封装,底层仍然调用 Function Calling。本章优先展示原生方式是为了降低框架依赖,让你看清每一步发生了什么。LangChain 的 AgentExecutor 提供了更多开箱即用的功能(自动重试、错误恢复、记忆管理等),但抽象层也增加了调试难度。建议先用原生方式理解机制,再用框架封装提高开发效率。
Q4:Agent 的成本比标准 RAG 高多少?
取决于推理步数。标准 RAG 一次 LLM 调用,Agent 通常 2 到 5 次。不做缓存的情况下成本是标准 RAG 的 2 到 5 倍。但复杂问题的答案质量也显著更高,这个取舍需要根据业务场景评估。如果预算敏感,可以从两个方向优化:对相同的查询-工具调用对做结果缓存,以及用更便宜的模型(如 GPT-4o-mini)做路由判断。
Q5:如何调试 Agent 的推理过程?
Agent 调试比标准 RAG 困难,因为错误可能出在任一推理步骤。建议从三个层面入手:记录每次迭代的完整上下文(Thought、Action、Observation),用 LangSmith 等可视化工具追踪调用链,以及为关键决策点(如工具选择、是否继续检索)设置断言式检查。如果模型反复调用同一个工具却得不到满意结果,通常是工具描述或返回格式出了问题。
练习
练习 1:实现单工具 RAG Agent
在你的 RAG 项目中基于 Function Calling 实现一个单工具 Agent,将检索器封装为 Tool。
验证标准:
- Agent 对内部知识库能覆盖的问题正确调用
search_knowledge_base - 能够展示每次工具调用的参数和返回结果
- 对不需要检索的简单对话类问题,Agent 直接回答而不调用工具
练习 2:多步推理任务测试
设计一个需要至少两次检索才能完整回答的问题(如"对比项目 A 的部署流程和项目 B 的部署流程,分析哪个更复杂"),测试 Agent 是否能自主完成多步检索和综合分析。
验证标准:
- Agent 执行了至少两次工具调用
- 每次调用的查询参数有明显差异(针对不同子问题)
- 最终答案综合了所有检索结果,而非仅基于最后一次
练习 3:实现 Router Agent
实现一个 Router Agent,根据问题类型路由到技术文档 Agent、业务文档 Agent 和通用 Agent。
验证标准:
- 能够正确区分技术问题、业务问题和通用问题,分类准确率超过 80%
- 每个子 Agent 拥有独立的工具集和 System Prompt
- 路由错误时能降级到通用 Agent 兜底
练习 4:对比 Agent 和标准 RAG 的综合表现
用第12章构建的评估集,选取 5 个需要多步推理的复杂问题,分别用标准 RAG 和 Agent RAG 运行,从答案质量、延迟和成本三个维度对比。
验证标准:
- 量化两种方案的 Faithfulness 和 Answer Relevancy
- 记录平均延迟和 LLM 调用次数差异
- 分析哪些问题类型从 Agent 中受益最大,哪些收益不足以覆盖额外成本
📚 延伸阅读
- ReAct 论文 — Yao et al., "ReAct: Synergizing Reasoning and Acting in Language Models",ReAct 模式的原始论文
- OpenAI Function Calling Guide — OpenAI Function Calling 官方指南,包含详细的 API 说明和最佳实践
- Anthropic Tool Use — Anthropic 的工具使用文档,适用于 Claude 模型
- LangChain Agents — LangChain Agent 开发指南,包含 AgentExecutor 等高级封装
- LangSmith — LangChain 官方的调试和监控平台,适合 Agent 应用的可视化调试