Multi-Document QnA
Auf dieser Seite
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 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 als base64-Kodierung übermittelt:{"type": "document_url", "document_url": "data:application/pdf;base64,…"}; der Typdocument_base64aus älteren Beispielen existiert weder in der Dokumentation noch immistralaiSDK, und diese Beispiele wären fehlgeschlagen. Quellen: OCR Processor · Document QnA. Korrektur vom 3. November 2026: Der Code las zuvorpage.document_annotationSeite für Seite; immistralaiSDK 3.7.0 ist die Dokumentenannotation ein einzelnes Feld in der Antwort (response.document_annotation), und die Annotation eines Bildes wird ausimage.image_annotationgelesen.
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