Intégration OCR + RAG
Šajā lapā
Mise à jour du 2 novembre 2026 — OCR. OCR 4.0 (
mistral-ocr-4-0) a été retiré le 30 septembre 2026. Utilise OCR 4.1 (mistral-ocr-4-1), disponible généralement depuis le 31 août au même tarif, ou l’aliasmistral-ocr-latest, qui le cible depuis le 16 juillet. OCR 4.1 ajoute des scores de confiance au niveau des blocs. Addendum du 3 novembre 2026 : Un PDF local est transmis en base64 sous la forme{"type": "document_url", "document_url": "data:application/pdf;base64,…"}; le typedocument_base64présent dans d’anciens exemples n’existe ni dans la documentation ni dans le SDKmistralai, et ces exemples auraient échoué. Sources : OCR Processor · Document QnA. Addendum du 3 novembre : Les annotations d’image sont lues depuisimage.image_annotation(SDKmistralai3.7.0), et nonimage.annotation.
Construire un système documentaire intelligent
La génération augmentée par récupération (RAG) est la technique qui rend interrogeables de vastes corpus documentaires. En combinant l’OCR de Mistral, les embeddings et une base vectorielle, tu crées un système capable de répondre à des questions sur tes archives — dix ans de rapports, un référentiel de contrats ou une bibliothèque technique numérisée.
Pourquoi utiliser l’OCR plutôt que d’indexer les fichiers tels quels ? Parce que le défi fondamental du RAG documentaire est que les fragments indexés doivent être du texte. Les embeddings multimodaux ne sont pas encore assez performants pour comparer directement des questions textuelles avec des images de documents. L’OCR sert de pont : il convertit tes documents en texte structuré de haute qualité, que tu indexes ensuite dans ta base vectorielle.
L’architecture en cinq étapes
Tout commence par l’ingestion, c’est-à-dire la réception des documents, qu’ils arrivent en PDF, en images ou en fichiers DOCX. Vient ensuite l’OCR avec annotations, produisant à la fois du texte et des métadonnées structurées. Le découpage (chunking) divise ce texte en segments cohérents, l’embedding les vectorise et les stocke dans la base vectorielle, et la requête boucle la boucle : recherche sémantique parmi les vecteurs, suivie de la génération de la réponse. Chaque étape conditionne la suivante, et l’extraction détermine tout le reste : si l’OCR rate quelque chose, aucune recherche ne le trouvera.
Les sections suivantes détaillent le code des quatre étapes que tu écriras toi-même ; l’ingestion dépend de ton système de réception spécifique.
Étape 1 : Une extraction sans perte
L’appel OCR ici est configuré pour le RAG, ce qui se voit dans trois choix. table_format="markdown" conserve les tableaux dans un format lisible par le LLM. L’annotation par boîte englobante décrit les images, et le code remplace ensuite chaque référence  par sa description textuelle : un graphique de répartition des revenus devient une phrase indexable au lieu d’une lacune dans le texte. Enfin, include_image_base64=False évite de récupérer des mégaoctets de pixels dont l’index n’a que faire.
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]:
"""Extrait le contenu enrichi d'un document pour le 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 non nécessaires pour le RAG
)
pages = []
for page in response.pages:
contenu = page.markdown
# Remplacer les références d'image par leurs 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
Étape 2 : Un découpage respectueux du document
Découper tous les mille caractères coupe en plein milieu d’une phrase et sépare un titre de son contenu. Puisque l’OCR te fournit du Markdown, exploite sa structure : la fonction segmente d’abord sur les titres de niveau deux, conserve la section entière seulement si elle tient dans la taille maximale, et ne retombe sur les paragraphes qu’en cas de dépassement. Chaque fragment conserve ainsi son titre de section, ce qui améliore considérablement la pertinence de la recherche sémantique.
def chunker_par_sections(
texte: str,
taille_max: int = 1000,
chevauchement: int = 200
) -> list[str]:
"""Découpe le texte en respectant les sections Markdown."""
sections = texte.split("\n## ")
chunks = []
for section in sections:
if not section.strip():
continue
# Reconstruire le titre de section
if not section.startswith("## "):
section = "## " + section
if len(section) <= taille_max:
chunks.append(section)
else:
# Sous-découpage par paragraphes
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
Étape 3 : Vectoriser et rechercher
L’indexation vectorise chaque fragment avec mistral-embed et stocke, alongside le vecteur, le nom du document et l’ID du fragment — sans ces métadonnées, tu peux répondre mais pas citer tes sources. La recherche vectorise la question de la même manière, puis calcule la similarité cosinus normalisée par les normes des deux vecteurs, empêchant un long fragment de gagner simplement parce qu’il est long.
import numpy as np
def creer_index(documents: dict[str, list[dict]]) -> list[dict]:
"""Crée un index vectoriel à partir des documents extraits."""
index = []
for nom_doc, pages in documents.items():
# Concaténer toutes les pages
texte_complet = "\n\n".join(p["contenu"] for p in pages)
# Découpage
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]:
"""Recherche les fragments les plus pertinents."""
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]]
Étape 4 : Générer une réponse sourcée
La dernière pièce assemble les cinq meilleurs fragments dans un contexte, chacun préfixé par son document et son numéro, et impose une instruction stricte au modèle : répondre uniquement à partir du contexte fourni et citer les sources. Ce prompt système distingue un assistant documentaire d’un modèle qui improvise, et c’est pourquoi tu as conservé les métadonnées lors de l’indexation.
def repondre_question(question: str, index: list[dict]) -> str:
"""Répond à une question en utilisant le RAG."""
# Recherche des fragments pertinents
resultats = rechercher_chunks(question, index, top_k=5)
# Construction du contexte
contexte = "\n\n---\n\n".join(
f"[Source: {r['document']}, Fragment {r['chunk_id']}]\n{r['texte']}"
for r in resultats
)
# Génération de la réponse
response = client.chat.complete(
model="mistral-small-latest",
messages=[
{
"role": "system",
"content": (
"Tu es un assistant documentaire. Réponds "
"aux questions uniquement sur la base du "
"contexte fourni. Cite tes sources."
)
},
{
"role": "user",
"content": (
f"Contexte:\n{contexte}\n\n"
f"Question: {question}"
)
}
]
)
return response.choices[0].message.content
Du prototype à la base vectorielle
Un index en mémoire fonctionne tant que tu restes sous quelques milliers de fragments. Au-delà, la recherche linéaire s’effondre et rien ne survit à un redémarrage : passe à une véritable base vectorielle (Pinecone, Weaviate, Qdrant, ChromaDB). Le changement est peu coûteux, comme le montre cette variante ChromaDB où seul le stockage et la requête changent — tes fonctions d’extraction et de découpage restent intactes.
# Exemple avec ChromaDB
import chromadb
chroma_client = chromadb.Client()
collection = chroma_client.create_collection(name="documents")
# Indexation
for item in index:
collection.add(
ids=[f"{item['document']}_{item['chunk_id']}"],
embeddings=[item["embedding"].tolist()],
documents=[item["texte"]],
metadatas=[{"document": item["document"]}]
)
# Recherche
resultats = collection.query(
query_embeddings=[q_emb.tolist()],
n_results=5
)
Galvenās atziņas
- Le pipeline OCR + RAG convertit tes documents en une base de connaissances interrogeable
- L’enrichissement via les annotations (descriptions d’images) prévient la perte d’information
- Un découpage intelligent respecte les sections et paragraphes du document
- Utilise une véritable base vectorielle en production (ChromaDB, Pinecone, Qdrant)
- La qualité de l’extraction OCR détermine la qualité des réponses du RAG