w wyl123ly 的博客
MD

进阶RAG-Self-RAG与Agentic-RAG

35 KB 2026.10.18 原文件

进阶RAG-Self-RAG与Agentic-RAG

定义

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

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

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

其中 是第 个片段上的反思 token, 是第 次检索返回的段落集合, 表示该片段是否执行检索。

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

其中 是原问题, 是已发出的查询, 是已取得的段落, 是当前草稿, 是剩余预算。

符号约定如下。

符号含义
输入问题
输出序列
反思 token 序列
生成片段数
最大步数
检索段落集合
每轮检索返回的段落数
是否检索的二值决策
检索与采纳的阈值
生成策略或控制器策略
第 步的状态
第 步的动作
剩余预算,包括步数与 token 数
多跳问题的跳数
第 跳的成功概率

其余术语在首次出现处定义。反思 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取值插入位置判断对象
RetrieveYes / No每个生成片段之前当前是否需要检索
ISRELRelevant / Irrelevant每个检索段落之后段落与问题是否相关
ISSUPFully supported / Partially supported / No support每个生成片段之后片段是否被段落支持
ISUSE1 到 5完整输出之后回答对问题的有用程度

生成序列因此形如

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

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

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

阈值 越高,检索越少; 时永不检索, 时每段都检索。ISREL 与 ISSUP 同样按阈值过滤:低于阈值的段落被丢弃,低于阈值的片段被重新生成或触发二次检索。

3 Self-RAG 的训练信号

训练分两个阶段。

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

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

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

其中 是增广序列, 与 分别是输出 token 与反思 token 的位置集合。屏蔽检索段落的原因是:段落已在输入中给出,让模型复述段落会浪费容量,并使损失被长段落主导。

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

4 推理时的候选选择

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

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

解码流程如下。

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

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

该流程的计算量高于朴素 RAG:每个片段最多 次生成,加上 critic 的前向。束宽与候选数是延迟的主要来源,通常取 到 、 到 。

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 项目负责人常驻的城市。第一跳求负责人,第二跳以负责人为查询求城市,两次检索必须串行。

多跳的成功率随跳数下降。设第 跳独立的成功概率为 ,则

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

7 GraphRAG 的索引与查询

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

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

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

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

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

8 成本与延迟分析

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

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

Agentic RAG 的延迟可以写成

其中 是实际步数, 是检索次数, 是验证次数。取 、、、 s、 s、 s、 s,总延迟约 s;朴素 RAG 约为 s。多步方案的延迟约为朴素方案的两倍,收益必须用正确率提升来抵消。

成本控制依赖显式预算:最大步数 、最大检索次数、最大 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 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 替换为自然语言推理模型,即可得到生产结构的骨架。

运行输出如下。

=== 朴素 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
控制变量同一分块器、同一嵌入模型、同一生成模型、同一提示模板、同一召回数
主指标答案 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 推理时的候选评分公式,并解释 与阈值 的作用。
  • [ ] 能推导三跳问题在单跳成功率 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 的实体图构建、层次化社区检测与社区摘要思想。