Vai al contenuto principale
Italiano— Scegli una lingua
Menu

QnA su più documenti

Lezione 14 di 16 Aggiornata il 3 novembre 2026 Sviluppatore
In questa pagina
  1. Quando la risposta si estende su più file
  2. Invia tutto in una singola chiamata
  3. Separare estrazione e interrogazione
  4. Passa al RAG documentale
  5. Un flusso di lavoro di confronto end-to-end
  6. Punti chiave

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’alias mistral-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 tipo document_base64 presente nei vecchi esempi non esiste né nella documentazione né nell’SDK mistralai, e quegli esempi avrebbero fallito. Fonti: OCR Processor · Document QnA. Corretto il 3 novembre 2026: il codice precedente leggeva page.document_annotation pagina per pagina; nell’SDK mistralai 3.7.0, l’annotazione del documento è un singolo campo nella risposta (response.document_annotation), mentre l’annotazione di un’immagine si legge da image.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