Resultados estructurados en Amazon Bedrock: respuestas de IA que cumplen con los esquemas

Hoy anunciamos resultados estructurados sobre Roca Amazónica—una capacidad que transforma fundamentalmente la forma en que se pueden obtener respuestas JSON validadas de modelos básicos mediante decodificación restringida para el cumplimiento del esquema.

Esto representa un cambio de ideal en el mejora de aplicaciones de IA. En emplazamiento de validar las respuestas JSON y escribir una razonamiento alternativa para cuando fallen, puede tener lugar directamente a construir con los datos. Con resultados estructurados, puede crear canales de datos de energía cero que confíen en los resultados del maniquí, sistemas agentes confiables que llamen con confianza a funciones externas y arquitecturas de aplicaciones simplificadas sin razonamiento de reintento.

En esta publicación, exploramos los desafíos de la engendramiento JSON tradicional y cómo los resultados estructurados los resuelven. Cubrimos los dos mecanismos principales (formato de salida de esquema JSON y uso cumplidor de herramientas) contiguo con detalles de implementación, mejores prácticas y ejemplos prácticos de código. Ya sea que esté creando canales de procedencia de datos, flujos de trabajo agentes o API impulsadas por IA, aprenderá a utilizar resultados estructurados para crear aplicaciones confiables y listas para producción. Nuestro compañero cuaderno jupyter proporciona ejemplos prácticos para cada característica cubierta aquí.

El problema de la engendramiento JSON tradicional

Durante primaveras, obtener datos estructurados a partir de modelos de estilo significó elaborar indicaciones detalladas, esperar lo mejor y construir sistemas elaborados de manejo de errores. Incluso con indicaciones cuidadosas, los desarrolladores se encuentran asiduamente con:

• Fallos de estudio: Sintaxis JSON no válida que error json.loads() llamadas
• Campos faltantes: Puntos de datos requeridos ausentes en las respuestas
• Tipos no coincidentes: Cadenas donde se esperan números enteros, interrumpiendo el procesamiento posterior
• Violaciones de esquema: Respuestas que técnicamente analizan pero no coinciden con su maniquí de datos

En los sistemas de producción, estas fallas se agravan. Una única respuesta con formato incorrecto puede transmitirse en cascada a través de su canalización, lo que requiere reintentos que aumentan la latencia y los costos. Para flujos de trabajo agentes donde los modelos llaman a herramientas, los parámetros no válidos pueden interrumpir por completo las llamadas a funciones.

Considere un sistema de reservas que requiera passengers: int. Sin la aplicación del esquema, el maniquí podría retornar passengers: "two" o passengers: "2"—JSON sintácticamente válido, pero semánticamente incorrecto para la firma de su función.

¿Qué cambia con los resultados estructurados?

Los resultados estructurados en Amazon Bedrock no son una restablecimiento incremental: es un cambio fundamental del formato de resultados probabilístico al determinista. Mediante la decodificación restringida, Amazon Bedrock restringe las respuestas del maniquí para que se ajusten al esquema JSON especificado. Están disponibles dos mecanismos complementarios:

Estas funciones se pueden utilizar de forma independiente o conjunta, lo que le brinda un control preciso sobre lo que genera el maniquí y cómo claridad a sus funciones.

Qué ofrecen los resultados estructurados:

• Siempre válido: No más JSON.parse() errores o excepciones de estudio
• Escriba seguro: Los tipos de campos se aplican y los campos obligatorios siempre están presentes
• Confiable: No se necesitan reintentos por violaciones del esquema
• Presto para la producción: Implemente con confianza a escalera empresarial

Cómo funcionan los resultados estructurados

Los resultados estructurados utilizan muestreo restringido con artefactos gramaticales compilados. Esto es lo que sucede cuando realiza una solicitud:

1. Potencia de esquema: Amazon Bedrock valida su esquema JSON con el subconjunto JSON Schema Draft 2020-12 compatible
2. compilación de gramática: Para esquemas nuevos, Amazon Bedrock compila una gramática (la primera solicitud puede tardar más)
3. Almacenamiento en elegancia: Las gramáticas compiladas se almacenan en elegancia durante 24 horas, lo que agiliza las solicitudes posteriores
4. engendramiento restringida: El maniquí genera tokens que producen JSON válido que coincide con su esquema.

Consideraciones de rendimiento:

• Latencia de primera solicitud: La compilación auténtico podría juntar latencia a los nuevos esquemas
• Rendimiento en elegancia: Las solicitudes posteriores con esquemas idénticos tienen una sobrecarga mínima
• Zona de influencia del elegancia: Las gramáticas se almacenan en elegancia por cuenta durante 24 horas desde el primer llegada.

Cambiar la estructura del esquema JSON o el esquema de entrada de una aparejo invalida el elegancia, pero cambiar solo name o description los campos no.

Comenzando con resultados estructurados

El ulterior ejemplo demuestra resultados estructurados con la API de Converse:

import boto3
import json
# Initialize the Bedrock Runtime client
bedrock_runtime = boto3.client(
    service_name="bedrock-runtime",
    region_name="us-east-1"  # Choose your preferred region
)
# Define your JSON schema
extraction_schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string", "description": "Customer name"},
        "email": {"type": "string", "description": "Customer email address"},
        "plan_interest": {"type": "string", "description": "Product plan of interest"},
        "demo_requested": {"type": "boolean", "description": "Whether a demo was requested"}
    },
    "required": ("name", "email", "plan_interest", "demo_requested"),
    "additionalProperties": False
}
# Make the request with structured outputs
response = bedrock_runtime.converse(
    modelId="us.anthropic.claude-opus-4-5-20251101-v1:0",
    messages=(
        {
            "role": "user",
            "content": (
                {
                    "text": "Extract the key information from this email: John Smith ([email protected]) is interested in our Enterprise plan and wants to schedule a demo for next Tuesday at 2pm."
                }
            )
        }
    ),
    inferenceConfig={
        "maxTokens": 1024
    },
    outputConfig={
        "textFormat": {
            "type": "json_schema",
            "structure": {
                "jsonSchema": {
                    "schema": json.dumps(extraction_schema),
                    "name": "lead_extraction",
                    "description": "Extract lead information from customer emails"
                }
            }
        }
    }
)
# Parse the schema-compliant JSON response
result = json.loads(response("output")("message")("content")(0)("text"))
print(json.dumps(result, indent=2))

Producción:

{
  "name": "John Smith",
  "email": "[email protected]",
  "plan_interest": "Enterprise",
  "demo_requested": true
}

La respuesta se ajusta a su esquema; no se requiere energía adicional.

Requisitos y mejores prácticas

Para utilizar productos estructurados de guisa efectiva, siga estas pautas:

• Colocar additionalProperties: false sobre todos los objetos. Esto es necesario para que funcionen los resultados estructurados. Sin él, su esquema no será aceptado.

{
  "type": "object",
  "properties": {
    "name": {"type": "string"}
  },
  "required": ("name"),
  "additionalProperties": false
}

• Utilice nombres y descripciones de campos descriptivos. Los modelos utilizan nombres de propiedades y descripciones para comprender qué datos extraer. Nombres claros como customer_email superan a los nombres genéricos como field1.
• Usar enum para títulos restringidos. Cuando un campo tiene un conjunto circunscrito de títulos válidos, utilice enum para cercar las opciones. Esto restablecimiento la precisión y produce títulos válidos.
• Comience con lo principal y luego agregue complejidad. Comience con los campos mínimos requeridos y agregue complejidad gradualmente. Los esquemas básicos se compilan más rápido y son más fáciles de amparar.
• Reutilice esquemas para beneficiarse del almacenamiento en elegancia. Estructura tu aplicación para reutilizar esquemas en todas las solicitudes. El elegancia gramatical de 24 horas restablecimiento significativamente el rendimiento de consultas repetidas.
• Controlar stopReason en cada respuesta. Dos escenarios pueden producir respuestas no conformes: rechazos (cuando el maniquí rechaza por razones de seguridad) y límites simbólicos (cuando max_tokens se alcanza antiguamente de completar). Maneje entreambos casos en su código.
• Pruebe con datos realistas antiguamente de la implementación. Valide sus esquemas con entradas representativas de la producción. Los casos extremos en datos reales a menudo revelan problemas de diseño de esquemas.

Funciones de esquema JSON compatibles:

• Todos los tipos básicos: object, array, string, integer, number, boolean, null
• enum (solo cadenas, números, bools o nulos)
• const, anyOf, allOf (con limitaciones)
• $ref, $defy definitions (solo referencias internas)
• Formatos de cautiverio: date-time, time, date, duration, email, hostname, uri, ipv4, ipv6, uuid
• Formación minItems (solo títulos 0 y 1)

No compatible:

• Esquemas recursivos
• Forastero $ref referencias
• Restricciones numéricas (minimum, maximum, multipleOf)
• Restricciones de cautiverio (minLength, maxLength)
• additionalProperties establecido en cualquier otra cosa que no sea false

Uso cumplidor de herramientas para flujos de trabajo agentes

Al crear aplicaciones donde los modelos llaman a herramientas, establezca strict: true en la definición de su aparejo para restringir los parámetros de la aparejo para que coincidan exactamente con su esquema de entrada:

import boto3
import json
bedrock_runtime = boto3.client('bedrock-runtime', region_name="us-east-1")
response = bedrock_runtime.converse(
    modelId="us.anthropic.claude-opus-4-5-20251101-v1:0",
    messages=(
        {
            "role": "user",
            "content": ({"text": "What's the weather like in San Francisco?"})
        }
    ),
    inferenceConfig={"maxTokens": 1024},
    toolConfig={
        "tools": (
            {
                "toolSpec": {
                    "name": "get_weather",
                    "description": "Get the current weather for a specified location",
                    "strict": True,  # Enable strict mode
                    "inputSchema": {
                        "json": {
                            "type": "object",
                            "properties": {
                                "location": {
                                    "type": "string",
                                    "description": "The city and state, e.g., San Francisco, CA"
                                },
                                "unit": {
                                    "type": "string",
                                    "enum": ("celsius", "fahrenheit"),
                                    "description": "Temperature unit"
                                }
                            },
                            "required": ("location", "unit"),
                            "additionalProperties": False
                        }
                    }
                }
            }
        )
    }
)
# Tool inputs conform to the schema
for content_block in response("output")("message")("content"):
    if "toolUse" in content_block:
        tool_input = content_block("toolUse")("input")
        print(f"Tool: {content_block('toolUse')('name')}")
        print(f"Input: {json.dumps(tool_input, indent=2)}")

Con strict: truelas panorama estructuradas restringen la salida de modo que:

• El location El campo es siempre una cautiverio.
• El unit El campo siempre es cualquiera de los dos. celsius o fahrenheit
• No aparecen campos inesperados en la entrada.

Aplicaciones prácticas en todas las industrias

El cuaderno demuestra casos de uso que abarcan industrias:

• Servicios financieros: extraiga datos estructurados de informes de ganancias, solicitudes de préstamos y documentos de cumplimiento. Con resultados estructurados, todos los campos obligatorios están presentes y escritos correctamente para el procesamiento posterior.
• Cuidado de la salubridad: Analice notas clínicas en registros estructurados que cumplan con el esquema. Extraiga información del paciente, diagnósticos y planes de tratamiento en JSON validado para la integración de EHR.
• Comercio electrónico: Cree canales confiables de beneficio del catálogo de productos. Extraiga especificaciones, categorías y atributos de descripciones de productos con resultados consistentes y confiables.
• Legítimo: Analice contratos y extraiga términos, partes, fechas y obligaciones secreto en formatos estructurados adecuados para sistemas de trámite de contratos.
• Servicio al cliente: cree sistemas inteligentes de enrutamiento y respuesta de tickets donde las intenciones, sentimientos y entidades extraídas coincidan con el maniquí de datos de su aplicación.

Nominar el enfoque correcto

Nuestras pruebas revelaron patrones claros sobre cuándo utilizar cada función:

Utilice el formato de salida del esquema JSON cuando:

• Necesitas la respuesta del maniquí en una estructura específica.
• Creación de canales de procedencia de datos
• Generando respuestas listas para API
• Crear informes o resúmenes estructurados

Utilice un uso cumplidor de herramientas cuando:

• Construyendo sistemas agentes que llaman a funciones externas.
• Implementación de flujos de trabajo de varios pasos con cadenas de herramientas
• Requerir tipos de parámetros validados para llamadas a funciones
• Conexión de IA a bases de datos, API o servicios externos

Utilice entreambos juntos cuando:

• Crear agentes complejos que necesitan llamadas de herramientas validadas y respuestas finales estructuradas.
• Crear sistemas donde los resultados de las herramientas intermedias se conviertan en resultados estructurados.
• Implementación de flujos de trabajo empresariales que requieren cumplimiento de esquemas de un extremo a otro

Comparación de API: Converse en comparación con InvokeModel

Tanto la API de Converse como la API de InvokeModel admiten panorama estructuradas, con formatos de parámetros sutilmente diferentes:

Nota: La API InvokeModel utiliza diferentes nombres de campos de solicitud según el tipo de maniquí. Para los modelos Anthropic Claude, utilice output_config.format para panorama de esquema JSON. Para modelos de peso despejado, utilice response_format en cambio.

Elija la API de Converse para conversaciones de varios turnos y la API de InvokeModel cuando necesite llegada directo al maniquí con formatos de solicitud específicos del proveedor.

Modelos compatibles y disponibilidad

Los resultados estructurados generalmente están disponibles en todas las regiones comerciales de AWS para proveedores de modelos seleccionados de Amazon Bedrock:

• antrópico
• búsqueda profunda
• Google
• minimax
• Mistral AI
• IA disparada a la cristalera
• Nvidia
• Destapado AI
• Qwen

La característica funciona perfectamente con:

• Inferencia entre regiones: Utilice resultados estructurados en todas las regiones de AWS sin configuración adicional
• inferencia por lotes: Procese grandes volúmenes con resultados compatibles con el esquema
• Transmisión: Transmita respuestas estructuradas con ConverseStream o InvokeModelWithResponseStream

Conclusión

En esta publicación, descubrió cómo los resultados estructurados en Amazon Bedrock reducen la incertidumbre del JSON generado por IA a través de respuestas validadas y compatibles con el esquema. Al utilizar el formato de salida JSON Schema y el uso cumplidor de herramientas, puede crear canales de procedencia de datos confiables, flujos de trabajo de agente sólidos y aplicaciones de IA listas para producción, sin razonamiento de energía o estudio personalizado. Ya sea que esté extrayendo datos de documentos, creando automatización inteligente o creando API impulsadas por IA, los resultados estructurados brindan la confiabilidad que sus aplicaciones exigen.

Los resultados estructurados ahora están disponibles de forma generalizada en Amazon Bedrock. Para utilizar resultados estructurados con las API de Converse, actualice al posterior SDK de AWS. Para obtener más información, consulte el Documentación de Amazon Bedrock y explora nuestro cuaderno de muestra.

¿Qué flujos de trabajo podrían desbloquear JSON validado y compatible con el esquema en su ordenamiento? El cuaderno proporciona todo lo que necesita para averiguarlo.

Sobre los autores