什么是 RAG 重排序（Rerank）？为什么检索之后还要重排序？

// --- Maven 依赖 ---
// <dependency>
//     <groupId>dev.langchain4j</groupId>
//     <artifactId>langchain4j-cohere</artifactId>
//     <version>1.0.0-beta24</version>
// </dependency>

import dev.langchain4j.model.cohere.CohereScoringModel;
import dev.langchain4j.rag.content.aggregator.ReRankingContentAggregator;
import dev.langchain4j.rag.DefaultRetrievalAugmentor;
import dev.langchain4j.service.AiServices;

// 1. 构建 ScoringModel（这里用 Cohere，也可以换 Jina / Voyage AI）
CohereScoringModel scoringModel = CohereScoringModel.builder()
    .apiKey(System.getenv("COHERE_API_KEY"))
    .modelName("rerank-v3.5")
    .build();

// 2. 构建重排序聚合器
ReRankingContentAggregator contentAggregator = ReRankingContentAggregator.builder()
    .scoringModel(scoringModel)
    // 可选：设置重排后保留的 Top-K 数量
    .maxSelectedResults(3)
    .build();

// 3. 构建 RAG 增强器
DefaultRetrievalAugmentor retrievalAugmentor = DefaultRetrievalAugmentor.builder()
    .contentRetriever(vectorStoreRetriever)  // 向量检索器（粗筛）
    .contentAggregator(contentAggregator)     // 重排序聚合器（精排）
    .build();

// 4. 构建 AI 服务
Assistant assistant = AiServices.builder(Assistant.class)
    .chatLanguageModel(chatModel)
    .retrievalAugmentor(retrievalAugmentor)
    .build();

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.client.ChatClientRequestSpec;
import org.springframework.ai.chat.client.advisor.api.*;
import org.springframework.ai.document.Document;
import org.springframework.ai.vectorstore.SearchRequest;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.web.client.RestTemplate;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 自定义 Rerank Advisor
 * 在向量检索之后，调用 Rerank API 对结果重新排序
 */
public class RerankAdvisor implements CallAroundAdvisor {

    private final VectorStore vectorStore;
    private final RestTemplate restTemplate;
    private final String rerankApiUrl;
    private final int topK;           // 初始检索数量
    private final int rerankTopN;     // 重排后保留数量

    public RerankAdvisor(VectorStore vectorStore, String rerankApiUrl,
                         int topK, int rerankTopN) {
        this.vectorStore = vectorStore;
        this.restTemplate = new RestTemplate();
        this.rerankApiUrl = rerankApiUrl;
        this.topK = topK;
        this.rerankTopN = rerankTopN;
    }

    @Override
    public AdvisedResponse aroundCall(AdvisedRequest request, CallAroundAdvisorChain chain) {
        String userQuery = request.userText();

        // 第一步：向量检索，多召回一些候选（粗筛）
        // 比如 topK=40，为后续重排序留足空间
        List<Document> candidates = vectorStore.similaritySearch(
            SearchRequest.builder()
                .query(userQuery)
                .topK(topK)
                .build()
        );

        // 第二步：调用 Rerank API 进行精排
        List<Document> reranked = rerank(userQuery, candidates);

        // 第三步：取重排后的 Top-N 结果，拼装到 Prompt 中
        String context = reranked.stream()
            .limit(rerankTopN)
            .map(doc -> doc.getText())
            .collect(Collectors.joining("\n\n"));

        // 将上下文注入到用户消息中
        String enhancedQuery = "基于以下参考资料回答问题：\n\n"
            + context + "\n\n问题：" + userQuery;

        AdvisedRequest newRequest = AdvisedRequest.from(request)
            .withUserText(enhancedQuery)
            .build();

        return chain.nextAroundCall(newRequest);
    }

    /**
     * 调用外部 Rerank API（如 Cohere / 阿里云 qwen3-rerank）
     */
    private List<Document> rerank(String query, List<Document> candidates) {
        // 构建请求体（以 Cohere Rerank API 为例）
        Map<String, Object> requestBody = Map.of(
            "query", query,
            "documents", candidates.stream()
                .map(Document::getText)
                .toList(),
            "top_n", rerankTopN,
            "model", "rerank-v3.5"
        );

        // 调用 API 并解析返回的重排序结果
        Map<String, Object> response = restTemplate.postForObject(
            rerankApiUrl, requestBody, Map.class
        );

        // 按 relevance_score 降序排列，返回重排后的文档列表
        // ...解析逻辑省略...
        return candidates; // 简化示例
    }

    @Override
    public String getName() {
        return "RerankAdvisor";
    }

    @Override
    public int getOrder() {
        return 100; // 确保在检索 Advisor 之后执行
    }
}

ChatClient chatClient = ChatClient.builder(chatModel)
    .defaultAdvisors(
        new RerankAdvisor(vectorStore,
            "https://api.cohere.com/v2/rerank",
            40,   // 粗筛 Top-40
            3     // 精排后取 Top-3
        )
    )
    .build();