10. 评估与优化

package com.albertstack.rag.evaluation;

public record EvalCase(
        String question, // 评估用例的提问
        String expectedContent // 期望检索结果中包含的文本片段
) {}

package com.albertstack.rag.evaluation;

public record EvalResult(
        double hitRate, // 命中率：命中数 / 总用例数
        double mrr, // 平均倒数排名：Σ(1 / 命中位置) / 总用例数
        int totalCases,
        int hits
) {
    @Override
    public String toString() {
        return "EvalResult{hitRate=%.2f%%, mrr=%.4f, hits=%d/%d}"
                .formatted(hitRate * 100, mrr, hits, totalCases);
    }
}

package com.albertstack.rag.evaluation;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.vectorstore.SearchRequest;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.stereotype.Component;

import java.util.List;

@Slf4j
@Component
@RequiredArgsConstructor
public class RetrievalEvaluator {

    private final VectorStore vectorStore;

    public EvalResult evaluate(List<EvalCase> cases, int topK) {
        int hits = 0;
        double mrrSum = 0;

        for (var evalCase : cases) {
            var results = vectorStore.similaritySearch(
                    SearchRequest.builder()
                            .query(evalCase.question())
                            .topK(topK)
                            .build()
            );

            // 用 contains 而不是精确匹配，符合"找到相关段落即算命中"的直觉
            for (int i = 0; i < results.size(); i++) {
                if (results.get(i).getText().contains(evalCase.expectedContent())) {
                    hits++;
                    // i 从 0 起，加 1 后第一名得 1 分、第二名得 0.5 分
                    mrrSum += 1.0 / (i + 1);
                    break; // 一个用例只算排名最高的命中，避免重复计分
                }
            }
        }

        var result = new EvalResult(
                (double) hits / cases.size(),
                mrrSum / cases.size(),
                cases.size(),
                hits
        );
        log.info("评估结果: {}", result);
        return result;
    }
}

package com.albertstack.rag.evaluation;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@Slf4j
@SpringBootTest
class RetrievalEvaluatorTest {

    @Autowired
    RetrievalEvaluator evaluator;

    @Test
    void shouldEvaluateRetrievalQuality() {
        var cases = List.of(
                new EvalCase("Spring AI 支持哪些向量数据库？", "Qdrant"),
                new EvalCase("Ollama 怎么管理模型？", "ollama"),
                new EvalCase("RAG 的核心思想是什么？", "检索"),
                new EvalCase("ChatClient 怎么使用？", "ChatClient"),
                new EvalCase("Embedding 是什么？", "向量")
                // 实际项目里建议准备 20-50 个用例以获得统计意义
        );

        var result = evaluator.evaluate(cases, 5);
        log.info("命中率={}, MRR={}", result.hitRate(), result.mrr());
    }
}

package com.albertstack.rag.evaluation;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@RequiredArgsConstructor
public class AnswerEvaluator {

    private final ChatClient chatClient;

    public double scoreAnswer(String question, String answer, String expectedPoints) {
        // 在 prompt 里明确给出 5 档评分标准，避免 LLM 用自己的标准随意打分
        String prompt = """
                你是一个严格的评估专家。请评估以下 RAG 系统的回答质量。

                评分标准（1-5 分）：
                - 5 分：完全正确，覆盖所有要点，没有幻觉
                - 4 分：基本正确，覆盖主要要点
                - 3 分：部分正确，遗漏了一些要点
                - 2 分：大部分不正确或不相关
                - 1 分：完全错误或答非所问

                问题：%s
                期望要点：%s
                实际回答：%s

                只返回一个数字（1-5），不要任何解释。
                """.formatted(question, expectedPoints, answer);

        String score = chatClient.prompt().user(prompt).call().content();

        try {
            return Double.parseDouble(score.trim());
        } catch (NumberFormatException e) {
            // LLM 偶尔不听话返回长篇解释，给个中性分而不是抛异常打断流程
            log.warn("LLM 返回了非数字评分: {}，默认给 3 分", score);
            return 3.0;
        }
    }
}

package com.albertstack.rag.evaluation;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@Slf4j
@SpringBootTest
class AnswerEvaluatorTest {

    @Autowired
    AnswerEvaluator answerEvaluator;

    @Test
    void shouldScoreAnswerQuality() {
        String question = "Spring AI 支持哪些向量数据库？";
        String expectedPoints = "Qdrant、Pinecone、Milvus、PGVector 等主流向量数据库，通过统一的 VectorStore 抽象屏蔽差异";

        // 用一对反差明显的答案做对照：好答案应该接近 5 分，差答案应该接近 1 分
        String goodAnswer = "Spring AI 通过 VectorStore 抽象支持 Qdrant、Pinecone、Milvus、PGVector 等主流向量数据库，切换实现只需改配置。";
        String badAnswer = "Spring AI 是一个前端可视化框架，主要用来画图表。";

        log.info("好答案: {}", goodAnswer);
        double goodScore = answerEvaluator.scoreAnswer(question, goodAnswer, expectedPoints);
        log.info("好答案得分: {}", goodScore);

        log.info("差答案: {}", badAnswer);
        double badScore = answerEvaluator.scoreAnswer(question, badAnswer, expectedPoints);
        log.info("差答案得分: {}", badScore);
    }
}

var results = vectorStore.similaritySearch(
        SearchRequest.builder().query("你的测试问题").topK(5).build()
);
results.forEach(doc -> log.info("score={}, text={}",
        doc.getScore(), doc.getText().substring(0, Math.min(100, doc.getText().length()))));