AI Prompt Engineering · Aula

Validadores de esquemas e regras

Garanta o cumprimento das restrições.

Validadores de esquemas e regras é uma aula grátis de AI Prompt Engineering no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Prompt Engineering, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Prompt Engineering inclui 4 aulas no total.

Validadores fazem cumprir o contrato

Um validador é uma barreira de proteção que verifica a saída em relação a uma especificação explícita: um esquema JSON, um conjunto de regras de negócio ou ambos. Diferentemente de um classificador de moderação, um validador é determinístico e totalmente auditável; a mesma entrada sempre produz o mesmo veredito.

Camada de validação do esquema

O primeiro validador confirma que a saída corresponde ao contrato estrutural. Colete todos os erros, não apenas o primeiro, para que o retorno para reparo seja completo.

import jsonschema
def schema_errors(obj, schema):
    v = jsonschema.Draft202012Validator(schema)
    return [f"{list(e.path) or 'root'}: {e.message}"
            for e in v.iter_errors(obj)]

Além do esquema: regras de negócio

Os esquemas não conseguem expressar tudo. Um esquema pode dizer que discount é um número, mas não que ele não pode exceder o subtotal. Validadores de regras codificam essas invariantes entre campos e de domínio.

RULES = [
  ('discount_le_subtotal', lambda o: o['discount'] <= o['subtotal']),
  ('total_consistent', lambda o: o['total'] == o['subtotal'] - o['discount']),
  ('currency_supported', lambda o: o['currency'] in SUPPORTED)
]
def rule_errors(o):
    return [name for name, fn in RULES if not fn(o)]

Modelos tipados como validadores

Uma biblioteca de modelos tipados (por exemplo, Pydantic) também funciona como geradora de esquemas e validadora, com validadores personalizados para regras. A falha na análise é o veredito.

from pydantic import BaseModel, field_validator

class Order(BaseModel):
    subtotal: float
    discount: float
    total: float

    @field_validator('discount')
    @classmethod
    def discount_ok(cls, v, info):
        if v < 0:
            raise ValueError('discount must be non-negative')
        return v

Validadores de fundamentação e citações

Para saídas de RAG, valide se as afirmações são sustentadas pelo contexto fornecido. Exija que o modelo cite identificadores de fontes; depois, verifique se cada identificador citado existe e se os trechos citados realmente aparecem na fonte. Rejeite respostas que citem fontes ausentes ou inventadas.

def citations_valid(answer, sources):
    for cite in answer['citations']:
        if cite['source_id'] not in sources:
            return False
        if cite['quote'] not in sources[cite['source_id']]:
            return False
    return True

Verificações referenciais e entre sistemas

Algumas regras exigem consultas externas: o identificador do pedido referenciado existe, o produto está em estoque, a data está em uma janela válida? Esses validadores consultam os seus sistemas. Mantenha-os rápidos (use cache e processamento em lotes), pois ficam no caminho da resposta.

def order_exists(o):
    return db.exists('SELECT 1 FROM orders WHERE id = %s', o['order_id'])

Vereditos com marcação de gravidade

Nem todas as violações têm a mesma gravidade. Marque cada regra com uma gravidade para que o fluxo possa escolher a ação adequada: bloqueie completamente as violações críticas, gere novamente em caso de problemas de qualidade e permita a passagem com um aviso para as menores.

RULE_SEVERITY = {
  'discount_le_subtotal': 'critical',
  'total_consistent': 'critical',
  'tone_professional': 'warning'
}

Componha os validadores em ordem

Execute os validadores começando pelos mais baratos e interrompa no primeiro erro grave: esquema, depois regras em memória, depois consultas externas e, por fim, verificações de avaliação por modelo. Isso minimiza o custo no caminho comum de rejeição.

def validate_all(obj):
    errs = schema_errors(obj, SCHEMA)
    if errs: return Reject(errs, 'critical')
    errs = rule_errors(obj)
    if errs: return Reject(errs, max_severity(errs))
    if not order_exists(obj): return Reject(['order_id'], 'critical')
    return Accept()

Validadores orientam o retorno para reparo

O valor de um validador se multiplica quando suas mensagens alimentam o ciclo de reparo. Emita erros acionáveis por máquina com o caminho do campo, a regra que falhou e o valor problemático, para que o modelo possa corrigir com precisão em uma única rodada.

{'errors': [
  {'path': 'discount', 'rule': 'discount_le_subtotal',
   'got': 120, 'limit': 100}
]}

Teste os próprios validadores

Um validador com defeito pode permitir silenciosamente uma saída incorreta ou bloquear uma saída válida. Faça testes unitários de cada regra com exemplos positivos e negativos e adicione testes baseados em propriedades para invariantes numéricas. O conjunto de testes do validador é código crítico para produção, não um programa.

def test_discount_rule():
    assert rule_errors({'discount':10,'subtotal':100,'total':90}) == []
    assert 'discount_le_subtotal' in rule_errors(
        {'discount':120,'subtotal':100,'total':-20})

Validadores versus decodificação restrita

A decodificação restrita evita erros estruturais durante a geração, mas não consegue impor semântica, pois não conhece as suas regras de negócio. Os validadores detectam violações semânticas depois da geração. Use ambos: decodificação para a estrutura, validadores para o significado e o ciclo de reparo para conciliar os dois.

Verificação rápida

Um esquema JSON marca desconto e subtotal como números. O modelo retorna desconto 120 com subtotal 100. Qual camada deve detectar isso?

Recapitulação

Validadores de esquema e de regras:

A validação de esquema abrange a estrutura; os validadores de regras abrangem a semântica.
Modelos tipados geram esquemas e validam em um só lugar.
Adicione verificações de fundamentação, citações e referências para RAG e fluxos de dados.
Marque a gravidade, componha começando pelos mais baratos e forneça erros precisos para o reparo.
Teste os validadores como código crítico para produção.

Próximo: validação por autocrítica, na qual o modelo verifica a própria saída.

Perguntas Frequentes

A aula “Validadores de esquemas e regras” é grátis?

Sim — o texto completo de “Validadores de esquemas e regras” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Prompt Engineering, atualize para CoddyKit PRO. O curso de AI Prompt Engineering inclui 4 aulas no total.

O que vou aprender em “Validadores de esquemas e regras”?

Garanta o cumprimento das restrições. Você pratica AI Prompt Engineering com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar AI Prompt Engineering?

Nenhuma experiência prévia é necessária. AI Prompt Engineering no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Validadores de esquemas e regras”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de AI Prompt Engineering?

Sim. Cada aula de AI Prompt Engineering inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para AI Prompt Engineering