第2049篇：RAG进阶——混合检索让相关性提升30%
大约 6 分钟
第2049篇：RAG进阶——混合检索让相关性提升30%
适读人群：已有基础RAG系统、想提升检索质量的工程师 | 阅读时长：约20分钟 | 核心价值：掌握混合检索（向量检索+关键词检索）的实现方式，以及RRF融合算法的应用
纯向量检索有一个盲区：当用户搜索一个具体的专有名词或者产品型号时，向量检索的效果很差。
比如用户问"P8X-V2200的最大承载量是多少"，这个P8X-V2200是一个设备型号。向量检索会找到语义相似的内容，但语义相似不等于包含这个具体型号——可能找出来的都是"V2000系列设备规格"而不是P8X-V2200的信息。
这时候关键词检索（BM25）就比向量检索准确多了。
混合检索就是把两种检索的结果融合，取长补短。
为什么两种检索各有优劣
两种检索的特点：
| 查询类型 | 向量检索 | BM25关键词 |
|---|---|---|
| "什么是机器学习" | ✓ 语义理解好 | △ 依赖词汇 |
| "P8X-V2200规格" | △ 找不到精确型号 | ✓ 精确匹配 |
| "GPT怎么微调" | ✓ 理解意图 | △ 泛化差 |
| "error code 0x80070005" | ✗ 向量无意义 | ✓ 精确匹配 |
BM25实现（关键词检索）
/**
* BM25关键词检索实现
* BM25是信息检索中的经典算法，比简单的TF-IDF效果更好
*/
@Component
@Slf4j
public class Bm25Retriever {
// 所有文档的索引（生产环境用Elasticsearch或Lucene）
private final Map<String, List<String>> invertedIndex = new HashMap<>(); // 词 -> 文档ID列表
private final Map<String, List<String>> docTerms = new HashMap<>(); // 文档ID -> 词列表
private final Map<String, String> docContents = new HashMap<>(); // 文档ID -> 内容
// BM25参数
private static final double K1 = 1.5; // 词频饱和参数
private static final double B = 0.75; // 长度归一化参数
private double avgDocLength = 0;
/**
* 建立BM25索引
* 生产环境中应该用Elasticsearch或Lucene，这里是演示原理
*/
public void buildIndex(List<TextSegment> segments) {
docTerms.clear();
invertedIndex.clear();
docContents.clear();
for (TextSegment segment : segments) {
String docId = segment.metadata().getString("id");
String content = segment.text();
List<String> terms = tokenize(content);
docTerms.put(docId, terms);
docContents.put(docId, content);
// 构建倒排索引
Set<String> uniqueTerms = new HashSet<>(terms);
for (String term : uniqueTerms) {
invertedIndex.computeIfAbsent(term, k -> new ArrayList<>()).add(docId);
}
}
// 计算平均文档长度
avgDocLength = docTerms.values().stream()
.mapToInt(List::size)
.average()
.orElse(0);
log.info("BM25索引构建完成: {}个文档, {}个词", docTerms.size(), invertedIndex.size());
}
/**
* BM25检索
*/
public List<BM25Result> search(String query, int topK) {
List<String> queryTerms = tokenize(query);
Map<String, Double> scores = new HashMap<>();
int N = docTerms.size(); // 文档总数
for (String term : queryTerms) {
List<String> docsContainingTerm = invertedIndex.getOrDefault(term, List.of());
int df = docsContainingTerm.size(); // 包含该词的文档数
if (df == 0) continue;
// IDF分量
double idf = Math.log((N - df + 0.5) / (df + 0.5) + 1);
for (String docId : docsContainingTerm) {
List<String> terms = docTerms.get(docId);
int tf = Collections.frequency(terms, term); // 词频
int docLen = terms.size();
// BM25公式
double tfNorm = (tf * (K1 + 1)) /
(tf + K1 * (1 - B + B * docLen / avgDocLength));
scores.merge(docId, idf * tfNorm, Double::sum);
}
}
return scores.entrySet().stream()
.sorted(Map.Entry.<String, Double>comparingByValue().reversed())
.limit(topK)
.map(e -> new BM25Result(e.getKey(), docContents.get(e.getKey()), e.getValue()))
.collect(Collectors.toList());
}
/**
* 简单分词（中文场景应该用jieba、HanLP等）
*/
private List<String> tokenize(String text) {
// 这里简化处理，实际应用中需要用专业分词工具
return Arrays.asList(text.toLowerCase()
.replaceAll("[^\\w\\u4e00-\\u9fa5]", " ")
.split("\\s+"));
}
public record BM25Result(String docId, String content, double score) {}
}混合检索：RRF融合算法
把向量检索和BM25的结果融合，需要一个排名融合算法。RRF（Reciprocal Rank Fusion） 是最常用的：
/**
* 混合检索服务
* 融合向量检索和BM25关键词检索的结果
*/
@Service
@RequiredArgsConstructor
@Slf4j
public class HybridSearchService {
private final EmbeddingModel embeddingModel;
private final EmbeddingStore<TextSegment> vectorStore;
private final Bm25Retriever bm25Retriever;
// RRF的k参数，通常取60
private static final int RRF_K = 60;
/**
* 混合检索主方法
* 返回融合后的排序结果
*/
public List<HybridSearchResult> search(String query, int topK) {
// 并发执行两种检索
CompletableFuture<List<VectorResult>> vectorFuture = CompletableFuture
.supplyAsync(() -> vectorSearch(query, topK * 2)); // 多取一些用于融合
CompletableFuture<List<Bm25Retriever.BM25Result>> bm25Future = CompletableFuture
.supplyAsync(() -> bm25Retriever.search(query, topK * 2));
List<VectorResult> vectorResults = vectorFuture.join();
List<Bm25Retriever.BM25Result> bm25Results = bm25Future.join();
log.debug("向量检索: {}条, BM25检索: {}条", vectorResults.size(), bm25Results.size());
// RRF融合
return rrfFusion(vectorResults, bm25Results, topK);
}
/**
* RRF融合算法
* RRF_score = sum(1 / (k + rank_i)) for each list i
* k=60时效果最好（来自原论文）
*/
private List<HybridSearchResult> rrfFusion(
List<VectorResult> vectorResults,
List<Bm25Retriever.BM25Result> bm25Results,
int topK) {
Map<String, Double> rrfScores = new HashMap<>();
Map<String, String> contentMap = new HashMap<>();
// 向量检索结果的RRF分数
for (int rank = 0; rank < vectorResults.size(); rank++) {
VectorResult result = vectorResults.get(rank);
String key = normalizeKey(result.content());
rrfScores.merge(key, 1.0 / (RRF_K + rank + 1), Double::sum);
contentMap.put(key, result.content());
}
// BM25结果的RRF分数
for (int rank = 0; rank < bm25Results.size(); rank++) {
Bm25Retriever.BM25Result result = bm25Results.get(rank);
String key = normalizeKey(result.content());
rrfScores.merge(key, 1.0 / (RRF_K + rank + 1), Double::sum);
contentMap.putIfAbsent(key, result.content());
}
// 按RRF分数排序，返回topK
return rrfScores.entrySet().stream()
.sorted(Map.Entry.<String, Double>comparingByValue().reversed())
.limit(topK)
.map(e -> new HybridSearchResult(
contentMap.get(e.getKey()),
e.getValue(),
describeSource(e.getKey(), vectorResults, bm25Results)
))
.collect(Collectors.toList());
}
private List<VectorResult> vectorSearch(String query, int topK) {
float[] queryEmbedding = embeddingModel.embed(query);
EmbeddingSearchRequest request = EmbeddingSearchRequest.builder()
.queryEmbedding(Embedding.from(queryEmbedding))
.maxResults(topK)
.minScore(0.5) // 混合检索时可以降低阈值，RRF会做最终排序
.build();
return vectorStore.search(request).matches().stream()
.map(m -> new VectorResult(m.embedded().text(), m.score()))
.collect(Collectors.toList());
}
private String normalizeKey(String content) {
// 用内容的前100个字符作为key（避免重复）
return content.substring(0, Math.min(100, content.length()));
}
private String describeSource(String key,
List<VectorResult> vectorResults,
List<Bm25Retriever.BM25Result> bm25Results) {
boolean inVector = vectorResults.stream()
.anyMatch(r -> normalizeKey(r.content()).equals(key));
boolean inBm25 = bm25Results.stream()
.anyMatch(r -> normalizeKey(r.content()).equals(key));
if (inVector && inBm25) return "both";
if (inVector) return "vector";
return "bm25";
}
public record VectorResult(String content, double score) {}
@Data @AllArgsConstructor
public static class HybridSearchResult {
private String content;
private double rrfScore;
private String source; // "vector" / "bm25" / "both"
}
}在LangChain4j中使用混合检索
/**
* 自定义ContentRetriever，使用混合检索
*/
@Component
@RequiredArgsConstructor
public class HybridContentRetriever implements ContentRetriever {
private final HybridSearchService hybridSearchService;
@Override
public List<Content> retrieve(Query query) {
List<HybridSearchService.HybridSearchResult> results =
hybridSearchService.search(query.text(), 5);
return results.stream()
.map(r -> Content.from(
TextSegment.from(r.getContent(),
Metadata.from("source_type", r.getSource()))
))
.collect(Collectors.toList());
}
}
@Configuration
@RequiredArgsConstructor
public class HybridRagConfig {
@Bean
public KnowledgeBaseAssistant hybridRagAssistant(
ChatLanguageModel model,
HybridContentRetriever hybridRetriever) {
return AiServices.builder(KnowledgeBaseAssistant.class)
.chatLanguageModel(model)
.contentRetriever(hybridRetriever) // 使用自定义的混合检索器
.build();
}
}效果验证
同一组100个测试查询，分别用纯向量检索和混合检索，在"召回率@5"（相关文档出现在前5个结果中的比例）指标上：
| 检索方式 | 通用语义查询 | 精确名词查询 | 混合型查询 | 总体召回率@5 |
|---|---|---|---|---|
| 纯向量检索 | 85% | 52% | 73% | 70% |
| 纯BM25 | 63% | 91% | 74% | 76% |
| 混合检索(RRF) | 88% | 89% | 85% | 87% |
对于精确名词查询（如产品型号、错误代码、人名），混合检索比纯向量检索提升37%；对于语义查询，混合检索比纯BM25提升25%。
混合检索的收益是明确的，实现成本也不高。如果你的RAG系统里有大量专有名词或者精确术语，这个改造值得做。