AI Hallucination Detection in Production — What Actually Works

interface GroundedResponse {
  answer: string;
  citations: Citation[];
  groundingScore: number;  // 0-1, % of claims grounded in sources
}
 
async function verifyGrounding(
  response: string,
  sourceDocuments: Document[]
): Promise<GroundedResponse> {
  // Extract factual claims from the response
  const claims = await extractClaims(response);
  
  // Check each claim against source documents
  const verified = await Promise.all(
    claims.map(async (claim) => {
      const match = await findSupportingEvidence(claim, sourceDocuments);
      return {
        claim: claim.text,
        supported: match.confidence > 0.8,
        source: match.document,
        confidence: match.confidence,
      };
    })
  );
 
  const groundingScore = verified.filter(v => v.supported).length / verified.length;
 
  return {
    answer: response,
    citations: verified.filter(v => v.supported).map(v => v.source),
    groundingScore,
  };
}

const validators: Record<string, Validator> = {
  orderNumber: {
    pattern: /ORD-\d{4,6}/,
    validate: async (id) => {
      const exists = await db.orders.exists({ id });
      return { valid: exists, type: "order_reference" };
    },
  },
  invoiceAmount: {
    pattern: /\$[\d,]+\.?\d{0,2}/,
    validate: async (amount, context) => {
      if (!context.orderId) return { valid: false, type: "unverifiable" };
      const invoice = await db.invoices.find({ orderId: context.orderId });
      return {
        valid: invoice?.amount === parseFloat(amount.replace(/[$,]/g, "")),
        type: "invoice_amount",
      };
    },
  },
  dateReference: {
    pattern: /\b\d{4}-\d{2}-\d{2}\b|(?:January|February|March|April|May|June|July|August|September|October|November|December)\s+\d{1,2}/,
    validate: async (date, context) => {
      // Verify date exists in related records
      return await verifyDateInContext(date, context);
    },
  },
};

async function calibrateResponse(response: string, context: RetrievalContext) {
  // Ask the model to self-evaluate (works better than you'd expect)
  const evaluation = await llm.evaluate({
    prompt: `Given ONLY the following source documents, rate your confidence 
    that the response is factually accurate. Be conservative.
    
    Source documents: ${context.documents}
    Response: ${response}
    
    Rate confidence 0-100 and explain any uncertain claims.`,
  });
 
  // Apply calibration curve (learned from historical data)
  const calibrated = calibrationCurve(evaluation.rawConfidence);
 
  return {
    response,
    confidence: calibrated,
    uncertainClaims: evaluation.uncertainClaims,
    action: calibrated > 0.8 ? "serve" : calibrated > 0.5 ? "flag" : "escalate",
  };
}