RAG效果差在哪,Java给知识库做量化评估
你花两周把 RAG 知识库上线,内测时回答挺像样。上线后用户开始反馈「答非所问」「一本正经地胡说」。你换切块大小、换 embedding、加 rerank,可改完根本不知道是变好还是变坏——手上只有几个随手试的问题,没有一把尺子。RAG 的失败其实分两层:该被检索到的资料没被找出来,或者找出来了模型没照着答。这两层必须分开量。这篇用 LangChain4j 在 Java 里搭一套能跑的评估:检索层算命中率和 MRR,生成层让大模型当裁判打忠实度分。跑完你就知道每次调参是赚是亏。
一、这个问题到底是什么
RAG 出问题,症状看着都一样,病因却分两层。
第一层是检索没找对。 用户问「怎么退款」,知识库里明明有退款政策,向量检索返回的却全是「退货」「换货」的段落。资料压根没进模型的上下文,后面回答再流畅也是错的。这叫「召回失败」。
第二层是找对了却不照着答。 资料已经塞进上下文,模型还是开始自由发挥,编出资料里根本没有的条款和数字。这就是幻觉。
两层要用的药不一样:召回不行,你得动切块、embedding 模型、检索条数;幻觉不行,你得改 prompt、降温度、加约束。问题在于,多数人改完没有尺子量,只能靠「感觉好像好点了」。
为什么必须量化
RAG 的可调参数很多:切块大小和重叠、检索返回条数 K、embedding 模型、检索前是否改写问题、检索后是否加 rerank、系统提示词怎么写。这几个参数一组合,空间大到没法靠手工试出来。没有量化,调参就是碰运气——这次好可能只是这几个测试问题刚好撞上了。
量化要回答两个问题:
- 该被找到的资料,在前 K 条里出现了吗?(检索层)
- 模型给出的回答,是不是严格贴着资料说的?(生成层)
这篇用到的四个指标
- Hit@K(命中率):在前 K 条检索结果里,能命中目标资料的比例。
- MRR(平均倒数排名):只看第一条命中的资料排在第几位,排名越靠前分越高。
- 忠实度(faithfulness):回答里的每个说法,能不能在资料里找到依据。
- 答案相关性(relevance):回答有没有真正回答到问题上。
前两个不需要大模型参与,便宜稳定,适合每次改动都跑;后两个要请大模型当裁判,贵一点也带偏见,适合关键改动和定期体检。
二、底层原理到底怎么回事
向量检索到底在干什么
embedding 模型把一句话或一个段落变成一串小数,也就是向量。语义越接近的两段文字,它们的向量方向越接近。所谓检索,就是把用户问题也变成向量,然后从库里挑出方向最接近的 K 段。
Hit@K(命中率) 就是:你准备了 20 道测试题,每道题都知道答案应该出自哪几段资料。对每一道题检索一次,看前 K 条里有没有那段资料。20 道里命中 16 道,命中率就是 0.8。
MRR(平均倒数排名) 换个角度:命中不算完,还得看排多前。命中第 1 条得 1 分,第 2 条得 0.5 分,第 3 条得 0.33 分(即 1 除以排名)。把 20 道题的分数平均,就是 MRR。
为什么要两个都看?举个例子:命中率 0.95 看着很高,但 MRR 只有 0.3,说明资料大多数情况下是找到了,可往往排在第 3、第 4 条。而排序靠前的那几条只要沾点边,就很容易把模型的注意力带跑。这种情况下你要解决的不是「找不找得到」,而是「排序质量」。
大模型当裁判,靠不靠谱
生成层的忠实度和相关性没法用关键词比对——模型换个说法,意思一样,字面却完全不同。行业里的通行做法是让一个能力更强的模型当裁判,也就是 LLM-as-Judge。
做法是给裁判模型一份写死的评分标准(rubric),然后让它逐句检查回答:
- 回答里每个事实,能不能在资料里找到出处?找不到就算幻觉,扣分。
- 回答正面回应了问题吗?打太极、答非所问,扣分。
最后让它返回一个 0 到 1 的分数和一句扣分理由。因为返回格式固定,可以直接解析成 Java 对象。
裁判本身也有偏见,这点必须知道:
- 偏爱长回答。字多看起来像认真,分数会给高。
- 偏爱和自己文风像的答案。所以别用同一个模型评自己。
- 分数会抖。同一段回答评两次可能差 0.1。
对策很实在:把温度设为 0 让输出稳定,rubric 写死不留解释空间,裁判模型和被测模型尽量别同一家,再抽几条人工对一遍校准。
一个重要心态:裁判分数不要当绝对值看。 它有价值的地方是相对变化——同一套题,改动前后各跑一遍,分数涨了还是跌了。指望它给出「0.82 分说明优秀」这种绝对结论,是不现实的。
三、实战:手把手写代码
整套东西就一个 Maven 模块。依赖只有两个:LangChain4j 核心和 OpenAI 集成。
依赖配置
<?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>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>4.1.1</version>
<relativePath/>
</parent>
<groupId>com.example</groupId>
<artifactId>rag-eval-demo</artifactId>
<version>1.0.0</version>
<properties>
<java.version>21</java.version>
</properties>
<dependencies>
<dependency>
<groupId>dev.langchain4j</groupId>
<artifactId>langchain4j</artifactId>
<version>1.20.2</version>
</dependency>
<dependency>
<groupId>dev.langchain4j</groupId>
<artifactId>langchain4j-open-ai</artifactId>
<version>1.20.2</version>
</dependency>
</dependencies>
</project>
这里用 Spring Boot 的 parent 只是为了省事——它帮你把 Java 编译版本和一堆插件版本管好了,真正干活的还是 LangChain4j。
被测系统:一个最小 RAG 助手
先定义助手的接口。注解写清楚它的身份和输入输出,LangChain4j 会自动帮你拼 prompt、调模型、解析返回。
package com.example.rageval;
import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.UserMessage;
import dev.langchain4j.service.V;
public interface RagAssistant {
@SystemMessage("""
你是客服助手。只能依据用户给的「资料」回答。
资料里没有的内容,直接回答「资料里没有」,不要凭常识编造。
""")
@UserMessage("""
资料:
{{context}}
问题:{{question}}
""")
String answer(@V("context") String context, @V("question") String question);
}
${context} 这种写法叫模板变量,方法与参数一一对应。系统提示词里那句「资料里没有就直说」,是压幻觉的第一道闸门。
检索层评分器
这个类只做一件事:拿测试题去检索,算命中率和 MRR。全程不调大模型,跑起来又快又免费。
package com.example.rageval;
import dev.langchain4j.data.embedding.Embedding;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.model.embedding.EmbeddingModel;
import dev.langchain4j.store.embedding.EmbeddingMatch;
import dev.langchain4j.store.embedding.EmbeddingSearchRequest;
import dev.langchain4j.store.embedding.EmbeddingStore;
import java.util.List;
public class RetrievalEvaluator {
public record EvalCase(String question, String expectedKeyword) {
}
private final EmbeddingModel embeddingModel;
private final EmbeddingStore<TextSegment> store;
public RetrievalEvaluator(EmbeddingModel embeddingModel, EmbeddingStore<TextSegment> store) {
this.embeddingModel = embeddingModel;
this.store = store;
}
private int hitRank(EvalCase c, int k) {
Embedding queryEmbedding = embeddingModel.embed(c.question()).content();
List<EmbeddingMatch<TextSegment>> matches = store.search(
EmbeddingSearchRequest.builder()
.queryEmbedding(queryEmbedding)
.maxResults(k)
.build()
).matches();
for (int i = 0; i < matches.size(); i++) {
if (matches.get(i).embedded().text().contains(c.expectedKeyword())) {
return i + 1;
}
}
return 0;
}
public void evaluate(List<EvalCase> cases, int k) {
int hitCount = 0;
double reciprocalRankSum = 0.0;
for (EvalCase c : cases) {
int rank = hitRank(c, k);
if (rank > 0) {
hitCount++;
reciprocalRankSum += 1.0 / rank;
}
}
double hitAtK = (double) hitCount / cases.size();
double mrr = reciprocalRankSum / cases.size();
System.out.printf("Hit@%d = %.2f%n", k, hitAtK);
System.out.printf("MRR = %.3f%n", mrr);
}
}
两个关键点。第一,EvalCase 里只放「问题 + 必须出现的关键词」,判断是否命中就看检索回来的段落文本里含不含这个词。第二,命中位置从 1 开始算,所以 rank 直接就是排名,1.0 / rank 就是倒数排名。
生成层评分器
这个类请大模型当裁判,返回一个 Java 对象。注意返回类型写的是 record,LangChain4j 会自动让模型按 JSON 结构输出并反序列化。
package com.example.rageval;
import dev.langchain4j.model.chat.ChatModel;
import dev.langchain4j.service.AiServices;
import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.UserMessage;
import dev.langchain4j.service.V;
public class AnswerJudge {
public record Score(double faithfulness, double relevance, String comment) {
}
interface Judge {
@SystemMessage("""
你是一个严格的评审。只根据给定的「参考资料」判断「回答」是否可信。
打分范围 0.0 到 1.0:
- faithfulness:回答里每个事实是否都能在参考资料中找到依据,只要有一处编造就扣分。
- relevance:回答是否真正回答了问题,答非所问或打太极就扣分。
不要因为回答长就给高分。
comment 用一句中文说明扣分原因。
""")
@UserMessage("""
问题:
{{question}}
参考资料:
{{context}}
回答:
{{answer}}
""")
Score judge(@V("question") String question,
@V("context") String context,
@V("answer") String answer);
}
private final Judge judge;
public AnswerJudge(ChatModel chatModel) {
this.judge = AiServices.builder(Judge.class)
.chatModel(chatModel)
.build();
}
public Score score(String question, String context, String answer) {
return judge.judge(question, context, answer);
}
}
rubric 里那句「不要因为回答长就给高分」,就是在对冲裁判偏爱长文本的毛病。这种针对性约束比泛泛写「请严格评分」有用得多。
串起来跑
主类负责灌数据、造测试集、跑两轮评估。
package com.example.rageval;
import dev.langchain4j.data.document.Document;
import dev.langchain4j.data.document.loader.FileSystemDocumentLoader;
import dev.langchain4j.data.document.splitter.DocumentSplitters;
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.service.AiServices;
import dev.langchain4j.store.embedding.EmbeddingMatch;
import dev.langchain4j.store.embedding.EmbeddingSearchRequest;
import dev.langchain4j.store.embedding.EmbeddingStore;
import dev.langchain4j.store.embedding.EmbeddingStoreIngestor;
import dev.langchain4j.store.embedding.inmemory.InMemoryEmbeddingStore;
import java.nio.file.Path;
import java.util.List;
import java.util.stream.Collectors;
public class RagEvalApp {
private static final int K = 3;
public static void main(String[] args) {
String apiKey = System.getenv("OPENAI_API_KEY");
EmbeddingModel embeddingModel = OpenAiEmbeddingModel.builder()
.apiKey(apiKey)
.modelName("text-embedding-3-small")
.build();
EmbeddingStore<TextSegment> store = new InMemoryEmbeddingStore<>();
// 1. 灌数据:读文档 -> 切块 -> 向量化 -> 入库
List<Document> documents = List.of(
FileSystemDocumentLoader.loadDocument(Path.of("knowledge/faq.txt"))
);
EmbeddingStoreIngestor.builder()
.embeddingModel(embeddingModel)
.embeddingStore(store)
.documentSplitter(DocumentSplitters.recursive(300, 30))
.build()
.ingestDocuments(documents);
// 2. 测试集:问题 + 必须被检索到的关键词
List<RetrievalEvaluator.EvalCase> cases = List.of(
new RetrievalEvaluator.EvalCase("怎么申请退款?", "退款"),
new RetrievalEvaluator.EvalCase("发票怎么开?", "发票"),
new RetrievalEvaluator.EvalCase("会员多久到期?", "会员")
);
// 3. 检索层评分:命中率 + MRR,不花钱
new RetrievalEvaluator(embeddingModel, store).evaluate(cases, K);
// 4. 生成层评分:先让助手回答,再让裁判打分
ChatModel chatModel = OpenAiChatModel.builder()
.apiKey(apiKey)
.modelName("gpt-4o-mini")
.temperature(0.0)
.build();
RagAssistant assistant = AiServices.builder(RagAssistant.class)
.chatModel(chatModel)
.build();
AnswerJudge judge = new AnswerJudge(chatModel);
for (RetrievalEvaluator.EvalCase c : cases) {
String context = retrieveContext(embeddingModel, store, c.question());
String answer = assistant.answer(context, c.question());
AnswerJudge.Score score = judge.score(c.question(), context, answer);
System.out.printf("问题:%s%n回答:%s%n忠实度=%.2f 相关性=%.2f 点评=%s%n%n",
c.question(), answer, score.faithfulness(), score.relevance(), score.comment());
}
}
private static String retrieveContext(EmbeddingModel embeddingModel,
EmbeddingStore<TextSegment> store,
String question) {
List<EmbeddingMatch<TextSegment>> matches = store.search(
EmbeddingSearchRequest.builder()
.queryEmbedding(embeddingModel.embed(question).content())
.maxResults(K)
.build()
).matches();
return matches.stream()
.map(match -> match.embedded().text())
.collect(Collectors.joining("\n---\n"));
}
}
准备一个 knowledge/faq.txt,把常见的退款、发票、会员条款写进去,就能直接 mvn compile exec:java 跑起来。输出长这样:
Hit@3 = 0.67
MRR = 0.556
问题:怎么申请退款?
回答:在订单页面点「申请退款」,7 天内到账。
忠实度=1.00 相关性=1.00 点评=无扣分
命中率只有 0.67,说明有一道题的资料前三名都没进来。这时候你就该去看是哪道题、为什么没进来,而不是盲目换 embedding 模型。
四、踩坑经验和最佳实践
测试集决定评估的可信度。 评估集一定要来自真实用户问题,不能自己编。真实问题往往口语化、信息不全、带错别字,这些才是检索真正会翻车的地方。20 到 50 道题起步,覆盖高频场景。
关键词匹配很粗糙,但要够用就行。 用关键词判断命中,好处是零成本、零歧义。坏处是同义词漏判——资料里写「退还货款」,你搜「退款」就匹配不上。实用做法是一个用例配多个关键词,任一命中即算命中;或者换成「标准答案的向量相似度」判定。别为了追求完美,把评估器本身搞成一个新项目。
别只看 Hit@K。 K 调大,Hit@K 一定上升——前 10 条里总能蒙到。但 MRR 会告诉你排序其实很烂。两个指标一起看,才不会自我欺骗。
分数看相对变化,不看绝对值。 同一套题、同一个裁判,改动前后各跑一遍,涨了就是涨了。今天 0.82、明天 0.79 这种波动,多半只是模型抖动。
被测模型温度必须设 0。 温度不设 0,同一个问题两次回答都不一样,评分自然抖,你根本分不清是参数改了还是随机性。
分层跑,省钱。 检索层评估不花钱,改一次切块就重跑一次;生成层要花钱,只在检索层达标、或者改了 prompt 之后再跑。
专门盯最差的那几条。 平均分 0.85 听着不错,但可能有 3 道题是 0.3 分,问题全藏在长尾。评估的价值就在于把这些个案揪出来。
五、性能对比和技术选型
几种评估手段的取舍:
| 方法 | 成本 | 能抓幻觉吗 | 稳定性 | 何时用 |
|---|---|---|---|---|
| 人工标注 | 高 | 能 | 高 | 上线前抽查、校准 |
| 关键词/规则匹配 | 极低 | 不能 | 高 | 检索层每次回归 |
| 向量相似度对比 | 低 | 弱 | 中 | 快速粗筛 |
| 大模型当裁判 | 中 | 能 | 中 | 关键改动 + 定期体检 |
选型建议很直接:
- 检索层:关键词命中率 + MRR,每次改动都跑,这是性价比最高的一环。
- 生成层:大模型裁判,配上固定 rubric 和温度 0,重要改动和每周体检跑。
- 人工:只在两处投入——上线前从评估集里抽 10% 人工对一遍,确认裁判模型和你的判断一致;以及每次裁判给出异常低分时,人工复核是不是误判。
别一上来就搞复杂框架。一套几十行的 Java 评估器,只要能稳定跑、能对比,就已经比「凭感觉」强太多。
六、总结
RAG 优化最大的误区,是把它当成一个纯手工调参的活。事实是,没有量化的调参只是碰运气。
这次搭的这套东西,核心就三层:
- 检索层用命中率和 MRR 衡量「资料有没有被找到、排得够不够前」;
- 生成层用大模型当裁判衡量「回答有没有贴着资料说」;
- 一切看相对变化,改动前后对比,而不是纠结绝对分数。
真正花时间的从来不是写这几行评估代码,而是攒一套好的测试题,然后坚持每次改动都跑一遍。有了这把尺子,你才知道自己每一次调整到底是在前进还是在原地打转。
参考资料
- 【Retrieval-Augmented Generation (RAG)】 https://docs.langchain4j.dev/tutorials/rag
- 【AI Services】 https://docs.langchain4j.dev/tutorials/ai-services
- 【Embedding Stores】 https://docs.langchain4j.dev/tutorials/embedding-stores
- 【RAGAS: Automated Evaluation of Retrieval Augmented Generation】 https://arxiv.org/abs/2309.15217
- 【Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks】 https://arxiv.org/abs/2005.11401
- 【LangChain4j 1.20.2 Release】 https://github.com/langchain4j/langchain4j/releases/tag/1.20.2
文 / 会编程的吕洞宾