Integrazione OCR + RAG
In questa pagina
- Costruire un sistema documentale intelligente
- L’architettura in cinque passaggi
- Passaggio 1: Estrazione senza perdite
- Passaggio 2: Chunking rispettoso della struttura del documento
- Passaggio 3: Vettorializzazione e ricerca
- Passaggio 4: Generare una risposta con fonti
- Dal prototipo al vector store
- 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’aliasmistral-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 tipodocument_base64presente negli esempi più vecchi non esiste né nella documentazione né nell’SDKmistralai, e quegli esempi avrebbero fallito. Fonti: OCR Processor · Document QnA. Addendum 3 novembre: le annotazioni delle immagini si leggono daimage.image_annotation(SDKmistralai3.7.0), non daimage.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  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""
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