Nächste Schritte: Dokument-KI, Funktionsaufrufe und multimodale Pipelines

Aktualisiert am 3. November 2026 basierend auf der Mistral-Seite Document QnA und dem mistralai SDK 3.7.0: Das Beispiel fragt ein Dokument mit einem Chat-Modell (mistral-small-latest) ab, nicht mit dem OCR-Modell, und document_image_limit ist kein Parameter für chat.complete (der Aufruf wäre fehlgeschlagen); Seitengrenzen werden in client.ocr.process festgelegt. Quelle: Document QnA.

Über die Vision-API hinaus

Sie haben nun die Grundlagen der Mistral Vision-API gemeistert: Bilder über URL und Base64 senden, Diagramme analysieren, OCR durchführen, strukturierte Daten extrahieren und Bilder vergleichen. Diese Basis hat eine natürliche Grenze: Bisher hat das Modell immer ein Bild betrachtet und Text zurückgegeben, niemals eine Aktion ausgeführt. Diese letzte Lektion überschreitet diese Grenze in drei Phasen: dem spezialisierten Dienst für Dokumente, dem Funktionsaufruf, der die Analyse in Aktion verwandelt, und Pipelines, die sie verbinden.

Mistral Document AI (OCR 4)

Für fortgeschrittene OCR-Bedürfnisse bietet Mistral Document AI, einen Dienst, der auf die Verarbeitung von Dokumenten spezialisiert ist. Während die Vision-API einzelne Bilder verarbeitet, denkt Document AI auf Dokumentenebene: Es verarbeitet mehrseitige PDFs und analysiert lange Dateien in einem Durchgang. Es bewältigt komplexe Layouts – Spalten, Kopf- und Fußzeilen, verschachtelte Tabellen – und erhält die Struktur, wobei die Ausgabe die Dokumenthierarchie von Überschriften, Absätzen und Listen beibehält. Schließlich ist die OCR-Genauigkeit sowohl für gedruckten als auch für handschriftlichen Text optimiert.

Beispiel für einen Document AI-Aufruf

from mistralai.client import Mistral
import os

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

# Analysieren Sie ein PDF mit Document AI
response = client.chat.complete(
    model="mistral-small-latest",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Extrahieren Sie den vollständigen Inhalt dieses Dokuments und bewahren Sie die Struktur bei."
                },
                {
                    "type": "document_url",
                    "document_url": "https://example.com/annual-report.pdf"
                }
            ]
        }
    ]
)

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

Der Unterschied zu allem, was Sie bisher geschrieben haben, liegt im Elementtyp: document_url statt image_url, gelesen von einem Standard-Chat-Modell (mistral-small-latest in der Mistral-Dokumentation). Das Dokument darf nicht größer als 50 MB sein und darf maximal 1.000 Seiten enthalten. Um nur einen Teil eines 300-seitigen Jahresberichts zu verarbeiten, verwenden Sie stattdessen den OCR-Endpunkt (client.ocr.process), wo die Parameter pages und image_limit die Arbeit begrenzen.

Wann Document AI vs. Vision API verwenden

Denken Sie an die Faustregel: Verwenden Sie die Vision-API für das, was als Bild geboren wurde, und Document AI für das, was als Dokument geboren wurde.

Vision + Funktionsaufrufe

Bisher erhielt Ihr Code eine Antwort und entschied, was er damit anfangen soll. Der Funktionsaufruf kehrt diese Beziehung um: Sie stellen dem Modell eine Liste verfügbarer Aktionen bereit, und es wählt basierend auf dem Bild, welche davon aufgerufen werden soll. Dies ist der Schlüssel zum Aufbau autonomer visueller Agenten.

Der Zyklus besteht aus vier Schritten:

1. Sie senden ein Bild + Funktionsdefinitionen
2. Das Modell analysiert das Bild und entscheidet, welche Funktion aufgerufen werden soll
3. Sie führen die Funktion aus und geben das Ergebnis zurück
4. Das Modell formuliert eine finale Antwort

Beispiel: Rechnungsverarbeitungs-Agent

Betrachten Sie eine Buchhaltung, die Rechnungen per Post erhält. Zwei Ergebnisse sind möglich: Die Rechnung ist gültig und muss erfasst werden, oder sie weist eine Anomalie auf und muss markiert werden. Wir definieren daher zwei Werkzeuge mit ihren Parametern und erforderlichen Feldern.

import json

# Verfügbare Werkzeuge definieren
outils = [
    {
        "type": "function",
        "function": {
            "name": "enregistrer_facture",
            "description": "Enregistre une facture dans le système comptable",
            "parameters": {
                "type": "object",
                "properties": {
                    "emetteur": {"type": "string", "description": "Nom de l'émetteur"},
                    "numero": {"type": "string", "description": "Numéro de facture"},
                    "date": {"type": "string", "description": "Date d'émission (YYYY-MM-DD)"},
                    "montant_ttc": {"type": "number", "description": "Montant TTC en euros"},
                    "tva": {"type": "number", "description": "Montant de la TVA"}
                },
                "required": ["emetteur", "numero", "date", "montant_ttc"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "signaler_anomalie",
            "description": "Signale une anomalie sur une facture (doublons, montants incohérents)",
            "parameters": {
                "type": "object",
                "properties": {
                    "type_anomalie": {"type": "string"},
                    "description": {"type": "string"}
                },
                "required": ["type_anomalie", "description"]
            }
        }
    }
]

# Senden Sie das Bild mit den Werkzeugen
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": "Vous êtes un assistant comptable. Analysez les factures et utilisez les outils appropriés."
        },
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Traitez cette facture."},
                {"type": "image_url", "image_url": encoder_image("factures/facture-2024-0042.jpg")}
            ]
        }
    ],
    tools=outils,
    tool_choice="auto"
)

# Den Funktionsaufruf verarbeiten
if response.choices[0].message.tool_calls:
    appel = response.choices[0].message.tool_calls[0]
    nom_fonction = appel.function.name
    arguments = json.loads(appel.function.arguments)
    print(f"Fonction appelée : {nom_fonction}")
    print(f"Arguments : {json.dumps(arguments, indent=2, ensure_ascii=False)}")

Gestalten Sie das Feld description für jede Funktion sorgfältig: Das Modell stützt sich bei seiner Entscheidung auf dies, nicht auf den Namen. Eine vage Beschreibung erzeugt einen Agenten, der die falsche Funktion aufruft.

Multimodale Pipelines

Eine multimodale Pipeline verknüpft mehrere Verarbeitungsschritte, indem sie Vision, Text und Werkzeuge kombiniert. Ihr Wert liegt sowohl ökonomisch als auch organisatorisch: Jeder Schritt verwendet ausschließlich das für ihn notwendige Modell.

Beispiel: Postverarbeitungs-Pipeline

Eingehende Post für ein KMU mischt Rechnungen, Angebote, Verträge und Werbung. Die Klassifizierung kostet wenig; die detaillierte Analyse kostet mehr. Die Pipeline beginnt daher mit einer Sortierung mittels eines leichten Modells und greift nur auf Large zurück, wenn dies für Dokumente gerechtfertigt ist.

def mail_pipeline(image_path):
    """Pipeline complet : classification -> extraction -> action."""

    # Étape 1 : Classification (modèle léger)
    classification = client.chat.complete(
        model="mistral-small-latest",
        response_format={"type": "json_object"},
        messages=[{
            "role": "user",
            "content": [
                {"type": "text", "text": 'Classifiez ce document : {"type": "facture|devis|contrat|courrier|autre", "urgence": "haute|moyenne|basse"}'},
                {"type": "image_url", "image_url": encoder_image(image_path)}
            ]
        }]
    )
    info = json.loads(classification.choices[0].message.content)
    print(f"Type : {info['type']} | Urgence : {info['urgence']}")

    # Étape 2 : Extraction détaillée (modèle puissant, seulement si nécessaire)
    if info["type"] == "facture":
        extraction = client.chat.complete(
            model="mistral-large-latest",
            response_format={"type": "json_object"},
            messages=[{
                "role": "user",
                "content": [
                    {"type": "text", "text": "Extrayez toutes les données de cette facture en JSON : emetteur, numero, date, lignes, total_ht, tva, total_ttc."},
                    {"type": "image_url", "image_url": encoder_image(image_path)}
                ]
            }]
        )
        data = json.loads(extraction.choices[0].message.content)
        return {"classification": info, "données": data}

    # Étape 3 : Résumé pour les autres types
    summary = client.chat.complete(
        model="mistral-small-latest",
        messages=[{
            "role": "user",
            "content": [
                {"type": "text", "text": "Résumez le contenu de ce document en 3 phrases maximum."},
                {"type": "image_url", "image_url": encoder_image(image_path)}
            ]
        }]
    )
    return {"classification": info, "summary": summary.choices[0].message.content}

# Traiter un lot de courrier
from pathlib import Path

for file in sorted(Path("courrier/").glob("*.jpg")):
    print(f"\n--- {file.name} ---")
    result = mail_pipeline(file)
    print(json.dumps(result, indent=2, ensure_ascii=False))

In einem Stapel, bei dem ein von fünf Elementen eine Rechnung ist, sehen vier von fünf Dokumenten das teure Modell nie, bei gleicher finaler Qualität.

Kurszusammenfassung

Über diese 12 Lektionen haben Sie vom Mechanismus zur Anwendung übergegangen. Sie haben zunächst die multimodale Architektur verstanden und erfahren, was tatsächlich passiert, wenn ein Bild in das Modell eingeht, dann gelernt, die Variante zu wählen, die für Ihre Arbeitslast geeignet ist – Large, Small oder Ministral. Anschließend haben Sie gelernt, Bilder über URL und Base64 einzusenden, einzeln oder in Stapeln. Auf dieser Grundlage haben Sie sich den Anwendungen zugewandt, die den Großteil der realen Arbeit ausmachen: Diagramme analysieren, Text über OCR lesen, strukturierte Daten extrahieren, Bilder für Qualitätskontrolle vergleichen und die Entwicklung verfolgen. Schließlich haben Sie gelernt, Ihre Aufrufe hinsichtlich Kosten, Latenz und Zuverlässigkeit zu optimieren, und Vision in größere Pipelines zu integrieren, dank des Funktionsaufrufs.

Nächste Schritte

Vier Richtungen erweitern diesen Pfad natürlich. Erstens Document AI, dessen OCR 4 Dokumente verarbeitet, die die Vision-API nicht unterstützen kann. Zweitens Agenten, die Vision und Funktionsaufrufe kombinieren, um Systeme zu bauen, die entscheiden und handeln. Drittens Feinabstimmung, wenn Ihre Bilder Spezifika aufweisen, die ein Generalistenmodell nicht kennt – ein Katalog von Industrieteilen, ein internes Formular. Schließlich die Batch-API, die entwickelt wurde, um Tausende von Bildern bei reduzierten Kosten zu verarbeiten, wenn die Reaktionszeit nicht kritisch ist. Langfristig werden erweiterte multimodale Fähigkeiten den Weg zu Video und Audio ebnen, sofern verfügbar.

Wichtige Erkenntnisse

• Document AI (OCR 4) ist das natürliche Komplement zur Vision-API für komplexe Dokumente und PDFs
• Funktionsaufrufe verwandeln Vision in einen autonomen Agenten, der auf extrahierte Daten eingreifen kann
• Eine multimodale Pipeline kombiniert Klassifizierung (Small) und Extraktion (Large), um Qualität und Kosten zu optimieren
• Die Mistral Vision-API ist ein grundlegender Baustein für den Aufbau moderner KI-Anwendungen

Wissen testen

Vision über die API: fünf Fragen, um die Pipeline zu verankern.

1. Wie senden Sie ein Bild an die Mistral-API?

Antwort: Über URL oder Base64-kodiert, in einer Nachricht mit gemischtem Text- und Bildinhalt – und mehrere Bilder können in derselben Nachricht für Vergleiche übertragen werden.

2. Was ermöglicht Vision über die Beschreibung hinaus?

Antwort: Diagrammanalyse, OCR (Transkribieren von Text aus Bildern) und Extraktion strukturierter Daten – das Bild wird zur Datenquelle, nicht zur Illustration.

3. Wie machen Sie strukturierte Extraktion aus einem Bild zuverlässig?

Antwort: Definieren Sie das erwartete Schema präzise (Felder, Format), fordern Sie Vollständigkeit oder das Eingeständnis des Fehlens an, und überprüfen Sie kritische Werte – Vision wird wie Text promptiert.

4. Welche Grenzen sollten Sie im Hinterkopf behalten?

Antwort: Die Bildqualität bestimmt alles (Auflösung, Schärfe); sehr kleiner Text und komplexe Layouts ermüden das Modell – optimieren Sie den Input, bevor Sie den Output beschuldigen.

5. Was sind die natürlichen Folgeschritte zu diesem Kurs?

Antwort: Document AI für vollständige Dokumente, Funktionsaufrufe, um die Extraktion mit Ihren Systemen zu verbinden, und multimodale Pipelines, die alles kombinieren.

URL oder Base64, präzise Prompts, sorgfältige Inputs: Die Vision-Pipeline ist bereit – die nächsten Schritte integrieren sie in Ihre Anwendungen.