Preguntas y respuestas con varios documentos
En esta página
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 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. Corregido el 3 de noviembre de 2026: El código leía anteriormentepage.document_annotationpágina por página; en el SDKmistralai3.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 desdeimage.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