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

Preguntas y respuestas con varios documentos

Lección 14 de 16 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. Cuando la respuesta abarca varios archivos
  2. Enviar todo en una única llamada
  3. Extracción separada de la consulta
  4. Pasar a RAG de documentos
  5. Un flujo de trabajo de comparación de extremo a extremo
  6. Puntos clave

Actualizado el 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 en general 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. Corregido el 3 de noviembre de 2026: El código leía anteriormente page.document_annotation página por página; en el SDK mistralai 3.7.0, la anotación del documento es un único campo en la respuesta (response.document_annotation), y la anotación de una imagen se lee desde image.image_annotation.

Cuando la respuesta abarca varios archivos

En muchos escenarios profesionales, la respuesta a una pregunta no se encuentra en un único documento. Es posible que necesites comparar contratos, cruzar facturas con órdenes de compra o analizar una serie de informes. Existen tres estrategias, y el mejor enfoque consiste en elegir en función del volumen en lugar de saltar inmediatamente a la opción más sofisticada.

Enviar todo en una única llamada

El método más directo consiste en apilar varios bloques document_url en el mismo mensaje. El modelo ve ambos contratos uno al lado del otro y puede compararlos genuinamente, algo que el procesamiento página por página no puede lograr. Aquí cambiamos a mistral-large-latest porque la comparación implica razonamiento, no solo lectura.

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": (
                        "Compara las condiciones de pago "
                        "de estos dos contratos."
                    )
                },
                {
                    "type": "document_url",
                    "document_url": "https://example.com/contract-A.pdf"
                },
                {
                    "type": "document_url",
                    "document_url": "https://example.com/contract-B.pdf"
                }
            ]
        }
    ]
)

print(response.choices[0].message.content)

La limitación aparece rápidamente: la suma de los documentos no debe superar la ventana de contexto del modelo. Dos folletos de diez páginas pasan sin dificultad; dos acuerdos marco de doscientas páginas, no.

Extracción separada de la consulta

Para grandes volúmenes, la estrategia recomendada desacopla estos dos pasos. Pasas cada documento por OCR, conservas el Markdown resultante y luego construyes manualmente el contexto que se envía al LLM. La ventaja es el control: el truncamiento a 5.000 caracteres visible en el ejemplo, mantener el nombre de cada documento como encabezado de sección y el mensaje de sistema que establece el rol de asistente legal. Tú decides exactamente qué entra en la ventana de contexto en lugar de dejar que ocurra automáticamente.

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

def extract_text(url: str) -> str:
    """Extrae texto de un documento mediante OCR."""
    response = client.ocr.process(
        model="mistral-ocr-latest",
        document={"type": "document_url", "document_url": url}
    )
    return "\n\n".join(p.markdown for p in response.pages)


# Extracción OCR para cada documento
documents = {
    "Contrato A": extract_text("https://example.com/contract-A.pdf"),
    "Contrato B": extract_text("https://example.com/contract-B.pdf"),
    "Contrato C": extract_text("https://example.com/contract-C.pdf"),
}

# Construir el prompt con contexto
context = "\n\n---\n\n".join(
    f"## {name}\n\n{text[:5000]}"  # Limitar si es necesario
    for name, text in documents.items()
)

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": (
                "Eres un asistente legal. Analiza los "
                "documentos proporcionados y responde a las preguntas."
            )
        },
        {
            "role": "user",
            "content": (
                f"Aquí tienes los documentos:\n\n{context}\n\n"
                f"Pregunta: ¿Qué contrato ofrece las mejores "
                f"condiciones de terminación anticipada?"
            )
        }
    ]
)

Pasar a RAG de documentos

Más allá de unas pocas docenas de documentos, ninguna ventana de contexto será suficiente. Debes enviar entonces solo los pasajes relevantes, lo que requiere dividir los textos, vectorizarlos con mistral-embed y buscar por similitud en el momento de la consulta. La fragmentación con una superposición de 200 caracteres evita que una frase cortada por la mitad pierda su significado entre fragmentos, y top_k determina cuántos pasajes acompañarán finalmente a la pregunta.

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

def create_embeddings(text: str) -> list[float]:
    """Crea incrustaciones (embeddings) para un texto."""
    response = client.embeddings.create(
        model="mistral-embed",
        inputs=[text]
    )
    return response.data[0].embedding


def chunker(text: str, size: int = 1000, overlap: int = 200) -> list[str]:
    """Divide el texto en fragmentos con superposición."""
    chunks = []
    start = 0
    while start < len(text):
        end = start + size
        chunk = text[start:end]
        chunks.append(chunk)
        start = end - overlap
    return chunks


# Pipeline RAG simplificado
def index_document(name: str, text: str) -> list[dict]:
    """Indexa un documento para su búsqueda."""
    chunks = chunker(text)
    index = []

    for i, chunk in enumerate(chunks):
        embedding = create_embeddings(chunk)
        index.append({
            "document": name,
            "chunk_id": i,
            "text": chunk,
            "embedding": embedding
        })

    return index


def search(query: str, index: list[dict], top_k: int = 5) -> list[dict]:
    """Busca los fragmentos más relevantes."""
    q_embedding = create_embeddings(query)

    # Cálculo de similitud del coseno
    import numpy as np
    scores = []
    for item in index:
        score = np.dot(q_embedding, item["embedding"])
        scores.append((score, item))

    scores.sort(key=lambda x: x[0], reverse=True)
    return [item for _, item in scores[:top_k]]

Resumamos la lógica de selección. Enviar varios documentos en una única llamada sigue siendo insuperable por su simplicidad y funciona bien para dos o tres documentos breves. El OCR separado seguido de preguntas y respuestas ofrece flexibilidad y te da control sobre lo que se envía al LLM, a costa de un poco de código adicional. El RAG de documentos es más pesado de configurar, pero se vuelve esencial a medida que crece el corpus, porque es el único enfoque que escala.

Un flujo de trabajo de comparación de extremo a extremo

Las dos técnicas pueden combinarse: nada impide extraer primero datos estructurados mediante anotación y luego pasar esos datos al LLM para su análisis. En un lote de facturas, cada documento se reduce a tres campos —proveedor, importe, fecha— antes de que una única solicitud pida al modelo que identifique tendencias y anomalías. El coste en tokens se vuelve insignificante y el análisis se centra en cifras extraídas limpiamente en lugar de en texto interpretado sobre la marcha.

import os
from pydantic import BaseModel, Field
from mistralai.client import Mistral
from mistralai.extra import response_format_from_pydantic_model

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

class InvoiceSummary(BaseModel):
    vendor: str = Field(..., description="Nombre del proveedor")
    amount_inc_tax: float = Field(..., description="Importe con impuestos incluidos")
    date: str = Field(..., description="Fecha (AAAA-MM-DD)")

def compare_invoices(paths: list[str]) -> str:
    """Compara varias facturas y devuelve un análisis."""
    import base64

    invoices = []
    for path in paths:
        with open(path, "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}"
            },
            document_annotation_format=response_format_from_pydantic_model(
                InvoiceSummary
            )
        )

        if response.document_annotation:
            invoice = InvoiceSummary.model_validate_json(
                response.document_annotation
            )
            invoices.append(invoice)

    # Análisis comparativo mediante LLM
    summary = "\n".join(
        f"- {f.vendor}: {f.amount_inc_tax} € ({f.date})"
        for f in invoices
    )

    response = client.chat.complete(
        model="mistral-small-latest",
        messages=[
            {
                "role": "user",
                "content": (
                    f"Aquí tienes {len(invoices)} facturas:\n{summary}\n\n"
                    f"Analiza tendencias y anomalías."
                )
            }
        ]
    )

    return response.choices[0].message.content

Puntos clave

  • Tres enfoques para preguntas y respuestas con varios documentos: en línea, OCR separado, RAG
  • El enfoque en línea funciona para 2–3 documentos breves
  • OCR separado + preguntas y respuestas ofrece más control sobre los tokens consumidos
  • RAG es esencial para corpus grandes (decenas de documentos)
  • Combina anotaciones estructuradas con preguntas y respuestas para análisis precisos