Intégratie van OCR + RAG
Op deze pagina
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 aliasmistral-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 typedocument_base64uit oudere voorbeelden bestaat noch in de documentatie, noch in demistralaiSDK, en die voorbeelden zouden gefaald hebben. Bronnen: OCR Processor · Document QnA. Addendum 3 november: Image-annotaties worden gelezen vanuitimage.image_annotation(SDKmistralai3.7.0), nietimage.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 -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""
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