跳到主内容
快讯直播
AI智模界
教程

用 StitchRAG 搭证据保持的 RAG 上下文:分块、扩散拼接与引用核验

做过 RAG 的人大多踩过同一个坑:检索回来 8 个片段,每个都“看起来相关”,拼进上下文之后模型答得挺顺,可你回头核对时发现——结论来自第 3 段的半句话,而那句话离开了第 2 段的限定条件,意思刚好反了。上下文越长,这种断章取义越容易发生,token 也烧得越多。

这篇教程搭一条“证据保持”的流水线:把文档切成带坐标的块,检索时从种子块向外扩散拼接成连续的证据段,生成时强制模型按证据编号引用,最后用一个核验器逐句回查引用是否成立。这里把 StitchRAG 当成这套“分块—扩散拼接—引用核验”的设计模式来落地实现,组件全部用通用开源件与标准 HTTP 接口,可以按你的技术栈替换;涉及具体项目版本的地方,以官方文档当前版本为准。

这篇能做出什么

跑完整条流水线,你会得到:

1. 一套带坐标的分块:每个块都有 doc_id、章节路径、字符起止偏移、文档内顺序号。任何一句引用都能回到原文的确定位置。

2. 更短但更完整的上下文:对比“直接取 Top-K”,拼接后的上下文通常能明显减少 token,同时保留被检索块中间被跳过的桥接内容。

3. 可核验的引用:答案里出现 [E1] [E2],程序逐句检查每个引用编号对应的证据段是否真的支撑该句;不支撑就剔除或触发拒答,而不是让幻觉混过去。

4. 一份离线评测脚本:量化“引用支撑率”“上下文 token 数”“拒答率”三个指标。

一个具体例子:问“退款到账时间是多久”。朴素 Top-K 检索命中三段:A 说“审核通过后 7 个工作日”、B 说“银行处理需 1–3 个工作日”、C 说“跨境订单不适用上述时效”。如果只取 A 和 C,模型会说“7 个工作日,但跨境不适用”,漏掉 B 的累加关系;如果只取 A 和 B,就会漏掉 C 的排除条件。扩散拼接的做法是:把 A 选为种子后,检查它在原文中的相邻块 B,发现 B 与 A 共享实体“到账时间”,于是把 B 和 A 合并成一段连续证据 E1;C 因为在同一章节且和 A 共享“7 个工作日”这个关键短语,作为跨位置证据被补进来成为 E2。最后给模型的不是三段散装文本,而是两段带编号、语义完整的证据。

前置条件清单

动手前确认这些:

  • Python 3.x 环境,能用 pip 装包。
  • 一个文本嵌入服务:任何提供 OpenAI 兼容 /embeddings 接口的服务都行(自建或云服务)。如果没有,本文提供了一个纯本地哈希向量的降级实现,可以先跑通链路再换。
  • 一个对话模型接口:同样按 OpenAI 兼容 /chat/completions 调用。请把 base_url、api_key、模型名放在环境变量里,具体模型名以你所使用平台的官方文档当前版本为准。
  • 一份测试语料:10–50 篇 Markdown 或纯文本文档即可,最好包含“条件、例外、时效”这类容易断章取义的内容,效果差异才看得出来。
  • 基础依赖:requests、numpy。这两样足够跑通全流程;向量库、分词器、重排模型都属于可选增强。

目录结构建议这样:

```text

stitchrag/

chunking.py # 分块

index.py # 嵌入与索引

retrieve.py # 混合召回

stitch.py # 扩散拼接

generate.py # 带编号生成

verify.py # 引用核验

pipeline.py # 串起来

data/

raw/ # 原始文档

index/ # 块与向量

```

步骤一:带坐标的结构化分块

分块的目标不是“切得均匀”,而是“切完之后还能拼回去”。所以每个块必须记下自己在原文中的位置和顺序。

```python

stitchrag/chunking.py

import re, hashlib, json

from dataclasses import dataclass, asdict

HEADING_RE = re.compile(r"^(#{1,6})\s+(.*)$", re.M)

SENT_SPLIT = re.compile(r"(?<=[。!?!?;;])|(?<=\n)")

@dataclass

class Chunk:

chunk_id: str

doc_id: str

section: str # 章节路径,如 "售后政策 > 退款"

order: int # 文档内全局顺序,拼接时靠它判断相邻

start: int # 字符偏移

end: int

text: str

def _sections(raw: str):

"""按标题切章节,返回 [(section_path, start, end)]"""

marks = [(m.start(), len(m.group(1)), m.group(2).strip())

for m in HEADING_RE.finditer(raw)]

if not marks:

return [("", 0, len(raw))]

out, stack = [], []

for i, (pos, level, title) in enumerate(marks):

stack = [(lv, t) for lv, t in stack if lv < level]

stack.append((level, title))

end = marks[i + 1][0] if i + 1 < len(marks) else len(raw)

out.append((" > ".join(t for _, t in stack), pos, end))

return out

def _pack(sentences, head, target, overlap):

"""把句子打包成 target 长度左右的块,块间保留 overlap 个字符的重叠"""

chunks, buf, buf_start = [], [], 0

cursor = head

for sent in sentences:

if not buf:

buf_start = cursor

buf.append(sent)

cursor += len(sent)

if sum(len(s) for s in buf) >= target:

text = "".join(buf)

chunks.append((buf_start, buf_start + len(text), text))

回退 overlap:从下一块开头重复尾部内容

keep, kept = [], 0

for s in reversed(buf):

if kept + len(s) > overlap:

break

keep.insert(0, s)

kept += len(s)

buf = keep

buf_start = cursor - kept

if buf:

text = "".join(buf)

chunks.append((buf_start, buf_start + len(text), text))

return chunks

def split_doc(doc_id: str, raw: str, target: int = 400, overlap: int = 80):

chunks, order = [], 0

for section, s, e in _sections(raw):

body = raw[s:e]

sentences = [x for x in SENT_SPLIT.split(body) if x and x.strip()]

for start, end, text in _pack(sentences, s, target, overlap):

cid = hashlib.sha1(f"{doc_id}:{start}:{end}".encode()).hexdigest()[:12]

chunks.append(Chunk(cid, doc_id, section, order, start, end, text))

order += 1

return chunks

def build_corpus(raw_dir: str, out_path: str, target: int = 400, overlap: int = 80):

import pathlib

all_chunks = []

for p in sorted(pathlib.Path(raw_dir).glob("**/*")):

if p.suffix.lower() not in {".md", ".txt"}:

continue

doc_id = str(p.relative_to(raw_dir))

for c in split_doc(doc_id, p.read_text(encoding="utf-8"), target, overlap):

all_chunks.append(asdict(c))

with open(out_path, "w", encoding="utf-8") as f:

for c in all_chunks:

f.write(json.dumps(c, ensure_ascii=False) + "\n")

print(f"生成 {len(all_chunks)} 个块 -> {out_path}")

return all_chunks

```

order 字段是关键:后面判断“块 A 的下一块是谁”“两个块之间还缺不缺内容”,全靠它。

块大小怎么定?target 太小(比如 150 字符)会导致相邻块共享大量上下文、拼接时冗余;太大(比如 1200 字符)会让证据段里混进无关内容,核验时也难定位。文档型语料从 300–500 字符起步比较稳妥,overlap 取 target 的 15%–20%。

步骤二:建索引(向量 + 关键词双路)

先用标准 HTTP 接口调嵌入服务;没有服务时自动降级为本地哈希向量,保证链路能跑通。

```python

stitchrag/index.py

import json, os, hashlib

import numpy as np

import requests

BASE_URL = os.environ.get("LLM_BASE_URL", "").rstrip("/")

API_KEY = os.environ.get("LLM_API_KEY", "")

EMBED_MODEL = os.environ.get("EMBED_MODEL", "")

def _hash_vec(text: str, dim: int = 512) -> np.ndarray:

"""降级方案:字符 bigram 哈希到固定维度,够做冒烟测试"""

v = np.zeros(dim, dtype=np.float32)

for i in range(len(text) - 1):

h = int(hashlib.md5(text[i:i + 2].encode()).hexdigest(), 16)

v[h % dim] += 1.0

n = np.linalg.norm(v)

return v / n if n else v

def embed(texts):

if not (BASE_URL and EMBED_MODEL):

return np.stack([_hash_vec(t) for t in texts])

out = []

for i in range(0, len(texts), 32): # 分批,避免单次请求过大

batch = texts[i:i + 32]

r = requests.post(

f"{BASE_URL}/embeddings",

headers={"Authorization": f"Bearer {API_KEY}"},

json={"model": EMBED_MODEL, "input": batch},

timeout=60,

)

r.raise_for_status()

out.extend([d["embedding"] for d in r.json()["data"]])

m = np.array(out, dtype=np.float32)

return m / np.clip(np.linalg.norm(m, axis=1, keepdims=True), 1e-9, None)

def build_index(chunks_path: str, out_prefix: str):

chunks = [json.loads(line) for line in open(chunks_path, encoding="utf-8")]

mat = embed([c["text"] for c in chunks])

np.save(f"{out_prefix}_vectors.npy", mat)

json.dump([c["chunk_id"] for c in chunks], open(f"{out_prefix}_ids.json", "w"))

print(f"索引就绪:{mat.shape[0]} 条,维度 {mat.shape[1]}")

```

关键词这一路不引入额外依赖,用字符 bigram 的重叠度做一个轻量打分,对中文短查询够用;正式环境可以换成成熟的分词 + BM25 实现,具体用法以对应库的官方文档为准。

步骤三:扩散式证据拼接

这是整条流水线的核心。思路分四段:选种子 → 向邻居扩散 → 补桥接 → 合并成连续证据段。

```python

stitchrag/stitch.py

import json, math

import numpy as np

def load_corpus(chunks_path):

chunks = [json.loads(l) for l in open(chunks_path, encoding="utf-8")]

by_id = {c["chunk_id"]: c for c in chunks}

by_doc = {}

for c in chunks:

by_doc.setdefault(c["doc_id"], []).append(c)

for v in by_doc.values():

v.sort(key=lambda x: x["order"])

return chunks, by_id, by_doc

def _bigrams(s):

return {s[i:i + 2] for i in range(len(s) - 1)}

def _overlap(a, b):

A, B = _bigrams(a), _bigrams(b)

return len(A & B) / (len(A | B) or 1)

def hybrid_recall(query, chunks, vecs, ids, embed, top_k=12, alpha=0.6):

qv = embed([query])[0]

dense = vecs @ qv

sparse = np.array([_overlap(query, c["text"]) for c in chunks], dtype=np.float32)

dn = (dense - dense.min()) / (dense.ptp() or 1.0)

sn = (sparse - sparse.min()) / (sparse.ptp() or 1.0)

score = alpha * dn + (1 - alpha) * sn

order = np.argsort(-score)[:top_k]

return [(ids[i], float(score[i])) for i in order]

def diffuse(seed_scores, by_id, by_doc, query,

radius=1, decay=0.6, coherence_min=0.15, budget_chars=2600):

"""从种子向外扩散,返回按文档顺序排好的证据块列表"""

cand = {} # cid -> (score, source)

for cid, s in seed_scores:

cand[cid] = (s, "seed")

1) 邻居扩散:同文档前后各 radius 块,按距离衰减

for cid, s in list(cand.items()):

c = by_id[cid]

siblings = by_doc[c["doc_id"]]

idx = [x["chunk_id"] for x in siblings].index(cid)

for d in range(1, radius + 1):

for j in (idx - d, idx + d):

if 0 <= j < len(siblings):

nb = siblings[j]

sc = s * (decay ** d) * (0.5 + 0.5 * _overlap(query, nb["text"]))

if sc > cand.get(nb["chunk_id"], (0,))[0]:

cand[nb["chunk_id"]] = (sc, f"neighbor:{d}")

2) 语义凝聚扩散:与任一已选块高度重合的块也纳入候选

for c in sorted(cand.keys()):

base = by_id[c]["text"]

for other in by_doc.get(by_id[c]["doc_id"], []):

if other["chunk_id"] in cand:

continue

coh = _overlap(base, other["text"])

if coh >= coherence_min:

cand[other["chunk_id"]] = (cand[c][0] * coh, "semantic")

3) 补桥接:同文档内两个已选块之间被跳过的块全部补齐,避免断章

picked = set(cand.keys())

for doc, siblings in by_doc.items():

orders = [i for i, x in enumerate(siblings) if x["chunk_id"] in picked]

if len(orders) >= 2:

for i in range(min(orders), max(orders) + 1):

picked.add(siblings[i]["chunk_id"])

4) 预算裁剪:按分数降序取,直到字符预算用尽

ranked = sorted(((cid, cand.get(cid, (0.1, "bridge"))[0]) for cid in picked),

key=lambda x: -x[1])

keep, used = [], 0

for cid, s in ranked:

size = len(by_id[cid]["text"])

if used + size > budget_chars:

continue

keep.append(cid)

used += size

return keep

def merge_blocks(cids, by_id):

"""把同文档连续的块合并成证据段,编号 E1、E2…"""

keep = sorted(cids, key=lambda x: (by_id[x]["doc_id"], by_id[x]["order"]))

blocks, cur = [], None

for cid in keep:

c = by_id[cid]

if cur and cur["doc_id"] == c["doc_id"] and c["order"] == cur["last_order"] + 1:

cur["texts"].append(c["text"])

cur["chunk_ids"].append(cid)

cur["last_order"] = c["order"]

cur["end"] = c["end"]

else:

if cur:

blocks.append(cur)

cur = {"doc_id": c["doc_id"], "section": c["section"],

"chunk_ids": [cid], "texts": [c["text"]],

"start": c["start"], "end": c["end"], "last_order": c["order"]}

if cur:

blocks.append(cur)

for i, b in enumerate(blocks, 1):

b["evidence_id"] = f"E{i}"

b["text"] = "\n".join(b.pop("texts"))

return blocks

```

几个参数值得调:

  • radius:邻居扩散半径。文档条目短的语料可以设 2,长文设 1 就够,否则一次召回会把整章拖进来。
  • decay:距离衰减。0.6 意味着距离 2 的邻居只剩种子 36% 的分数,能有效抑制上下文膨胀。
  • budget_chars:字符预算。这是“上下文更短”的直接闸门,比事后截断可靠得多。
  • coherence_min:语义凝聚阈值。调高会变保守,调低会引入大量弱相关块。

merge_blocks 那一步是“保持证据”的关键:同文档里连续的块重新粘成一整段,模型读到的是完整语义,而不是被切碎的片段。

步骤四:用带编号的证据生成

把证据段渲染成编号文本,并在系统提示里明确约束引用方式。

```python

stitchrag/generate.py

import os, re, requests

BASE_URL = os.environ.get("LLM_BASE_URL", "").rstrip("/")

API_KEY = os.environ.get("LLM_API_KEY", "")

CHAT_MODEL = os.environ.get("CHAT_MODEL", "")

SYSTEM = """你是严谨的资料助手。只能依据给定的证据段回答。

每条结论后必须标注来源编号,格式为 [E1]、[E2];一句话用到多段证据就写 [E1][E3]。

证据段不足以回答时,直接说明缺少什么信息,不要推测。

不要引入证据段之外的常识。"""

def render(blocks):

parts = []

for b in blocks:

parts.append(f"[{b['evidence_id']}] 来源:{b['doc_id']} | 章节:{b['section']}\n{b['text']}")

return "\n\n---\n\n".join(parts)

def answer(question, blocks, temperature=0.2):

payload = {

"model": CHAT_MODEL,

"temperature": temperature,

"messages": [

{"role": "system", "content": SYSTEM},

{"role": "user", "content": f"证据段:\n\n{render(blocks)}\n\n问题:{question}"},

],

}

r = requests.post(f"{BASE_URL}/chat/completions",

headers={"Authorization": f"Bearer {API_KEY}"},

json=payload, timeout=120)

r.raise_for_status()

return r.json()["choices"][0]["message"]["content"]

```

注意提示里写了“证据段不足以回答时直接说明”,这一句能拦住相当一部分硬编答案的情况。温度调低一点,引用行为会更稳定。

步骤五:引用核验

生成完不算完,逐句回查。分两层:先做便宜的字符重合度检查,再把可疑句交给核验模型判定。

```python

stitchrag/verify.py

import re, requests, os

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

SENT_RE = re.compile(r"[^。!?!?\n]+[。!?!?]?")

def _bigrams(s):

return {s[i:i + 2] for i in range(len(s) - 1)}

def overlap(a, b):

A, B = _bigrams(a), _bigrams(b)

return len(A & B) / (len(A) or 1)

def verify(answer_text, blocks, threshold=0.45, judge=False):

by_eid = {b["evidence_id"]: b for b in blocks}

report = []

for sent in SENT_RE.findall(answer_text):

sent = sent.strip()

if len(sent) < 6:

continue

eids = CITE_RE.findall(sent)

bare = CITE_RE.sub("", sent).strip()

if not eids:

report.append({"sentence": sent, "status": "no_citation", "score": 0.0})

continue

missing = [e for e in eids if e not in by_eid]

score = max((overlap(bare, by_eid[e]["text"]) for e in eids if e in by_eid),

default=0.0)

status = "ok"

if missing:

status = "dangling_citation"

elif score < threshold:

status = "weak_support"

report.append({"sentence": sent, "status": status,

"score": round(score, 3), "eids": eids})

return report

def judge_with_model(question, sentence, blocks):

"""把弱支撑句交给模型复核,返回 supported / unsupported"""

ctx = "\n\n".join(f"[{b['evidence_id']}] {b['text']}" for b in blocks)

prompt = (f"证据段:\n{ctx}\n\n待核验句子:{sentence}\n\n"

f"该句的每个事实是否都能在上述证据段中找到依据?"

f"只回答 supported 或 unsupported。")

r = requests.post(

f"{os.environ['LLM_BASE_URL'].rstrip('/')}/chat/completions",

headers={"Authorization": f"Bearer {os.environ.get('LLM_API_KEY','')}"},

json={"model": os.environ.get("CHAT_MODEL", ""), "temperature": 0,

"messages": [{"role": "user", "content": prompt}]},

timeout=60)

r.raise_for_status()

return r.json()["choices"][0]["message"]["content"].strip().lower().startswith("supported")

def enforce(answer_text, report, support_ratio_min=0.7):

bad = {r["sentence"] for r in report if r["status"] in {"no_citation", "weak_support", "dangling_citation"}}

kept = [s for s in SENT_RE.findall(answer_text) if s.strip() not in bad]

total = len([r for r in report]) or 1

ratio = 1 - len(bad) / total

if ratio < support_ratio_min:

return None, ratio # 支撑率过低,走拒答或重检索

return "".join(kept).strip(), ratio

```

status 的三种取值对应三类问题:dangling_citation 是模型编了不存在的编号(比如只有 E1–E3 却引了 E5),no_citation 是整句没有任何来源,weak_support 是引了但内容对不上。前两类直接拦截,第三类才值得花模型调用去复核。

support_ratio_min 是拒答阈值。设太低会放过幻觉,设太高会把正常回答也拦掉。建议先用 0.7 起步,拿测试语料跑一轮看分布再调。

步骤六:串起流水线并记录日志

```python

stitchrag/pipeline.py

import json, time

from .stitch import load_corpus, hybrid_recall, diffuse, merge_blocks

from .generate import answer

from .verify import verify, enforce

class Pipeline:

def __init__(self, chunks_path, vec_path, ids_path):

import numpy as np

self.chunks, self.by_id, self.by_doc = load_corpus(chunks_path)

self.vecs = np.load(vec_path)

self.ids = json.load(open(ids_path))

from .index import embed

self.embed = embed

self.pos = {cid: i for i, cid in enumerate(self.ids)}

def run(self, question, top_k=10, radius=1, budget_chars=2600, log_path="run.jsonl"):

t0 = time.time()

seeds = hybrid_recall(question, self.chunks, self.vecs, self.ids, self.embed, top_k)

picked = diffuse(seeds, self.by_id, self.by_doc, question,

radius=radius, budget_chars=budget_chars)

blocks = merge_blocks(picked, self.by_id)

text = answer(question, blocks)

report = verify(text, blocks)

final, ratio = enforce(text, report)

record = {

"question": question,

"seed_ids": [c for c, _ in seeds],

"evidence": [{"id": b["evidence_id"], "doc": b["doc_id"],

"chunks": b["chunk_ids"], "chars": len(b["text"])} for b in blocks],

"context_chars": sum(len(b["text"]) for b in blocks),

"support_ratio": round(ratio, 3),

"verification": report,

"answer": final,

"elapsed_ms": int((time.time() - t0) * 1000),

}

with open(log_path, "a", encoding="utf-8") as f:

f.write(json.dumps(record, ensure_ascii=False) + "\n")

return record

```

evidence 字段里存了每段证据由哪些 chunk_id 组成。这就是“可回溯”的落点:出问题时拿着 chunk_id 和字符偏移,能直接定位回原文。

步骤七:跑一轮离线评测

不看数字的调参都是猜。写个小脚本,对比“朴素 Top-K”和“扩散拼接”两种上下文策略:

```python

eval.py

import json

from stitchrag.pipeline import Pipeline

from stitchrag.generate import answer

from stitchrag.verify import verify

def naive_blocks(p, question, k=6):

seeds = __import__("stitchrag.stitch", fromlist=["hybrid_recall"]).hybrid_recall(

question, p.chunks, p.vecs, p.ids, p.embed, top_k=k)

cids = [c for c, _ in seeds]

return [{"evidence_id": f"E{i}", "doc_id": p.by_id[c]["doc_id"],

"section": p.by_id[c]["section"], "chunk_ids": [c],

"text": p.by_id[c]["text"]} for i, c in enumerate(cids, 1)]

p = Pipeline("data/index/chunks.jsonl", "data/index/vectors.npy", "data/index/ids.json")

rows = []

for q in [l.strip() for l in open("data/questions.txt", encoding="utf-8") if l.strip()]:

r = p.run(q)

nb = naive_blocks(p, q)

nans = answer(q, nb)

nrep = verify(nans, nb)

rows.append({

"q": q,

"stitch_chars": r["context_chars"],

"naive_chars": sum(len(b["text"]) for b in nb),

"stitch_support": r["support_ratio"],

"naive_unsupported": sum(1 for x in nrep if x["status"] != "ok"),

})

for r in rows:

print(json.dumps(r, ensure_ascii=False))

```

重点看三个数:stitch_chars 是否低于 naive_chars(上下文更短的直接证据)、stitch_support 的分布(引用支撑率)、naive_unsupported(朴素方案里有多少句没有可靠来源)。如果拼接后 token 降了但支撑率也明显掉,说明 budget_chars 卡太紧或者 radius 太小,桥接块没补上。

常见坑与排错

坑一:拼接后上下文反而更长。

多半是 radius 或 coherence_min 设得太宽松,扩散把整章都拉进来了。先看日志里 evidence 的 chars 分布,如果单个证据段动辄上千字符,说明桥接补齐把大段无关内容一起吞了。把 radius 降到 1、coherence_min 提到 0.2 以上再试。

坑二:模型不按 [E1] 格式引用。

两个原因。一是证据段渲染时编号格式不统一(比如正文里也出现了 [E...]),换个不会撞车的编号前缀;二是系统提示里的约束被更靠后的内容冲淡了,把引用要求放到提示末尾再强调一次通常有效。

坑三:dangling_citation 特别多。

说明模型在编编号。检查一下 merge_blocks 的编号是不是连续的——如果证据段被过滤后编号出现空洞(E1、E3、E5),模型容易顺手补成 E2、E4。稳妥的做法是渲染前统一重新编号。

坑四:核验把正确答案判成 weak_support。

字符 bigram 重合度对“换一种说法”很不友好,模型把“7 个工作日”写成“一周左右”时重合度会很低。这时候别急着降阈值,先开 judge_with_model 复核,把判定权交给模型,只对复核也不通过的句子动手。阈值本身按语料调,没有通用值。

坑五:字符偏移对不上。

分块时用的是 Python 字符串下标,如果原文里有 CRLF 或者后续做了文本清洗,偏移就会漂移。建索引和核验要用同一份原文,不要在中间环节改文本。

坑六:检索结果彼此矛盾。

比如两篇文档的退款时效不一致(旧政策没下线)。这种时候不要指望模型自己选。在 render 里给每段证据带上 doc_id 和章节,让模型看到来源差异;顺手在核验步骤记录“同一事实存在多个来源”的情况,回头治理语料。

坑七:降级哈希向量导致召回质量差。

哈希向量只适合跑通链路。真实使用必须接上嵌入服务,否则关键词路和向量路会高度重复,alpha 调参也就失去意义了。

下一步建议

链路跑通之后,按收益从高到低往下做:

1. 换掉轻量打分。把字符 bigram 的关键词路换成成熟的分词 + BM25 实现,向量路接真实嵌入服务,再考虑加一个重排模型对 seed_scores 做二次排序。排序质量提升会直接反映在扩散起点上。

2. 把核验做成闭环。当前是“事后剔除”。更进一步的做法是:核验失败的句子触发一次定向重检索(拿这句话当查询,专门找支撑证据),再让模型重写这一句。这样拒答率会下降,同时不牺牲可信度。

3. 证据段粒度自适应。现在 budget_chars 是全局常量。可以按问题复杂度动态给预算:事实型问题给 1200 字符,比较型、流程型问题给 3000 字符。用问题里的疑问词和实体数量做个简单分类器就够。

4. 索引层持久化。把块、向量、元数据落到正式存储里,支持增量更新和按 doc_id 删除。语料一过百篇,全量重建的耗时就会开始碍事。

5. 把评测变成回归测试。固定一批问题、固定期望的证据段(用 doc_id + 章节标),每次改参数跑一遍,看 support_ratio 和上下文长度的变化。没有回归测试,参数调优很快就会变成凭感觉。

这套流水线的价值不在某个单点技巧,而在于把“上下文”从一段糊在一起的文本,变成一组有编号、有坐标、可回查的证据结构。只要这个结构在,换模型、换向量库、换分块策略,核验那一层都不用动。

AI 生成本文由 AI 基于公开信息自动生成,仅供参考。