Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Codestral API in Python

Lektion 3 von 14 Aktualisiert am 2. November 2026 Entwickler
Auf dieser Seite
  1. Aufruf von Codestral aus Python
  2. Installation und Konfiguration
  3. Vollständiger FIM-Aufruf
  4. Chat-Aufruf für Code-Generierung
  5. Fortgeschrittene Parameter
  6. Zwei Muster zum Kopieren und Einfügen
  7. Fehlerbehandlung
  8. Kernaussagen

Aufruf von Codestral aus Python

In dieser Lektion wechseln wir von der Theorie zur ausführbaren Code-Implementierung. Sie werden das Mistral AI Python SDK verwenden, um Codestral über seine beiden Endpunkte abzufragen, die fortgeschrittenen Parameter einzustellen, die einen nützlichen Vorschlag von einem ausschweifenden unterscheiden, und die Muster umzusetzen, die in den meisten realen Integrationen zu finden sind.

Installation und Konfiguration

Installieren Sie das SDK mit einem einzigen Befehl:

pip install mistralai

Rufen Sie Ihren API-Schlüssel von console.mistral.ai ab und lesen Sie ihn aus der Umgebungsvariable, statt ihn hartcodiert in Ihre Datei einzufügen:

import os
from mistralai.client import Mistral

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

Zwei Plattformen bieten Codestral an, und Sie wählen zwischen ihnen, wenn Sie Ihren Schlüssel erstellen. api.mistral.ai arbeitet nach dem Pay-per-Use-Prinzip mit nutzungsbasierter Abrechnung: Dies ist der Standardweg, wenn Codestral nur ein Baustein unter vielen in einer Anwendung ist. codestral.mistral.ai ist ein dedizierter Endpunkt, der kostenlos oder über ein Abo zugänglich ist und für die direkte Nutzung durch einen Entwickler innerhalb seines Editors konzipiert wurde.

Vollständiger FIM-Aufruf

Hier ist ein detaillierter FIM-Aufruf mit allen wichtigen Parametern:

from mistralai.client import Mistral

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

response = client.fim.complete(
    model="codestral-latest",
    prompt="def calculate_vat(price_excl: float, rate: float = 0.20) -> float:",
    suffix="price = float(input('Price excl. VAT: '))\nprint(f'Price incl. VAT: {calculate_vat(price):.2f} EUR')",
    temperature=0,
    max_tokens=150,
    stop=["\n\n"],
)

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

Analyse der Antwort

Das zurückgegebene Objekt enthält mehr als nur den generierten Text. In der Produktion sollten Sie systematisch drei Informationen prüfen: die Completion selbst, den Tokenverbrauch, der Ihre Abrechnung bestimmt, und den Stop-Grund, der Ihnen mitteilt, ob das Modell natürlich abgeschlossen hat oder Ihr Limit erreicht hat.

# Zugriff auf die generierte Completion
text = response.choices[0].message.content

# Prüfung der verbrauchten Token
tokens_prompt = response.usage.prompt_tokens
tokens_completion = response.usage.completion_tokens
tokens_total = response.usage.total_tokens

# Prüfung des Stop-Grundes
reason = response.choices[0].finish_reason  # "stop", "length", etc.

Ein finish_reason von "length" bei der Hälfte Ihrer Aufrufe ist ein klares Signal: Ihr max_tokens ist zu niedrig, und Sie liefern Ihren Nutzern abgeschnittenen Code.

Chat-Aufruf für Code-Generierung

Sobald kein Cursor mitten in einer Datei vorhanden ist – beispielsweise für die vollständige Generierung, Erklärung oder Refaktorierung – übernimmt das Chat-Endpunkt. Die Systemnachricht rahmt das Ausgabeformat ein, wodurch der Bedarf an einer nachträglichen Bereinigung der Antwort entfällt:

response = client.chat.complete(
    model="codestral-latest",
    messages=[
        {
            "role": "system",
            "content": "You are an expert Python development assistant. Respond with code only, no explanations."
        },
        {
            "role": "user",
            "content": "Write a Python function that validates an email address using regex."
        }
    ],
    temperature=0.2,
    max_tokens=500,
)

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

Fortgeschrittene Parameter

Das Paar min_tokens / max_tokens rahmt die Ausgabelänge ein. Der untere Wert (Floor) ist nützlich, wenn Sie einen Block generieren, der Sie wissen, dass er nicht kürzer als ein bestimmtes Volumen sein kann, wie beispielsweise eine Funktion mit ihrer Fehlerbehandlung.

# min_tokens: erzwingt eine minimale Ausgabelänge
# max_tokens: begrenzt die maximale Länge
response = client.fim.complete(
    model="codestral-latest",
    prompt=prompt,
    suffix=suffix,
    min_tokens=20,
    max_tokens=300,
)

Stop-Tokens spielen eine andere Rolle: Sie unterbrechen die Generierung bei einem bestimmten Muster und halten die Completion im Rahmen der aktuellen Funktion, anstatt das Modell dazu zu bringen, in die nächste zu wechseln.

# Generierung bei spezifischen Mustern stoppen
response = client.fim.complete(
    model="codestral-latest",
    prompt=prompt,
    suffix=suffix,
    stop=["\n\n", "\nclass ", "\ndef "],  # Stoppt vor einer neuen Funktion/Klasse
)

Schließlich regelt die Temperatur die Variabilität. Bei 0 liefert dieselbe Eingabe immer dieselbe Ausgabe, was für die Autovervollständigung erforderlich ist. Bei ca. 0.3 schlägt das Modell Varianten vor, was interessant ist, wenn mehrere Vorschläge angezeigt werden sollen. Bei 0.7 befinden Sie sich im Modus des Code-Brainstormings, was nützlich ist, um einen Ansatz zu erkunden, aber für einen Bearbeitungsfluss ungeeignet ist.

# temperature=0: deterministisch (Autovervollständigung)
# temperature=0.3: leicht kreativ (mehrere Vorschläge)
# temperature=0.7: kreativ (Code-Brainstorming)

response = client.fim.complete(
    model="codestral-latest",
    prompt=prompt,
    suffix=suffix,
    temperature=0.3,
    top_p=0.95,
)

Zwei Muster zum Kopieren und Einfügen

Das erste reproduziert das IDE-Verhalten: Sie teilen den Dateiinhalte an der Cursorposition auf, und die beiden Hälften werden zum Prompt und zum Suffix.

def autocomplete_ide(file_content: str, cursor_position: int) -> str:
    """Simulates IDE auto-completion with Codestral FIM."""
    prompt = file_content[:cursor_position]
    suffix = file_content[cursor_position:]

    response = client.fim.complete(
        model="codestral-latest",
        prompt=prompt,
        suffix=suffix,
        temperature=0,
        max_tokens=100,
        stop=["\n\n", "\ndef ", "\nclass "],
    )

    return response.choices[0].message.content

Das zweite automatisiert die Dokumentation für ein bestehendes Projekt: Sie übergeben eine Funktion, rufen deren Docstring ab, und die Systemanweisung erzwingt ein einheitliches Format, sodass das Ergebnis ohne weitere Bearbeitung eingefügt werden kann.

def generate_docstring(function_code: str) -> str:
    """Generates a docstring for a Python function."""
    response = client.chat.complete(
        model="codestral-latest",
        messages=[
            {
                "role": "system",
                "content": "Generate a Google-style docstring for the following function. Return ONLY the docstring between triple quotes."
            },
            {
                "role": "user",
                "content": function_code
            }
        ],
        temperature=0,
        max_tokens=300,
    )
    return response.choices[0].message.content

Fehlerbehandlung

Ein Netzwerkaufruf wird früher oder später fehlschlagen, und eine Editor-Erweiterung, die bei einem Validierungsfehler abstürzt, ist schlimmer als eine Erweiterung ohne Vervollständigung. Daher sollten Sie Ihre Aufrufe immer einhüllen:

from mistralai.client import Mistral
from mistralai.client.errors import HTTPValidationError

try:
    response = client.fim.complete(
        model="codestral-latest",
        prompt=prompt,
        suffix=suffix,
    )
except HTTPValidationError as e:
    print(f"Validation error: {e}")
except Exception as e:
    print(f"Unexpected error: {e}")

Kernaussagen

  • Das SDK mistralai stellt client.fim.complete() für FIM und client.chat.complete() für Chat bereit.
  • Die Parameter prompt und suffix sind spezifisch für den FIM-Endpunkt.
  • Verwenden Sie temperature=0 für die Autovervollständigung und 0.2-0.7 für kreative Generierung.
  • stop begrenzt die Generierung auf einen kohärenten Code-Block.
  • min_tokens und max_tokens steuern die Ausgabelänge.
  • Behandeln Sie HTTP-Fehler in Produktionscode immer.