Como Reduzir Alucinações de IA em Produção: Grounding, RAG e Guardrails que Realmente Funcionam

Sua feature de IA foi pra produção na terça. Na quinta, um usuário tirou screenshot do chatbot citando com total confiança um caso da Suprema Corte que não existe. Na sexta, já tinha 47 tickets no suporte sobre o chatbot inventando funcionalidades do produto que nunca foram construídas. Na segunda, o PM tá pedindo pra "só colocar um disclaimer."

Parece familiar? Você não tá sozinho. No início de 2026, apenas 29% dos desenvolvedores confiam nos outputs de IA — caiu de 40% em 2024. Quase metade do código gerado por IA entra nos codebases sem review completo. O problema não é que os LLMs estão quebrados — é que a gente tá colocando eles em produção sem a infra de engenharia necessária pra detectar quando eles falham.

Alucinações não são um bug que dá pra patchear. São uma propriedade fundamental de como os modelos de linguagem funcionam. Mas isso não quer dizer que você tá sem opções. Existe uma disciplina de engenharia crescente focada em tornar os LLMs confiavelmente úteis — e é muito mais profundo que "só bota RAG."

Este guia cobre o stack completo de redução de alucinações: entender por que os modelos alucinam, implementar técnicas de grounding, construir pipelines RAG eficazes, adicionar guardrails de saída e monitorar taxas de alucinação em produção. Cada técnica vem com código TypeScript que você pode adaptar hoje.

Por que LLMs alucinam: O modelo mental pra engenheiros

Antes de corrigir alucinações, precisa entender por que elas acontecem. Não a explicação acadêmica — o modelo mental prático que ajuda a prever quando vão ocorrer.

A máquina de autocompletar

LLMs não "sabem" coisas. Eles preveem o token mais provável dado os tokens anteriores. Quando você pergunta pro GPT-5 "Qual é a capital da França?", ele não consulta um fato — gera "Paris" porque é a continuação estatisticamente mais provável do prompt nos dados de treinamento.

Essa distinção importa porque explica quando alucinações acontecem:

1. Regiões de baixa confiança. Quando o modelo encontra um prompt onde múltiplas continuações são igualmente prováveis, ele escolhe uma. Às vezes escolhe errado.

2. Lacunas nos dados de treino. Informação que não estava (ou era escassa) nos dados de treinamento força o modelo a interpolar. Ele não diz "não sei" por padrão — gera texto que parece plausível.

3. Pressão pra seguir instruções. Quando você manda o modelo "sempre dar uma resposta", ele vai dar — mesmo quando não deveria. A instrução de ser útil conflita com a instrução de ser preciso.

4. Overflow de janela de contexto. Quando informação relevante tá enterrada num contexto longo, o modelo pode ignorar e gerar da memória paramétrica. É o problema do "perdido no meio."

5. Fabricação induzida por formato. Quando você pede output estruturado (JSON, tabelas), o modelo pode inventar valores pra preencher campos obrigatórios em vez de deixar vazio.

Taxonomia de alucinações

Nem toda alucinação é igual. Categorizar ajuda a escolher a contramedida certa:

Cada tipo precisa de mitigação diferente. Fabricação factual precisa de grounding. Fabricação de fonte precisa de verificação de citação. Alucinação de instrução precisa de enforcement de uso de ferramentas. Vamos montar as defesas.

Camada 1: Grounding — Ancorar o modelo na realidade

Grounding é a prática de fornecer ao modelo material fonte autoritativo e restringir ele pra gerar respostas baseadas nesse material. É a técnica mais fundamental pra reduzir alucinações.

Engenharia de system prompt pra grounding

O system prompt é a primeira linha de defesa. A maioria dos devs escreve prompts que incentivam alucinação sem perceber:

// ❌ Esse system prompt incentiva alucinação
const badSystemPrompt = `Você é um agente de suporte ao cliente simpático da Acme Corp.
Responda todas as perguntas de forma completa e útil.`;

// ✅ Esse system prompt reduz alucinação
const goodSystemPrompt = `Você é um agente de suporte ao cliente da Acme Corp.

REGRAS CRÍTICAS:
1. Responda APENAS usando os documentos de contexto fornecidos.
2. Se a resposta não estiver no contexto, diga: "Não tenho essa informação. Posso te conectar com um atendente."
3. NUNCA invente funcionalidades, preços ou políticas do produto.
4. Ao citar informação, referencie a seção específica do documento.
5. Se não tiver certeza sobre algum detalhe, diga explicitamente.

Sua data de corte de conhecimento significa que informações atuais podem não estar disponíveis.
Em caso de dúvida, direcione pra docs.acme.com.`;

Padrões-chave:

• Permissão explícita pra dizer "não sei." Modelos geram algo por padrão. Você precisa autorizar explicitamente a abstenção.
• Especificar limite de conhecimento. Diga ao modelo exatamente de onde o conhecimento dele vem.
• Exigir citações. Quando o modelo precisa citar fontes, ele alucina menos porque citações fabricadas são mais fáceis de detectar.
• Penalizar confiança. Frases como "se não tiver certeza, diga" ativam os mecanismos de calibração do modelo.

Exemplos few-shot de grounding

Exemplos few-shot são surpreendentemente eficazes pra ensinar ao modelo quando se abster:

const groundingExamples = [
  {
    role: "user",
    content: "Qual é a garantia de uptime do plano Enterprise?"
  },
  {
    role: "assistant",
    content: "De acordo com a documentação de preços (Seção 3.2), o plano Enterprise inclui SLA de uptime de 99.99% com créditos financeiros pra qualquer downtime que exceda esse limite."
  },
  {
    role: "user",
    content: "Vocês suportam integração com SAP?"
  },
  {
    role: "assistant",
    content: "Não encontro SAP listado na documentação de integrações atual. Recomendo conferir nossa página de integrações em docs.acme.com/integrations pra a lista mais atualizada, ou posso te conectar com nosso time de integrações pra discutir opções personalizadas."
  }
];

O segundo exemplo é o que importa. Ele ensina ao modelo a forma de uma resposta honesta de "não sei" — que ainda é útil sem fabricar informação.

Temperatura e controles de sampling

Temperatura baixa não elimina alucinações, mas reduz fabricação criativa:

import OpenAI from 'openai';

const openai = new OpenAI();

async function groundedCompletion(
  systemPrompt: string,
  context: string,
  userQuery: string
) {
  const response = await openai.chat.completions.create({
    model: 'gpt-5',
    temperature: 0.1,        // Temperatura baixa pra tarefas factuais
    top_p: 0.9,              // Nucleus sampling levemente restrito
    frequency_penalty: 0.3,  // Desincentivar padrões repetitivos
    presence_penalty: 0.0,   // Não forçar diversidade (queremos precisão)
    messages: [
      { role: 'system', content: systemPrompt },
      { role: 'user', content: `Contexto:\n${context}\n\nPergunta: ${userQuery}` }
    ],
  });

  return response.choices[0].message.content;
}

Nuance importante: Temperatura 0 não significa "zero alucinações." Significa que o modelo escolhe o token mais provável a cada passo. Se a continuação mais provável for uma alucinação (porque o modelo genuinamente não tem a informação certa), temperatura 0 vai alucinar com confiança máxima.

Camada 2: RAG — Alimentar o modelo com o que ele precisa

Retrieval-Augmented Generation é a técnica mais adotada pra reduzir alucinações. A ideia é simples: em vez de depender da memória paramétrica do modelo, você busca documentos relevantes e injeta no contexto.

Mas a maioria das implementações RAG é mediana pra reduzir alucinações porque focam na qualidade da busca e ignoram a outra metade: como o modelo usa o contexto recuperado.

O pipeline RAG que realmente reduz alucinações

// Passo 1: Estratégia de chunking importa mais que modelo de embedding
function intelligentChunk(document: string, metadata: Record<string, any>) {
  const sections = document.split(/\n## /);
  
  return sections.map((section, index) => ({
    content: index === 0 ? section : `## ${section}`,
    metadata: {
      ...metadata,
      sectionIndex: index,
      documentTitle: metadata.title,
      sectionTitle: section.split('\n')[0]?.trim() || 'Introduction',
      previousSection: index > 0 ? sections[index - 1].slice(-200) : null,
      nextSection: index < sections.length - 1 
        ? sections[index + 1].slice(0, 200) : null,
    }
  }));
}

// Passo 2: Busca com scoring de relevância
async function retrieveWithScoring(
  query: string,
  vectorStore: SupabaseVectorStore,
  options: { topK: number; scoreThreshold: number }
) {
  const results = await vectorStore.similaritySearchWithScore(
    query,
    options.topK * 2
  );

  const relevant = results
    .filter(([_, score]) => score >= options.scoreThreshold)
    .slice(0, options.topK);

  if (relevant.length === 0) {
    return {
      documents: [],
      confidence: 'none',
      message: 'Nenhum documento suficientemente relevante encontrado'
    };
  }

  return {
    documents: relevant.map(([doc, score]) => ({
      content: doc.pageContent,
      metadata: doc.metadata,
      relevanceScore: score
    })),
    confidence: relevant[0][1] > 0.85 ? 'high' : 'moderate',
    message: null
  };
}

// Passo 3: Geração com enforcement de citação
async function generateWithRAG(
  query: string,
  retrievalResult: Awaited<ReturnType<typeof retrieveWithScoring>>
) {
  if (retrievalResult.confidence === 'none') {
    return {
      answer: "Não tenho informação suficiente na base de conhecimento pra responder com precisão. Pode reformular a pergunta, ou prefere que eu te conecte com um especialista?",
      citations: [],
      confidence: 'none'
    };
  }

  const contextBlock = retrievalResult.documents
    .map((doc, i) => `[Fonte ${i + 1}: ${doc.metadata.documentTitle} > ${doc.metadata.sectionTitle}]\n${doc.content}`)
    .join('\n\n---\n\n');

  const response = await openai.chat.completions.create({
    model: 'gpt-5',
    temperature: 0.1,
    messages: [
      {
        role: 'system',
        content: `Você é um assistente preciso. Responda APENAS com base nas fontes fornecidas.

Regras:
- Cite fontes usando a notação [Fonte N]
- Se as fontes não respondem completamente, diga o que PODE e o que NÃO PODE responder
- Nunca extrapole além do que as fontes dizem explicitamente
- Se fontes se contradizem, apresente ambos os pontos de vista com citações`
      },
      {
        role: 'user',
        content: `Fontes:\n${contextBlock}\n\nPergunta: ${query}`
      }
    ]
  });

  return {
    answer: response.choices[0].message.content,
    citations: retrievalResult.documents.map(d => d.metadata),
    confidence: retrievalResult.confidence
  };
}

Os cinco erros de RAG que causam alucinações

Mesmo com RAG, a maioria das implementações continua alucinando. Por quê:

1. Sem threshold de relevância. Se seu pipeline RAG sempre retorna algo, o modelo vai tentar responder a partir de contexto irrelevante. Isso é pior que não ter contexto — dá falsa confiança ao modelo.

// ❌ Sempre retorna resultados, mesmo irrelevantes
const results = await vectorStore.similaritySearch(query, 5);

// ✅ Só retorna acima do threshold de relevância
const results = await vectorStore.similaritySearchWithScore(query, 10);
const filtered = results.filter(([_, score]) => score > 0.75);

2. Chunks pequenos demais. Fragmentos de 200 tokens perdem contexto. O modelo vê "a taxa é 4.5%" mas não vê que era de uma seção de preços de 2023 já atualizada.

3. Sem metadata de documento. Sem título, data e hierarquia de seção, o modelo não consegue avaliar autoridade ou atualidade da fonte. Trata um blog post de 3 anos atrás igual à documentação oficial de ontem.

4. Contexto demais. Mais contexto nem sempre é melhor. Com 15 chunks injetados, o modelo tem dificuldade pra identificar o relevante. O efeito "perdido no meio" faz com que informação nas posições 4-12 de um contexto de 15 chunks seja frequentemente ignorada.

5. Sem caminho de "não sei". Se o pipeline sempre gera resposta, vai alucinar quando o contexto não contém a resposta. Precisa de um caminho explícito de abstenção.

Busca híbrida: O melhor dos dois mundos

Busca vetorial pura perde matches exatos de keyword. Busca por keyword perde similaridade semântica. Busca híbrida combina as duas:

async function hybridSearch(
  query: string,
  supabase: any,
  options: { topK: number; vectorWeight: number }
) {
  const vectorResults = await supabase.rpc('match_documents', {
    query_embedding: await embedQuery(query),
    match_threshold: 0.7,
    match_count: options.topK * 2,
  });

  const keywordResults = await supabase.rpc('search_documents', {
    search_query: query,
    match_count: options.topK * 2,
  });

  // Reciprocal Rank Fusion (RRF) pra combinar resultados
  const scores = new Map<string, number>();
  const k = 60;

  vectorResults.data?.forEach((doc: any, rank: number) => {
    const id = doc.id;
    const score = (scores.get(id) || 0) + options.vectorWeight / (k + rank + 1);
    scores.set(id, score);
  });

  keywordResults.data?.forEach((doc: any, rank: number) => {
    const id = doc.id;
    const weight = 1 - options.vectorWeight;
    const score = (scores.get(id) || 0) + weight / (k + rank + 1);
    scores.set(id, score);
  });

  return Array.from(scores.entries())
    .sort((a, b) => b[1] - a[1])
    .slice(0, options.topK);
}

Camada 3: Guardrails de Output — Capturar alucinações pós-geração

Grounding e RAG reduzem alucinações. Guardrails capturam as que passam. É a rede de segurança.

Validação estrutural

O guardrail mais simples e eficaz: validar que o output bate com a estrutura esperada.

import { z } from 'zod';

const ProductRecommendationSchema = z.object({
  productName: z.string().min(1),
  productId: z.string().regex(/^PROD-\d{6}$/),
  price: z.number().positive(),
  inStock: z.boolean(),
  reasoning: z.string().min(20),
});

async function validateOutput(
  llmOutput: string,
  schema: z.ZodSchema,
  knownProducts: Map<string, any>
) {
  let parsed;
  try {
    parsed = schema.parse(JSON.parse(llmOutput));
  } catch (e) {
    return { valid: false, error: 'Validação estrutural falhou', data: null };
  }

  // Cruzar com dados reais
  const realProduct = knownProducts.get(parsed.productId);
  if (!realProduct) {
    return { valid: false, error: `Product ID ${parsed.productId} não existe`, data: null };
  }

  const issues: string[] = [];
  if (Math.abs(parsed.price - realProduct.price) > 0.01) {
    issues.push(`Preço incorreto: LLM disse ${parsed.price}, real é ${realProduct.price}`);
  }
  if (parsed.inStock !== realProduct.inStock) {
    issues.push(`Stock incorreto: LLM disse ${parsed.inStock}, real é ${realProduct.inStock}`);
  }

  return issues.length > 0
    ? { valid: false, error: issues.join('; '), data: parsed }
    : { valid: true, error: null, data: parsed };
}

LLM-as-Judge: Auto-verificação

Usar uma segunda chamada ao LLM pra verificar o primeiro output. Mais caro, mas captura alucinações sutis que validação estrutural não pega:

async function selfVerify(
  originalQuery: string,
  context: string,
  generatedAnswer: string
): Promise<{ isGrounded: boolean; issues: string[]; confidence: number }> {
  const verificationPrompt = `Você é um fact-checker. Verifique se a resposta gerada por IA está completamente respaldada pelo contexto fornecido.

Contexto:
${context}

Pergunta original: ${originalQuery}

Resposta gerada: ${generatedAnswer}

Analise a resposta frase por frase. Pra cada afirmação:
1. Está diretamente respaldada pelo contexto? (SUPPORTED)
2. É uma inferência razoável do contexto? (INFERRED)
3. Não se encontra no contexto? (UNSUPPORTED)
4. Contradiz o contexto? (CONTRADICTED)

Responda em JSON:
{
  "claims": [{ "claim": "...", "status": "...", "evidence": "..." }],
  "overallGrounded": true/false,
  "confidence": 0.0-1.0,
  "issues": ["..."]
}`;

  const verification = await openai.chat.completions.create({
    model: 'gpt-5',
    temperature: 0,
    response_format: { type: 'json_object' },
    messages: [
      { role: 'system', content: 'Você é um fact-checker preciso. Seja rigoroso.' },
      { role: 'user', content: verificationPrompt }
    ]
  });

  return JSON.parse(verification.choices[0].message.content!);
}

Otimização de custo: Não precisa verificar toda resposta. Implemente verificação seletiva:

function shouldVerify(response: string, context: any): boolean {
  // Sempre verificar respostas de alto risco
  if (context.category === 'medical' || context.category === 'legal') return true;
  
  // Verificar respostas com números (propensas a fabricação)
  if (/\d+%|\$\d+|\d+ (users|customers|times)/.test(response)) return true;
  
  // Verificar respostas que citam fontes específicas
  if (/according to|de acordo com|conforme/.test(response)) return true;
  
  // Pular verificação pra confirmações simples
  if (response.length < 100) return false;
  
  // Sampling aleatório pro resto (10%)
  return Math.random() < 0.1;
}

Verificação de citação

Quando o modelo afirma citar uma fonte, verifica se a citação existe e se o conteúdo realmente suporta a afirmação:

async function verifyCitations(
  answer: string,
  providedSources: Array<{ id: string; content: string; title: string }>
): Promise<{
  verified: boolean;
  fabricatedCitations: string[];
  unsupportedClaims: string[];
}> {
  const citationPattern = /\[Fonte (\d+)\]/g;
  const citedSources = new Set<number>();
  let match;
  
  while ((match = citationPattern.exec(answer)) !== null) {
    citedSources.add(parseInt(match[1]));
  }

  const fabricatedCitations: string[] = [];

  for (const sourceNum of citedSources) {
    if (sourceNum > providedSources.length || sourceNum < 1) {
      fabricatedCitations.push(`[Fonte ${sourceNum}] não existe`);
    }
  }

  return {
    verified: fabricatedCitations.length === 0,
    fabricatedCitations,
    unsupportedClaims: []
  };
}

Camada 4: Scoring de Confiança — Saber quando não sabe

Uma das técnicas mais poderosas e subutilizadas: fazer o modelo reportar sua própria confiança e usar esse sinal pra filtrar respostas.

Confiança por token

O GPT-5 da OpenAI suporta logprobs — log probabilidades pra cada token gerado. (Nota: a API do Claude da Anthropic não suporta logprobs atualmente; use confiança auto-reportada pro Claude.) Tokens de baixa probabilidade são sinais de alucinação:

⚠️ Nota sobre GPT-5: logprobs só tá disponível quando reasoning_effort tá em "none". Usar logprobs com outros níveis de raciocínio vai dar erro.

async function getConfidenceScore(
  prompt: string,
  systemPrompt: string
): Promise<{
  response: string;
  confidence: number;
  lowConfidenceSpans: Array<{ text: string; probability: number }>;
}> {
  const completion = await openai.chat.completions.create({
    model: 'gpt-5',
    temperature: 0,
    logprobs: true,
    top_logprobs: 3,
    messages: [
      { role: 'system', content: systemPrompt },
      { role: 'user', content: prompt }
    ]
  });

  const content = completion.choices[0].message.content!;
  const logprobs = completion.choices[0].logprobs?.content || [];

  const avgLogProb = logprobs.reduce(
    (sum, token) => sum + token.logprob, 0
  ) / logprobs.length;
  const confidence = Math.exp(avgLogProb);

  const lowConfidenceSpans: Array<{ text: string; probability: number }> = [];
  let currentSpan = '';
  let spanMinProb = 1;

  for (const token of logprobs) {
    const prob = Math.exp(token.logprob);
    if (prob < 0.5) {
      currentSpan += token.token;
      spanMinProb = Math.min(spanMinProb, prob);
    } else if (currentSpan) {
      lowConfidenceSpans.push({ text: currentSpan, probability: spanMinProb });
      currentSpan = '';
      spanMinProb = 1;
    }
  }

  if (currentSpan) {
    lowConfidenceSpans.push({ text: currentSpan, probability: spanMinProb });
  }

  return { response: content, confidence, lowConfidenceSpans };
}

Confiança auto-reportada

Pedir pro modelo avaliar sua própria confiança. Não é perfeito, mas combinado com outros sinais é surpreendentemente útil:

async function generateWithConfidence(query: string, context: string) {
  const response = await openai.chat.completions.create({
    model: 'gpt-5',
    temperature: 0.1,
    response_format: { type: 'json_object' },
    messages: [
      {
        role: 'system',
        content: `Responda a pergunta com base no contexto fornecido.
Pra cada parte da resposta, avalie sua confiança:
- HIGH: Diretamente declarado no contexto
- MEDIUM: Inferência razoável do contexto
- LOW: Não bem respaldado pelo contexto
- NONE: Especulação pura

Responda em JSON: {
  "answer": "resposta",
  "confidence_breakdown": [
    { "claim": "...", "confidence": "HIGH|MEDIUM|LOW|NONE", "source": "..." }
  ],
  "overall_confidence": "HIGH|MEDIUM|LOW|NONE",
  "caveats": ["limitações importantes"]
}`
      },
      {
        role: 'user',
        content: `Contexto:\n${context}\n\nPergunta: ${query}`
      }
    ]
  });

  const result = JSON.parse(response.choices[0].message.content!);

  if (result.overall_confidence === 'LOW' || result.overall_confidence === 'NONE') {
    return {
      ...result,
      shouldEscalate: true,
      userMessage: `Tenho confiança limitada nessa resposta. ${result.caveats?.join(' ') || 'A informação disponível pode não cobrir completamente a pergunta.'}`
    };
  }

  return { ...result, shouldEscalate: false };
}

Camada 5: Monitoramento em Produção — Medir o que importa

Não dá pra melhorar o que não mede. Veja como rastrear taxas de alucinação em produção.

Tracking de taxa de alucinação

interface HallucinationEvent {
  id: string;
  timestamp: Date;
  query: string;
  response: string;
  hallucinationType: 'factual' | 'source' | 'instruction' | 'coherence' | 'temporal';
  severity: 'critical' | 'moderate' | 'minor';
  detectionMethod: 'user_report' | 'guardrail' | 'self_verify' | 'citation_check';
  context: {
    model: string;
    temperature: number;
    ragUsed: boolean;
    retrievalScore: number | null;
    tokenConfidence: number;
  };
}

class HallucinationMonitor {
  private events: HallucinationEvent[] = [];

  async trackResponse(params: {
    query: string;
    response: string;
    context: string;
    model: string;
    ragScore: number | null;
    confidence: number;
  }) {
    const verificationResult = await selfVerify(
      params.query,
      params.context,
      params.response
    );

    if (!verificationResult.isGrounded) {
      const event: HallucinationEvent = {
        id: crypto.randomUUID(),
        timestamp: new Date(),
        query: params.query,
        response: params.response,
        hallucinationType: this.classifyHallucination(verificationResult.issues),
        severity: this.assessSeverity(verificationResult),
        detectionMethod: 'self_verify',
        context: {
          model: params.model,
          temperature: 0.1,
          ragUsed: params.ragScore !== null,
          retrievalScore: params.ragScore,
          tokenConfidence: params.confidence,
        }
      };

      this.events.push(event);
      if (event.severity === 'critical') {
        console.error(`🚨 Alucinação crítica detectada: ${event.hallucinationType}`);
      }
    }

    return verificationResult;
  }

  getMetrics(timeWindow: { start: Date; end: Date }) {
    const windowEvents = this.events.filter(
      e => e.timestamp >= timeWindow.start && e.timestamp <= timeWindow.end
    );

    return {
      totalResponses: windowEvents.length,
      hallucinationRate: windowEvents.length / (windowEvents.length || 1),
      byType: this.groupBy(windowEvents, 'hallucinationType'),
      bySeverity: this.groupBy(windowEvents, 'severity'),
    };
  }

  private classifyHallucination(issues: string[]): HallucinationEvent['hallucinationType'] {
    const issueText = issues.join(' ').toLowerCase();
    if (issueText.includes('source') || issueText.includes('citation')) return 'source';
    if (issueText.includes('contradict')) return 'coherence';
    return 'factual';
  }

  private assessSeverity(result: any): HallucinationEvent['severity'] {
    if (result.confidence < 0.3) return 'critical';
    if (result.confidence < 0.6) return 'moderate';
    return 'minor';
  }

  private groupBy<T>(arr: T[], key: keyof T) {
    return arr.reduce((acc, item) => {
      const k = String(item[key]);
      acc[k] = (acc[k] || 0) + 1;
      return acc;
    }, {} as Record<string, number>);
  }
}

Feedback de usuários

O sinal mais honesto: deixar os usuários reportarem alucinações e usar esses dados pra melhorar o pipeline.

async function handleFeedback(feedback: {
  responseId: string;
  feedbackType: 'hallucination' | 'incorrect' | 'helpful' | 'not_helpful';
  userComment?: string;
  correction?: string;
}) {
  await db.insert(feedbackTable).values({
    responseId: feedback.responseId,
    type: feedback.feedbackType,
    comment: feedback.userComment,
    correction: feedback.correction,
    timestamp: new Date(),
  });

  if (feedback.feedbackType === 'hallucination') {
    await db.insert(knownHallucinationsTable).values({
      responseId: feedback.responseId,
      userCorrection: feedback.correction,
      reviewStatus: 'pending',
    });
  }
}

Tudo junto: Pipeline de defesa em profundidade

Nenhuma técnica sozinha elimina alucinações. A abordagem de produção é defesa em profundidade:

async function safeAIResponse(
  query: string,
  userContext: { userId: string; category: string }
) {
  // Camada 1: Busca e scoring de contexto (RAG)
  const retrieval = await retrieveWithScoring(query, vectorStore, {
    topK: 5,
    scoreThreshold: 0.7,
  });

  // Camada 2: Geração grounded
  const generation = await generateWithRAG(query, retrieval);

  // Camada 3: Scoring de confiança
  const confidence = await getConfidenceScore(query, groundedSystemPrompt);

  // Camada 4: Verificação seletiva
  if (shouldVerify(generation.answer, userContext)) {
    const verification = await selfVerify(
      query,
      retrieval.documents.map(d => d.content).join('\n'),
      generation.answer
    );

    if (!verification.isGrounded) {
      return {
        response: "Quero te dar informação precisa. " +
          "Algumas partes da resposta inicial não puderam ser totalmente verificadas. " +
          "Vou te passar apenas o que tenho certeza.",
        confidence: 'low',
        citations: generation.citations,
        verified: false,
      };
    }
  }

  // Camada 5: Monitoramento
  await hallucinationMonitor.trackResponse({
    query,
    response: generation.answer,
    context: retrieval.documents.map(d => d.content).join('\n'),
    model: 'gpt-5',
    ragScore: retrieval.documents[0]?.relevanceScore || null,
    confidence: confidence.confidence,
  });

  return {
    response: generation.answer,
    confidence: generation.confidence,
    citations: generation.citations,
    verified: true,
  };
}

Checklist de redução de alucinações

Pré-lançamento

• System prompt permite explicitamente respostas "não sei"
• Temperatura ≤ 0.3 pra tarefas factuais
• Pipeline RAG com threshold de relevância
• Chunks com metadata (título, data, seção)
• Validação de schema pra outputs estruturados
• Verificação de citação implementada
• Scoring de confiança integrado (logprobs ou auto-reportado)
• Respostas de fallback pra outputs de baixa confiança

Pós-lançamento

• Dashboard de monitoramento de alucinações ativo
• Mecanismo de feedback de usuários implementado
• Dataset de alucinações conhecidas sendo construído
• Review semanal de métricas
• Framework de A/B testing pra melhoria de prompts
• Alertas configuradas pra picos críticos

Conclusão

Alucinações não vão desaparecer. A arquitetura fundamental dos LLMs — prever continuações prováveis — significa que sempre vão ter o potencial de gerar texto que soa plausível mas é falso. Nenhuma quantidade de RLHF, fine-tuning ou prompts engenhosos vai mudar isso completamente.

Mas isso não quer dizer que não dá pra construir features de IA confiáveis. Os times que tão mandando bem com produtos de IA em 2026 não acharam um prompt mágico. Eles construíram infra de engenharia em volta dos modelos: grounding, retrieval, guardrails, scoring de confiança, monitoramento e feedback loops.

O insight principal: trate outputs do LLM como input de usuário. Você não confiaria em input arbitrário de usuário sem validação. Não confie em output de LLM sem verificação também.

Comece pela camada que atende o maior risco. Se os usuários tão vendo fatos fabricados, implemente RAG com thresholds de relevância. Se tão vendo citações fabricadas, adicione verificação de citação. Se não sabe o que estão vendo, comece pelo monitoramento.

O objetivo não é perfeição. É engenharia de uma taxa de erro aceitável — e ter a infra pra detectar, medir e melhorar com o tempo.