Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Integrazione OCR + RAG

Lezione 15 di 16 Aggiornata il 3 novembre 2026 Sviluppatore
In questa pagina
  1. Costruire un sistema documentale intelligente
  2. L’architettura in cinque passaggi
  3. Passaggio 1: Estrazione senza perdite
  4. Passaggio 2: Chunking rispettoso della struttura del documento
  5. Passaggio 3: Vettorializzazione e ricerca
  6. Passaggio 4: Generare una risposta con fonti
  7. Dal prototipo al vector store
  8. Punti chiave

Aggiornamento 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), generalmente disponibile dal 31 agosto allo stesso prezzo, oppure l’alias mistral-ocr-latest, che punta ad esso dal 16 luglio. OCR 4.1 aggiunge punteggi di confidenza a livello di blocco. Addendum 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 negli esempi più vecchi non esiste né nella documentazione né nell’SDK mistralai, e quegli esempi avrebbero fallito. Fonti: OCR Processor · Document QnA. Addendum 3 novembre: le annotazioni delle immagini si leggono da image.image_annotation (SDK mistralai 3.7.0), non da image.annotation.

Costruire un sistema documentale intelligente

La Generazione Aumentata dal Recupero (RAG) è la tecnica che rende interrogabili grandi corpora documentali. Combinando l’OCR di Mistral, gli embedding e un vector store, crei un sistema capace di rispondere a domande sui tuoi archivi: dieci anni di report, un repository di contratti o una biblioteca tecnica digitalizzata.

Perché usare l’OCR invece di indicizzare i file così come sono? Perché la sfida fondamentale del RAG documentale è che i chunk indicizzati devono essere testo. Gli embedding multimodali non sono ancora abbastanza performanti per confrontare direttamente domande testuali con immagini di documenti. L’OCR funge da ponte: converte i tuoi documenti in testo strutturato di alta qualità, che poi indici nel tuo vector store.

L’architettura in cinque passaggi

Tutto inizia con l’ingestione, ovvero la ricezione dei documenti, che arrivino come PDF, immagini o file DOCX. Segue l’OCR con annotazioni, che produce sia testo che metadati strutturati. Il chunking taglia questo testo in segmenti coerenti, l’embedding li vettorializza e li memorizza nel vector store, e la query chiude il ciclo: ricerca semantica tra i vettori, seguita dalla generazione della risposta. Ogni passo condiziona il successivo e l’estrazione determina tutto il resto: se l’OCR manca qualcosa, nessuna ricerca potrà trovarlo.

Le sezioni seguenti dettagliano il codice per i quattro passaggi che scriverai tu; l’ingestione dipende dal tuo specifico sistema di acquisizione.

Passaggio 1: Estrazione senza perdite

La chiamata OCR qui è configurata per il RAG, come evidenziano tre scelte. table_format="markdown" preserva le tabelle in un formato leggibile dall’LLM. L’annotazione con bounding box descrive le immagini e il codice sostituisce successivamente ogni riferimento ![image](image) con la sua descrizione testuale: un grafico di distribuzione dei ricavi diventa una frase indicizzabile invece di un vuoto nel testo. Infine, include_image_base64=False evita di recuperare megabyte di pixel di cui l’indice non ha bisogno.

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]:
    """Extracts enriched content from a document for 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  # Images not needed for RAG
    )

    pages = []
    for page in response.pages:
        contenu = page.markdown

        # Replace image references with their descriptions
        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

Passaggio 2: Chunking rispettoso della struttura del documento

Dividere ogni mille caratteri taglia le frasi a metà e separa un titolo dal suo contenuto. Dato che l’OCR ti fornisce Markdown, sfruttane la struttura: la funzione segmenta prima sui titoli di livello due, mantiene l’intera sezione solo se rientra nella dimensione massima e ricorre ai paragrafi solo in caso di overflow. Ogni chunk mantiene così il titolo della sua sezione, migliorando significativamente la rilevanza della ricerca semantica.

def chunker_par_sections(
    texte: str,
    taille_max: int = 1000,
    chevauchement: int = 200
) -> list[str]:
    """Splits text respecting Markdown sections."""
    sections = texte.split("\n## ")
    chunks = []

    for section in sections:
        if not section.strip():
            continue

        # Reconstruct section heading
        if not section.startswith("## "):
            section = "## " + section

        if len(section) <= taille_max:
            chunks.append(section)
        else:
            # Sub-split by paragraphs
            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

Passaggio 3: Vettorializzazione e ricerca

L’indicizzazione vettorializza ogni chunk con mistral-embed e memorizza, insieme al vettore, il nome del documento e l’ID del chunk: senza questi metadati, puoi rispondere ma non citare le fonti. La ricerca vettorializza la domanda nello stesso modo, quindi calcola la similarità del coseno normalizzata per le norme di entrambi i vettori, impedendo a un chunk lungo di vincere semplicemente perché è lungo.

import numpy as np

def creer_index(documents: dict[str, list[dict]]) -> list[dict]:
    """Creates a vector index from extracted documents."""
    index = []

    for nom_doc, pages in documents.items():
        # Concatenate all pages
        texte_complet = "\n\n".join(p["contenu"] for p in pages)

        # Chunking
        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]:
    """Searches for the most relevant chunks."""
    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]]

Passaggio 4: Generare una risposta con fonti

Il pezzo finale assembla i primi cinque chunk in un contesto, ciascuno prefissato con il suo documento e numero, e impone un’istruzione rigorosa al modello: rispondere solo basandosi sul contesto fornito e citare le fonti. Questo prompt di sistema distingue un assistente documentale da un modello che improvvisa, ed è il motivo per cui hai preservato i metadati durante l’indicizzazione.

def repondre_question(question: str, index: list[dict]) -> str:
    """Answers a question using RAG."""
    # Search for relevant chunks
    resultats = rechercher_chunks(question, index, top_k=5)

    # Build context
    contexte = "\n\n---\n\n".join(
        f"[Source: {r['document']}, Chunk {r['chunk_id']}]\n{r['texte']}"
        for r in resultats
    )

    # Generate answer
    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

Dal prototipo al vector store

Un indice in memoria funziona finché resti sotto poche migliaia di chunk. Oltre quella soglia, la ricerca lineare collassa e nulla sopravvive a un riavvio: passa a un vero vector store (Pinecone, Weaviate, Qdrant, ChromaDB). Il passaggio è poco costoso, come mostrato in questa variante ChromaDB dove cambiano solo storage e query: le tue funzioni di estrazione e chunking restano intatte.

# Example with ChromaDB
import chromadb

chroma_client = chromadb.Client()
collection = chroma_client.create_collection(name="documents")

# Indexing
for item in index:
    collection.add(
        ids=[f"{item['document']}_{item['chunk_id']}"],
        embeddings=[item["embedding"].tolist()],
        documents=[item["texte"]],
        metadatas=[{"document": item["document"]}]
    )

# Search
resultats = collection.query(
    query_embeddings=[q_emb.tolist()],
    n_results=5
)

Punti chiave

  • La pipeline OCR + RAG converte i tuoi documenti in una base di conoscenza interrogabile
  • L’arricchimento tramite annotazioni (descrizioni immagini) previene la perdita di informazioni
  • Il chunking intelligente rispetta le sezioni e i paragrafi del documento
  • Usa un vero vector store in produzione (ChromaDB, Pinecone, Qdrant)
  • La qualità dell’estrazione OCR determina la qualità delle risposte RAG