Saídas estruturadas

Pide a resposta como JSON: calquera obxecto JSON, ou JSON que siga un esquema que envíes. Úsao cando un programa, non unha persoa, le 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)

import OpenAI from "openai";

const client = new OpenAI({ apiKey: "YOUR_API_KEY", baseURL: "https://api.shannon-ai.com/v1" });

const response = await 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.
let person = null;
try {
  person = JSON.parse(response.choices[0].message.content);
} catch {
  // ask again, or report the failure
}

console.log(person);

curl https://api.shannon-ai.com/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "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"]
        }
      }
    }
  }'

O JSON é o texto da resposta, en 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 é un campo de /v1/chat/completions. Sen el, a resposta é texto normal.

Modo	Valor	Que obtés
Obxecto JSON	`{"type": "json_object"}`	A resposta é JSON sen unha forma prescrita. Indica no prompt que claves queres.
Esquema JSON	`{"type": "json_schema", "json_schema": {"name": "…", "schema": {…}}}`	A resposta segue o esquema que envías: as súas claves, tipos e campos obrigatorios.
Estrito	`"strict": true`	Un campo de `json_schema`, non un terceiro modo. É `true` a menos que envíes `false`.

Campo	Tipo	Valor predeterminado	Descrición	Aplicado por
`type`	`string`		`json_object` ou `json_schema`. Obrigatorio dentro de `response_format`. `text` acéptase e dá unha resposta de texto normal.	Todos os modelos que aceptan o modo
`json_schema.schema`	`object`		O JSON Schema que segue a resposta. Envíao sempre que `type` sexa `json_schema`.	Todos os modelos que aceptan o modo
`json_schema.name`	`string`		Unha etiqueta para o esquema, como no formato de OpenAI.	Modelos open-weight alojados
`json_schema.strict`	`boolean`	`true`	Se a resposta debe seguir o esquema exactamente. Os modelos Shannon aplican todos os esquemas como estritos.	Modelos open-weight alojados

O modo de obxecto JSON non necesita esquema. Nomea as claves no prompt:

Corpo da solicitude

{
  "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"}
}

Compatibilidade por modelo

Modelo	`json_object`	`json_schema`
Todos os modelos Shannon (`shannon-*`)	Si	Si
Modelos open-weight alojados, excepto os nomeados abaixo	Si	Si
`Laguna-S-2.1-W4A16-AUTOROUND-REAP`	—	—
`inkling-W4A16-AUTOROUND-REAP`	Si	—

GET /v1/models informa o mesmo por id: capabilities.json_schema en todos os modelos e capabilities.response_format nos modelos open-weight alojados. Modelos e prezos

Palabras clave de esquema admitidas

O que recibe un modelo do teu esquema depende do modelo e do endpoint:

Modelos	`/v1/chat/completions`	`/v1/responses`
Modelos Shannon	O subconxunto de palabras clave de abaixo, aplicado como estrito.	O esquema tal como o envías, aplicado como estrito.
Modelos open-weight alojados	O esquema tal como o envías. `strict` é `true` a menos que o envíes.	O esquema tal como o envías. `strict` é `true` a menos que o envíes.

O subconxunto de palabras clave dos modelos Shannon en /v1/chat/completions:

Palabra clave	Como se le
Palabras clave lidas	`type`, `format`, `title`, `description`, `nullable`, `enum`, `items`, `properties`, `required`, `minItems`, `maxItems`, `minimum`, `maximum`, `minLength`, `maxLength`, `pattern`, `anyOf`, `default`
`$ref`	Resólvese desde `$defs` ou `definitions` no nivel superior do esquema. As palabras clave escritas xunto ao `$ref`, como `description`, consérvanse. Unha referencia sen definición correspondente lese como `{"type": "object"}`.
`allOf`	Os membros fúndense nun só esquema. Onde dous membros definen a mesma palabra clave, vale o último.
`oneOf`	Lese como `anyOf`.
Esquemas que se referencian a si mesmos	Expándense ata 24 niveis. Un nivel máis profundo lese como `{"type": "object"}`.
Fóra do subconxunto	Todas as demais palabras clave, por exemplo `additionalProperties`, `const`, `multipleOf`, `uniqueItems`, `exclusiveMinimum`, `exclusiveMaximum`, `patternProperties`, `prefixItems`, `minProperties`, `maxProperties`, `not` e `if` / `then` / `else`. Non forman parte do esquema que recibe o modelo.

En /v1/responses: text.format

/v1/responses escribe a mesma solicitude como text.format. O esquema está directamente en format, xunto a name e strict, non baixo unha clave json_schema. Para o modo de obxecto JSON envía {"format": {"type": "json_object"}}.

Corpo da solicitude

{
  "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 elemento 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": []
        }
      ]
    }
  ]
}

A compatibilidade por modelo e os erros son os mesmos que en /v1/chat/completions. API Responses

En /v1/messages: unha ferramenta como esquema

O formato Messages non ten campo de saída estruturada. Para obter JSON dos mesmos modelos, chama a /v1/chat/completions ou /v1/responses coa mesma clave.

Para quedar en /v1/messages, describe o obxecto como unha ferramenta: pon o teu esquema en input_schema e nomea a ferramenta en tool_choice. O input do bloque tool_use é entón o teu obxecto, xa analizado. Un tool_choice nomeado aplícano os modelos open-weight alojados.

Corpo da solicitude

{
  "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"}
    }
  ]
}

Comproba que stop_reason sexa tool_use antes de ler o bloque. Chamadas a funcións

Como chega o JSON

O JSON é unha cadea. A resposta non leva un obxecto analizado xunto a ela: executa o teu analizador JSON sobre message.content.
Con stream: true o JSON chega en anacos de delta.content. Úneos e analiza cando remate o stream; un anaco soamente non é JSON válido.
Un modelo open-weight alojado responde a unha solicitude con response_format sen texto de razoamento: reasoning_content é null.

Comproba o que recibes

O esquema guía como escribe o modelo. A API non compara a resposta rematada co teu esquema, así que o teu código fai a comprobación final:

Analiza dentro dun xestor de erros, como fai o exemplo do principio.
Valida o obxecto analizado co mesmo esquema no teu propio código, por exemplo cunha biblioteca de JSON Schema, Pydantic ou Zod.
Unha resposta longa pode rematar antes de que o JSON estea completo. Unha resposta sen stream informa finish_reason só como stop ou tool_calls, así que un erro de análise é o sinal. Pregunta de novo, ou pide un obxecto máis pequeno.

Erros

Estado	Tipo	Mensaxe	Cando
`400`	`invalid_request_error`	`<id> does not accept response_format`	O modelo non acepta ningún dos dous modos.
`400`	`invalid_request_error`	`<id> does not accept response_format json_schema; use json_object`	O modelo acepta `json_object` e enviaches `json_schema`.
`422`	`invalid_request_error`	`Failed to deserialize the JSON body into the target type: …`	`response_format` non ten `type`, ou non é un obxecto JSON.

As dúas respostas 400 envíanse antes de descontar nada do teu saldo. Xestión de erros