---
tags: [AI, rag, agent]
阶段: 06-Prompt与RAG
难度: ★★★
created: 2026-10-18
related: "[[RAG原理与流程]], [[检索优化与重排Rerank]], [[RAG评估]]"
---

# 进阶RAG-Self-RAG与Agentic-RAG

## 定义

**Self-RAG**（self-reflective retrieval-augmented generation）指在生成序列中显式产生反思 token，用这些 token 决定是否检索、评价检索段落是否相关、评价生成内容是否被证据支持、评价回答是否有用，并以反思 token 的概率参与候选选择的方法。

**Agentic RAG** 指把检索封装为可调用工具，由控制器在多步循环中决定何时检索、检索什么、是否继续、何时终止的方法。

Self-RAG 的生成过程可写为带反思 token 的序列生成：

$$
p_\theta(y,c\mid x)=\prod_{t=1}^{T}p_\theta\big((y_t,c_t)\mid x,y_{<t},c_{<t},r_t,\mathcal{P}_t\big),
$$

其中 $c_t$ 是第 $t$ 个片段上的反思 token，$\mathcal{P}_t$ 是第 $t$ 次检索返回的段落集合，$r_t\in\{0,1\}$ 表示该片段是否执行检索。

Agentic RAG 可写为部分可观测的决策过程：

$$
s_t=(q,\mathcal{Q}_t,\mathcal{P}_t,d_t,b_t),\qquad
a_t\sim\pi_\theta(a\mid s_t),\qquad
a_t\in\{\textsc{Retrieve}(q'),\ \textsc{Answer},\ \textsc{Verify},\ \textsc{Stop}\},
$$

其中 $q$ 是原问题，$\mathcal{Q}_t$ 是已发出的查询，$\mathcal{P}_t$ 是已取得的段落，$d_t$ 是当前草稿，$b_t$ 是剩余预算。

符号约定如下。

| 符号 | 含义 |
|---|---|
| $x$ | 输入问题 |
| $y$ | 输出序列 |
| $c$ | 反思 token 序列 |
| $T$ | 生成片段数 |
| $T_{\max}$ | 最大步数 |
| $\mathcal{P}$ | 检索段落集合 |
| $k$ | 每轮检索返回的段落数 |
| $r$ | 是否检索的二值决策 |
| $\delta$ | 检索与采纳的阈值 |
| $\pi_\theta$ | 生成策略或控制器策略 |
| $s_t$ | 第 $t$ 步的状态 |
| $a_t$ | 第 $t$ 步的动作 |
| $b_t$ | 剩余预算，包括步数与 token 数 |
| $H$ | 多跳问题的跳数 |
| $p_h$ | 第 $h$ 跳的成功概率 |

其余术语在首次出现处定义。**反思 token**（reflection token）是加入词表的特殊 token，其取值表示对检索必要性或生成质量的判断；**ISREL** 是"Is Relevant"的缩写，二值判断段落与问题是否相关；**ISSUP** 是"Is Supported"的缩写，三级判断生成内容被段落支持的程度；**ISUSE** 是"Is Useful"的缩写，五级判断回答对问题的有用程度；**自适应检索**（adaptive retrieval）指由模型决定是否检索；**查询分解**（query decomposition）指把复合问题拆成子问题；**多跳问答**（multi-hop QA）指答案需要串联多个证据片段的问题；**GraphRAG** 指以实体关系图与社区摘要为索引结构的检索增强方法。

## 为什么重要

朴素 RAG 的流程固定为"检索一次、拼接上下文、生成一次"。这一流程在四类情形下失效，且失效原因各不相同。

第一类是不该检索时检索。问题属于常识、算术或对话历史中已有信息，检索返回无关段落，生成模型被无关内容干扰，答案质量低于不检索。第二类是检索了但不相关。查询与文档措辞不匹配、分块切断证据、嵌入模型域外失效，都会让候选段落与问题无关。第三类是段落相关但不支持结论。段落讨论同一主题，却不包含支持具体断言的句子，模型倾向于补全段落中没有的细节。第四类是答案不支持问题。回答本身有证据，但没有回答用户实际询问的槽位，例如问了城市却回答了人名。

多跳问题还会引入第五类失效：单次检索只能覆盖一跳，桥接实体在第二跳才出现。比较类与聚合类问题则需要先分解再汇总，固定流程无法表达这种控制结构。

Self-RAG 与 Agentic RAG 分别从两个方向处理这些失效。Self-RAG 把判断内化：用标注数据训练模型产生反思 token，使"是否检索""是否相关""是否有支撑""是否有用"成为可预测的 token，并在解码时用这些 token 的概率筛选候选。Agentic RAG 把判断外化：把检索、验证、终止写成显式动作，由控制器在多步循环中调用，用额外的模型调用换取可控性与可观测性。

本篇位于 [[RAG原理与流程]] 与 [[检索优化与重排Rerank]] 之后。流程笔记给出单轮链路的定义，重排笔记处理候选排序，本篇处理"检索几次、何时停止、如何验证"的控制问题。验证环节与 [[幻觉与缓解]] 的归因方法直接相关，评估口径由 [[RAG评估]] 定义，工具调用协议见 [[AI-Agent与工具调用]]。对应学习目标中的"会评估"：能设计对照实验，把多步带来的增益与成本分开测量。

## 原理与推导

### 1 朴素 RAG 的失效分类

把失效类型、可观测现象与对应机制列成表，便于在错误分析时归类。

| 失效类型 | 现象 | 根因 | 对应机制 | 可测指标 |
|---|---|---|---|---|
| 过度检索 | 常识问题被无关段落干扰 | 流程强制检索 | 自适应检索 | 无检索问题的正确率 |
| 检索不足 | 需要外部事实却直接作答 | 模型不知道知识边界 | 检索必要性判断 | 需检索问题的召回率 |
| 段落不相关 | 上下文与问题主题不符 | 词汇不匹配、分块错误 | 查询改写、重排 | ISREL 准确率、recall@k |
| 无支撑生成 | 答案含段落中没有的细节 | 生成模型补全 | 句子级验证 | ISSUP 分布、引用精确率 |
| 答非所问 | 答案正确但槽位错误 | 问题解析错误 | 答案级评判 | ISUSE 分布、人工正确率 |
| 多跳断裂 | 只回答第一跳 | 单次检索 | 迭代检索、查询分解 | 跳数覆盖率 |
| 聚合缺失 | 全局问题只给局部证据 | 块级检索 | GraphRAG、社区摘要 | 聚合题正确率 |
| 证据冲突 | 多段落给出矛盾事实 | 无冲突处理 | 证据加权、时效过滤 | 冲突检测率 |

这张表的作用是约束改进方向：每一类失效对应一个机制，机制的效果用指定指标测量。若把多跳失败归因于嵌入模型，就会在错误的位置投入优化。

### 2 Self-RAG 的反思 token

Self-RAG 在词表中加入四类反思 token。

| token | 取值 | 插入位置 | 判断对象 |
|---|---|---|---|
| Retrieve | Yes / No | 每个生成片段之前 | 当前是否需要检索 |
| ISREL | Relevant / Irrelevant | 每个检索段落之后 | 段落与问题是否相关 |
| ISSUP | Fully supported / Partially supported / No support | 每个生成片段之后 | 片段是否被段落支持 |
| ISUSE | 1 到 5 | 完整输出之后 | 回答对问题的有用程度 |

生成序列因此形如

```text
[Retrieve=Yes]
<段落 1> [ISREL=Relevant]
<段落 2> [ISREL=Irrelevant]
片段 1 [ISSUP=Fully supported]
[Retrieve=No]
片段 2 [ISSUP=Partially supported]
[ISUSE=4]
```

反思 token 与普通 token 共享同一个解码器与同一套参数。这一设计使判断不需要额外的分类器，也不需要把判断结果拼回提示词；模型在生成文本的同时生成判断，判断与文本在同一上下文中计算。

自适应性由 Retrieve token 的概率直接给出：

$$
\text{执行检索}\iff
\hat p_\theta\big(\mathrm{Retrieve}=\text{Yes}\mid x,y_{<t}\big)>\delta .
$$

阈值 $\delta$ 越高，检索越少；$\delta=1$ 时永不检索，$\delta=0$ 时每段都检索。ISREL 与 ISSUP 同样按阈值过滤：低于阈值的段落被丢弃，低于阈值的片段被重新生成或触发二次检索。

### 3 Self-RAG 的训练信号

训练分两个阶段。

第一阶段训练 critic。对三元组 $(x,y,\mathcal{P})$ 用强模型标注反思 token：段落与问题是否相关、输出片段是否被段落支持、整体回答是否有用。critic 以语言模型为骨干，输入为问题、输出与证据，目标是预测对应的反思 token，损失为反思 token 位置上的交叉熵：

$$
\mathcal{L}_{\text{critic}}
=-\sum_{j}\log p_\phi\big(c_j\mid x,y,\mathcal{P}\big).
$$

critic 只学习判断，不学习生成答案。它的输出构成第二阶段的数据标注。

第二阶段训练生成器。对训练语料中的每个片段执行检索，按 critic 的判断插入 Retrieve、ISREL、ISSUP 与 ISUSE token，构成增广序列；生成器在该序列上做下一 token 预测，但对检索段落屏蔽损失，只对输出文本与反思 token 计算交叉熵：

$$
\mathcal{L}_{\text{gen}}
=-\sum_{t\in\mathcal{T}_{\text{out}}\cup\mathcal{T}_{\text{critic}}}
\log p_\theta\big(z_t\mid z_{<t}\big),
$$

其中 $z$ 是增广序列，$\mathcal{T}_{\text{out}}$ 与 $\mathcal{T}_{\text{critic}}$ 分别是输出 token 与反思 token 的位置集合。屏蔽检索段落的原因是：段落已在输入中给出，让模型复述段落会浪费容量，并使损失被长段落主导。

这一训练方式与前缀提示不同。提示中写 `[Relevant]` 只是给模型一个标签词，模型没有学过在该位置输出该标签，也没有学过标签与后续生成的关系；Self-RAG 的反思 token 是训练目标的一部分，模型在特定上下文下对特定标签分配了概率质量。

### 4 推理时的候选选择

Self-RAG 在推理时使用片段级束搜索。设束宽为 $B$，每个片段生成 $N$ 个候选，每个候选的评分为

$$
s(y)=\lambda_{g}\log p_\theta(y\mid x,\mathcal{P})
+\lambda_{r}\hat p(\mathrm{ISREL}=\text{Relevant})
+\lambda_{s}\hat p(\mathrm{ISSUP}=\text{Fully supported})
+\lambda_{u}\hat p(\mathrm{ISUSE}),
$$

其中带帽的概率是 critic 在对应位置的归一化概率，$\lambda$ 为权重。前三项在片段级计算，ISUSE 在完整输出上计算。

解码流程如下。

1. 在当前片段起点计算 Retrieve 分布，按阈值决定是否检索。
2. 若检索，取前 $k$ 个段落，逐段计算 ISREL，丢弃低于阈值的段落。
3. 对保留的每个段落生成 $N$ 个候选片段，计算每个候选的 ISSUP。
4. 按 $s(y)$ 保留前 $B$ 个候选，进入下一片段。
5. 生成结束后计算 ISUSE，对完整候选排序，输出最高分者。

若所有候选的 ISSUP 都低于阈值，系统有两种处理：输出带不确定表述的答案，或触发一次补充检索。前者保证延迟，后者提高正确率，选择取决于应用的错误成本。

该流程的计算量高于朴素 RAG：每个片段最多 $N\times k$ 次生成，加上 critic 的前向。束宽与候选数是延迟的主要来源，通常取 $B=2$ 到 $4$、$N=2$ 到 $4$。

### 5 Agentic RAG 的形式化

Agentic RAG 把控制写成显式循环。状态包含原问题、已发查询、已取段落、当前草稿与剩余预算；动作包含检索、作答、验证与终止。

一个典型的多步策略如下。

1. 规划：判断问题是否需要外部证据；若需要，判断是单跳还是多跳。
2. 首轮检索：用原问题或改写后的查询检索。
3. 充分性检查：检查当前证据是否覆盖问题的全部槽位。若缺少槽位，提取已知的桥接实体，用实体改写查询。
4. 二次检索：用改写查询检索，合并去重。
5. 作答与验证：生成带引用的草稿，逐条检查断言是否有段落支持。
6. 终止：验证通过、达到步数上限或预算耗尽时停止。

与 Self-RAG 的对比可以用控制位置概括。Self-RAG 的控制在模型内部：是否检索由 Retrieve token 的概率决定，是否采纳由 ISSUP 的概率决定，控制逻辑与语言能力共享参数。Agentic RAG 的控制在编排层：是否检索由控制器输出的动作决定，验证由独立调用完成，控制逻辑可以单独修改、记录与回放，但每次判断都要一次完整的模型调用。

### 6 查询分解与多跳

复合问题需要分解。并列型分解把问题拆成互不依赖的子问题，分别检索后汇总；顺序型分解让后一个子问题依赖前一个的答案。

以比较型问题为例：`A 与 B 的发布年份哪个更早`。并列分解为 `A 的发布年份` 与 `B 的发布年份`，两次检索可并行，最后比较两个年份。以桥接型问题为例：`Atlas 项目负责人常驻的城市`。第一跳求负责人，第二跳以负责人为查询求城市，两次检索必须串行。

多跳的成功率随跳数下降。设第 $h$ 跳独立的成功概率为 $p_h$，则

$$
P_{\text{success}}\approx\prod_{h=1}^{H}p_h .
$$

取 $p_h=0.8$、$H=3$，成功率约 $0.512$。错误会沿链传播：第一跳取错实体，第二跳的查询条件建立在错误实体上，后续检索再准也无法恢复。这正是需要在每跳之后做验证的原因：验证把"整链成功"分解为"每跳成功"，使错误在跳与跳之间被拦截，而不是在最终答案处才发现。

### 7 GraphRAG 的索引与查询

GraphRAG 用图结构组织语料，索引阶段包含四步。

1. 把文档切成文本单元。
2. 用模型从每个文本单元抽取实体、关系与声明，实体作为节点，关系作为边，声明作为带来源的附加属性。
3. 对实体图做层次化社区检测，GraphRAG 使用 Leiden 算法，把节点划分为多级社区。
4. 自底向上为每个社区生成摘要，子社区摘要汇入父社区摘要。

查询分为两类。全局查询面向"语料的主要主题是什么"这类需要汇总全 corpus 的问题，做法是对各社区摘要并行生成部分答案，再归约为最终答案，属于 map-reduce 结构。局部查询面向具体实体，从实体节点出发扩展邻居与关联声明，收集相关文本单元后生成答案。

GraphRAG 的成本集中在索引阶段：每个文本单元一次抽取调用，每个社区一次摘要调用，总调用数约为文本单元数与社区数之和。查询阶段的全局搜索需要对所有社区摘要做一次 map，社区数多时延迟与成本都高于块级检索。

适用边界明确：全局性、主题性、需要跨文档汇总的问题收益最大；单实体事实问题用块级检索即可，图的构建成本无法摊薄。

### 8 成本与延迟分析

不同方案的成本结构差异很大。下表给出量级关系，具体数值随模型、硬件与语料变化。

| 方法 | 索引成本 | 每查询检索次数 | 每查询模型调用 | 相对延迟 | 适用 |
|---|---|---|---|---|---|
| 朴素 RAG | 低 | 1 | 1 | 1.0 | 单跳事实问答 |
| 朴素 RAG 加重排 | 低 | 1 | 1 加 $k$ 对前向 | 1.1–1.3 | 排序噪声大 |
| Self-RAG | 中，需训练 critic | 0–2 | 1 次多候选解码 | 1.3–2.0 | 需要自适应检索 |
| Agentic RAG | 低 | 1 到 $T_{\text{steps}}$ | 2–5 | 3–6 | 多跳、比较、需要验证 |
| GraphRAG | 高，全语料抽取 | 1 次图查询 | 1 加社区 map | 索引一次性，查询 2–5 | 全局主题汇总 |

Agentic RAG 的延迟可以写成

$$
T_{\text{agentic}}\approx T_{\text{steps}}\,T_{\text{plan}}
+R\,T_{\text{ret}}+T_{\text{gen}}+V\,T_{\text{verify}},
$$

其中 $T_{\text{steps}}$ 是实际步数，$R$ 是检索次数，$V$ 是验证次数。取 $T_{\text{steps}}=3$、$R=2$、$V=1$、$T_{\text{plan}}=0.3$ s、$T_{\text{ret}}=0.05$ s、$T_{\text{gen}}=0.8$ s、$T_{\text{verify}}=0.3$ s，总延迟约 $3\times0.3+2\times0.05+0.8+0.3=2.1$ s；朴素 RAG 约为 $0.05+0.8+0.3=1.15$ s。多步方案的延迟约为朴素方案的两倍，收益必须用正确率提升来抵消。

成本控制依赖显式预算：最大步数 $T_{\max}$、最大检索次数、最大 token 数。没有预算约束的循环会在检索无命中时反复重试，成本随步数线性增长而正确率不增。

### 9 何时不该用高级 RAG

高级 RAG 的收益依赖三个前提：朴素 RAG 确实存在可测量的失效、失效可以通过增加控制步骤修复、修复带来的收益高于成本。任一前提不成立时，应停留在朴素方案。

具体判据如下。

语料足够小，全部内容可以放入长上下文且查询以单跳事实为主时，直接拼接全文的延迟与正确率都可能优于检索管线。检索的价值来自筛选，当筛选没有必要，检索只增加一次失败点。

朴素 RAG 在验证集上的正确率已经达到业务要求，且错误类型集中在生成而非检索时，增加检索轮次无益，应转向提示优化或微调。

延迟预算低于 1 秒且无法并行时，Agentic RAG 的多步串行调用无法满足约束；Self-RAG 的多候选解码同样会增加延迟。

没有标注集时，无法判断多步方案是否真的提高了正确率，也无法做消融。此时应先建立评估集，再考虑架构升级。

检索质量本身是瓶颈时，应先修分块与嵌入。分块切断了证据，任何控制层都无法恢复；这类问题的表现是多跳方案同样失败，且失败模式与朴素方案一致。

## 关键直觉

> [!tip]
> Self-RAG 把"是否检索、是否相关、是否有支撑、是否有用"变成可预测的 token，使这些判断进入训练目标与解码搜索；Agentic RAG 把同样的判断变成外部循环中的动作与状态，用多次模型调用换取可控性、可观测性与可修改性。

两者不是互斥的替代关系：Agentic RAG 的控制器可以是普通模型，也可以是带反思 token 的 Self-RAG 模型；Self-RAG 的片段级束搜索也可以在 Agent 循环中作为单步生成器。选择取决于控制逻辑需要多频繁地修改，以及延迟预算允许几次模型调用。

## 例子与代码

以下代码实现一个最小的 Agentic RAG 循环：控制器判断是否需要检索、首轮检索后检查证据是否覆盖全部槽位、缺少槽位时用桥接实体改写查询并二次检索、生成带引用的草稿并验证。运行环境为 Python 3.10 及以上，只依赖标准库。

代码用规则函数替代模型的三类调用，目的是让控制流在无模型环境中可复现、可打印、可断言；真实系统中 `plan`、`answer`、`verify` 都是模型调用，循环结构不变。

```python
# Python 3.10+，仅标准库
import re
from collections import Counter

CORPUS = [
    {"id": "p1", "text": "Atlas 项目的负责人是林哲。"},
    {"id": "p2", "text": "林哲的常驻办公地点是成都研发中心。"},
    {"id": "p3", "text": "Atlas 项目于 2024 年第三季度启动，目标是统一内部检索接口。"},
    {"id": "p4", "text": "成都研发中心位于高新区，主要负责基础平台研发。"},
    {"id": "p5", "text": "Orion 项目的负责人是陈默，办公地点在深圳。"},
    {"id": "p6", "text": "内部检索接口的日均调用量为 120 万次。"},
]

LEADER_RE = re.compile(r"([^。，]+?)的负责人是([\u4e00-\u9fff]{2,4})")
CITY_RE = re.compile(r"([\u4e00-\u9fff]{2,4})的常驻办公地点是([\u4e00-\u9fff]{2,8})")
ARITH_RE = re.compile(r"^\s*(\d+)\s*([+\-*/]|加|减|乘|除)\s*(\d+)\s*(等于几|等于多少|是多少)?\s*[?？]?\s*$")
OP_MAP = {"+": "+", "加": "+", "-": "-", "减": "-", "*": "*", "乘": "*", "/": "/", "除": "/"}


def _bigrams(s):
    s = re.sub(r"[^0-9a-z\u4e00-\u9fff]", "", s.lower())
    return {s[i:i + 2] for i in range(len(s) - 1)}


def retrieve(query, corpus, k=2):
    """字符二元组重叠打分，替代真实系统中的 BM25 或向量检索。"""
    q = _bigrams(query)
    scored = []
    for p in corpus:
        score = len(q & _bigrams(p["text"])) / (len(q) ** 0.5 + 1e-9)
        scored.append((score, p))
    scored.sort(key=lambda item: (-item[0], item[1]["id"]))
    return [p for s, p in scored[:k] if s > 0]


def facts(passages):
    leaders, cities = {}, {}
    for p in passages:
        for m in LEADER_RE.finditer(p["text"]):
            leaders[m.group(1).strip()] = (m.group(2), p["id"])
        for m in CITY_RE.finditer(p["text"]):
            cities[m.group(1)] = (m.group(2), p["id"])
    return leaders, cities


def _subject(question):
    m = re.match(r"(.+?)的负责人", question)
    return m.group(1).strip() if m else None


class PseudoLLM:
    """用规则函数替代 LLM 的三类调用，使控制流可在无模型环境中复现。"""

    def __init__(self):
        self.calls = Counter()

    def _resolve(self, question, passages):
        leaders, cities = facts(passages)
        subject = _subject(question)
        if subject is None:
            return None
        if subject not in leaders:
            return {"slot": "负责人", "subject": subject}
        leader, ev1 = leaders[subject]
        if "城市" in question or "常驻" in question:
            if leader not in cities:
                return {"slot": "城市", "subject": subject, "leader": leader}
            city, ev2 = cities[leader]
            return {"slot": None, "subject": subject, "leader": leader, "city": city, "cites": [ev1, ev2]}
        return {"slot": None, "subject": subject, "leader": leader, "cites": [ev1]}

    def plan(self, question, state):
        self.calls["plan"] += 1
        if ARITH_RE.match(question):
            return {"action": "answer", "query": None, "reason": "问题只含算术运算，不需要外部证据"}
        if not state["passages"] and not state["queries"]:
            return {"action": "retrieve", "query": question, "reason": "尚无候选段落，先执行首轮检索"}
        if not state["passages"]:
            return {"action": "answer", "query": None, "reason": "检索无命中，按无外部证据作答"}
        r = self._resolve(question, state["passages"])
        if r is not None and r["slot"] is None:
            return {"action": "answer", "query": None, "reason": "证据链完整，可以作答"}
        if len(state["queries"]) >= 2:
            return {"action": "answer", "query": None, "reason": "已达检索次数上限，按现有证据作答"}
        if r is not None and r["slot"] == "城市":
            return {"action": "retrieve", "query": f"{r['leader']} 常驻 办公地点 城市",
                    "reason": f"缺少城市，用桥接实体 {r['leader']} 改写查询后二次检索"}
        subject = r["subject"] if r else question
        return {"action": "retrieve", "query": f"{subject} 的负责人是谁",
                "reason": "缺少负责人，改写查询后二次检索"}

    def answer(self, question, passages):
        self.calls["answer"] += 1
        m = ARITH_RE.match(question)
        if m:
            a, b = int(m.group(1)), int(m.group(3))
            op = OP_MAP[m.group(2)]
            value = {"+": a + b, "-": a - b, "*": a * b, "/": a / b if b else float("nan")}[op]
            return {"text": str(value), "citations": []}
        r = self._resolve(question, passages)
        if r is None or r["slot"] is not None:
            return {"text": "信息不足，无法确定。", "citations": []}
        if "city" in r:
            return {"text": f"{r['leader']} 常驻 {r['city']}。", "citations": r["cites"]}
        return {"text": f"{r['subject']}的负责人是{r['leader']}。", "citations": r["cites"]}

    def verify(self, question, draft, passages):
        self.calls["verify"] += 1
        if ARITH_RE.match(question):
            return {"supported": True, "reason": "算术结果由输入直接决定"}
        r = self._resolve(question, passages)
        if r is None or r["slot"] is not None:
            slot = r["slot"] if r else "问题结构"
            return {"supported": False, "reason": f"缺少{slot}对应的证据"}
        value = r.get("city") or r["leader"]
        ok = value in draft["text"]
        return {"supported": ok, "reason": "草稿实体与证据链一致" if ok else "草稿与证据链不一致"}


def agentic_rag(question, llm, max_steps=5, k=2):
    state = {"queries": [], "passages": [], "draft": None}
    for step in range(1, max_steps + 1):
        plan = llm.plan(question, state)
        print(f"[step {step}] plan -> {plan['action']:<8} | {plan['reason']}")
        if plan["action"] == "retrieve":
            hits = retrieve(plan["query"], CORPUS, k=k)
            state["queries"].append(plan["query"])
            seen = {p["id"] for p in state["passages"]}
            state["passages"].extend([p for p in hits if p["id"] not in seen])
            print(f"[step {step}] retrieve {plan['query']!r} -> {[p['id'] for p in hits]}")
        elif plan["action"] == "answer":
            draft = llm.answer(question, state["passages"])
            verdict = llm.verify(question, draft, state["passages"])
            print(f"[step {step}] answer   -> {draft['text']!r} citations={draft['citations']}")
            print(f"[step {step}] verify   -> supported={verdict['supported']} | {verdict['reason']}")
            if verdict["supported"]:
                return {"answer": draft["text"], "retrievals": len(state["queries"]), "steps": step}
            if state["draft"] is not None:
                return {"answer": draft["text"], "retrievals": len(state["queries"]), "steps": step}
            state["draft"] = draft
        else:
            break
    text = state["draft"]["text"] if state["draft"] else "未完成"
    return {"answer": text, "retrievals": len(state["queries"]), "steps": max_steps}


def naive_rag(question, llm, k=3):
    hits = retrieve(question, CORPUS, k=k)
    draft = llm.answer(question, hits)
    verdict = llm.verify(question, draft, hits)
    return {"answer": draft["text"], "retrievals": 1, "supported": verdict["supported"],
            "hits": [p["id"] for p in hits]}


if __name__ == "__main__":
    golden = {"Atlas 项目的负责人常驻哪个城市？": "成都",
              "Orion 项目的负责人是谁？": "陈默",
              "1 加 1 等于几？": "2"}

    print("=== 朴素 RAG：固定一次检索 ===")
    naive_results = {}
    for q, gold in golden.items():
        llm = PseudoLLM()
        out = naive_rag(q, llm)
        ok = gold in out["answer"]
        naive_results[q] = (out, ok, dict(llm.calls))
        print(f"{q} -> 检索={out['hits']} 答案={out['answer']!r} 正确={ok} 调用={dict(llm.calls)}")

    print("\n=== Agentic RAG：按需检索与二次检索 ===")
    agentic_results = {}
    for q, gold in golden.items():
        print(f"\n-- {q}")
        llm = PseudoLLM()
        out = agentic_rag(q, llm)
        ok = gold in out["answer"]
        agentic_results[q] = (out, ok, dict(llm.calls))
        print(f"结果: {out['answer']!r} 正确={ok} 检索次数={out['retrievals']} 步数={out['steps']}")

    print("\n=== 对照汇总 ===")
    print(f"{'问题':<26}{'朴素正确':<8}{'朴素检索':<8}{'Agentic正确':<12}{'Agentic检索':<12}{'Agentic步数':<11}")
    for q in golden:
        n_out, n_ok, _ = naive_results[q]
        a_out, a_ok, _ = agentic_results[q]
        print(f"{q:<26}{str(n_ok):<8}{n_out['retrievals']:<8}{str(a_ok):<12}{a_out['retrievals']:<12}{a_out['steps']:<11}")
```

代码分四部分。`retrieve` 用字符二元组重叠打分，模拟检索器，并过滤零分文档；`facts` 与 `_resolve` 从段落中抽取负责人与城市事实，替代模型的理解能力；`PseudoLLM` 的 `plan`、`answer`、`verify` 分别对应控制器、生成器与校验器，`plan` 返回动作与理由，`answer` 返回文本与引用，`verify` 返回支持判定；`agentic_rag` 维护状态并逐步打印决策，`naive_rag` 固定执行一次检索。把 `plan` 中的槽位检查替换为模型调用、把 `verify` 替换为自然语言推理模型，即可得到生产结构的骨架。

运行输出如下。

```text
=== 朴素 RAG：固定一次检索 ===
Atlas 项目的负责人常驻哪个城市？ -> 检索=['p1', 'p3', 'p5'] 答案='信息不足，无法确定。' 正确=False 调用={'answer': 1, 'verify': 1}
Orion 项目的负责人是谁？ -> 检索=['p5', 'p1', 'p3'] 答案='Orion 项目的负责人是陈默。' 正确=True 调用={'answer': 1, 'verify': 1}
1 加 1 等于几？ -> 检索=[] 答案='2' 正确=True 调用={'answer': 1, 'verify': 1}

=== Agentic RAG：按需检索与二次检索 ===

-- Atlas 项目的负责人常驻哪个城市？
[step 1] plan -> retrieve | 尚无候选段落，先执行首轮检索
[step 1] retrieve 'Atlas 项目的负责人常驻哪个城市？' -> ['p1', 'p3']
[step 2] plan -> retrieve | 缺少城市，用桥接实体 林哲 改写查询后二次检索
[step 2] retrieve '林哲 常驻 办公地点 城市' -> ['p2', 'p5']
[step 3] plan -> answer   | 证据链完整，可以作答
[step 3] answer   -> '林哲 常驻 成都研发中心。' citations=['p1', 'p2']
[step 3] verify   -> supported=True | 草稿实体与证据链一致
结果: '林哲 常驻 成都研发中心。' 正确=True 检索次数=2 步数=3

-- Orion 项目的负责人是谁？
[step 1] plan -> retrieve | 尚无候选段落，先执行首轮检索
[step 1] retrieve 'Orion 项目的负责人是谁？' -> ['p5', 'p1']
[step 2] plan -> answer   | 证据链完整，可以作答
[step 2] answer   -> 'Orion 项目的负责人是陈默。' citations=['p5']
[step 2] verify   -> supported=True | 草稿实体与证据链一致
结果: 'Orion 项目的负责人是陈默。' 正确=True 检索次数=1 步数=2

-- 1 加 1 等于几？
[step 1] plan -> answer   | 问题只含算术运算，不需要外部证据
[step 1] answer   -> '2' citations=[]
[step 1] verify   -> supported=True | 算术结果由输入直接决定
结果: '2' 正确=True 检索次数=0 步数=1

=== 对照汇总 ===
问题                        朴素正确    朴素检索    Agentic正确   Agentic检索  Agentic步数
Atlas 项目的负责人常驻哪个城市？       False   1       True        2           3
Orion 项目的负责人是谁？           True    1       True        1           2
1 加 1 等于几？                True    1       True        0           1
```

三个问题展示三种控制行为。

多跳问题在朴素 RAG 中失败。固定检索用完整问题检索，返回 p1、p3、p5：p1 含 `Atlas 项目` 与 `负责人`，p3 也含 `Atlas 项目`，p5 含 `负责人`，三篇都与查询有字面重叠，但都不含城市。`answer` 找不到城市槽位，输出"信息不足"。Agentic 循环在首轮只取到 p1 与 p3，`plan` 检查发现负责人已知、城市缺失，把桥接实体 `林哲` 写入改写查询，第二轮取到 p2，随后作答并给出两条引用。两轮检索的召回集合从两篇扩展到四篇，覆盖了证据链。

单跳问题在两种方案下都成功，但成本不同。Agentic 方案用一次检索、两步完成；朴素方案用一次检索、一次生成，步数更少。这提示多步控制并非在所有问题上都更优，收益依赖问题结构。

不需要检索的问题展示自适应检索的价值。朴素方案仍然执行一次检索，返回空列表，随后由 `answer` 直接计算；Agentic 方案在 `plan` 阶段判定为算术问题，检索次数为 0。一次无用的检索在单条请求上只是几十毫秒，在高并发下会转化为可观的成本与尾延迟。

### 与朴素 RAG 的对照实验设计

上面的演示只覆盖三个构造问题，不能说明方案在真实数据上的收益。对照实验需要控制变量并测量过程指标，设计如下。

| 维度 | 设置 |
|---|---|
| 数据集 | 自建 200 题，覆盖单跳、多跳、比较、聚合四类；另取 HotpotQA 与 Natural Questions 各 500 题做外部验证 |
| 基线 | 朴素 RAG、朴素 RAG 加重排、Self-RAG、Agentic RAG |
| 控制变量 | 同一分块器、同一嵌入模型、同一生成模型、同一提示模板、同一召回数 $k$ |
| 主指标 | 答案 EM 与 F1、判定模型打分、引用精确率与引用召回率 |
| 过程指标 | retrieval recall@k、平均检索次数、模型调用次数、总 token 数、p50 与 p95 延迟 |
| 统计 | 配对 bootstrap 估计 95% 置信区间，三个随机种子取均值，报告效应量 |
| 消融 | 去掉验证步骤、去掉查询改写、步数上限取 1、2、3、5 |
| 错误分析 | 按第 1 节的失效类型人工分类 100 条错误，报告各类占比 |

实验的关键是区分"多步带来的正确率增益"与"多次调用带来的成本"。只看主指标会高估复杂方案：多步方案通常调用更多 token，而更多 token 本身就能提高正确率。应同时报告等 token 预算下的对比，即给朴素 RAG 相同的 token 预算做多次采样取多数投票，再比较。

引用指标需要单独定义。引用精确率统计答案引用的段落中确实包含支撑句的比例；引用召回率统计支撑答案所需的段落被引用的比例。只报告精确率会奖励"少引用"的策略，只报告召回率会奖励"全引用"的策略，两者必须同时报告。

消融实验回答机制问题。去掉验证步骤后正确率下降的幅度，衡量验证的价值；去掉查询改写后多跳子集的下降幅度，衡量桥接实体的价值；步数上限从 1 增到 5 时正确率的饱和点，决定生产环境的默认上限。

## 易错点

> [!warning]
> - 把 Self-RAG 的反思 token 当作提示词里的普通标签：这些 token 需要 critic 标注与生成器微调，仅在提示中写 `[Relevant]` 不会产生可靠判断，也不会改变解码分布。
> - 把 Agentic RAG 等同于"多调用几次模型"：没有状态、终止条件与预算控制的循环会重复检索同一查询，成本上升而正确率不变。
> - 用检索次数衡量多跳收益：收益来自正确的桥接实体与覆盖的证据链，检索次数只是成本项；两次错误检索不如一次正确检索。
> - 忽略错误传播：单跳成功率 0.8 时三跳成功率约 0.51，不在每跳后验证就无法阻止错误累积。
> - 对单实体事实问题使用 GraphRAG：索引阶段的全语料抽取成本无法摊薄，查询阶段收益接近零。
> - 不设最大步数与 token 预算：延迟与成本随输入分布变化，尾延迟不可控，线上会出现超时重试放大。

## 关联笔记

- [[RAG原理与流程]]（前置）：给出单轮检索增强的定义与链路，本篇处理该链路之外的检索时机与迭代控制。
- [[检索优化与重排Rerank]]（前置）：召回与重排决定每轮检索的候选质量，迭代检索的每一跳都复用该管线。
- [[AI-Agent与工具调用]]（前置）：工具调用协议是 Agentic RAG 的实现基础，检索工具的参数与返回值遵循同一套接口。
- [[幻觉与缓解]]（对照）：ISSUP 与引用验证针对的是无支撑生成，两者从不同层面处理同一类错误。
- [[RAG评估]]（后续）：本篇的对照实验需要三元组评估与检索指标的口径，评估笔记给出完整定义。

## 达标检测

- [ ] 能列出朴素 RAG 的五类失效，并为每类给出对应的改进机制与可测指标。
- [ ] 能说明 Self-RAG 四类反思 token 的取值、插入位置与判断对象。
- [ ] 能写出 Self-RAG 推理时的候选评分公式，并解释 $\lambda$ 与阈值 $\delta$ 的作用。
- [ ] 能推导三跳问题在单跳成功率 0.8 时的整体成功率，并说明为什么需要逐跳验证。
- [ ] 能运行本篇代码，把最大步数改为 1 并说明多跳问题的结果变化。
- [ ] 能设计一个区分"多步增益"与"更多 token 增益"的对照实验，写出控制变量与等预算基线。
- [ ] 能判断给定场景是否应使用 Agentic RAG，并给出至少两条量化依据。
- [ ] 能指出"仅在提示词中写 `[Relevant]` 就认为实现了 Self-RAG"这一错误，并说明缺少的训练环节。

## 参考来源

- Asai et al., *Self-RAG: Learning to Retrieve, Generate, and Critique through Self-Reflection*, arXiv:2310.11511 —— 对应本篇反思 token 的定义、训练信号与推理时的候选选择。
- Gao et al., *Retrieval-Augmented Generation for Large Language Models: A Survey*, arXiv:2312.10997 —— 对应朴素 RAG 的失效分类与检索增强流程的演进脉络。
- Edge et al., *From Local to Global: A Graph RAG Approach to Query-Focused Summarization*, Microsoft Research, 2024 —— 对应本篇 GraphRAG 的实体图构建、层次化社区检测与社区摘要思想。
