La IA puede convertir notas desestructuradas en JSON, pero el resultado debe validarse por separado. Esta guía usa un pequeño ejemplo sintético y una comprobación en Python para verificar campos obligatorios, tipos, valores permitidos y coherencia básica.
La traducción se ha realizado con IA. Comprueba el código, las unidades y los valores junto con el original. La revisión por hablantes nativos de cada idioma aún no se ha completado. English
Para quién esPersonas que usan un asistente de chat con IA para convertir notas, correos, formularios u otros textos desordenados en JSON estructurado y necesitan una validación repetible.
La IA resulta útil para convertir texto irregular en campos estructurados, pero una respuesta que parece un JSON válido todavía puede estar equivocada. Puede faltar una clave obligatoria, un número puede aparecer como texto, un campo puede contener un valor no permitido o la IA puede inferir información que nunca estuvo presente en la fuente.
El flujo más seguro separa la extracción de la validación. Primero pide a la IA que convierta el texto de origen a una estructura fija. Después comprueba el JSON devuelto mediante reglas explícitas. La validación no demuestra que todos los datos extraídos sean correctos, pero permite detectar muchos errores estructurales antes de copiar los datos a una hoja de cálculo, una base de datos, un script o un flujo de trabajo.
Este ejemplo es sintético. Supongamos que una nota breve de soporte contiene el nombre del cliente, el número de ticket, la prioridad, los productos afectados y una hora opcional para devolver la llamada.
Texto de origen: "Ticket 1842. Customer: Mira Lee. Login fails on the desktop app and web portal. Priority is high. Please call after 15:30. Products affected: Desktop, Web."
| Campo | Regla |
|---|---|
| ticket_id | Entero obligatorio |
| customer | Cadena obligatoria no vacía |
| priority | Obligatorio: low, medium o high |
| products | Lista obligatoria no vacía de cadenas |
| callback_time | Cadena con formato HH:MM o null |
El esquema se mantiene deliberadamente simple para poder comprobarlo con la biblioteca estándar de Python. Estas reglas son más estrictas que limitarse a comprobar si la respuesta puede analizarse como JSON.
Indica exactamente qué campos están permitidos y cómo deben tratarse los datos ausentes. Por ejemplo: "Extrae el siguiente texto en un único objeto JSON con exactamente estas claves: ticket_id, customer, priority, products, callback_time. ticket_id debe ser un entero. priority debe ser low, medium o high. products debe ser una lista de cadenas. Usa null para callback_time si no aparece. No infieras datos que falten. Devuelve solo JSON."
Un resultado correcto para la nota sintética tendría ticket_id 1842, customer Mira Lee, priority high, products Desktop y Web, y callback_time 15:30.
Una respuesta de IA plausible pero defectuosa podría devolver ticket_id como la cadena "1842", priority como "urgent" y añadir un campo no permitido como issue_summary. Puede parecer estructurada y legible, pero no cumple el esquema acordado.
El siguiente script utiliza únicamente la biblioteca estándar de Python. Carga una respuesta sintética de IA, comprueba que no existan claves inesperadas, verifica las claves y los tipos obligatorios, revisa los valores permitidos de priority, comprueba la lista de products y valida el formato de callback_time. Escribe un informe en outputs y se detiene si el informe ya existe.
import json
import re
from pathlib import Path
AI_RESPONSE = '''{
"ticket_id": "1842",
"customer": "Mira Lee",
"priority": "urgent",
"products": ["Desktop", "Web"],
"callback_time": "15:30",
"issue_summary": "Login problem"
}'''
REQUIRED_KEYS = {
"ticket_id",
"customer",
"priority",
"products",
"callback_time",
}
ALLOWED_PRIORITIES = {"low", "medium", "high"}
TIME_PATTERN = re.compile(r"^(?:[01]\d|2[0-3]):[0-5]\d$")
errors = []
try:
data = json.loads(AI_RESPONSE)
except json.JSONDecodeError as exc:
raise SystemExit(f"Invalid JSON: {exc}")
if not isinstance(data, dict):
errors.append("Top-level value must be a JSON object.")
else:
actual_keys = set(data)
missing = REQUIRED_KEYS - actual_keys
unexpected = actual_keys - REQUIRED_KEYS
if missing:
errors.append("Missing keys: " + ", ".join(sorted(missing)))
if unexpected:
errors.append("Unexpected keys: " + ", ".join(sorted(unexpected)))
if "ticket_id" in data and not isinstance(data["ticket_id"], int):
errors.append("ticket_id must be an integer.")
if "customer" in data:
customer = data["customer"]
if not isinstance(customer, str) or not customer.strip():
errors.append("customer must be a non-empty string.")
if "priority" in data:
priority = data["priority"]
if not isinstance(priority, str) or priority not in ALLOWED_PRIORITIES:
errors.append("priority must be low, medium, or high.")
if "products" in data:
products = data["products"]
if not isinstance(products, list) or not products:
errors.append("products must be a non-empty list.")
elif not all(isinstance(item, str) and item.strip() for item in products):
errors.append("Every product must be a non-empty string.")
if "callback_time" in data:
callback = data["callback_time"]
if callback is not None:
if not isinstance(callback, str) or not TIME_PATTERN.fullmatch(callback):
errors.append("callback_time must be HH:MM or null.")
status = "PASS" if not errors else "FAIL"
lines = [f"Validation: {status}"]
lines.extend(f"- {error}" for error in errors)
output_dir = Path("outputs")
output_dir.mkdir(exist_ok=True)
output_file = output_dir / "json_validation.txt"
if output_file.exists():
raise SystemExit(f"Stop: {output_file} already exists.")
output_file.write_text("\n".join(lines) + "\n", encoding="utf-8")
print(f"Wrote {output_file}")
En la respuesta sintética defectuosa, la validación debería fallar por tres motivos. ticket_id es una cadena en lugar de un entero. priority es urgent, que no pertenece al conjunto permitido. issue_summary es una clave inesperada. La lista de products y el formato de callback_time sí cumplen sus reglas estructurales.
| Comprobación | Valor de la IA | Esperado | Resultado |
|---|---|---|---|
| ticket_id | "1842" | entero | FAIL |
| customer | "Mira Lee" | cadena no vacía | PASS |
| priority | "urgent" | low, medium o high | FAIL |
| products | ["Desktop", "Web"] | lista no vacía de cadenas | PASS |
| callback_time | "15:30" | HH:MM o null | PASS |
| claves adicionales | issue_summary | ninguna | FAIL |
Cuando falla el esquema, normalmente conviene devolver el resultado para corregirlo en lugar de convertir valores silenciosamente. Convertir automáticamente "1842" en 1842 puede ocultar que no se siguieron las instrucciones de extracción. La conveniencia de permitir conversiones depende del flujo de trabajo posterior.
La validación estructural es solo una capa. También debes comparar los campos importantes con el texto original. En este ejemplo, ticket 1842, Mira Lee, high, Desktop, Web y 15:30 aparecen explícitamente en la fuente. La fuente no utiliza la palabra urgent, por lo que sustituir high por urgent cambia el valor indicado en lugar de limitarse a reformatearlo.
Un error común es comprobar únicamente si json.loads acepta la respuesta. Que el análisis tenga éxito demuestra que la sintaxis es JSON válida, no que las claves obligatorias, los tipos o los valores sean correctos. Otro error es permitir campos adicionales arbitrarios, lo que puede hacer que el código posterior dependa de información que nunca formó parte de la especificación.
Con esquemas más grandes, el código de validación escrito a mano resulta más difícil de mantener. Puede ser apropiado utilizar un sistema de esquemas o una biblioteca de validación específica, pero las preguntas básicas siguen siendo las mismas: qué campos son obligatorios, qué tipos se permiten, qué valores son válidos y si la información ausente puede representarse como null.
La validación tampoco demuestra que el texto original sea completo o fiable. Si la fuente contiene un número de ticket incorrecto o una frase ambigua, una extracción estructuralmente correcta conservará ese problema. Mantén disponible el texto original para poder rastrear los campos importantes cuando falle una regla de validación o de negocio.
2026-09-21 · hand-checked example · Python 3.12
Las explicaciones y los ejemplos son de elaboración propia. Puedes consultar los comportamientos y conceptos relacionados en las siguientes fuentes oficiales.