← 返回首页 📚 实战课程
📑 本篇章节导航 (共6章,点击直达)
本节目标核心知识实战代码:手写一个完整的RAG管道面试模拟动手练习下一课预告

P3-03 - RAG管道从原理到生产

本节目标

1. RAG的完整链路是什么?每个环节解决什么问题?

2. 文档切分策略有哪些?为什么chunk_size不能太大也不能太小?

3. 向量数据库怎么选?PGVector vs Milvus vs Redis的区别?

4. 检索到的文档太多或太不相关怎么办?Rerank是什么?

5. 面试官说"RAG召回率低怎么排查",你怎么回答?

核心知识

一、RAG是什么 — 一句话解释


RAG = Retrieval-Augmented Generation(检索增强生成)

问题:大模型不知道你的私有数据(公司文档、业务规则、产品知识)
方案:先把私有数据变成向量存起来,用户提问时先检索相关文档,再把检索结果塞给大模型

一句话:不是让模型"记住"所有知识,而是让模型"查阅"相关资料再回答

类比:
  没有RAG = 闭卷考试(只能靠记忆)
  有RAG   = 开卷考试(可以翻书查阅)

二、RAG完整链路(7个步骤)


┌─────────────────────────────────────────────────────────────┐
│                      离线索引阶段                             │
│                                                               │
│  原始文档                                                     │
│    │                                                          │
│    ▼                                                          │
│  ① 文档加载(PDF/Word/HTML/Markdown → 纯文本)                │
│    │                                                          │
│    ▼                                                          │
│  ② 文档切分(长文档 → 多个小Chunk)                            │
│    │                                                          │
│    ▼                                                          │
│  ③ Embedding(文本 → 向量,如768维或1536维浮点数组)           │
│    │                                                          │
│    ▼                                                          │
│  ④ 存入向量数据库(向量 + 原文 + 元数据)                      │
│                                                               │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│                      在线查询阶段                             │
│                                                               │
│  用户提问:"公司年假政策是什么?"                                │
│    │                                                          │
│    ▼                                                          │
│  ⑤ Query Embedding(问题 → 向量)                             │
│    │                                                          │
│    ▼                                                          │
│  ⑥ 向量检索(在向量库中找最相似的Top-K个Chunk)                 │
│    │                                                          │
│    ▼                                                          │
│  ⑦ Rerank(可选,对检索结果重排序,提高相关性)                  │
│    │                                                          │
│    ▼                                                          │
│  组装Prompt:                                                  │
│    System: "根据以下参考资料回答用户问题"                       │
│    Context: [检索到的3个Chunk拼在一起]                          │
│    User: "公司年假政策是什么?"                                  │
│    │                                                          │
│    ▼                                                          │
│  调用大模型 → 返回基于检索内容的回答                             │
│                                                               │
└─────────────────────────────────────────────────────────────┘

三、文档切分 — 最容易被忽略但影响最大的环节


Chunk Size 的影响:

太大(如2000 Token):
  ✗ 一个Chunk包含太多主题 → 检索时相关和不相关的内容混在一起
  ✗ 浪费上下文窗口空间
  ✗ 模型被无关信息干扰

太小(如100 Token):
  ✗ 语义被截断 → 检索到的片段缺少上下文
  ✗ 需要检索更多Chunk才能覆盖完整信息
  ✗ 增加不必要的噪音

推荐范围:
  - 通用文档:500-1000 Token,重叠100-200 Token
  - 技术文档:300-800 Token,重叠50-100 Token
  - FAQ类:按问答对切分,一个Q-A对就是一个Chunk

切分策略:
  1. 固定长度切分(最简单,效果一般)
  2. 按段落/标题切分(推荐,保留语义完整性)
  3. 语义切分(用Embedding相似度检测语义边界,效果最好但成本高)
  4. 递归切分(LangChain的RecursiveCharacterTextSplitter)

四、向量数据库选型


┌──────────────┬────────────────┬─────────────────┬──────────────────┐
│ 数据库        │ 优点            │ 缺点             │ 适用场景          │
├──────────────┼────────────────┼─────────────────┼──────────────────┤
│ PGVector     │ 不用引入新组件   │ 性能一般          │ 小规模、已有PG    │
│              │ 用现有PostgreSQL │ 10万级以上变慢    │ 快速验证          │
├──────────────┼────────────────┼─────────────────┼──────────────────┤
│ Milvus       │ 专业向量数据库   │ 部署运维复杂      │ 大规模生产环境    │
│              │ 亿级向量检索     │ 学习成本高        │ 企业级应用        │
├──────────────┼────────────────┼─────────────────┼──────────────────┤
│ Redis        │ 已有Redis基础设施│ 向量功能较新      │ 已有Redis的小规模 │
│ (Redis Stack)│ 低延迟          │ 功能不如专业向量库 │ 缓存+向量混合     │
├──────────────┼────────────────┼─────────────────┼──────────────────┤
│ Chroma       │ 轻量、Python友好│ Java支持弱        │ Python项目        │
├──────────────┼────────────────┼─────────────────┼──────────────────┤
│ Pinecone     │ 全托管、零运维   │ 付费、数据在海外   │ 不想管基础设施    │
└──────────────┴────────────────┴─────────────────┴──────────────────┘

面试选型话术:
> "我们先用PGVector快速验证(因为已有PostgreSQL),效果可以但数据量大了之后检索变慢。
> 后续计划迁移到Milvus,它支持亿级向量检索而且有Spring AI的官方集成。
> 选型时主要考虑三个维度:数据规模(我们XX万条)、查询延迟要求(<100ms)、运维成本。"

五、检索优化 — 从基础到高级


基础检索(向量相似度):
  问题 → Embedding → cosine相似度 → Top-K

问题:检索到的文档不相关怎么办?

优化1:Hybrid Search(混合检索)
  向量检索(语义相似) + 关键词检索(精确匹配) → 合并结果
  适合:专业术语、产品名称等精确匹配场景

优化2:Query Rewrite(查询改写)
  用户问:"年假怎么算"
  改写为:"公司年假计算公式、工龄对应天数、年假使用规则"
  目的:把模糊问题展开成更具体的查询,提高召回率

优化3:Multi-Query(多查询扩展)
  用LLM把用户问题改写成3-5个不同角度的问题
  分别检索,合并去重
  目的:覆盖不同表述方式的相关文档

优化4:Rerank(重排序)
  初步检索Top-20 → Rerank模型精排 → 取Top-5
  Rerank模型专门做"这段文档和问题有多相关"的判断
  常用:Cohere Rerank、bge-reranker、cross-encoder

优化5:元数据过滤
  检索前先按元数据过滤(部门、时间、文档类型)
  减少检索范围,提高精度

六、RAG效果不好怎么排查(面试高频!)


面试官:"RAG召回率低/效果不好,怎么排查?"

排查框架(按链路逐步检查):

1. 文档质量问题
   → 文档是否完整?有没有乱码/格式问题?
   → 文档是否太旧?知识库是否及时更新?
   验证方法:随机抽查10个Chunk,人工看是否有价值

2. 切分问题
   → Chunk是否截断了关键信息?
   → Chunk大小是否合适?
   验证方法:找一个已知答案的问题,看它对应的Chunk是否被完整切分

3. Embedding问题
   → Embedding模型是否适合中文/专业领域?
   → 通用模型 vs 领域微调模型
   验证方法:用已知相关的问题-文档对,看cosine相似度分数

4. 检索问题
   → Top-K是否太小?(K=3可能不够)
   → 是否需要混合检索?
   验证方法:人工标注10个问题,看检索结果是否包含正确文档

5. Rerank问题
   → 是否需要加Rerank层?
   → Rerank模型选型是否合适?
   验证方法:对比加Rerank前后的Top-5准确率

6. Prompt问题
   → Prompt是否引导模型基于Context回答?
   → 是否有"如果Context没有相关内容,请回答不知道"的兜底?
   验证方法:看模型是否在编造Context中没有的信息(幻觉)

7. 评测体系
   → 有没有Golden Set(标准测试集)?
   → 有没有定量指标(召回率/准确率/F1)?
   验证方法:构建50个Q&A对的标准测试集,定期跑评测

实战代码:手写一个完整的RAG管道

Step 1: 文档加载和切分


@Service
public class DocumentService {

    private final VectorStore vectorStore;

    public DocumentService(VectorStore vectorStore) {
        this.vectorStore = vectorStore;
    }

    /**
     * 加载Markdown文档并切分
     */
    public void loadMarkdown(String filePath) {
        // 1. 读取文件
        Resource resource = new FileSystemResource(filePath);

        // 2. 文档加载器
        TextReader reader = new TextReader(resource);
        reader.getCustomMetadata().put("source", filePath);

        // 3. 切分
        TokenTextSplitter splitter = new TokenTextSplitter(
            800,   // chunkSize: 每个Chunk最多800 Token
            200,   // overlap: 相邻Chunk重叠200 Token
            5,     // minChunkLength: 最小Chunk长度
            10000, // maxNumChunks: 最大Chunk数量
            true   // keepSeparator: 保留分隔符
        );

        List<Document> chunks = splitter.apply(reader.get());

        // 4. 存入向量数据库(自动做Embedding)
        vectorStore.add(chunks);

        System.out.println("已索引 " + chunks.size() + " 个文档片段");
    }
}

Step 2: RAG查询


@Service
public class RagService {

    private final ChatClient chatClient;
    private final VectorStore vectorStore;

    public RagService(ChatModel chatModel, VectorStore vectorStore) {
        this.vectorStore = vectorStore;
        this.chatClient = ChatClient.builder(chatModel)
            .defaultSystem("""
                你是一个知识库助手。请严格根据以下参考资料回答用户问题。
                如果参考资料中没有相关内容,请回答"抱歉,知识库中没有找到相关信息"。
                不要编造答案。
                """)
            .build();
    }

    /**
     * 基础RAG查询
     */
    public String query(String question) {
        // 1. 向量检索
        List<Document> docs = vectorStore.similaritySearch(
            SearchRequest.builder()
                .query(question)
                .topK(5)           // 检索最相似的5个Chunk
                .similarityThreshold(0.7)  // 相似度阈值
                .build()
        );

        // 2. 拼接Context
        String context = docs.stream()
            .map(doc -> doc.getText())
            .collect(Collectors.joining("\n\n---\n\n"));

        // 3. 调用模型
        return chatClient.prompt()
            .user(userSpec -> userSpec
                .text("""
                    参考资料:
                    {context}

                    用户问题:{question}
                    """)
                .param("context", context)
                .param("question", question)
            )
            .call()
            .content();
    }
}

Step 3: 用QuestionAnswerAdvisor简化(Spring AI内置RAG)


// Spring AI内置了RAG Advisor,不用手动检索和拼接

ChatClient client = ChatClient.builder(chatModel)
    .defaultAdvisors(
        new QuestionAnswerAdvisor(vectorStore)  // 自动检索+注入
    )
    .build();

// 使用时直接问,Advisor自动做检索
String answer = client.prompt()
    .user("公司年假政策是什么?")
    .call()
    .content();

面试模拟

Q1: "你们的RAG方案召回率怎么样?怎么评测的?"

"我们构建了一个Golden Set,包含50个标准问题-答案对。

>

评测方法是:对每个问题,看检索到的Top-5文档中是否包含正确答案的来源文档(召回率),以及模型最终回答是否准确(准确率)。

>

初期纯向量检索的召回率只有65%,主要问题是专业术语检索不准。加了关键词检索做混合检索后提升到82%。然后又加了Rerank层,最终稳定在90%左右。

>

我们还做了个简单但有效的改进:在Chunk里加了文档标题和章节标题作为前缀,这样即使Chunk本身没有关键词,元数据也能帮助检索。"

Q2: "文档更新后,旧答案还在怎么办?"

"这是个常见问题——向量数据库里存着旧的Chunk,检索时还在返回过时信息。

>

我们的方案是给每个Chunk加元数据:文档ID + 更新时间 + 版本号。文档更新时:
1. 先按文档ID删除所有旧Chunk(vectorStore.delete)
2. 重新切分和索引新文档

>

这保证了同一份文档只有一个版本在向量库里。

>

更高级的方案是增量索引——只重新索引变更的部分,但实现更复杂。"

动手练习

练习1:搭建一个最小RAG系统

1. 准备3-5个Markdown文档(可以用公司FAQ或技术文档)

2. 配置PGVector:spring.ai.vectorstore.pgvector.initialize-schema=true

3. 写一个文档加载接口,上传文档并自动切分索引

4. 写一个查询接口,输入问题返回RAG回答

5. 测试:问文档中的问题,验证是否能准确回答

练习2:对比不同Chunk Size的效果

1. 分别用chunk_size=200、500、1000切分同一批文档

2. 对同样的10个问题做检索

3. 对比检索结果的相关性

下一课预告

P3-04将深入Function Calling,从工具注册到多工具编排到错误处理。