Extração de Tabelas e Estrutura
Nesta página
Atualizado em 2 de novembro de 2026 — OCR. O OCR 4.0 (
mistral-ocr-4-0) foi desativado a 30 de setembro de 2026. Utilize o OCR 4.1 (mistral-ocr-4-1), geralmente disponível desde 31 de agosto pelo mesmo preço, ou o aliasmistral-ocr-latest, que aponta para ele desde 16 de julho. O OCR 4.1 adiciona pontuações de confiança ao nível do bloco.
Tabelas: A Fraqueza Histórica do OCR
Peça ao Tesseract para extrair a tabela de resumo de um relatório financeiro e obterá uma sequência de linhas onde os valores da coluna “Total” se misturam com os da coluna “Quantidade”, sem qualquer indicação que os ligue às suas linhas originais. O problema não é o reconhecimento de carateres, que funciona bem; é a total falta de consciência da estrutura tabular. As soluções tradicionais leem da esquerda para a direita e de cima para baixo, perdendo pelo caminho as relações entre colunas e linhas.
O OCR 4 aborda a página de forma diferente: ele vê-a. Esta compreensão visual permite-lhe restaurar uma tabela como uma tabela, e não como texto achatado.
O Parâmetro table_format
Controla a renderização das tabelas com um único parâmetro passado na chamada ao OCR:
import os
from mistralai.client import Mistral
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
# Formato Markdown (recomendado para a maioria dos 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"
)
São possíveis três valores, e a escolha não é cosmética: determina o que pode fazer com o resultado a jusante.
Com null, o valor predefinido, as tabelas são integradas no fluxo Markdown sem formatação tabular específica. Esta configuração funciona quando não está a processar documentos tabulares e apenas quer texto para indexação.
Com "markdown", cada tabela é renderizada no formato padrão de pipes, produzindo um resultado legível tal como está e fácil de analisar:
| Produto | Quantidade | Preço Unitário | Total |
|---------|----------|------------|-------|
| Widget A | 100 | €12,50 | €1.250 |
| Widget B | 50 | €25,00 | €1.250 |
| **Total** | **150** | | **€2.500** |
Com "html", a tabela é renderizada como HTML completo, preservando a fusão de células e formatação avançada que o Markdown não consegue expressar:
<table>
<thead>
<tr>
<th>Produto</th>
<th>Quantidade</th>
<th>Preço Unitário</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>
Na prática, o Markdown cobre a maioria das necessidades: indexação RAG, pesquisa ou exibição num editor. Mude para HTML assim que as suas tabelas incluírem células fundidas ou o resultado precisar de ser incorporado numa página web. Mantenha null apenas quando as tabelas não forem relevantes no seu fluxo de trabalho — digamos, um relatório narrativo ou correspondência.
Recuperação de Tabelas como Dados
Uma tabela Markdown continua a ser texto. Para a transformar em dados manipuláveis, precisa de a detetar no fluxo e dividi-la. A função abaixo percorre as linhas, identifica as que pertencem a uma tabela, ignora a linha separadora e fecha a tabela atual assim que surge uma linha 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]]]:
"""Extrai tabelas Markdown e converte-as em listas."""
tables = []
lines = markdown.split("\n")
current_table = []
in_table = False
for line in lines:
if "|" in line and line.strip().startswith("|"):
# Ignorar linha 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
# Extração OCR com tabelas 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 pelas páginas e extrair tabelas
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}, Tabela {i + 1}:")
print(json.dumps(table, indent=2, ensure_ascii=False))
A verificação final fora do ciclo não é decorativa: sem ela, uma tabela no final de uma página — um caso comum para o resumo de uma fatura — nunca seria adicionada à lista, pois nenhuma linha normal surgiria para a fechar.
Transição para o pandas para Análise
Uma lista de listas serve para exportação, não para cálculo. Converter para um DataFrame significa promover a primeira linha a cabeçalhos:
import pandas as pd
def tables_to_dataframes(markdown: str) -> list[pd.DataFrame]:
"""Converte tabelas Markdown em DataFrames 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
# Utilização
for page in ocr_response.pages:
dfs = tables_to_dataframes(page.markdown)
for df in dfs:
print(df.to_string())
print()
O teste len(table) < 2 filtra falsos positivos: uma linha isolada contendo um pipe, dentro de um bloco de código ou num endereço, não produzirá um DataFrame quebrado e vazio. Tenha em mente que os valores permanecem como strings; converter “€1.250” num número continua a ser da sua responsabilidade.
Quando as Tabelas se Tornam Complexas
Células fundidas, cabeçalhos de dois níveis ou layouts irregulares empurram o Markdown para além dos seus limites expressivos. Mude então para HTML e deixe o BeautifulSoup e o pandas tratar da análise:
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)
Esta abordagem poupa-o de escrever um analisador: pd.read_html trata dos atributos rowspan e colspan que a sua divisão manual ignoraria. O custo é uma dependência extra e um resultado ligeiramente mais verboso — uma compensação que vale a pena para relatórios financeiros ou tabelas regulamentares.
Pontos-chave
- O parâmetro
table_formatcontrola a renderização da tabela (null, markdown, html) - O formato Markdown adequa-se à maioria dos casos de uso
- O formato HTML preserva células fundidas e formatação avançada
- As tabelas extraídas podem ser convertidas em DataFrames pandas para análise
- O OCR 4 reconstrói fielmente a estrutura tabular, mesmo em layouts complexos