LLM Hallucination Complete Guide [2026] - Understanding, Detecting & Eliminating AI Confabulation

user_query = "What year did Einstein win the Nobel Prize in Physics?"

hallucinated_response = "Einstein won the Nobel Prize in Physics in 1905 for his theory of relativity."

correct_response = "Einstein won the Nobel Prize in Physics in 1921 for his theory of the photoelectric effect, not relativity."

def simplified_llm_generation(prompt, temperature=1.0):
    """
    Simplified demonstration of LLM generation process
    Higher temperature = more randomness = higher hallucination risk
    """
    probabilities = model.predict_next_token(prompt)
    
    if temperature > 0:
        probabilities = apply_temperature(probabilities, temperature)
    
    next_token = sample_from_distribution(probabilities)
    
    return next_token

from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
from langchain_openai import ChatOpenAI

def rag_with_hallucination_reduction(query, knowledge_base):
    """
    Example of using RAG to reduce hallucinations
    """
    embeddings = OpenAIEmbeddings()
    vectorstore = Chroma.from_documents(knowledge_base, embeddings)
    
    relevant_docs = vectorstore.similarity_search(query, k=5)
    context = "\n".join([doc.page_content for doc in relevant_docs])
    
    prompt = f"""Answer the question based on the following reference materials.
    
Rules:
1. Only use information from the reference materials
2. If the materials don't contain relevant information, clearly state "Unable to answer based on available materials"
3. Do not fabricate any information

Reference Materials:
{context}

Question: {query}

Answer:"""
    
    llm = ChatOpenAI(model="gpt-4-turbo", temperature=0)
    response = llm.invoke(prompt)
    
    return response.content

anti_hallucination_prompt = """
You are a rigorous AI assistant. When answering questions, please follow these principles:

## Core Principles
1. **Honesty**: If uncertain, clearly state so
2. **Verifiability**: Provide verifiable information sources when possible
3. **Conservatism**: Better to say less than to fabricate

## Response Format
- Certain information: State directly
- Uncertain information: Use qualifiers like "to my knowledge", "possibly"
- Unable to answer: Clearly state "I don't have enough information to answer this question"

## Prohibited Behaviors
- Do not fabricate citations, statistics, or expert quotes
- Do not invent non-existent events or people
- Do not give definitive answers to questions beyond your knowledge scope

User Question: {question}
"""

def adjust_temperature_for_task(task_type):
    """
    Adjust temperature parameter based on task type
    """
    temperature_map = {
        "factual_qa": 0.0,
        "summarization": 0.3,
        "translation": 0.3,
        "creative_writing": 0.7,
        "brainstorming": 1.0
    }
    return temperature_map.get(task_type, 0.5)

def multi_model_verification(query, models):
    """
    Multi-model cross-validation to reduce hallucinations
    """
    responses = []
    for model in models:
        response = model.generate(query)
        responses.append(response)
    
    consensus = find_consensus(responses)
    
    confidence = calculate_agreement_score(responses)
    
    return {
        "answer": consensus,
        "confidence": confidence,
        "requires_verification": confidence < 0.8
    }

import re
from typing import List, Dict, Any
from dataclasses import dataclass
from langchain_openai import ChatOpenAI
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma

@dataclass
class FactCheckResult:
    claim: str
    verdict: str
    confidence: float
    evidence: List[str]
    explanation: str

class HallucinationDetector:
    """LLM Hallucination Detection and Fact-Checking System"""
    
    def __init__(self, knowledge_base_path: str = None):
        self.llm = ChatOpenAI(model="gpt-4-turbo", temperature=0)
        self.embeddings = OpenAIEmbeddings()
        self.knowledge_base = None
        
        if knowledge_base_path:
            self.load_knowledge_base(knowledge_base_path)
    
    def load_knowledge_base(self, path: str):
        """Load knowledge base for fact-checking"""
        from langchain.document_loaders import DirectoryLoader
        
        loader = DirectoryLoader(path, glob="**/*.txt")
        documents = loader.load()
        self.knowledge_base = Chroma.from_documents(
            documents, 
            self.embeddings
        )
    
    def extract_claims(self, text: str) -> List[str]:
        """Extract factual claims from text"""
        prompt = f"""Extract all factual claims (statements that can be verified as true or false) from the following text.
        
List each claim on a separate line, excluding opinions or subjective judgments.

Text:
{text}

Factual Claims:"""
        
        response = self.llm.invoke(prompt)
        claims = [c.strip() for c in response.content.split('\n') if c.strip()]
        return claims
    
    def verify_claim(self, claim: str) -> FactCheckResult:
        """Verify a single claim"""
        evidence = []
        if self.knowledge_base:
            docs = self.knowledge_base.similarity_search(claim, k=3)
            evidence = [doc.page_content for doc in docs]
        
        evidence_text = "\n".join(evidence) if evidence else "No available evidence"
        
        prompt = f"""As a fact-checking expert, please verify the following claim.

Claim: {claim}

Reference Evidence:
{evidence_text}

Please analyze and provide:
1. Verdict (Supported/Refuted/Unable to Verify)
2. Confidence (a value between 0-1)
3. Detailed explanation

Format:
Verdict: [result]
Confidence: [value]
Explanation: [detailed description]"""
        
        response = self.llm.invoke(prompt)
        result = self._parse_verification_result(response.content, claim, evidence)
        
        return result
    
    def _parse_verification_result(
        self, 
        response: str, 
        claim: str, 
        evidence: List[str]
    ) -> FactCheckResult:
        """Parse verification result"""
        verdict = "Unable to Verify"
        confidence = 0.5
        explanation = response
        
        if "Supported" in response:
            verdict = "Supported"
        elif "Refuted" in response:
            verdict = "Refuted"
        
        confidence_match = re.search(r'Confidence[：:]\s*([\d.]+)', response)
        if confidence_match:
            confidence = float(confidence_match.group(1))
        
        return FactCheckResult(
            claim=claim,
            verdict=verdict,
            confidence=confidence,
            evidence=evidence,
            explanation=explanation
        )
    
    def check_consistency(self, text: str) -> Dict[str, Any]:
        """Check internal consistency of text"""
        prompt = f"""Analyze whether the following text contains internal contradictions or logical inconsistencies.

Text:
{text}

Please identify:
1. Whether contradictions exist (Yes/No)
2. Specific contradictions (if any)
3. Severity of contradictions (High/Medium/Low)"""
        
        response = self.llm.invoke(prompt)
        
        has_contradiction = "Yes" in response.content and "contradiction" in response.content.lower()
        
        return {
            "has_contradiction": has_contradiction,
            "analysis": response.content
        }
    
    def full_check(self, text: str) -> Dict[str, Any]:
        """Complete hallucination detection workflow"""
        claims = self.extract_claims(text)
        
        claim_results = []
        for claim in claims:
            result = self.verify_claim(claim)
            claim_results.append(result)
        
        consistency = self.check_consistency(text)
        
        hallucination_score = self._calculate_hallucination_score(
            claim_results, 
            consistency
        )
        
        return {
            "claims_checked": len(claims),
            "claim_results": claim_results,
            "consistency_check": consistency,
            "hallucination_score": hallucination_score,
            "recommendation": self._get_recommendation(hallucination_score)
        }
    
    def _calculate_hallucination_score(
        self, 
        claim_results: List[FactCheckResult],
        consistency: Dict
    ) -> float:
        """Calculate hallucination risk score (0-1, higher means more risk)"""
        if not claim_results:
            return 0.5
        
        refuted_count = sum(1 for r in claim_results if r.verdict == "Refuted")
        unverified_count = sum(1 for r in claim_results if r.verdict == "Unable to Verify")
        total = len(claim_results)
        
        claim_score = (refuted_count * 1.0 + unverified_count * 0.5) / total
        
        consistency_score = 0.3 if consistency["has_contradiction"] else 0
        
        return min(1.0, claim_score * 0.7 + consistency_score)
    
    def _get_recommendation(self, score: float) -> str:
        """Provide recommendation based on score"""
        if score < 0.2:
            return "Low Risk: Content has high credibility"
        elif score < 0.5:
            return "Medium Risk: Recommend manual review of key information"
        else:
            return "High Risk: Strongly recommend fact-checking"


if __name__ == "__main__":
    detector = HallucinationDetector()
    
    test_text = """
    According to research, GPT-4 was released in 2022 and is OpenAI's most powerful model.
    The model has 1 trillion parameters and training costs exceeded $1 billion.
    OpenAI CEO Sam Altman stated that GPT-5 will be released by the end of 2024.
    """
    
    result = detector.full_check(test_text)
    
    print(f"Claims Checked: {result['claims_checked']}")
    print(f"Hallucination Risk Score: {result['hallucination_score']:.2f}")
    print(f"Recommendation: {result['recommendation']}")