Produktionspipeline
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), 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-Verarbeiter · Dokument-Fragen und Antworten. Korrektur vom 3. November 2026: Der Code las zuvorpage.document_annotationSeite für Seite; immistralaiSDK 3.7.0 ist die Dokument-Anmerkung ein einzelnes Feld in der Antwort (response.document_annotation), und die Anmerkung eines Bildes wird ausimage.image_annotationgelesen.
Vom Prototyp zur Produktion
Sie haben gelernt, wie Sie OCR, Anmerkungen und Dokument-Fragen und Antworten (Document AI QnA) verwenden. Ein kostspieliger Lücken bleibt bestehen: der Abstand zwischen einem Skript, das auf Ihrem Laptop funktioniert, und einem Dienst, auf den Ihre Kollegen jeden Morgen angewiesen sind. Diese abschließende Lektion fasst die vorherigen Bausteine zu einer robusten Pipeline zusammen, einschließlich Fehlerwiederherstellung, Überwachung und Kostenkontrolle.
Die sechs Komponenten einer vollständigen Pipeline
- Eingangs-Warteschlange: Empfängt und priorisiert Dokumente.
- Vorverarbeitung: Validiert, konvertiert Formate und verbessert Bilder.
- OCR + Anmerkungen: Extrahiert Text und strukturierte Daten.
- Nachverarbeitung: Validiert, reinigt und bereichert Daten.
- Speicherung: Datenbanken, Vektorspeicher und Archivierung.
- Abfrage-Schnittstelle: QnA-API, Dashboards und Integrationen.
Der Code in dieser Lektion deckt den Kern der Kette ab – die Schritte 3 und 4 –, da sich dort die operativen Schwierigkeiten konzentrieren.
Eine Klasse, die die Verarbeitung kapselt
Die PipelineDocumentAI-Klasse setzt eine Konfiguration einmal und für alle fest – das Anmerkungs-Schema, das Tabellenformat und die Anzahl der Wiederholungsversuche – und wendet sie dann auf jedes Dokument an. Drei Mechanismen verdienen Ihre Aufmerksamkeit. Erstens, Wiederholung mit exponentiellem Backoff (time.sleep(2 ** tentative)) verteilt die Versuche um eine, dann zwei, dann vier Sekunden. Dies gibt transienten API-Sättigungen Zeit, sich aufzulösen, anstatt sie zu verschlimmern. Zweitens, Protokollierung verfolgt jeden Erfolg mit seiner Seitenanzahl und Dauer sowie jeden Misserfolg mit seiner Versuchsnummer; ohne diese Zeilen würden Sie Vorfälle nur entdecken, wenn die Buchhaltung anruft. Schließlich füttert das stats-Wörterbuch den Endbericht des Batches.
Beachten Sie, dass die Methode immer ein ResultatTraitement zurückgibt, auch nachdem alle Wiederholungsversuche erschöpft sind: Der Aufrufer muss niemals eine Ausnahme behandeln, er liest einfach das erreur-Feld.
import os
import time
import base64
import logging
from pathlib import Path
from dataclasses import dataclass, field
from mistralai.client import Mistral
from mistralai.extra import response_format_from_pydantic_model
from pydantic import BaseModel, Field
from typing import Optional
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("document_ai_pipeline")
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
@dataclass
class ResultatTraitement:
fichier: str
pages: int = 0
texte: str = ""
annotations: Optional[dict] = None
duree_secondes: float = 0.0
erreur: Optional[str] = None
class PipelineDocumentAI:
def __init__(
self,
schema_annotation=None,
table_format: str = "markdown",
max_retries: int = 3,
):
self.schema_annotation = schema_annotation
self.table_format = table_format
self.max_retries = max_retries
self.stats = {"total": 0, "succes": 0, "erreurs": 0}
def traiter_document(self, chemin: str) -> ResultatTraitement:
"""Verarbeitet ein Dokument mit Wiederholung und Überwachung."""
debut = time.time()
self.stats["total"] += 1
for tentative in range(self.max_retries):
try:
# Lesen und kodieren
with open(chemin, "rb") as f:
doc_b64 = base64.b64encode(f.read()).decode("utf-8")
# Aufrufparameter
params = {
"model": "mistral-ocr-latest",
"document": {
"type": "document_url",
"document_url": f"data:application/pdf;base64,{doc_b64}"
},
"table_format": self.table_format,
}
if self.schema_annotation:
params["document_annotation_format"] = (
response_format_from_pydantic_model(
self.schema_annotation
)
)
# OCR-Aufruf
response = client.ocr.process(**params)
# Text extrahieren
texte = "\n\n".join(
p.markdown for p in response.pages
)
# Anmerkungen extrahieren
annotations = None
if self.schema_annotation:
if response.document_annotation:
annotations = response.document_annotation
duree = time.time() - debut
self.stats["succes"] += 1
logger.info(
f"OK: {chemin} ({len(response.pages)} Seiten, "
f"{duree:.1f}s)"
)
return ResultatTraitement(
fichier=chemin,
pages=len(response.pages),
texte=texte,
annotations=annotations,
duree_secondes=duree,
)
except Exception as e:
logger.warning(
f"Tentative {tentative + 1}/{self.max_retries} "
f"échouée pour {chemin}: {e}"
)
if tentative < self.max_retries - 1:
time.sleep(2 ** tentative) # Exponentieller Backoff
# Alle Versuche fehlgeschlagen
self.stats["erreurs"] += 1
return ResultatTraitement(
fichier=chemin,
duree_secondes=time.time() - debut,
erreur="Échec après toutes les tentatives",
)
def traiter_dossier(self, dossier: str) -> list[ResultatTraitement]:
"""Verarbeitet alle PDFs in einem Ordner."""
chemin = Path(dossier)
fichiers = sorted(chemin.glob("*.pdf"))
resultats = []
for fichier in fichiers:
resultat = self.traiter_document(str(fichier))
resultats.append(resultat)
return resultats
def rapport(self) -> str:
"""Generiert einen Verarbeitungsbericht."""
return (
f"Dokumente verarbeitet : {self.stats['total']}\n"
f"Erfolge : {self.stats['succes']}\n"
f"Fehler : {self.stats['erreurs']}\n"
f"Erfolgsquote : "
f"{self.stats['succes']/max(self.stats['total'],1)*100:.1f}%"
)
In der Praxis deckt dieselbe Klasse beide Bedürfnisse ab: Instanziert ohne Schema extrahiert sie einfach Text; instanziert mit einem Pydantic-Modell erzeugt sie auch strukturierte Daten.
# Einfache Pipeline (nur OCR)
pipeline = PipelineDocumentAI(table_format="markdown")
resultats = pipeline.traiter_dossier("./factures/")
print(pipeline.rapport())
# Pipeline mit Anmerkungen
from pydantic import BaseModel, Field
class ExtractionFacture(BaseModel):
fournisseur: str = Field(..., description="Name des Lieferanten")
montant_ttc: float = Field(..., description="Betrag inkl. MwSt.")
date: str = Field(..., description="Datum (JJJJ-MM-TT)")
pipeline_annote = PipelineDocumentAI(
schema_annotation=ExtractionFacture,
table_format="markdown"
)
resultats = pipeline_annote.traiter_dossier("./factures/")
Die Rechnung im Voraus antizipieren
Kostenkontrolle ist in der Produktion unerlässlich und beginnt mit dem Verständnis dessen, wofür Sie abgerechnet werden.
| Element | Abrechnungsgrundlage |
|---|---|
| OCR | pro verarbeiteter Seite |
| Anmerkungen | im OCR-Aufruf enthalten (keine zusätzlichen Kosten) |
| QnA | Eingabe-/Ausgabe-Token basierend auf dem Chat-Modell |
| Embeddings | Eingabe-Token |
Die Tatsache, dass Anmerkungen keine zusätzlichen Kosten verursachen, ändert das Design: Metadaten während des OCR-Passes extrahieren, anstatt nachher einen separaten LLM-Aufruf auszuführen. Die untenstehende Schätzfunktion ermöglicht es Ihnen, ein Projekt zu preisen, bevor Sie es starten; ihre Raten sind Größenordnungsangaben zur Anpassung, wobei die veröffentlichte Referenztabelle von Mistral die Autorität bleibt.
def estimer_cout(
nombre_pages: int,
avec_qna: bool = False,
modele_qna: str = "mistral-small-latest"
) -> dict:
"""Schätzt die Verarbeitungskosten."""
# Näherungsweise Raten (aktuelle Raten prüfen)
cout_ocr_par_page = 0.001 # Basierend auf dem Tarif anpassen
cout_qna_par_1k_tokens = {
"mistral-small-latest": 0.001,
"mistral-large-latest": 0.008,
}
cout_ocr = nombre_pages * cout_ocr_par_page
cout_qna = 0.0
if avec_qna:
# Schätzung: ~500 Token pro Seite im Durchschnitt
tokens_estimes = nombre_pages * 500
cout_qna = (
tokens_estimes / 1000
* cout_qna_par_1k_tokens.get(modele_qna, 0.001)
)
return {
"cout_ocr": round(cout_ocr, 4),
"cout_qna": round(cout_qna, 4),
"cout_total": round(cout_ocr + cout_qna, 4),
}
Dienstgesundheit überwachen
Eine Pipeline verschlechtert sich langsam und stumm: ein neuer Anbieter sendet Scans schlechterer Qualität, die Fehlerrate steigt von 2 % auf 15 %, und niemand bemerkt es, bis die Monatsabrechnung fällig ist. Vier Kennzahlen reichen aus, um Drift zu erkennen – verarbeitetes Volumen, durchschnittliche Dauer, Fehlerrate und geschätzte Kosten –, sofern Sie sie systematisch emittieren und an Ihr übliches Tool senden, sei es Datadog, Prometheus oder ein anderes.
import json
from datetime import datetime
def log_metrique(nom: str, valeur: float, tags: dict = None) -> None:
"""Protokolliert eine Überwachungskennzahl."""
metrique = {
"timestamp": datetime.utcnow().isoformat(),
"nom": nom,
"valeur": valeur,
"tags": tags or {}
}
# In der Produktion: Senden an Datadog, Prometheus usw.
logger.info(f"METRIQUE: {json.dumps(metrique)}")
# Beispiel-Kennzahlen zur Verfolgung
log_metrique("ocr.pages_traitees", 150, {"batch": "factures_mars"})
log_metrique("ocr.duree_moyenne_secondes", 2.3)
log_metrique("ocr.taux_erreur", 0.02)
log_metrique("ocr.cout_estime_usd", 0.15)
Wohin geht es weiter
Sie haben nun die Grundlagen, um ein vollständiges Dokument-KI-System zu erstellen, und mehrere Erweiterungen stehen je nach Ihren Anforderungen offen. Sehr hohe Volumina rechtfertigen eine On-Premise-Deployment des OCR-Modells auf einer dedizierten GPU; hochspezifische Dokumente für Ihr Geschäft könnten Feinabstimmung (fine-tuning) motivieren, ein Thema, das Sie direkt mit Mistral ansprechen sollten. Auf der Integrationsseite besteht die Herausforderung darin, die Pipeline mit Ihren bestehenden Systemen – ERP, CRM – zu verbinden und ein Dashboard zu erstellen, damit Ihre Teams Dokumente selbst abfragen können, ohne Sie zu durchlaufen. Der letzte Schritt ist das Entfernen des manuellen Auslösens: Die Pipeline läuft automatisch, wenn neue Dokumente eintreffen.
Kurzfassung des Kurses
Diese sechzehn Lektionen haben Sie durch den gesamten Zyklus geführt. Sie haben mit den Grundlagen begonnen – was Dokument-KI ist, das OCR-4-Modell und Anwendungsfälle –, bevor Sie in fortgeschrittenes OCR über die API, Tabellenextraktion, Kopf-/Fußzeilen und Optimierung übergingen. Anmerkungen gaben Ihnen dann strukturierte Extraktion, Batch-Verarbeitung und Compliance-Kontrolle, gefolgt von Dokument-Fragen und Antworten, die natürliche Sprachabfragen eröffneten, von isolierten Dokumenten bis hin zu Korpora, die in RAG indiziert sind. Sie haben nun die notwendigen Bausteine, um das Dokumentenmanagement Ihrer Organisation mit Mistral Document AI auszustatten.
Wichtige Erkenntnisse
- Eine Produktionspipeline umfasst Wiederholung, Protokollierung, Überwachung und Kostenmanagement.
- Exponentieller Backoff schützt vor transienten API-Fehlern.
- Schätzen Sie Ihre Kosten, bevor Sie skalieren (OCR pro Seite, QnA pro Token).
- Kontinuierliche Überwachung ermöglicht es Ihnen, Leistungsverschlechterungen zu erkennen.
- Dokument-KI deckt den gesamten Dokumentenlebenszyklus ab, von der Ingestion bis zum Betrieb.
Wissen testen
OCR, Anmerkungen, QnA: Validieren Sie die vollständige Dokumentenkette.
1. Was erzeugt die OCR-API von Mistral aus einem Dokument?
Antwort: Den strukturierten Inhalt des Dokuments – Text, Tabellen, Layout – bereit für die programmatische Nutzung: OCR 4 liest das Dokument als Datenquelle, nicht als Bild.
2. Was ist der Zweck der Anmerkungs-API?
Antwort: Strukturierte Metadaten gemäß Ihrem Schema zu extrahieren (Rechnungsfelder, Vertragsklauseln) – entweder einzeln oder im Batch für hohe Volumina.
3. Was ermöglicht Dokument-Fragen und Antworten?
Antwort: Fragen in natürlicher Sprache über ein oder mehrere Dokumente zu stellen und Antworten basierend auf deren Inhalt zu erhalten – die konversationsschicht auf der Extraktion.
4. Wie optimieren Sie die OCR-Genauigkeit?
Antwort: Durch Eingabequalität (Auflösung, Schärfe, Orientierung) und den Umgang mit schwierigen Bereichen – Kopfzeilen, Fußzeilen, Paginierung –, die Sie im Kurs explizit verwalten lernen.
5. Warum OCR und RAG kombinieren?
Antwort: OCR verwandelt gescannte Dokumente in indexierbaren Text, während RAG sie im großen Maßstab abfragbar macht: Zusammen ermöglichen sie semantische Suche über gesamte Archive hinweg.
Extraktion, Anmerkung, Frage und Antwort, Indizierung: Die obenstehende Produktionspipeline verknüpft alle vier miteinander – Ihre Papierkram wird zu einer Datenbank.