Skip to content

RAG 落地:向量库、切分与检索 ​

本篇要点:能把业务文档变成可检索的知识库,并让模型只依据检索到的片段回答。前置:《工具调用:把 Java 方法暴露给模型》用工具解决了"实时状态",这一章处理另一半——不会变成表、也不该为它写工具的静态知识。

1 为什么需要它:政策改了一版,模型还在答旧的 ​

今年 3 月,售后把大家电的无理由退货期从 7 天改成 15 天。文件发了,话术更新了,客服助手的回答没变。

上线一周,客诉 30 多起,全是"你们客服说 7 天"。查日志,模型答得斩钉截铁:"大家电支持 7 天无理由退货。"它没说错,它的训练数据里就是 7 天。

给模型补这类知识,通常有三条路。

微调。要标注数据、要训练、要评测,而且下次政策再改,整个流程重来一遍。这个活该由算法团队做,不该由业务系统做。

把政策全文塞进提示词。整个库 3200 页,每次提问光输入就上百万 token,而且每问一次付一次;更要命的是模型在长上下文里会漏读中间那几段。

检索后只塞相关的几段。用户问"空调退货几天",系统先去文档里捞出讲大家电退货的 3 段,再连同问题一起发给模型。这就是检索增强生成(RAG,Retrieval-Augmented Generation)。

第三条路要认清一点:RAG 没有让模型学会你的政策,它只是每次把几段原文递到模型眼前。所以答案对不对,七成取决于"递过去的那几段对不对"。

2 核心概念 ​

2.1 向量化与相似度 ​

定义:嵌入模型(embedding model)把一段文字映射成一串浮点数,语义相近的文字,向量也相近。检索就是算两个向量的余弦相似度,取最近的那几个。

类比:把每段话拍成地图上的一个点,问"退货"就相当于在地图上找个位置,然后捡起离它最近的点。

反例:向量不知道你的业务口径。"退货"和"退款"在向量空间里几乎重合,但一个是物流动作,一个是资金动作,流程完全不同。指望相似度替你区分业务语义,会得到"看起来相关、实际没用"的片段。

2.2 VectorStore 抽象 ​

定义:VectorStore 只有几个方法——add(List<Document>)、similaritySearch(SearchRequest)、delete(...)。SearchRequest 装四件事:查询文本、topK、similarityThreshold、filterExpression。

换库时改的是依赖和配置,不是业务代码。这是这个抽象的全部价值,别在它上面加自己的方法再到处 instanceof。

反例:只按向量检索,不加元数据过滤。库里有三个事业部、两个租户的文档,一次检索把它们混在一起送给模型,模型答得头头是道,用的是别家的政策。过滤条件(dept == 'aftersale'、tenant == 't-1024')不是优化项,是隔离手段。

2.3 切分:决定检索上限的一步 ​

定义:切分(chunking)把长文档按 token 数切成块,块是检索的最小单位。Spring AI 的 TokenTextSplitter 默认 chunkSize=800(token)、minChunkSizeChars=350、keepSeparator=true。

块太大,一块里混了三个主题,检索命中之后噪声多;块太小,一句话被切开,检索到的是半句。这个取舍没有普适答案,但有一个硬性检查:随机抽 10 块,看有没有从句子中间断开的。

反例(中文项目必踩):TokenTextSplitter 的默认断句标点是 . ? ! 和换行,中文的 。?! 不在里面。一份中文政策按默认配置切,块边界会落在任意字符上,标题和正文被切开,"第 3 条"和它的内容分到两块。解决办法是 withPunctuationMarks(List.of('。','?','!',';')),这件事没有任何报错会提醒你。

2.4 检索增强 Advisor ​

定义:QuestionAnswerAdvisor 是一个 Advisor,在请求发往模型之前插入一步:拿当前用户消息去 VectorStore 检索,把命中的片段拼进用户消息,再交给模型。

它适合"一个知识库、一次检索、直接回答"的场景。需要改写查询、多路检索、重排的时候,用 RetrievalAugmentationAdvisor 把检索流程拆成模块自己拼。

反例:把 topK 设成 20。你以为给了模型更多信息,实际是给它 20 段里 17 段无关的内容,还把成本抬上去。4 到 6 段通常够用,剩下的靠阈值和重排筛。

图 5-1 是两条链:离线入库跑一次,在线检索每次提问都跑。

图 5-1 RAG 的两条链:入库这侧决定上限,检索这侧决定这一次能不能命中

选哪个向量库,先看手上已经有什么,见表 5-1。

表 5-1 三种常见 VectorStore 的取舍(截至 2026 年 11 月,均为系列级说明)

选项什么时候选它要提前知道的限制
PGVector已经在用 PostgreSQL,chunk 在百万级以内,需要和业务表 join、要事务HNSW 索引最多支持 2000 维;dimensions 定了之后改维度要重建表
Redis(Redis Stack)已有 Redis,要求毫秒级检索,靠 TTL 管短期知识内存单价高;需要 Redis Stack 的 Query Engine 与 JSON 模块,普通 Redis 装不了
Milvuschunk 上千万,要独立扩缩容、要试多种索引多一套要运维的集群,小项目上是纯负担

2.5 混合检索与重排 ​

向量检索擅长"意思相近",不擅长精确串。用户报订单号 SO202611160001、问型号 KFR-35GW,这类串会被 tokenizer 切碎,向量相似度基本是噪声;关键词检索(BM25)反而一查一个准。

混合检索就是两路都跑,再融合。融合算法里最省事的是倒数排名融合(RRF,Reciprocal Rank Fusion):只看排名不看分数,score = Σ 1/(60 + rank)。好处是不用把余弦距离和 BM25 分数归一化——这两个量纲根本没法直接比。

重排(rerank)是第二道筛子:把召回的 20 段交给一个交叉编码器(cross-encoder),它对"问题 + 片段"逐对打分,比向量点积准得多,也慢得多。所以它只处理召回后的少量候选,不参与全库检索。

3 动手实践:把政策库建起来 ​

3.1 依赖与建表 ​

xml
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.ai</groupId>
      <artifactId>spring-ai-bom</artifactId>
      <version>1.1.8</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<dependencies>
  <dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-starter-model-openai</artifactId>
  </dependency>
  <!-- 向量库:PGVector -->
  <dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-starter-vector-store-pgvector</artifactId>
  </dependency>
  <!-- QuestionAnswerAdvisor 在这个包里 -->
  <dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-advisors-vector-store</artifactId>
  </dependency>
</dependencies>
yaml
spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/aftersale
    username: postgres
    password: postgres
  ai:
    vectorstore:
      pgvector:
        index-type: HNSW
        distance-type: COSINE_DISTANCE
        dimensions: 1536
        table-name: policy_chunk
        # 默认是 false。第一次建表要显式打开,之后关掉,别让应用有建表权限
        initialize-schema: true

建表这一步是显式 opt-in 的。早期版本默认帮你建,现在不会了——initialize-schema 忘了写,第一次 add 会在 SQL 层报 relation 不存在。

3.2 入库:读、切、写 ​

java
package top.mqxu.ai.rag;

import org.springframework.ai.document.Document;
import org.springframework.ai.reader.TextReader;
import org.springframework.ai.transformer.splitter.TokenTextSplitter;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.core.io.Resource;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class PolicyIngestService {

    private final VectorStore vectorStore;

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

    public int ingest(Resource policyFile, String tenant, String dept, String effectiveFrom) {
        TextReader reader = new TextReader(policyFile);
        // 元数据会跟着每个 chunk 走,检索时用来做隔离和时效过滤
        reader.getCustomMetadata().put("tenant", tenant);
        reader.getCustomMetadata().put("dept", dept);
        reader.getCustomMetadata().put("effectiveFrom", effectiveFrom);
        reader.getCustomMetadata().put("docType", "policy");

        List<Document> raw = reader.read();

        TokenTextSplitter splitter = TokenTextSplitter.builder()
                .withChunkSize(400)             // 政策类文档,一块 400 token 左右
                .withMinChunkSizeChars(200)
                .withKeepSeparator(true)
                // 关键一行:中文断句标点,默认值里没有中文句号
                .withPunctuationMarks(List.of('。', '?', '!', ';'))
                .build();

        List<Document> chunks = splitter.apply(raw);
        vectorStore.add(chunks);
        return chunks.size();
    }
}

运行结果(java -jar 启动后调用一次,日志节选):

text
2026-11-16T19:41:02.118  INFO  PolicyIngestService : 入库完成,源文档 1 个,chunk 9 个
2026-11-16T19:41:02.119  DEBUG PolicyIngestService : chunk[0] len=392 source=aftersale-policy.txt tenant=t-1024 dept=aftersale
2026-11-16T19:41:02.120  DEBUG PolicyIngestService : chunk[1] len=401 ... 起首="第三章 大家电类目",末尾="自签收之日起 15 日内"

同一份文件不加 withPunctuationMarks 会切出 11 个 chunk,其中 4 个的起首是半句话,例如"内可申请无理由退货,需保持包装完整。"——前半句在上一块里。这类错误不会抛异常,只会在用户问到边界条件时给出半截答案。

3.3 检索:阈值、过滤、引用 ​

java
package top.mqxu.ai.rag;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.client.advisor.vectorstore.QuestionAnswerAdvisor;
import org.springframework.ai.vectorstore.SearchRequest;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.stereotype.Service;

@Service
public class PolicyQaService {

    private final ChatClient chatClient;
    private final QuestionAnswerAdvisor advisor;

    public PolicyQaService(ChatClient.Builder builder, VectorStore vectorStore) {
        this.advisor = QuestionAnswerAdvisor.builder(vectorStore)
                .searchRequest(SearchRequest.builder()
                        .topK(6)
                        .similarityThreshold(0.55)   // 低于这个分的不进上下文
                        .build())
                .build();
        this.chatClient = builder
                .defaultSystem("""
                        只依据提供的资料回答。资料里没有的,回答“我在现有政策里没找到这条”,
                        不要用常识补充。回答末尾用【文件名 第N条】标出依据。""")
                .build();
    }

    public String ask(String tenant, String dept, String question) {
        // tenant / dept 从登录态取,且只允许库里存在的枚举值,不拼请求参数
        String filter = "tenant == '" + tenant + "' && dept == '" + dept + "'";
        return this.chatClient.prompt()
                .user(question)
                .advisors(this.advisor)
                // 每次请求单独注入过滤条件,防止跨租户串数据
                .advisors(a -> a.param(QuestionAnswerAdvisor.FILTER_EXPRESSION, filter))
                .call()
                .content();
    }
}

运行结果:

text
$ curl -s 'localhost:8080/api/policy/ask?q=空调退货几天'
空调属于大家电类目,自签收之日起 15 日内可申请无理由退货,需保持包装完整、配件齐全。
若已安装,需先拆机并承担上门费。【aftersale-policy.txt 第三章 第 3.2 条】

这里的 tenant 来自登录态,不是请求头。过滤表达式是拼字符串的,谁把请求参数拼进去,就等于把过滤器的钥匙递给了调用方——一个 ' || tenant == ' 就能把别家文档捞出来。取值必须限定在白名单里。

同一句话,把 tenant 换成另一个事业部的值,返回的是"现有政策里没找到"。这就是元数据过滤该起的作用:不是让答案更准,是让不该看见的文档根本不进候选集。

阈值 0.55 是这份语料上试出来的。换嵌入模型必须重新试——不同模型的相似度分布不一样,0.55 在 A 模型上筛掉三成,在 B 模型上可能一段都不剩。这个数没有通用值。

图 5-1 里那一步重排,这段代码并没有做:QuestionAnswerAdvisor 只负责"检索 + 拼接",没留重排的口子。要接交叉编码器,得换 RetrievalAugmentationAdvisor,把重排写成一个 DocumentPostProcessor 挂上去。先不做也说得过去——召回 6 段直接给模型,比召回 6 段再排错顺序要安全。

3.4 混合检索:两路结果用 RRF 合并 ​

java
package top.mqxu.ai.rag;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

public final class ReciprocalRankFusion {

    private static final int K = 60;   // 原论文的平滑常数,60 是常用取值

    private ReciprocalRankFusion() {
    }

    /** rankings 里每个列表已按各自的相关性从高到低排好,这里只用名次 */
    public static List<String> fuse(List<List<String>> rankings, int topN) {
        Map<String, Double> score = new LinkedHashMap<>();
        for (List<String> ranking : rankings) {
            for (int i = 0; i < ranking.size(); i++) {
                score.merge(ranking.get(i), 1.0 / (K + i + 1), Double::sum);
            }
        }
        List<String> fused = new ArrayList<>(score.keySet());
        fused.sort(Comparator.comparingDouble((String id) -> score.get(id)).reversed());
        return fused.subList(0, Math.min(topN, fused.size()));
    }

    public static void main(String[] args) {
        List<String> bm25 = List.of("policy-07", "policy-03", "policy-11");
        List<String> vector = List.of("policy-03", "policy-11", "policy-07");
        System.out.println(fuse(List.of(bm25, vector), 3));
    }
}

运行结果:

text
[policy-03, policy-07, policy-11]

两条路各自的第一名不同(BM25 选 07,向量选 03),融合后 03 排第一:它在两路里都是前两名。RRF 的全部逻辑就是这一句——两路都认可的结果排前面。它不需要知道余弦距离是 0.61 还是 BM25 得了 12.4 分,这也是它能在异构检索器之间通用的原因。

4 常见误解 ​

「块切得越小,检索越准。」块小了确实更容易命中,但命中之后模型拿到的是半句话。真正决定效果的是"一块是不是一个完整意思",不是"一块有多少 token"。验收方法不是看块数,是随机抽 10 块人工读一遍。

「相似度高就说明这段能用。」余弦相似度衡量的是语义接近,不是答案正确。政策库里同时存在 2024 版和 2026 版,两段都讲"退货期",向量距离也几乎一样,模型可能挑中旧的那版。版本和时效必须靠元数据过滤解决,靠相似度解决不了。

「上了 RAG 就不用改提示词。」检索只负责把资料递过去,怎么用资料是提示词的事。没有"只依据资料回答、没有就说没找到"这句约束,模型会把检索结果和训练记忆混着用,而且混得很自信。

5 小结 ​

  • RAG 不改变模型的知识,它只改变这一次请求里模型能看到什么。答案质量的上限在入库阶段就定了:切分和元数据没做好,后面调阈值救不回来。
  • VectorStore 是薄抽象,选型的依据是团队已有的运维能力,不是基准测试排名。PGVector 适合已经跑着 PostgreSQL 的团队。
  • 中文文档必须显式配置断句标点。TokenTextSplitter 默认只认英文句号问号感叹号,这件事不报错。
  • 元数据过滤是隔离手段,不是性能优化。租户、部门、生效日期都要进过滤条件。
  • 精确串(订单号、型号、条款号)靠关键词检索,语义靠向量,两路用 RRF 合并;重排只处理召回后的少量候选。

6 相关文章 ​

到这里,工具让模型能读实时数据,检索让模型能读文档。但只要模型还在你的进程里跑,能力就锁在这一个应用里——IDE 插件、桌面客户端、别的团队的 Agent 都用不上。

《MCP Server:让模型安全调用 Java 业务能力》把《工具调用:把 Java 方法暴露给模型》的工具搬到一个协议后面:MCP。你会看到同一批 @Tool 方法换成 @McpTool 之后,工具调用从"进程内反射"变成"跨进程 JSON-RPC",而《工具调用:把 Java 方法暴露给模型》画的四个检查点一个都不能少,还多出传输层鉴权和沙箱。