RAG Hallucination Detection: Faithfulness Metrics That Work

Retrieved context:
  "Apple Inc. was founded on April 1, 1976 by Steve Jobs, Steve Wozniak, and Ronald Wayne."

LLM answer (correct):
  "Apple was founded in 1976 by Jobs, Wozniak, and Wayne." → Faithful ❌

LLM answer (hallucination):
  "Apple was founded in 1976 by Steve Jobs and Steve Wozniak." → Faithful ✓
  "Apple was founded in 1977 at Stanford University."            → Hallucination ✗
  "Apple's first product was the iPad, launched in 2000."        → Hallucination ✗

Production monitoring (low latency, high throughput):
  → NLI Faithfulness (lightweight model, batch processing)
  → Logit-based (precomputed, free)

Development/offline evaluation (high accuracy):
  → LLM-as-Judge (most reliable)
  → FActScore (detailed fact decomposition)

Budget constraint:
  → NLI Faithfulness (open source, no API costs)
  → BERTScore QA-based (lightweight)

Need both speed AND accuracy:
  → Two-stage: Logit-based (fast pass 1) → NLI (deep check for flagged items)

Step 1: Extract atomic claims from LLM answer
  "Apple was founded in 1976 by Steve Jobs and Steve Wozniak."
  → [Claim 1] "Apple was founded in 1976"
  → [Claim 2] "Apple was founded by Steve Jobs"
  → [Claim 3] "Apple was founded by Steve Wozniak"

Step 2: For each claim, check against retrieved context using NLI
  Context: "Apple Inc. was founded on April 1, 1976 by Steve Jobs, Steve Wozniak, and Ronald Wayne."

  Claim 1: "Apple was founded in 1976"
  → NLI(context, claim) → ENTAILMENT ✓

  Claim 2: "Apple was founded by Steve Jobs"
  → NLI(context, claim) → ENTAILMENT ✓

  Claim 3: "Apple was founded by Steve Wozniak"
  → NLI(context, claim) → ENTAILMENT ✓

Step 3: Aggregate
  Faithfulness = (count entailments) / (total claims)
  Faithfulness = 3/3 = 1.0 (completely faithful)

Another example:
  Claim: "Apple was founded in 1977"
  → NLI(context, claim) → CONTRADICTION ✗
  Faithfulness = 0.66 (2/3 claims supported)

from transformers import pipeline
from typing import List

class NLIFaithfulnessDetector:
    def __init__(self, model_name="microsoft/deberta-v3-large-mnli"):
        self.nli_pipeline = pipeline(
            "zero-shot-classification",
            model=model_name
        )

    def extract_claims(self, answer: str) -> List[str]:
        """Simple claim extraction via sentence splitting."""
        import re
        claims = re.split(r'(?<=[.!?])\s+', answer)
        return [c.strip() for c in claims if c.strip()]

    def check_claim(self, claim: str, context: str) -> tuple:
        """Check if claim is entailed by context."""
        result = self.nli_pipeline(
            claim,
            candidate_labels=["entailment", "contradiction", "neutral"],
            hypothesis_template="The context says: {}"
        )
        label = result["labels"][0]
        score = result["scores"][0]
        return label, score

    def faithfulness_score(self, answer: str, context: str) -> float:
        """Compute faithfulness as fraction of supported claims."""
        claims = self.extract_claims(answer)
        if not claims:
            return 1.0

        supported = 0
        for claim in claims:
            label, score = self.check_claim(claim, context)
            if label == "entailment":
                supported += 1

        return supported / len(claims)

# Usage
detector = NLIFaithfulnessDetector()
answer = "Apple was founded in 1976 by Steve Jobs."
context = "Apple Inc. was founded on April 1, 1976 by Steve Jobs."

score = detector.faithfulness_score(answer, context)
print(f"Faithfulness: {score:.2f}")

Prompt to Judge LLM:

You are evaluating whether an AI answer is faithful to the provided context.
Rate the answer on faithfulness from 0-10.

Context:
{context}

Answer:
{answer}

Faithfulness definition: Every claim in the answer must be directly
supported by the context. Do not accept inferences that go beyond
the context. Numbers, dates, names, and relationships must match exactly.

Also provide a list of UNSUPPORTED_CLAIMS if any.

Response format:
SCORE: [0-10]
UNSUPPORTED_CLAIMS: [list or NONE]
REASONING: [brief explanation]

System: You are a strict faithfulness evaluator for RAG systems.
You will be given context documents and an LLM-generated answer.
Your job is to determine if every statement in the answer is
supported by the context.

Rules:
1. Only accept claims directly supported by the context
2. Exact numbers, dates, names must match
3. Do NOT accept "common knowledge" — if it's not in context, it's unsupported
4. Context may contain multiple chunks — the answer only needs support from any chunk
5. Be strict: unsupported = hallucination
6. Return JSON: {"faithfulness": 0.0-1.0, "unsupported_claims": [...], "explanation": "..."}

NLI-Based (preferred for most use cases):
  ✅ Production monitoring (fast, cheap, good accuracy)
  ✅ Offline evaluation pipelines (batch process thousands)
  ✅ Budget-constrained projects (free models)
  ✅ High-throughput systems (sub-second per evaluation)

LLM-as-Judge (preferred for high-stakes):
  ✅ Legal, medical, financial applications
  ✅ When accuracy > cost
  ✅ For debugging specific hallucination cases
  ✅ For building hallucination detection training data
  ✅ When you need human-interpretable explanations

1. For each answer generated by LLM, generate questions from it
2. Try to answer those questions using only the retrieved context
3. If answer matches → faithful
   If answer doesn't match → hallucination

Example:
  LLM answer: "The Eiffel Tower was built in 1889 for the World's Fair."

  Question generated: "When was the Eiffel Tower built?"
  Answer from context: "The Eiffel Tower was constructed between 1887 and 1889..."
  Match: Yes ✓ (1889 is within 1887-1889)

  Question generated: "What event was the Eiffel Tower built for?"
  Answer from context: "built for the 1889 Exposition Universelle (World's Fair)"
  Match: Yes ✓

  Faithfulness: 2/2 = 1.0 ✓

from transformers import pipeline
import nltk
from nltk import word_tokenize

class QAHallucinationDetector:
    def __init__(self):
        self.qa_pipeline = pipeline(
            "question-answering",
            model="deepset/roberta-base-squad2"
        )

    def answer_to_questions(self, answer: str):
        """Simple: split answer into sentences and create yes/no questions."""
        sentences = nltk.sent_tokenize(answer)
        questions = []
        for sent in sentences:
            # Generate a question: "Is it true that {sentence}?"
            q = f"Is it true that {sent.lower()}?"
            questions.append(q)
        return questions

    def check_answer(self, question: str, context: str, original: str) -> bool:
        """Check if QA model can answer with the same info."""
        result = self.qa_pipeline(
            question=question,
            context=context
        )
        # Simple: check if answer matches original statement
        return result["score"] > 0.3  # Threshold tuned for faithfulness

    def faithfulness_score(self, answer: str, context: str) -> float:
        questions = self.answer_to_questions(answer)
        if not questions:
            return 1.0

        supported = 0
        for q in questions:
            if self.check_answer(q, context, answer):
                supported += 1

        return supported / len(questions)

                    ┌──────────────┐
                    │  User Query  │
                    └──────┬───────┘
                           │
                    ┌──────▼───────┐
                    │   RAG App    │
                    │  (LLM + RAG) │
                    └──────┬───────┘
                           │
                    ┌──────▼───────┐
               ┌───▶  LLM Output  │
               │    └──────┬───────┘
               │           │
               │    ┌──────▼───────┐
               │    │Hallucination │
               │    │  Detector    │
               │    └──────┬───────┘
               │           │
               │    ┌──────▼───────┐
               │    │  Monitoring  │
               │    │  Dashboard   │
               │    └──────┬───────┘
               │           │
               │    ┌──────▼───────┐
               │    │  Alerting    │
               │    │(if <0.7 thr) │
               │    └──────┬───────┘
               │           │
               └───────────┘ (feedback loop for improvement)

1. Sample-based evaluation
   Don't score every generation (expensive). Use stratified
   sampling: 10% of all traffic, 50% of edge cases, 100% of
   flagged items.

2. Two-stage pipeline
   Stage 1 (cheap): Logit-based or perplexity → flag suspicious (5% cost)
   Stage 2 (expensive): NLI or LLM-as-Judge → deep check flagged items

3. Per-user and per-domain monitoring
   Different user segments may hallucinate differently
   Track faithfulness per document source, per query type

4. Graduated response
   Faithfulness 0.85-1.0: OK (log only)
   Faithfulness 0.70-0.85: Log + investigate (warn)
   Faithfulness 0.50-0.70: Log + alert + re-route to fallback model
   Faithfulness < 0.50: Block output, return "Unable to answer"

5. Context quality metrics
   Track: chunk relevance, retrieval score, context length
   Low context quality is the best predictor of hallucinations

from deepeval import evaluate
from deepeval.metrics import FaithfulnessMetric
from deepeval.test_case import LLMTestCase

# Set up metric
faithfulness = FaithfulnessMetric(
    threshold=0.7,
    model="gpt-4o",  # or "local" for NLI-based
)

# Evaluate
test_case = LLMTestCase(
    input="When was Apple founded?",
    actual_output="Apple was founded in 1976 by Steve Jobs.",
    retrieval_context=[
        "Apple Inc. was founded on April 1, 1976 by Steve Jobs, Steve Wozniak, and Ronald Wayne."
    ]
)

result = faithfulness.measure(test_case)
print(f"Faithfulness score: {faithfulness.score}")
print(f"Verdict: {'PASS' if result else 'FAIL'}")

from trulens_eval import Feedback, TruLlama
from trulens_eval.feedback.provider import OpenAI
from trulens_eval.feedback import Groundedness

provider = OpenAI(model_engine="gpt-4o")

# Define groundedness feedback
groundedness = Groundedness(groundedness_provider=provider)
f_groundedness = (
    Feedback(groundedness.groundedness_measure_with_cot_reasons, name="Groundedness")
    .on_input_output()
)

# Apply to your RAG app
tru_rag = TruLlama(
    rag_app,
    app_id="my-rag-app",
    feedbacks=[f_groundedness]
)

Combined Hallucination Risk Score:

Risk = w1 × (1 - NLI Faithfulness)
     + w2 × (1 - QA Faithfulness)
     + w3 × (Logit Uncertainty)
     + w4 × (1 - Retrieval Relevance)
     + w5 × (Source Freshness Score)

Where w1-w5 sum to 1 and are tuned on your data.

Example weights for production:
  w1 (NLI Faithfulness) = 0.40
  w2 (QA Faithfulness)  = 0.20
  w3 (Logit Uncertainty)= 0.15
  w4 (Retrieval)        = 0.15
  w5 (Freshness)        = 0.10

Thresholds:
  Risk < 0.2: Safe (return to user)
  Risk 0.2-0.4: Slight risk (maybe flag for review)
  Risk 0.4-0.7: High risk (do not return, re-route)
  Risk > 0.7: Critical (block, log, alert)