一、RAG 的完整工作流程概览
RAG(Retrieval-Augmented Generation,检索增强生成)并不是一次简单的向量搜索,而是一套从知识数据处理到模型回答的完整工程链路。
一个完整的 RAG 系统通常包含两个阶段:
- 离线知识入库(Indexing Pipeline):负责采集、解析、清洗、切分、向量化和建立索引。
- 在线检索生成(Retrieval and Generation Pipeline):负责理解用户问题、检索相关知识、构建上下文并生成答案。
两个阶段通过知识库和索引连接起来。
1.1 完整架构
flowchart TB
subgraph OFF["离线知识入库"]
A["原始知识数据"]
B["数据采集与连接"]
C["文档解析"]
D["文本清洗与结构化"]
E["Chunking 文档切分"]
F["Embedding 向量化"]
G["向量索引"]
H["文本与元数据存储"]
A --> B --> C --> D --> E --> F --> G
E --> H
end
subgraph ON["在线检索生成"]
I["用户问题"]
J["问题理解与改写"]
K["Query Embedding"]
L["混合检索"]
M["候选结果过滤"]
N["Reranking 重排序"]
O["上下文构建"]
P["大语言模型"]
Q["答案与引用"]
I --> J --> K --> L --> M --> N --> O --> P --> Q
end
G --> L
H --> L
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#EAF3EC,stroke:#83A995,color:#315D49
style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style E fill:#EAF3EC,stroke:#83A995,color:#315D49
style F fill:#EAF3EC,stroke:#83A995,color:#315D49
style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style H fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style J fill:#EAF3EC,stroke:#83A995,color:#315D49
style K fill:#EAF3EC,stroke:#83A995,color:#315D49
style L fill:#EAF3EC,stroke:#83A995,color:#315D49
style M fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style N fill:#EAF3EC,stroke:#83A995,color:#315D49
style O fill:#EAF3EC,stroke:#83A995,color:#315D49
style P fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style Q fill:#E5F0E9,stroke:#83A995,color:#315D49
1.2 两条链路的职责
| 维度 | 离线知识入库 | 在线检索生成 |
|---|---|---|
| 执行时机 | 文档新增或更新时 | 用户每次提问时 |
| 核心目标 | 建立可检索知识索引 | 找到当前问题需要的证据 |
| 主要输入 | PDF、Word、网页、数据库等 | 用户问题和会话上下文 |
| 核心处理 | 解析、清洗、切分、向量化 | 改写、检索、过滤、排序 |
| 主要输出 | 向量索引和知识片段 | 模型回答和引用 |
| 性能重点 | 吞吐量、数据质量、索引效率 | 检索延迟、召回质量、生成速度 |
两条链路不应混为一谈。
文档入库通常可以异步执行,而在线检索需要在用户请求的响应时间预算内完成。
二、第一阶段:离线知识入库流程
离线阶段的任务是将原始知识转化为可检索的数据。
它决定了 RAG 系统能够检索到什么、检索结果是否完整,以及知识更新是否可靠。
2.1 第一步:数据采集
数据采集(Data Ingestion)是知识入库的入口。
常见数据来源:
| 数据来源 | 数据形式 | 采集方式 |
|---|---|---|
| 本地文件 | PDF、DOCX、TXT、Markdown | 文件上传、目录扫描 |
| 企业网盘 | 文档、表格、附件 | API、同步连接器 |
| 网站 | HTML、网页内容 | Web Crawler、API |
| 数据库 | 业务记录、结构化数据 | SQL、CDC、业务 API |
| 代码仓库 | 源代码、README、注释 | Git、代码解析器 |
| 知识管理系统 | 页面、文档、知识条目 | 系统 API |
数据采集层需要关注几个问题:
数据来源标识
每份文档都应该有稳定的 document_id,不能只使用文件名作为唯一标识。
增量同步
不应每次都重新采集全部文档。可以根据更新时间、版本号、内容哈希或事件通知判断是否需要更新。
权限信息
需要在入库时获取文档所属租户、部门、访问级别和授权范围,为后续检索权限过滤提供依据。
数据版本
同一文档可能存在多个版本,需要能够识别新增、修改和删除操作。
建议为每份文档记录:
{
"document_id": "doc_10001",
"source_id": "source_001",
"source_type": "file",
"file_name": "technical-guide.pdf",
"content_hash": "sha256-value",
"version": 3,
"tenant_id": "tenant_001",
"updated_at": "2026-11-20T10:00:00Z"
}
这里的 content_hash 可以用于识别内容是否真正发生变化,避免对没有变化的文档重复执行解析和向量化。
2.2 第二步:文档解析
采集到的原始文件通常不能直接用于语义检索,需要先转换为可处理的内容。
不同格式需要不同的解析器。
| 文档类型 | 解析重点 |
|---|---|
| 页面文本、阅读顺序、表格、页码 | |
| DOCX | 标题、段落、表格、图片 |
| HTML | 正文提取、标题层级、链接 |
| Markdown | 标题、代码块、列表、引用 |
| XLSX | 工作表、列名、行数据 |
| PPTX | 幻灯片标题、正文、备注 |
| 代码文件 | 文件路径、类、函数、注释 |
例如,一份 PDF 技术文档可能包含:
第 1 页:产品介绍
第 2 页:系统架构
第 3 页:部署流程
第 4 页:配置参数
第 5 页:故障排查
解析后应该尽量保留:
- 原始文档 ID。
- 页码。
- 标题层级。
- 段落顺序。
- 表格结构。
- 代码块边界。
- 图片与正文之间的关联。
如果只提取纯文本,可能丢失重要的结构信息。
例如:
| 参数 | 类型 | 默认值 |
|---|---|---|
| timeout | integer | 30 |
| retry | integer | 3 |
如果解析后变成没有列名和边界的连续字符串,模型可能无法准确理解参数和值之间的关系。
对于扫描版 PDF,还需要 OCR;对于包含大量图表的文档,可能需要视觉模型提取图表信息。
2.3 第三步:文本清洗与结构化
文档解析后,通常还需要清洗。
常见操作:
- 删除重复页眉、页脚。
- 去除导航栏和广告内容。
- 修复异常换行。
- 处理乱码和特殊字符。
- 清理重复文本。
- 规范标题和段落格式。
- 保留必要的表格与代码结构。
清洗不能过度。
对于技术文档,以下内容通常具有很高的检索价值:
HTTP 429
ERR_CONNECTION_RESET
PostgreSQL 16.2
timeout = 30
retry_count = 3
如果把数字、标点、下划线和特殊字符全部删除,就可能破坏关键技术信息。
结构化后的文档可以保留标题路径:
{
"document_id": "doc_10001",
"title": "Redis 技术指南",
"sections": [
{
"heading": "缓存机制",
"subheading": "缓存淘汰策略",
"content": "Redis 支持多种缓存淘汰策略,包括 LRU 和 LFU。"
}
]
}
标题路径可以在后续 Chunking 时作为上下文信息保留下来。
2.4 第四步:Chunking 文档切分
Chunking 是将长文档拆分成多个可独立检索片段的过程。
每个片段称为 Chunk。
假设原始文档:
# Redis 缓存机制
## 一、缓存淘汰策略
Redis 支持多种缓存淘汰策略。
常见策略包括 LRU、LFU 和随机淘汰。
## 二、缓存过期机制
Redis 支持为 Key 设置过期时间。
可以拆分为:
Chunk 1:
标题:Redis 缓存机制
章节:缓存淘汰策略
内容:Redis 支持多种缓存淘汰策略。
常见策略包括 LRU、LFU 和随机淘汰。
Chunk 2:
标题:Redis 缓存机制
章节:缓存过期机制
内容:Redis 支持为 Key 设置过期时间。
每个 Chunk 都应该有自己的唯一标识,并保留与原始文档的关联。
常见切分策略
| 策略 | 原理 | 适用场景 |
|---|---|---|
| 固定长度 | 按 Token 数量切分 | 普通文本 |
| Overlap | 相邻片段保留重叠内容 | 连续叙述 |
| 按段落切分 | 根据自然段落边界切分 | 文章、报告 |
| 按标题切分 | 根据章节层级切分 | 技术文档、手册 |
| 语义切分 | 根据主题变化切分 | 长篇自然语言 |
| Parent-Child | 小片段检索、大片段补充上下文 | 复杂知识库 |
Chunk Size 与 Overlap
假设:
- Chunk Size = 500 Tokens。
- Chunk Overlap = 100 Tokens。
那么相邻 Chunk 会保留 100 Tokens 的重叠内容。
flowchart TB
A["原始文档 Token 1-1200"] --> B["Chunk 1:1-500"]
A --> C["Chunk 2:401-900"]
A --> D["Chunk 3:801-1200"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#EAF3EC,stroke:#83A995,color:#315D49
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
Overlap 能够减少边界处的语义丢失,但会增加向量数量和重复检索概率。
Chunk Size 也不是越小越好:
- 太小:上下文不完整,容易丢失限定条件。
- 太大:检索粒度变粗,容易引入无关内容。
- 合理大小:能够独立表达一个相对完整的知识单元。
实际项目应根据文档类型和评估结果调整参数。
2.5 第五步:生成 Embedding 向量
完成 Chunking 后,需要使用 Embedding 模型将每个文本片段转换为向量。
假设:
Redis 支持 LRU 和 LFU 两种常见缓存淘汰策略。
经过 Embedding 模型:
其中:
- x:Chunk 文本。
- E:Embedding 模型。
- d:向量维度。
- v_i:向量的第 i 个分量。
例如:
向量表示的是模型学习得到的语义特征,不是关键词列表,也不能直接将每个维度解释为某个具体概念。
Embedding 处理流程
flowchart TB
A["Chunk 文本"] --> B["Embedding 模型"]
B --> C["生成固定维度向量"]
C --> D["附加 Chunk ID"]
D --> E["准备写入向量索引"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#EAF3EC,stroke:#83A995,color:#315D49
style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
需要保证:
- 文档向量和查询向量处于兼容的向量空间。
- 向量维度符合索引要求。
- Embedding 模型版本可追踪。
- 模型更换时能够识别旧向量是否需要重新生成。
- 批量向量化时能够处理失败和重试。
2.6 第六步:保存向量、文本与元数据
向量生成后,需要将数据写入知识库。
一个 Chunk 的完整记录通常包含三部分:
- Vector:向量。
- Text:原始文本或规范化文本。
- Metadata:文档来源和业务属性。
示例:
{
"id": "chunk_10001",
"vector": [0.12, -0.34, 0.56],
"text": "Redis 支持 LRU 和 LFU 两种常见缓存淘汰策略。",
"metadata": {
"document_id": "doc_10001",
"title": "Redis 技术指南",
"section": "缓存淘汰策略",
"page": 12,
"tenant_id": "tenant_001",
"version": 3
}
}
实际系统中,向量通常存储在向量数据库或支持向量索引的数据库中,原始文档和其他业务信息也可以存放在对象存储或关系数据库中。
数据之间的关联
flowchart TB
A["Document 文档"] --> B["Chunk 1"]
A --> C["Chunk 2"]
A --> D["Chunk 3"]
B --> E["Embedding Vector 1"]
C --> F["Embedding Vector 2"]
D --> G["Embedding Vector 3"]
B --> H["Metadata"]
C --> I["Metadata"]
D --> J["Metadata"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#EAF3EC,stroke:#83A995,color:#315D49
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style H fill:#E5F0E9,stroke:#83A995,color:#315D49
style I fill:#E5F0E9,stroke:#83A995,color:#315D49
style J fill:#E5F0E9,stroke:#83A995,color:#315D49
2.7 第七步:建立检索索引
知识数据写入后,需要建立检索索引。
常见索引类型:
- Flat:精确向量搜索。
- HNSW:基于图结构的近似最近邻搜索。
- IVF:基于聚类的倒排索引。
- IVF-PQ:结合聚类和向量量化。
如果使用混合检索,还需要建立关键词索引,例如 BM25 倒排索引。
至此,离线知识入库流程基本完成。
需要注意,数据写入成功不一定意味着已经可以立即检索。不同数据库的索引构建、刷新和可见性机制可能不同,需要明确处理索引就绪状态。
三、第二阶段:在线检索与生成流程
当用户提出问题时,系统开始执行在线 RAG 链路。
在线流程的核心目标是:在有限的延迟和上下文预算内,找到最相关、最可信且用户有权限访问的知识。
3.1 第一步:接收用户问题
假设用户提出:
Redis 的 LFU 淘汰策略是如何工作的?
系统需要获得:
- 当前用户身份。
- 当前会话 ID。
- 用户问题。
- 知识库范围。
- 模型配置。
- 会话历史。
请求示例:
{
"conversation_id": "conv_001",
"query": "Redis 的 LFU 淘汰策略是如何工作的?",
"knowledge_base_id": "kb_001"
}
用户身份和权限不能直接信任请求体中的字段,应该从服务端验证过的认证信息中获取。
3.2 第二步:Query Processing 问题处理
用户原始问题不一定适合直接检索。
例如:
它是怎么淘汰数据的?
如果当前会话前文讨论的是 Redis,系统可以结合对话历史进行指代消解:
Redis 的缓存淘汰策略是如何工作的?
常见问题处理包括:
- 文本规范化。
- 关键词提取。
- 指代消解。
- 查询改写。
- 多查询生成。
- 查询分类。
- 知识库路由。
Query Rewrite
Query Rewrite 的主要目标是将自然语言问题转换为更适合检索的查询表达。
例如:
| 原始问题 | 改写查询 |
|---|---|
| 它怎么淘汰数据? | Redis 缓存淘汰机制 |
| LFU 和 LRU 有啥区别? | Redis LFU 与 LRU 淘汰策略的区别 |
| 怎么配置? | Redis maxmemory-policy 配置方法 |
查询改写可以由规则、模型或两者结合完成。
需要保留原始问题,避免改写过程改变用户真正想问的内容。
3.3 第三步:Query Embedding
如果使用向量检索,需要将处理后的查询转换为向量。
其中:
- Q:用户查询。
- E:Embedding 模型。
- q:查询向量。
例如:
Redis 的 LFU 淘汰策略是如何工作的?
经过 Embedding 后得到:
查询向量与离线阶段生成的文档向量处于兼容的向量空间,才能进行有意义的相似度搜索。
3.4 第四步:执行知识检索
检索阶段通常有多种方式。
向量检索
根据查询向量与文档向量的相似度,查找语义相关的 Chunk。
关键词检索
通过 BM25 等算法查找包含关键术语的文档。
混合检索
结合向量检索与关键词检索,兼顾语义表达和精确匹配。
例如:
用户问题:
Redis 的 LFU 淘汰策略是如何工作的?
向量检索:
1. Redis LFU 机制
2. Redis LRU 机制
3. Redis 内存管理
关键词检索:
1. LFU 淘汰算法
2. maxmemory-policy
3. Redis 高频访问统计
两种检索方式的结果可以合并,再交给后续排序模块。
3.5 第五步:Metadata Filtering 权限与元数据过滤
初步检索结果可能包含用户不应该访问的文档,也可能包含不符合当前业务条件的内容。
例如:
tenant_id = tenant_001
document_type = technical
version = 3
过滤可以基于:
- 租户 ID。
- 用户权限。
- 部门。
- 文档类型。
- 文档版本。
- 时间范围。
- 知识库范围。
需要特别注意:权限过滤应该尽可能在检索阶段执行,而不是等到模型生成后再过滤。
如果缓存了检索结果,缓存键也必须包含必要的租户和权限上下文,防止不同用户之间共享不应共享的检索内容。
3.6 第六步:Reranking 重排序
检索阶段得到的候选结果可能并不完全符合问题。
Reranker 会对候选文档进行更精细的相关性判断。
例如:
| 候选内容 | 初始排名 | 重排序后 |
|---|---|---|
| Redis LFU 机制 | 1 | 1 |
| Redis LRU 机制 | 2 | 3 |
| Redis 内存管理 | 3 | 2 |
| Redis 持久化机制 | 4 | 4 |
Reranking 可以使用 Cross-Encoder 或其他排序模型。
典型方式是将 Query 和候选 Chunk 共同输入模型,获得相关性分数:
其中:
- Q:查询文本。
- D_i:候选文档。
- R:重排序模型。
- s_i:相关性评分。
最后根据评分选出最终候选结果。
Reranker 的成本通常高于简单向量检索,因此常见架构是先召回一批候选,再对较小集合进行重排序。
3.7 第七步:构建上下文 Context Construction
检索完成后,需要将最终候选片段组织成模型可以理解的上下文。
不能直接将所有检索结果无差别地拼接起来。
需要考虑:
- 相关性排序。
- 内容去重。
- 文档来源。
- 章节上下文。
- Token 预算。
- 时间和版本信息。
- 内容之间是否存在冲突。
例如,最终检索到:
[资料 1]
Redis LFU 根据访问频率进行近似淘汰。
[资料 2]
Redis LFU 使用近似计数机制,并结合时间衰减处理访问频率。
[资料 3]
maxmemory-policy 可以配置不同的内存淘汰策略。
系统可以将这些资料组合为:
参考资料:
资料 1:
Redis LFU 根据访问频率进行近似淘汰。
资料 2:
Redis LFU 使用近似计数机制,并结合时间衰减处理访问频率。
资料 3:
maxmemory-policy 可以配置不同的内存淘汰策略。
用户问题:
Redis 的 LFU 淘汰策略是如何工作的?
3.8 第八步:调用大语言模型生成答案
上下文准备完成后,后端调用大语言模型。
Prompt 通常包含:
- System Prompt。
- 会话历史。
- 检索到的知识片段。
- 当前用户问题。
- 输出格式要求。
例如:
System:
你是一个专业的技术助手。
请遵守以下规则:
1. 优先根据参考资料回答。
2. 不要编造资料中不存在的信息。
3. 如果资料不足,请明确说明。
4. 关键结论应提供对应来源。
Context:
[资料 1]
Redis LFU 根据访问频率进行近似淘汰。
[资料 2]
Redis LFU 使用近似计数机制,并结合时间衰减处理访问频率。
Question:
Redis 的 LFU 淘汰策略是如何工作的?
模型根据这些上下文生成自然语言回答。
需要注意,RAG 并不意味着模型只能使用检索到的信息。除非采用严格约束和验证机制,否则模型仍可能结合参数化知识补充内容。
3.9 第九步:答案校验与引用
模型生成完成后,可以执行进一步处理:
- 检查引用 ID 是否存在。
- 检查引用是否属于当前用户可访问范围。
- 校验输出格式。
- 检查敏感信息。
- 对关键结论执行证据验证。
- 根据业务规则决定是否允许返回。
例如:
{
"answer": "Redis LFU 根据键的访问频率进行近似淘汰。",
"citations": [
{
"document_id": "doc_10001",
"chunk_id": "chunk_10002",
"title": "Redis 技术指南",
"page": 12
}
]
}
引用信息应由服务端根据实际检索结果管理,不能完全信任模型自行生成的文档 ID 或页码。
3.10 第十步:返回答案并记录日志
最终结果返回前端。
{
"conversation_id": "conv_001",
"message_id": "msg_002",
"answer": "Redis LFU 根据键的访问频率进行近似淘汰。",
"citations": [
{
"title": "Redis 技术指南",
"page": 12
}
],
"usage": {
"input_tokens": 1200,
"output_tokens": 300
}
}
后端还需要记录:
- 请求 ID。
- 查询内容或经过脱敏的查询摘要。
- 检索命中数量。
- 候选文档 ID。
- Reranker 结果。
- 模型版本。
- Token 使用量。
- 检索耗时。
- 模型生成耗时。
- 错误信息。
这些信息可以用于后续分析检索质量和系统性能。
四、在线 RAG 的完整时序
前面的流程从功能角度拆解了各个步骤。下面从系统交互角度看一次完整请求。
4.1 时序图
sequenceDiagram
autonumber
participant U as 用户
participant API as RAG API
participant Q as Query Processor
participant E as Embedding
participant V as Vector Database
participant R as Reranker
participant L as LLM
participant D as Data Store
U->>API: 发送问题
API->>API: 身份认证与权限校验
API->>D: 获取会话历史
D-->>API: 返回历史消息
API->>Q: 处理用户问题
Q-->>API: 返回检索查询
API->>E: 生成查询向量
E-->>API: 返回 Query Vector
API->>V: 执行向量或混合检索
V-->>API: 返回候选 Chunk
API->>API: 元数据与权限过滤
API->>R: 候选结果重排序
R-->>API: 返回排序结果
API->>API: 构建增强上下文
API->>L: 发送 Prompt
L-->>API: 返回生成结果
API->>API: 引用与输出校验
API->>D: 保存消息和引用
API-->>U: 返回答案
4.2 在线请求的延迟组成
RAG 的响应时间不是只有模型生成时间。
可以抽象为:
其中:
- T_{auth}:身份认证和权限检查。
- T_{query}:问题处理和改写。
- T_{embedding}:查询向量化。
- T_{retrieval}:知识检索。
- T_{rerank}:重排序。
- T_{context}:上下文构建。
- T_{generation}:模型生成。
- T_{post}:后处理和持久化。
实际实现中,部分操作可以并行执行,例如向量检索和关键词检索。
但依赖关系必须保留:检索结果尚未返回,就无法完成基于这些结果的重排序和最终上下文构建。