Agent开发 07|RAG:如何找到并用好企业知识?

0 阅读23分钟

Agent开发 07|RAG:如何找到并用好企业知识?

《Agent开发》系列 · 第 07 篇

用户问:“订单 1001 付款成功了,金币还没到账,可以直接再发一次吗?”

订单接口能告诉我们支付是否有效、发放记录是什么,却不一定能解释公司的处理规则。规则可能写在内部文档里:发放超时不代表最终失败,必须查询账务结果,符合补发条件后还需要审批。

如果只把问题交给大模型,它可能根据一般经验回答。可我们需要的是符合当前业务制度、适用于这类订单、能够追溯来源的回答。

最直接的办法,是先找到相关业务文档,把必要片段交给模型,再让它结合查询结果作答。这个过程叫 RAG(Retrieval-Augmented Generation,检索增强生成)。

本篇先讲清这条链路,再逐步解释 Chunking、Embedding、BM25、Hybrid Search 和 Re-ranking。我们还会运行一个标准库示例,观察检索、融合、引用与指标计算;没有接入真实模型的部分会明确标出。

一、RAG 怎样参与订单助手的工作?

1.1 先找到依据,再组织回答

用户提出问题
    ↓
后端查询订单与发放状态
    ↓
后端检索“发放超时如何处理”等相关知识
    ↓
把业务查询结果、文档片段及来源交给模型
    ↓
模型依据这些信息组织解释或提出下一步工具请求
    ↓
后端返回回答,后续操作继续接受独立校验

这里有两种不同的信息来源:业务接口回答“订单现在怎么样”,知识文档回答“遇到这种情况应该怎样处理”。知识库里写着“超时后核对账务”,不等于订单 1001 已经核对完了。

RAG 也不等于给模型重新训练。常见做法是在调用时补充信息,模型参数并没有因此被更新。文档可以变化,但索引是否及时更新,仍然需要工程机制保证。

1.2 什么时候值得做 RAG?

适合检索的内容通常包括业务制度、操作手册、产品说明、常见故障和内部技术资料。它们数量较多、会更新,而且回答需要来源依据。

如果问题只需查一张订单,直接调用订单接口通常更合适。如果只有几条稳定规则,放入受版本管理的配置或指令中可能更简单。RAG 不是每个 Agent 都必须经过的步骤,也不能替代权限、实时查询和业务规则执行。

二、先把文档变成可以检索的资料

2.1 文档解析:拿到的文字要保持原意

企业资料可能来自 Markdown、网页、PDF、扫描图片和表格。索引之前,需要提取内容,并保留标题、段落、页码、表格关系等结构。

例如,一张表写着“发放超时 → 核对最终结果”,解析后如果把条件与处理方式分开,模型可能把另一行的动作接上来。文本能提取出来,不代表语义结构就正确。

每份资料还需要元数据:来源、文档版本、生效范围、更新时间、租户和访问权限。没有这些字段,后面就难以区分旧规则、其他客户的内部文档和当前允许使用的依据。

2.2 Chunking:为什么要切成片段?

一本操作手册可能有几十页,但这次问题只需要“发放超时处理”的两段。把整本手册交给模型,会增加长度,也容易混入无关内容。

Chunking(切块)就是将文档拆成可以独立检索的片段。一个 Chunk 至少应保留正文以及它来自哪里。例如:

片段 ID:grant:1
文档:发放超时处理
版本:2
内容:GRANT_TIMEOUT 表示发放请求超时,不能仅凭超时确认未到账。
      应按原操作编号核对最终账务记录。

切得过小,会把条件、例外和处理动作拆开;切得过大,容易让大量无关内容参与匹配。可以优先按章节和完整段落切分,必要时加入相邻片段或上级标题,而不是先寻找一个适用于所有文档的固定长度。

Overlap(重叠)会让相邻片段共享部分文字,减少边界丢失,但也会制造重复结果和额外存储。重叠大小应通过实际问题检验,不能认为越多越好。

2.3 建索引与回答问题是两条流程

资料准备时
    文档 → 解析 → 切块 → 权限与版本元数据 → 建立检索索引

用户提问时
    问题 → 限定可访问资料 → 检索候选片段 → 排序与选择 → 交给模型

文档修改后,索引中的旧片段也需要更新或失效。只新增新版本而保留旧版本参与检索,会让互相矛盾的规则同时进入上下文。

三、Embedding:用户和文档用词不同,怎样找到相关内容?

3.1 关键词不一样,需求可能是同一个

用户说“钱扣了,余额没变”,文档写的是“支付成功但金币未到账”。如果只比较完全相同的词,可能漏掉有用片段。

Embedding(嵌入)模型把文本转换成一组数值,也就是向量。检索时分别得到问题向量和文档片段向量,再用相似度比较,寻找表达相关含义的内容。

建索引:文档片段 → Embedding 模型 → 向量与片段标识
查询时:用户问题 → 兼容的查询编码方式 → 问题向量
                                   ↓
                          在文档向量中寻找近邻

通常文档向量可以预先计算,查询向量在用户提问时计算。问题和文档必须采用兼容的编码模型、版本与检索约定,不能把不同模型产生的向量直接混在一起比较。

3.2 相近不等于正确

相似度用于排序,不是答案正确率。“可以补发”和“禁止补发”可能包含相似语义主题,向量接近不能替代对具体条件和否定词的理解。

余弦相似度比较向量方向,点积或距离也可用于检索,选择要符合模型的训练与使用方式。无论分数多高,都不能直接把它当成“有 90% 的概率允许补发”。

真实 Embedding 的每一维通常没有可直接命名的业务含义。本篇代码用“支付、金币、超时”等手工维度演示向量比较,只是可解释的教学替身,不是训练得到的语义 Embedding。

3.3 向量数据库解决存储与查找问题

片段少时,可以在内存中计算相似度;规模大时,需要向量索引帮助高效寻找近邻,也需要元数据过滤、更新和删除能力。

向量数据库不负责替我们判断哪份制度有权威性。索引是否漏召回、权限过滤是否正确、文档版本是否一致,仍然要单独验证。近似近邻搜索以效率换取一定的召回损失,参数也应结合数据规模与效果测试。

四、BM25:有了语义检索,为什么还要关键词?

当用户给出 GRANT_TIMEOUT 这样的错误码时,我们首先希望找到明确包含这个代码的文档。语义相近但讨论另一个错误码的页面,可能不是所需依据。

BM25 是一种基于词项匹配的排序方法。它综合考虑词在当前文档中出现的次数、在整个集合中的稀有程度,以及文档长度。重复出现同一个词的收益会逐渐饱和,避免单纯堆词就获得无限高分。Lucene BM25 说明

通俗理解:一个很少见的错误码,恰好出现在某段说明里,往往比“订单”“处理”这类常见词更有区分度。

BM25 也有边界。用户和文档完全没有共享词项时,它很难仅凭词项匹配识别同义表达;中文分词、别名、大小写及错误码处理也会影响结果。

因此,词项检索与向量检索各有价值。先看问题类型与数据,再判断是否同时使用,而不是按“传统算法”和“新模型”决定谁应该被淘汰。

五、Hybrid Search 与 Re-ranking:多路结果怎样一起用?

5.1 Hybrid Search:让不同检索方式提供候选

Hybrid Search(混合检索)通常把词项检索和向量检索等方式组合起来。例如 BM25 找到精确错误码,向量检索找到不同表达的相关处理说明。

但两路分数未必在同一个尺度上。一个 BM25 分数是 7,余弦相似度是 0.8,直接相加没有天然可比性。

一种简单融合方法是 RRF(Reciprocal Rank Fusion,倒数排名融合):不直接比较原始分数,而是根据片段在各路结果中的名次累加贡献。

某片段的融合分数 = 各路结果中 1 / (c + 名次) 的总和

名次从 1 开始;未出现在某一路时,该路不贡献分数。c 是平滑常数,控制头部和后部名次的差异。候选池大小、融合参数和最终保留数量仍应通过业务评测选择。Elasticsearch RRF 文档

5.2 Re-ranking:对少量候选再仔细判断

检索面对整个资料库,通常优先考虑速度和召回。拿到候选之后,可以针对“问题与每个片段是否真正相关”再次打分,这叫 Re-ranking(重排)。

一种常见方案是 Cross-Encoder:把问题和片段一起输入模型,评估两者的相关性。与分别编码的检索方式相比,它能更细致地比较内容,但逐对计算更昂贵,所以通常用于较小的候选集合。Sentence Transformers 检索与重排文档

全量资料
    ↓ BM25 与向量检索
候选集合
    ↓ 融合、去重
较小候选集合
    ↓ 重排
最终证据片段

重排只能调整交给它的候选。正确文档根本没被召回,它无法凭空找回来。RRF 主要组合已有名次,学习型重排器则重新读取问题与内容,二者不是同一个步骤。

5.3 候选数量与最终数量不要混淆

检索先取多少条、融合后保留多少条、重排后交给模型多少条,可能是三个不同的数字。

候选太少会漏掉答案;最终片段太多可能造成上下文冗余。还要去除高度重复内容,保留条件与例外的完整性。把 Top K 从 3 改成 30,并不保证回答一定改善。

六、找到片段后,怎样用来回答?

6.1 引用应能定位到具体证据

给模型的资料不应只有匿名文本,还需要片段标识、文档名称、版本,以及必要时的页码或链接。

回答可以解释“发放超时不能直接判断为未到账,需要按原操作编号核对最终账务记录”,并引用 grant:1。后端再把标识映射到实际可访问的文档位置。

引用 ID 存在,只能证明引用目标存在;还要检查原文是否真的支持这句话。模型可能引用了正确文档,却写出文档没有给出的结论。

6.2 没有足够依据时,应保留不确定性

如果资料只解释一般流程,却没有订单 1001 的最终状态,回答应说明还需要查询,不能从制度文档推断这张订单一定未到账。

如果检索结果不足,可以补充关键词、查询其他授权来源、请用户澄清或转人工。不要因为搜索总会返回最相近的几条,就把它们当成充分证据。

检索结果也可能包含恶意指令。外部文档属于数据,不应获得改变系统规则或业务权限的能力。是否允许发放金币,最终仍由工具执行与业务系统校验。

七、怎样评估检索质量?

7.1 先标注什么资料对这个问题有用

准备一组代表性问题,标注相关片段及相关性等级,并固定语料版本。否则不同实验使用的文档不同,指标就不容易比较。

本例用片段作为评估单位。真实项目也可以用文档,但不能一边按片段排名,一边用不一致的文档标注计算。未标注不一定真不相关;标注不完整会影响指标解释。

7.2 Recall@K:需要的资料找全了吗?

假设一个问题有两个相关片段 a、b。前 3 条只找到 a,那么 Recall@3 为 1/2。

Recall@K = 前 K 条中命中的相关片段数 / 已标注的全部相关片段数

它强调覆盖,但不区分相关片段排在第一还是第三。

7.3 MRR:第一个有用结果出现得够早吗?

某问题第一个相关片段排第 2,倒数排名 RR 为 1/2;排第 1 则为 1。在一组问题上对 RR 求平均,得到 MRR。

如果只检查前 K 条,应明确写成截断的 MRR@K:前 K 条没有相关结果,该问题记 0。它关注第一个命中,不反映后面是否漏掉其他必要资料。

7.4 nDCG:最重要的依据是否排在前面?

有些片段直接回答问题,另一些仅提供背景。nDCG 允许给它们不同相关性等级,并对靠后的结果折减收益,再与理想顺序比较。

本篇采用常见形式:

DCG@K = Σ (2^相关性等级 - 1) / log2(名次 + 1)
nDCG@K = DCG@K / 理想排序的 DCG@K

这是本文选定的计算约定;使用其他工具时需核对增益函数和无相关结果的处理方式。不同排序指标的目的和取舍,可参考信息检索教材。Introduction to Information Retrieval

例如,a 的等级为 3,b 为 1,实际排名是 [x, a, b],其中 x 不相关,则:

指标结果含义
Recall@31.0两个相关片段都找到了
RR@30.5第一个相关片段排第二
nDCG@3约 0.6443找齐了,但重要资料排序不理想

无答案问题没有相关片段,不能照常除以零。应单独评估拒答与错误引用等行为,并明确它们是否纳入某个聚合指标。

八、代码实践:运行检索、融合、重排和指标

8.1 哪些是真实计算,哪些是教学替身?

完整代码见附录,配套文件为 demo/07-rag/rag_demo.py,仅使用 Python 标准库。

部分本例实现
文档与切块内置教学制度,按完整段落切块
权限与版本按传入租户和 active 标记过滤
BM25实际计算词频、文档频率和长度归一化
向量一路手工关键词特征及余弦相似度,不是学习型 Embedding
融合实际 RRF 计算
重排错误码精确匹配优先的规则,不是 Cross-Encoder
回答输出原文片段与引用,不调用 LLM 生成
指标实际计算 Recall、RR 和 nDCG 的手算例

这种取舍让我们先看清各阶段输入输出。替换为真实模型后,语义检索与回答效果需要重新评测,不能沿用本例作为效果证明。

8.2 运行与观察

将附录保存为 rag_demo.py,在文件所在目录运行:

python3 rag_demo.py
python3 rag_demo.py "扣费了但是余额没变怎么办"
python3 rag_demo.py "火星天气预报"

默认问题为 GRANT_TIMEOUT 后能直接补发吗?,输出各路片段顺序、最终原文证据及指标手算结果。

默认结果的前几行是:

bm25 ['grant:1', 'approval:1', 'refund:1', 'grant:2']
toy_vector ['grant:1']
fused ['grant:1', 'approval:1', 'refund:1', 'grant:2']

精确错误码帮助 grant:1 排在前面。但第三条混入了退款说明,说明词项重叠并不等于片段适合回答当前问题。规则重排只处理错误码匹配,没有能力全面判断答案支持度。

可以把它当成失败样本:先检查召回是否包含更合适的 grant:2,再比较候选数量和重排策略,而不是马上换一个更大的生成模型。

“火星天气预报”没有匹配到证据,代码输出需要补充问题或人工核对的提示。现实中无关问题也可能匹配到一些词,因此仅检查结果是否为空,不足以判断证据是否充分。

8.3 两处关键实现

权限与版本过滤发生在两路检索之前:

if doc["tenant"] != tenant or not doc["active"]:
    continue

本例租户是函数参数,默认 a,不是认证系统。生产中必须从可信登录身份取得租户,不能允许模型或用户任意改成 b 访问其他资料。

RRF 使用名次而非原始分数:

scores[chunk_id] += 1 / (constant + rank)

融合后的候选再交给规则重排,最终选取 K 条。每个片段保留来源和版本,输出引用来自这些字段,不由模型编造。

8.4 如何替换成真实 Embedding?

先选定兼容的文档和查询编码方式,对当前有效、授权的片段建立向量索引。保存模型版本、切块版本与文档版本。查询时编码问题,使用相同的向量空间检索,再保留原来的候选接口与引用信息。

更换模型可能需要重建全部文档向量;只换查询模型而不更新旧索引,结果未必有意义。向量检索与 BM25 的结果需要按片段 ID 去重,再融合与重排。

本篇没有提供未经运行的真实模型接入代码。配套单元测试检查公式、引用回溯、权限范围、旧文档排除、无结果与指标边界;真实模型下载、质量和资源消耗属于后续接入验证。

在配套目录运行测试:

python3 -m unittest -v test_rag_demo.py

九、答错了,先定位是哪一段出问题

观察到的现象优先检查
原始文件有内容,索引没有解析是否丢段、切块是否遗漏、索引是否更新
文档存在但没召回问法、分词、Embedding、过滤条件、候选数
候选里有正确片段,最终被挤掉融合、重排、去重和最终 K
正确片段已交给模型,回答仍错指令、上下文组织、冲突信息和生成行为
回答引用正确 ID,但原文不支持引用与具体结论的一致性
答案符合旧政策版本、失效标记和更新链路

不要把所有问题都叫“模型幻觉”。检索失败与生成失败的修复方向不同:没有提供正确材料,就应先修检索;材料正确仍推断过度,再检查生成。

十、PDF、图片和表格怎么办?

多模态文档首先仍是信息保真问题。文本 PDF 可以解析文字和结构,扫描件可能需要 OCR(光学字符识别),图表则可能需要图像理解或结构化提取。

文档 → 提取页面、文字、图片与表格
     → 保留页码、坐标、标题与单位
     → 分别建立适合的文本或多模态索引
     → 检索证据及原始位置
     → 必要时把原图或表格一起交给支持的模型

例如“金额”和“金币数量”在不同列,解析时不能丢掉表头和单位。OCR 将 500 识别成 5000,后续语义检索再好也无法自动弥补源数据错误。

选择文本化、图像检索或两者组合,需要根据资料类型验证。并不是接入一个多模态模型,就可以省略解析质量、权限、来源和引用检查。

十一、面试与自查

Q:RAG 为什么同时需要检索和生成?

检索负责从可访问的资料中找到相关证据,生成负责结合问题、证据与业务信息组织回答。检索正确不保证回答正确,生成模型也不能弥补根本没有提供的事实。

Q:有 Embedding,为什么还保留 BM25?

Embedding 有助于处理不同表述的语义关系,BM25 对错误码、产品名等明确词项很有价值。是否混合、怎样融合,应由代表性问题的检索和任务评测决定。

Q:重排能解决所有召回问题吗?

不能。它只能比较候选集中的片段,正确资料没进入候选时,应先检查解析、索引和召回链路。

试着回答:

  1. Top 3 中有两个重复片段和一条旧政策,增加 K 一定能解决问题吗?
  2. 文档说“超时后核对账务”,能否据此判断订单 1001 未到账?
  3. Recall@3 等于 1,是否足以说明最终回答可靠?

参考思路:需要先检查去重和版本,而不是只增加数量;制度不是订单事实;找齐资料不保证排序、理解、引用和执行正确。

十二、总结

RAG 的价值来自一条完整的信息链:文档解析正确,片段保留含义,检索覆盖需要的依据,排序挑出适用内容,回答能够回溯来源,权限与版本控制贯穿其中。

Embedding、BM25、融合和重排都是为这条链服务的。选择它们时,先问当前失败发生在哪一步,再决定增加什么机制。

参考资料

附录:完整可运行代码

文件名:rag_demo.py,与配套文件一致。

"""RAG 教学:真实词项 BM25 + 手工特征向量 + RRF + 规则重排。

无模型、无学习型 Embedding、无真实 LLM 生成;只输出检索片段与引用。
"""
import argparse
import math
import re
from collections import Counter

DOCUMENTS = [
    {"id": "grant", "tenant": "a", "version": 2, "active": True,
     "title": "发放超时处理", "text":
     "GRANT_TIMEOUT 表示发放请求超时,不能仅凭超时确认未到账。应按原操作编号核对最终账务记录。\n\n"
     "支付成功但金币未到账时,先核对支付与最终发放状态。符合补发条件后创建审批申请,批准不等于实际入账。"},
    {"id": "approval", "tenant": "a", "version": 1, "active": True,
     "title": "补发审批", "text":
     "补发申请必须绑定订单、目标用户与金币数量。执行前重新核验批准范围和当前业务状态。"},
    {"id": "refund", "tenant": "a", "version": 1, "active": True,
     "title": "退款说明", "text": "退款应核验渠道交易与当前订单状态,退款不等于金币补发。"},
    {"id": "old", "tenant": "a", "version": 1, "active": False,
     "title": "废止的超时说明", "text": "GRANT_TIMEOUT 后立即重新发放金币。"},
    {"id": "private", "tenant": "b", "version": 1, "active": True,
     "title": "其他租户内部记录", "text": "GRANT_TIMEOUT 租户 b 内部敏感处理记录。"},
]


def chunks_for(tenant):
    chunks = []
    for doc in DOCUMENTS:
        if doc["tenant"] != tenant or not doc["active"]:
            continue
        for i, paragraph in enumerate(doc["text"].split("\n\n"), 1):
            chunks.append({
                "id": f"{doc['id']}:{i}", "text": paragraph, "title": doc["title"],
                "source": doc["id"], "version": doc["version"], "tenant": tenant,
            })
    return chunks


def tokens(text):
    """英文代码完整保留;中文采用相邻双字,不是生产分词器。"""
    result = re.findall(r"[a-z0-9_]+", text.lower())
    for segment in re.findall(r"[\u4e00-\u9fff]+", text):
        result.extend(segment[i:i + 2] for i in range(max(1, len(segment) - 1)))
    return result


def bm25(query, chunks, k1=1.2, b=0.75):
    if not chunks:
        return []
    documents = [tokens(c["title"] + " " + c["text"]) for c in chunks]
    avg_length = sum(map(len, documents)) / len(documents)
    if not avg_length:
        return []
    df = Counter(term for doc in documents for term in set(doc))
    scores = []
    for chunk, doc in zip(chunks, documents):
        tf = Counter(doc)
        score = 0.0
        for term in set(tokens(query)):
            frequency = tf[term]
            if not frequency:
                continue
            idf = math.log(1 + (len(documents) - df[term] + 0.5) / (df[term] + 0.5))
            denominator = frequency + k1 * (1 - b + b * len(doc) / avg_length)
            score += idf * frequency * (k1 + 1) / denominator
        if score > 0:
            scores.append((chunk["id"], score))
    return sorted(scores, key=lambda x: (-x[1], x[0]))


FEATURES = [
    ("支付", "扣费", "付款"),
    ("金币", "余额", "到账", "发放"),
    ("超时", "grant_timeout"),
    ("审批", "批准", "授权"),
    ("退款", "退钱"),
]


def toy_vector(text):
    text = text.lower()
    return [float(any(word in text for word in group)) for group in FEATURES]


def cosine(a, b):
    norm = math.sqrt(sum(x*x for x in a) * sum(y*y for y in b))
    return sum(x*y for x, y in zip(a, b)) / norm if norm else 0.0


def toy_retrieve(query, chunks):
    scores = [(c["id"], cosine(toy_vector(query), toy_vector(c["text"]))) for c in chunks]
    return sorted((x for x in scores if x[1] > 0), key=lambda x: (-x[1], x[0]))


def rrf(rankings, constant=60):
    if constant < 0:
        raise ValueError("constant 不能为负数")
    scores = Counter()
    for ranking in rankings:
        seen = set()
        for rank, (chunk_id, _) in enumerate(ranking, 1):
            if chunk_id in seen:
                raise ValueError("单路结果不能包含重复片段")
            seen.add(chunk_id)
            scores[chunk_id] += 1 / (constant + rank)
    return sorted(scores.items(), key=lambda x: (-x[1], x[0]))


def rule_rerank(query, ranking, chunks):
    """只演示错误码精确匹配优先;不是 Cross-Encoder。"""
    codes = set(re.findall(r"\b[A-Z]+_[A-Z_]+\b", query))
    by_id = {c["id"]: c for c in chunks}
    return sorted(ranking, key=lambda item: -sum(code in by_id[item[0]]["text"] for code in codes))


def retrieve(query, tenant="a", k=3, pool=4):
    if type(k) is not int or k <= 0 or type(pool) is not int or pool < k:
        raise ValueError("要求 0 < k <= pool,且为整数")
    chunks = chunks_for(tenant)
    lexical = bm25(query, chunks)[:pool]
    vector = toy_retrieve(query, chunks)[:pool]
    fused = rrf([lexical, vector])[:pool]
    ranked = rule_rerank(query, fused, chunks)[:k]
    by_id = {c["id"]: c for c in chunks}
    return {"bm25": lexical, "toy_vector": vector, "fused": fused,
            "evidence": [by_id[key] for key, _ in ranked]}


def metrics(ranking, relevance, k):
    if type(k) is not int or k <= 0:
        raise ValueError("k 必须是正整数")
    if len(set(ranking)) != len(ranking):
        raise ValueError("排名中不能有重复片段")
    if any(grade < 0 for grade in relevance.values()):
        raise ValueError("相关性等级不能为负数")
    relevant = {key for key, grade in relevance.items() if grade > 0}
    if not relevant:
        raise ValueError("本例指标要求至少一个相关片段;无答案问题单独评测")
    top = ranking[:k]
    recall = len(set(top) & relevant) / len(relevant)
    rr = next((1 / rank for rank, key in enumerate(top, 1) if key in relevant), 0.0)
    dcg = sum((2**relevance.get(key, 0)-1) / math.log2(rank+1) for rank, key in enumerate(top, 1))
    ideal = sorted(relevance.values(), reverse=True)[:k]
    idcg = sum((2**grade-1) / math.log2(rank+1) for rank, grade in enumerate(ideal, 1))
    return {"recall@k": recall, "rr@k": rr, "ndcg@k": dcg/idcg}


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("query", nargs="?", default="GRANT_TIMEOUT 后能直接补发吗?")
    args = parser.parse_args()
    result = retrieve(args.query)
    for key in ("bm25", "toy_vector", "fused"):
        print(key, [chunk_id for chunk_id, _ in result[key]])
    print("以下仅是检索证据,不是模型生成的答案:")
    for chunk in result["evidence"]:
        print(f"[{chunk['id']} v{chunk['version']}] {chunk['title']}:{chunk['text']}")
    if not result["evidence"]:
        print("未找到证据,请补充问题或转交人工核对。")
    # 独立的手算例,避免把教学语料上的排名冒充业务质量。
    print("指标手算例:", metrics(["x", "a", "b"], {"a": 3, "b": 1}, 3))


if __name__ == "__main__":
    main()

建议亲自改一次查询:先用明确错误码,再改成用户的口语表达,比较每一路候选及最终片段。先看见系统为什么找对或找错,再谈算法组合,理解会更扎实。

检索已有了可观察的结果,下一步需要判断一次修改究竟改善了什么、又损害了什么。下一篇:Agent开发 08|LLM Eval:怎么验证 Agent 的效果? 我们将建立可重复的样本与评价规则,让“感觉变好了”变成有证据的比较。