Ir al contenido principal
Español— Elegir un idioma
Menú

Integración de OCR + RAG

Lección 15 de 16 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. Construcción de un sistema documental inteligente
  2. La arquitectura de cinco pasos
  3. Paso 1: Extracción sin pérdidas
  4. Paso 2: Fragmentado donde el documento lo permita
  5. Paso 3: Vectorizar y buscar
  6. Paso 4: Generar una respuesta con fuentes
  7. Del prototipo al almacén vectorial
  8. Puntos clave

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 alias mistral-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 tipo document_base64 de ejemplos anteriores no existe ni en la documentación ni en el SDK mistralai, y esos ejemplos habrían fallado. Fuentes: Procesador OCR · Preguntas y respuestas sobre documentos. Addendum 3 de noviembre: Las anotaciones de imagen se leen desde image.image_annotation (SDK mistralai 3.7.0), no desde image.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 ![image](image) 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"![{image.id}]({image.id})"
                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