返回专栏
· 20 分钟阅读

RAG 的完整工作流程:从知识入库、向量检索到答案生成的全链路解析


一、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 第二步:文档解析

采集到的原始文件通常不能直接用于语义检索,需要先转换为可处理的内容。

不同格式需要不同的解析器。

文档类型 解析重点
PDF 页面文本、阅读顺序、表格、页码
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 模型:

E(x)=[v_1,v_2,\ldots,v_d]

其中:

  • x:Chunk 文本。
  • E:Embedding 模型。
  • d:向量维度。
  • v_i:向量的第 i 个分量。

例如:

E(x)=[0.12,-0.34,0.56,\ldots]

向量表示的是模型学习得到的语义特征,不是关键词列表,也不能直接将每个维度解释为某个具体概念。

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 的完整记录通常包含三部分:

  1. Vector:向量。
  2. Text:原始文本或规范化文本。
  3. 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(Q)

其中:

  • Q:用户查询。
  • E:Embedding 模型。
  • q:查询向量。

例如:

Redis 的 LFU 淘汰策略是如何工作的?

经过 Embedding 后得到:

q=[q_1,q_2,\ldots,q_d]

查询向量与离线阶段生成的文档向量处于兼容的向量空间,才能进行有意义的相似度搜索。

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 共同输入模型,获得相关性分数:

s_i=R(Q,D_i)

其中:

  • 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 通常包含:

  1. System Prompt。
  2. 会话历史。
  3. 检索到的知识片段。
  4. 当前用户问题。
  5. 输出格式要求。

例如:

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_{total}= T_{auth}+ T_{query}+ T_{embedding}+ T_{retrieval}+ T_{rerank}+ T_{context}+ T_{generation}+ T_{post}

其中:

  • T_{auth}:身份认证和权限检查。
  • T_{query}:问题处理和改写。
  • T_{embedding}:查询向量化。
  • T_{retrieval}:知识检索。
  • T_{rerank}:重排序。
  • T_{context}:上下文构建。
  • T_{generation}:模型生成。
  • T_{post}:后处理和持久化。

实际实现中,部分操作可以并行执行,例如向量检索和关键词检索。

但依赖关系必须保留:检索结果尚未返回,就无法完成基于这些结果的重排序和最终上下文构建。