Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Multi-Document QnA

Lektion 14 von 16 Aktualisiert am 3. November 2026 Entwickler
Auf dieser Seite
  1. Wenn die Antwort mehrere Dateien umfasst
  2. Alles in einem einzigen Aufruf senden
  3. Extraktion und Abfrage trennen
  4. Zum Dokument-RAG übergehen
  5. Ein End-to-End-Vergleichsprozess
  6. Kernaussagen

Aktualisiert am 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), der seit dem 31. August zum gleichen Preis allgemein verfügbar ist, 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 als base64-Kodierung übermittelt: {"type": "document_url", "document_url": "data:application/pdf;base64,…"}; der Typ document_base64 aus älteren Beispielen existiert weder in der Dokumentation noch im mistralai SDK, und diese Beispiele wären fehlgeschlagen. Quellen: OCR Processor · Document QnA. Korrektur vom 3. November 2026: Der Code las zuvor page.document_annotation Seite für Seite; im mistralai SDK 3.7.0 ist die Dokumentenannotation ein einzelnes Feld in der Antwort (response.document_annotation), und die Annotation eines Bildes wird aus image.image_annotation gelesen.

Wenn die Antwort mehrere Dateien umfasst

In vielen professionellen Szenarien findet die Antwort auf eine Frage nicht in einem einzigen Dokument. Sie müssen möglicherweise Verträge vergleichen, Rechnungen mit Bestellungen abgleichen oder eine Reihe von Berichten analysieren. Es gibt drei Strategien, und der beste Ansatz besteht darin, basierend auf dem Volumen zu wählen, anstatt sofort zur ausgefeiltesten Option zu greifen.

Alles in einem einzigen Aufruf senden

Die direkteste Methode besteht darin, mehrere document_url-Blöcke in derselben Nachricht zu stapeln. Das Modell sieht beide Verträge nebeneinander und kann sie tatsächlich vergleichen, was eine Seite-für-Seite-Verarbeitung nicht leisten kann. Wir wechseln hier zu mistral-large-latest, da ein Vergleich Reasoning erfordert und nicht nur das Lesen.

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": (
                        "Vergleichen Sie die Zahlungsbedingungen "
                        "dieser beiden Verträge."
                    )
                },
                {
                    "type": "document_url",
                    "document_url": "https://example.com/contract-A.pdf"
                },
                {
                    "type": "document_url",
                    "document_url": "https://example.com/contract-B.pdf"
                }
            ]
        }
    ]
)

print(response.choices[0].message.content)

Die Einschränkung zeigt sich schnell: Die Summe der Dokumente darf das Kontextfenster des Modells nicht überschreiten. Zwei zehnseitige Broschüren werden problemlos verarbeitet; zwei hundertseitige Rahmenverträge hingegen nicht.

Extraktion und Abfrage trennen

Für große Volumina ist die empfohlene Strategie, diese beiden Schritte zu entkoppeln. Sie führen jedes Dokument durch OCR, behalten das resultierende Markdown bei und konstruieren dann manuell den Kontext, der an das LLM gesendet wird. Der Vorteil liegt in der Kontrolle: Die Trunkierung auf 5.000 Zeichen, wie im Beispiel sichtbar, wobei jeder Dokumentname als Abschnittsüberschrift dient, sowie die Systemnachricht, die die Rolle eines Rechtsassistenten festlegt. Sie entscheiden genau, was in das Kontextfenster gelangt, anstatt dies automatisch passieren zu lassen.

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

def extract_text(url: str) -> str:
    """Extrahiert Text aus einem Dokument via OCR."""
    response = client.ocr.process(
        model="mistral-ocr-latest",
        document={"type": "document_url", "document_url": url}
    )
    return "\n\n".join(p.markdown for p in response.pages)


# OCR-Extraktion für jedes Dokument
documents = {
    "Vertrag A": extract_text("https://example.com/contract-A.pdf"),
    "Vertrag B": extract_text("https://example.com/contract-B.pdf"),
    "Vertrag C": extract_text("https://example.com/contract-C.pdf"),
}

# Aufbau des Prompts mit Kontext
context = "\n\n---\n\n".join(
    f"## {name}\n\n{text[:5000]}"  # Begrenzen, falls notwendig
    for name, text in documents.items()
)

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": (
                "Sie sind ein Rechtsassistent. Analysieren Sie "
                "die bereitgestellten Dokumente und beantworten Sie Fragen."
            )
        },
        {
            "role": "user",
            "content": (
                f"Hier sind die Dokumente:\n\n{context}\n\n"
                f"Frage: Welcher Vertrag bietet die besten "
                f"Bedingungen für eine vorzeitige Kündigung?"
            )
        }
    ]
)

Zum Dokument-RAG übergehen

Jenseits von einigen Dutzend Dokumenten reicht kein Kontextfenster aus. Sie müssen dann nur die relevanten Passagen senden, was das Aufteilen der Texte, das Vektorisieren mit mistral-embed und die Suche nach Ähnlichkeit zur Abfragezeit erfordert. Das Chunking mit einem Überlappungsbereich von 200 Zeichen verhindert, dass ein Satz in der Mitte abgeschnitten wird und zwischen den Chunks seine Bedeutung verliert, und top_k bestimmt, wie viele Passagen der Frage schließlich beiliegen.

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

def create_embeddings(text: str) -> list[float]:
    """Erstellt Embeddings für einen Text."""
    response = client.embeddings.create(
        model="mistral-embed",
        inputs=[text]
    )
    return response.data[0].embedding


def chunker(text: str, size: int = 1000, overlap: int = 200) -> list[str]:
    """Teilt Text in Chunks mit Überlappung auf."""
    chunks = []
    start = 0
    while start < len(text):
        end = start + size
        chunk = text[start:end]
        chunks.append(chunk)
        start = end - overlap
    return chunks


# Vereinfachtes RAG-Pipeline
def index_document(name: str, text: str) -> list[dict]:
    """Indexiert ein Dokument für die Suche."""
    chunks = chunker(text)
    index = []

    for i, chunk in enumerate(chunks):
        embedding = create_embeddings(chunk)
        index.append({
            "document": name,
            "chunk_id": i,
            "text": chunk,
            "embedding": embedding
        })

    return index


def search(query: str, index: list[dict], top_k: int = 5) -> list[dict]:
    """Sucht nach den relevantesten Chunks."""
    q_embedding = create_embeddings(query)

    # Berechnung der Kosinusähnlichkeit
    import numpy as np
    scores = []
    for item in index:
        score = np.dot(q_embedding, item["embedding"])
        scores.append((score, item))

    scores.sort(key=lambda x: x[0], reverse=True)
    return [item for _, item in scores[:top_k]]

Fassen wir die Auswahllogik zusammen. Das Senden mehrerer Dokumente in einem einzigen Aufruf bleibt für Einfachheit ungeschlagen und funktioniert gut für zwei oder drei kurze Dokumente. Die getrennte OCR gefolgt von QnA bietet Flexibilität und gibt Ihnen Kontrolle darüber, was an das LLM gesendet wird, auf Kosten etwas mehr Code. Dokument-RAG ist aufwändiger einzurichten, wird aber unerlässlich, wenn der Korpus wächst, da es der einzige Ansatz ist, der skaliert.

Ein End-to-End-Vergleichsprozess

Die beiden Techniken können kombiniert werden: Es schließt nichts aus, zunächst strukturierte Daten via Annotation zu extrahieren und diese Daten dann an das LLM zur Analyse weiterzugeben. Bei einer Serie von Rechnungen wird jedes Dokument auf drei Felder reduziert – Lieferant, Betrag, Datum – bevor eine einzige Anfrage das Modell auffordert, Trends und Anomalien zu identifizieren. Die Token-Kosten werden vernachlässigbar, und die Analyse konzentriert sich auf sauber extrahierte Zahlenwerte statt auf Text, der auf dem Laufenden interpretiert wird.

import os
from pydantic import BaseModel, Field
from mistralai.client import Mistral
from mistralai.extra import response_format_from_pydantic_model

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

class InvoiceSummary(BaseModel):
    vendor: str = Field(..., description="Name des Lieferanten")
    amount_inc_tax: float = Field(..., description="Betrag einschließlich Steuer")
    date: str = Field(..., description="Datum (JJJJ-MM-TT)")

def compare_invoices(paths: list[str]) -> str:
    """Vergleicht mehrere Rechnungen und gibt eine Analyse zurück."""
    import base64

    invoices = []
    for path in paths:
        with open(path, "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}"
            },
            document_annotation_format=response_format_from_pydantic_model(
                InvoiceSummary
            )
        )

        if response.document_annotation:
            invoice = InvoiceSummary.model_validate_json(
                response.document_annotation
            )
            invoices.append(invoice)

    # Vergleichsanalyse via LLM
    summary = "\n".join(
        f"- {f.vendor}: €{f.amount_inc_tax} ({f.date})"
        for f in invoices
    )

    response = client.chat.complete(
        model="mistral-small-latest",
        messages=[
            {
                "role": "user",
                "content": (
                    f"Hier sind {len(invoices)} Rechnungen:\n{summary}\n\n"
                    f"Analysieren Sie Trends und Anomalien."
                )
            }
        ]
    )

    return response.choices[0].message.content

Kernaussagen

  • Drei Ansätze für Multi-Document QnA: inline, separate OCR, RAG
  • Der inline-Ansatz funktioniert für 2–3 kurze Dokumente
  • Separate OCR + QnA bietet mehr Kontrolle über verbrauchte Tokens
  • RAG ist für große Korpora (Dutzende von Dokumenten) unerlässlich
  • Kombinieren Sie strukturierte Annotationen mit QnA für präzise Analysen