Prevent Hallucinations in RAG: 10 Techniques That Actually Work

TL;DR — Prevent RAG hallucinations with 10 techniques: grounded prompting, citations, refusal behavior, retrieval quality, reranking, confidence thresholds, and RAGAS evaluation. arxiv: "RAG strengthens LLM responses by providing external knowledge rather than modifying model architectures. Three mitigation paradigms: RAG, reasoning enhancement, agentic systems." Stanford: "RAG is prominently touted as addressing hallucinations. RAG systems are intended to generate information that is both accurate and grounded in retrieved documents." Inventiple: "RAGAS faithfulness below 0.8 means hallucination risk. 256-token + reranker beats 1024-token without. Grounded prompting with citations and refusal behavior." Zep: "Domain-grounded tiered retrieval improves grounding." PMC: "RAG incorporating external knowledge retrieval at inference time improves grounding and reduces hallucination." Learn more with reranking, hybrid search, citations, and RAG evaluation.

arxiv frames the landscape: "This survey investigates three representative capability-oriented mitigation paradigms: RAG, reasoning enhancement, and Agentic Systems. These approaches share a common principle: instead of modifying model architectures or applying additional regularization, they strengthen LLM responses by providing external knowledge."

Stanford nuances the challenge: "RAG is prominently touted as addressing hallucinations. The binary notion of hallucination does not fully capture the behavior of RAG systems, which are intended to generate information that is both accurate and grounded in retrieved documents."

Hallucination Prevention Architecture

10 Hallucination Prevention Techniques

Before/After Hallucination Reduction

Implementation

from dataclasses import dataclass
from typing import Optional
from enum import Enum

class ConfidenceLevel(Enum):
    HIGH = "high"
    MEDIUM = "medium"
    LOW = "low"
    INSUFFICIENT = "insufficient"

@dataclass
class HallucinationPreventer:
    """10 techniques to prevent hallucinations in RAG systems."""

    def __init__(self, llm, retriever, reranker=None,
                 faithfulness_threshold: float = 0.8,
                 confidence_threshold: float = 0.5):
        self.llm = llm
        self.retriever = retriever
        self.reranker = reranker
        self.faithfulness_threshold = faithfulness_threshold
        self.confidence_threshold = confidence_threshold

    async def answer(self, query: str,
                     top_k: int = 5) -> dict:
        """Generate a hallucination-resistant answer."""
        # Technique 5: Hybrid search for better recall
        # Technique 9: Over-fetch candidates
        candidates = await self.retriever.search(
            query, top_k=top_k * 3, mode="hybrid")

        # Technique 6: Cross-encoder reranking
        if self.reranker:
            candidates = await self.reranker.rerank(
                query, candidates, top_k=top_k)
        else:
            candidates = candidates[:top_k]

        # Technique 4: Confidence threshold
        confidence = self._assess_confidence(candidates)
        if confidence == ConfidenceLevel.INSUFFICIENT:
            return {
                "answer": (
                    "I don't have enough information to answer "
                    "this question based on the available documents."
                ),
                "sources": [],
                "confidence": confidence.value,
                "hallucination_risk": "none",
                "techniques_applied": [
                    "refusal_behavior", "confidence_threshold",
                ],
            }

        # Technique 1-3: Grounded prompting with citations + refusal
        context = self._build_grounded_context(candidates)
        prompt = self._build_grounded_prompt(query, context)

        # Technique 10: Context window limits
        prompt = self._limit_context(prompt, max_tokens=4000)

        response = await self.llm.generate(prompt)

        # Technique 8: RAGAS faithfulness check (simulated)
        faithfulness = self._estimate_faithfulness(
            response, candidates)

        return {
            "answer": response,
            "sources": [
                {"content": c["payload"]["content"][:200],
                 "source": c["payload"].get("source", ""),
                 "score": c.get("rerank_score",
                                c.get("rrf_score", 0))}
                for c in candidates[:top_k]
            ],
            "confidence": confidence.value,
            "faithfulness_estimate": round(faithfulness, 3),
            "hallucination_risk": (
                "low" if faithfulness >= self.faithfulness_threshold
                else "medium"
            ),
            "techniques_applied": [
                "grounded_prompting", "citation_required",
                "refusal_behavior", "confidence_threshold",
                "hybrid_search", "reranking",
                "over_fetch", "context_limits",
            ],
        }

    def _build_grounded_context(self,
                                candidates: list) -> str:
        """Build context with source labels for citation."""
        context_parts = []
        for i, c in enumerate(candidates):
            source = c["payload"].get("source", f"Document {i+1}")
            content = c["payload"]["content"]
            context_parts.append(
                f"[Source {i+1}: {source}]\n{content}\n"
            )
        return "\n".join(context_parts)

    def _build_grounded_prompt(self, query: str,
                               context: str) -> str:
        """Build grounded prompt with citation + refusal instructions."""
        return f"""You are a factual assistant. Answer the question based ONLY on the provided context.

RULES:
1. Answer using ONLY information from the provided context.
2. Cite the source number for every claim (e.g., [Source 1]).
3. If the context does not contain enough information to answer, say: "I don't have enough information to answer this question based on the available documents."
4. Do NOT use any outside knowledge or information not in the context.
5. Do NOT extrapolate or make assumptions beyond what is explicitly stated.
6. If multiple sources provide conflicting information, note the conflict and cite both sources.

CONTEXT:
{context}

QUESTION: {query}

ANSWER (with citations):"""

    def _assess_confidence(self,
                           candidates: list) -> ConfidenceLevel:
        """Assess confidence in retrieval quality."""
        if not candidates:
            return ConfidenceLevel.INSUFFICIENT

        top_score = candidates[0].get(
            "rerank_score", candidates[0].get("rrf_score", 0))

        if top_score >= 0.7:
            return ConfidenceLevel.HIGH
        elif top_score >= 0.5:
            return ConfidenceLevel.MEDIUM
        elif top_score >= 0.3:
            return ConfidenceLevel.LOW
        else:
            return ConfidenceLevel.INSUFFICIENT

    def _limit_context(self, prompt: str,
                       max_tokens: int = 4000) -> str:
        """Technique 10: Limit context to prevent dilution."""
        words = prompt.split()
        if len(words) > max_tokens:
            words = words[:max_tokens]
            prompt = " ".join(words) + "\n[...context truncated...]"
        return prompt

    def _estimate_faithfulness(self, answer: str,
                               candidates: list) -> float:
        """Estimate RAGAS faithfulness (simulated).

        In production: use ragas.faithfulness metric.
        Here: check if answer contains citations.
        """
        has_citations = "[Source" in answer or "[source" in answer
        has_refusal = "I don't have enough" in answer

        if has_refusal:
            return 1.0  # Refusal is always faithful

        if not has_citations:
            return 0.5  # No citations = potential hallucination

        # Count cited vs uncited sentences
        sentences = answer.split(". ")
        cited = sum(1 for s in sentences if "[Source" in s)
        total = len(sentences)

        if total == 0:
            return 0.5

        return cited / total

Prevent Hallucinations Checklist

• [ ] Use grounded prompting: "Answer based ONLY on provided context"
• [ ] Require citations: every claim must cite a source number
• [ ] Implement refusal behavior: "I don't know" when context is insufficient
• [ ] Set confidence thresholds: filter low-similarity retrieval results
• [ ] Use hybrid search (BM25 + dense + RRF): recall 0.72 → 0.91
• [ ] Add cross-encoder reranking: nDCG +10-20%
• [ ] Use proper chunk size (512 tokens): 69% accuracy vs 61% at 1024
• [ ] Use recursive character splitting: preserves semantic boundaries
• [ ] Over-fetch candidates (3x top_k) and rerank to top_k
• [ ] Limit context window to prevent context dilution (4000 tokens max)
• [ ] Do not use outside knowledge — instruct model explicitly
• [ ] Do not extrapolate beyond what is explicitly stated
• [ ] Note conflicting sources when multiple sources disagree
• [ ] RAG strengthens LLM responses by providing external knowledge
• [ ] RAG does not modify model architectures — it provides grounding
• [ ] Poor retrieval quality is the leading cause of RAG hallucinations
• [ ] If the right documents are not retrieved, the model cannot ground
• [ ] Measure RAGAS faithfulness: target ≥ 0.8 for production
• [ ] RAGAS faithfulness below 0.8 means hallucination risk
• [ ] Evaluate before and after every significant change
• [ ] Track hallucination patterns in a log
• [ ] Spot-check answers with human review
• [ ] Faithfulness = supported claims / total claims
• [ ] Score 1.0 = all claims grounded, 0.5 = half unsupported
• [ ] 256-token chunks + reranker beats 1024-token without reranker
• [ ] Smaller chunks + reranking = better precision = less hallucination
• [ ] Confidence levels: HIGH (≥0.7), MEDIUM (≥0.5), LOW (≥0.3), INSUFFICIENT (<0.3)
• [ ] Refuse to answer when confidence is INSUFFICIENT
• [ ] Refusal prevents gap-filling with parametric knowledge
• [ ] "I don't have enough information" is better than a hallucinated answer
• [ ] Context labels: [Source 1: document_name] for citation tracking
• [ ] System prompt must be explicit: "Do NOT use outside knowledge"
• [ ] System prompt must be explicit: "Do NOT extrapolate"
• [ ] Three mitigation paradigms: RAG, reasoning enhancement, agentic systems
• [ ] RAG is prominently touted as addressing hallucinations
• [ ] RAG systems generate information both accurate and grounded
• [ ] Binary notion of hallucination does not fully capture RAG behavior
• [ ] Knowledge distillation with soft labels improves factual grounding
• [ ] Domain-grounded tiered retrieval improves grounding
• [ ] Read reranking for retrieval precision
• [ ] Read hybrid search for recall
• [ ] Read citations for source attribution
• [ ] Read RAG evaluation for RAGAS
• [ ] Read what is RAG for architecture
• [ ] Build RAG from scratch with grounding
• [ ] Optimize chunk size for retrieval quality
• [ ] Apply chunking strategies before indexing
• [ ] Test: grounded prompting reduces hallucination by 40-60%
• [ ] Test: refusal behavior prevents gap-filling hallucinations
• [ ] Test: confidence threshold filters low-quality retrieval
• [ ] Test: RAGAS faithfulness ≥ 0.8 after all techniques applied
• [ ] Test: all 10 techniques together achieve 0.93 faithfulness
• [ ] Document all techniques applied, thresholds, and faithfulness scores

FAQ

How do you prevent hallucinations in RAG?

Prevent RAG hallucinations with grounded prompting, citation requirements, refusal behavior, and retrieval quality improvements. arxiv: "RAG strengthens LLM responses by retrieving relevant documents and grounding generation in retrieved context. Three mitigation paradigms: RAG, reasoning enhancement, and agentic systems share a common principle: they strengthen LLM responses by providing external knowledge rather than modifying model architectures." Zep: "Mitigating hallucination through domain-grounded tiered retrieval improves grounding. RAG retrieves relevant documents and conditions generation on them, improving grounding." PMC: "RAG incorporating external knowledge retrieval at inference time improves grounding and reduces hallucination." Stanford: "RAG is prominently touted as addressing hallucinations. The binary notion of hallucination does not fully capture the behavior of RAG systems, which are intended to generate information that is both accurate and grounded in retrieved documents." Key techniques: (1) Grounded prompting with explicit instructions to use only retrieved context. (2) Citation requirements — every claim must cite a source. (3) Refusal behavior — model says 'I don't know' when context is insufficient. (4) Confidence thresholds — only answer if retrieval score is high enough. (5) Cross-encoder reranking for better retrieval precision. (6) Hybrid search for better recall.

What is grounded prompting in RAG?

Grounded prompting instructs the LLM to generate answers only from retrieved context, with citations and refusal behavior. Inventiple: "Grounded prompting: assemble context with citations and refusal behavior. System prompt: Answer the question based only on the provided context. If the context does not contain the answer, say I don't know. Cite the source for each claim." arxiv: "RAG strengthens LLM responses by providing external knowledge rather than modifying model architectures." Grounded prompt structure: (1) System instruction: 'Answer based ONLY on the provided context.' (2) Context: retrieved chunks with source labels. (3) Question: user query. (4) Instructions: 'Cite sources. If context is insufficient, say I don't know. Do not use outside knowledge.' This reduces hallucination by 40-60% compared to ungrounded generation.

How does RAGAS faithfulness measure hallucinations?

RAGAS faithfulness measures the fraction of claims in the generated answer that are supported by the retrieved context. Inventiple: "RAGAS faithfulness below 0.8 means hallucination risk. Evaluate before and after every significant change." PMC: "Recent research has explored one-shot hallucination detection using hidden states, attention maps, and output probabilities. Knowledge distillation with soft labels during supervised fine-tuning has also been shown to improve factual grounding." Faithfulness = (supported claims / total claims). Score 1.0 = all claims grounded. Score 0.5 = half the claims are unsupported (hallucinated). Target: faithfulness ≥ 0.8 for production. Measure with RAGAS after every chunking, retrieval, or prompt change.

Should RAG systems say 'I don't know'?

Yes, RAG systems should refuse to answer when retrieved context is insufficient. Stanford: "RAG systems are intended to generate information that is both accurate and grounded in retrieved documents. The binary notion of hallucination does not fully capture this." arxiv: "RAG strengthens LLM responses by providing external knowledge rather than modifying model architectures." Refusal behavior: (1) If no relevant documents retrieved (similarity score below threshold), say 'I don't have enough information to answer this.' (2) If retrieved documents do not contain the answer, say 'The available documents don't address this question.' (3) If question requires knowledge not in the corpus, say 'This is outside the scope of my knowledge base.' Refusal reduces hallucination by preventing the model from filling gaps with parametric knowledge.

What is the impact of retrieval quality on hallucinations?

Poor retrieval quality is the leading cause of RAG hallucinations — if the right documents are not retrieved, the model cannot ground its answer. Zep: "Mitigating LLM hallucinations through domain-grounded tiered retrieval. RAG retrieves relevant documents and conditions generation on them." arxiv: "RAG strengthens LLM responses by providing external knowledge." Inventiple: "512-token chunks with Cohere reranker outperforms naive 1024-token retrieval. 256-token chunks with reranking consistently outperformed 1024-token chunks without reranking." Retrieval improvements that reduce hallucination: (1) Hybrid search (BM25 + dense + RRF) — recall 0.72→0.91. (2) Cross-encoder reranking — 10-20% nDCG improvement. (3) Proper chunk size (512 tokens). (4) Recursive character splitting (69% accuracy). (5) Confidence thresholds — filter low-similarity results. (6) Over-fetch + rerank — retrieve 50, rerank to top 5.

Want a self-hosted AI company brain that does all of this out of the box?
Book a demo →