Saltar al contenido principal
Venice ahora incluye salidas estructuradas mediante “response_format” como campo disponible en la API. Este campo te permite generar respuestas a tus prompts que sigan un formato predefinido específico. Con este nuevo método, los modelos son menos propensos a alucinar claves o valores incorrectos en la respuesta, algo más frecuente al intentarlo mediante manipulación del system prompt o function calling. El campo “response_format” de salida estructurada utiliza el formato de la API de OpenAI, y se describe con más detalle en la guía de OpenAI aquí. OpenAI también publicó un artículo introductorio sobre el uso de salidas estructuradas dentro de la API específicamente aquí. Como esta es una funcionalidad avanzada, hay un puñado de “gotchas” en la parte inferior de esta página que deben seguirse. Esta funcionalidad no está disponible de forma nativa en todos los modelos. Consulta la sección de modelos aquí y busca “supportsResponseSchema” para los modelos aplicables. 
    {
      "id": "venice-uncensored",
      "type": "text",
      "object": "model",
      "created": 1726869022,
      "owned_by": "venice.ai",
      "model_spec": {
        "availableContextTokens": 32768,
        "capabilities": {
          "supportsFunctionCalling": true,
          "supportsResponseSchema": true,
          "supportsWebSearch": true
        },

​
Cómo usar respuestas estructuradas

Para usar correctamente “response_format” puedes definir tu schema con varias “properties”, que representan categorías de salidas, cada una con tipos de datos configurados individualmente. Estos objetos pueden anidarse para crear estructuras de salida más avanzadas. Aquí tienes un ejemplo de una llamada a la API usando response_format para explicar el proceso paso a paso de resolver una ecuación matemática. Puedes ver que las properties se configuraron para requerir tanto “steps” como “final_answer” en la respuesta. Dentro del anidamiento, la categoría steps consta tanto de “explanation” como de “output”, cada uno como cadenas. 
curl --request POST \
  --url https://api.venice.ai/api/v1/chat/completions \
  --header 'Authorization: Bearer <api-key>' \
  --header 'Content-Type: application/json' \
  --data '{
  "model": "venice-uncensored",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful math tutor."
    },
    {
      "role": "user",
      "content": "solve 8x + 31 = 2"
    }
  ],
  "response_format": {
    "type": "json_schema",
    "json_schema": {
      "name": "math_response",
      "strict": true,
      "schema": {
        "type": "object",
        "properties": {
          "steps": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "explanation": {
                  "type": "string"
                },
                "output": {
                  "type": "string"
                }
              },
              "required": ["explanation", "output"],
              "additionalProperties": false
            }
          },
          "final_answer": {
            "type": "string"
          }
        },
        "required": ["steps", "final_answer"],
        "additionalProperties": false
      }
    }
  }
}
Aquí está la respuesta que se recibió del modelo. Puedes ver que la estructura siguió los requisitos, proporcionando primero los “steps” con la “explanation” y el “output” de cada paso, y después la “final answer”. 
{
  "steps": [
    {
      "explanation": "Subtract 31 from both sides to isolate the term with x.",
      "output": "8x + 31 - 31 = 2 - 31"
    },
    {
      "explanation": "This simplifies to 8x = -29.",
      "output": "8x = -29"
    },
    {
      "explanation": "Divide both sides by 8 to solve for x.",
      "output": "x = -29 / 8"
    }
  ],
  "final_answer": "x = -29 / 8"
}
Aunque este es un ejemplo simple, puede extrapolarse a casos de uso más avanzados como: extracción de datos, ejercicios de cadena de razonamiento, generación de UI, categorización de datos y muchos otros.

​
Gotchas

Aquí tienes algunos requisitos clave a tener en cuenta al usar salidas estructuradas mediante response_format:
  • Las solicitudes iniciales que usen response_format pueden tardar más en generar una respuesta. Las solicitudes posteriores no experimentarán la misma latencia que la inicial.
  • Para consultas más grandes, el modelo puede fallar al completar si se alcanzan max_tokens o el timeout del modelo, o si se infringe algún límite de velocidad.
  • Un formato de schema incorrecto provocará errores al completar, normalmente por timeout.
  • Aunque response_format garantiza que el modelo produzca una salida con un formato concreto, no garantiza que el modelo proporcione la información correcta en su interior. El contenido depende del prompt y del rendimiento del modelo.
  • Las salidas estructuradas mediante response_format no son compatibles con llamadas a funciones en paralelo.
  • Importante: todos los campos o parámetros deben incluir una etiqueta required. Para hacer un campo opcional, debes añadir una opción null dentro del type del campo, así: "type": ["string", "null"]
  • Es posible hacer campos opcionales dando una opción null dentro del campo required para permitir una respuesta vacía.
  • Importante: additionalProperties debe estar en false para que response_format funcione correctamente.
  • Importante: strict debe estar en true para que response_format funcione correctamente.