RAG 混合检索深度解析：BM25 + 向量检索 + RRF 算法，让 AI 真正"找到"你要的内容

import dev.langchain4j.model.embedding.EmbeddingModel;
import dev.langchain4j.store.embedding.EmbeddingStore;
import dev.langchain4j.rag.retriever.HybridRetriever;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class HybridRetrieverConfig {

    /**
     * 构建混合检索器
     * 同时使用 BM25 关键词检索 + 向量语义检索，通过 RRF 算法融合结果
     *
     * @param embeddingModel 向量化模型（将文本转为向量）
     * @param embeddingStore 向量数据库（存储和检索向量）
     */
    @Bean
    public HybridRetriever hybridRetriever(
            EmbeddingModel embeddingModel,
            EmbeddingStore embeddingStore) {

        return HybridRetriever.builder()
                // ── 向量检索配置 ──────────────────────────
                .embeddingModel(embeddingModel)   // 语义检索的向量化模型
                .vectorStore(embeddingStore)       // 向量数据库实例

                // ── BM25 检索配置 ──────────────────────────
                .bm25TopK(20)   // BM25 关键词检索召回前 20 条候选
                .vectorTopK(20) // 向量语义检索召回前 20 条候选

                // ── RRF 融合配置 ──────────────────────────
                // rrfK 是 RRF 公式中的平滑常数 k，业界标准值为 60
                // 值越大：低排名文档的得分被削弱越少（结果更"民主"）
                // 值越小：结果越集中于两路都排名靠前的文档
                .rrfK(60)

                .build()
                .init(); // 初始化 BM25 索引
    }
}

import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.rag.content.retriever.ContentRetriever;
import dev.langchain4j.rag.retriever.HybridRetriever;
import dev.langchain4j.service.AiServices;
import org.springframework.stereotype.Service;

@Service
public class KnowledgeBaseService {

    private final KnowledgeAssistant assistant;

    public KnowledgeBaseService(
            ChatLanguageModel chatModel,
            HybridRetriever hybridRetriever) {

        // 将 HybridRetriever 适配为 LangChain4j 的 ContentRetriever 接口
        ContentRetriever contentRetriever = query -> {
            // hybridRetriever 内部自动完成：
            // 1. BM25 关键词检索（topK=20）
            // 2. 向量语义检索（topK=20）
            // 3. RRF 融合排序
            // 4. 返回融合后的最终结果列表
            return hybridRetriever.retrieve(query.text());
        };

        // 使用 AiServices 自动组装 RAG pipeline
        this.assistant = AiServices.builder(KnowledgeAssistant.class)
                .chatLanguageModel(chatModel)
                .contentRetriever(contentRetriever)
                .build();
    }

    /**
     * 知识库问答入口
     * @param userQuestion 用户问题
     * @return AI 生成的答案（基于混合检索的上下文）
     */
    public String ask(String userQuestion) {
        return assistant.answer(userQuestion);
    }
}

import dev.langchain4j.service.SystemMessage;

/**
 * 知识库问答 AI Service
 * LangChain4j 会自动将混合检索结果注入为上下文
 */
public interface KnowledgeAssistant {

    @SystemMessage("""
            你是一个专业的知识库问答助手。
            请严格根据提供的上下文内容来回答用户问题。
            如果上下文中没有相关信息，请直接告知用户，不要编造答案。
            """)
    String answer(String userQuestion);
}

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/knowledge")
public class KnowledgeController {

    private final KnowledgeBaseService knowledgeBaseService;

    public KnowledgeController(KnowledgeBaseService knowledgeBaseService) {
        this.knowledgeBaseService = knowledgeBaseService;
    }

    /**
     * 问答接口
     * POST /api/knowledge/ask
     * Body: {"question": "苹果14的屏幕分辨率是多少？"}
     */
    @PostMapping("/ask")
    public AnswerResponse ask(@RequestBody QuestionRequest request) {
        String answer = knowledgeBaseService.ask(request.question());
        return new AnswerResponse(answer);
    }

    // 请求/响应 DTO（Java 16+ record）
    record QuestionRequest(String question) {}
    record AnswerResponse(String answer) {}
}

// ❌ 错误：两路各 20 条，合并后 40 条全塞给大模型
List<TextSegment> bm25Results = bm25.retrieve(query);
List<TextSegment> vectorResults = vector.retrieve(query);
List<TextSegment> combined = new ArrayList<>();
combined.addAll(bm25Results);
combined.addAll(vectorResults); // 可能包含大量重复文档，且未按质量排序

// ✅ 正确：HybridRetriever 内部完成两路召回 + RRF 融合 + 去重
List<TextSegment> results = hybridRetriever.retrieve(userQuery);
// results 已经是按 RRF 分数排序、去重后的结果