A IA pode transformar anotações não estruturadas em JSON, mas o resultado ainda precisa ser validado. Este guia usa um pequeno exemplo sintético e uma verificação em Python para conferir campos obrigatórios, tipos, valores permitidos e consistência básica.
A tradução foi feita com IA. Confira o código, as unidades e os valores junto com o original. A revisão por falantes nativos de cada idioma ainda não foi concluída. English
Para quem éPessoas que usam um assistente de chat com IA para converter anotações, e-mails, formulários ou outros textos desorganizados em JSON estruturado e precisam de uma etapa de validação repetível.
A IA é útil para transformar texto irregular em campos estruturados, mas uma resposta que parece um JSON válido ainda pode estar errada. Uma chave obrigatória pode estar ausente, um número pode ser retornado como texto, um campo pode conter um valor não permitido ou a IA pode inferir informações que nunca apareceram na fonte.
O fluxo mais seguro separa extração de validação. Primeiro, peça à IA para mapear o texto de origem para uma estrutura fixa. Depois, verifique o JSON retornado contra regras explícitas. A validação não prova que todos os fatos extraídos estão corretos, mas detecta muitos erros estruturais antes que os dados sejam copiados para uma planilha, banco de dados, script ou fluxo de trabalho.
Este exemplo é sintético. Suponha que uma breve nota de suporte contenha nome do cliente, número do ticket, prioridade, produtos afetados e um horário opcional para retorno.
Texto de origem: "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 | Regra |
|---|---|
| ticket_id | Inteiro obrigatório |
| customer | String obrigatória não vazia |
| priority | Obrigatório: low, medium ou high |
| products | Lista obrigatória não vazia de strings |
| callback_time | String no formato HH:MM ou null |
O esquema é deliberadamente simples e pode ser verificado apenas com a biblioteca padrão do Python. As regras são mais rígidas do que simplesmente perguntar se a resposta pode ser analisada como JSON.
Informe exatamente quais campos são permitidos e como tratar informações ausentes. Por exemplo: "Extraia o texto a seguir para um único objeto JSON com exatamente estas chaves: ticket_id, customer, priority, products, callback_time. ticket_id deve ser inteiro. priority deve ser low, medium ou high. products deve ser uma lista de strings. Use null para callback_time se não estiver informado. Não infira fatos ausentes. Retorne apenas JSON."
Um resultado correto para a nota sintética teria ticket_id 1842, customer Mira Lee, priority high, products Desktop e Web e callback_time 15:30.
Uma resposta plausível, mas incorreta, poderia retornar ticket_id como a string "1842", priority como "urgent" e adicionar um campo não permitido como issue_summary. Ainda pode parecer organizada e legível, mas não atende ao esquema combinado.
O script a seguir usa apenas a biblioteca padrão do Python. Ele carrega uma resposta sintética da IA, verifica se existem chaves inesperadas, confere chaves obrigatórias e tipos, testa os valores permitidos de priority, valida a lista products e verifica o formato de callback_time. O relatório é gravado em outputs e o script para se o arquivo já existir.
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}")
Para a resposta sintética incorreta, a validação deve falhar por três motivos. ticket_id é uma string em vez de inteiro. priority é urgent, que está fora do conjunto permitido. issue_summary é uma chave inesperada. A lista products e o formato de callback_time atendem às respectivas regras estruturais.
| Verificação | Valor da IA | Esperado | Resultado |
|---|---|---|---|
| ticket_id | "1842" | inteiro | FAIL |
| customer | "Mira Lee" | string não vazia | PASS |
| priority | "urgent" | low, medium ou high | FAIL |
| products | ["Desktop", "Web"] | lista não vazia de strings | PASS |
| callback_time | "15:30" | HH:MM ou null | PASS |
| chaves extras | issue_summary | nenhuma | FAIL |
Quando o esquema falha, normalmente é melhor devolver o resultado para correção em vez de converter valores silenciosamente. Converter automaticamente "1842" em 1842 pode esconder o fato de que as instruções de extração não foram seguidas. Permitir ou não coerção depende do fluxo posterior.
A validação estrutural é apenas uma camada. Campos importantes também devem ser comparados diretamente com o texto original. Neste exemplo, ticket 1842, Mira Lee, high, Desktop, Web e 15:30 aparecem explicitamente na fonte. A fonte não usa a palavra urgent, portanto substituir high por urgent altera o valor declarado em vez de apenas reformatá-lo.
Um erro comum é verificar apenas se json.loads aceita a resposta. Uma análise bem-sucedida prova que a sintaxe é JSON válida, não que chaves obrigatórias, tipos ou valores estejam corretos. Outro erro é permitir campos extras arbitrários, fazendo com que o código posterior possa depender de informações que nunca fizeram parte da especificação.
Com esquemas maiores, código de validação escrito à mão fica mais difícil de manter. Um sistema de esquema dedicado ou uma biblioteca de validação pode ser mais adequado, mas as perguntas básicas continuam iguais: quais campos são obrigatórios, quais tipos são permitidos, quais valores são válidos e se informações ausentes podem ser representadas por null.
A validação também não prova que o texto original seja completo ou confiável. Se a fonte contiver um número de ticket incorreto ou redação ambígua, uma extração estruturalmente correta preservará esse problema. Mantenha o texto original disponível para rastrear campos importantes quando uma regra de validação ou de negócio falhar.
2026-09-21 · hand-checked example · Python 3.12
As explicações e os exemplos são de elaboração própria. Os comportamentos e conceitos relacionados podem ser consultados nas fontes oficiais abaixo.