Integração OCR + RAG
Nesta página
Atualização de 2 de novembro de 2026 — OCR. O OCR 4.0 (
mistral-ocr-4-0) foi descontinuado 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. Adenda de 3 de novembro de 2026: Um PDF local é transmitido em base64 como{"type": "document_url", "document_url": "data:application/pdf;base64,…"}; o tipodocument_base64de exemplos anteriores não existe nem na documentação nem no SDKmistralai, e esses exemplos teriam falhado. Fontes: Processador OCR · Perguntas e Respostas sobre Documentos. Adenda de 3 de novembro: As anotações de imagem são lidas a partir deimage.image_annotation(SDKmistralai3.7.0), e não deimage.annotation.
Construir um sistema de documentos inteligente
A Geração Aumentada por Recuperação (RAG) é a técnica que torna consultáveis grandes corpora de documentos. Ao combinar o OCR da Mistral, embeddings e uma loja vetorial, cria um sistema capaz de responder a perguntas sobre os seus arquivos — dez anos de relatórios, um repositório de contratos ou uma biblioteca técnica digitalizada.
Por que utilizar OCR em vez de indexar os ficheiros tal como estão? Porque o desafio fundamental do RAG para documentos é que os fragmentos indexados devem ser texto. Os embeddings multimodais ainda não são suficientemente performantes para comparar diretamente perguntas em texto com imagens de documentos. O OCR serve de ponte: converte os seus documentos em texto estruturado de alta qualidade, que depois indexa na sua loja vetorial.
A arquitetura de cinco passos
Tudo começa pela ingestão, ou seja, a receção de documentos, quer cheguem como PDFs, imagens ou ficheiros DOCX. Segue-se o OCR com anotações, produzindo tanto texto como metadados estruturados. A fragmentação corta este texto em segmentos coerentes, o embedding vetoriza-os e armazena-os na loja vetorial, e a consulta fecha o ciclo: pesquisa semântica entre os vetores, seguida da geração da resposta. Cada passo condiciona o seguinte, e a extração determina todo o resto — se o OCR falhar, nenhuma pesquisa encontrará a informação.
As secções seguintes detalham o código para os quatro passos que escreverá; a ingestão depende do seu sistema de entrada específico.
Passo 1: Extração sem perdas
A chamada ao OCR aqui está configurada para RAG, o que é evidente em três escolhas. table_format="markdown" preserva as tabelas num formato que o LLM consegue ler. A anotação da caixa delimitadora descreve as imagens, e o código substitui subsequentemente cada referência  pela sua descrição textual: um gráfico de distribuição de receitas torna-se uma frase indexável em vez de uma lacuna no texto. Por fim, include_image_base64=False evita buscar megabytes de pixels de que o índice não precisa.
import os
import base64
from mistralai.client import Mistral
from mistralai.extra import response_format_from_pydantic_model
from pydantic import BaseModel, Field
from typing import Optional
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
class DescriptionImage(BaseModel):
type_image: str = Field(..., description="Type: graph, table, photo, logo")
description: str = Field(..., description="Content description")
def extraire_document_enrichi(chemin: str) -> list[dict]:
"""Extracts enriched content from a document for RAG."""
with open(chemin, "rb") as f:
doc_b64 = base64.b64encode(f.read()).decode("utf-8")
response = client.ocr.process(
model="mistral-ocr-latest",
document={
"type": "document_url",
"document_url": f"data:application/pdf;base64,{doc_b64}"
},
table_format="markdown",
bbox_annotation_format=response_format_from_pydantic_model(
DescriptionImage
),
include_image_base64=False # Images not needed for RAG
)
pages = []
for page in response.pages:
contenu = page.markdown
# Replace image references with their descriptions
for image in page.images:
if image.image_annotation:
desc = DescriptionImage.model_validate_json(
image.image_annotation
)
placeholder = f""
remplacement = (
f"[{desc.type_image}: {desc.description}]"
)
contenu = contenu.replace(placeholder, remplacement)
pages.append({
"page": page.index + 1,
"contenu": contenu,
"header": page.header or "",
"footer": page.footer or "",
})
return pages
Passo 2: Fragmentação onde o documento o permite
Dividir a cada mil caracteres corta frases a meio e separa um título do seu conteúdo. Como o OCR lhe fornece Markdown, aproveite a sua estrutura: a função segmenta primeiro pelos títulos de nível dois, mantém toda a secção apenas se couber no tamanho máximo e recorre aos parágrafos apenas quando há excesso. Cada fragmento mantém assim o seu título de secção, o que melhora significativamente a relevância da pesquisa semântica.
def chunker_par_sections(
texte: str,
taille_max: int = 1000,
chevauchement: int = 200
) -> list[str]:
"""Splits text respecting Markdown sections."""
sections = texte.split("\n## ")
chunks = []
for section in sections:
if not section.strip():
continue
# Reconstruct section heading
if not section.startswith("## "):
section = "## " + section
if len(section) <= taille_max:
chunks.append(section)
else:
# Sub-split by paragraphs
paragraphes = section.split("\n\n")
chunk_courant = ""
for para in paragraphes:
if len(chunk_courant) + len(para) > taille_max:
if chunk_courant:
chunks.append(chunk_courant.strip())
chunk_courant = para
else:
chunk_courant += "\n\n" + para
if chunk_courant:
chunks.append(chunk_courant.strip())
return chunks
Passo 3: Vetorizar e pesquisar
A indexação vetoriza cada fragmento com mistral-embed e armazena, juntamente com o vetor, o nome do documento e o ID do fragmento — sem estes metadados, pode responder mas não citar fontes. A pesquisa vetoriza a pergunta da mesma forma e calcula depois a similaridade do cosseno normalizada pelas normas de ambos os vetores, impedindo que um fragmento longo vença simplesmente por ser longo.
import numpy as np
def creer_index(documents: dict[str, list[dict]]) -> list[dict]:
"""Creates a vector index from extracted documents."""
index = []
for nom_doc, pages in documents.items():
# Concatenate all pages
texte_complet = "\n\n".join(p["contenu"] for p in pages)
# Chunking
chunks = chunker_par_sections(texte_complet)
for i, chunk in enumerate(chunks):
# Embedding
response = client.embeddings.create(
model="mistral-embed",
inputs=[chunk]
)
index.append({
"document": nom_doc,
"chunk_id": i,
"texte": chunk,
"embedding": np.array(response.data[0].embedding),
"page": pages[0]["page"] if pages else 0,
})
return index
def rechercher_chunks(
question: str,
index: list[dict],
top_k: int = 5
) -> list[dict]:
"""Searches for the most relevant chunks."""
response = client.embeddings.create(
model="mistral-embed",
inputs=[question]
)
q_emb = np.array(response.data[0].embedding)
scores = []
for item in index:
similarite = np.dot(q_emb, item["embedding"]) / (
np.linalg.norm(q_emb) * np.linalg.norm(item["embedding"])
)
scores.append((similarite, item))
scores.sort(key=lambda x: x[0], reverse=True)
return [item for _, item in scores[:top_k]]
Passo 4: Gerar uma resposta com fontes
A peça final reúne os cinco melhores fragmentos num contexto, cada um prefixado com o seu documento e número, e impõe uma instrução estrita ao modelo: responder apenas com base no contexto fornecido e citar as fontes. Este prompt de sistema distingue um assistente de documentos de um modelo que improvisa, e é por isso que preservou os metadados durante a indexação.
def repondre_question(question: str, index: list[dict]) -> str:
"""Answers a question using RAG."""
# Search for relevant chunks
resultats = rechercher_chunks(question, index, top_k=5)
# Build context
contexte = "\n\n---\n\n".join(
f"[Source: {r['document']}, Chunk {r['chunk_id']}]\n{r['texte']}"
for r in resultats
)
# Generate answer
response = client.chat.complete(
model="mistral-small-latest",
messages=[
{
"role": "system",
"content": (
"You are a document assistant. Answer "
"questions based solely on the provided "
"context. Cite sources."
)
},
{
"role": "user",
"content": (
f"Context:\n{contexte}\n\n"
f"Question: {question}"
)
}
]
)
return response.choices[0].message.content
Do protótipo à loja vetorial
Um índice em memória funciona enquanto se mantiver abaixo de alguns milhares de fragmentos. Para além disso, a pesquisa linear colapsa e nada sobrevive a um reinício: mude para uma loja vetorial real (Pinecone, Weaviate, Qdrant, ChromaDB). A mudança é pouco dispendiosa, como mostra esta variante com ChromaDB onde apenas o armazenamento e a consulta mudam — as suas funções de extração e fragmentação permanecem intactas.
# Example with ChromaDB
import chromadb
chroma_client = chromadb.Client()
collection = chroma_client.create_collection(name="documents")
# Indexing
for item in index:
collection.add(
ids=[f"{item['document']}_{item['chunk_id']}"],
embeddings=[item["embedding"].tolist()],
documents=[item["texte"]],
metadatas=[{"document": item["document"]}]
)
# Search
resultats = collection.query(
query_embeddings=[q_emb.tolist()],
n_results=5
)
Pontos-chave
- O pipeline OCR + RAG converte os seus documentos numa base de conhecimento consultável
- O enriquecimento via anotações (descrições de imagens) previne a perda de informação
- A fragmentação inteligente respeita as secções e parágrafos do documento
- Utilize uma loja vetorial real em produção (ChromaDB, Pinecone, Qdrant)
- A qualidade da extração por OCR determina a qualidade das respostas do RAG