Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

De MistralAzure-client in Python

Les 5 van 14 Bijgewerkt op 2 november 2026 Gevorderd
Op deze pagina
  1. Programmeren met MistralAzure
  2. Installatie en configuratie
  3. Chat-voltooiingen
  4. Streaming
  5. Asynchrone aanroepen
  6. Functieaanroepen
  7. Foutafhandeling
  8. Verbruik meten
  9. Belangrijkste punten

Programmeren met MistralAzure

Uw Azure-eindpunt is geïmplementeerd en reageert; nu moet u de code schrijven om dit betrouwbaar te gebruiken. Deze les behandelt de Python MistralAzure-client: initialisatie, de patronen die u dagelijks zult gebruiken—eenvoudige aanroepen, streaming, asynchrone uitvoering en functieaanroepen—en de specifieke details die Azure onderscheiden van de directe API.

Installatie en configuratie

Bijgewerkt op 2 november 2026 — Mistral SDK 2 en later. Sinds versie 2.0 van de Python-SDK (maart 2026) wordt de Azure-client geïmporteerd vanuit mistralai.azure.client, en zijn de parameters azure_endpoint en azure_api_key uit versie 1 veranderd in server_url en api_key. De code in deze les volgt de huidige versie (3.7.0, 1 november 2026). Bronnen: v2.0.0 release notes · Mistral on Azure.

De Azure-client is opgenomen in het mistralai-pakket; er zijn geen extra afhankelijkheden vereist.

pip install mistralai

Initialisatie vereist twee parameters:

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 — De URL van uw Azure-eindpunt
  • api_key — De authenticatiesleutel van het eindpunt

Een derde, optionele parameter, api_version, staat standaard op 2024-05-01-preview. De SDK voegt dit automatisch als URL-parameter toe aan elk verzoek.

Chat-voltooiingen

Vanaf hier komt de ervaring overeen met die van de standaardclient. Gebruik een systeembericht om de rol van het model te definiëren, een gebruikersbericht voor de vraag, en lees het antwoord uit choices[0].message.content.

response = client.chat.complete(
    model="azureai",
    messages=[
        {"role": "system", "content": "Je bent een technische assistent gespecialiseerd in Python."},
        {"role": "user", "content": "Hoe implementeer ik een cache-decorator?"}
    ]
)

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

Generatieparameters gedragen zich exact zoals bij de directe Mistral API. Als een reactie te onvoorspelbaar of uitgebreid is, corrigeert u dit hier, niet in de prompt.

response = client.chat.complete(
    model="azureai",
    messages=[
        {"role": "user", "content": "Genereer een haiku over cloudcomputing."}
    ],
    temperature=0.7,
    max_tokens=150,
    top_p=0.95
)
  • temperature — Regelt de creativiteit (0,0 = deterministisch, 1,0 = creatief)
  • max_tokens — Beperkt de lengte van het antwoord
  • top_p — Nucleus-sampling

Streaming

Bij antwoorden van enkele honderden woorden laat een standaardoproep de gebruiker enkele seconden naar een bevroren scherm staren. Streaming elimineert deze waargenomen wachttijd door tekst weer te geven terwijl deze wordt gegenereerd. Dit is de standaardmodus wanneer er sprake is van een menselijke interface.

stream = client.chat.stream(
    model="azureai",
    messages=[
        {"role": "user", "content": "Leg uit hoe een load balancer werkt."}
    ]
)

for chunk in stream:
    content = chunk.data.choices[0].delta.content
    if content:
        print(content, end="", flush=True)
print()  # Nieuwe regel aan het einde

Let op de if content-controle: sommige chunks komen leeg aan en zouden zonder deze voorzorgsmaatregel None op het scherm afdrukken.

Asynchrone aanroepen

In een webserver—FastAPI, Django async—blokkeert een synchrone aanroep een worker voor de volledige generatieduur, vaak enkele seconden per verzoek. De asynchrone client geeft de controle terug tijdens het wachten, waardoor één proces tientallen gelijktijdige verzoeken kan afhandelen.

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

# Uitvoering
result = asyncio.run(generate_response("Wat is Kubernetes?"))
print(result)

Functieaanroepen

Functieaanroepen gedragen zich identiek aan de directe API. U beschrijft beschikbare tools, het model beslist of er een wordt aangeroepen, en uw code voert de functie daadwerkelijk uit—het model formuleert alleen de intentie en de argumenten.

import json

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Haal het weer op voor een stad",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "Naam van de stad"}
                },
                "required": ["city"]
            }
        }
    }
]

response = client.chat.complete(
    model="azureai",
    messages=[{"role": "user", "content": "Wat is het weer in Parijs?"}],
    tools=tools,
    tool_choice="auto"
)

# Controleer of het model een functie wil aanroepen
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"Functie aangeroepen: {tool_call.function.name}")
    print(f"Argumenten: {args}")

Foutafhandeling

In productie komen drie soorten fouten regelmatig terug, en ze vereisen verschillende reacties. Een 429 signaleert een tarieflimiet en vereist een nieuwe poging met exponentiële backoff. Een 401 duidt op een ongeldige of verlopen sleutel: opnieuw proberen is nutteloos, dus faal direct met een duidelijke melding. Een 404 wijst bijna altijd op een verkeerd geconfigureerde AZUREAI_ENDPOINT-variabele. Het onderscheiden van deze gevallen bespaart u een uur debuggen van een typefout in een URL.

import time
from mistralai.azure.client import MistralAzure

def robust_call(client, messages, max_retries=3):
    """Aanroep met exponentiële retry en foutafhandeling."""
    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"Tarieflimiet — opnieuw proberen over {wait}s")
                time.sleep(wait)
            elif "401" in error_str:
                raise ValueError("Ongeldige of verlopen API-sleutel") from e
            elif "404" in error_str:
                raise ValueError("Eindpunt niet gevonden — controleer AZUREAI_ENDPOINT") from e
            else:
                if attempt == max_retries - 1:
                    raise
                time.sleep(1)
    raise RuntimeError("Mislukt na alle pogingen")

Verbruik meten

Elk antwoord bevat een usage-object met details over de verbruikte tokens. Lees dit systematisch: het is de enige betrouwbare maatstaf om kosten te schatten en een systeemprompt te signaleren die door herhaalde bewerkingen is opgeblazen.

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

usage = response.usage
print(f"Prompt-tokens  : {usage.prompt_tokens}")
print(f"Antwoord-tokens: {usage.completion_tokens}")
print(f"Totaal tokens  : {usage.total_tokens}")

Belangrijkste punten

  • De MistralAzure-client werkt net als de standaardclient, met model="azureai"
  • Streaming (chat.stream) wordt aanbevolen voor gebruikersinterfaces
  • Asynchrone aanroepen (complete_async) zijn essentieel voor webservers
  • Functieaanroepen en JSON-modus werken identiek aan de directe API
  • Implementeer altijd exponentiële retry om 429-fouten af te handelen