Corrective RAG (CRAG)

A lightweight classifier that assesses the relevance of each fetched document against the user query. It assigns a confidence score to every retrieved passage, categorizing them as correct, ambiguous, or incorrect. This evaluation gate determines whether the retrieved context is sufficient for generation or requires correction. The evaluator is typically fine-tuned on a dataset of query-document pairs labeled for relevance, enabling it to detect subtle mismatches that would otherwise lead to hallucination.

When documents are flagged as ambiguous, CRAG triggers a targeted decomposition step. The query is broken into sub-queries and re-executed against the knowledge base. Retrieved passages are then segmented into granular knowledge strips, and the evaluator re-scores each strip. Only strips that pass the relevance threshold are retained, effectively filtering noise from partially relevant documents and extracting the precise factual nuggets needed for grounding.

If the evaluator classifies all retrieved documents as incorrect or irrelevant, CRAG abandons the internal knowledge base entirely. It triggers an external web search via a search API, treating the open web as a supplementary knowledge source. The retrieved web results are then fed into the knowledge refinement pipeline for strip-level evaluation. This ensures the system never generates from poor context, gracefully degrading to broader search when proprietary data is insufficient.

The architecture operates as a closed feedback loop rather than a linear pipeline. After any corrective action—refinement or web search—the evaluator re-assesses the new context. This iterative cycle continues until sufficient high-confidence knowledge strips are assembled. The loop design prevents cascading errors by ensuring that only verified, relevant information reaches the generation phase, making CRAG inherently more robust than static retrieve-then-generate architectures.

A deterministic arbitration layer governs the transition between CRAG's operational modes. It consumes the evaluator's confidence scores and enforces a rule-based policy:

• Correct documents → proceed directly to generation
• Ambiguous documents → trigger knowledge refinement
• Incorrect documents → trigger web search fallback This explicit control flow makes the system's behavior auditable and predictable, unlike implicit model-based routing.

The gatekeeper module in CRAG that assesses the quality of fetched documents before they reach the generation step. It classifies retrieved results into three confidence tiers:

• Correct: Documents are relevant and sufficient; proceed directly to generation
• Incorrect: Documents are irrelevant; trigger an external web search fallback
• Ambiguous: Partial relevance detected; combine internal and external sources

The evaluator typically uses a fine-tuned Natural Language Inference (NLI) model or a lightweight cross-encoder to compute relevance scores between the query and each retrieved passage.

The post-retrieval optimization step triggered when the evaluator deems documents ambiguous. Rather than discarding partially relevant content, CRAG decomposes the retrieved text into atomic statements and filters out those with low entailment scores.

This process:

• Strips irrelevant or contradictory sentences from passages
• Preserves only factual segments that directly support the query
• Passes the refined knowledge to the generator alongside any supplementary web search results

The refinement step prevents the model from being distracted by noise in long documents.

The external grounding mechanism activated when the retrieval evaluator flags documents as incorrect. CRAG reformulates the original query into optimized search terms and queries public search APIs to fetch fresh, relevant content.

Key design considerations:

• Query rewriting to maximize search engine recall
• Deduplication against already-retrieved internal documents
• Re-ranking of web results using the same evaluator model
• Caching frequently accessed external sources to reduce latency

This fallback transforms CRAG from a closed-book to an open-domain verification system.

While both Self-RAG and Corrective RAG implement self-critique loops, they differ architecturally:

• Self-RAG trains special reflection tokens directly into the language model, making retrieval decisions and critique an intrinsic part of token generation
• CRAG uses an external evaluator module decoupled from the generator, allowing plug-and-play swapping of retrieval assessment models without retraining the LLM
• Self-RAG critiques output during generation; CRAG evaluates documents before generation begins

CRAG's decoupled design offers greater modularity and easier debugging of retrieval failures.

The mathematical backbone of the retrieval evaluator. For each retrieved document-passage pair, an NLI model computes:

• Entailment probability: The passage logically supports the query's information need
• Contradiction probability: The passage directly conflicts with known facts
• Neutral probability: No logical relationship detected

CRAG aggregates these scores across all retrieved documents to assign the overall confidence tier. A passage with entailment score > 0.7 typically qualifies as Correct, while scores < 0.3 trigger the web search fallback.

CRAG functions as a specialized reasoning step within broader agentic RAG architectures. In an agent loop:

• The agent decomposes a complex query into sub-questions
• Each sub-question triggers a CRAG pipeline for verified retrieval
• The agent synthesizes verified answers from multiple CRAG cycles
• If all retrieval attempts fail, the agent can escalate to a human or request clarification

This hierarchical design combines CRAG's document-level self-correction with agentic task-level planning, creating a robust multi-hop reasoning system that verifies facts at every step.