Salidas restringidas o forzadas por esquema
En las lecciones anteriores validaste a mano el JSON del modelo. La práctica moderna va un paso antes: impedir que el modelo emita JSON incorrecto desde el principio. Esto es la decodificación restringida (también llamada salidas estructuradas). Le das a la API un esquema, y el decodificador solo puede muestrear tokens que mantengan la salida válida según él. El modelo, literalmente, no puede producir un campo que falte ni un valor con el tipo incorrecto.
Con la API al estilo de OpenAI pasas un response_format con un JSON Schema y strict: true (solo ilustrativo -> aquí no llamamos a ningún modelo):
resp = client.chat.completions.create(
model="...",
messages=[...],
response_format={
"type": "json_schema",
"json_schema": {
"name": "person",
"strict": True,
"schema": {
"type": "object",
"properties": {"name": {"type": "string"}, "age": {"type": "integer"}},
"required": ["name", "age"],
},
},
},
)El resto de este curso llama a Anthropic, que ofrece la misma garantía mediante output_config para respuestas con JSON garantizado y el uso de herramientas strict para entradas de herramientas perfectas según el esquema:
resp = client.messages.create(
model="claude-opus-5-5",
max_tokens=1024,
messages=[...],
output_config={"format": {
"type": "json_schema",
"schema": {
"type": "object",
"properties": {"name": {"type": "string"}, "age": {"type": "integer"}},
"required": ["name", "age"],
},
}},
)En ambos casos es el proveedor quien aplica la restricción. Pero la decodificación restringida sigue sin poder comprobar tus reglas de negocio (¿es plausible la edad? ¿es la moneda una de las que admites?), y no todos los modelos ni pasarelas la admiten. Así que validas en tu lado de todos modos. Ese validador es lo que construyes ahora.
En el lado de Python, el estándar de facto para declarar y validar esa forma es Pydantic. Escribes una clase de modelo y la biblioteca analiza, convierte y valida por ti:
from pydantic import BaseModel
class Person(BaseModel):
name: str
age: int
record = Person.model_validate_json(text) # raises if it does not fitPydantic no está disponible en este entorno dentro del navegador, así que construirás la misma idea a mano con la biblioteca estándar. Eso es exactamente lo que estas bibliotecas hacen por dentro, y hace imposible pasar las reglas por alto. Vas a escribir validate_against_schema(obj, schema).
El schema es un dict. Cada valor es o bien una cadena con el nombre de un tipo ("int", "float", "str", "bool", "list", "dict") o bien un pequeño dict de especificación como {"type": "int", "default": 0}. Tu función devuelve un dict de resultado {"ok": bool, "value": dict, "errors": list}:
- Si
objno es undict, devuelveok=Falsecon un error de raíz y unvaluevacío. - Para cada campo: si falta y la especificación tiene un
"default", rellena el valor por defecto (el paso de conversión y valores por defecto). Si falta sin valor por defecto, registra un error. - Si está presente, comprueba su tipo. Si no coincide, registra un error que nombre el campo.
- Convierte un
intsimple enfloatcuando se espera un float (eso no pierde información y es seguro), pero no conviertas nada más. - Si hubo algún error, devuelve
ok=Falsecon loserrorsreunidos y unvaluevacío; si no, devuelveok=Truecon elvaluevalidado.
La trampa de bool es int. En Python bool es una subclase de int, así que isinstance(True, int) es True y el true de JSON se decodifica como el True de Python. Una comprobación de tipo ingenua dejaría pasar "age": true por un campo int. Rechaza explícitamente un bool siempre que se requiera un int o un float:
if expected is int and isinstance(value, bool):
errors.append(field + ": expected int, got bool")Constrúyelo para que dos cargas bien formadas distintas pasen, para que un campo que falta y un tipo incorrecto acaben cada uno en errors, para que se rellene un valor por defecto, para que un int se convierta en float y para que un bool disimulado se rechace donde se requiere un número.
Escribe validate_against_schema(obj, schema), que devuelva {"ok", "value", "errors"}. schema asigna a cada campo una cadena con el nombre de un tipo ("int"/"float"/"str"/"bool"/"list"/"dict") o un dict de especificación {"type": ..., "default": ...}. Rechaza un obj que no sea dict, registra un error por cada campo que falte (sin valor por defecto) o tenga el tipo incorrecto, rellena el valor por defecto cuando se dé uno, convierte un int simple en float y rechaza un bool donde se requiera un int o un float (la trampa de bool es int). Devuelve ok=True con el value validado solo cuando no haya errores.
¿Has visto un problema en esta lección? Avísanos · Preguntar sobre esta lección
Este ejercicio se abre pronto
Termina la lección anterior y esta se desbloquea. Todo el curso es gratis, no hace falta cuenta, y puedes leer esta lección ahora mismo.
Este navegador está bloqueando las cookies de learn.floati.life, así que las lecciones que terminaste aquí no se pueden abrir en orden. Permite las cookies de este sitio y recarga.