跳到主要内容
Ed. notes

05 引用体系:编号是局部命名空间

长文 · 2026-11-17 · 合集第 6 / 10 篇

  • RAG
  • 引用
  • SSE
第 6 / 10 篇 · 查看全部章节 → 当前:05 引用体系:编号是局部命名空间

一句话结论

引用能降低幻觉,但不能消除幻觉。[n] 是每次请求内的局部命名空间,一旦发出就不能改;因此编号必须由服务端统一分配,约束放在生成前,校验放在流结束后。多次检索时,用一个只增不改的注册表维护它。

它解决什么问题

引用系统有三个典型故障:

  • 模型引用 [7],但资料只有 5 条;
  • 上一轮回答里的 [1] 被拼进历史,和这一轮的 [1] 指向不同文章;
  • 改成「模型自己决定检索」后,同一段内容被检索两次,编号开始漂移。

它们分别对应:缺少校验、跨轮命名空间冲突、多次检索缺少注册表。

为什么引用有用,以及它的边界

要求模型「每个事实后标 [n],n 对应资料编号」,会促使它从资料里摘取,减少编造。注意措辞:减少,不是消除。 模型完全可能编一个不存在的编号,或者标了 [1] 但内容其实来自 [3]。

编号是局部命名空间

每一轮资料都从 [1] 重新编号:

context = "\n\n".join(
    f"[{index}] {chunk.title} — {label}\n{chunk.text}"
    for index, chunk in enumerate(chunks, start=1)
)

而历史里的回答也带着上一轮的 [1] [2]。把它们原样拼进 messages:

Human: 资料:[1] 镜像与多阶段构建…[2] 部署…
AI:    多阶段构建把依赖分层[1],减少了镜像体积[2]。
Human: 资料:[1] 自动化测试…[2] CI…
AI:    ← 现在看到两个 [1],指向两篇不同的文章

模型可能把上一轮的 [1] 当成本轮的 [1],或者在新回答里沿用旧编号。用户点开引用,发现文不对题。

修法:历史进入 prompt 前,剥掉所有 [n]。

_CITATION = re.compile(r"\[\d+\]")

def strip_citations(text: str) -> str:
    return _CITATION.sub("", text).strip()

信息损失很小——引用关系本来就不该跨轮复用。

流式下只能「前约束 + 后校验」

一旦 token 发出去,就收不回来。所以:

前约束:prompt 里动态写死范围。

SYSTEM_PROMPT = f"""……
资料编号只有 [1] 到 [{len(chunks)}]。
只能引用这个范围内的编号。"""

后校验:流结束后检查,不改文本,只发警告。

def invalid_citations(answer: str, n: int) -> list[int]:
    used = {int(x) for x in re.findall(r"\[(\d+)\]", answer)}
    return sorted(x for x in used if x < 1 or x > n)


bad = invalid_citations(answer, len(chunks))
if bad:
    yield _sse("done", {"finishReason": "stop", "citationWarning": True})

前端显示一行「部分引用可能不准确」。这比偷偷发错误答案、或者为了修引用把整段回答重写一遍都更诚实、更便宜。

五条不变量

不变量 含义
唯一性 一个 n 只对应一个来源
稳定性 n 一旦发出,含义永不改变
完备性 模型可能引用的每个 n 都在列表里
幂等性 同一内容重复检索,得到同一个 n
有序性 明确 n 是否代表相关性

现状靠「一次检索、一个列表、一次 enumerate」天然满足前四条。一旦检索发生多次,就必须显式维护。

多次检索:服务端注册表

如果让模型通过工具自己决定检索,ReAct 的循环会让检索发生 0~N 次。此时编号不能再由「本次检索的列表下标」决定,而要由一个注册表分配:

from dataclasses import dataclass, field


@dataclass
class SourceRegistry:
    """一次请求内的引用注册表。编号只增不改。"""

    _by_chunk: dict[str, int] = field(default_factory=dict)
    _sources: list[dict[str, object]] = field(default_factory=list)

    def get_or_add(self, hit) -> tuple[int, bool]:
        existing = self._by_chunk.get(hit.id)
        if existing is not None:
            return existing, False

        number = len(self._sources) + 1
        self._by_chunk[hit.id] = number
        self._sources.append(hit.as_source(number))
        return number, True

    def snapshot(self) -> list[dict[str, object]]:
        return list(self._sources)

规则:

  1. 去重键是 chunk.id。本仓库的切片 ID 是稳定哈希,同一段内容无论被检索几次,都是同一个编号。
  2. 编号 = 首次出现顺序,单调递增,绝不回收。
  3. 作用域 = 单次请求。跨轮重新编号,历史引用剥掉。
  4. 工具结果必须带 [n],否则模型会自己发明编号。
  5. 每次推送全量快照。前端现有的「整体替换」语义直接兼容,不需要改成增量合并。
  6. 必须加上限:最多 3 次工具调用、最多 20 条来源,否则模型可以一直搜下去。

编号的语义也要说清楚:[1] 是「第一次检索的第一条」,不代表全局最相关。排序和编号要分开——前端可以按分数排序显示,但标签仍是原来的 n。

更简单:两阶段「先规划、后检索」

如果目的只是「让 LLM 决定搜什么」,而不是边搜边答,可以完全不引入注册表:

triage → plan(结构化输出 1~3 个搜索词)
        → retrieve_many(并行)
        → merge + 去重 + 排序
        → enumerate 一次 → [1..n]
        → generate

chunks 又变回一个列表,build_messages 和 sources 事件各自 enumerate 一次,现有契约零改动。代价是多一次 LLM 调用(单轮完整问题可跳过),失去「边搜边想」,但十几篇语料本来也不需要。

我怎么试的

1. 跨轮引用冲突

构造两轮对话,让第一轮命中文章 A、第二轮命中文章 B,检查 sent messages:

messages = build_messages("第二个问题", history, chunks)
transcript = "\n".join(m.content for m in messages)

assert "[1]" not in transcript.split("资料:")[0]   # 历史里不应残留编号

2. 越界引用校验

assert invalid_citations("结论见 [1] 和 [7]。", n=5) == [7]
assert invalid_citations("结论见 [1] 和 [5]。", n=5) == []

3. 注册表幂等

registry = SourceRegistry()
first = registry.get_or_add(hit)
second = registry.get_or_add(hit)

assert first == second
assert len(registry.snapshot()) == 1

这三条都只依赖纯函数,不需要数据库或模型,适合放进默认测试集。

坑和限制

  • 流式回答不能事后改。 引用校验只能发警告,不能替换已发送的文本;想彻底修,只能改成非流式,但那会牺牲对话体验。
  • 编号不等于相关性。 多次检索后 [1] 只是「第一次出现」,不要在前端暗示它是最佳来源。
  • 注册表需要上限。 没有上限,模型可能循环检索,上下文和费用一起失控。
  • 历史剥离不能省。 即使有了注册表,跨请求仍然重新编号;历史里的旧编号必须清掉。
  • 校验只查范围,不查内容。 [1] 在范围内,不代表那句话真的出自资料 1;更强的忠实度校验需要逐句蕴含判断,成本和复杂度都更高。
  • 前端 :key 依赖 n 唯一。 累积快照必须保证不重复,否则列表渲染会出现重复 key。

适合谁

适合已经能看到来源列表、但引用偶尔指向错文章的人,或者正在考虑「让模型自己决定检索」的人。先守住唯一、稳定、完备、幂等这四条,再谈更复杂的 agent 形态。

下一篇回到体验本身:从用户点发送到第一个字出现,中间到底发生了什么。