Batch-Annotationen
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), das seit dem 31. August allgemein verfügbar ist und denselben Preis hat, 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 in der Form{"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 · Dokumenten-Fragen und Antworten. Korrektur vom 3. November 2026: Der Code las zuvorpage.document_annotationSeite für Seite; im SDKmistralai3.7.0 ist die Dokumentenannotation ein einzelnes Feld in der Antwort (response.document_annotation), und die Bildannotation wird ausimage.image_annotationgelesen.
Skalierung nach oben
Die Verarbeitung eines Dokuments nach dem anderen eignet sich für Prototypen. In der Produktion sieht die Realität anders aus: Eine Buchhaltungsebene erhält täglich hunderte Rechnungen, und eine Anwaltskanzlei digitalisiert während der Due Diligence tausende Dokumente. Der Code muss sich entsprechend ändern – es geht nicht mehr nur darum, eine Antwort zu erhalten, sondern sicherzustellen, dass kein Dokument verloren geht, und genau zu wissen, welche fehlgeschlagen sind.
Mit sequentieller Verarbeitung beginnen
Halten Sie es zunächst einfach. Der folgende Durchlauf iteriert durch einen Ordner mit PDFs, kodiert jede Datei in base64, sendet sie an den OCR-Engine mit dem Annotationsschema und sammelt die Ergebnisse. Der kritische Teil liegt im try/except-Block: Eine unlesbare Rechnung oder ein fehlgeschlagener API-Aufruf darf niemals den gesamten Batch unterbrechen. Wir protokollieren den Fehler mit dem Dateinamen und fahren fort, sodass Sie am Ende eine Liste haben, bei der jeder Eintrag einen status aufweist. Der Zähler, der bei jeder Iteration angezeigt wird, ist nicht nur eine nette Option; bei der Verarbeitung von dreihundert Dateien verhindert das Wissen über Ihren Fortschritt, dass Sie einen Job neu starten müssen, der bereits zur Hälfte abgeschlossen ist.
import os
import json
import time
from pathlib import Path
from mistralai.client import Mistral
from mistralai.extra import response_format_from_pydantic_model
from pydantic import BaseModel, Field
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
class ExtractionFacture(BaseModel):
fournisseur: str = Field(..., description="Lieferantenname")
numero: str = Field(..., description="Rechnungsnummer")
montant_ttc: float = Field(..., description="Gesamtbetrag einschließlich Steuer")
date: str = Field(..., description="Datum (JJJJ-MM-TT)")
def traiter_dossier_factures(dossier: str) -> list[dict]:
"""Verarbeitet alle Rechnungen in einem Ordner."""
resultats = []
chemin = Path(dossier)
fichiers = list(chemin.glob("*.pdf"))
print(f"Verarbeite {len(fichiers)} Dateien...")
for i, fichier in enumerate(fichiers):
print(f" [{i+1}/{len(fichiers)}] {fichier.name}")
try:
import base64
with open(fichier, "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(
ExtractionFacture
),
table_format="markdown"
)
if response.document_annotation:
facture = ExtractionFacture.model_validate_json(
response.document_annotation
)
resultats.append({
"fichier": fichier.name,
"fournisseur": facture.fournisseur,
"numero": facture.numero,
"montant_ttc": facture.montant_ttc,
"date": facture.date,
"statut": "ok"
})
except Exception as e:
resultats.append({
"fichier": fichier.name,
"statut": "erreur",
"erreur": str(e)
})
return resultats
Parallelisieren, ohne die API zu überlasten
Sequentielle Verarbeitung verbringt den größten Teil ihrer Zeit mit dem Warten auf das Netzwerk. Asynchrone Aufrufe eliminieren diese Verschwendung, sofern Sie die Parallelität begrenzen: Das Starten von dreihundert Anfragen gleichzeitig löst Fehler aufgrund von Rate-Limits aus und lässt Sie mit einem halbfertigen Batch zurück. Der asyncio-Semaphore bewältigt genau dies – max_concurrent=5 bedeutet, dass zu jedem Zeitpunkt maximal fünf Dokumente in Bearbeitung sind, unabhängig davon, wie viele Dateien in der Warteschlange stehen. Die einzelne Funktion behält dieselbe Disziplin wie die sequentielle Version bei: Sie fängt Ausnahmen ab und gibt ein Status-Dictionary zurück, anstatt dass gather abstürzt.
import os
import asyncio
import base64
from pathlib import Path
from mistralai.client import Mistral
from mistralai.extra import response_format_from_pydantic_model
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
async def traiter_document(chemin_fichier: Path, schema) -> dict:
"""Verarbeitet ein Dokument asynchron."""
try:
with open(chemin_fichier, "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(
schema
)
)
annotations = []
if response.document_annotation:
annotations.append(response.document_annotation)
return {
"fichier": chemin_fichier.name,
"annotations": annotations,
"statut": "ok"
}
except Exception as e:
return {
"fichier": chemin_fichier.name,
"statut": "erreur",
"erreur": str(e)
}
async def traiter_batch(
dossier: str,
schema,
max_concurrent: int = 5
) -> list[dict]:
"""Verarbeitet einen Ordner mit kontrollierter Parallelität."""
chemin = Path(dossier)
fichiers = list(chemin.glob("*.pdf"))
semaphore = asyncio.Semaphore(max_concurrent)
async def traiter_avec_limite(fichier):
async with semaphore:
return await traiter_document(fichier, schema)
taches = [traiter_avec_limite(f) for f in fichiers]
resultats = await asyncio.gather(*taches)
return list(resultats)
# Ausführung
# résultats = asyncio.run(traiter_batch("./factures/", ExtractionFacture))
Wenn das Volumen Batch-Inferenz rechtfertigt
Ab einem bestimmten Schwellenwert verschiebt sich die Frage von der Geschwindigkeit zu den Kosten. Mistral bietet einen dedizierten Batch-Inferenz-Service an, der wirtschaftlicher ist als einzelne Aufrufe. Sie übermitteln eine JSONL-Datei, die pro Zeile eine Anfrage enthält. Das Feld custom_id – hier der Dateiname ohne Erweiterung – ermöglicht es Ihnen, jede Antwort der ursprünglichen Datei zuzuordnen, wenn der Batch abgeschlossen ist.
import json
def preparer_batch_jsonl(dossier: str, sortie: str) -> int:
"""Vorbereitet eine JSONL-Datei für die Batch-Verarbeitung."""
chemin = Path(dossier)
fichiers = list(chemin.glob("*.pdf"))
compte = 0
with open(sortie, "w") as f:
for fichier in fichiers:
with open(fichier, "rb") as pdf:
doc_b64 = base64.b64encode(pdf.read()).decode("utf-8")
requete = {
"custom_id": fichier.stem,
"model": "mistral-ocr-latest",
"document": {
"type": "document_url",
"document_url": f"data:application/pdf;base64,{doc_b64}"
}
}
f.write(json.dumps(requete) + "\n")
compte += 1
print(f"{compte} Anfragen vorbereitet in {sortie}")
return compte
Verfolgen, was passiert ist
Massive Verarbeitung ohne Metriken ist eine Blackbox. Die folgende kleine Dataclass zählt Erfolge und Fehler, berechnet die verstrichene Zeit und leitet daraus eine Geschwindigkeit in Dokumenten pro Sekunde ab. Diese Geschwindigkeit zeigt Ihnen, ob Ihre max_concurrent-Einstellung optimal ist, während die Liste der fehlgeschlagenen Dateien Ihren Prozess zur Wiederherstellung von Vorfällen speist.
import time
from dataclasses import dataclass, field
@dataclass
class StatsBatch:
total: int = 0
succes: int = 0
erreurs: int = 0
temps_debut: float = field(default_factory=time.time)
fichiers_erreur: list = field(default_factory=list)
@property
def duree(self) -> float:
return time.time() - self.temps_debut
@property
def vitesse(self) -> float:
if self.duree > 0:
return self.succes / self.duree
return 0.0
def rapport(self) -> str:
return (
f"Verarbeitung abgeschlossen in {self.duree:.1f}s\n"
f" Erfolge: {self.succes}/{self.total}\n"
f" Fehler: {self.erreurs}\n"
f" Geschwindigkeit: {self.vitesse:.2f} docs/s\n"
f" Fehlgeschlagene Dateien: {self.fichiers_erreur}"
)
Schließlich exportieren Sie die Skriptergebnisse. CSV geht in die Excel-Tabelle der Buchhaltung, JSON in Ihre Anwendung; in beiden Fällen stellen Sie sicher, dass die Kodierung UTF-8 und ensure_ascii=False ist, sonst erscheinen Ihre akzentuierten Zeichen für den Empfänger als unlesbare Zeichenfolgen.
import csv
import json
def exporter_csv(resultats: list[dict], chemin: str) -> None:
"""Exportiert Ergebnisse nach CSV."""
if not resultats:
return
cles = resultats[0].keys()
with open(chemin, "w", newline="", encoding="utf-8") as f:
writer = csv.DictWriter(f, fieldnames=cles)
writer.writeheader()
writer.writerows(resultats)
print(f"CSV-Export: {chemin}")
def exporter_json(resultats: list[dict], chemin: str) -> None:
"""Exportiert Ergebnisse nach JSON."""
with open(chemin, "w", encoding="utf-8") as f:
json.dump(resultats, f, ensure_ascii=False, indent=2)
print(f"JSON-Export: {chemin}")
Kernaussagen
- Sequentielle Verarbeitung eignet sich für kleine Volumina mit robustem Fehlermanagement
- Parallelverarbeitung mit
asynciound Semaphoren beschleunigt große Volumina - Der Batch-Inferenz-Service von Mistral ist die kosteneffektivste Lösung für sehr große Volumina
- Fügen Sie Überwachung und Berichterstattung hinzu, um Fortschritt zu verfolgen und Fehler zu identifizieren
- Exportieren Sie Ergebnisse nach CSV oder JSON zur Integration mit Ihren Systemen