Integración de OCR + RAG
En esta página
Actualización 2 de noviembre de 2026 — OCR. OCR 4.0 (
mistral-ocr-4-0) se retiró el 30 de septiembre de 2026. Utiliza OCR 4.1 (mistral-ocr-4-1), disponible generalmente 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. Addendum 3 de noviembre de 2026: Un PDF local se transmite en base64 como{"type": "document_url", "document_url": "data:application/pdf;base64,…"}; el tipodocument_base64de ejemplos anteriores no existe ni en la documentación ni en el SDKmistralai, y esos ejemplos habrían fallado. Fuentes: Procesador OCR · Preguntas y respuestas sobre documentos. Addendum 3 de noviembre: Las anotaciones de imagen se leen desdeimage.image_annotation(SDKmistralai3.7.0), no desdeimage.annotation.
Construcción de un sistema documental inteligente
La Generación Aumentada por Recuperación (RAG) es la técnica que permite consultar grandes corpus documentales. Al combinar el OCR de Mistral, los embeddings y un almacén vectorial, creas un sistema capaz de responder preguntas sobre tus archivos: diez años de informes, un repositorio de contratos o una biblioteca técnica digitalizada.
¿Por qué usar OCR en lugar de indexar los archivos tal cual? Porque el desafío fundamental del RAG documental es que los fragmentos indexados deben ser texto. Los embeddings multimodales aún no son lo suficientemente eficaces para comparar directamente preguntas de texto con imágenes de documentos. El OCR actúa como puente: convierte tus documentos en texto estructurado de alta calidad, que luego indexas en tu almacén vectorial.
La arquitectura de cinco pasos
Todo comienza con la ingesta, es decir, la recepción de documentos, ya lleguen como PDF, imágenes o archivos DOCX. A continuación viene el OCR con anotaciones, que produce tanto texto como metadatos estructurados. El fragmentado (chunking) divide este texto en segmentos coherentes, la vectorización los convierte en vectores y los almacena en el almacén vectorial, y la consulta cierra el ciclo: búsqueda semántica entre los vectores, seguida de la generación de la respuesta. Cada paso condiciona al siguiente, y la extracción lo determina todo: si el OCR no lo captura, ninguna búsqueda lo encontrará.
Las siguientes secciones detallan el código para los cuatro pasos que escribirás tú mismo; la ingesta depende de tu sistema de entrada específico.
Paso 1: Extracción sin pérdidas
La llamada al OCR aquí está configurada para RAG, algo evidente en tres elecciones. table_format="markdown" conserva las tablas en un formato que el LLM puede leer. La anotación de cuadros delimitadores (bounding box) describe las imágenes, y el código sustituye posteriormente cada referencia  por su descripción textual: un gráfico de distribución de ingresos se convierte en una frase indexable en lugar de un hueco en el texto. Por último, include_image_base64=False evita cargar megabytes de píxeles que el índice no necesita.
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]:
"""Extrae contenido enriquecido de un documento para 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 # Imágenes no necesarias para RAG
)
pages = []
for page in response.pages:
contenu = page.markdown
# Sustituir referencias a imágenes por sus descripciones
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
Paso 2: Fragmentado donde el documento lo permita
Dividir cada mil caracteres corta frases a la mitad y separa un encabezado de su contenido. Dado que el OCR te proporciona Markdown, aprovecha su estructura: la función segmenta primero por encabezados de nivel dos, mantiene toda la sección solo si cabe dentro del tamaño máximo y recurre a los párrafos solo cuando se excede. Así, cada fragmento conserva su encabezado de sección, lo que mejora significativamente la relevancia de la búsqueda semántica.
def chunker_par_sections(
texte: str,
taille_max: int = 1000,
chevauchement: int = 200
) -> list[str]:
"""Divide el texto respetando las secciones Markdown."""
sections = texte.split("\n## ")
chunks = []
for section in sections:
if not section.strip():
continue
# Reconstruir el encabezado de la sección
if not section.startswith("## "):
section = "## " + section
if len(section) <= taille_max:
chunks.append(section)
else:
# Subdivisión por párrafos
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
Paso 3: Vectorizar y buscar
La indexación vectoriza cada fragmento con mistral-embed y almacena, junto al vector, el nombre del documento y el ID del fragmento; sin estos metadatos, puedes responder pero no citar fuentes. La búsqueda vectoriza la pregunta de la misma manera y luego calcula la similitud del coseno normalizada por las normas de ambos vectores, evitando que un fragmento largo gane simplemente por ser largo.
import numpy as np
def creer_index(documents: dict[str, list[dict]]) -> list[dict]:
"""Crea un índice vectorial a partir de documentos extraídos."""
index = []
for nom_doc, pages in documents.items():
# Concatenar todas las páginas
texte_complet = "\n\n".join(p["contenu"] for p in pages)
# Fragmentado
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]:
"""Busca los fragmentos más relevantes."""
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]]
Paso 4: Generar una respuesta con fuentes
La pieza final ensambla los cinco mejores fragmentos en un contexto, cada uno precedido por su documento y número, e impone una instrucción estricta al modelo: responder solo basándose en el contexto proporcionado y citar las fuentes. Este prompt de sistema distingue a un asistente documental de un modelo que improvisa, y es la razón por la que conservaste los metadatos durante la indexación.
def repondre_question(question: str, index: list[dict]) -> str:
"""Responde a una pregunta usando RAG."""
# Buscar fragmentos relevantes
resultats = rechercher_chunks(question, index, top_k=5)
# Construir contexto
contexte = "\n\n---\n\n".join(
f"[Source: {r['document']}, Chunk {r['chunk_id']}]\n{r['texte']}"
for r in resultats
)
# Generar respuesta
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
Del prototipo al almacén vectorial
Un índice en memoria funciona mientras te mantengas por debajo de unos pocos miles de fragmentos. Más allá de eso, la búsqueda lineal colapsa y nada sobrevive a un reinicio: cambia a un almacén vectorial real (Pinecone, Weaviate, Qdrant, ChromaDB). El cambio es económico, como se muestra en esta variante con ChromaDB donde solo cambian el almacenamiento y la consulta; tus funciones de extracción y fragmentado permanecen intactas.
# Ejemplo con ChromaDB
import chromadb
chroma_client = chromadb.Client()
collection = chroma_client.create_collection(name="documents")
# Indexación
for item in index:
collection.add(
ids=[f"{item['document']}_{item['chunk_id']}"],
embeddings=[item["embedding"].tolist()],
documents=[item["texte"]],
metadatas=[{"document": item["document"]}]
)
# Búsqueda
resultats = collection.query(
query_embeddings=[q_emb.tolist()],
n_results=5
)
Puntos clave
- La canalización OCR + RAG convierte tus documentos en una base de conocimientos consultable
- El enriquecimiento mediante anotaciones (descripciones de imágenes) evita la pérdida de información
- El fragmentado inteligente respeta las secciones y párrafos del documento
- Usa un almacén vectorial real en producción (ChromaDB, Pinecone, Qdrant)
- La calidad de la extracción OCR determina la calidad de las respuestas RAG