5 System-Level Strategies to Mitigate LLM Hallucinations in Production

5 Practical Techniques to Detect and Mitigate LLM Hallucinations Beyond Prompt Engineering

Developers often encounter LLMs that confidently invent non-existent API endpoints or legal citations during system integration. This lack of grounding occurs because models generate responses based on learned patterns rather than checking facts against live, verified data sources.

Why This Matters

LLMs prioritize helpfulness and response generation over factual accuracy, often failing to admit when they lack specific information. Treating hallucination as a system-level architecture problem rather than a prompting issue allows engineering teams to build validation layers that maintain user trust even when the core model’s internal training data is static or incomplete.

Key Insights

• Retrieval-Augmented Generation (RAG) utilizes tools like FAISS and SentenceTransformers to provide real-time external context, shifting the source of truth from model memory to curated data.
• Self-consistency techniques involve querying a model multiple times; if answers diverge, it indicates a high probability of hallucination or model uncertainty.
• Constrained generation via JSON schemas or function calling restricts the model’s output space, preventing it from generating unsupported free-text formats in structured environments.
• Confidence scoring uses token probabilities or explicit model self-evaluation to flag low-certainty responses for downstream rejection or human review.
• Human-in-the-loop pipelines route inconsistent or high-risk outputs to reviewers, creating a safety net for edge cases that automated safeguards might miss.

Working Examples

A basic RAG implementation using SentenceTransformers for embeddings and FAISS for vector search to ground model responses.

from sentence_transformers import SentenceTransformer
import faiss
import numpy as np
from openai import OpenAI

embedder = SentenceTransformer("all-MiniLM-L6-v2")
documents = ["Our refund policy allows returns within 30 days.", "Shipping takes 3 to 5 business days."]
doc_embeddings = embedder.encode(documents).astype("float32")
index = faiss.IndexFlatL2(doc_embeddings.shape[1])
index.add(doc_embeddings)

query = "How long does delivery take?"
query_embedding = embedder.encode([query]).astype("float32")
_, indices = index.search(query_embedding, k=1)
retrieved_doc = documents[indices[0][0]]

client = OpenAI()
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "Answer using the provided context only."},
        {"role": "user", "content": f"Context: {retrieved_doc}\n\nQuestion: {query}"}
    ]
)
print(response.choices[0].message.content)

Using JSON schemas to enforce structural constraints on LLM outputs, reducing the risk of free-text hallucinations.

import json
from jsonschema import validate
from openai import OpenAI

client = OpenAI()
schema = {
    "type": "object",
    "properties": {
        "product_name": {"type": "string"},
        "price": {"type": "number"},
        "availability": {"type": "string", "enum": ["in_stock", "out_of_stock"]}
    },
    "required": ["product_name", "price", "availability"]
}

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "Extract product details in JSON format only."},
        {"role": "user", "content": "The iPhone 13 costs $799 and is currently available."}
    ],
    response_format={"type": "json_object"}
)

result = json.loads(response.choices[0].message.content)
validate(instance=result, schema=schema)
print(result)

Practical Applications

• Use Case: Customer support bots using RAG to fetch specific policy documents. Pitfall: Relying on poor indexing or irrelevant documents leads the model to guess when the retrieval step fails.
• Use Case: High-stakes financial or legal tools utilizing human-in-the-loop review for low-confidence scores. Pitfall: Treating the first response as final without verification layers allows subtle factual errors to reach users.

References:

• https://machinelearningmastery.com/5-practical-techniques-to-detect-and-mitigate-llm-hallucinations-beyond-prompt-engineering/