Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Klienten MistralAzure i Python

Lektion 5 av 14 Uppdaterad 2 november 2026 Avancerad
På denna sida
  1. Kodning med MistralAzure
  2. Installation och konfiguration
  3. Chat-kompletteringar
  4. Strömning
  5. Asynkrona anrop
  6. Funktionsanrop
  7. Felhantering
  8. Mätning av förbrukning
  9. Viktiga punkter

Kodning med MistralAzure

Din Azure-slutpunkt är distribuerad och svarar; nu måste du skriva koden som använder den pålitligt. Denna lektion går igenom Python-klienten MistralAzure: initiering, de mönster du kommer att använda dagligen – enkla anrop, strömning, asynkron exekvering och funktionsanrop – samt de få specifika detaljer som skiljer Azure från det direkta API:t.

Installation och konfiguration

Uppdaterad 2 november 2026 — Mistral SDK 2 och senare. Sedan version 2.0 av Python-SDK:t (mars 2026) importeras Azure-klienten från mistralai.azure.client, och dess parametrar från version 1, azure_endpoint och azure_api_key, har bytts ut mot server_url och api_key. Koden i denna lektion följer den aktuella versionen (3.7.0, 1 november 2026). Källor: v2.0.0 release notes · Mistral on Azure.

Azure-klienten ingår i paketet mistralai; inga ytterligare beroenden krävs.

pip install mistralai

Initiering kräver två parametrar:

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-slutpunkts URL
  • api_key — Slutpunktens autentiseringsnyckel

En tredje, valfri parameter, api_version, har standardvärdet 2024-05-01-preview. SDK:t lägger automatiskt till detta som en URL-parameter i varje begäran.

Chat-kompletteringar

Härifrån speglar upplevelsen den vanliga klienten. Använd ett systemmeddelande för att definiera modellens roll, ett användarmeddelande för frågan, och läs svaret från choices[0].message.content.

response = client.chat.complete(
    model="azureai",
    messages=[
        {"role": "system", "content": "Du är en teknisk assistent specialiserad på Python."},
        {"role": "user", "content": "Hur implementerar jag en cache-dekorator?"}
    ]
)

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

Genereringsparametrar fungerar exakt som med det direkta Mistral-API:t. Om ett svar är för oförutsägbart eller utförligt, korrigera det här, inte i prompten.

response = client.chat.complete(
    model="azureai",
    messages=[
        {"role": "user", "content": "Skriv en haiku om molndatorer."}
    ],
    temperature=0.7,
    max_tokens=150,
    top_p=0.95
)
  • temperature — Styr kreativiteten (0,0 = deterministiskt, 1,0 = kreativt)
  • max_tokens — Begränsar svarslängden
  • top_p — Nukleus-sampling

Strömning

För svar som sträcker sig över flera hundra ord får användaren stirra på en frusen skärm i flera sekunder vid ett vanligt anrop. Strömning eliminerar denna upplevda väntan genom att visa texten i takt med att den genereras. Detta är standardläget närhelst ett mänskligt gränssnitt är inblandat.

stream = client.chat.stream(
    model="azureai",
    messages=[
        {"role": "user", "content": "Förklara hur en lastbalanserare fungerar."}
    ]
)

for chunk in stream:
    content = chunk.data.choices[0].delta.content
    if content:
        print(content, end="", flush=True)
print()  # Ny rad på slutet

Observera kontrollen if content: vissa chunkar anländer tomma och skulle skriva ut None på skärmen utan denna försiktighetsåtgärd.

Asynkrona anrop

I en webbserver – FastAPI, Django async – låser ett blockerande anrop en arbetare under hela genereringstiden, ofta flera sekunder per begäran. Den asynkrona klienten lämnar tillbaka kontrollen under väntan, vilket låter en enda process hantera dussintals samtidiga begäranden.

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

# Exekvering
result = asyncio.run(generate_response("Vad är Kubernetes?"))
print(result)

Funktionsanrop

Funktionsanrop fungerar identiskt med det direkta API:t. Du beskriver tillgängliga verktyg, modellen avgör om den ska anropa ett, och din kod exekverar faktiskt funktionen – modellen formulerar endast avsikten och argumenten.

import json

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Hämta vädret för en stad",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "Namn på staden"}
                },
                "required": ["city"]
            }
        }
    }
]

response = client.chat.complete(
    model="azureai",
    messages=[{"role": "user", "content": "Vad är vädret i Paris?"}],
    tools=tools,
    tool_choice="auto"
)

# Kontrollera om modellen vill anropa 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 anropad: {tool_call.function.name}")
    print(f"Argument: {args}")

Felhantering

I produktion återkommer tre familjer av fel, och de kräver olika åtgärder. En 429 signalerar en hastighetsbegränsning och kräver ett nytt försök med exponentiell backoff. En 401 indikerar en ogiltig eller utgången nyckel: att försöka igen är meningslöst, så misslyckas omedelbart med ett tydligt meddelande. En 404 pekar nästan alltid på en felaktigt konfigurerad variabel AZUREAI_ENDPOINT. Att skilja på dessa fall sparar dig från att spendera en timme på att felsöka ett stavfel i en URL.

import time
from mistralai.azure.client import MistralAzure

def robust_call(client, messages, max_retries=3):
    """Anrop med exponentiellt återförsök och felhantering."""
    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"Hastighetsbegränsning — försöker igen om {wait}s")
                time.sleep(wait)
            elif "401" in error_str:
                raise ValueError("Ogiltig eller utgången API-nyckel") from e
            elif "404" in error_str:
                raise ValueError("Slutpunkt hittades inte — kontrollera AZUREAI_ENDPOINT") from e
            else:
                if attempt == max_retries - 1:
                    raise
                time.sleep(1)
    raise RuntimeError("Misslyckades efter alla återförsök")

Mätning av förbrukning

Varje svar inkluderar ett usage-objekt som detaljerar förbrukade tokens. Läs detta systematiskt: det är det enda pålitliga måttet för att uppskatta kostnader och upptäcka en systemprompt som har blivit uppblåst av upprepade redigeringar.

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"Totalt tokens   : {usage.total_tokens}")

Viktiga punkter

  • Klienten MistralAzure fungerar som standardklienten, med model="azureai"
  • Strömning (chat.stream) rekommenderas för användargränssnitt
  • Asynkrona anrop (complete_async) är avgörande för webbserverar
  • Funktionsanrop och JSON-läge fungerar identiskt med det direkta API:t
  • Implementera alltid exponentiellt återförsök för att hantera 429-fel