Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Integration von OCR und RAG

Lektion 15 von 16 Aktualisiert am 3. November 2026 Entwickler
Auf dieser Seite
  1. Aufbau eines intelligenten Dokumentsystems
  2. Die fünfstufige Architektur
  3. Schritt 1: Extraktion, die nichts verliert
  4. Schritt 2: Chunking, wo das Dokument es zulässt
  5. Schritt 3: Vektorisieren und Suche
  6. Schritt 4: Generierung einer zitierten Antwort
  7. Vom Prototypen zum Vektorspeicher
  8. Kernaussagen

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 Alias mistral-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 Typ document_base64 aus älteren Beispielen existiert weder in der Dokumentation noch im mistralai-SDK, und diese Beispiele wären fehlgeschlagen. Quellen: OCR-Verarbeiter · Dokumenten-Fragenbeantwortung. Ergänzung vom 3. November: Bildannotierungen werden aus image.image_annotation (SDK mistralai 3.7.0) gelesen, nicht aus image.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 ![image](image)-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"![{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

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.