Ver todos los artículos
OllamaSalida estructuradaBenchmarksFacturasIA local

Salida JSON estructurada con Ollama: 40 facturas, medido

JG
Jacobo González Jaspe
|
Ilustración abstracta: anillos concéntricos con un arco ámbar que recorre parte del exterior. Desde la spark
Ilustración generada con IA en nuestra máquina.

Al terminar este artículo sabrás sacar de un modelo local un JSON que tu código pueda leer siempre, y sabrás comprobar si los valores que trae son correctos. Los ficheros de 7B que probamos cargaron en menos de 5 GB en Q4, así que basta un portátil de 16 GB; nuestras cifras salen de una DGX Spark. Probamos seis modelos y versiones con 40 facturas sintéticas en español para ver dónde falla cada uno.

La prueba

Escribimos un generador, no un modelo, que produce 40 facturas ficticias a partir de una semilla fija. Diez son facturas formales, diez son correos que anuncian una, diez son tickets de caja y diez son documentos desordenados, con espacios de más y «N.I.F.», como se lee un mal escaneo. Cada documento nombra al emisor y a un cliente, cada uno con su NIF.

Los importes vienen en formato español («1.234,56 €», «1 234,56 EUR») y las fechas en tres estilos. El modelo debe devolver nueve campos: número de factura, fecha, nombre del emisor, NIF del emisor, NIF del cliente, base, tipo de IVA, cuota de IVA y total. Las respuestas correctas salen del mismo generador, así que ningún modelo escribió ninguna. Las empresas son inventadas.

Son facturas sintéticas, no reales. Eso hace que las respuestas correctas sean seguras, pero también que no hayamos medido la precisión con facturas reales. Cuenta con que tus documentos den otra nota: por eso el paso 2 te pide puntuar diez tuyos.

Lo pedimos de tres formas, con la misma instrucción y temperatura 0: un prompt normal, format: "json" y format con un esquema JSON.

Qué necesitas

  • Ollama 0.5 o posterior. Los esquemas llegaron en diciembre de 2024 (anuncio de Ollama). Nuestra guía de instalación sirve para un portátil.
  • Un modelo de 7B u 8B; qwen2.5:7b ocupó 4,8 GB cargado con 4k de contexto en nuestra prueba.
  • Diez documentos reales tuyos y sus respuestas correctas, escritas por una persona. Sin respuestas solo mides lo seguro que suena el modelo.
  • Python 3 con requests.

Paso 1: escribe el esquema

Nombra cada campo, dale un tipo y márcalo como obligatorio. Usa number para el dinero: un campo numérico no admite el símbolo del euro ni la coma decimal española.

JSON
{
  "type": "object",
  "properties": {
    "invoice_number": {"type": "string"},
    "issue_date":     {"type": "string", "description": "AAAA-MM-DD"},
    "issuer_name":    {"type": "string"},
    "issuer_tax_id":  {"type": "string"},
    "client_tax_id":  {"type": "string"},
    "base_amount":    {"type": "number"},
    "vat_rate":       {"type": "number"},
    "vat_amount":     {"type": "number"},
    "total_amount":   {"type": "number"}
  },
  "required": ["invoice_number", "issue_date", "issuer_name", "issuer_tax_id",
               "client_tax_id", "base_amount", "vat_rate", "vat_amount", "total_amount"]
}

Guárdalo como schema.json. Mantén también la lista de campos en el prompt: el esquema fija la forma y el prompt explica qué significa cada campo.

Paso 2: envíalo y puntúalo

Python
import json, requests

SCHEMA = json.load(open("schema.json"))
PROMPT = ("Extrae los datos de esta factura como JSON. issue_date en formato AAAA-MM-DD, "
          "importes como número con punto decimal, NIF sin espacios ni guiones.\n\nDocumento:\n")

def ok(campo, valor, correcto):
    if campo.endswith("_amount") or campo == "vat_rate":
        return isinstance(valor, (int, float)) and abs(valor - correcto) <= 0.01
    if campo.endswith("tax_id"):
        return str(valor).replace("-", "").replace(" ", "").upper() == correcto
    return str(valor).strip().casefold() == str(correcto).strip().casefold()

docs = json.load(open("mis-facturas.json"))   # [{"text": "...", "gold": {...}}, ...]
bien = total = 0
for d in docs:
    r = requests.post("http://localhost:11434/api/chat", json={
        "model": "qwen2.5:7b", "stream": False, "format": SCHEMA,
        "options": {"temperature": 0, "num_ctx": 4096},
        "messages": [{"role": "user", "content": PROMPT + d["text"]}]},
        timeout=300).json()
    datos = json.loads(r["message"]["content"])
    bien += sum(ok(k, datos.get(k), v) for k, v in d["gold"].items())
    total += len(d["gold"])
print(f"{bien}/{total} campos correctos")

Salida esperada: una línea como 329/360 campos correctos, que es lo que sacó Q4_K_M con nuestro conjunto y el prompt del benchmark; este prompt más corto puede sacar algún campo más o menos. Si json.loads falla, ejecuta ollama --version: antes de la 0.5, el esquema de format se ignora. Nuestras 40 facturas con sus respuestas son públicas en structured-extraction-es-invoices-2026-11-05.json; cárgalas con json.load(open(...))["docs"] para probar tu modelo con el mismo conjunto antes de nada.

Qué medimos

Medido el 2026-11-05 en nuestra primera DGX Spark (spark-43d5, NVIDIA GB10, 128 GB de memoria unificada), Ollama 0.30.10, un modelo cargado cada vez, con num_ctx 4096 y semilla 42. Fichero en bruto: structured-extraction-2026-11-05.json.

bash
python3 scripts/bench/run_for_topic.py --host prime --slug structured-extraction \
  --bench "structured_extraction.py --models llama3.1:8b,qwen2.5-coder:7b,qwen2.5:7b-instruct-q4_K_M,qwen2.5:7b-instruct-q8_0,qwen2.5:7b-instruct-fp16,gemma4:26b"

Con esquema, 40 facturas, 360 campos:

ModeloFicheroCargadoCampos bienFacturas enteras bienCorreos enteros bienSegundos por facturatok/s
gemma4:26b (MoE)18,0 GB17,2 GB3604010 de 103,0762,3
qwen2.5:7b Q8_08,1 GB7,9 GB344345 de 104,9627,9
qwen2.5:7b FP1615,2 GB14,5 GB344345 de 108,3616,3
qwen2.5-coder:7b4,7 GB4,8 GB339334 de 103,4641,0
qwen2.5:7b Q4_K_M4,7 GB4,8 GB329262 de 103,3742,1
llama3.1:8b4,9 GB5,3 GB321221 de 102,8840,6

Las tres formas de pedirlo (campos bien de 360, y respuestas que eran JSON puro, listo para cargar):

ModeloPrompt normalformat: "json"format: esquemaJSON puro: prompt / json / esquema
gemma4:26b3603603600 / 40 / 40
qwen2.5:7b Q8_03413443445 / 40 / 40
qwen2.5:7b FP163413443443 / 40 / 40
qwen2.5-coder:7b3443393390 / 40 / 40
qwen2.5:7b Q4_K_M3323293296 / 40 / 40
llama3.1:8b3283213210 / 40 / 40

Sin format, 226 de 240 respuestas llegaron dentro de un bloque de código o detrás de una frase («Aquí tienes el JSON…»). Todas se pudieron leer después de recortar el bloque, pero ese recorte es código que tienes que escribir y mantener. Con format: "json", llama3.1:8b devolvió una vez los cuatro números como texto; con el esquema, la misma factura volvió con números. Cambiar de modo movió la precisión 7 campos o menos de 360.

Lo que no te dicen

  • Quién emite la factura es el campo difícil. En los correos, los datos del cliente van en el cuerpo y el emisor firma al final. Los modelos de 7B y 8B fallaron el emisor en 5 a 9 de 10 correos, y siempre pusieron al cliente en su lugar. gemma4:26b no falló ninguno.
  • Los importes fueron lo fácil. Las tres versiones de Qwen2.5 7B Instruct acertaron base, IVA y total en las 40 facturas con esquema. Los errores fueron nombres, NIF y una fecha.
  • Q4 pierde letras de los NIF. La versión Q4_K_M devolvió un NIF sin su letra en seis facturas en las que Q8_0 la conservó; cinco estaban escritos en grupos con espacios, como «A 09 014 170», que volvió como «09014170». Q8_0 acertó enteras 8 facturas que Q4_K_M falló, y ninguna al revés.
  • «12/06/2026» se convirtió en diciembre. Las tres versiones de Qwen2.5 7B Instruct leyeron la fecha de un ticket con el mes primero. Pide fechas ISO y revisa las que caigan en el futuro.
  • Aquí el esquema no lo hizo más lento. Las respuestas con esquema fueron más cortas (sin bloque de código ni frase de entrada), así que los segundos por factura bajaron en los seis. llama3.1:8b ya estaba cargado para otro trabajo de la máquina cuando empezó la prueba, así que sus tiempos pueden estar alterados y son los menos fiables de la tabla.

Veredicto

  • Esquema: compra (es gratis). Manda format con un esquema en cada llamada de extracción. Es un campo.
  • Modelo: mide antes. Con estas facturas sintéticas, gemma4:26b (17,2 GB cargado, así que cuenta con 24 GB o más) acertó todos los campos y tardó 3,07 s por factura, menos que cualquier versión de Qwen2.5 7B. En una máquina de 16 GB, lo que mejor puntuó de lo que probamos y cabe fue Qwen2.5 7B en Q8_0, con una persona que revise emisor y NIF.
  • Sáltatelo si piensas llevar los datos directos a la contabilidad desde un modelo de 7B sin revisión. Incluso la mejor versión de 7B de la prueba falló el emisor en la mitad de los correos.

Cuándo no hacerlo

Si tus facturas llegan escaneadas o en foto, primero necesitas el texto: OCR o un modelo de visión, que esta prueba no cubre. Lo medimos aparte con estas mismas 40 facturas convertidas en imágenes: leer facturas escaneadas con un modelo de visión local. Si recibes facturas electrónicas estructuradas (XML de Facturae, o lo que exporte tu programa de facturación), lee el fichero; un modelo de lenguaje solo añade errores a datos que ya son exactos. Y si procesas una docena de facturas al mes, teclearlas es más rápido que montar y comprobar todo esto.

Siguientes pasos

Trabaja con nosotros

Elegimos el modelo y la máquina midiendo, no adivinando. Si quieres ver tus propios documentos pasando por un modelo local en hardware real, reserva una llamada gratuita de 15 minutos o mira cómo trabajamos en consultoría.

Diagrama
Compartir: LinkedIn X
Veredicto semanal

Recibe las guías nuevas antes que nadie

Suscríbete y te avisamos cuando publiquemos guías, plantillas y workflows nuevos. Un correo a la semana, sin spam.

Ya publicados: 101 guías y 25 plantillas. Todo gratis y sin registro.

Bonus: el kit de inicio de IA local en PDF al suscribirte
1x por semana Sin spam Cancela cuando quieras

Ver qué recibes