深入浅出RAG——第15章:Agent RAG —— 让 RAG 具备自主决策能力

5 阅读12分钟

📖 本章学习目标

  • 解释 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 应用的可视化调试