Die richtige Anstrengungsstufe für das Nachdenken wählen

Lektion am 2. November 2026 überarbeitet. Sie verglich zuvor die „anpassbare” Nachdenkfähigkeit von Mistral Small mit die „native” von Magistral, doch Magistral wurde am 31. Juli 2026 eingestellt. Die Wahl liegt nun zwischen Generalistenmodellen und reasoning_effort-Stufen. Quellen: Nachdenken · Small 4 und Large 4 Modellkarten.

Zwei Regler statt einer Modellpalette

Die Wahl eines Nachdenkmodells bei Mistral bedeutete früher die Auswahl zwischen zwei getrennten Modellsammlungen. Heute bedeutet es das Einstellen zweier Regler: das Modell (Small 4 für die meisten Aufgaben, Large 4 für die schwierigsten Fälle) und die Anstrengungsstufe (none oder high bei Small 4; low, medium oder high bei Large 4). Eine einzelne Anwendung kann und sollte häufig mehrere Kombinationen nutzen.

Die Entscheidungsmatrix

Diese Matrix bietet Startpunkte, keine absoluten Wahrheiten: Ihre eigenen Evaluierungen entscheiden. Denken Sie auch daran, dass Large 4 ab dem 2. November 2026 in der öffentlichen Vorschau (Public Preview) verfügbar ist.

Berechnen Sie vor dem Skalieren

Die aufgeführten Preise (pro Million Token, aufgezeichnet am 2. November 2026) ermöglichen es Ihnen, die Kosten einer Einstellung aus dem usage-Feld in den Antworten zu schätzen:

RATES = {  # USD pro Million Token: (Eingabe, Ausgabe)
    "mistral-small-2603": (0.15, 0.60),
    "mistral-large-4-0": (0.70, 2.10),
    "mistral-medium-3-5": (1.50, 7.50),   # veraltet, Einstellung am 30. April 2027
}

def cost(response, model):
    """Kosten einer Antwort, einschließlich Nachdenken (ohne Rabatte für Caches)."""
    input_rate, output_rate = RATES[model]
    u = response.usage
    return (u.prompt_tokens * input_rate + u.completion_tokens * output_rate) / 1_000_000

Addieren Sie diese Kosten pro Anforderungstyp über einige Tage des echten Datenverkehrs: diese Zahl zeigt Ihnen, ob eine generalisierte high-Einstellung nachhaltig ist.

Eine Routing-Architektur

In einer echten Anwendung sind die meisten Anfragen einfach. Das Bezahlen für Nachdenken bei diesen Anfragen bringt keinen Mehrwert. Der folgende Router fragt zunächst Small 4 ohne Nachdenken ab, um die Komplexität der Frage zu schätzen, und leitet die Anfrage dann an die entsprechende Einstellung weiter:

import os
from mistralai.client import Mistral

class ReasoningRouter:
    """Leitet jede Frage an ein Modell und eine Anstrengungsstufe weiter."""

    def __init__(self):
        self.client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

    def complexity(self, question):
        r = self.client.chat.complete(
            model="mistral-small-2603",
            messages=[{"role": "user", "content":
                f"Bewerten Sie die Komplexität dieser Frage von 0 bis 10. Antworten Sie nur mit der Zahl: {question}"}],
            reasoning_effort="none",
        )
        try:
            return min(max(int(str(r.choices[0].message.content).strip()), 0), 10)
        except ValueError:
            return 5  # konservativer Wert, falls die Antwort keine Zahl ist

    def respond(self, question, system_prompt=None):
        score = self.complexity(question)
        if score <= 3:
            model, level = "mistral-small-2603", "none"
        elif score <= 7:
            model, level = "mistral-small-2603", "high"
        else:
            model, level = "mistral-large-4-0", "high"
        messages = [{"role": "system", "content": system_prompt}] if system_prompt else []
        messages.append({"role": "user", "content": question})
        return self.client.chat.complete(model=model, messages=messages, reasoning_effort=level)

Der Klassifizierungsaufruf kostet wenig: ein paar Dutzend Token auf dem günstigsten Modell, ohne Nachdenken. Passen Sie die Schwellenwerte nach Beobachtung an, indem Sie die Qualität und die Kosten jeder Verzweigung vergleichen.

Best Practices für die Produktion

Nutzungsdaten pro Verzweigung protokollieren. Speichern Sie für jede Antwort das Modell, die Stufe, usage.prompt_tokens, usage.completion_tokens und die oben berechneten Kosten. Ohne diese Zahlen können Sie nicht feststellen, ob sich Nachdenken lohnt.

Datumsgebundene Identifikatoren festlegen. Verwenden Sie in der Produktion mistral-small-2603 statt mistral-small-latest: ein Alias kann sich auf eine neue Version umschalten, ohne dass Ihr Code geändert werden muss. Zentralisieren Sie diese Identifikatoren in einer einzigen Konfiguration.

MODELS = {
    "fast": ("mistral-small-2603", "none"),
    "reasoning": ("mistral-small-2603", "high"),
    "deep": ("mistral-large-4-0", "high"),
}

Planen Sie eine Fallback-Lösung. Da Large 4 in der öffentlichen Vorschau ist, schützt ein Fallback auf Small 4 im high-Modus Ihre Anwendung, falls der Aufruf fehlschlägt. Alle SDK-HTTP-Fehler leiten von MistralError ab:

from mistralai.client import errors

def query_with_fallback(client, messages):
    try:
        return client.chat.complete(model="mistral-large-4-0", messages=messages, reasoning_effort="high")
    except errors.MistralError:
        return client.chat.complete(model="mistral-small-2603", messages=messages, reasoning_effort="high")

Achten Sie auf Verfallsdaten. Die Mistral-Modellseite listet Verfalls- und Einstellungstermine auf. Medium 3.5 wird am 30. April 2027 eingestellt: Wenn Sie es verwenden, ist das Datum bereits festgelegt.

Kurzzusammenfassung

Nachdenken gibt dem Modell einen Raum zum Überlegen, bevor es antwortet; bei Mistral konfigurieren Sie dies pro Anfrage mit reasoning_effort, dessen Werte vom Modell abhängen. Die Antwort kommt dann als Fragmente an – Überlegung und Antwort –, die Sie lesen müssen, auch im Streaming-Modus, und für mehrstufige Gespräche vollständig wiedergeben. Agenten und die Conversations-API tragen die gleiche Einstellung in completion_args. Magistral ist eingestellt: Small 4 und Large 4 übernehmen, wobei Medium 3.5 nur als Übergangsschritt dient. Schließlich ist Nachdenken dort gerechtfertigt, wo es Wege zu erkunden und Fehler zu fangen gibt (Mathematik, Code, Entscheidungen), und es muss immer gemessen werden: Qualität, Token, Latenz.

Wichtige Erkenntnisse

• Zwei Regler: das Modell (Small 4, Large 4) und die reasoning_effort-Stufe
• Small 4 im none-Modus für einfache Aufgaben, im high-Modus für mehrstufige; Large 4 für die schwierigsten Fälle
• Berechnen Sie jede Einstellung aus usage und offiziellen Preisen, bevor Sie sie skalieren
• Ein Router reserviert Nachdenken für Anfragen, die davon profitieren
• In der Produktion: datumsgebundene Identifikatoren, Protokollierung der Nutzung, Fallback von Large 4 auf Small 4

Testen Sie Ihr Wissen

Fünf Fragen, um die wesentlichen Inhalte des Kurses zu validieren.