Você pergunta algo simples pro chatbot e ele inventa uma resposta com toda a confiança do mundo. Não é bug — é feature dos LLMs. O problema é que 40% dos chatbots em produção ainda alucinam com frequência suficiente para causar estragos, segundo benchmarks de 2026 (Fonte: Guia Analítico de Avaliação de LLMs, NeuralPulse).

A boa notícia? Dá para reduzir drasticamente esse índice combinando três técnicas que a pesquisa acadêmica já validou: Chain-of-Thought estruturado, Self-Consistency com votação e otimização automática com DSPy. Este tutorial mostra as 7 etapas para construir esse sistema do zero em Python.

"Chain-of-thought + self-consistency gives the biggest accuracy boost for reasoning tasks. For everything else, few-shot with 3-5 examples is the best cost-to-quality tradeoff." — SurePrompts Team, Every Prompt Engineering Technique Explained (2026)

Etapa 1: Entenda por que LLMs alucinam (e o que funciona contra isso)

Antes de escrever código, vale entender o inimigo. LLMs são máquinas de completar padrões, não de verificar fatos. Quando não sabem a resposta, inventam — e fazem isso porque foram treinados para soar convincentes, não para ser precisos.

As três técnicas que vamos usar atacam o problema de ângulos complementares:

Juntas, essas três técnicas formam um cinturão de segurança para seu chatbot. A Etapa 2 começa com a fundação de tudo: o system prompt.

Etapa 2: Construa um system prompt robusto e enxuto

O system prompt é a primeira linha de defesa. A pesquisa da iBuidl Research (2026) revelou dois achados importantes:

1. System prompts acima de 800 tokens começam a perder eficácia — o modelo dilui a aderência às instruções.
2. Few-shot com apenas 3 exemplos eleva a confiabilidade de saída estruturada de 71% para 94%.

Traduzindo: menos é mais. Um system prompt inchado prejudica mais do que ajuda.

# system_prompt.py — Template base anti-alucinação

SYSTEM_PROMPT = """Você é um assistente de IA especializado em fornecer respostas PRECISAS e VERIFICÁVEIS.

REGRAS OBRIGATÓRIAS:

1. NUNCA invente informações. Se não souber, diga "Não tenho informação suficiente para responder."
2. SEMPRE raciocine passo a passo antes de responder (use o formato de raciocínio abaixo).
3. BASEIE cada afirmação em dados do contexto fornecido.
4. Se o usuário pedir algo fora do seu escopo, recuse educadamente.
5. MANTENHA respostas concisas — máximo 3 parágrafos salvo quando mais detalhe for explicitamente solicitado.

Exemplo de formato de resposta: RACIOCÍNIO: [Seu raciocínio passo a passo aqui]

RESPOSTA: [Sua resposta final baseada no raciocínio acima] """

Esse template já aplica dois princípios: enxuto (menos de 400 tokens) e estruturado (separa raciocínio de resposta). Guarde ele — vamos refiná-lo nas próximas etapas.

Etapa 3: Implemente Chain-of-Thought estruturado

Chain-of-Thought é simples na teoria e transformador na prática. Em vez de pedir uma resposta direta, você força o modelo a explicar o passo a passo antes de concluir. A iBuidl Research documentou um ganho consistente de 34% em acurácia com modelos modernos (GPT-5, Claude 4, Gemini 2.5).

O segredo é estruturar o CoT — não pode ser um "pense passo a passo" genérico. Você precisa de um formato que o modelo siga à risca.

# cot_pipeline.py — Chain-of-Thought estruturado

from openai import OpenAI import json

client = OpenAI()

def responder_com_cot(pergunta: str, contexto: str) -> dict: """Executa Chain-of-Thought estruturado e retorna raciocínio + resposta."""

messages = [
    {"role": "system", "content": """Você é um analista que raciocina passo a passo.

Sempre siga este formato:

PASSO 1: Identifique os dados relevantes no contexto PASSO 2: Relacione os dados com a pergunta PASSO 3: Verifique se há informação suficiente PASSO 4: Elabore a resposta baseada APENAS nos dados verificados

Se em QUALQUER passo você perceber que não tem dados suficientes, PARE e informe."""}, {"role": "user", "content": f"Contexto: {contexto}\n\nPergunta: {pergunta}"} ]

resposta = client.chat.completions.create(
    model="gpt-5.5",
    messages=messages,
    temperature=0.3,  # Baixa temperatura para consistência no raciocínio
    max_tokens=1024
)

return {
    "resposta_completa": resposta.choices[0].message.content,
    "tokens_gastos": resposta.usage.total_tokens
}

Exemplo de uso

resultado = responder_com_cot( pergunta="Qual foi o faturamento da empresa no Q3?", contexto="No Q1 faturamos R$ 2M, no Q2 R$ 2,5M. O relatório do Q3 será divulgado na próxima semana." ) print(resultado["resposta_completa"])

Perceba o que acontece: o modelo passa pelo PASSO 3 ("Verifique se há informação suficiente") e identifica que o Q3 não foi divulgado. Sem o CoT, ele provavelmente inventaria um número. Com o CoT, ele para antes de alucinar.

Etapa 4: Adicione Self-Consistency com votação majoritária

O Chain-of-Thought já reduz alucinações, mas ainda tem um problema: o raciocínio pode ser consistente e errado ao mesmo tempo. É aí que entra a Self-Consistency.

A ideia é genial na simplicidade: em vez de rodar o modelo uma vez, rode N vezes (com temperatura mais alta para gerar variedade) e escolha a resposta mais frequente. Pesquisas de 2025-2026 mostram ganhos de 12 a 18% de acurácia adicional sobre o CoT puro (Fonte: Adaline.ai).

# self_consistency.py — Votação majoritária sobre múltiplas execuções CoT

from openai import OpenAI from collections import Counter import re

client = OpenAI()

def extrair_resposta(texto: str) -> str: """Extrai o bloco RESPOSTA do texto gerado pelo CoT.""" match = re.search(r"RESPOSTA:\s*(.*?)(?:\n|$)", texto, re.DOTALL) return match.group(1).strip() if match else texto.strip()

def responder_com_consistency( pergunta: str, contexto: str, n_amostras: int = 5, temperatura_base: float = 0.7 ) -> dict: """ Gera N respostas com Chain-of-Thought e escolhe a mais frequente. Temperatura mais alta (0.7) garante diversidade nas amostras. """ respostas = [] raciocinios = []

for i in range(n_amostras):
    messages = [
        {"role": "system", "content": """Pense passo a passo e depois responda.

PASSO 1: Identifique dados relevantes PASSO 2: Analise a relação com a pergunta
PASSO 3: Verifique se há dados suficientes PASSO 4: Conclua

Formato final: RACIOCÍNIO: [seu raciocínio] RESPOSTA: [resposta final]"""}, {"role": "user", "content": f"Contexto: {contexto}\n\nPergunta: {pergunta}"} ]

    resp = client.chat.completions.create(
        model="gpt-5.5",
        messages=messages,
        temperature=temperatura_base,
        max_tokens=1024
    )
    
    texto = resp.choices[0].message.content
    raciocinios.append(texto)
    respostas.append(extrair_resposta(texto))

# Votação majoritária — escolhe a resposta mais frequente
contagem = Counter(respostas)
resposta_final = contagem.most_common(1)[0][0]

return {
    "resposta_final": resposta_final,
    "todas_as_respostas": respostas,
    "votacao": dict(contagem),
    "n_amostras": n_amostras
}

Teste: pergunta com informação ambígua no contexto

resultado = responder_com_consistency( pergunta="O produto X está disponível?", contexto="O produto X foi lançado em janeiro. Em março, a produção foi pausada para adequação regulatória. A previsão de retorno é para o próximo trimestre, sujeito a aprovação da ANVISA.", n_amostras=5 )

print(f"Resposta final (votação): {resultado['resposta_final']}") print(f"Distribuição dos votos: {resultado['votacao']}")

O custo? 5 chamadas de API em vez de 1. Mas o ganho em confiabilidade compensa — e você pode ajustar n_amostras conforme seu orçamento de tokens. Para respostas de baixo risco, 3 amostras já fazem diferença.

Etapa 5: Otimize tudo com DSPy — a máquina de prompts que aprende

As etapas 3 e 4 funcionam, mas têm um problema: os prompts foram escritos na mão. Cada ajuste de wording, cada temperatura, cada template exige tentativa e erro. É aí que o DSPy entra.

Desenvolvido por Stanford NLP, o DSPy inverte a lógica: em vez de você tunar o prompt manualmente, você declara o que quer (entrada, saída, métrica) e o framework otimiza o prompt automaticamente. O paper publicado no IEEE ESCI 2026 mostra: 30-45% de melhoria em acurácia factual e ~25% de redução em alucinações (arXiv:2604.04869).

"DSPy represents a fundamental shift in how engineers interact with language models — you declare what you want and the framework handles the 'how' while you focus on the 'what'." — Rob Ragan, Starlog (Maio/2026)

# dspy_optimizer.py — Otimização automática de prompts com DSPy

import dspy from dspy.teleprompt import BootstrapFewShot

Configura o LM — pode ser OpenAI, Anthropic, etc.

lm = dspy.LM("openai/gpt-5.5", temperature=0.3) dspy.settings.configure(lm=lm)

Define o módulo — você declara O QUE, não COMO

class ChatbotAntiAlucinacao(dspy.Module): def init(self): super().init() # O DSPy vai aprender o melhor prompt para este módulo self.responder = dspy.ChainOfThought("contexto, pergunta -> resposta")

def forward(self, contexto, pergunta):
    return self.responder(contexto=contexto, pergunta=pergunta)

Dados de treino — pares de exemplo com resposta esperada

TREINO = [ dspy.Example( contexto="O Brasil tem 26 estados e 1 Distrito Federal. População estimada em 2026: 218 milhões.", pergunta="Quantos estados tem o Brasil?", resposta="26 estados mais o Distrito Federal." ).with_inputs("contexto", "pergunta"),

dspy.Example(
    contexto="A empresa faturou R$ 10M em 2025. A projeção para 2026 é de R$ 14M.",
    pergunta="Quanto a empresa faturou em 2025?",
    resposta="R$ 10 milhões."
).with_inputs("contexto", "pergunta"),

dspy.Example(
    contexto="O evento TechConf acontece anualmente em São Paulo desde 2019.",
    pergunta="Onde será a TechConf 2026?",
    resposta="Não tenho informação suficiente para responder. O contexto informa que o evento acontece em São Paulo, mas não confirma a edição de 2026."
).with_inputs("contexto", "pergunta"),

]

Métrica: penaliza respostas que inventam informação

def metrica_precisao(example, pred, trace=None): if "não tenho informação" in pred.resposta.lower(): return "não tenho informação" in example.resposta.lower() return pred.resposta.lower().strip() == example.resposta.lower().strip()

Otimizador — DSPy vai testar variações do prompt e escolher a melhor

otimizador = BootstrapFewShot(metric=metrica_precisao) chatbot_otimizado = otimizador.compile( ChatbotAntiAlucinacao(), trainset=TREINO, max_bootstrapped_demos=3, # Máximo de 3 exemplos (validação da iBuidl) max_labeled_demos=3 )

Teste com dados reais — o prompt agora foi otimizado

resposta = chatbot_otimizado( contexto="O Google investiu US$ 30 bilhões em infraestrutura de IA em 2026.", pergunta="Quanto o Google investiu em IA?" ) print(f"Resposta otimizada: {resposta.resposta}")

Note o max_bootstrapped_demos=3 — não é coincidência. A pesquisa da iBuidl mostra que 3 exemplos são o ponto ideal entre qualidade e custo. O DSPy respeita isso automaticamente.

Etapa 6: Gerencie a janela de contexto sem perder informação no meio

Você já montou o pipeline anti-alucinação, mas tem um problema silencioso: conforme o histórico da conversa cresce, o modelo perde informação no meio da janela de contexto.

O fenômeno é conhecido como Lost in the Middle, documentado pela SurePrompts (2026):

(Fonte: SurePrompts, Context Window Management Strategies, 2026)

Isso significa que, em uma conversa longa, a informação crítica que está no meio tende a ser esquecida — e o modelo alucina justamente onde não deveria.

# context_manager.py — Gerenciamento inteligente de contexto

from collections import deque

class GerenciadorContexto: """ Mantém o contexto relevante no início e fim da janela, minimizando o efeito 'Lost in the Middle'. """

def __init__(self, max_tokens: int = 6000):
    self.max_tokens = max_tokens
    self.historico = deque()
    self.info_permanente = ""  # Dados fixos (sempre no início)

def definir_info_permanente(self, info: str):
    """Define informações que ficam SEMPRE no topo do contexto."""
    self.info_permanente = info

def adicionar_turno(self, pergunta: str, resposta: str):
    """Adiciona um turno de conversa ao histórico."""
    self.historico.append({
        "pergunta": pergunta,
        "resposta": resposta
    })

def montar_contexto(self, nova_pergunta: str) -> list[dict]:
    """
    Monta a lista de mensagens seguindo a estratégia:
    - Info permanente no início (sempre visível)
    - Turnos mais recentes no fim (maior recall)
    - Turnos do meio comprimidos ou removidos
    """
    messages = [
        {"role": "system", "content": self.info_permanente}
    ]
    
    # Mantém apenas os N turnos mais recentes (exclui os do meio)
    MAX_TURNOS = 6
    turnos_recentes = list(self.historico)[-MAX_TURNOS:]
    
    for turno in turnos_recentes:
        messages.append({"role": "user", "content": turno["pergunta"]})
        messages.append({"role": "assistant", "content": turno["resposta"]})
    
    messages.append({"role": "user", "content": nova_pergunta})
    return messages

Integração com o pipeline completo

gc = GerenciadorContexto() gc.definir_info_permanente(SYSTEM_PROMPT) # Da Etapa 2

Simula uma conversa

gc.adicionar_turno("Qual o horário de funcionamento?", "Seg a sex, 8h às 18h.") gc.adicionar_turno("Aceitam cartão?", "Sim, todos os cartões.")

O contexto montado tem a info permanente + só os turnos recentes

contexto = gc.montar_contexto("Qual o prazo de entrega?")

Essa estratégia simples — cabeça + calda, sem barriga — mantém o recall acima de 85% mesmo em conversas longas, porque as informações mais importantes ficam nas zonas de alto recall.

Etapa 7: Junte tudo no chatbot completo

Agora vamos unir todas as peças: system prompt enxuto (Etapa 2), Chain-of-Thought (Etapa 3), Self-Consistency (Etapa 4), otimização DSPy (Etapa 5) e gerenciamento de contexto (Etapa 6).

# chatbot_anti_hallucination.py — Pipeline completo

from openai import OpenAI from collections import Counter import re import dspy

=== ETAPA 2: System prompt robusto ===

SYSTEM_PROMPT = """Você é um assistente PRECISO e VERIFICÁVEL. NUNCA invente informações. Se não souber, assuma. Sempre raciocine passo a passo antes de responder."""

=== ETAPA 3 + 4: CoT com Self-Consistency ===

class PipelineRaciocinio: def init(self, model: str = "gpt-5.5", n_amostras: int = 5): self.client = OpenAI() self.model = model self.n_amostras = n_amostras

def _gerar_resposta(self, mensagens: list) -> str:
    resp = self.client.chat.completions.create(
        model=self.model,
        messages=mensagens,
        temperature=0.7,  # Alta para diversidade nas amostras
        max_tokens=1024
    )
    return resp.choices[0].message.content

def _extrair_resposta(self, texto: str) -> str:
    match = re.search(r"RESPOSTA:\s*(.*)", texto, re.DOTALL)
    return match.group(1).strip() if match else texto.strip()

def processar(self, pergunta: str, contexto: str) -> dict:
    template_cot = f"""Contexto: {contexto}

Pergunta: {pergunta}

PASSO 1: Identifique dados relevantes no contexto PASSO 2: Relacione com a pergunta PASSO 3: Verifique se há dados suficientes PASSO 4: Conclua

RACIOCÍNIO: [seu raciocínio]

RESPOSTA: [sua resposta final]"""

    mensagens_base = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": template_cot}
    ]
    
    # Gera múltiplas amostras (Self-Consistency)
    respostas = []
    for _ in range(self.n_amostras):
        texto = self._gerar_resposta(mensagens_base)
        respostas.append(self._extrair_resposta(texto))
    
    # Votação majoritária
    contagem = Counter(respostas)
    resposta_final = contagem.most_common(1)[0][0]
    
    return {
        "resposta": resposta_final,
        "confianca": contagem.most_common(1)[0][1] / self.n_amostras,
        "votacao": dict(contagem)
    }

=== ETAPA 5: Configura DSPy como camada extra de otimização ===

lm = dspy.LM("openai/gpt-5.5", temperature=0.3) dspy.settings.configure(lm=lm)

class ValidadorDSPy(dspy.Module): """Módulo DSPy que valida e refina a resposta final.""" def init(self): super().init() self.validar = dspy.ChainOfThought("pergunta, resposta_bruta, contexto -> resposta_validada, explicacao")

def forward(self, pergunta, resposta_bruta, contexto):
    return self.validar(
        pergunta=pergunta,
        resposta_bruta=resposta_bruta,
        contexto=contexto
    )

validador = ValidadorDSPy()

=== FUNÇÃO PRINCIPAL ===

def chatbot_resposta(pergunta: str, contexto: str) -> dict: # Passo 1: Gera respostas com CoT + Self-Consistency pipeline = PipelineRaciocinio(n_amostras=5) resultado = pipeline.processar(pergunta, contexto)

# Passo 2: Valida com DSPy (camada extra de segurança)
validacao = validador(
    pergunta=pergunta,
    resposta_bruta=resultado["resposta"],
    contexto=contexto
)

return {
    "resposta": validacao.resposta_validada,
    "nivel_confianca": "ALTA" if resultado["confianca"] >= 0.8 else "MÉDIA" if resultado["confianca"] >= 0.6 else "BAIXA",
    "detalhes": {
        "consenso": round(resultado["confianca"] * 100, 1),
        "total_amostras": 5,
        "distribuicao": resultado["votacao"]
    }
}

=== TESTE ===

teste = chatbot_resposta( pergunta="Qual o PIB do Brasil em 2025?", contexto="O PIB do Brasil cresceu 3,2% em 2024, atingindo R$ 10,9 trilhões. Dados de 2025 serão divulgados pelo IBGE no próximo trimestre." ) print(f"Resposta: {teste['resposta']}") print(f"Confiança: {teste['nivel_confianca']}") print(f"Consenso entre amostras: {teste['detalhes']['consenso']}%")

Esse é o chatbot completo. Rode o teste e veja o resultado: o modelo reconhece que não tem dados de 2025 (porque o contexto diz que serão divulgados no próximo trimestre) e responde de forma honesta, sem alucinar.

O nível de confiança te dá um termômetro: se for BAIXA, vale a pena adicionar uma camada de verificação externa (uma busca na web ou RAG, por exemplo).

Benchmark: o ganho real em números

Para fechar, um resumo do que cada camada adiciona ao pipeline:

Baseado em dados compilados de iBuidl Research (2026) e IEEE ESCI (arXiv:2604.04869)

O custo adicional da Self-Consistency (5,5× de tokens) pode assustar, mas lembre-se: cada alucinação em produção custa mais caro que tokens extras. O Morgan Stanley, por exemplo, implementou um chatbot com GPT-4 para seus assessores financeiros e atingiu 98% de adoção — justamente porque o sistema era confiável o suficiente para dar acesso instantâneo a +350 mil documentos de pesquisa, reduzindo o tempo de busca de 30 minutos para segundos (Fonte: Reruption, 2026).

O que vem depois

Esse pipeline é a base. Os próximos passos naturais são:

1. Adicionar RAG — substitua o contexto estático por uma busca vetorial em tempo real (veja nosso tutorial RAG do Zero)
2. Testar com outros modelos — Claude 4 Sonnet e Gemini 2.5 Pro também se beneficiam do CoT + Self-Consistency
3. Expandir o dataset de treino do DSPy — quanto mais exemplos de "não sei" você incluir, mais o otimizador aprende a não alucinar

O mercado de prompt engineering já movimenta US$ 6,95 bilhões em 2026, crescendo 33% ao ano (Fonte: Lushbinary, Abr/2026). Não é mais sobre "como fazer o ChatGPT responder direito" — é uma disciplina com ferramentas, métricas e padrões de governança. E o básico que você acabou de implementar é o pilar de qualquer sistema de IA confiável em produção.

Quer ir além? O próximo passo lógico é conectar esse pipeline a uma base de conhecimento externa. Nosso tutorial de RAG do Zero mostra exatamente como fazer isso.

Tem dúvidas ou quer compartilhar sua implementação? Mande um feedback — o NeuralPulse está de olho no que a comunidade está construindo.