QnA su più documenti
In questa pagina
Aggiornato il 2 novembre 2026 — OCR. OCR 4.0 (
mistral-ocr-4-0) è stato ritirato il 30 settembre 2026. Utilizza OCR 4.1 (mistral-ocr-4-1), disponibile in versione generale dal 31 agosto allo stesso prezzo, oppure l’aliasmistral-ocr-latest, che punta a questa versione dal 16 luglio. OCR 4.1 aggiunge punteggi di confidenza a livello di blocco. Addendum del 3 novembre 2026: un PDF locale viene trasmesso in base64 come{"type": "document_url", "document_url": "data:application/pdf;base64,…"}; il tipodocument_base64presente nei vecchi esempi non esiste né nella documentazione né nell’SDKmistralai, e quegli esempi avrebbero fallito. Fonti: OCR Processor · Document QnA. Corretto il 3 novembre 2026: il codice precedente leggevapage.document_annotationpagina per pagina; nell’SDKmistralai3.7.0, l’annotazione del documento è un singolo campo nella risposta (response.document_annotation), mentre l’annotazione di un’immagine si legge daimage.image_annotation.
Quando la risposta si estende su più file
In molti scenari professionali, la risposta a una domanda non si trova in un singolo documento. Potresti dover confrontare contratti, incrociare fatture con ordini di acquisto o analizzare una serie di report. Esistono tre strategie e l’approccio migliore consiste nello scegliere in base al volume, senza saltare immediatamente all’opzione più sofisticata.
Invia tutto in una singola chiamata
Il metodo più diretto consiste nell’impilare più blocchi document_url nello stesso messaggio. Il modello vede entrambi i contratti fianco a fianco e può confrontarli realmente, cosa che l’elaborazione pagina per pagina non permette di fare. Qui passiamo a mistral-large-latest perché il confronto implica ragionamento, non semplice lettura.
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": (
"Compare the payment terms "
"of these two contracts."
)
},
{
"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)
Il limite emerge rapidamente: la somma dei documenti non deve superare la finestra di contesto del modello. Due brochure di dieci pagine passano senza difficoltà; due accordi quadro di duecento pagine no.
Separare estrazione e interrogazione
Per grandi volumi, la strategia consigliata disaccoppia questi due passaggi. Passi ogni documento attraverso l’OCR, conservi il Markdown risultante e costruisci manualmente il contesto inviato all’LLM. Il vantaggio è il controllo: il troncamento a 5.000 caratteri visibile nell’esempio, il mantenimento del nome di ogni documento come intestazione di sezione e il messaggio di sistema che stabilisce il ruolo di assistente legale. Decidi esattamente cosa entra nella finestra di contesto invece di lasciarlo accadere automaticamente.
import os
from mistralai.client import Mistral
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
def extract_text(url: str) -> str:
"""Estrae il testo da un documento tramite 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)
# Estrazione OCR per ogni documento
documents = {
"Contract A": extract_text("https://example.com/contract-A.pdf"),
"Contract B": extract_text("https://example.com/contract-B.pdf"),
"Contract C": extract_text("https://example.com/contract-C.pdf"),
}
# Costruzione del prompt con il contesto
context = "\n\n---\n\n".join(
f"## {name}\n\n{text[:5000]}" # Limita se necessario
for name, text in documents.items()
)
response = client.chat.complete(
model="mistral-large-latest",
messages=[
{
"role": "system",
"content": (
"You are a legal assistant. Analyze the "
"provided documents and answer questions."
)
},
{
"role": "user",
"content": (
f"Here are the documents:\n\n{context}\n\n"
f"Question: Which contract offers the best "
f"early termination conditions?"
)
}
]
)
Passa al RAG documentale
Oltre qualche decina di documenti, nessuna finestra di contesto sarà sufficiente. Devi quindi inviare solo i passaggi rilevanti, il che richiede di suddividere i testi, vettorializzarli con mistral-embed e cercare per similarità al momento della query. La frammentazione con una sovrapposizione di 200 caratteri impedisce che una frase tagliata a metà perda il suo significato tra i chunk, mentre top_k determina quanti passaggi accompagneranno infine la domanda.
import os
from mistralai.client import Mistral
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
def create_embeddings(text: str) -> list[float]:
"""Crea embedding per un testo."""
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]:
"""Suddivide il testo in chunk con sovrapposizione."""
chunks = []
start = 0
while start < len(text):
end = start + size
chunk = text[start:end]
chunks.append(chunk)
start = end - overlap
return chunks
# Pipeline RAG semplificata
def index_document(name: str, text: str) -> list[dict]:
"""Indicizza un documento per la ricerca."""
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]:
"""Cerca i chunk più rilevanti."""
q_embedding = create_embeddings(query)
# Calcolo della similarità 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]]
Riassumiamo la logica di selezione. L’invio di più documenti in una singola chiamata rimane imbattibile per semplicità e funziona bene per due o tre documenti brevi. L’OCR separato seguito da QnA offre flessibilità e ti dà il controllo su ciò che viene inviato all’LLM, al costo di un po’ di codice aggiuntivo. Il RAG documentale è più pesante da configurare ma diventa essenziale man mano che il corpus cresce, perché è l’unico approccio scalabile.
Un flusso di lavoro di confronto end-to-end
Le due tecniche possono essere combinate: nulla ti impedisce di estrarre prima dati strutturati tramite annotazione, per poi passarli all’LLM per l’analisi. Su un lotto di fatture, ogni documento viene ridotto a tre campi—fornitore, importo, data—prima che una singola richiesta chieda al modello di identificare trend e anomalie. Il costo in token diventa trascurabile e l’analisi si concentra su cifre estratte correttamente piuttosto che su testo interpretato al volo.
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="Vendor name")
amount_inc_tax: float = Field(..., description="Amount including tax")
date: str = Field(..., description="Date (YYYY-MM-DD)")
def compare_invoices(paths: list[str]) -> str:
"""Confronta più fatture e restituisce un'analisi."""
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)
# Analisi comparativa tramite 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"Here are {len(invoices)} invoices:\n{summary}\n\n"
f"Analyze trends and anomalies."
)
}
]
)
return response.choices[0].message.content
Punti chiave
- Tre approcci per il QnA su più documenti: inline, OCR separato, RAG
- L’approccio inline funziona per 2–3 documenti brevi
- OCR separato + QnA offre maggiore controllo sui token consumati
- Il RAG è essenziale per grandi corpora (decine di documenti)
- Combina annotazioni strutturate con QnA per analisi precise