Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Der MistralAzure-Client in Python

Lektion 5 von 14 Aktualisiert am 2. November 2026 Fortgeschritten
Auf dieser Seite
  1. Programmieren mit MistralAzure
  2. Installation und Konfiguration
  3. Chat-Vervollständigungen
  4. Streaming
  5. Asynchrone Aufrufe
  6. Funktionsaufrufe
  7. Fehlerbehandlung
  8. Verbrauch messen
  9. Kernaussagen

Programmieren mit MistralAzure

Ihr Azure-Endpunkt ist bereitgestellt und reagiert; nun müssen Sie den Code schreiben, der ihn zuverlässig nutzt. Diese Lektion erläutert den Python-Client MistralAzure: Initialisierung, die Muster, die Sie täglich verwenden werden – einfache Aufrufe, Streaming, asynchrone Ausführung und Funktionsaufrufe – sowie die wenigen Besonderheiten, die Azure von der direkten API unterscheiden.

Installation und Konfiguration

Aktualisiert am 2. November 2026 — Mistral SDK 2 und höher. Seit Version 2.0 des Python-SDK (März 2026) werden der Azure-Client aus mistralai.azure.client importiert, und die Parameter azure_endpoint und azure_api_key aus Version 1 wurden zu server_url und api_key. Der Code in dieser Lektion folgt der aktuellen Version (3.7.0, 1. November 2026). Quellen: Release Notes v2.0.0 · Mistral auf Azure.

Der Azure-Client ist im Paket mistralai enthalten; es sind keine zusätzlichen Abhängigkeiten erforderlich.

pip install mistralai

Die Initialisierung erfordert zwei Parameter:

import os
from mistralai.azure.client import MistralAzure

client = MistralAzure(
    server_url=os.environ["AZUREAI_ENDPOINT"],
    api_key=os.environ["AZUREAI_API_KEY"]
)
  • server_url — Ihre Azure-Endpunkt-URL
  • api_key — Der Authentifizierungsschlüssel des Endpunkts

Ein dritter, optionaler Parameter, api_version, standardisiert auf 2024-05-01-preview. Das SDK fügt diesen automatisch jedem Request als URL-Parameter hinzu.

Chat-Vervollständigungen

Ab hier gleicht die Erfahrung der Standard-Client. Verwenden Sie eine Systemnachricht, um die Rolle des Modells zu rahmen, eine Benutzernachricht für die Frage und lesen Sie die Antwort aus choices[0].message.content.

response = client.chat.complete(
    model="azureai",
    messages=[
        {"role": "system", "content": "Sie sind ein technischer Assistent, der sich auf Python spezialisiert."},
        {"role": "user", "content": "Wie implementiere ich einen Cache-Decorator?"}
    ]
)

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

Generierungsparameter verhalten sich exakt wie bei der direkten Mistral-API. Wenn eine Antwort zu unvorhersehbar oder ausufernd ist, korrigieren Sie dies hier, nicht im Prompt.

response = client.chat.complete(
    model="azureai",
    messages=[
        {"role": "user", "content": "Erstellen Sie ein Haiku über Cloud Computing."}
    ],
    temperature=0.7,
    max_tokens=150,
    top_p=0.95
)
  • temperature — Steuert die Kreativität (0,0 = deterministisch, 1,0 = kreativ)
  • max_tokens — Begrenzt die Antwortlänge
  • top_p — Nucleus-Sampling

Streaming

Bei Antworten, die mehrere hundert Wörter umfassen, lässt ein Standardaufruf den Benutzer für mehrere Sekunden auf einen eingefrorenen Bildschirm starren. Streaming eliminiert diese wahrgenommene Wartezeit, indem Text angezeigt wird, während er generiert wird. Dies ist der Standardmodus, sobald eine menschliche Schnittstelle involviert ist.

stream = client.chat.stream(
    model="azureai",
    messages=[
        {"role": "user", "content": "Erklären Sie, wie ein Lastenausgleich funktioniert."}
    ]
)

for chunk in stream:
    content = chunk.data.choices[0].delta.content
    if content:
        print(content, end="", flush=True)
print()  # Neue Zeile am Ende

Beachten Sie die if content-Prüfung: einige Pakete kommen leer an und würden ohne diese Vorsichtsmaßnahme None auf den Bildschirm drucken.

Asynchrone Aufrufe

In einem Webserver – FastAPI, Django async – bindet ein blockierender Aufruf einen Worker für die gesamte Generierungsdauer, oft mehrere Sekunden pro Request. Der asynchrone Client gibt die Kontrolle während der Wartezeit ab, sodass ein einzelner Prozess Dutzende gleichzeitige Requests bearbeiten kann.

import asyncio
from mistralai.azure.client import MistralAzure

client = MistralAzure(
    server_url=os.environ["AZUREAI_ENDPOINT"],
    api_key=os.environ["AZUREAI_API_KEY"]
)

async def generate_response(prompt: str) -> str:
    response = await client.chat.complete_async(
        model="azureai",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

# Ausführung
result = asyncio.run(generate_response("Was ist Kubernetes?"))
print(result)

Funktionsaufrufe

Funktionsaufrufe verhalten sich identisch zur direkten API. Sie beschreiben verfügbare Tools, das Modell entscheidet, ob eines aufgerufen werden soll, und Ihr Code führt die Funktion tatsächlich aus – das Modell formuliert lediglich die Absicht und Argumente.

import json

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Holen Sie sich das Wetter für eine Stadt",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "Name der Stadt"}
                },
                "required": ["city"]
            }
        }
    }
]

response = client.chat.complete(
    model="azureai",
    messages=[{"role": "user", "content": "Wie ist das Wetter in Paris?"}],
    tools=tools,
    tool_choice="auto"
)

# Prüfen, ob das Modell einen Funktionsaufruf wünscht
if response.choices[0].message.tool_calls:
    tool_call = response.choices[0].message.tool_calls[0]
    args = json.loads(tool_call.function.arguments)
    print(f"Funktion aufgerufen: {tool_call.function.name}")
    print(f"Argumente: {args}")

Fehlerbehandlung

In der Produktion treten drei Familien von Fehlern wiederholt auf, und sie erfordern unterschiedliche Reaktionen. Ein 429 signalisiert ein Rate-Limit und erfordert einen Retry mit exponentiellem Backoff. Ein 401 zeigt einen ungültigen oder abgelaufenen Schlüssel an: Ein Retry ist nutzlos, daher sofort mit einer klaren Meldung versagen. Ein 404 weist fast immer auf eine falsch konfigurierte Umgebungsvariable AZUREAI_ENDPOINT hin. Das Unterscheiden dieser Fälle spart Ihnen eine Stunde Debuggen wegen eines Tippfehlers in einer URL.

import time
from mistralai.azure.client import MistralAzure

def robust_call(client, messages, max_retries=3):
    """Aufruf mit exponentiellem Retry und Fehlerbehandlung."""
    for attempt in range(max_retries):
        try:
            return client.chat.complete(
                model="azureai",
                messages=messages
            )
        except Exception as e:
            error_str = str(e)
            if "429" in error_str:
                wait = 2 ** attempt
                print(f"Rate limit — Retry in {wait}s")
                time.sleep(wait)
            elif "401" in error_str:
                raise ValueError("Ungültiger oder abgelaufener API-Schlüssel") from e
            elif "404" in error_str:
                raise ValueError("Endpunkt nicht gefunden — prüfen Sie AZUREAI_ENDPOINT") from e
            else:
                if attempt == max_retries - 1:
                    raise
                time.sleep(1)
    raise RuntimeError("Fehler nach allen Retries")

Verbrauch messen

Jede Antwort enthält ein usage-Objekt, das verbrauchte Tokens detailliert. Lesen Sie dies systematisch: Es ist das einzige zuverlässige Maß zur Kostenschätzung und zum Erkennen eines Systemprompts, der durch wiederholte Änderungen aufgebläht wurde.

response = client.chat.complete(
    model="azureai",
    messages=[{"role": "user", "content": "Hallo"}]
)

usage = response.usage
print(f"Prompt-Tokens  : {usage.prompt_tokens}")
print(f"Antwort-Tokens: {usage.completion_tokens}")
print(f"Gesamt-Tokens  : {usage.total_tokens}")

Kernaussagen

  • Der MistralAzure-Client funktioniert wie der Standard-Client, unter Verwendung von model="azureai"
  • Streaming (chat.stream) wird für Benutzerschnittstellen empfohlen
  • Asynchrone Aufrufe (complete_async) sind für Webserver unerlässlich
  • Funktionsaufrufe und JSON-Modus funktionieren identisch zur direkten API
  • Implementieren Sie immer exponentielle Retries, um 429-Fehler zu bewältigen