← 返回首页 📖 📖 Wiki知识库
📐 学习维度 本篇是 📖 📖 Wiki知识库 🏠 首页 🛤️ 学习路径 📚 全部文章

AgenticRAG自适应检索深度实战 - 四、Corrective RAG (CRAG):检索纠错

本文是 AgenticRAG自适应检索深度实战 的分章阅读版。

四、Corrective RAG (CRAG):检索纠错

4.1 核心思想

论文:"Corrective Retrieval Augmented Generation"(2024)

关键:用 检索评估器(轻量模型)给每个文档打 3 个等级:

4.2 CRAG 流程


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;
}

4.3 Java 实现


@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
}

4.4 检索评估器实现


@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());
    }
}

4.5 知识精炼


@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();
    }
}


相关页面