AI Prompt Engineering · Aula

Esquema JSON em solicitações

Restrinja o formato da saída.

Aula 2 de 413 etapas

Esquema JSON em solicitações é uma aula grátis de AI Prompt Engineering no CoddyKit. Esta é a aula 2 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.

O Esquema como Contrato de Saída

Um Esquema JSON descreve declarativamente o formato de uma saída válida: tipos, chaves obrigatórias, restrições de valores e aninhamento. Quando transmitido a uma API de saída estruturada, ele se torna um contrato rígido; quando incorporado a uma instrução, torna-se uma orientação forte.

Dominar a autoria de esquemas é a habilidade central da geração estruturada.

O Sinalizador de Rigor Muda Tudo

No modo rigoroso, os provedores exigem que toda propriedade seja listada em required e que additionalProperties seja false. Os campos opcionais são expressos como uma união com null, e não por omissão.

{
  'type': 'object',
  'properties': {
    'name': {'type': 'string'},
    'nickname': {'type': ['string', 'null']}
  },
  'required': ['name', 'nickname'],
  'additionalProperties': False
}

Restringindo Valores Escalares

Inclua a validação no esquema em vez de fazer pós-processamento:

  • enum para escolhas fixas.
  • minimum/maximum para intervalos numéricos.
  • pattern para cadeias de caracteres validadas por expressões regulares.
  • format para indicações como date-time ou email.
{
  'rating': {'type': 'integer', 'minimum': 1, 'maximum': 5},
  'sku': {'type': 'string', 'pattern': '^[A-Z]{3}-[0-9]{4}$'},
  'created': {'type': 'string', 'format': 'date-time'}
}

Vetores e Tuplas

Use items para vetores homogêneos e adicione minItems/maxItems para limitar o comprimento. Para tuplas posicionais, forneça um vetor de esquemas por meio de prefixItems.

{
  'tags': {
    'type': 'array',
    'items': {'type': 'string'},
    'minItems': 1,
    'maxItems': 5
  }
}

Uniões Discriminadas com oneOf

Modele resultados polimórficos com oneOf e um campo discriminador. O modelo escolhe exatamente um ramo, e seu desserializador seleciona com base na etiqueta.

{
  'oneOf': [
    {'type': 'object', 'properties': {
        'kind': {'const': 'email'},
        'address': {'type': 'string', 'format': 'email'}},
     'required': ['kind', 'address']},
    {'type': 'object', 'properties': {
        'kind': {'const': 'phone'},
        'number': {'type': 'string'}},
     'required': ['kind', 'number']}
  ]
}

Gerando Esquemas a partir de Tipos

Escrever esquemas manualmente é propenso a erros. Derive-os de modelos tipados para que o esquema e seu código nunca se afastem um do outro.

from pydantic import BaseModel

class Invoice(BaseModel):
    total: float
    currency: str
    paid: bool

schema = Invoice.model_json_schema()
# pass schema directly to response_format

As Descrições Também são Instruções

Cada description no esquema é lida pelo modelo. Use-as para orientar a semântica, não apenas para documentar campos.

Por exemplo, uma descrição como 'código de país ISO-3166 alfa-2, em letras maiúsculas' melhora significativamente a acurácia do campo. Trate as descrições como microinstruções incorporadas ao contrato.

{
  'country': {
    'type': 'string',
    'description': 'ISO-3166 alpha-2 code, uppercase, e.g. US, TR, DE'
  }
}

Incorporando o Esquema na Instrução

Quando o provedor não oferece suporte nativo, incorpore o esquema à instrução e exija conformidade. Combine-o com um único exemplo no contexto e uma instrução explícita de somente JSON, sem prosa.

SYSTEM = (
  'You output ONLY JSON matching this schema. No markdown, no commentary.\n'
  'Schema:\n' + json.dumps(schema) + '\n'
  'If a value is unknown, use null.'
)

Evitando o Excesso de Esquema

Esquemas excessivamente profundos ou ramificados confundem o modelo e aumentam o custo de tokens. Orientações:

  • Mantenha o aninhamento superficial; reduza os níveis sempre que possível.
  • Prefira enumerações a cadeias de caracteres livres.
  • Divida um esquema enorme em várias chamadas focadas.
  • Alguns provedores limitam a profundidade do aninhamento e o número total de propriedades; verifique os limites.

Referências e Reutilização

Use $defs e $ref para reutilizar subesquemas, por exemplo, um Address usado no faturamento e no envio. Observe que alguns modos rigorosos restringem a profundidade da recursão; portanto, verifique o suporte antes de depender de referências autorreferentes.

{
  '$defs': {
    'Address': {'type': 'object', 'properties': {
        'city': {'type': 'string'}}, 'required': ['city'],
      'additionalProperties': False}
  },
  'type': 'object',
  'properties': {
    'billing': {'$ref': '#/$defs/Address'},
    'shipping': {'$ref': '#/$defs/Address'}
  },
  'required': ['billing', 'shipping'],
  'additionalProperties': False
}

Validando o Próprio Esquema

Há uma classe sutil de erros: o esquema está malformado, não a saída. Use validate para verificar os esquemas na integração contínua em relação ao metamodelo do Esquema JSON e faça uma verificação de ida e volta com um objeto de exemplo por meio do seu validador antes de publicar.

import jsonschema
jsonschema.Draft202012Validator.check_schema(schema)
# also: validate a known-good sample
jsonschema.validate(sample_obj, schema)

Verificação Rápida

No modo de Esquema JSON rigoroso de um provedor, como um campo opcional é expresso corretamente?

Recapitulação

Agora você consegue criar esquemas precisos:

  • O modo rigoroso exige que todos os campos sejam obrigatórios e que additionalProperties seja falso.
  • Restrinja escalares com enumerações, intervalos, padrões e formatos.
  • Modele o polimorfismo com discriminadores oneOf.
  • Gere esquemas a partir de modelos tipados; trate as descrições como microinstruções.
  • Valide o próprio esquema na integração contínua.

A seguir: aplicando esquemas a chamadas de ferramentas e funções.

Grátis para começar

Aprenda AI Prompt Engineering com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
53
Aulas
199

Perguntas Frequentes

A aula “Esquema JSON em solicitações” é grátis?

Sim — o texto completo de “Esquema JSON em solicitações” é 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 “Esquema JSON em solicitações”?

Restrinja o formato da saída. 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 2 de 4.

Quanto tempo leva a aula “Esquema JSON em solicitações”?

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

  1. Por que usar saída estruturada
  2. Esquema JSON em solicitações
  3. Esquemas de ferramentas e funções
  4. Ciclos de correção e validação
← Voltar para AI Prompt Engineering