Extracción de tablas y estructura
En esta página
Actualizado el 2 de noviembre de 2026 — OCR. El modelo OCR 4.0 (
mistral-ocr-4-0) se retiró el 30 de septiembre de 2026. Utiliza OCR 4.1 (mistral-ocr-4-1), disponible en producción desde el 31 de agosto al mismo precio, o el aliasmistral-ocr-latest, que apunta a él desde el 16 de julio. OCR 4.1 añade puntuaciones de confianza a nivel de bloque.
Tablas: la debilidad histórica del OCR
Pídele a Tesseract que extraiga la tabla resumen de un informe financiero y obtendrás una ristra de líneas donde los valores de la columna «Total» se mezclan con los de la columna «Cantidad», sin ninguna pista que los vincule a sus filas originales. El problema no es el reconocimiento de caracteres, que funciona bien; es la total falta de conciencia de la estructura tabular. Las soluciones tradicionales leen de izquierda a derecha y de arriba abajo, perdiendo por el camino las relaciones entre columnas y filas.
OCR 4 aborda la página de forma distinta: la ve. Esta comprensión visual le permite restaurar una tabla como tal, no como texto aplanado.
El parámetro table_format
Controlas el renderizado de las tablas con un único parámetro que pasas a la llamada del OCR:
import os
from mistralai.client import Mistral
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
# Formato Markdown (recomendado para la mayoría de los casos)
ocr_response = client.ocr.process(
model="mistral-ocr-latest",
document={
"type": "document_url",
"document_url": "https://example.com/financial-report.pdf"
},
table_format="markdown"
)
Existen tres valores posibles y la elección no es cosmética: determina qué puedes hacer con el resultado aguas abajo.
Con null, el valor por defecto, las tablas se integran en el flujo de Markdown sin un formato tabular específico. Esta configuración funciona cuando no procesas documentos tabulares y solo quieres texto para indexar.
Con "markdown", cada tabla se renderiza en el formato estándar de tuberías, produciendo una salida legible tal cual y fácil de analizar:
| Producto | Cantidad | Precio unitario | Total |
|---------|----------|------------|-------|
| Widget A | 100 | 12,50 € | 1.250 € |
| Widget B | 50 | 25,00 € | 1.250 € |
| **Total** | **150** | | **2.500 €** |
Con "html", la tabla se renderiza como HTML completo, conservando la fusión de celdas y el formato avanzado que Markdown no puede expresar:
<table>
<thead>
<tr>
<th>Producto</th>
<th>Cantidad</th>
<th>Precio unitario</th>
<th>Total</th>
</tr>
</thead>
<tbody>
<tr>
<td>Widget A</td>
<td>100</td>
<td>12,50 €</td>
<td>1.250 €</td>
</tr>
</tbody>
</table>
En la práctica, Markdown cubre la mayoría de las necesidades: indexación RAG, búsqueda o visualización en un editor. Cambia a HTML en cuanto tus tablas incluyan celdas fusionadas o el resultado deba incrustarse en una página web. Mantén null solo cuando las tablas no importen en tu flujo de trabajo, por ejemplo, en un informe narrativo o correspondencia.
Recuperación de tablas como datos
Una tabla en Markdown sigue siendo texto. Para convertirla en datos manipulables, necesitas localizarla en el flujo y dividirla. La siguiente función recorre las líneas, identifica las que pertenecen a una tabla, ignora la línea separadora y cierra la tabla actual en cuanto aparece una línea normal:
import os
import re
import json
from mistralai.client import Mistral
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
def extract_markdown_tables(markdown: str) -> list[list[list[str]]]:
"""Extrae tablas de Markdown y las convierte en listas."""
tables = []
lines = markdown.split("\n")
current_table = []
in_table = False
for line in lines:
if "|" in line and line.strip().startswith("|"):
# Ignorar línea separadora (|---|---|)
if re.match(r"^\|[\s\-:|]+\|$", line.strip()):
continue
cells = [
c.strip() for c in line.strip().strip("|").split("|")
]
current_table.append(cells)
in_table = True
else:
if in_table and current_table:
tables.append(current_table)
current_table = []
in_table = False
if current_table:
tables.append(current_table)
return tables
# Extracción OCR con tablas en Markdown
ocr_response = client.ocr.process(
model="mistral-ocr-latest",
document={
"type": "document_url",
"document_url": "https://example.com/invoice.pdf"
},
table_format="markdown"
)
# Iterar por páginas y extraer tablas
for page in ocr_response.pages:
tables = extract_markdown_tables(page.markdown)
for i, table in enumerate(tables):
print(f"Página {page.index + 1}, Tabla {i + 1}:")
print(json.dumps(table, indent=2, ensure_ascii=False))
La comprobación final fuera del bucle no es decorativa: sin ella, una tabla al final de una página —un caso común en el resumen de una factura— nunca se añadiría a la lista, ya que ninguna línea normal aparecería después para cerrarla.
Paso a pandas para el análisis
Una lista de listas basta para la exportación, no para el cálculo. Convertir a un DataFrame implica promover la primera fila a cabeceras:
import pandas as pd
def tables_to_dataframes(markdown: str) -> list[pd.DataFrame]:
"""Convierte tablas de Markdown en DataFrames de pandas."""
tables = extract_markdown_tables(markdown)
dataframes = []
for table in tables:
if len(table) < 2:
continue
headers = table[0]
data = table[1:]
df = pd.DataFrame(data, columns=headers)
dataframes.append(df)
return dataframes
# Uso
for page in ocr_response.pages:
dfs = tables_to_dataframes(page.markdown)
for df in dfs:
print(df.to_string())
print()
La prueba len(table) < 2 filtra los falsos positivos: una línea aislada que contenga una tubería, dentro de un bloque de código o una dirección, no producirá un DataFrame roto y vacío. Ten en cuenta que los valores siguen siendo cadenas; convertir «1.250 €» a un número sigue siendo tarea tuya.
Cuando las tablas se complican
Las celdas fusionadas, los encabezados de dos niveles o los diseños irregulares empujan a Markdown más allá de sus límites expresivos. Cambia entonces a HTML y deja que BeautifulSoup y pandas se encarguen del análisis:
from bs4 import BeautifulSoup
import pandas as pd
ocr_response = client.ocr.process(
model="mistral-ocr-latest",
document={
"type": "document_url",
"document_url": "https://example.com/complex-report.pdf"
},
table_format="html"
)
for page in ocr_response.pages:
soup = BeautifulSoup(page.markdown, "html.parser")
tables = soup.find_all("table")
for table in tables:
df = pd.read_html(str(table))[0]
print(df)
Este enfoque te ahorra escribir un analizador: pd.read_html gestiona los atributos rowspan y colspan que tu división manual pasaría por alto. El coste es una dependencia extra y una salida ligeramente más verbosa, una compensación que merece la pena para informes financieros o tablas regulatorias.
Puntos clave
- El parámetro
table_formatcontrola el renderizado de tablas (null, markdown, html) - El formato Markdown se adapta a la mayoría de los casos de uso
- El formato HTML conserva las celdas fusionadas y el formato avanzado
- Las tablas extraídas pueden convertirse en DataFrames de pandas para su análisis
- OCR 4 reconstruye fielmente la estructura tabular, incluso en diseños complejos