本文是 AgenticRAG自适应检索深度实战 的分章阅读版。
论文:"Corrective Retrieval Augmented Generation"(2024)
关键:用 检索评估器(轻量模型)给每个文档打 3 个等级:
digraph CRAG {
rankdir=TB;
node [shape=box];
Q [label="Query"];
R [label="知识库检索"];
E [label="检索评估器\n(3级分类)", shape=diamond];
K [label="知识精炼\n(提取关键句)"];
W [label="Web 检索\n(兜底)"];
M [label="合并"];
G [label="生成"];
Q -> R -> E;
E -> K [label="Correct"];
E -> W [label="Incorrect"];
E -> K [label="Ambiguous\n(降权)"];
K -> M;
W -> M;
M -> G;
}
@Service
public class CRAGService {
@Autowired private VectorRepository vectorRepo;
@Autowired private RetrievalEvaluator evaluator;
@Autowired private KnowledgeRefiner refiner;
@Autowired private WebSearchService webSearch;
@Autowired private LLMClient llm;
private static final int TOP_K = 5;
public String ask(String query) {
// 1. 知识库检索
List<VectorHit> hits = vectorRepo.search(query, TOP_K);
// 2. 检索评估
List<EvaluatedDoc> evaluated = hits.stream()
.map(h -> evaluator.evaluate(query, h))
.toList();
// 3. 分类处理
List<Doc> finalDocs = new ArrayList<>();
boolean needWeb = false;
for (EvaluatedDoc ed : evaluated) {
switch (ed.getGrade()) {
case CORRECT:
// 直接用
finalDocs.add(ed.toDoc());
break;
case AMBIGUOUS:
// 提取关键句(降权)
String refined = refiner.extractKeySentences(ed.getContent(), query);
finalDocs.add(Doc.of(refined, 0.5));
break;
case INCORRECT:
// 丢弃,触发 web 检索
needWeb = true;
break;
}
}
// 4. Web 检索兜底(所有都无关时)
if (needWeb || finalDocs.isEmpty()) {
List<WebResult> webResults = webSearch.search(query, 5);
finalDocs.addAll(webResults.stream()
.map(w -> Doc.of(w.getSnippet(), 0.3))
.toList());
}
// 5. 生成
String context = finalDocs.stream()
.map(Doc::format)
.collect(Collectors.joining("\n\n"));
return llm.chat("基于以下文档回答:\n" + context + "\n\n问题:" + query);
}
}
@Data @AllArgsConstructor
class EvaluatedDoc {
private String content;
private RetrievalGrade grade;
public Doc toDoc() { return new Doc(content, 1.0); }
}
enum RetrievalGrade {
CORRECT, AMBIGUOUS, INCORRECT
}
@Service
public class RetrievalEvaluator {
@Autowired private LLMClient llm;
@Autowired private CrossEncoderReranker reranker;
public EvaluatedDoc evaluate(String query, VectorHit hit) {
// 双重评估:
// 1. Reranker Cross-Encoder 分数
double score = reranker.score(query, hit.getContent());
// 2. LLM 判断
RetrievalGrade grade = llmJudge(query, hit.getContent());
// 综合
if (score > 0.85 && grade == RetrievalGrade.CORRECT) {
return new EvaluatedDoc(hit.getContent(), RetrievalGrade.CORRECT);
} else if (score < 0.3 || grade == RetrievalGrade.INCORRECT) {
return new EvaluatedDoc(hit.getContent(), RetrievalGrade.INCORRECT);
} else {
return new EvaluatedDoc(hit.getContent(), RetrievalGrade.AMBIGUOUS);
}
}
private RetrievalGrade llmJudge(String query, String doc) {
String prompt = """
判断文档是否包含回答问题所需的信息。
只输出: CORRECT / AMBIGUOUS / INCORRECT
问题: {{query}}
文档: {{doc}}
""";
String r = llm.chat(prompt, Map.of("query", query, "doc", doc));
return RetrievalGrade.valueOf(r.trim());
}
}
@Service
public class KnowledgeRefiner {
@Autowired private LLMClient llm;
public String extractKeySentences(String doc, String query) {
// 启发式: 找与 query 关键词重合度高的句子
List<String> sentences = splitSentences(doc);
Set<String> queryWords = tokenize(query);
List<ScoredSentence> scored = sentences.stream()
.map(s -> new ScoredSentence(s, jaccard(s, queryWords)))
.sorted(Comparator.comparingDouble(ScoredSentence::getScore).reversed())
.limit(3)
.toList();
return scored.stream()
.map(ScoredSentence::getText)
.collect(Collectors.joining(" "));
}
private double jaccard(String sentence, Set<String> queryWords) {
Set<String> sentWords = tokenize(sentence);
Set<String> intersection = new HashSet<>(sentWords);
intersection.retainAll(queryWords);
Set<String> union = new HashSet<>(sentWords);
union.addAll(queryWords);
return (double) intersection.size() / union.size();
}
}