FDE 企业 AI 落地与交付 · 知识检索与问答问题 · 2026-07-10

千万文档级 RAG 如何逼近零幻觉

千万级文档RAG如何实现接近零幻觉?本文详解一条从检索、验证到拒答的完整流水线。

核心内容:

  1. 构建混合索引与智能检索重排策略
  2. 带引用生成与逐条核验的验证闸门
  3. 可自我纠错的Agent循环与大规模评估

文章拆解一个面向千万级文档的 RAG 流水线,重点是如何通过检索、约束、验证和弃答,把幻觉压到接近零。

向 RAG 系统中塞入的文档越多,它“编造答案”的空间也就越大;当语料规模增长到数百万、逼近 10M 乃至更高时,幻觉问题只会进一步恶化。想要在这种规模下依然让答案可信,就必须构建一条这样的流水线:让 agent 自行核查证据,并为每一条结论附上引用。这与 Claude 使用引用的核心思路一致。

这条流水线包含的全部组件如下。我们会自上而下逐步搭建,每次只完成一个组件:

全部代码都已发布在我的 GitHub 仓库中(Theory + Code):

GitHub - FareedKhan-dev/rag-zero-hallucinations: Handling 10M+ docs using RAG with zero…[1]Handling 10M+ docs using RAG with zero hallucinatons - GitHub - FareedKhan-dev/rag-zero-hallucinations: Handling 10M+…

千万文档级 RAG 如何逼近零幻觉

接近零,而非绝对零

我们要解决的问题,不是“让模型更聪明”。即便换成更大的模型,只要检索没有返回有效结果,它依然会猜;因为“猜”本来就是生成模型的默认行为。

所以,与其追求一个完美模型,不如把一个普通模型包裹进一套系统里,并且让它只有一种安全的失败方式:当证据缺失时,正确输出不该是流畅却未经证实的猜测,而应该是拒答。

这就形成了四层控制机制,后文每一节都对应其中一层。

  1. 检索到正确证据:混合稠密检索与 BM25 检索、上下文化 chunk,以及重排。
  2. 约束生成:只能基于上下文作答;每句话都必须引用 passage id;否则就拒答。
  3. 核验每一条原子级 claim:使用 faithfulness judge,将每条 claim 与其引用文本逐一比对。
  4. 拒答:当 claim 支持度或检索置信度低于校准阈值时,拒绝回答。

我们的目标有两个,而且必须同时达成。第一个是 可信性:对于我们选择回答的问题,幻觉率要接近于零。

第二个是 规模化:检索底座必须能够承载 10M+ 向量,并且仍然在毫秒级返回结果。前者依赖验证逻辑,后者依赖索引能力。

这两者我们都会构建。

项目初始化

在实现任何逻辑之前,先把项目本身搭起来。整体计划是:导入所需库,固定所有随机种子以保证可复现性,检查我们可用的那一块 GPU,把一个轻量客户端指向生成模型,并冻结配置,使无头运行在每次执行时都保持一致。

首先是导入依赖,以及一个统一设置所有随机数生成器种子的函数。

import json, os, random, subprocess, timefrom dataclasses import dataclass, asdict, fieldimport numpy as npdef set_determinism(seed: int) -> None: """Seed every RNG we touch so runs are reproducible.""" random.seed(seed) np.random.seed(seed) os.environ["PYTHONHASHSEED"] = str(seed) try: import torch torch.manual_seed(seed) torch.cuda.manual_seed_all(seed) except Exception: passset_determinism(42)

我会在最开始固定随机种子,因为不可复现的 RAG 评测根本不能算评测;而这篇博客的核心目的,就是让读者能够信任最终给出的那些数字。这个 notebook 也做了参数化处理,因此只需一个单元格就能解析本次运行配置,并打印接下来将采用的构建环境。

#### OUTPUT ####profile=FULL slice=20000 eval=100+100 artifacts=/mnt/data/artifacts

这次跑的是完整配置:20,000 个 passages,以及 100+100 道评测题;不是我最开始用来低成本排查代码错误的那个微型 smoke profile。我们只使用单张 GPU,所以 VRAM 是一项刚性预算,而不是运行到一半才发现的意外限制。为此,我们先用 nvidia-smi 读取显卡信息,并通过断言确认当前硬件确实符合预期。

def gpu_report() -> dict: """Return GPU name / memory / driver and assert we are on an 80GB H100.""" name = _smi("name")[0] total = float(_smi("memory.total")[0]) / 1024.0 # GiB rep = { "name": name, "total_gb": round(total, 1), "free_gb": round(float(_smi("memory.free")[0]) / 1024.0, 1), "driver": _smi("driver_version")[0] } print(json.dumps(rep, indent=2)) assert "H100" in name and total >= 79 # one 80GB H100, nothing smaller return rep#### OUTPUT ####{ "name": "NVIDIA H100 PCIe", "total_gb": 79.6, "free_gb": 32.8, "driver": "570.195.03"}

我们运行在一张 80 GB 的 NVIDIA H100 上;配套主机还有 180 GB 内存和 750 GB NVMe 磁盘。随着索引规模增大,这些资源在后文会变得很关键。32B 生成模型并不直接运行在这个 notebook 里。

它部署在独立的 vLLM server 中,我们通过一个小型的 OpenAI-compatible client 与之通信。把它常驻在独立进程里并保持热启动状态,意味着我们可以反复重跑这个 notebook,而不必每次都重新加载模型。

class LocalLLM: """面向预热完成的 vLLM OpenAI-compatible server 的轻量客户端。""" def __init__(self, endpoint: str, model: str, thinking: bool = False): self.endpoint, self.model, self.thinking = endpoint.rstrip("/"), model, thinking def chat(self, system: str, user: str, temperature: float = 0.0, max_tokens: int = 512) -> str: body = { "model": self.model, "temperature": temperature, "max_tokens": max_tokens, "messages": [ {"role": "system", "content": system}, {"role": "user", "content": user} ] } if not self.thinking: # Qwen3:关闭 body["chat_template_kwargs"] = {"enable_thinking": False} r = requests.post(f"{self.endpoint}/chat/completions", json=body, timeout=120) r.raise_for_status() return r.json()["choices"][0]["message"]["content"]llm = LocalLLM("http://localhost:8000/v1", "Qwen/Qwen3-32B")print(f"[llm] up={llm.is_up()}")#### OUTPUT ####[llm] up=True

服务已经启动。最后一步配置工作,是把所有可调参数固定到一个配置对象里并打印出来,这样后文所有实验数字都集中在同一个地方。

#### OUTPUT ####{ "gen_model": "Qwen/Qwen3-32B", "embed_offline": "Qwen/Qwen3-Embedding-4B", "rerank_model": "Qwen/Qwen3-Reranker-4B", "chunk_tokens": 256, "chunk_overlap": 32, "retrieve_k": 150, "rerank_top_n": 20, "rrf_k": 60, "max_hops": 3, "crag_ok": 0.7, "crag_bad": 0.4, "tau_claim": 0.3, "tau_abstain": 0.3, "seed": 42}

这里的设置是:先召回 150 个候选,再重排压缩到 20 个;允许 agent 最多进行 3 次纠错跳转;并把两个支持度阈值都先设为 0.3,后面再做校准。生成模型使用 Qwen3–32B,Embedding 和 Reranker 使用 Qwen3 的 4B 模型,而负责判断忠实性的也是同一个 32B 模型。

我把生成器固定在 temperature 0,同时关闭 thinking trace,因为我需要结果可复现、延迟尽可能低;另外,采样本身也是模型偏离已提供证据的一个额外入口。这里所有模型都采用本地部署的开放权重 Qwen3,这也是整套方案成立的前提:文档和查询都不离开这台机器。正因如此,这样的 pipeline 才真正适用于私有语料库。

工具准备好之后,就可以开始取数据了。

获取数据

一个 pipeline 的上限,取决于它下面那层 corpus 的质量。因此第一步真正要做的事,是先下载数据集并实际看一遍。我选择 HotpotQA 的 distractor 设置,主要有两个原因。

首先,它的每个问题都附带句子级别的 gold supporting facts,这为后续评估检索召回率提供了最干净的打分依据;其次,它自带的 Wikipedia 段落天然就是一套可直接使用的真实 corpus。为了测试另一面,我又引入了 SQuAD v2 中的 impossible questions,并手工写了少量 false-premise questions,因为要衡量幻觉,唯一可靠的方法就是故意提出 corpus 无法回答的问题,再检查系统是否真的保持沉默。

第三组数据 HaluBench 会在接近结尾时出现,它唯一的用途是验证 verifier 本身。真正用来构建和检索的 corpus,还是 HotpotQA。

from datasets import load_datasetdef load_hotpotqa(split: str = "validation"): # datasets 3.x wants the namespaced repo id return load_dataset("hotpotqa/hotpot_qa", "distractor", split=split, cache_dir=DS_CACHE)hotpot = load_hotpotqa()print(f"[data] hotpotqa(validation) = {len(hotpot)} questions")
#### OUTPUT ####[data] hotpotqa(validation) = 7405 questions

也就是说,这里一共有 7,405 个问题,并且每个问题都附带了其对应的 Wikipedia 段落来源。接下来,我们先定义 passage 和 question 的数据结构,再实现一个构建器:把所有问题的上下文段落合并成一个统一语料库,同时记录哪些 passage 是对应问题的 gold evidence。

@dataclassclass Passage: id: str title: str text: str is_gold_for: list[str] = field(default_factory=list)@dataclassclass QAItem: qid: str question: str answer: str answerable: bool gold_titles: list[str] = field(default_factory=list) gold_sentences: list[str] = field(default_factory=list) qtype: str = ""class CorpusBuilder: """Build a passage corpus + QA items from HotpotQA distractor contexts.""" def build(self, qa, n_passages: int): passages, qa_items = {}, [] for ex in qa: gold = list(dict.fromkeys(ex["supporting_facts"]["title"])) for t, ss in zip(ex["context"]["title"], ex["context"]["sentences"]): para = " ".join(s.strip() for s in ss).strip() if len(para)
#### OUTPUT ####[corpus] passages=20007 qa_items=2073 gold-bearing passages=4072

现在,我们手里有 20,007 个 passages 和 2,073 个问题,其中 4,072 个 passages 被标记为某些问题的 gold evidence。在基于这些数据继续构建系统之前,应该先真正看一眼数据本身:既要看规模分布,也要看一个真实样本。

import pandas as pdtok_lens = [len(p.text.split()) for p in corpus]print(pd.Series(tok_lens, name="passage_word_count").describe().round(1).to_string())ex = qa_items[0]print(f"\nSample question:\n Q: {ex.question}\n A: {ex.answer} (type={ex.qtype})")print(f" gold titles: {ex.gold_titles}")for s in ex.gold_sentences: print(f" - {s}")#### OUTPUT ####count 20007.0mean 89.2std 53.4min 7.025% 54.050% 80.075% 113.0max 1378.0Sample question:Q: Were Scott Derrickson and Ed Wood of the same nationality?A: yes (type=comparison)gold titles: ['Scott Derrickson', 'Ed Wood']- Scott Derrickson (born July 16, 1966) is an American director, screenwriter and producer.- Edward Davis Wood Jr. was an American filmmaker, actor, writer, producer, and director.

这些 passage 的平均长度约为 89 个词:既足够短,能在一个 prompt 中容纳几段;又足够长,能够承载完整事实。上面的示例是一个比较型问题:“Were Scott Derrickson and Ed Wood of the same nationality?” 它对应的两条 gold sentence 已经直接给出答案:两人都是 American。

在这篇博客里,我会一路跟踪这个问题贯穿整个流程。因为让一个真实问题走完整条 pipeline,最能把每个组件讲清楚、讲具体。这里其实已经能看出两个层次。

像这个例子这样“可回答”的问题,可以用来衡量系统是否找回了正确证据;而我后面加入的“不可回答”问题,则用来衡量幻觉。因为如果系统会对语料库中根本没有支持证据的问题作答,那它本质上就是在编造答案。

清洗语料库

垃圾输入,往往就会产出幻觉。所以在建立索引之前,必须先把文本清洗干净。这里有两个成本很低、但收益极高的步骤。其一是标准化,它能让 tokenizer 在所有 passage 上都表现一致;其二是近重复去重,它可以避免被复制或转发的段落挤占检索结果前列,造成“看似召回变高、实则没有新增证据”的假象。

import re, unicodedatadef normalize_text(s: str) -> str: s = unicodedata.normalize("NFKC", s) # canonical unicode form s = s.replace("­", "") # drop soft hyphens s = re.sub(r"[ \t]+", " ", s) # collapse runs of spaces return s.strip()

我首先做 NFKC 标准化,因为 BM25 是基于原始字符做分词的:一个连字,或者一串意外空白,都可能把一个词拆成两个,或者把两个词粘成一个,从而在不知不觉中损害召回率。对于脏文本,这个函数的效果正是我们想要的。

#### OUTPUT ####>>> normalize_text("the final report\twas ready")'the final report was ready'

连字 "fi" 会被还原成普通的 "fi",制表符和连续空格也会折叠成单个空格。这样一来,那些仅仅因为不可见字符不同而有差异的 passage,就会得到完全一致的分词结果。

更有意思的是去重部分。这里我必须选择像 MinHash LSH 这样的近似方法,而不能做两两精确比较。因为精确的 pairwise comparison 是二次复杂度,在语料库规模上根本跑不完;而带有 LSH 索引的 MinHash 则能以近似线性的时间找出近重复内容。

删除这些近重复内容,可以同时服务两个目标。一方面,当我们朝着 10M vectors 的规模推进时,它能让索引更小;另一方面,它还能防止同一段文字的三份拷贝挤满检索结果前列。后者是一种很隐蔽的问题:retriever 会把冗余上下文喂给模型,让模型对单一来源产生过度信任。

class Deduper: """通过基于词 shingles 的 MinHash LSH 去除近重复段落。""" def __init__(self, threshold: float = 0.9, num_perm: int = 64): self.threshold, self.num_perm = threshold, num_perm def fit_transform(self, passages: list[Passage]): lsh = MinHashLSH(threshold=self.threshold, num_perm=self.num_perm) kept, dropped = [], 0 for p in passages: m = self._mh(p.text) if lsh.query(m): dropped += 1 continue lsh.insert(p.id, m) kept.append(p) return kept, {"kept": len(kept), "dropped_near_dup": dropped}
#### OUTPUT ####{ "kept": 19987, "dropped_near_dup": 19, "input": 20007, "after_quality": 20006, "after_dedup": 19987}

去掉 19 个近重复段落和 1 个过短片段后,我们最终保留了 19,987 个 passages。这份语料只是经过筛选的一部分,但清洗流程本身无需改动——无论输入规模是两万个 passages,还是两千万个,跑的都是同一套步骤。

切块与上下文

接下来要把 passages 切成 chunks。最省事的做法是固定长度切块,但这往往也是错误的做法,因为它会把承载实体信息的句子,从用于消歧的上下文里硬生生切开;对多跳问题来说,这几乎是致命的。

因此,我们采用按句子打包的方式:在 token 预算内尽量放入完整句子,并保留少量重叠。同时,token 计数直接使用生成模型自己的 tokenizer,这样预算才与模型实际看到的内容一致。看似只是切块细节,实则是幻觉问题的一个隐藏来源。

如果某个 chunk 超出预算后被悄悄截断,恰好包含答案的那一句就可能直接消失。这样一来,问题会在没有任何真实理由的情况下,看起来像是“无法回答”。所以我宁可遵守句子边界,多付出几个 chunks 的代价,也不愿承担这种风险。

class StructureAwareChunker: def __init__(self, tokenizer, target_tokens: int = 256, overlap: int = 32): self.tok, self.target, self.overlap = tokenizer, target_tokens, overlap def chunk(self, passage: Passage) -> list[Chunk]: sents = split_sentences(passage.text) or [passage.text] chunks, cur, cur_tok = [], [], 0 for s in sents: st = self._ntok(s) if cur and cur_tok + st > self.target: chunks.append(self._make(passage, cur)) cur, cur_tok = ([cur[-1]], self._ntok(cur[-1])) if self.overlap else ([], 0) cur.append(s) cur_tok += st if cur: chunks.append(self._make(passage, cur)) return chunks
#### OUTPUT ####[chunk] 19987 passages -> 21259 chunks (tokens: mean=125 p95=236)

最终我们得到 21,259 个 chunks,平均长度 125 tokens,距离 256 的预算上限还有充足余量。不过,在建立索引之前,还有一个问题必须先解决。

像 “revenue grew 3 percent that quarter” 这样的 chunk,单独拿出来其实是不可检索的,因为“谁的 revenue”以及“哪个 quarter”都丢了。为了解决这个问题,我们在建立索引前,先给每个 chunk 前面补上一句用于定位语境的单行说明。这就是 contextual retrieval 的思路,只不过这句话不是由托管模型生成,而是由我们本地部署的 Qwen3 来写。

CONTEXTUALIZE_PROMPT = ( "下面是一篇标题为 '{title}' 的文档:\n\n\n" "下面是其中的一个分块:\n\n\n" "请用一句简短的单句上下文( "让它即使脱离原文也能被单独检索。只返回这句话。")

这种做法会把每个 chunk 的调用分发到线程池中并行执行,因为这些调用彼此独立,而且 vLLM 会在服务端自动做 batch,所以速度远快于逐个 chunk 串行处理。我们还会把结果做 checkpoint,因此重新运行时可以直接跳过这一步。

class Contextualizer: def contextualize(self, chunks, doc_lookup, workers: int = 32): def _one(c): user = CONTEXTUALIZE_PROMPT.format( title=c.title, doc=doc_lookup.get(c.passage_id, c.text)[:4000], chunk=c.text, ) ctx = self.llm.chat("You write concise retrieval context.", user, max_tokens=64).strip() c.contextual_text = (ctx + "\n" + c.text) if ctx else c.text with ThreadPoolExecutor(max_workers=workers) as ex: list(ex.map(_one, chunks)) return chunks
#### OUTPUT ####Before: Ed Wood is a 1994 American biographical period comedy-drama film directed and produced by Tim Burton, and starring Johnny Depp as cult filmmaker Ed Wood...After (context-prefixed): This chunk introduces the 1994 film *Ed Wood*, directed by Tim Burton, and outlines its main subject and cast. Ed Wood is a 1994 American biographical period comedy-drama film...

多出来的只是一个额外句子:每个 chunk 只需一次很短的生成,成本很低,却能在 chunk 本身语义不够明确时,直接告诉 retriever 这段内容到底在讲什么。召回率之所以能做到这么高,主要就靠这一步。

而召回率,正是整个“幻觉问题”的根基。因为下游的 verifier 只能基于检索阶段真正找到的证据来约束答案;如果证据没被召回,它就无从判断、无从落地。所以,我在这里多买到的每一点 recall,最终都会转化成一个“可以回答”的问题,而不是一个“只能拒答”的问题。

加载检索模型

chunk 准备好之后,就该加载那些把它们变成“可搜索证据”的模型,以及后续用于答案校验的模型了。这里一共有 3 个模型与 generator 共享同一块 GPU,所以每加载一个模型,我们都会记录一次 VRAM 快照,确保始终不超预算。此处先加载 reranker 和 faithfulness judge;embedder 会稍后在构建索引时再加载。

我们不希望在 3 个步骤之后,才以 out-of-memory crash 的形式发现显存超限。因此,每次加载都会同时记录 nvidia-smi 给出的整卡显存占用,以及 torch 给出的当前 kernel 进程显存占用。

def vram_snapshot(tag: str) -> dict: """在每个加载步骤后记录整块 GPU 和当前 kernel 的 VRAM 使用情况。""" kernel = round(torch.cuda.memory_allocated() / 1024**3, 2) used = round(float(_smi("memory.used")[0]) / 1024.0, 2) print(f"[vram] {tag:22} gpu_used={used}GB kernel={kernel}GB") return {"tag": tag, "gpu_used_gb": used, "kernel_gb": kernel}

重排器(reranker)是一个小型因果模型,作为“是 / 否”裁判使用。对每个 query 与 document 配对,我们都会套进固定模板,再直接从下一 token 的 logits 里读取分数,因此对每个候选文档的重排只需要一次 forward pass。之所以加载专用的 cross-encoder reranker,而不是直接相信 embedding 分数,是因为 embedder 会把整段文本压缩成单个向量:这样做扫描整个语料库足够快,但会模糊两类内容之间的差别——一种只是顺带提到了相关实体,另一种则是真正回答了问题。而恰恰是这种区分,决定了错误证据能否被挡在 prompt 之外,最终也挡在答案之外。

class Qwen3Reranker: """根据模型赋给 'yes' token 的概率,为 (query, doc) 对打分。""" @torch.no_grad() def score(self, query: str, docs: list[str], batch_size: int = 16) -> list[float]: out = [] for i in range(0, len(docs), batch_size): batch = [self._fmt(query, d) for d in docs[i:i + batch_size]] enc = self.tok( batch, return_tensors="pt", padding=True, truncation=True, max_length=1024 ).to(self.model.device) logits = self.model(**enc).logits[:, -1, :] # last-token logits yn = logits[:, [self.no_id, self.yes_id]] # compare 'no' against 'yes' probs = torch.softmax(yn.float(), dim=-1)[:, 1] # keep P('yes') out.extend(probs.cpu().tolist()) return out
class Qwen3Reranker: """根据模型赋给 'yes' token 的概率,为 (query, doc) 对打分。""" @torch.no_grad() def score(self, query: str, docs: list[str], batch_size: int = 16) -> list[float]: out = [] for i in range(0, len(docs), batch_size): batch = [self._fmt(query, d) for d in docs[i:i + batch_size]] enc = self.tok( batch, return_tensors="pt", padding=True, truncation=True, max_length=1024 ).to(self.model.device) logits = self.model(**enc).logits[:, -1, :] # last-token logits yn = logits[:, [self.no_id, self.yes_id]] # compare 'no' against 'yes' probs = torch.softmax(yn.float(), dim=-1)[:, 1] # keep P('yes') out.extend(probs.cpu().tolist()) return out

faithfulness judge 直接使用 32B 生成模型本身,并通过 prompt 要求它针对某条 claim 与给定 context 返回一个单一的支持分数。我把本地 32B 设为 judge,是因为 RAG 里的 faithfulness 检查,本质上是在多段长文本上下文中核对一条 claim;而这正是小型 sentence-pair NLI 模型最容易变得脆弱的场景。更重要的是,这个 judge 是整个系统里唯一一个能把“听起来很自信但实际上错误”的回答,硬生生拦成 abstention 的组件。

它是“近乎零幻觉”这一结论的核心,因此我宁愿把手头最强的模型优先用在这里。NLI cross-encoder 和 MiniCheck 仍然接入了系统,作为更轻量的备选方案,但这次运行实际使用的是 LLM judge。

JUDGE_PROMPT = ( "You are a strict fact-checker. Decide whether the CONTEXT supports the CLAIM.\n\n" "CONTEXT:\n{context}\n\nCLAIM: {claim}\n\n" "Output ONLY a number: 1.0 if the context clearly states or entails the claim, " "0.0 if it contradicts or does not mention it, or a value in between.")class JudgeVerifier: def _score(self, claim: str, context: str) -> float: out = self.llm.chat( "You are a strict faithfulness grader.", JUDGE_PROMPT.format(context=context[:6000], claim=claim), max_tokens=8 ) m = re.search(r"01?", out) return min(1.0, float(m.group())) if m else 0.0#### OUTPUT ####[vram] reranker gpu_used=54.3GB kernel=7.49GB[verifier] using the local LLM as faithfulness judge[vram] whole-GPU used=54.3GB / 80.0GB (need >= 3.0GB headroom)
JUDGE_PROMPT = ( "You are a strict fact-checker. Decide whether the CONTEXT supports the CLAIM.\n\n" "CONTEXT:\n{context}\n\nCLAIM: {claim}\n\n" "Output ONLY a number: 1.0 if the context clearly states or entails the claim, " "0.0 if it contradicts or does not mention it, or a value in between.")class JudgeVerifier: def…
— 以上为试看内容(约 40%),开通会员后阅读全文 —

原文出处:https://www.53ai.com/news/RAG/2026071058673.html