Ir para o conteúdo
Saídas estruturadas

Saídas estruturadas

Peça a resposta em JSON: qualquer objeto JSON, ou um JSON que siga um schema que você envia. Use quando um programa, e não uma pessoa, lê a resposta.

POST https://api.shannon-ai.com/v1/chat/completions 

import json
from openai import OpenAI

client = OpenAI(api_key="YOUR_API_KEY", base_url="https://api.shannon-ai.com/v1")

response = client.chat.completions.create(
    model="Kimi-K3-3BIT-REAP",
    messages=[
        {"role": "user", "content": "Extract the person: John Doe, 30 years old, engineer."}
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "person",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "age": {"type": "integer"},
                    "occupation": {"type": "string"},
                },
                "required": ["name", "age", "occupation"],
            },
        },
    },
)

# The JSON arrives as text in message.content: parse it, then check it.
try:
    person = json.loads(response.choices[0].message.content)
except json.JSONDecodeError:
    person = None  # ask again, or report the failure

print(person)

O JSON é o texto da resposta, em choices[0].message.content:

200 JSON 
{
  "id": "chatcmpl-0c4e7a1b9d2f4e6a8b3c5d7e9f1a2b3c",
  "object": "chat.completion",
  "created": 1791590400,
  "model": "Kimi-K3-3BIT-REAP",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "{\"name\":\"John Doe\",\"age\":30,\"occupation\":\"engineer\"}",
        "reasoning_content": null
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 96,
    "completion_tokens": 19,
    "total_tokens": 115,
    "prompt_tokens_details": {"cached_tokens": 0},
    "completion_tokens_details": {"reasoning_tokens": 0}
  }
}

Os modos de response_format

response_format é um campo de /v1/chat/completions. Sem ele, a resposta é texto comum.

Modo Valor O que você recebe
Objeto JSON {"type": "json_object"} A resposta é um JSON sem formato prescrito. Diga no prompt quais chaves você quer.
JSON schema {"type": "json_schema", "json_schema": {"name": "…", "schema": {…}}} A resposta segue o schema que você envia: suas chaves, tipos e campos obrigatórios.
Strict "strict": true Um campo de json_schema, não um terceiro modo. É true, a menos que você envie false.
Campo Tipo Padrão Descrição Aplicado por
type string json_object ou json_schema. Obrigatório dentro de response_format. text é aceito e dá uma resposta de texto comum. Todo modelo que aceita o modo
json_schema.schema object O JSON Schema que a resposta segue. Envie-o sempre que type for json_schema. Todo modelo que aceita o modo
json_schema.name string Um rótulo para o schema, como no formato da OpenAI. Modelos open-weight hospedados
json_schema.strict boolean true Se a resposta tem de seguir o schema exatamente. Os modelos Shannon aplicam todo schema como strict. Modelos open-weight hospedados

O modo de objeto JSON não precisa de schema. Nomeie as chaves no prompt:

Corpo da requisição 
{
  "model": "shannon-3",
  "messages": [
    {
      "role": "user",
      "content": "Name the capital of France. Answer as JSON with the keys city and country."
    }
  ],
  "response_format": {"type": "json_object"}
}

Suporte por modelo

Modelo json_object json_schema
Todo modelo Shannon (shannon-*) Sim Sim
Modelos open-weight hospedados, exceto os nomeados abaixo Sim Sim
Laguna-S-2.1-W4A16-AUTOROUND-REAP — —
inkling-W4A16-AUTOROUND-REAP Sim —

GET /v1/models informa o mesmo para cada id: capabilities.json_schema em todos os modelos e capabilities.response_format nos modelos open-weight hospedados. Modelos e preços

Palavras-chave de schema aceitas

O que um modelo recebe do seu schema depende do modelo e do endpoint:

Modelos /v1/chat/completions /v1/responses
Modelos Shannon O subconjunto de palavras-chave abaixo, aplicado como strict. O schema como você o envia, aplicado como strict.
Modelos open-weight hospedados O schema como você o envia. strict é true, a menos que você o envie. O schema como você o envia. strict é true, a menos que você o envie.

O subconjunto de palavras-chave dos modelos Shannon em /v1/chat/completions:

Palavra-chave Como é lido
Palavras-chave lidas type, format, title, description, nullable, enum, items, properties, required, minItems, maxItems, minimum, maximum, minLength, maxLength, pattern, anyOf, default
$ref Resolvido a partir de $defs ou definitions no nível superior do schema. As palavras-chave escritas ao lado do $ref, como description, são mantidas. Uma referência sem definição correspondente é lida como {"type": "object"}.
allOf Os membros são combinados em um único schema. Quando dois membros definem a mesma palavra-chave, vale o último.
oneOf Lido como anyOf.
Schemas que se referem a si mesmos Expandidos até 24 níveis. Um nível mais profundo é lido como {"type": "object"}.
Fora do subconjunto Toda outra palavra-chave, por exemplo additionalProperties, const, multipleOf, uniqueItems, exclusiveMinimum, exclusiveMaximum, patternProperties, prefixItems, minProperties, maxProperties, not e if / then / else. Elas não fazem parte do schema que o modelo recebe.

Em /v1/responses: text.format

/v1/responses escreve a mesma requisição como text.format. O schema fica diretamente em format, ao lado de name e strict, e não sob uma chave json_schema. Para o modo de objeto JSON, envie {"format": {"type": "json_object"}}.

Corpo da requisição 
{
  "model": "Kimi-K3-3BIT-REAP",
  "input": "Extract the person: John Doe, 30 years old, engineer.",
  "text": {
    "format": {
      "type": "json_schema",
      "name": "person",
      "strict": true,
      "schema": {
        "type": "object",
        "properties": {
          "name": {"type": "string"},
          "age": {"type": "integer"},
          "occupation": {"type": "string"}
        },
        "required": ["name", "age", "occupation"]
      }
    }
  }
}

O JSON é o text da parte output_text do item message:

200 JSON 
{
  "output": [
    {
      "id": "msg_7e1d3c5b9a2f4d6e8c0b1a3f5e7d9c2b",
      "type": "message",
      "role": "assistant",
      "status": "completed",
      "content": [
        {
          "type": "output_text",
          "text": "{\"name\":\"John Doe\",\"age\":30,\"occupation\":\"engineer\"}",
          "annotations": []
        }
      ]
    }
  ]
}

O suporte por modelo e os erros são os mesmos de /v1/chat/completions. API Responses

Em /v1/messages: uma ferramenta como schema

O formato Messages não tem campo de saída estruturada. Para obter JSON dos mesmos modelos, chame /v1/chat/completions ou /v1/responses com a mesma chave.

Para continuar em /v1/messages, descreva o objeto como uma ferramenta: coloque o seu schema em input_schema e nomeie a ferramenta em tool_choice. O input do bloco tool_use é então o seu objeto, já interpretado. Um tool_choice nomeado é aplicado pelos modelos open-weight hospedados.

Corpo da requisição 
{
  "model": "Kimi-K3-3BIT-REAP",
  "max_tokens": 1024,
  "messages": [
    {
      "role": "user",
      "content": "Extract the person: John Doe, 30 years old, engineer."
    }
  ],
  "tools": [
    {
      "name": "record_person",
      "description": "Record the extracted person.",
      "input_schema": {
        "type": "object",
        "properties": {
          "name": {"type": "string"},
          "age": {"type": "integer"},
          "occupation": {"type": "string"}
        },
        "required": ["name", "age", "occupation"]
      }
    }
  ],
  "tool_choice": {"type": "tool", "name": "record_person"}
}
200 JSON 
{
  "stop_reason": "tool_use",
  "content": [
    {
      "type": "tool_use",
      "id": "toolu_4b8d2f6a1c3e4a5b9d7f0e2c4a6b8d1f",
      "name": "record_person",
      "input": {"name": "John Doe", "age": 30, "occupation": "engineer"}
    }
  ]
}

Verifique se stop_reason é tool_use antes de ler o bloco. Chamada de funções

Como o JSON chega

  • O JSON é uma string. A resposta não traz um objeto já interpretado ao lado: execute o seu parser de JSON em message.content.
  • Com stream: true, o JSON chega em trechos de delta.content. Junte-os e faça o parse quando o stream terminar; um trecho isolado não é um JSON válido.
  • Um modelo open-weight hospedado responde a uma requisição com response_format sem texto de raciocínio: reasoning_content é null.

Verifique o que você recebe

O schema orienta como o modelo escreve. A API não compara a resposta final com o seu schema, então o seu código faz a verificação final:

  • Faça o parse dentro de um tratador de erros, como no exemplo do início.
  • Valide o objeto interpretado com o mesmo schema no seu próprio código, por exemplo com uma biblioteca de JSON Schema, Pydantic ou Zod.
  • Uma resposta longa pode terminar antes de o JSON estar completo. Uma resposta sem stream informa finish_reason apenas como stop ou tool_calls, então um erro de parse é o sinal. Peça de novo, ou peça um objeto menor.

Erros

Status Tipo Mensagem Quando
400 invalid_request_error <id> does not accept response_format O modelo não aceita nenhum dos dois modos.
400 invalid_request_error <id> does not accept response_format json_schema; use json_object O modelo aceita json_object e você enviou json_schema.
422 invalid_request_error Failed to deserialize the JSON body into the target type: … response_format não tem type, ou não é um objeto JSON.

As duas respostas 400 são enviadas antes de qualquer desconto do seu saldo. Tratamento de erros