Mistral Large 3 Tutorial: Bau eines multimodalen Zentrums zur Bewertung von Intelligenz

Mistral Large 3 ist ein multimodales MoE-Modell, das entwickelt wurde, um Infos aus komplizierten visuellen Dokumenten zu lesen, zu verarbeiten und zu strukturieren. Anstatt Diagramme und PDFs einfach als statische Bilder zu sehen, ist es so gemacht, dass es Tabellen und Erkenntnisse raussucht und daraus coole Geschichten macht.

In diesem Tutorial nutzen wir das Modell Mistral Large 3 (mistral-large-2512), um einen Multimodal Intelligence Evaluation Hub in Streamlit zu erstellen. Der Ablauf sieht so aus:

• Du lädst Sachen wie Diagramme, Finanzberichte oder mehrseitige PDFs hoch.
• Mistral liest Texte und Zahlen direkt aus dem Bild.
• Es wandelt alle sichtbaren Tabellen in CSV-Zeichenfolgen um.
• Mistral macht dann aus den Eingaben Erkenntnisse, Risiken und Anomalien.
• Am Ende gibt's kurze Zusammenfassungen in mehreren Sprachen.

All das wird mit einem einzigen Modell (mistral-large-2512), einem einzigen Endpunkt (/v1/chat/completions) und einem strengen JSON-Schema gemacht, damit die Ergebnisse strukturiert und zuverlässig bleiben. 

Ich empfehle, unseren Artikel über Mistral 3, der die wichtigsten Funktionen der neuen Modelle vorstellt. 

Was ist Mistral Large 3?

Mistral Large 3 ist eine spärliche Mix-of-Experts-Architektur (MOE) mit 41 Milliarden aktiven Parametern von insgesamt 675 Milliarden und einem 2,5 Milliarden Parameter umfassenden Bildverarbeitungs-Encoder für das Bildverständnis.

Hier sind ein paar wichtige Eigenschaften, die für dieses Modell wichtig sind:

• Multimodal: Mistral Large 3 kann sowohl mit Texten als auch mit Bildern (Diagramme, Screenshots, Dokumente) umgehen.
• Langer Kontext (256k Token): Es ist für lange Dokumente, RAG-Pipelines und Unternehmens-Workflows gemacht.
• Agentisches und strukturiertes Output-: Es unterstützt Funktionsaufrufe und JSON/JSON-Schema-Ausgabe über die Chat-API.
• Multilingual: Das große Modell 3 von Mistral macht echt was her in über 40 Sprachen, nicht nur auf Englisch.

Die Modellkarte und die Ökosystem-Dokumente erwähnen auch ein paar wichtige Hinweise:

• Es ist kein spezielles Argumentationsmodell, d. h. es gibt auch bestimmte spezielle Argumentationsvarianten, die bei schwierigen logischen Aufgaben besser abschneiden können.
• Bei reinen Sehaufgaben liegt es hinter Modellen, die speziell auf das Sehen ausgerichtet sind, daher sind Vorverarbeitung und gute Eingabeaufforderungen wichtig.
• Für die Darstellung empfiehlt Mistral, das Seitenverhältnis nahe bei 1:1 zu halten und extrem schmale oder breite Bilder zu vermeiden. Das Zuschneiden von Bildern hilft also dabei, die Leistung des Modells zu verbessern. 

Mistral 3 Großes Beispielprojekt: Multimodaler Intelligenzbewertungs-Hub

In diesem Abschnitt erstellen wir einen Multimodal Intelligence Evaluation Hub mit Mistral Large 3, eingebettet in eine Streamlit-App. Auf hoher Ebene macht die fertige App Folgendes:

• Nimmt reportähnliche Eingaben wie Diagramm-Screenshots, einzelne Reportseiten oder mehrseitige PDFs mit Tabellen und Diagrammen an.
• Konvertiert PDFs in ein einziges gestapeltes Bild, schneidet es dann auf ein Seitenverhältnis von ungefähr 1:1 zu (gemäß der Empfehlung von Mistral Large 3 Vision), passt die Größe auf etwa 1024×1024 an und codiert das Ergebnis als Base64-Daten-URL.
• Dann schicken wir die Anweisungen des Benutzers und das Bild an mistral-large-2512, das response_format im JSON-Schema-Modus nutzt, um eine strukturierte JSON-Nutzlast zurückzubekommen.
• Zum Schluss machen wir aus dem JSON ein interaktives Dashboard mit neu aufgebauten Tabellen als DataFrames, die man als CSV-Dateien runterladen kann, mit Stichpunkten zu Erkenntnissen/Risiken/Anomalien, einem Social-Media-fähigen Beitrag und mehrsprachigen Zusammenfassungen in Expandern.

Das verwandelt einen statischen visuellen Bericht in einen interaktiven Informationsassistenten, der komplett von Mistral Large 3 betrieben wird.

Lass es uns Schritt für Schritt aufbauen.

Schritt 1: Voraussetzungen und Einrichtung

Bevor wir unsere Streamlit-Demo auf Mistral Large 3 aufbauen können, brauchen wir eine einfache lokale Umgebung, um über die Mistral-API mit dem Modell zu kommunizieren. Fang damit an, ein paar Hilfsbibliotheken zu installieren, um die Benutzeroberfläche, Dokumente und Konfiguration zu verwalten. 

pip install streamlit mistralai pillow pdf2image pandas python-dotenv

Wir werden die oben genannten Kernbibliotheken wie streamlit für die interaktive Web-App-Benutzeroberfläche, mistralai für die Kommunikation mit der Mistral-API und pillow und pdf2image zum Öffnen und Konvertieren von PDFs in Bilder, pandas zum Bearbeiten von tabellarischen Daten oder Protokollen und python-dotenv zum sicheren Laden von Umgebungsvariablen wie MISTRAL_API_KEY aus einer .env -Datei.

Als Nächstes logg dich in die Mistral AI-Plattform ein und geh zu den API-Schlüssel ..

Leg deinen Standard-Arbeitsbereich fest (wenn du dazu aufgefordert wirst) und klick auf Neuen Schlüssel erstellen.

Gib deinem Schlüssel einen aussagekräftigen Namen und leg optional ein Ablaufdatum fest.

Kopiere zum Schluss den generierten Schlüssel und exportiere ihn als Umgebungsvariable wie folgt:

export MISTRAL_API_KEY="your_mistral_api_key_here"

Jetzt ist unsere Umgebung bereit, sich bei der Mistral-API anzumelden.

Schritt 2: Mistral-Client starten

Nachdem die Umgebung eingerichtet und die Abhängigkeiten installiert sind, musst du als Nächstes den Mistral-Client starten, der alle unsere Anfragen an das Mistral Large 3-Modell verarbeitet. Das gibt uns einen Einstiegspunkt, um Anweisungen von unserer Streamlit-App an Mistral Large 3 zu schicken.

MISTRAL_API_KEY = os.getenv("MISTRAL_API_KEY")
MODEL_ID = "mistral-large-2512"  
if MISTRAL_API_KEY is None:
    raise RuntimeError("Please set the MISTRAL_API_KEY environment variable.")
client = MistralClient(api_key=MISTRAL_API_KEY)

Der obige Code-Block macht drei Sachen:

• Es liest die Umgebungsvariable „ MISTRAL_API_KEY “ aus und speichert den Modellnamen in „ MODEL_ID “, sodass wir ihn in der ganzen App wiederverwenden können.
• Dann checkt es, ob der API-Schlüssel da ist, und gibt 'nen klaren Fehler aus, wenn er fehlt.
• Außerdem wird eine Instanz von „ MistralClient “ mit dem offiziellen SDK „ mistralai “ erstellt, die wir für alle weiteren Anfragen an das Modell verwenden werden.

Nachdem der Client jetzt läuft, machen wir ein paar Hilfsfunktionen, die Aufforderungen senden und Antworten in der Streamlit-Benutzeroberfläche verarbeiten.

Schritt 3: Bildvorverarbeitung

Bevor wir Bilder oder PDFs an Mistral Large 3 schicken, müssen wir sie „modellfreundlich“ machen. Die Vision API funktioniert am besten, wenn die Eingaben quadratisch, angemessen groß und in einem einheitlichen Format codiert sind. 

Schritt 3.1: Zentriert

Zuerst laden wir das hochgeladene Bild und machen daraus einen quadratischen Ausschnitt. 

def load_image_from_upload(uploaded_file) -> Image.Image:
    return Image.open(io.BytesIO(uploaded_file.read())).convert("RGB")
def center_crop_to_square(img: Image.Image) -> Image.Image:
    width, height = img.size
    if width == height:
        return img
    if width > height:
        offset = (width - height) // 2
        box = (offset, 0, offset + height, height)
    else:
        offset = (height - width) // 2
        box = (0, offset, width, offset + width)
    return img.crop(box)

Der obige Code-Block sorgt dafür, dass Diagramme oder Tabellen, die wir hochladen, in ein quadratisches Ausschnittformat umgewandelt werden, bevor sie an das Modell weitergeleitet werden, was der Vision Guidance von Mistral entspricht.

Schritt 3.2: Größenänderung 

Als Nächstes ändern wir die Größe des Bildes auf maximal 1024 × 1024 Pixel, um Qualität, Latenz und Token-Kosten unter einen Hut zu bringen.

def resize_for_vlm(img: Image.Image, max_size: int = 1024) -> Image.Image:
    width, height = img.size
    scale = min(max_size / width, max_size / height, 1.0)
    if scale == 1.0:
        return img
    new_w = int(width * scale)
    new_h = int(height * scale)
    return img.resize((new_w, new_h), Image.LANCZOS)

Hier berechnen wir einen Faktor „ scale “, der beide Dimensionen unter „ max_size “ hält und gleichzeitig das Seitenverhältnis beibehält. Wenn das Bild schon klein genug ist, geben wir es so wie es ist zurück. Ansonsten berechnen wir die neuen Dimensionen und verwenden LANCZOS Resampling für eine hochwertige Verkleinerung.

Dieser Schritt sorgt dafür, dass Bilder dein Kontextfenster nicht überladen oder die Reaktionszeiten unnötig verlangsamen.

Schritt 3.3: PDFs zu gestapelten Bildern

Bei PDFs wollen wir das Modell oft auf mehr als einer Seite zeigen. Ein einfacher Trick ist, alle Seiten zu rendern und sie vertikal zu einem hohen Bild zu stapeln. 

def stack_images_vertically(images: List[Image.Image]) -> Image.Image:
    if not images:
        raise ValueError("No images to stack")
    target_width = images[0].size[0]
    resized_images = []
    for img in images:
        if img.size[0] != target_width:
            aspect_ratio = img.size[1] / img.size[0]
            new_height = int(target_width * aspect_ratio)
            img = img.resize((target_width, new_height), Image.LANCZOS)
        resized_images.append(img)
    total_height = sum(img.size[1] for img in resized_images)
    stacked = Image.new('RGB', (target_width, total_height))
    y_offset = 0
    for img in resized_images:
        stacked.paste(img, (0, y_offset))
        y_offset += img.size[1] 
    return stacked
def uploaded_file_to_square_base64(uploaded_file) -> Tuple[str, str]:
    mime_type = uploaded_file.type
    raw_bytes = uploaded_file.getvalue()
    if mime_type == "application/pdf":
        pages = convert_from_bytes(raw_bytes)
        pages_rgb = [page.convert("RGB") for page in pages]
        img = stack_images_vertically(pages_rgb)
        img = resize_for_vlm(img, max_size=1024)
        mime_type = "image/png"  
    else:
        img = Image.open(io.BytesIO(raw_bytes)).convert("RGB")
        img = center_crop_to_square(img)
        img = resize_for_vlm(img, max_size=1024)
    return mime_type, image_to_base64_data_url(img, mime_type=mime_type)

Die Funktion „ stack_images_vertically() “ ( ) nimmt eine Liste von PIL-Bildern, normalisiert sie auf eine einheitliche Breite, behält dabei das Seitenverhältnis bei, berechnet die Gesamthöhe und fügt sie untereinander in eine einzige RGB-Leinwand ein. DieFunktion „ “uploaded_file_to_square_base64() entscheidet dann anhand des MIME-Typs, was zu tun ist:

• Bei PDFs macht es aus jeder Seite ein Bild, stapelt sie übereinander und passt die Größe an.
• Bei normalen Bild-Uploads wird das Bild geladen, mittig zu einem Quadrat zugeschnitten und in der Größe angepasst.

In beiden Fällen gibt es ein normalisiertes Bild zusammen mit einem MIME-Typ für den letzten Kodierungsschritt zurück.

Schritt 3.4: Kodierung nach Base64 

Die Vision API von Mistral nimmt Bilder als „ image_url “-Objekte an, die entweder echte URLs oder „ data: “-URLs sein können.

def image_to_base64_data_url(img: Image.Image, mime_type: str = "image/png") -> str:
    buffer = io.BytesIO()
    if mime_type == "image/jpeg":
        img.save(buffer, format="JPEG", quality=90)
    else:
        img.save(buffer, format="PNG")
        mime_type = "image/png"
    b64 = base64.b64encode(buffer.getvalue()).decode("utf-8")
    return f"data:{mime_type};base64,{b64}"

Wir fangen damit an, das Bild in einen Speicherpuffer zu schreiben und ein passendes Format (wie JPEG oder PNG) auszuwählen, bevor wir die Bytes schließlich mit Base64 verschlüsseln. 

Zum Schluss packen wir die verschlüsselte Zeichenfolge in eine URL vom Typ „ data:{mime_type};base64 “, die direkt an die Mistral Vision API weitergeleitet werden kann, zum Beispiel als image_url.

Am Ende dieses Schritts durchläuft jede hochgeladene Datei, egal ob es sich um eine einzelne PNG-Datei, ein breites Dashboard oder ein mehrseitiges PDF handelt, die gleiche Pipeline mit den Schritten „Zentrieren und Zuschneiden“, „Größenänderung“, „PDF-Stapeln“ und „Base64-Daten-URL-Konvertierung“.

Schritt 4: Multimodale Inferenzanforderung 

In diesem Schritt packen wir alles in eine einzige Hilfsfunktion, die eine Vision-Plus-Text-Anfrage sendet und das Modell dazu bringt, im JSON-Format zu antworten. Wir machen das, indem wir Folgendes kombinieren:

• Eine Systemaufforderung, die die Rolle des Modells als Multimodaler Intelligenz-Bewerterdefiniert,
• Eine Benutzernachricht, die Anweisungen mit dem Bildinhalt vermischt, und
• Ein JSON-Schema wird über „ response_format “ übergeben, damit die Ausgabe strukturiert und leicht zu analysieren ist.

def call_mistral_large_multimodal(
    mime_type: str,
    image_data_url: str,
    user_instruction: str,
    languages: List[str],
) -> Dict[str, Any]:
    json_schema = {
        "type": "object",
        "properties": {
            "csv_tables": {
                "type": "array",
                "items": {"type": "string"},
                "description": "Each item is a CSV string representing one table found in the image."
            },
            "insights": {
                "type": "array",
                "items": {"type": "string"},
                "description": "Up to 5 key insights about the content."
            },
            "risks": {
                "type": "array",
                "items": {"type": "string"},
                "description": "Up to 5 key risks or red flags."
            },
            "anomalies": {
                "type": "array",
                "items": {"type": "string"},
                "description": "Any anomalies, outliers, or surprising patterns you detect."
            },
            "translations": {
                "type": "object",
                "properties": {
                    lang: {"type": "string"} for lang in languages
                },
                "description": "Short high-level summaries in the selected languages."
            },
        },
        "required": ["csv_tables", "insights", "risks"],
        "additionalProperties": False,
    }
    system_prompt = (
        "You are a Multimodal Intelligence Evaluator using Mistral Large 3.\n"
        "You are given a single document-like image (e.g. chart + table, financial report page).\n\n"
        "Your tasks:\n"
        "1. Read all visible text and numbers directly from the image.\n"
        "2. Reconstruct any clearly visible tables into valid CSV strings.\n"
        "   - Use the first row as headers when possible.\n"
        "   - Use commas as separators and newline per row.\n"
        "3. Derive up to 5 concise INSIGHTS about trends, patterns, or takeaways.\n"
        "4. Derive up to 5 concise RISKS or red flags (business, financial, operational, etc.).\n"
        "5. Detect any anomalies or surprising patterns if present (else return an empty list).\n"
        "6. Provide short summaries in the requested languages.\n\n"
        "You MUST respond ONLY with a JSON object that matches the provided JSON schema.\n"
        "Do not include any extra commentary outside of the JSON."
    )
    messages = [
        {
            "role": "system",
            "content": [
                {"type": "text", "text": system_prompt},
            ],
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": user_instruction or "Analyze this financial report page.",
                },
                {
                    "type": "image_url",
                    "image_url": image_data_url,
                },
            ],
        },
    ]
    response = client.chat(
        model=MODEL_ID,
        messages=messages,
        temperature=0.2,
        max_tokens=2048,
        response_format={
            "type": "json_schema",
            "json_schema": {
                "name": "multimodal_intel_eval",
                "schema": json_schema,
                "strict": True,
            },
        },
    )
    content = response.choices[0].message.content
    try:
        parsed = json.loads(content)
    except json.JSONDecodeError:
        try:
            start = content.index("{")
            end = content.rindex("}") + 1
            parsed = json.loads(content[start:end])
        except Exception:
            raise ValueError(f"Model did not return valid JSON. Raw content:\n{content}")
    return parsed

Die Funktion „ call_mistral_large_multimodal() ” ist das Herzstück der multimodalen Intelligenz-Demo.

• Die Funktion erstellt zuerst ein JSON-Schema, das Arrays für „ csv_tables “, „ insights “, „ risks “, „ anomalies “ und ein „ translations “-Objekt mit Schlüsseln aus der Liste „ languages “ definiert. 
• Wir haben auch eine detaillierte Systemaufforderung definiert, die das Modell als Multimodal Intelligence Evaluator und es durch die Aufgaben des Lesens von Zahlen, der Rekonstruktion von Tabellen als CSV, der Extraktion von Erkenntnissen, Risiken, Anomalien und mehrsprachigen Zusammenfassungen führt.
• Die Funktion „ call_mistral_large_multimodal() “ baut dann das Nachrichten-Array im Chat-Format auf, indem sie die Systemanweisungen mit einer Benutzernachricht kombiniert, die sowohl Textanweisungen als auch die Nutzlast „ image_url “ enthält. Es ruft „ client.chat() “ mit „ MODEL_ID “ auf, während die Temperatur für eine deterministische Ausgabe niedrig gehalten wird, und „ response_format={"type": "json_schema",} “, damit die Antwort dem Schema entspricht. Zum Schluss versuchen wir, es mit „ json.loads “ zu analysieren.

Damit hast du jetzt einen soliden Ausgangspunkt, um ein rohes Diagramm oder einen Bericht in eine strukturierte Erzählung zu verwandeln.

Schritt 5: Erstellen der Streamlit-Benutzeroberfläche

Nachdem die Vorverarbeitungs-Pipeline und der Mistral-Client eingerichtet sind, musst du zum Schluss alles in eine Streamlit-Schnittstelle packen. 

st.set_page_config(
    page_title="Multimodal Intelligence Evaluation Hub - Mistral Large 3",
    layout="wide",
)
st.title("Multimodal Intelligence Evaluation Hub")
st.caption("Powered by **Mistral Large 3**")
col_left, col_right = st.columns([2, 1])
with col_left:
    uploaded_file = st.file_uploader(
        "Upload an image or report (PNG, JPG, WEBP, or PDF)",
        type=["png", "jpg", "jpeg", "webp", "pdf"],
    )
    default_prompt = (
        "Give me 3–5 key insights and risks from this input and export any tables you see as CSV "
        "Also write down the findings for a professional audience."
    )
    user_instruction = st.text_area(
        "Instruction to Mistral Large 3",
        value=default_prompt,
        height=120,
    )
with col_right:
    st.subheader("Multilingual Options")
    languages = st.multiselect(
        "Additional summary languages",
        options=["fr", "de", "es", "hi", "zh", "ja"],
        default=["hi"],
        help="Mistral Large 3 supports dozens of languages; these will receive short summaries.",
        label_visibility="collapsed",
    )
    run_button = st.button("Run Analysis", type="primary")
if run_button:
    if uploaded_file is None:
        st.error("Please upload an image or PDF first.")
        st.stop()
    prep_msg = "Preparing PDF (combining all pages)..." if uploaded_file.type == "application/pdf" else "Preparing image..."
    with st.spinner(prep_msg):
        mime_type, data_url = uploaded_file_to_square_base64(uploaded_file)
    mime, b64_part = data_url.split(",", 1)
    img_bytes = base64.b64decode(b64_part)
    st.image(img_bytes, caption="Center-cropped & resized image for the model", width=400)
    with st.spinner("Processing..."):
        try:
            result = call_mistral_large_multimodal(
                mime_type=mime_type,
                image_data_url=data_url,
                user_instruction=user_instruction,
                languages=languages,
            )
        except Exception as e:
            st.error(f"Error calling Mistral Large 3: {e}")
            st.stop()
    st.header("Results")
    csv_tables = result.get("csv_tables", [])
    if csv_tables:
        st.subheader("Reconstructed Tables (CSV)")
        for i, csv_str in enumerate(csv_tables):
            st.markdown(f"**Table {i+1}**")
            try:
                df = pd.read_csv(io.StringIO(csv_str))
                st.dataframe(df, use_container_width=True)
            except Exception:
                st.text_area(f"Raw CSV for Table {i+1}", value=csv_str, height=150)
            st.download_button(
                label=f"Download Table {i+1} as CSV",
                data=csv_str,
                file_name=f"table_{i+1}.csv",
                mime="text/csv",
                key=f"csv_download_{i}",
            )
    else:
        st.info("No tables were detected or reconstructed.")
    insights = result.get("insights", [])
    risks = result.get("risks", [])
    anomalies = result.get("anomalies", [])
    col_ins, col_risk = st.columns(2)
    with col_ins:
        st.subheader("Key Insights")
        if insights:
            for bullet in insights:
                st.markdown(f"- {bullet}")
        else:
            st.write("_No explicit insights returned._")
    with col_risk:
        st.subheader("Risks")
        if risks:
            for bullet in risks:
                st.markdown(f"- {bullet}")
        else:
            st.write("_No explicit risks returned._")
    st.subheader("Anomalies")
    if anomalies:
        for bullet in anomalies:
            st.markdown(f"- {bullet}")
    else:
        st.write("_No anomalies reported._")
    translations = result.get("translations", {}) or {}
    if translations:
        st.subheader(" Multilingual Summaries")
        for lang_code, summary in translations.items():
            with st.expander(f"Summary in {lang_code}"):
                st.write(summary)
    else:
        st.info("No multilingual summaries were requested or returned.")
    # Raw JSON (debug)
    # with st.expander(" Raw JSON (debug)"):
    #     st.json(result)

Der obige StreamLit-UI-Code macht ein paar wichtige Sachen:

Die Methode „ st.set_page_config “ teilt das Layout in zwei Spalten auf. Die linke Seite kümmert sich um die wichtigsten Eingaben (Datei-Uploader und ein bearbeitbarer Textbereich mit Standardanweisungen). Auf der anderen Seite gibt's auf der rechten Seite mehrsprachige Optionen über st.multiselect und einen Button „ -Laufanalyse durchführen”. Wenn du auf den Button klickst, checkt die App, ob eine Datei da ist, wandelt Bilder oder PDFs in eine Base64-Daten-URL um und zeigt dann das Vorschaubild an. 

Sobald ein Ergebnis da ist, werden die neu gemachten CSV-Tabellen als DataFrame angezeigt, zusammen mit Erkenntnissen, Risiken, Auffälligkeiten und mehrsprachigen Zusammenfassungen. Optional können wir auch Ansichten debuggen (auskommentiert), wodurch wir das rohe JSON während der Entwicklung überprüfen können.

Wenn du diesen Schritt erledigt hast, kannst du alles als „ app.py ” speichern und das ganze Erlebnis starten mit:

streamlit run app.py

Im folgenden Video siehst du eine gekürzte Version des Arbeitsablaufs mit Bild- und PDF-Eingaben: