# Salida JSON estructurada con Ollama: 40 facturas, medido

> Sacamos 9 campos de 40 facturas sintéticas con 6 modelos locales. El esquema JSON dejó limpias todas las respuestas; la precisión la decidió el modelo.

- Publicado: 2026-11-12
- Autor: Jacobo González Jaspe
- Idioma: es
- Etiquetas: Ollama, Salida estructurada, Benchmarks, Facturas, IA local
- URL canónica: https://vorluxai.com/blog/ollama-salida-json-facturas-medido-es/
- Fuente: VORLUX AI (J4SGON S.L.), https://vorluxai.com/

---

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.

> **En corto**
> - **Te llevas:** la precisión campo a campo de seis modelos locales con 40 facturas, tres formas de pedirlo y el código para puntuarlo.
> - **Cuesta:** nada. Un campo `format` en la petición.
> - **Veredicto:** manda siempre un esquema. Convirtió todas las respuestas en JSON limpio. La precisión la puso el modelo: gemma4:26b acertó 360 de 360 campos, los de 7B y 8B entre 321 y 344, y todos esos modelos pequeños tropezaron con quién emite una factura enviada por correo.

## 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](https://ollama.com/blog/structured-outputs)). Nuestra [guía de instalación](https://vorluxai.com/blog/instalar-ollama-primer-llm-local-es/) 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](https://vorluxai.com/data/measurements/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](https://vorluxai.com/data/measurements/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:**

| Modelo | Fichero | Cargado | Campos bien | Facturas enteras bien | Correos enteros bien | Segundos por factura | tok/s |
|---|---|---|---|---|---|---|---|
| gemma4:26b (MoE) | 18,0 GB | 17,2 GB | 360 | 40 | 10 de 10 | 3,07 | 62,3 |
| qwen2.5:7b Q8_0 | 8,1 GB | 7,9 GB | 344 | 34 | 5 de 10 | 4,96 | 27,9 |
| qwen2.5:7b FP16 | 15,2 GB | 14,5 GB | 344 | 34 | 5 de 10 | 8,36 | 16,3 |
| qwen2.5-coder:7b | 4,7 GB | 4,8 GB | 339 | 33 | 4 de 10 | 3,46 | 41,0 |
| qwen2.5:7b Q4_K_M | 4,7 GB | 4,8 GB | 329 | 26 | 2 de 10 | 3,37 | 42,1 |
| llama3.1:8b | 4,9 GB | 5,3 GB | 321 | 22 | 1 de 10 | 2,88 | 40,6 |

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

| Modelo | Prompt normal | `format: "json"` | `format: esquema` | JSON puro: prompt / json / esquema |
|---|---|---|---|---|
| gemma4:26b | 360 | 360 | 360 | 0 / 40 / 40 |
| qwen2.5:7b Q8_0 | 341 | 344 | 344 | 5 / 40 / 40 |
| qwen2.5:7b FP16 | 341 | 344 | 344 | 3 / 40 / 40 |
| qwen2.5-coder:7b | 344 | 339 | 339 | 0 / 40 / 40 |
| qwen2.5:7b Q4_K_M | 332 | 329 | 329 | 6 / 40 / 40 |
| llama3.1:8b | 328 | 321 | 321 | 0 / 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

- Mira qué pierde Q4_K_M frente a Q8_0 y FP16 con estas mismas facturas: [Q4, Q8 o FP16, medido](https://vorluxai.com/blog/q4-q8-fp16-cuantizacion-medido-es/).
- Elige la codificación pensando en tu memoria: [cuantización GGUF: elige el fichero adecuado](https://vorluxai.com/blog/gguf-quantization-pick-the-right-file-for-your-hardware-es/).
- Fija `num_ctx` antes de que los documentos largos lo llenen: [Ollama num_ctx y memoria, medido](https://vorluxai.com/blog/ollama-longitud-contexto-memoria-medida-es/).
- Lleva los campos extraídos a una búsqueda sobre tus documentos: [RAG local con Qdrant y bge-m3](https://vorluxai.com/blog/rag-local-qdrant-bge-m3-medido-es/).
- Antes de pasar facturas reales, lee la EIPD que rellenamos para esta misma extracción.

## 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](https://vorluxai.com/contact/) o mira [cómo trabajamos en consultoría](https://vorluxai.com/consulting/).
