How to Detect LLM Hallucinations in Production Systems 2026

# ❌ Traditional testing catches syntax errors but not semantic hallucinations
def test_llm_response():
    response = llm.generate("What is the capital of France?")
    assert isinstance(response, str)  # ✅ Passes
    assert len(response) > 0  # ✅ Passes
    # But response could be "The capital of France is Lyon" ❌

# ❌ Keyword checking misses sophisticated hallucinations
def test_llm_keyword():
    response = llm.generate("What is the capital of France?")
    assert "Paris" in response  # Too brittle
    # Misses: "The historic capital Paris, though Berlin is now the capital"

# ✅ Need semantic understanding and fact verification
def test_llm_hallucination_aware():
    response = llm.generate("What is the capital of France?")

    # Extract structured answer
    answer = extract_city_name(response)

    # Verify against knowledge base
    assert verify_fact("capital", "France", answer)

    # Check model confidence
    confidence = get_model_confidence(response)
    if confidence < 0.8:
        # Flag for human review
        flag_uncertain_response(response)

from dataclasses import dataclass
from typing import List, Dict, Tuple
import numpy as np
from enum import Enum

class HallucinationSeverity(Enum):
    NONE = "none"
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"
    CRITICAL = "critical"

@dataclass
class TokenAnalysis:
    token: str
    position: int
    entailment_score: float  # 0.0 to 1.0
    is_hallucinated: bool
    confidence: float

@dataclass
class HallucinationReport:
    full_response: str
    hallucination_detected: bool
    severity: HallucinationSeverity
    confidence_score: float  # Overall confidence in response
    problematic_tokens: List[TokenAnalysis]
    safe_to_show_user: bool
    recommendation: str

class HaluGateDetector:
    """
    Token-level hallucination detection inspired by HaluGate
    Uses consistency checking against source context
    """

    def __init__(
        self,
        entailment_threshold: float = 0.7,
        critical_threshold: float = 0.5
    ):
        self.entailment_threshold = entailment_threshold
        self.critical_threshold = critical_threshold

    def check_entailment(
        self,
        premise: str,  # Source context
        hypothesis: str  # Generated token in context
    ) -> float:
        """
        Check if hypothesis is entailed by premise
        Returns score 0.0 (contradiction) to 1.0 (entailment)

        In production, use a model like:
        - DeBERTa-v3-base-mnli
        - RoBERTa-large-mnli
        - Or API like Cohere's NLI endpoint
        """

        # Simulate NLI model for demo
        # In production: Use actual NLI model
        premise_lower = premise.lower()
        hypothesis_lower = hypothesis.lower()

        # Simple heuristic for demo (replace with real NLI)
        if hypothesis_lower in premise_lower:
            return 0.95  # Strong entailment

        # Check for semantic overlap
        premise_words = set(premise_lower.split())
        hypothesis_words = set(hypothesis_lower.split())
        overlap = len(premise_words & hypothesis_words) / len(hypothesis_words) if hypothesis_words else 0

        return min(0.9, overlap * 1.2)  # Scale overlap to entailment score

    def detect_hallucinations(
        self,
        source_context: str,
        generated_response: str
    ) -> HallucinationReport:
        """
        Analyze generated response for hallucinations
        Returns detailed report with token-level analysis
        """

        # Split response into sentences for analysis
        sentences = generated_response.split('. ')
        token_analyses = []
        problematic_tokens = []

        for sent_idx, sentence in enumerate(sentences):
            # Check entailment of each sentence against context
            sentence_with_context = f"{sentence}."
            entailment_score = self.check_entailment(
                premise=source_context,
                hypothesis=sentence_with_context
            )

            is_hallucinated = entailment_score < self.entailment_threshold
            is_critical = entailment_score < self.critical_threshold

            analysis = TokenAnalysis(
                token=sentence,
                position=sent_idx,
                entailment_score=entailment_score,
                is_hallucinated=is_hallucinated,
                confidence=entailment_score
            )

            token_analyses.append(analysis)

            if is_hallucinated:
                problematic_tokens.append(analysis)

        # Calculate overall metrics
        if not token_analyses:
            overall_confidence = 0.0
        else:
            overall_confidence = np.mean([t.entailment_score for t in token_analyses])

        hallucination_detected = len(problematic_tokens) > 0

        # Determine severity
        if not hallucination_detected:
            severity = HallucinationSeverity.NONE
        else:
            critical_count = sum(1 for t in problematic_tokens if t.entailment_score < self.critical_threshold)
            hallucination_rate = len(problematic_tokens) / len(token_analyses)

            if critical_count > 0 or hallucination_rate > 0.5:
                severity = HallucinationSeverity.CRITICAL
            elif hallucination_rate > 0.3:
                severity = HallucinationSeverity.HIGH
            elif hallucination_rate > 0.15:
                severity = HallucinationSeverity.MEDIUM
            else:
                severity = HallucinationSeverity.LOW

        # Safety recommendation
        safe_to_show = severity in [HallucinationSeverity.NONE, HallucinationSeverity.LOW]

        if severity == HallucinationSeverity.CRITICAL:
            recommendation = "BLOCK: Do not show to user. Response contains critical hallucinations."
        elif severity == HallucinationSeverity.HIGH:
            recommendation = "WARN: Show with disclaimer or regenerate response."
        elif severity == HallucinationSeverity.MEDIUM:
            recommendation = "CAUTION: Flag uncertain sections for user."
        else:
            recommendation = "OK: Safe to show to user."

        return HallucinationReport(
            full_response=generated_response,
            hallucination_detected=hallucination_detected,
            severity=severity,
            confidence_score=overall_confidence,
            problematic_tokens=problematic_tokens,
            safe_to_show_user=safe_to_show,
            recommendation=recommendation
        )

    def generate_user_friendly_report(self, report: HallucinationReport) -> str:
        """Generate human-readable report"""

        output = "=== HALLUCINATION DETECTION REPORT ===\n\n"

        if report.severity == HallucinationSeverity.NONE:
            output += "✅ No hallucinations detected\n"
            output += f"Confidence Score: {report.confidence_score:.2%}\n"
            return output

        output += f"⚠️  Hallucination Detected: {report.severity.value.upper()}\n"
        output += f"Overall Confidence: {report.confidence_score:.2%}\n"
        output += f"Safe to Show User: {'Yes' if report.safe_to_show_user else 'NO'}\n\n"

        output += f"Recommendation: {report.recommendation}\n\n"

        if report.problematic_tokens:
            output += "Problematic Sections:\n"
            for token in report.problematic_tokens:
                output += f"  - Position {token.position}: '{token.token[:50]}...'\n"
                output += f"    Entailment Score: {token.entailment_score:.2%}\n"

        return output

# Usage Example
detector = HaluGateDetector(
    entailment_threshold=0.7,
    critical_threshold=0.5
)

# Example: Medical information (high-risk domain)
source_context = """
Aspirin is a common pain reliever and anti-inflammatory medication.
It works by blocking the production of prostaglandins.
The typical adult dose is 325-650mg every 4-6 hours.
It should not be given to children with viral infections due to Reye's syndrome risk.
"""

# ✅ Accurate response
accurate_response = """
Aspirin is an effective pain reliever that works by blocking prostaglandins.
Adults typically take 325-650mg every 4-6 hours.
It should not be given to children with viral infections.
"""

# ❌ Hallucinated response
hallucinated_response = """
Aspirin is a pain reliever that works by increasing endorphin production.
Adults should take 1000mg every 2 hours for maximum effectiveness.
It is safe for all children and has no significant side effects.
"""

# Check accurate response
print("Checking ACCURATE response:")
report1 = detector.detect_hallucinations(source_context, accurate_response)
print(detector.generate_user_friendly_report(report1))

print("\n" + "="*60 + "\n")

# Check hallucinated response
print("Checking HALLUCINATED response:")
report2 = detector.detect_hallucinations(source_context, hallucinated_response)
print(detector.generate_user_friendly_report(report2))

if not report2.safe_to_show_user:
    print("\n🚨 ALERT: Response blocked due to critical hallucinations")

# Example: High token probability doesn't mean factually correct
response_1 = "The capital of France is Paris"  # High prob, correct ✅
response_2 = "The capital of France is Lyon"   # High prob, WRONG ❌

# Both can have high token probabilities if the model learned wrong patterns

from typing import List, Set
import numpy as np
from collections import defaultdict

class SemanticEntropyDetector:
    """
    Detect hallucinations using semantic entropy
    Measures uncertainty by generating multiple responses and clustering by meaning
    """

    def __init__(self, num_samples: int = 5):
        self.num_samples = num_samples

    def generate_multiple_responses(
        self,
        prompt: str,
        llm_function
    ) -> List[str]:
        """
        Generate multiple responses to same prompt
        Uses temperature > 0 for diversity
        """
        responses = []

        for i in range(self.num_samples):
            # In production: Use your LLM API
            # response = llm_function(prompt, temperature=0.7)
            # For demo, simulate varied responses
            responses.append(f"Simulated response {i} to: {prompt}")

        return responses

    def cluster_by_meaning(
        self,
        responses: List[str]
    ) -> Dict[str, List[str]]:
        """
        Cluster responses by semantic meaning
        In production: Use sentence embeddings + clustering
        - sentence-transformers
        - OpenAI embeddings
        - Cohere embeddings
        """

        # Simplified clustering for demo
        # In production: Use actual embeddings + DBSCAN/KMeans
        clusters = defaultdict(list)

        for response in responses:
            # Get semantic fingerprint
            # Real implementation: embedding = model.encode(response)
            # cluster_id = assign_to_cluster(embedding)

            # Simplified: Use first 20 chars as "meaning"
            meaning_key = response[:20]
            clusters[meaning_key].append(response)

        return dict(clusters)

    def calculate_semantic_entropy(
        self,
        clusters: Dict[str, List[str]]
    ) -> float:
        """
        Calculate entropy over meaning clusters
        High entropy = model is uncertain about the answer
        """

        total_responses = sum(len(responses) for responses in clusters.values())

        # Calculate probability of each cluster
        cluster_probs = [
            len(responses) / total_responses
            for responses in clusters.values()
        ]

        # Calculate entropy: H = -Σ p(x) * log(p(x))
        entropy = -sum(
            p * np.log2(p) for p in cluster_probs if p > 0
        )

        return entropy

    def detect_with_semantic_entropy(
        self,
        prompt: str,
        llm_function,
        entropy_threshold: float = 1.0
    ) -> Dict:
        """
        Full semantic entropy pipeline
        Returns detection result with confidence metrics
        """

        # 1. Generate multiple responses
        responses = self.generate_multiple_responses(prompt, llm_function)

        # 2. Cluster by meaning
        clusters = self.cluster_by_meaning(responses)

        # 3. Calculate entropy
        entropy = self.calculate_semantic_entropy(clusters)

        # 4. Determine if hallucination likely
        high_uncertainty = entropy > entropy_threshold
        num_distinct_meanings = len(clusters)

        # If model gives many different answers, it's uncertain
        is_hallucinating = high_uncertainty and num_distinct_meanings > 2

        return {
            'entropy': entropy,
            'high_uncertainty': high_uncertainty,
            'num_distinct_meanings': num_distinct_meanings,
            'likely_hallucinating': is_hallucinating,
            'responses': responses,
            'clusters': clusters,
            'consensus_response': max(clusters.values(), key=len)[0] if clusters else None
        }

# Usage Example
detector = SemanticEntropyDetector(num_samples=5)

# Mock LLM function
def mock_llm(prompt, temperature=0.7):
    # Simulate: Sometimes consistent, sometimes inconsistent
    if "capital of France" in prompt:
        # Low entropy: Consistent correct answers
        return np.random.choice([
            "The capital of France is Paris.",
            "Paris is the capital of France.",
            "France's capital city is Paris."
        ])
    else:
        # High entropy: Model is uncertain, generates varied hallucinations
        return np.random.choice([
            "The answer is definitely A.",
            "Research shows it's B.",
            "According to studies, it's C.",
            "The correct answer is D.",
            "Most experts agree it's E."
        ])

# Test 1: Low entropy (model is confident and correct)
print("Test 1: Question with low entropy (model knows answer)")
result1 = detector.detect_with_semantic_entropy(
    "What is the capital of France?",
    mock_llm,
    entropy_threshold=1.0
)
print(f"Entropy: {result1['entropy']:.2f}")
print(f"Distinct meanings: {result1['num_distinct_meanings']}")
print(f"Likely hallucinating: {result1['likely_hallucinating']}")

print("\n" + "="*60 + "\n")

# Test 2: High entropy (model is uncertain, likely hallucinating)
print("Test 2: Question with high entropy (model uncertain)")
result2 = detector.detect_with_semantic_entropy(
    "What is the population of Atlantis?",  # Fictional city
    mock_llm,
    entropy_threshold=1.0
)
print(f"Entropy: {result2['entropy']:.2f}")
print(f"Distinct meanings: {result2['num_distinct_meanings']}")
print(f"Likely hallucinating: {result2['likely_hallucinating']}")

if result2['likely_hallucinating']:
    print("\n⚠️  WARNING: High semantic entropy detected - model is uncertain")
    print("Recommendation: Do not show response without fact-checking")

from typing import List, Dict, Callable
from dataclasses import dataclass

@dataclass
class MetamorphicTest:
    test_type: str
    original_question: str
    transformed_question: str
    original_answer: str
    transformed_answer: str
    is_consistent: bool
    inconsistency_score: float

class MetaQADetector:
    """
    Metamorphic testing for LLM hallucination detection
    Checks consistency across question transformations
    """

    def __init__(self, llm_function: Callable):
        self.llm = llm_function
        self.tests: List[MetamorphicTest] = []

    def test_paraphrase_consistency(
        self,
        original_question: str
    ) -> MetamorphicTest:
        """
        Test if paraphrased question yields same answer
        Metamorphic relation: Paraphrase(Q) should give same answer as Q
        """

        # Generate paraphrase
        paraphrase_prompt = f"Rephrase this question: {original_question}"
        paraphrased_q = self.llm(paraphrase_prompt)

        # Get answers to both
        original_answer = self.llm(original_question)
        paraphrased_answer = self.llm(paraphrased_q)

        # Check semantic equivalence
        is_consistent = self._are_semantically_equivalent(
            original_answer,
            paraphrased_answer
        )

        inconsistency_score = 0.0 if is_consistent else 1.0

        return MetamorphicTest(
            test_type="paraphrase",
            original_question=original_question,
            transformed_question=paraphrased_q,
            original_answer=original_answer,
            transformed_answer=paraphrased_answer,
            is_consistent=is_consistent,
            inconsistency_score=inconsistency_score
        )

    def test_decomposition_consistency(
        self,
        complex_question: str,
        sub_questions: List[str]
    ) -> MetamorphicTest:
        """
        Test if answer to complex question matches composed sub-answers
        Metamorphic relation: Answer(Q_complex) should equal Compose(Answer(Q1), Answer(Q2))
        """

        # Get answer to complex question
        complex_answer = self.llm(complex_question)

        # Get answers to sub-questions
        sub_answers = [self.llm(sq) for sq in sub_questions]

        # Compose sub-answers
        composed_answer = " ".join(sub_answers)

        # Check if complex answer is consistent with composition
        is_consistent = self._are_semantically_equivalent(
            complex_answer,
            composed_answer
        )

        inconsistency_score = 0.0 if is_consistent else 1.0

        return MetamorphicTest(
            test_type="decomposition",
            original_question=complex_question,
            transformed_question="; ".join(sub_questions),
            original_answer=complex_answer,
            transformed_answer=composed_answer,
            is_consistent=is_consistent,
            inconsistency_score=inconsistency_score
        )

    def test_addition_invariance(
        self,
        original_question: str,
        irrelevant_info: str
    ) -> MetamorphicTest:
        """
        Test if adding irrelevant information changes answer
        Metamorphic relation: Answer(Q + Irrelevant) should equal Answer(Q)
        """

        # Get original answer
        original_answer = self.llm(original_question)

        # Add irrelevant information
        modified_question = f"{original_question} {irrelevant_info}"

        # Get answer with irrelevant info
        modified_answer = self.llm(modified_question)

        # Should be same answer
        is_consistent = self._are_semantically_equivalent(
            original_answer,
            modified_answer
        )

        inconsistency_score = 0.0 if is_consistent else 1.0

        return MetamorphicTest(
            test_type="addition_invariance",
            original_question=original_question,
            transformed_question=modified_question,
            original_answer=original_answer,
            transformed_answer=modified_answer,
            is_consistent=is_consistent,
            inconsistency_score=inconsistency_score
        )

    def test_negation_consistency(
        self,
        positive_question: str
    ) -> MetamorphicTest:
        """
        Test if negated question yields opposite answer
        Metamorphic relation: Answer(NOT Q) should be opposite of Answer(Q)
        """

        # Get answer to positive question
        positive_answer = self.llm(positive_question)

        # Create negated version
        # Simple negation: "Is X true?" -> "Is X false?"
        negated_question = positive_question.replace("Is", "Is it false that")

        # Get answer to negated question
        negated_answer = self.llm(negated_question)

        # Check if answers are opposite
        is_consistent = self._are_opposite(positive_answer, negated_answer)

        inconsistency_score = 0.0 if is_consistent else 1.0

        return MetamorphicTest(
            test_type="negation",
            original_question=positive_question,
            transformed_question=negated_question,
            original_answer=positive_answer,
            transformed_answer=negated_answer,
            is_consistent=is_consistent,
            inconsistency_score=inconsistency_score
        )

    def _are_semantically_equivalent(self, answer1: str, answer2: str) -> bool:
        """
        Check if two answers are semantically equivalent
        In production: Use NLI model or embedding similarity
        """

        # Simplified check for demo
        # In production: Use sentence embeddings + cosine similarity

        # Normalize
        a1 = answer1.lower().strip()
        a2 = answer2.lower().strip()

        # Exact match
        if a1 == a2:
            return True

        # Check key term overlap
        words1 = set(a1.split())
        words2 = set(a2.split())
        overlap = len(words1 & words2) / len(words1 | words2) if words1 | words2 else 0

        return overlap > 0.6  # 60% word overlap threshold

    def _are_opposite(self, answer1: str, answer2: str) -> bool:
        """Check if answers are logically opposite"""

        # Simplified check
        a1_lower = answer1.lower()
        a2_lower = answer2.lower()

        # Check for opposite boolean values
        if ("yes" in a1_lower and "no" in a2_lower) or \
           ("no" in a1_lower and "yes" in a2_lower):
            return True

        if ("true" in a1_lower and "false" in a2_lower) or \
           ("false" in a1_lower and "true" in a2_lower):
            return True

        return False

    def run_full_metamorphic_suite(
        self,
        question: str
    ) -> Dict:
        """
        Run all metamorphic tests
        Returns aggregated inconsistency score
        """

        tests = []

        # Test 1: Paraphrase consistency
        tests.append(self.test_paraphrase_consistency(question))

        # Test 2: Addition invariance
        tests.append(self.test_addition_invariance(
            question,
            "Note: This is being asked on a Tuesday."
        ))

        # Calculate overall inconsistency
        total_inconsistency = sum(t.inconsistency_score for t in tests)
        avg_inconsistency = total_inconsistency / len(tests)

        # High inconsistency suggests hallucination
        likely_hallucinating = avg_inconsistency > 0.5

        return {
            'tests_run': len(tests),
            'tests_passed': sum(1 for t in tests if t.is_consistent),
            'avg_inconsistency': avg_inconsistency,
            'likely_hallucinating': likely_hallucinating,
            'test_results': tests
        }

# Mock LLM for testing
def mock_llm(prompt: str) -> str:
    """Simulated LLM that sometimes hallucinates"""
    import random

    if "capital of France" in prompt.lower():
        # Consistent correct answer
        return "The capital of France is Paris."
    elif "rephrase" in prompt.lower():
        # Return paraphrase
        return prompt.replace("Rephrase this question:", "").strip()
    elif "tuesday" in prompt.lower():
        # Should ignore irrelevant day information
        if random.random() < 0.7:
            return "The capital of France is Paris."
        else:
            return "On Tuesday, France's capital is Lyon."  # Hallucination!
    else:
        # Random hallucination
        return random.choice([
            "The answer is uncertain.",
            "According to sources, it's unclear.",
            "The information is not available."
        ])

# Usage
detector = MetaQADetector(llm_function=mock_llm)

print("Running Metamorphic Testing Suite...")
result = detector.run_full_metamorphic_suite(
    "What is the capital of France?"
)

print(f"\nTests Run: {result['tests_run']}")
print(f"Tests Passed: {result['tests_passed']}")
print(f"Average Inconsistency: {result['avg_inconsistency']:.2%}")
print(f"Likely Hallucinating: {result['likely_hallucinating']}")

if result['likely_hallucinating']:
    print("\n⚠️  WARNING: Metamorphic tests failed - response may be hallucinated")
    print("Recommendation: Flag for human review")

from datetime import datetime, timedelta
from typing import List
import time

class HallucinationMonitor:
    """
    Production monitoring system for LLM hallucinations
    Tracks rates, patterns, and triggers alerts
    """

    def __init__(self):
        self.events: List[Dict] = []
        self.alert_threshold = 0.15  # Alert if hallucination rate > 15%

    def log_generation(
        self,
        prompt: str,
        response: str,
        hallucination_detected: bool,
        confidence_score: float,
        detection_method: str,
        user_id: str = None,
        session_id: str = None
    ):
        """Log every LLM generation for monitoring"""

        event = {
            'timestamp': datetime.now(),
            'prompt': prompt[:100],  # Truncate for storage
            'response': response[:200],
            'hallucination_detected': hallucination_detected,
            'confidence_score': confidence_score,
            'detection_method': detection_method,
            'user_id': user_id,
            'session_id': session_id
        }

        self.events.append(event)

        # Check if alert needed
        self._check_alert_threshold()

    def _check_alert_threshold(self):
        """Check if hallucination rate exceeds threshold"""

        # Look at last hour
        one_hour_ago = datetime.now() - timedelta(hours=1)
        recent_events = [
            e for e in self.events
            if e['timestamp'] > one_hour_ago
        ]

        if len(recent_events) < 10:
            return  # Need more data

        hallucination_rate = sum(
            1 for e in recent_events if e['hallucination_detected']
        ) / len(recent_events)

        if hallucination_rate > self.alert_threshold:
            self._trigger_alert(hallucination_rate, len(recent_events))

    def _trigger_alert(self, rate: float, sample_size: int):
        """Send alert to ops team"""
        print(f"\n🚨 ALERT: Hallucination rate {rate:.1%} exceeds threshold {self.alert_threshold:.1%}")
        print(f"   Sample size: {sample_size} requests in last hour")
        print(f"   Action: Review recent model changes, check for data drift")

    def generate_metrics_report(self, time_window_hours: int = 24) -> Dict:
        """Generate metrics report for dashboard"""

        cutoff = datetime.now() - timedelta(hours=time_window_hours)
        recent = [e for e in self.events if e['timestamp'] > cutoff]

        if not recent:
            return {'error': 'No data in time window'}

        total_generations = len(recent)
        hallucinations = sum(1 for e in recent if e['hallucination_detected'])
        hallucination_rate = hallucinations / total_generations

        # Average confidence
        avg_confidence = sum(e['confidence_score'] for e in recent) / total_generations

        # Breakdown by detection method
        by_method = {}
        for event in recent:
            method = event['detection_method']
            if method not in by_method:
                by_method[method] = {'total': 0, 'hallucinations': 0}
            by_method[method]['total'] += 1
            if event['hallucination_detected']:
                by_method[method]['hallucinations'] += 1

        # Hallucinations per user (identify problem areas)
        by_user = {}
        for event in recent:
            user = event.get('user_id', 'anonymous')
            if user not in by_user:
                by_user[user] = {'total': 0, 'hallucinations': 0}
            by_user[user]['total'] += 1
            if event['hallucination_detected']:
                by_user[user]['hallucinations'] += 1

        return {
            'time_window_hours': time_window_hours,
            'total_generations': total_generations,
            'hallucinations_detected': hallucinations,
            'hallucination_rate': hallucination_rate,
            'average_confidence': avg_confidence,
            'by_detection_method': by_method,
            'top_affected_users': sorted(
                by_user.items(),
                key=lambda x: x[1]['hallucinations'],
                reverse=True
            )[:5],
            'status': 'CRITICAL' if hallucination_rate > 0.20 else
                     'WARNING' if hallucination_rate > 0.15 else 'OK'
        }

# Usage Example
monitor = HallucinationMonitor()

# Simulate production traffic
for i in range(100):
    # Simulate detection (85% accurate detection rate)
    is_hallucination = (i % 7 == 0)  # ~14% hallucination rate

    monitor.log_generation(
        prompt=f"User question {i}",
        response=f"Generated response {i}",
        hallucination_detected=is_hallucination,
        confidence_score=0.85 if not is_hallucination else 0.60,
        detection_method="semantic_entropy",
        user_id=f"user_{i % 10}",
        session_id=f"session_{i}"
    )

# Generate report
print("\n" + "="*60)
print("HALLUCINATION MONITORING REPORT (24 HOURS)")
print("="*60 + "\n")

report = monitor.generate_metrics_report(time_window_hours=24)

print(f"Status: {report['status']}")
print(f"Total Generations: {report['total_generations']}")
print(f"Hallucinations Detected: {report['hallucinations_detected']}")
print(f"Hallucination Rate: {report['hallucination_rate']:.2%}")
print(f"Average Confidence: {report['average_confidence']:.2%}")

print(f"\nTop Affected Users:")
for user, stats in report['top_affected_users']:
    user_rate = stats['hallucinations'] / stats['total'] if stats['total'] > 0 else 0
    print(f"  {user}: {stats['hallucinations']}/{stats['total']} ({user_rate:.1%})")