如何基于开源大模型搭建RAG问答系统实战教程

作者:热心市民鹿先生2026.11.18 11:22浏览量:0

简介:本文讲解如何基于开源大模型搭建一个最小可用的RAG检索增强问答系统,覆盖文档清洗、分块、向量化、存储、检索、提示词组装与结果验证。读者可按步骤完成从知识文档到精准回答的闭环,降低长文本冗余和模型幻觉,并掌握常见排查与优化方法。

教程目标

本教程要帮助读者完成一个最小可用但结构完整的企业级问答系统雏形:让开源大模型在回答用户问题时,不再只依赖模型自身参数化记忆,而是先检索内部知识库中的相关文档片段,再结合检索结果生成答案。

完成本教程后,你将能够:

  • 理解 RAG 的基本原理:检索增强生成如何通过“先检索、再生成”降低幻觉;
  • 完成知识库文档的加载、清洗、分块、向量化与存储;
  • 搭建一个可运行的问答链路,包括问题向量化、相似度检索、上下文拼接和模型生成;
  • 掌握分块大小、检索数量、相似度阈值、提示词模板等关键配置的调整思路;
  • 学会验证问答效果,并针对检索不准、回答越界、成本过高、响应慢等问题进行排查与优化。

本文示例以一个“开发规范文档问答”场景为背景,演示如何把一份结构化的规范文本转化为可检索、可问答的知识库。你可以将同一套思路迁移到产品手册、运维文档、客服知识、内部制度、技术博客等场景。


适用场景

RAG 适合那些“答案存在于外部资料中,而不是模型预训练知识中”的任务。典型场景包括:

  1. 内部规范问答
    例如开发规范、代码规范、安全规范、发布流程、故障处理手册等。模型需要回答“某项操作是否允许”“某个步骤应该按什么顺序执行”。

  2. 产品文档问答
    用户询问某个功能如何配置、某个接口参数是什么、某个问题如何排查。系统需要基于最新文档回答,而不是依赖模型旧知识。

  3. 运维手册问答
    运维人员询问告警处理、日志排查、扩容步骤、回滚流程等。答案往往分散在多个文档章节中,需要检索后汇总。

  4. 客服知识库问答
    将业务规则、常见问题、售后流程等资料构建为知识库,通过 RAG 提供统一、可控、可追溯的回答。

  5. 企业知识检索辅助
    对内部制度、项目文档、会议材料进行检索问答,帮助员工快速定位相关信息。

RAG 的核心价值在于:把“模型会什么”与“模型能查什么”解耦。模型负责理解和生成,知识库负责提供事实依据。


前置准备

在动手搭建之前,建议先准备以下内容。

1. 一份可用的知识文档

你需要准备一份纯文本或可转为纯文本的文档。文档可以是制度、手册、规范、FAQ、产品说明等。

示例文档应具有这些特征:

  • 内容相对集中,围绕一个主题;
  • 有明确的条目、章节或编号;
  • 文本质量较高,没有大量乱码、无关页眉页脚;
  • 最好存在自然分割标记,例如编号、标题、方括号标记、列表项等。

如果没有结构化文档,也可以先做简单的文本清洗和分段,但效果通常不如结构化文档稳定。

2. 一个可用的开源大模型推理接口

你需要一个可以调用的大模型服务或本地推理服务。该服务需要满足:

  • 能接受自然语言提示词;
  • 能返回文本生成结果;
  • 支持控制生成参数,例如温度、最大输出长度、超时时间等;
  • 最好支持流式输出或批量调用,便于优化体验。

本教程不绑定任何具体模型产品,你只需要确保模型具备基本的自然语言理解与生成能力。

3. 一个文本嵌入模型

文本嵌入模型用于把文本转换为向量。向量可以理解为文本在多维空间中的坐标。语义相近的文本,在向量空间中的距离通常更近。

选择嵌入模型时需要注意:

  • 输入输出应为文本向量;
  • 不同模型的向量维度可能不同,但同一套知识库中必须使用同一嵌入模型;
  • 中文文档建议选择对中文语义理解较好的嵌入模型;
  • 如果后续要替换嵌入模型,通常需要重新构建向量索引。

4. 一个向量检索能力

向量数据库或向量检索服务用于保存文档分块的向量,并支持相似度查询。

你需要具备:

  • 写入向量与元数据的能力;
  • 按向量相似度检索的能力;
  • 可选的过滤能力,例如按来源、版本、标签过滤;
  • 可选的批量写入与增量更新能力。

如果没有现成向量数据库,也可以使用支持向量检索的通用数据库、本地向量索引组件或云上向量检索服务。

5. 运行环境与访问权限

你需要准备:

  • 可运行的代码环境;
  • 文档读取与文本处理能力;
  • 调用模型接口的网络访问权限;
  • 调用向量检索服务的访问权限;
  • 密钥或访问凭证的安全管理方式。

注意不要把密钥硬编码在代码或日志中。建议通过环境变量、密钥管理服务或配置中心管理。


rag-">为什么需要 RAG:从长文本提示词说起

一个常见想法是:把需要告诉大模型的文档直接拼接到提示词里,然后一次性提问。这种方式在文档很小时可行,但随着知识量增长,会出现明显问题。

1. 长文本浪费 Token

如果每次请求都塞入整篇文档,会消耗大量输入 Token。对于知识库而言,这是不必要且昂贵的。

2. 冗余信息干扰生成

如果文档中与当前问题无关的内容太多,模型可能会被无关信息干扰,导致回答偏移、重复甚至编造。

3. 长上下文存在信息丢失风险

研究表明,大模型在处理很长上下文时,可能更容易记住开头和结尾,而对中间部分的信息利用不足。这种现象可以称为“Lost in the Middle”。

因此,更好的策略是:只把与当前问题最相关的少量文本片段传给模型。这正是 RAG 的目标。

RAG 的基本流程可以概括为:

  1. 将文档分块;
  2. 将每个分块转换为向量;
  3. 将向量保存到向量数据库;
  4. 用户提问时,将问题也转换为向量;
  5. 在向量数据库中检索最相近的分块;
  6. 将检索到的分块拼入提示词;
  7. 由大模型基于这些分块生成回答。

实施步骤

下面按照“离线构建知识库”和“在线问答检索”两个阶段进行说明。


第一阶段:离线构建知识库

离线阶段的目标是:把原始文档变成可被检索的向量知识库。


步骤 1:加载并清洗文档

首先读取原始文档,将其转换为统一格式的纯文本。

清洗目标包括:

  • 去除页眉、页脚、页码、重复空行;
  • 去除乱码或无效字符;
  • 保留有意义的标题、编号、条目;
  • 合并被错误换行打断的段落;
  • 删除明显重复的内容;
  • 统一全角、半角、空格、换行格式。

如果文档本身具有较强结构,例如每个条目都以特定符号开头,那么清洗时应尽量保留这些结构标记,因为后续分块可能会依赖它们。

示例处理思路:

  1. 输入:一份包含编号和条目的规范文档
  2. 处理:
  3. 1. 读取全文
  4. 2. 去掉重复空白行
  5. 3. 按结构标记拆分为候选块
  6. 4. 过滤空块或过短块
  7. 5. 保留每个块的原始编号和标题信息

步骤 2:设计分块策略

分块是 RAG 系统中最关键的设计之一。块太大,检索结果可能不够精准;块太小,上下文可能不完整。

常见分块策略有三种。

1. 固定大小分块

按固定字符数或固定 Token 数切分。例如每 500 个字符一个块。

优点:

  • 实现简单;
  • 块大小可控;
  • 便于预估上下文长度。

缺点:

  • 容易切断完整语义;
  • 可能把标题和正文分到不同块中;
  • 对结构化文档不够友好。

2. 递归字符分块

先尝试按段落切分;如果段落太长,再按句子切分;如果句子仍然太长,再按词或符号切分。

优点:

  • 尽量保持语义完整;
  • 比固定大小分块更自然;
  • 对普通文本较友好。

缺点:

  • 对强结构文档仍可能不够精准;
  • 需要设计递归规则和最小块长度。

3. 按结构或语义分块

根据文档自身结构进行切分,例如:

  • 按标题;
  • 按章节;
  • 按编号;
  • 按列表项;
  • 按问答对;
  • 按段落主题变化。

对于开发规范、运维手册这类文档,结构分块通常比单纯按字符切分更稳定。

如果文档中的每个规则都以类似“【】”这样的标记开头,可以按标记切分。这样可以保证每个规则条目成为一个相对独立的检索单元。

示例伪代码:

  1. def split_by_marker(text, marker="【"):
  2. parts = text.split(marker)
  3. chunks = []
  4. for part in parts:
  5. cleaned = clean_text(part)
  6. if is_valid_chunk(cleaned):
  7. chunks.append(cleaned)
  8. return chunks

其中:

  • clean_text 负责去除多余空白和无效字符;
  • is_valid_chunk 负责过滤空块或过短块;
  • marker 是文档中的结构标记。

如果你的文档没有这种明显标记,可以改用“标题 + 正文”的组合分块方式。


步骤 3:为每个分块补充元数据

只保存文本和向量还不够。生产环境中通常还需要保存元数据,以便后续过滤、追踪和更新。

常见元数据包括:

  • source:文档来源;
  • version:文档版本;
  • title:文档标题;
  • section:章节或小节;
  • chunk_id:分块编号;
  • created_at:创建时间;
  • updated_at:更新时间;
  • access_level:访问权限级别;
  • tags:标签,例如“安全”“发布”“数据库”。

元数据的作用包括:

  1. 检索时可以按来源过滤;
  2. 回答时可以附带引用来源;
  3. 文档更新后可以按版本重建索引;
  4. 可以按权限控制可见内容;
  5. 便于问题排查和效果评估。

步骤 4:将分块向量化

对每个分块调用嵌入模型,将其转换为向量。

需要注意:

  • 同一知识库必须使用同一个嵌入模型;
  • 向量维度需要与向量数据库中的索引维度一致;
  • 建议批量处理,提高构建效率;
  • 对失败调用设置重试;
  • 对超长块可以二次切分,避免超出嵌入模型输入限制。

示例流程:

  1. chunks = load_and_split(document)
  2. vectors = embed_batch(chunks)
  3. for chunk, vector in zip(chunks, vectors):
  4. save_to_vector_store(chunk, vector, metadata)

步骤 5:写入向量数据库

将文本、向量和元数据一起写入向量数据库。

建议每个记录至少包含:

  1. {
  2. "id": "唯一编号",
  3. "text": "分块文本",
  4. "vector": [0.12, 0.34, 0.56, ...],
  5. "source": "文档来源",
  6. "version": "文档版本",
  7. "section": "章节或标题",
  8. "created_at": "创建时间"
  9. }

写入时可以设置唯一 ID,便于后续更新和删除。例如,如果某个文档更新了,可以按文档来源或版本删除旧数据,再写入新数据。


第二阶段:在线问答与检索生成

在线阶段的目标是:当用户提问时,系统能够快速找到相关文档片段,并生成可靠回答。


步骤 6:接收并规范化用户问题

用户输入可能包含空格、错别字、口语表达或不完整语义。建议先做简单规范化:

  • 去除多余空格;
  • 去除无意义符号;
  • 统一大小写或全半角;
  • 如果问题过短,可提示用户补充;
  • 可选地进行查询改写,把口语表达转换为更正式的技术问题。

例如,用户问:“这个接口要不要鉴权?”

可以改写为:

  1. 接口是否需要鉴权?

查询改写不是必须项,但对于短问题、口语问题、同义词较多的问题很有帮助。


步骤 7:将用户问题向量化

使用与知识库相同的嵌入模型,将用户问题转换为向量。

注意:

  • 必须使用相同嵌入模型;
  • 如果模型支持指令格式,应保持问题编码方式一致;
  • 如果问题很长,可以先截取关键句或做摘要;
  • 如果问题包含多个意图,可以考虑拆分为多个子查询。

步骤 8:在向量数据库中检索候选分块

使用问题向量进行相似度检索,召回最相关的若干分块。

常见参数包括:

  • top_k:返回多少个候选块;
  • score_threshold:相似度阈值;
  • metadata_filters:元数据过滤条件;
  • deduplicate:是否去重;
  • rerank:是否进行二次排序。

如果知识库不大,top_k 可以设为 3 到 5;如果文档块较小,可以适当增加到 5 到 10;如果上下文长度有限,则需要控制最终拼接的内容总量。

示例伪代码:

  1. query_vector = embed(question)
  2. candidates = vector_store.search(
  3. query_vector=query_vector,
  4. top_k=5,
  5. filters={"source": "开发规范文档"}
  6. )

步骤 9:过滤与重排候选结果

初次向量检索可能召回一些看似相关但不够精确的块。可以进行二次处理:

  1. 按相似度阈值过滤低相关结果;
  2. 按元数据过滤错误版本或无权访问内容;
  3. 对重复内容去重;
  4. 对候选块进行重排;
  5. 保留最相关的少量块。

重排可以使用交叉编码器、规则评分或自定义打分模型。简单场景可以先不做重排,但要保留日志,便于后续分析。


步骤 10:组装提示词

将检索到的文档片段和用户问题一起组装成提示词。

提示词需要明确约束:

  • 只能根据提供的资料回答;
  • 如果资料不足,应明确说明无法回答;
  • 不要编造资料中不存在的内容;
  • 可以标注来源编号;
  • 回答要简洁、结构化。

示例提示词:

  1. 你是一个严谨的技术问答助手。
  2. 请仅根据下面提供的资料回答问题。
  3. 如果资料不足以回答,请明确说明“当前资料不足”。
  4. 不要编造资料中不存在的信息。
  5. 回答时请尽量标注依据的资料编号。
  6. 资料:
  7. 【资料1】……
  8. 【资料2】……
  9. 【资料3】……
  10. 用户问题:……

步骤 11:调用大模型生成回答

将组装好的提示词发送给大模型。

生成参数建议:

  • temperature:问答场景建议设为较低值,例如 0 到 0.3;
  • max_output_tokens:根据答案长度设置,避免过长;
  • timeout:设置合理超时,避免请求挂起;
  • retry:对网络错误或超时进行有限重试;
  • stream:如需更好交互体验,可启用流式输出。

示例伪代码:

  1. answer = llm.generate(
  2. prompt=prompt,
  3. temperature=0.1,
  4. max_output_tokens=800
  5. )

步骤 12:输出结果与引用来源

为了让用户信任答案,建议在最终输出中附带检索来源。

输出可以包括:

  • 回答正文;
  • 引用来源;
  • 命中文档片段编号;
  • 文档版本;
  • 置信度或相似度分数;
  • 无法回答时的提示。

这样用户不仅能获得答案,还能快速定位原始资料。


配置说明

RAG 系统不是“配好就能一直完美运行”的系统,很多效果问题都来自参数和策略配置。下面列出常见配置项及其含义。

1. 分块大小

分块大小决定每个知识单元包含多少信息。

  • 太小:语义不完整,检索后模型缺乏上下文;
  • 太大:检索不精准,浪费 Token,增加噪声。

对于规范类文档,建议按结构分块,让每个规则条目尽量保持完整。

2. 分块重叠

相邻块之间可以保留少量重叠内容,避免一句话被切断后导致上下文丢失。

  • 重叠太小:边界信息可能丢失;
  • 重叠太大:存储冗余增加,检索结果重复。

通常可以设置少量重叠,但需要根据文档结构反复测试。

3. Top-K

top_k 表示每次检索返回多少个候选块。

  • 太小:可能漏掉关键内容;
  • 太大:引入无关信息,增加生成成本。

建议从较小值开始,逐步调整。

4. 相似度阈值

相似度阈值用于过滤明显不相关的结果。

  • 阈值过高:可能过滤掉正确但表达不同的内容;
  • 阈值过低:无关内容进入上下文。

阈值应结合具体嵌入模型和业务语料调整。

5. 上下文长度上限

即使召回了多个分块,也不能无限拼接到提示词中。需要设置上下文长度上限。

常见做法:

  • 优先保留相似度高的块;
  • 超长时截断低分块;
  • 对长块进行摘要或二次切分;
  • 控制总 Token 数量。

6. 生成温度

问答系统通常希望回答稳定、准确,因此生成温度不宜过高。

  • 温度过高:回答更发散,容易偏离资料;
  • 温度过低:回答可能较死板,但更适合事实问答。

7. 元数据过滤

如果知识库包含多个来源或多个版本,应使用元数据过滤。

例如:

  1. filters = {
  2. "source": "开发规范文档",
  3. "version": "latest"
  4. }

这样可以避免检索到旧版本或错误文档。


示例:一个最小 RAG 问答流程

下面给出一个与具体产品和语言无关的伪代码示例,仅用于表达整体流程。

  1. # 注意:以下为流程伪代码,不绑定任何具体框架或产品
  2. function build_knowledge_base(document_path):
  3. raw_text = read_document(document_path)
  4. cleaned_text = clean_text(raw_text)
  5. chunks = split_by_structure(cleaned_text, marker="【")
  6. for chunk in chunks:
  7. if not is_valid_chunk(chunk):
  8. continue
  9. vector = embedding_model.encode(chunk)
  10. vector_store.upsert({
  11. "id": generate_chunk_id(chunk),
  12. "text": chunk,
  13. "vector": vector,
  14. "source": "开发规范文档",
  15. "version": "v1",
  16. "section": extract_section(chunk)
  17. })
  18. function answer(question):
  19. normalized_question = normalize(question)
  20. query_vector = embedding_model.encode(normalized_question)
  21. candidates = vector_store.search(
  22. query_vector=query_vector,
  23. top_k=5,
  24. filters={
  25. "source": "开发规范文档",
  26. "version": "v1"
  27. }
  28. )
  29. filtered = []
  30. for item in candidates:
  31. if item.score >= MIN_SCORE:
  32. filtered.append(item)
  33. if len(filtered) == 0:
  34. return {
  35. "answer": "当前知识库中没有找到足够依据。",
  36. "references": []
  37. }
  38. context_blocks = []
  39. references = []
  40. for index, item in enumerate(filtered):
  41. context_blocks.append(
  42. "【资料" + str(index + 1) + "】" + item.text
  43. )
  44. references.append({
  45. "id": item.id,
  46. "source": item.source,
  47. "score": item.score
  48. })
  49. context = join(context_blocks, separator="\n\n")
  50. prompt = build_prompt(
  51. question=normalized_question,
  52. context=context
  53. )
  54. answer = llm.generate(
  55. prompt=prompt,
  56. temperature=0.1,
  57. max_output_tokens=800
  58. )
  59. return {
  60. "answer": answer,
  61. "references": references
  62. }

这个示例表达了三个关键点:

  1. 离线阶段把文档切分、向量化并写入向量库;
  2. 在线阶段将问题向量化并检索相关分块;
  3. 生成阶段只使用检索到的上下文,并要求模型基于资料回答。

结果验证方法

搭建完成后,不能只看一次回答是否正常,而应建立验证方法。

1. 构建测试问题集

建议准备至少四类问题:

  1. 直接事实题
    答案在某个文档块中能直接找到。

  2. 跨块综合题
    答案需要结合多个分块信息。

  3. 干扰题
    问题中包含相似概念,容易召回错误块。

  4. 无答案题
    知识库中没有相关内容,系统应明确表示无法回答。

2. 检查检索命中是否正确

对于每个问题,人工标注正确文档块。然后检查:

  • 正确块是否被召回;
  • 正确块是否排在前面;
  • 是否召回了明显无关内容;
  • 是否因为阈值或过滤条件误删正确块。

3. 检查回答是否基于资料

回答应满足:

  • 不编造资料外内容;
  • 能对应到检索到的文档片段;
  • 资料不足时明确说明;
  • 引用来源准确。

4. 记录关键日志

建议记录以下信息:

  • 请求 ID;
  • 用户问题;
  • 查询向量;
  • 检索到的候选块;
  • 相似度分数;
  • 最终使用的上下文;
  • 模型输入与输出;
  • 响应耗时;
  • 输入输出 Token 数;
  • 是否触发降级或拒答。

日志有助于定位“检索错了”还是“生成错了”。


常见问题与排查思路

1. 检索不到相关内容

可能原因:

  • 分块过大,正确内容被稀释;
  • 分块过小,语义不完整;
  • 嵌入模型与语料不匹配;
  • 问题表达与文档表达差异较大;
  • 元数据过滤过严;
  • 向量库未更新。

排查思路:

  • 查看正确文本是否存在于知识库中;
  • 查看该文本是否成功向量化;
  • 临时关闭元数据过滤再检索;
  • 尝试降低相似度阈值;
  • 调整分块策略;
  • 尝试查询改写。

2. 检索到了但回答错误

可能原因:

  • 检索块相关但不充分;
  • 提示词约束不够;
  • 模型忽略资料,使用自身知识;
  • 上下文过长导致关键信息被忽略;
  • 多个资料冲突。

排查思路:

  • 检查提示词是否明确“只根据资料回答”;
  • 降低生成温度;
  • 减少无关上下文;
  • 增加来源编号和引用要求;
  • 检查多个文档版本是否同时存在。

3. 回答越界或编造

可能原因:

  • 检索结果不足,但模型仍强行回答;
  • 提示词没有要求“不知道就说不知道”;
  • 生成温度过高;
  • 上下文包含模糊内容。

排查思路:

  • 增加拒答提示;
  • 设置最低相似度阈值;
  • 无合格上下文时直接返回“未找到依据”;
  • 降低温度;
  • 对回答进行引用校验。

4. 上下文过长

可能原因:

  • top_k 太大;
  • 分块太大;
  • 没有限制上下文长度;
  • 多次召回内容重复。

排查思路:

  • 减少 top_k;
  • 对候选块去重;
  • 设置上下文最大 Token 数;
  • 对超长块摘要或二次切分;
  • 优先保留高相似度和高权重的块。

5. 文档更新后回答仍是旧内容

可能原因:

  • 向量库未同步更新;
  • 元数据没有版本区分;
  • 检索到旧版本文档。

排查思路:

  • 更新文档后重新向量化并写入;
  • 删除旧版本或标记旧版本;
  • 检索时增加版本过滤;
  • 定期校验知识库文档清单与向量库记录是否一致。

6. 响应慢或成本高

可能原因:

  • 检索返回过多内容;
  • 嵌入模型调用慢;
  • 生成输出过长;
  • 没有缓存机制;
  • 频繁重建索引。

排查思路:

  • 降低 top_k;
  • 控制最大输出长度;
  • 对高频问题缓存结果;
  • 对嵌入结果缓存;
  • 使用批量写入和增量更新;
  • 将大文档预处理为离线任务。

优化建议

1. 使用混合检索

纯向量检索擅长理解语义,但对精确术语、编号、函数名、配置项可能不够敏感。可以结合关键词检索和向量检索。

例如:

  • 向量检索负责语义相似;
  • 关键词检索负责精确命中术语;
  • 最后合并候选并进行重排。

2. 增加重排机制

向量检索通常先快速召回较多候选,再通过重排模型或规则进行精细排序。

重排目标:

  • 提高正确块进入最终上下文的概率;
  • 降低无关块进入提示词的概率;
  • 改善回答稳定性。

3. 对问题做改写

用户问题可能简短或口语化。可以进行:

  • 同义扩展;
  • 术语标准化;
  • 多查询生成;
  • 基于元数据的意图识别。

例如把“怎么加锁?”改写为“同步锁应如何实现?是否有超时机制?”

4. 建立评估集

建议维护一个持续增长的评估集,包含:

  • 标准问题;
  • 标准答案;
  • 正确来源;
  • 期望拒答问题;
  • 边界问题。

每次调整分块、嵌入模型、检索参数或提示词后,都进行回归测试。

5. 做好权限与脱敏

如果知识库包含敏感内容,需要在检索前进行权限控制:

  • 用户只能检索到自己有权访问的文档;
  • 元数据中记录权限级别;
  • 查询时根据用户身份过滤;
  • 对敏感字段进行脱敏;
  • 日志中避免输出敏感原文。

6. 云端部署可结合通用云能力

如果系统将服务部署到云端,可以结合百度智能云的通用能力进行工程化增强,例如:

  • 使用对象存储保存原始文档;
  • 使用数据库保存元数据;
  • 使用容器平台部署服务;
  • 使用日志服务记录调用链路;
  • 使用监控告警观察延迟和错误率;
  • 使用身份认证控制访问权限;
  • 使用消息队列处理离线索引构建任务。

这些能力本身不改变 RAG 的核心流程,但可以提升系统的稳定性、可维护性和可扩展性。


总结

本文围绕“如何搭建一个简单 RAG 问答系统”展开,从原始痛点出发,解释了为什么不能简单地把所有文档塞进提示词,并给出了完整的实现路径。

核心步骤可以归纳为:

  1. 准备知识文档,并进行清洗与结构化处理;
  2. 根据文档结构选择合适的分块策略;
  3. 为分块补充元数据,便于过滤和追踪;
  4. 使用嵌入模型将分块转换为向量;
  5. 将向量与文本写入向量数据库;
  6. 用户提问时,将问题向量化;
  7. 检索最相关的文档片段;
  8. 组装提示词,约束模型只根据资料回答;
  9. 输出答案并附带引用来源;
  10. 通过测试集、日志和监控持续优化效果。

RAG 不是一次性配置完成的任务,而是一个持续迭代的过程。你需要不断观察检索是否命中、上下文是否足够、回答是否越界、成本是否可控。掌握这套方法后,你可以把任意一类内部知识转化为可检索、可问答、可追溯的智能服务。