Pular para o conteúdo
Engenharia com agentes de IA: governança e custo em reais.

IA em produção · 30 de outubro de 2026

Conjunto de perguntas de avaliação: como montar e manter o seu

Por Medha

Cenário (sintético)

Um time montou, no início do projeto, um golden set de 30 perguntas e passou a rodá-lo a cada mudança no sistema. Depois de seis meses, o sistema passava em 100% do golden set — e ao mesmo tempo gerava reclamação real de usuário sobre uma política de reembolso que tinha mudado três meses antes. O golden set continuava cobrando a resposta baseada na versão antiga da política, porque ninguém tinha atualizado o conjunto de teste quando o documento mudou. O time estava otimizando o sistema para acertar uma prova desatualizada, não para responder certo no presente.

Esse é o segundo risco de um golden set, depois do risco mais óbvio de "não ter um": ter um golden set estático, que não acompanha a base de documentos nem os casos reais que aparecem depois do lançamento.

De onde tirar as perguntas

Um golden set representativo mistura pelo menos quatro origens, e não só uma:

  1. Perguntas reais. Extraídas de log de suporte, dúvidas recebidas por e-mail, ou de uma versão beta com usuário real. São a fonte mais valiosa porque refletem como as pessoas perguntam de verdade — nem sempre do jeito claro que o time imagina.
  2. Perguntas sintéticas cobrindo os casos hostis. Perguntas escritas propositalmente sobre os documentos mais difíceis identificados na amostra hostil (peça 01 desta série): tabela, documento digitalizado, regra condicional com exceção.
  3. Perguntas adversariais. Escritas para tentar induzir o sistema a alucinar ou vazar informação — por exemplo, perguntar por algo que não existe na base ("qual o desconto para clientes VIP?", quando não existe programa VIP) e verificar se o sistema recusa corretamente em vez de inventar uma resposta plausível.
  4. Perguntas fora de escopo. Perguntas que o sistema deveria recusar por não serem sobre o domínio coberto pela base — testando se ele sabe dizer "isso não está no meu escopo" em vez de responder qualquer coisa com confiança.

Um golden set feito só de perguntas fáceis, bem formuladas pelo próprio time que construiu o sistema, mede pouco: tende a acertar tudo e não revelar nada sobre o comportamento em produção.

Estrutura de um caso do golden set

Cada item do conjunto precisa de mais do que a pergunta e a resposta esperada — precisa de metadado que permita saber se ainda está válido:

- id: ge-014
  pergunta: "Posso reembolsar uma diária acima de R$ 400 se teve pré-aprovação?"
  fonte_esperada:
    documento: "Política de Reembolso de Viagem"
    secao: "4. Hospedagem"
    versao: "2026-03"
  categoria: regra_condicional
  origem: sintetica
  dificuldade: media
  criado_em: "2026-03-10"

Carregar esse conjunto em código, com validação explícita, evita que um item mal formatado passe despercebido — apontando exatamente qual caso e qual campo estão errados, em vez de estourar um erro genérico no meio da lista:

import yaml
from dataclasses import dataclass
from datetime import date

@dataclass
class CasoGolden:
    id: str
    pergunta: str
    documento_esperado: str
    secao_esperada: str
    versao_esperada: str
    categoria: str
    origem: str
    dificuldade: str
    criado_em: date

class GoldenSetInvalidoError(Exception):
    """Erro de validação do golden set, nomeando o caso e o campo
    ausente — para o problema ser corrigido no arquivo YAML, não
    descoberto como um KeyError sem contexto em produção."""

def carregar_golden_set(caminho: str) -> list[CasoGolden]:
    with open(caminho, encoding="utf-8") as f:
        bruto = yaml.safe_load(f)
    if not isinstance(bruto, list):
        raise GoldenSetInvalidoError(
            f"{caminho}: esperava uma lista de casos, recebeu {type(bruto).__name__}"
        )

    casos = []
    for item in bruto:
        item_id = item.get("id", "<sem id>") if isinstance(item, dict) else "<item não é um dicionário>"
        try:
            casos.append(CasoGolden(
                id=item["id"],
                pergunta=item["pergunta"],
                documento_esperado=item["fonte_esperada"]["documento"],
                secao_esperada=item["fonte_esperada"]["secao"],
                versao_esperada=item["fonte_esperada"]["versao"],
                categoria=item["categoria"],
                origem=item["origem"],
                dificuldade=item["dificuldade"],
                criado_em=date.fromisoformat(item["criado_em"]),
            ))
        except KeyError as campo_ausente:
            raise GoldenSetInvalidoError(
                f"caso '{item_id}' em {caminho}: campo obrigatório ausente {campo_ausente}"
            ) from campo_ausente
    return casos

Detectando cobertura fraca e caso desatualizado

Duas checagens automáticas ajudam a manter o golden set saudável ao longo do tempo. A primeira mostra se alguma categoria está sub-representada:

def cobertura_por_categoria(casos: list[CasoGolden]) -> dict[str, int]:
    """Conta quantos casos existem por categoria — revela se o golden
    set está concentrado só em perguntas fáceis ou só em uma origem."""
    contagem: dict[str, int] = {}
    for c in casos:
        contagem[c.categoria] = contagem.get(c.categoria, 0) + 1
    return contagem

A segunda sinaliza casos cuja versão esperada do documento não é mais a vigente — o problema exato do cenário desta peça:

def casos_com_versao_desatualizada(
    casos: list[CasoGolden], versao_vigente_por_doc: dict[str, str]
) -> list[CasoGolden]:
    """Sinaliza casos do golden set cuja versão esperada não é mais a
    versão vigente do documento de origem — evita que o teste continue
    cobrando uma resposta baseada em regra já revogada."""
    return [
        c for c in casos
        if versao_vigente_por_doc.get(c.documento_esperado) not in (None, c.versao_esperada)
    ]

Essa segunda checagem depende de ter, em algum lugar do sistema, um registro de qual é a versão vigente de cada documento — mais um motivo para o critério de metadado tratado na peça sobre chunking desta série.

Evitando "decorar a prova"

Se o mesmo golden set é usado tanto para ajustar o sistema (prompt, chunking, parâmetros de busca) quanto para decidir se ele está pronto, existe risco real de o time ajustar o sistema até ele acertar exatamente aquelas perguntas, sem que isso signifique melhora real em produção. Duas práticas reduzem esse risco: manter uma parte do golden set — um "holdout" — fora do ciclo de ajuste, usada só na avaliação final antes de liberar; e alimentar o golden set continuamente com falhas reais capturadas em produção, para que ele nunca pare de crescer com casos novos que o time não escreveu antecipadamente.

Critério prático de manutenção do golden set

  1. O conjunto tem perguntas de pelo menos quatro origens: reais, sintéticas sobre casos hostis, adversariais e fora de escopo?
  2. Existe checagem periódica de caso com versão de documento desatualizada?
  3. Uma parte do conjunto fica fora do ciclo de ajuste, servindo só de avaliação final (holdout)?
  4. Toda falha real relatada em produção vira, depois de corrigida, um novo caso permanente do golden set?

Próximo passo

Com o golden set e a régua de veredito definidos, a próxima peça enfrenta um problema específico de IA generativa: como avaliar uma resposta que pode mudar a cada execução, mesmo para a mesma pergunta e o mesmo documento.

Para aplicar este critério e os outros da série, fique de olho no Checklist de RAG em Produção, gratuito — ainda em preparação: deixe seu e-mail na lista de espera para recebê-lo assim que ele sair.

Checklist de RAG em Produção

Os critérios da série IA em produção reunidos num checklist para levar um RAG da prova de conceito à produção.

Só enviamos o material e avisos sobre ele. Privacidade