RAG 答非所问?Java 混合检索加重排序
知识库里明明躺着一条
ERR_CONN_4021的处理文档,用户问起这个错误码,RAG 却把“连接超时的通用排查”回了一遍。答案看着挺像那么回事,就是没用。这类问题不是模型笨,是检索这一层漏了。纯向量检索只认“意思像”,不认“字面一模一样”。今天我们把这个洞补上:用 BM25 抓精确词,用向量抓语义,用 RRF 把两路结果合起来,最后让模型对候选做一次重排序。全是 Java,核心逻辑两百行左右。
一、这个问题到底是什么
向量检索擅长“意思相近”,不擅长“字符串相同”,这是它的设计决定的,不是配置问题。
把文档变成向量的过程,是把一整段话压成一千多个浮点数。压缩的时候,模型保留的是语义轮廓:“连接超时”和“连接池满了”在向量空间里离得很近,因为它们讲的是同一类事。代价是细节被磨平了。ERR_CONN_4021 这种字符串,在训练语料里出现次数极少,模型没学过它有多重要,压完之后它跟“某个错误码”没什么区别。
于是就有了那个经典场面:
- 用户问:
ERR_CONN_4021 是什么错误?服务一直在重试 - 向量检索返回:连接超时和读超时要分开看 / 重试要用指数退避 / 网关 502 怎么排查
- 真正该返回的那条,讲 4021 的,排在第五名开外
三条返回里两条都在讲“重试”,看起来高度相关,实际上没有一条回答了“4021 是什么”。模型拿着这三条去组织语言,只能编出一个听起来合理的答案。这就是 RAG 里最难发现的一类错误——检索错了,但错得很像对的。
判断一个查询属于哪一类,有个土办法:把问题里的专有名词全删掉,剩下的句子还成立吗?
| 查询 | 删掉专有名词后 | 类型 | 靠什么检索 |
|---|---|---|---|
| 服务连接不上怎么办 | 还能问,语义完整 | 语义型 | 向量 |
ERR_CONN_4021 是什么 |
只剩“是什么”,没法问 | 实体型 | 关键词 |
| 4021 报错要不要重试 | 还剩“报错要不要重试” | 混合型 | 两路都要 |
真实业务里,第三类最多。客服问订单号,运维问错误码,电商问 SKU,法务问条款编号——全是“语义 + 实体”的混合体。只上向量检索,等于把实体那一半直接扔了。
二、底层原理到底怎么回事
混合检索的本质,是让两条互补的召回路径各干各擅长的事,再用排名融合把结果拼起来,最后用重排序做一次精排。
拆成四步看。
2.1 向量检索:按含义找
文档先过 embedding 模型变成向量,查询也变成向量,然后算余弦相似度——两个向量夹角越小,意思越接近。
它的强项是“换了说法也能找到”。用户说“扣了两次钱”,文档写“重复扣款”,字面一个词都不重合,向量照样能对上。弱项也在这儿:它对面“字面”完全不敏感。错误码、型号、人名、函数名,这些靠的是精确字符匹配,语义模型帮不上忙。
工程上还有个现实约束:向量检索通常走 ANN 近似索引,为了速度牺牲一点召回。topK 给小了,正确答案压根进不了候选池,后面再好的模型也救不回来。
2.2 BM25:按词找
BM25 是搜索引擎用了几十年的经典算法。它给“文档和查询的匹配程度”打分,分数由三个因子决定:
score = IDF(词) × [ tf × (k1+1) ] / [ tf + k1 × (1 - b + b × 文档长度/平均长度) ]
翻译成人话:
- tf(词频):这个词在这篇文档里出现几次。出现越多越相关,但收益递减——出现十次不比出现五次强一倍,
k1就是控制这个饱和速度的旋钮。 - IDF(逆文档频率):这个词在全库里有多稀有。
ERR_CONN_4021只在两篇文档里出现,权重就高;“的”“是”满库都是,权重趋近于零。这是 BM25 能抓住错误码的根本原因。 - 长度归一化:长文档天然更容易命中词,得压一压。
b控制压制力度,0.75 是常用值。
BM25 不需要模型、不需要 GPU、不花钱,纯内存计算,几万篇文档也是毫秒级。它的死穴是“不懂同义词”——用户说“扣了两次钱”,文档写“重复扣款”,零命中。
中文还有个坑:BM25 靠空格切词,中文没空格。上分词器(IK、jieba)当然可以,但要多引一个依赖、多维护一份词典。轻量做法是按字切 bigram:把“连接池满了”切成 连接、接池、池满、满了。粗是粗了点,但对错误码、专有名词这类查询,效果比想象中好,而且零依赖。我们的示例代码就走这条路。
2.3 RRF:把两路排名合起来
问题来了:向量检索给的是 0 到 1 的余弦相似度,BM25 给的是没有上界的分数,两个数根本不能相加。硬加权只会变成调参地狱。
RRF(Reciprocal Rank Fusion)绕开了这个问题——它不看分数,只看排名:
RRF(d) = Σ 1 / (k + rank_i(d))
一篇文档在每一路里的名次,取倒数加起来。k 通常取 60,作用是压平头部差距,避免某一路的第一名一家独大。
好处很直接:不管两路分数量纲差多远,只要“排在前面的更可信”这个假设成立,融合就有效。而且它对单路的异常分数天然免疫——某一路给出一个荒谬的高分,RRF 完全不关心。
一篇文档如果在向量里排第 2、在 BM25 里排第 1,得分是 1/62 + 1/61 ≈ 0.0325;另一篇只在向量里排第 1,得分是 1/61 ≈ 0.0164。两路都认可的,稳压单路第一。这正是我们要的效果:错误码文档靠 BM25 进榜,语义文档靠向量进榜,两路都对的排最前。
2.4 重排序:精度换延迟
融合之后的候选池大概 8 到 20 条,但它们只是“可能相关”。真正的排序要靠重排序模型。
区别在计算方式:向量检索是 bi-encoder,问题和文档各自算向量,从没见过面,所以快但粗。重排序是 cross-encoder(或者干脆让大模型来判断),把“问题 + 文档”一起喂进去,逐字比对,精度高一个档次,但每对都要算一次,慢且贵。
所以工业界的标准做法是两阶段漏斗:
- 召回阶段用便宜的方法(向量 + BM25)从十万篇里捞 20 条
- 精排阶段用贵的方法只对这 20 条打分,取前 3
永远不要用大模型对全库排序,那是烧钱。候选 20 条、最终留 3 条,是成本和效果比较平衡的位置。
三、实战:手把手写代码
先看依赖。用 Maven 建一个普通 Java 项目,不需要 Spring。
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>rag-hybrid</artifactId>
<version>1.0.0</version>
<properties>
<maven.compiler.release>21</maven.compiler.release>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>dev.langchain4j</groupId>
<artifactId>langchain4j</artifactId>
<version>1.22.0</version>
</dependency>
<dependency>
<groupId>dev.langchain4j</groupId>
<artifactId>langchain4j-open-ai</artifactId>
<version>1.22.0</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
<version>2.0.20</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.16.0</version>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>3.6.4</version>
<configuration>
<mainClass>com.example.rag.Main</mainClass>
</configuration>
</plugin>
</plugins>
</build>
</project>
langchain4j 是核心包,里面有 EmbeddingModel、Content、ReciprocalRankFuser 这些我们直接用的东西;langchain4j-open-ai 提供 OpenAI 协议的实现,任何兼容 OpenAI 接口的服务(DashScope 兼容模式、vLLM、Ollama 的 OpenAI 端点)都能接。
3.1 语料:十二篇运维文档
package com.example.rag;
import dev.langchain4j.data.segment.TextSegment;
import java.util.List;
public final class Corpus {
private Corpus() {
}
public static List<TextSegment> load() {
return List.of(
TextSegment.from("ERR_CONN_4021:上游连接池耗尽。常见触发场景是下游响应变慢,连接归还不上。"
+ "处理步骤:先看连接池活跃连接数和等待队列长度;临时调大 maxPoolSize 只能缓解,"
+ "根因通常是下游 P99 变长。"),
TextSegment.from("ERR_CONN_4021 在旧版网关里表示连接池满,新版网关把这个错误改成了 ERR_CONN_4031,"
+ "排查日志时两个错误码都可能出现,看网关版本号区分。"),
TextSegment.from("连接超时和读超时要分开看。连接超时说明 TCP 握手没完成,读超时说明连上了但对方不返回数据。"
+ "前者查网络和 DNS,后者查下游处理耗时。"),
TextSegment.from("重试策略建议:只对幂等接口重试,最多 3 次,退避用指数退避加随机抖动。"
+ "对非幂等的写接口重试会造成重复扣款。"),
TextSegment.from("HTTP 429 是限流响应,说明请求发太快了。收到 429 应该降低发送速率,"
+ "而不是立刻重试,否则会放大拥塞。"),
TextSegment.from("网关 502 通常是上游进程挂了或者端口没起来,503 是上游过载或被摘除。"
+ "两者都要先看健康检查结果。"),
TextSegment.from("线程池打满的表现是任务排队、接口 RT 上涨但 CPU 不高。"
+ "先看队列长度和拒绝策略,不要一上来就加线程数。"),
TextSegment.from("DNS 解析失败也会表现为连接超时,因为拿不到 IP 就建不了连接。"
+ "排查时用 dig 对比宿主机和容器内的解析结果。"),
TextSegment.from("TLS 握手失败常见原因是证书过期或证书链不完整。"
+ "用 openssl s_client 可以看到完整的握手过程。"),
TextSegment.from("全链路追踪里 traceId 串不起来,多半是异步线程没有传递 MDC,"
+ "或者跨服务调用时没透传 header。"),
TextSegment.from("发版回滚要先摘流量再回滚,避免新旧版本同时处理同一批请求。"),
TextSegment.from("JVM GC 停顿会导致接口偶发超时,看 GC 日志里的 pause 时间,"
+ "老年代回收频繁说明堆内存不够或者有内存泄漏。")
);
}
}
这十二篇是刻意设计的:第 1、2 篇是错误码专属文档,第 3、4、5、6 篇是“语义相邻但答非所问”的干扰项。真实知识库里干扰项只会更多。
3.2 向量检索:算余弦,取前 K
package com.example.rag;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.model.embedding.EmbeddingModel;
import dev.langchain4j.rag.content.Content;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
public class VectorRetriever {
private final EmbeddingModel embeddingModel;
private final List<TextSegment> segments;
private final List<float[]> vectors;
public VectorRetriever(EmbeddingModel embeddingModel, List<TextSegment> segments) {
this.embeddingModel = embeddingModel;
this.segments = segments;
this.vectors = new ArrayList<>();
for (TextSegment segment : segments) {
vectors.add(embeddingModel.embed(segment).content().vector());
}
}
public List<Content> retrieve(String query, int topK) {
float[] queryVector = embeddingModel.embed(query).content().vector();
List<Scored> scored = new ArrayList<>();
for (int i = 0; i < segments.size(); i++) {
scored.add(new Scored(segments.get(i), cosine(queryVector, vectors.get(i))));
}
scored.sort(Comparator.comparingDouble(Scored::score).reversed());
return scored.stream()
.limit(topK)
.map(scoredSegment -> Content.from(scoredSegment.segment()))
.toList();
}
private static double cosine(float[] a, float[] b) {
double dot = 0.0;
double normA = 0.0;
double normB = 0.0;
for (int i = 0; i < a.length; i++) {
dot += (double) a[i] * b[i];
normA += (double) a[i] * a[i];
normB += (double) b[i] * b[i];
}
if (normA == 0.0 || normB == 0.0) {
return 0.0;
}
return dot / (Math.sqrt(normA) * Math.sqrt(normB));
}
private record Scored(TextSegment segment, double score) {
}
}
构造函数里把所有文档的向量算好存内存——示例数据量小,这么做最直观。生产环境这一步换成向量数据库,retrieve 方法里的循环变成一次 search 调用,其余逻辑不动。
返回类型是 Content 而不是 TextSegment,因为后面要交给 ReciprocalRankFuser 融合,它认的就是 Content。
3.3 关键词检索:手写 BM25
package com.example.rag;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.rag.content.Content;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
public class Bm25Retriever {
private static final double K1 = 1.2;
private static final double B = 0.75;
private final List<TextSegment> segments;
private final List<Map<String, Integer>> termFrequencies = new ArrayList<>();
private final Map<String, Integer> documentFrequencies = new HashMap<>();
private final List<Integer> lengths = new ArrayList<>();
private final double averageLength;
public Bm25Retriever(List<TextSegment> segments) {
this.segments = segments;
for (TextSegment segment : segments) {
List<String> tokens = tokenize(segment.text());
Map<String, Integer> tf = new HashMap<>();
for (String token : tokens) {
tf.merge(token, 1, Integer::sum);
}
termFrequencies.add(tf);
lengths.add(tokens.size());
for (String token : tf.keySet()) {
documentFrequencies.merge(token, 1, Integer::sum);
}
}
this.averageLength = lengths.stream().mapToInt(Integer::intValue).average().orElse(1.0);
}
public List<Content> retrieve(String query, int topK) {
Set<String> queryTerms = new LinkedHashSet<>(tokenize(query));
List<Scored> scored = new ArrayList<>();
for (int i = 0; i < segments.size(); i++) {
Map<String, Integer> tf = termFrequencies.get(i);
int length = lengths.get(i);
double score = 0.0;
for (String term : queryTerms) {
int frequency = tf.getOrDefault(term, 0);
if (frequency == 0) {
continue;
}
int df = documentFrequencies.getOrDefault(term, 0);
double idf = Math.log(1.0 + (segments.size() - df + 0.5) / (df + 0.5));
double denominator = frequency + K1 * (1 - B + B * length / averageLength);
score += idf * (frequency * (K1 + 1)) / denominator;
}
if (score > 0) {
scored.add(new Scored(segments.get(i), score));
}
}
scored.sort(Comparator.comparingDouble(Scored::score).reversed());
return scored.stream()
.limit(topK)
.map(scoredSegment -> Content.from(scoredSegment.segment()))
.toList();
}
static List<String> tokenize(String text) {
String lower = text.toLowerCase(Locale.ROOT);
List<String> tokens = new ArrayList<>();
StringBuilder ascii = new StringBuilder();
StringBuilder cjk = new StringBuilder();
for (int i = 0; i < lower.length(); i++) {
char c = lower.charAt(i);
if (c >= 0x4E00 && c <= 0x9FFF) {
flushAscii(ascii, tokens);
cjk.append(c);
} else if ((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '_' || c == '.' || c == '-') {
flushCjk(cjk, tokens);
ascii.append(c);
} else {
flushAscii(ascii, tokens);
flushCjk(cjk, tokens);
}
}
flushAscii(ascii, tokens);
flushCjk(cjk, tokens);
return tokens;
}
private static void flushAscii(StringBuilder buffer, List<String> tokens) {
if (buffer.length() > 0) {
tokens.add(buffer.toString());
buffer.setLength(0);
}
}
private static void flushCjk(StringBuilder buffer, List<String> tokens) {
if (buffer.length() == 0) {
return;
}
String run = buffer.toString();
buffer.setLength(0);
if (run.length() == 1) {
tokens.add(run);
return;
}
for (int i = 0; i < run.length() - 1; i++) {
tokens.add(run.substring(i, i + 2));
}
}
private record Scored(TextSegment segment, double score) {
}
}
三个关键点,值得单独说:
切词规则。 ASCII 字母、数字、下划线、点、连字符连在一起算一个词,所以 ERR_CONN_4021 是一个完整 token,不会被拆碎。中文连续段走 bigram,切出相邻两字。两种字符交界处强制分段,避免 4021是什么 粘成一个 token。
IDF 的位置。 它乘在每一项上,所以只在少量文档出现的词会主导分数。err_conn_4021 只出现在 2 篇里,IDF 很高;“连接”“超时”这类词在七八篇里都有,IDF 低。结果就是精确匹配的文档天然排前面,不需要任何额外规则。
分数为 0 直接丢弃。 一个词都没命中的文档不该出现在关键词结果里,否则它会以“最后一名”的身份混进 RRF,白占一个位置。
3.4 用大模型做重排序
LangChain4j 的 ScoringModel 接口就是为这件事准备的:给它一批文档和一个查询,它返回一组分数。
package com.example.rag;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.model.chat.ChatModel;
import dev.langchain4j.model.output.Response;
import dev.langchain4j.model.scoring.ScoringModel;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class LlmScoringModel implements ScoringModel {
private static final Pattern SCORE_LINE = Pattern.compile("(\\d+)\\s*[::]\\s*(\\d+(?:\\.\\d+)?)");
private final ChatModel chatModel;
public LlmScoringModel(ChatModel chatModel) {
this.chatModel = chatModel;
}
@Override
public Response<List<Double>> scoreAll(List<TextSegment> segments, String query) {
if (segments.isEmpty()) {
return Response.from(Collections.<Double>emptyList());
}
List<Double> scores = new ArrayList<>(Collections.nCopies(segments.size(), 0.0));
String answer = chatModel.chat(buildPrompt(segments, query));
for (String line : answer.split("\\R")) {
Matcher matcher = SCORE_LINE.matcher(line);
if (!matcher.find()) {
continue;
}
int index = Integer.parseInt(matcher.group(1)) - 1;
if (index >= 0 && index < scores.size()) {
scores.set(index, Double.parseDouble(matcher.group(2)));
}
}
return Response.from(scores);
}
private static String buildPrompt(List<TextSegment> segments, String query) {
StringBuilder prompt = new StringBuilder();
prompt.append("你在给检索结果打分,判断每段资料能否回答用户的问题。\n");
prompt.append("用户问题:").append(query).append("\n\n");
for (int i = 0; i < segments.size(); i++) {
prompt.append("[").append(i + 1).append("] ").append(segments.get(i).text()).append("\n\n");
}
prompt.append("只输出 ").append(segments.size()).append(" 行,每行写成 序号:分数。\n");
prompt.append("分数取 0 到 10 的整数:0 表示完全无关,10 表示直接回答了问题。\n");
prompt.append("不要输出任何解释,不要重复原文。");
return prompt.toString();
}
}
scoreAll 是整个接口里唯一必须实现的方法,一次调用给全部文档打分——不是循环调 N 次。这一点很重要,N 次调用意味着 N 倍延迟和 N 倍费用。
解析用正则容错:模型偶尔会写成 1:8(中文冒号)或者 1: 8(多一个空格),正则两种都吃。解析不出来的行跳过,对应文档得 0 分,降级而不是抛异常——重排序挂了不该让整个问答挂掉。
3.5 融合与串联
package com.example.rag;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.model.scoring.ScoringModel;
import dev.langchain4j.rag.content.Content;
import dev.langchain4j.rag.content.aggregator.ReciprocalRankFuser;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
public class HybridSearcher {
private final VectorRetriever vectorRetriever;
private final Bm25Retriever bm25Retriever;
private final ScoringModel scoringModel;
public HybridSearcher(VectorRetriever vectorRetriever, Bm25Retriever bm25Retriever, ScoringModel scoringModel) {
this.vectorRetriever = vectorRetriever;
this.bm25Retriever = bm25Retriever;
this.scoringModel = scoringModel;
}
public List<Content> search(String query, int candidateK, int finalK) {
List<Content> vectorHits = vectorRetriever.retrieve(query, candidateK);
List<Content> keywordHits = bm25Retriever.retrieve(query, candidateK);
List<Content> fused = ReciprocalRankFuser.fuse(List.of(vectorHits, keywordHits));
List<Content> candidates = fused.stream().limit(candidateK).toList();
if (candidates.isEmpty()) {
return List.of();
}
List<TextSegment> segments = candidates.stream().map(Content::textSegment).toList();
List<Double> scores = scoringModel.scoreAll(segments, query).content();
List<Ranked> ranked = new ArrayList<>();
for (int i = 0; i < candidates.size(); i++) {
double score = i < scores.size() ? scores.get(i) : 0.0;
ranked.add(new Ranked(candidates.get(i), score));
}
ranked.sort(Comparator.comparingDouble(Ranked::score).reversed());
return ranked.stream()
.limit(finalK)
.map(Ranked::content)
.toList();
}
private record Ranked(Content content, double score) {
}
}
ReciprocalRankFuser.fuse() 是 LangChain4j 自带的实现,默认 k 取 60。两路各取 8 条,融合后去重,再截到 8 条进重排序——候选数要大于最终返回数,否则重排序没有腾挪空间。
3.6 跑起来
package com.example.rag;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.model.chat.ChatModel;
import dev.langchain4j.model.embedding.EmbeddingModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.model.openai.OpenAiEmbeddingModel;
import dev.langchain4j.model.scoring.ScoringModel;
import dev.langchain4j.rag.content.Content;
import java.util.List;
public class Main {
public static void main(String[] args) {
String apiKey = System.getenv("OPENAI_API_KEY");
if (apiKey == null || apiKey.isBlank()) {
throw new IllegalStateException("先设置环境变量 OPENAI_API_KEY");
}
String baseUrl = System.getenv().getOrDefault("OPENAI_BASE_URL", "https://api.openai.com/v1");
String chatModelName = System.getenv().getOrDefault("CHAT_MODEL", "gpt-4o-mini");
String embeddingModelName = System.getenv().getOrDefault("EMBEDDING_MODEL", "text-embedding-3-small");
ChatModel chatModel = OpenAiChatModel.builder()
.baseUrl(baseUrl)
.apiKey(apiKey)
.modelName(chatModelName)
.temperature(0.0)
.build();
EmbeddingModel embeddingModel = OpenAiEmbeddingModel.builder()
.baseUrl(baseUrl)
.apiKey(apiKey)
.modelName(embeddingModelName)
.build();
List<TextSegment> corpus = Corpus.load();
VectorRetriever vectorRetriever = new VectorRetriever(embeddingModel, corpus);
Bm25Retriever bm25Retriever = new Bm25Retriever(corpus);
ScoringModel scoringModel = new LlmScoringModel(chatModel);
String question = "ERR_CONN_4021 是什么错误?服务一直在重试,要不要紧?";
System.out.println("=== 只用向量检索 ===");
print(vectorRetriever.retrieve(question, 3));
System.out.println("\n=== 只用关键词检索 ===");
print(bm25Retriever.retrieve(question, 3));
HybridSearcher searcher = new HybridSearcher(vectorRetriever, bm25Retriever, scoringModel);
List<Content> finalHits = searcher.search(question, 8, 3);
System.out.println("\n=== 混合检索 + 重排序 ===");
print(finalHits);
System.out.println("\n=== 最终回答 ===");
System.out.println(answer(chatModel, question, finalHits));
}
private static String answer(ChatModel chatModel, String question, List<Content> hits) {
StringBuilder prompt = new StringBuilder();
prompt.append("只根据下面的资料回答问题。资料里没有的内容,直接说不知道。\n\n");
for (int i = 0; i < hits.size(); i++) {
prompt.append("资料").append(i + 1).append(":")
.append(hits.get(i).textSegment().text()).append("\n\n");
}
prompt.append("问题:").append(question);
return chatModel.chat(prompt.toString());
}
private static void print(List<Content> hits) {
for (int i = 0; i < hits.size(); i++) {
String text = hits.get(i).textSegment().text();
String preview = text.length() > 40 ? text.substring(0, 40) + "..." : text;
System.out.println((i + 1) + ". " + preview);
}
}
}
用 DashScope 的兼容模式跑,换两个环境变量就行:
export OPENAI_BASE_URL="https://dashscope.aliyuncs.com/compatible-mode/v1"
export OPENAI_API_KEY="你的key"
export CHAT_MODEL="qwen-plus"
export EMBEDDING_MODEL="text-embedding-v3"
mvn -q compile exec:java
跑完你会看到三段输出。第一段(纯向量)里,排前面的通常是“连接超时和读超时要分开看”“重试策略建议”这类语义邻居,4021 的那两篇不一定进前三。第二段(纯 BM25)反过来,前两条直接就是错误码文档,但语义型的问法它会漏。第三段(混合 + 重排序)把两边都收进来,再让模型判断哪条真正回答了“4021 是什么”——错误码文档被顶到第一。
具体顺序会随 embedding 模型和文档措辞浮动,但趋势是稳定的:单路都有明显短板,融合之后短板被补上。
四、踩坑经验和最佳实践
候选数给太小,融合等于没做。 见过有人两路各取 3 条来融合,结果两路高度重叠,融合前后一模一样。每路至少 20 条,融合后取 10 到 20 条进重排序。这不是浪费,重排序就是用来从噪音里挑信号的。
重排序候选别超过 30 条。 一次请求要把所有候选塞进上下文,20 条 300 字的文档就是 6000 字,成本和延迟都上去了。超过这个量,先反思召回阶段是不是太松。
文档要切碎,不切没法重排。 一篇 3000 字的文档,重排序模型很难判断“这段到底相不相关”,因为它里面啥都有一点。切成 300 到 500 字一段,每段主题单一,打分才有区分度。切分时保留一点重叠(50 字左右),避免答案被切在边界上。
大模型打分要 temperature 0。 同一批文档打两次分,顺序变了,你的检索结果就抖了。重排序是判断题不是创作题,不需要任何随机性。另外必现的一个坑:模型不按格式输出,加一句“不要输出解释”能挡掉八成。
停用词和数字要区别对待。 4021 这种纯数字,BM25 会给它很高的 IDF(因为稀有),这是好事。但订单号、时间戳这类数字如果被切碎,会产生大量无意义的匹配。真实项目里,正则提取出的实体应该单独加权,而不是指望通用分词。
embedding 要缓存。 十二篇文档每次启动重算一遍,开发时无所谓,生产环境是灾难。文档入库时算一次存起来,查询时只算查询那一条。增量更新时按文档 ID 删旧向量、插新向量,别全量重建。
RRF 的 k 值别乱调。 默认 60 是论文里的经验值,覆盖面广。有人喜欢调到 10,想让头部更突出,结果单路的第一名把另一路的优质结果全压下去了。除非你有明确的评测集,否则别动。
别把重排序当成万能药。 如果召回阶段压根没把正确文档捞进来,重排序再准也变不出来。先保证召回率,再谈精排。判断方法很土:拿 50 个真实问题,人工标出正确答案,看它进没进候选池。进不去,问题在召回;进去了但没排前面,问题在排序。
五、性能对比和技术选型
先把四种方案摆一起。延迟是量级估算,具体数字取决于模型和部署方式,但比例关系是可靠的。
| 方案 | 精确词匹配 | 同义改写 | 延迟量级 | 成本 | 适合场景 |
|---|---|---|---|---|---|
| 纯向量 | 弱 | 强 | 几十毫秒 | 每次查询一次 embedding | 口语化问答、语义搜索 |
| 纯 BM25 | 强 | 无 | 毫秒级 | 零 | 日志检索、代码搜索、错误码 |
| 向量 + BM25 + RRF | 强 | 强 | 几十毫秒 | 一次 embedding | 大多数 RAG 场景的默认选择 |
| 再加 LLM 重排序 | 强 | 强 | 加几百毫秒到 1 秒 | 多一次 LLM 调用 | 答案准确性优先、并发不高 |
我的建议很直接:
- 新项目直接上混合检索 + RRF,成本几乎为零(BM25 是纯内存计算),效果提升立竿见影。这一步的性价比最高。
- 重排序按需加。知识库超过几千篇、或者业务对错误零容忍(医疗、法务、金融),加。日活几万的客服机器人、延迟预算只有 500 毫秒,先别加,把召回做好更划算。
- 别自己训重排序模型,除非你有标注数据和 GPU 预算。用通用大模型打分,效果已经够用。
补一句:如果你用的是 LangChain4j 的 AiServices 那条链路,里面的 ReRankingContentAggregator 已经把“多路召回 + 重排序”封装好了,你只要传一个 ScoringModel 进去。上面手写的这套更适合你想控制每一环、或者要接自研检索服务的时候。原理完全一样,只是把零件摆开看。
六、总结
RAG 答非所问,十次里有七次是检索的问题,不是模型的问题。而检索错得最隐蔽的一种,是“语义很近但事实不对”——向量检索天生就会犯这个错,因为它的工作方式就是把字面差异磨掉。
补法不复杂,四步:
- 加一路 BM25,专治错误码、型号、人名这类精确匹配
- 中文没分词器就用 bigram,够用且零依赖
- 用 RRF 按排名融合,绕开分数量纲不可比的问题
- 对融合后的 20 条候选做一次重排序,取前 3 喂给模型
整套东西的核心代码不到两百行,不需要额外服务,不需要 GPU。真正的成本是重排序那一次 LLM 调用——而它换来的是“能答对”和“答得像”之间的差别。
先别急着换更大的模型。去看看你的检索返回了什么。
文 / 会编程的吕洞宾