Spring til hovedindhold
Dansk— Vælg et sprog
Menu

MistralAzure-klienten i Python

Lektion 5 af 14 Opdateret 2. november 2026 Avanceret
På denne side
  1. Kodning med MistralAzure
  2. Installation og konfiguration
  3. Chat-fuldførelser
  4. Streaming
  5. Asynkrone kald
  6. Funktionskald
  7. Håndtering af fejl
  8. Måling af forbrug
  9. Vigtige pointer

Kodning med MistralAzure

Dit Azure-endpoint er deployet og svarer; nu skal du skrive den kode, der bruger det pålideligt. Denne lektion gennemgår Python-klienten MistralAzure: initialisering, de mønstre du bruger dagligt – enkle kald, streaming, asynkron eksekvering og funktionskald – samt de få specifikke detaljer, der adskiller Azure fra det direkte API.

Installation og konfiguration

Opdateret 2. november 2026 — Mistral SDK 2 og nyere. Siden version 2.0 af Python-SDK’et (marts 2026) importeres Azure-klienten fra mistralai.azure.client, og dens version 1-parametre azure_endpoint og azure_api_key er blevet til server_url og api_key. Koden i denne lektion følger den aktuelle version (3.7.0, 1. november 2026). Kilder: v2.0.0 udgivelsesnoter · Mistral på Azure.

Azure-klienten er inkluderet i pakken mistralai; der kræves ingen yderligere afhængigheder.

pip install mistralai

Initialisering kræver to parametre:

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 — Din Azure-endpoint-URL
  • api_key — Endpointets godkendelsesnøgle

En tredje, valgfri parameter, api_version, har standardværdien 2024-05-01-preview. SDK’et tilføjer automatisk denne værdi som en URL-parameter til hver anmodning.

Chat-fuldførelser

Herfra ligner oplevelsen standardklienten. Brug en systembesked til at definere modellens rolle, en brugerbesked til spørgsmålet, og læs svaret fra choices[0].message.content.

response = client.chat.complete(
    model="azureai",
    messages=[
        {"role": "system", "content": "Du er en teknisk assistent specialiseret i Python."},
        {"role": "user", "content": "Hvordan implementerer jeg en cache-dekoratør?"}
    ]
)

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

Genereringsparametre opfører sig præcis som med det direkte Mistral-API. Hvis et svar er for uforudsigeligt eller verbost, skal du rette det her, ikke i prompten.

response = client.chat.complete(
    model="azureai",
    messages=[
        {"role": "user", "content": "Skriv et haiku om cloud computing."}
    ],
    temperature=0.7,
    max_tokens=150,
    top_p=0.95
)
  • temperature — Styrer kreativiteten (0,0 = deterministisk, 1,0 = kreativ)
  • max_tokens — Begrænser svarlængden
  • top_p — Nucleus-sampling

Streaming

Ved svar på flere hundrede ord vil et almindeligt kald få brugeren til at stirre på en frossen skærm i flere sekunder. Streaming eliminerer denne oplevede ventetid ved at vise tekst, efterhånden som den genereres. Dette er standardtilstanden, når der er involveret en menneskelig grænseflade.

stream = client.chat.stream(
    model="azureai",
    messages=[
        {"role": "user", "content": "Forklar, hvordan en load balancer fungerer."}
    ]
)

for chunk in stream:
    content = chunk.data.choices[0].delta.content
    if content:
        print(content, end="", flush=True)
print()  # Ny linje til sidst

Bemærk if content-tjekket: nogle chunks ankommer tomme og ville uden denne forholdsregel udskrive None på skærmen.

Asynkrone kald

I en webserver – FastAPI, Django async – vil et blokerende kald binde en worker i hele genereringens varighed, ofte flere sekunder per anmodning. Den asynkrone klient afgiver kontrollen under ventetiden, hvilket tillader en enkelt proces at håndtere dusinvis af samtidige anmodninger.

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

# Eksekvering
result = asyncio.run(generate_response("Hvad er Kubernetes?"))
print(result)

Funktionskald

Funktionskald opfører sig identisk med det direkte API. Du beskriver tilgængelige værktøjer, modellen beslutter, om den skal kalde ét, og din kode udfører faktisk funktionen – modellen formulerer kun hensigten og argumenterne.

import json

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Hent vejret for en by",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "Byens navn"}
                },
                "required": ["city"]
            }
        }
    }
]

response = client.chat.complete(
    model="azureai",
    messages=[{"role": "user", "content": "Hvad er vejret i Paris?"}],
    tools=tools,
    tool_choice="auto"
)

# Tjek om modellen ønsker at kalde en funktion
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 kaldt: {tool_call.function.name}")
    print(f"Argumenter: {args}")

Håndtering af fejl

I produktion genoptræder tre fejltyper, og de kræver forskellige responser. En 429 signalerer en rate-begrænsning og kræver et genforsøg med eksponentiel backoff. En 401 indikerer en ugyldig eller udløbet nøgle: det er nytteløst at forsøge igen, så fejlen skal kastes øjeblikkeligt med en klar besked. En 404 peger næsten altid på en forkert konfigureret variabel AZUREAI_ENDPOINT. At skelne mellem disse tilfælde sparer dig for at bruge en time på at fejlfinde en tastefejl i en URL.

import time
from mistralai.azure.client import MistralAzure

def robust_call(client, messages, max_retries=3):
    """Kald med eksponentielt genforsøg og fejlhåndtering."""
    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-begrænsning — forsøger igen om {wait}s")
                time.sleep(wait)
            elif "401" in error_str:
                raise ValueError("Ugyldig eller udløbet API-nøgle") from e
            elif "404" in error_str:
                raise ValueError("Endpoint ikke fundet – tjek AZUREAI_ENDPOINT") from e
            else:
                if attempt == max_retries - 1:
                    raise
                time.sleep(1)
    raise RuntimeError("Mislykkedes efter alle genforsøg")

Måling af forbrug

Hvert svar indeholder et usage-objekt, der detaljerer de forbrugte tokens. Læs dette systematisk: det er det eneste pålidelige mål til at estimere omkostninger og opdage en system-prompt, der er blevet oppustet af gentagne redigeringer.

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

usage = response.usage
print(f"Prompt-tokens   : {usage.prompt_tokens}")
print(f"Svar-tokens     : {usage.completion_tokens}")
print(f"I alt tokens    : {usage.total_tokens}")

Vigtige pointer

  • Klienten MistralAzure fungerer som standardklienten ved brug af model="azureai"
  • Streaming (chat.stream) anbefales til brugergrænseflader
  • Asynkrone kald (complete_async) er essentielle for webservere
  • Funktionskald og JSON-tilstand fungerer identisk med det direkte API
  • Implementér altid eksponentielt genforsøg for at håndtere 429-fejl