Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Intégration OCR + RAG

15. lecke 16 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Construire un système documentaire intelligent
  2. L’architecture en cinq étapes
  3. Étape 1 : Une extraction sans perte
  4. Étape 2 : Un découpage respectueux du document
  5. Étape 3 : Vectoriser et rechercher
  6. Étape 4 : Générer une réponse sourcée
  7. Du prototype à la base vectorielle
  8. Főbb megállapítások

Mise à jour du 2 novembre 2026 — OCR. L’OCR 4.0 (mistral-ocr-4-0) a été retiré le 30 septembre 2026. Utilise l’OCR 4.1 (mistral-ocr-4-1), disponible généralement depuis le 31 août au même tarif, ou l’alias mistral-ocr-latest qui le cible depuis le 16 juillet. L’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 type document_base64 présent dans d’anciens exemples n’existe ni dans la documentation ni dans le SDK mistralai, et ces exemples auraient échoué. Sources : Processeur OCR · Q&R sur les documents. Addendum du 3 novembre : Les annotations d’image sont lues depuis image.image_annotation (SDK mistralai 3.7.0), et non image.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 de données 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 ![image](image) 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 aucun usage.

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"![{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

É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, ne conserve la section entière que 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 pièce finale 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. Cette invite 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."""
    # Rechercher les fragments pertinents
    resultats = rechercher_chunks(question, index, top_k=5)

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

    # Générer 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 les 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 de données 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
)

Főbb megállapítások

  • Le pipeline OCR + RAG convertit tes documents en une base de connaissances interrogeable
  • L’enrichissement via les annotations (descriptions d’images) empêche la perte d’informations
  • Un découpage intelligent respecte les sections et les 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