Integration von OCR und RAG
Auf dieser Seite
Update vom 2. November 2026 — OCR. OCR 4.0 (
mistral-ocr-4-0) wurde am 30. September 2026 eingestellt. Nutzen Sie OCR 4.1 (mistral-ocr-4-1), das seit dem 31. August allgemein verfügbar ist und zum gleichen Preis angeboten wird, oder den Aliasmistral-ocr-latest, der seit dem 16. Juli darauf verweist. OCR 4.1 fügt Vertrauenswerte auf Blockebene hinzu. Ergänzung vom 3. November 2026: Ein lokales PDF wird im Base64-Format als{"type": "document_url", "document_url": "data:application/pdf;base64,…"}übermittelt; der Typdocument_base64aus älteren Beispielen existiert weder in der Dokumentation noch immistralai-SDK, und diese Beispiele wären fehlgeschlagen. Quellen: OCR-Verarbeiter · Dokumenten-Fragenbeantwortung. Ergänzung vom 3. November: Bildannotierungen werden ausimage.image_annotation(SDKmistralai3.7.0) gelesen, nicht ausimage.annotation.
Aufbau eines intelligenten Dokumentsystems
Retrieval-Augmented Generation (RAG) ist die Technik, die große Dokumentenkorpora abfragbar macht. Durch die Kombination von Mistrals OCR, Embeddings und einem Vektorspeicher erstellen Sie ein System, das Fragen zu Ihren Archiven beantworten kann – zehn Jahre Berichte, ein Vertragsarchiv oder eine digitalisierte technische Bibliothek.
Warum nutzen Sie OCR anstatt Dateien unverändert zu indizieren? Weil die grundlegende Herausforderung von Dokumenten-RAG darin besteht, dass indizierte Segmente Text sein müssen. Multimodale Embeddings sind noch nicht leistungsfähig genug, um Textfragen direkt mit Dokumentenbildern zu vergleichen. OCR dient als Brücke: Es wandelt Ihre Dokumente in hochwertigen strukturierten Text um, den Sie dann in Ihrem Vektorspeicher indizieren.
Die fünfstufige Architektur
Alles beginnt mit der Ingestion, also der Aufnahme von Dokumenten, egal ob diese als PDFs, Bilder oder DOCX-Dateien eintreffen. Anschließend folgt die OCR mit Annotierungen, die sowohl Text als auch strukturierte Metadaten erzeugt. Das Chunking unterteilt diesen Text in kohärente Segmente, Embeddings vektorisieren diese und speichern sie im Vektorspeicher, und die Abfrage schließt den Kreis: semantische Suche unter den Vektoren, gefolgt von der Antwortgenerierung. Jeder Schritt bedingt den nächsten, und die Extraktion bestimmt alles Weitere – wenn die OCR etwas verpasst, wird keine Suche es finden.
Die folgenden Abschnitte erläutern den Code für die vier Schritte, die Sie selbst programmieren; die Ingestion hängt von Ihrem spezifischen Aufnahmesystem ab.
Schritt 1: Extraktion, die nichts verliert
Der OCR-Aufruf hier ist für RAG konfiguriert, was sich in drei Entscheidungen zeigt. table_format="markdown" bewahrt Tabellen in einem Format, das das LLM lesen kann. Die Begrenzungskasten-Annotierung beschreibt Bilder, und der Code ersetzt im Anschluss jeden -Verweis durch seine Textbeschreibung: ein Umsatzverteilungsdiagramm wird zu einem indizierbaren Satz statt zu einer Lücke im Text. Schließlich verhindert include_image_base64=False, dass Megabytes an Pixeln abgerufen werden, die der Index nicht benötigt.
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]:
"""Extrahiert angereicherten Inhalt aus einem Dokument für 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 # Bilder nicht für RAG benötigt
)
pages = []
for page in response.pages:
contenu = page.markdown
# Ersetzt Bildverweise durch deren Beschreibungen
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
Schritt 2: Chunking, wo das Dokument es zulässt
Das Aufteilen aller tausend Zeichen trennt mitten im Satz und löst eine Überschrift von ihrem Inhalt. Da Ihnen OCR Markdown liefert, nutzen Sie dessen Struktur: Die Funktion segmentiert zunächst auf Überschriften der zweiten Ebene, behält den gesamten Abschnitt nur bei, wenn er innerhalb der maximalen Größe passt, und greift auf Absätze zurück, wenn er überläuft. Jedes Chunk behält somit seine Abschnittsüberschrift bei, was die Relevanz der semantischen Suche erheblich verbessert.
def chunker_par_sections(
texte: str,
taille_max: int = 1000,
chevauchement: int = 200
) -> list[str]:
"""Teilt Text unter Beachtung von Markdown-Sektionen auf."""
sections = texte.split("\n## ")
chunks = []
for section in sections:
if not section.strip():
continue
# Rekonstruiert Abschnittsüberschrift
if not section.startswith("## "):
section = "## " + section
if len(section) <= taille_max:
chunks.append(section)
else:
# Unterteilung nach Absätzen
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
Schritt 3: Vektorisieren und Suche
Das Indizieren vektorisiert jedes Chunk mit mistral-embed und speichert es zusammen mit dem Vektor, den Dokumentennamen und der Chunk-ID – ohne diese Metadaten können Sie zwar antworten, aber keine Quellen zitieren. Die Suche vektorisiert die Frage auf dieselbe Weise und berechnet dann die Kosinusähnlichkeit, normiert durch die Normen beider Vektoren, wodurch verhindert wird, dass ein langes Chunk allein wegen seiner Länge gewinnt.
import numpy as np
def creer_index(documents: dict[str, list[dict]]) -> list[dict]:
"""Erstellt einen Vektorindex aus extrahierten Dokumenten."""
index = []
for nom_doc, pages in documents.items():
# Alle Seiten zusammenfügen
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]:
"""Sucht nach den relevantesten 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]]
Schritt 4: Generierung einer zitierten Antwort
Das letzte Puzzleteil fasst die Top-Fünf-Chunks zu einem Kontext zusammen, wobei jeder mit seinem Dokument und seiner Nummer versehen ist, und verhängt eine strikte Anweisung für das Modell: Beantworten Sie ausschließlich auf Grundlage des bereitgestellten Kontexts und zitieren Sie Quellen. Dieser Systemprompt unterscheidet einen Dokumenten-Assistenten von einem Modell, das improvisiert, und genau darum haben Sie die Metadaten während des Indizierens erhalten.
def repondre_question(question: str, index: list[dict]) -> str:
"""Beantwortet eine Frage unter Verwendung von RAG."""
# Suche nach relevanten Chunks
resultats = rechercher_chunks(question, index, top_k=5)
# Aufbau des Kontexts
contexte = "\n\n---\n\n".join(
f"[Quelle: {r['document']}, Chunk {r['chunk_id']}]\n{r['texte']}"
for r in resultats
)
# Generierung der Antwort
response = client.chat.complete(
model="mistral-small-latest",
messages=[
{
"role": "system",
"content": (
"Sie sind ein Dokumenten-Assistent. Beantworten Sie "
"Fragen ausschließlich auf Grundlage des bereitgestellten "
"Kontexts. Zitieren Sie Quellen."
)
},
{
"role": "user",
"content": (
f"Kontext:\n{contexte}\n\n"
f"Frage: {question}"
)
}
]
)
return response.choices[0].message.content
Vom Prototypen zum Vektorspeicher
Ein Index im Arbeitsspeicher funktioniert, solange Sie unter einigen tausend Chunks bleiben. Darüber hinaus bricht die lineare Suche zusammen und nichts überlebt einen Neustart: Wechseln Sie zu einem echten Vektorspeicher (Pinecone, Weaviate, Qdrant, ChromaDB). Der Wechsel ist kostengünstig, wie diese ChromaDB-Variante zeigt, bei der nur die Speicherung und Abfrage geändert werden – Ihre Extraktions- und Chunking-Funktionen bleiben intakt.
# Beispiel mit ChromaDB
import chromadb
chroma_client = chromadb.Client()
collection = chroma_client.create_collection(name="documents")
# Indizierung
for item in index:
collection.add(
ids=[f"{item['document']}_{item['chunk_id']}"],
embeddings=[item["embedding"].tolist()],
documents=[item["texte"]],
metadatas=[{"document": item["document"]}]
)
# Suche
resultats = collection.query(
query_embeddings=[q_emb.tolist()],
n_results=5
)
Kernaussagen
- Die OCR- und RAG-Pipeline wandelt Ihre Dokumente in eine abfragbare Wissensbasis um.
- Anreicherung durch Annotierungen (Bildbeschreibungen) verhindert Informationsverlust.
- Intelligentes Chunking respektiert Dokumentensektionen und Absätze.
- Nutzen Sie in der Produktion einen echten Vektorspeicher (ChromaDB, Pinecone, Qdrant).
- Die Qualität der OCR-Extraktion bestimmt die Qualität der RAG-Antworten.