LLM Hallucination: Why AI Makes Things Up and 5 Strategies to Prevent It

How an LLM works at its core:

Input tokens → [Transformer layers] → probability distribution over next token → sample

Example:
"Paris is the ___" → {"capital": 0.91, "city": 0.06, "heart": 0.02, ...}
                   → select "capital"

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.prompts import ChatPromptTemplate

# The key: explicitly forbid fabrication
SYSTEM_PROMPT = """You are a helpful assistant that answers questions ONLY based on the provided context.

Rules:
1. Never make up information not in the context
2. If the answer isn't in the context, say "I don't have information about this in the provided documents"
3. Always cite which part of the context supports your answer

Context:
{context}
"""

def rag_query(question: str, vectorstore) -> dict:
    # Retrieve relevant documents
    docs = vectorstore.similarity_search(question, k=4)
    context = "\n\n---\n\n".join([doc.page_content for doc in docs])

    prompt = ChatPromptTemplate.from_messages([
        ("system", SYSTEM_PROMPT),
        ("human", "{question}")
    ])

    llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.1)
    chain = prompt | llm

    response = chain.invoke({
        "context": context,
        "question": question
    })

    return {
        "answer": response.content,
        "sources": [doc.metadata.get("source", "unknown") for doc in docs]
    }

def self_critique_pipeline(question: str, llm) -> str:
    """Two-pass self-critique to reduce hallucination"""

    # Pass 1: Generate initial answer
    initial_response = llm.invoke(
        f"Please answer the following question: {question}"
    )
    initial_answer = initial_response.content

    # Pass 2: Self-review (separate call, no memory of pass 1's reasoning)
    critique_prompt = f"""Review the following question and answer critically.

Question: {question}
Answer: {initial_answer}

Check for:
1. Factual accuracy — are any claims potentially wrong?
2. Unsupported specifics — dates, names, numbers that might be invented?
3. Outdated information that may have changed?

Mark uncertain claims explicitly, and provide a revised answer with corrections if needed.
Uncertain claims should use phrases like "as of my last training data" or "I believe, but please verify."
"""

    critique_response = llm.invoke(critique_prompt)
    return critique_response.content

# Usage
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4o", temperature=0.3)
result = self_critique_pipeline(
    "What were the main architectural innovations in GPT-3?",
    llm
)

def chain_of_verification(question: str, llm) -> dict:
    """
    Step 1: Generate initial answer
    Step 2: Extract verifiable claims as questions
    Step 3: Answer each verification question independently
    Step 4: Correct the final answer using verification results
    """

    # Step 1: Initial answer
    initial = llm.invoke(question).content

    # Step 2: Extract verification questions
    verification_prompt = f"""From the following answer, extract the key factual claims
and turn each into a standalone verification question.

Answer: {initial}

Format: one verification question per line.
Focus on specific facts: dates, names, numbers, relationships."""

    vq_raw = llm.invoke(verification_prompt).content
    questions = [q.strip() for q in vq_raw.split('\n') if q.strip()]

    # Step 3: Answer each independently (without seeing the original answer)
    verifications = {}
    for vq in questions[:5]:  # Cap at 5 to control costs
        answer = llm.invoke(
            f"Answer this question concisely and accurately: {vq}"
        ).content
        verifications[vq] = answer

    # Step 4: Produce corrected final answer
    correction_prompt = f"""Original question: {question}
Original answer: {initial}

Verification results:
{chr(10).join([f'Q: {q}\nA: {a}' for q, a in verifications.items()])}

Using the verification results, produce an improved final answer.
Where verification revealed uncertainty, use hedged language ("reportedly", "as of 2023", etc.)"""

    final_answer = llm.invoke(correction_prompt).content

    return {
        "initial_answer": initial,
        "verifications": verifications,
        "final_answer": final_answer
    }

from openai import OpenAI
client = OpenAI()

def factual_query(prompt: str) -> str:
    """Conservative settings for fact-based queries"""
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.1,     # Low: stick to highest-probability tokens
        top_p=0.9,           # Only sample from top 90% probability mass
        presence_penalty=0.0,   # Don't penalize repetition of established facts
        frequency_penalty=0.0   # Same
    )
    return response.choices[0].message.content

def creative_query(prompt: str) -> str:
    """Relaxed settings for creative tasks"""
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.9,     # High: allow exploration
        top_p=0.95
    )
    return response.choices[0].message.content

# Task-appropriate dispatch
answer = factual_query("Explain the difference between TCP and UDP")
story = creative_query("Write a short story about an AI that becomes self-aware")

CITATION_SYSTEM = """When answering questions, you MUST tag every factual claim:

- [Source: X] — where X is the specific source you're drawing from
- [Source: unknown] — for facts you believe are true but can't cite specifically
- [Inference] — for logical conclusions you're drawing yourself

Example:
"Python was first released in 1991 [Source: Python docs / Guido van Rossum].
It is now one of the most popular languages worldwide [Source: Stack Overflow Survey 2024].
It will likely remain dominant in ML for the next decade [Inference]."

Never omit source tags. If you would need to say [Source: unknown] for too many claims,
say so upfront and reduce the scope of your answer.
"""

def cited_response(question: str, llm) -> str:
    from langchain.schema import SystemMessage, HumanMessage
    messages = [
        SystemMessage(content=CITATION_SYSTEM),
        HumanMessage(content=question)
    ]
    response = llm.invoke(messages)
    return response.content

from ragas import evaluate
from ragas.metrics import faithfulness, answer_relevancy, context_precision

# Measures: does the answer stay faithful to the retrieved context?
# Score: 0.0 (fabricates everything) to 1.0 (perfectly grounded)
results = evaluate(
    dataset=test_dataset,  # questions, answers, contexts, ground_truths
    metrics=[faithfulness, answer_relevancy, context_precision]
)

print(f"Faithfulness:       {results['faithfulness']:.3f}")   # Target: >0.85
print(f"Answer Relevancy:   {results['answer_relevancy']:.3f}")  # Target: >0.80
print(f"Context Precision:  {results['context_precision']:.3f}") # Target: >0.75

class HallucinationConfig:
    """Hallucination-minimizing configs for different task types"""

    FACTUAL = {
        "temperature": 0.1,
        "system_suffix": "\n\nIf you're unsure about any fact, say so explicitly.",
        "use_rag": True,
        "self_critique": True
    }

    CONVERSATIONAL = {
        "temperature": 0.7,
        "system_suffix": "\n\nBe honest when you don't know something.",
        "use_rag": False,
        "self_critique": False
    }

    CODE = {
        "temperature": 0.2,
        "system_suffix": "\n\nOnly suggest functions and methods that actually exist.",
        "use_rag": True,   # Documentation-grounded RAG
        "self_critique": True
    }