Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Intégratie van OCR + RAG

Les 15 van 16 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. Een intelligent documentsysteem bouwen
  2. De architectuur in vijf stappen
  3. Stap 1: Extractie zonder verlies
  4. Stap 2: Chunking waar het document het toelaat
  5. Stap 3: Vectoriseren en zoeken
  6. Stap 4: Een onderbouwd antwoord genereren
  7. Van prototype naar vectoropslag
  8. Belangrijkste punten

Update 2 november 2026 — OCR. OCR 4.0 (mistral-ocr-4-0) is op 30 september 2026 buiten dienst gesteld. Gebruik OCR 4.1 (mistral-ocr-4-1), algemeen beschikbaar sinds 31 augustus tegen dezelfde prijs, of de alias mistral-ocr-latest, die er sinds 16 juli naar verwijst. OCR 4.1 voegt betrouwbaarheidsscores toe op blok-niveau. Addendum 3 november 2026: Een lokale PDF wordt in base64 verzonden als {"type": "document_url", "document_url": "data:application/pdf;base64,…"}; het type document_base64 uit oudere voorbeelden bestaat noch in de documentatie, noch in de mistralai SDK, en die voorbeelden zouden gefaald hebben. Bronnen: OCR Processor · Document QnA. Addendum 3 november: Image-annotaties worden gelezen vanuit image.image_annotation (SDK mistralai 3.7.0), niet image.annotation.

Een intelligent documentsysteem bouwen

Retrieval-Augmented Generation (RAG) is de techniek die grote documentencorpora doorzoekbaar maakt. Door Mistral’s OCR, embeddings en een vectoropslag te combineren, creëert u een systeem dat vragen over uw archieven kan beantwoorden—tien jaar aan rapporten, een contractenrepository of een gedigitaliseerde technische bibliotheek.

Waarom OCR gebruiken in plaats van bestanden ‘as-is’ te indexeren? Omdat de fundamentele uitdaging van document-RAG is dat geïndexeerde chunks tekst moeten zijn. Multimodale embeddings zijn nog niet performant genoeg om tekstvragen direct te vergelijken met documentafbeeldingen. OCR fungeert als brug: het zet uw documenten om in gestructureerde tekst van hoge kwaliteit, die u vervolgens indexeert in uw vectoropslag.

De architectuur in vijf stappen

Het begint allemaal met ingestie, oftewel het ontvangen van documenten, of ze nu als PDF’s, afbeeldingen of DOCX-bestanden binnenkomen. Daarna volgt OCR met annotaties, wat zowel tekst als gestructureerde metadata oplevert. Chunking snijdt deze tekst in coherente segmenten, embedding vectoriseert ze en slaat ze op in de vectoropslag, en de query sluit de cirkel: semantisch zoeken tussen de vectoren, gevolgd door het genereren van een antwoord. Elke stap bepaalt de volgende, en extractie bepaalt alles—als OCR het mist, zal geen enkele zoekopdracht het vinden.

De volgende secties detailleren de code voor de vier stappen die u zelf schrijft; ingestie hangt af van uw specifieke intake-systeem.

Stap 1: Extractie zonder verlies

De OCR-aanroep hier is geconfigureerd voor RAG, wat blijkt uit drie keuzes. table_format="markdown" behoudt tabellen in een formaat dat de LLM kan lezen. Bounding box-annotatie beschrijft afbeeldingen, en de code vervangt subsequently elke ![image](image)-referentie door de tekstbeschrijving: een grafiek met inkomstenverdeling wordt een indexeerbare zin in plaats van een gat in de tekst. Tot slot vermijdt include_image_base64=False het ophalen van megabytes aan pixels waar de index niets aan heeft.

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

Stap 2: Chunking waar het document het toelaat

Elke duizend karakters splitsen snijdt midden in een zin en scheidt een kop van de inhoud. Omdat OCR u Markdown geeft, maakt u gebruik van de structuur: de functie segmenteert eerst op koppen van niveau twee, behoudt de hele sectie alleen als deze binnen de maximale grootte past, en valt alleen terug op alinea’s als het overloopt. Elke chunk behoudt zo zijn sectiekop, wat de relevantie van semantisch zoeken aanzienlijk verbetert.

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

Stap 3: Vectoriseren en zoeken

Indexeren vectoriseert elke chunk met mistral-embed en slaat, naast de vector, de documentnaam en chunk-ID op—zonder deze metadata kunt u antwoorden maar geen bronnen citeren. Zoeken vectoriseert de vraag op dezelfde manier en berekent vervolgens de cosinus-overeenkomst genormaliseerd door de normen van beide vectoren, waardoor voorkomt wordt dat een lange chunk wint simpelweg omdat hij lang is.

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]]

Stap 4: Een onderbouwd antwoord genereren

Het laatste onderdeel voegt de top vijf chunks samen tot een context, elk voorafgegaan door het document en het nummer, en legt het model een strikte instructie op: antwoord alleen op basis van de verstrekte context en citeer bronnen. Deze systeemprompt onderscheidt een documentassistent van een model dat improviseert, en dit is waarom u metadata tijdens het indexeren heeft behouden.

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

Van prototype naar vectoropslag

Een index in het geheugen werkt zolang u onder de paar duizend chunks blijft. Daarboven stort lineair zoeken in en overleeft niets een herstart: schakel over naar een echte vectoropslag (Pinecone, Weaviate, Qdrant, ChromaDB). De overstap is goedkoop, zoals getoond in deze ChromaDB-variant waarbij alleen opslag en querying veranderen—uw extractie- en chunking-functies blijven intact.

# 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
)

Belangrijkste punten

  • De OCR + RAG-pipeline zet uw documenten om in een doorzoekbare kennisbank
  • Verrijking via annotaties (afbeeldingsbeschrijvingen) voorkomt informatieverlies
  • Intelligente chunking respecteert documentsecties en alinea’s
  • Gebruik in productie een echte vectoropslag (ChromaDB, Pinecone, Qdrant)
  • De kwaliteit van de OCR-extractie bepaalt de kwaliteit van de RAG-antwoorden