Salt la conținutul principal
Română— Alege o limbă
Meniu

Clientul MistralAzure în Python

Lecția 5 din 14 Actualizată 2 noiembrie 2026 Avansat
Pe această pagină
  1. Programarea cu MistralAzure
  2. Instalare și Configurare
  3. Completări de Chat
  4. Streaming
  5. Apeluri Asincrone
  6. Apelarea de Funcții
  7. Gestionarea Erorilor
  8. Măsurarea Consumului
  9. Puncte cheie

Programarea cu MistralAzure

Endpoint-ul dumneavoastră Azure este implementat și răspunde; acum trebuie să scrieți codul care îl va utiliza în mod fiabil. Această lecție detaliază clientul Python MistralAzure: inițializarea, tiparele pe care le veți utiliza zilnic—apeluri simple, streaming, execuție asincronă și apelarea de funcții—precum și câteva specificități care disting Azure de API-ul direct.

Instalare și Configurare

Actualizat la 2 noiembrie 2026 — Mistral SDK 2 și versiuni ulterioare. Începând cu versiunea 2.0 a SDK-ului Python (martie 2026), clientul Azure se importă din mistralai.azure.client, iar parametrii săi din versiunea 1, azure_endpoint și azure_api_key, au devenit server_url și api_key. Codul din această lecție urmează versiunea curentă (3.7.0, 1 noiembrie 2026). Surse: Notele de lansare v2.0.0 · Mistral pe Azure.

Clientul Azure este inclus în pachetul mistralai; nu sunt necesare dependențe suplimentare.

pip install mistralai

Inițializarea necesită doi parametri:

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 — URL-ul endpoint-ului dumneavoastră Azure
  • api_key — Cheia de autentificare a endpoint-ului

Un al treilea parametru opțional, api_version, are valoarea implicită 2024-05-01-preview. SDK-ul adaugă automat acest lucru la fiecare cerere ca parametru URL.

Completări de Chat

De aici, experiența este identică cu cea a clientului standard. Utilizați un mesaj de sistem pentru a defini rolul modelului, un mesaj de utilizator pentru întrebare și citiți răspunsul din choices[0].message.content.

response = client.chat.complete(
    model="azureai",
    messages=[
        {"role": "system", "content": "Ești un asistent tehnic specializat în Python."},
        {"role": "user", "content": "Cum implementez un decorator de cache?"}
    ]
)

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

Parametrii de generare se comportă exact ca în cazul API-ului direct Mistral. Dacă un răspuns este prea imprevizibil sau verbose, corectați-l aici, nu în prompt.

response = client.chat.complete(
    model="azureai",
    messages=[
        {"role": "user", "content": "Generează un haiku despre cloud computing."}
    ],
    temperature=0.7,
    max_tokens=150,
    top_p=0.95
)
  • temperature — Controlează creativitatea (0.0 = determinist, 1.0 = creativ)
  • max_tokens — Limitează lungimea răspunsului
  • top_p — Eșantionare nucleu (nucleus sampling)

Streaming

Pentru răspunsuri care se întind pe câteva sute de cuvinte, un apel standard lasă utilizatorul să privească un ecran blocat timp de câteva secunde. Streaming-ul elimină această așteptare percepută prin afișarea textului pe măsură ce este generat. Acesta este modul implicit ori de câte ori este implicată o interfață umană.

stream = client.chat.stream(
    model="azureai",
    messages=[
        {"role": "user", "content": "Explică cum funcționează un load balancer."}
    ]
)

for chunk in stream:
    content = chunk.data.choices[0].delta.content
    if content:
        print(content, end="", flush=True)
print()  # Linia nouă la final

Rețineți verificarea if content: unele fragmente sosesc goale și ar afișa None pe ecran fără această precauție.

Apeluri Asincrone

Într-un server web—FastAPI, Django async—un apel blocant ocupă un worker pe întreaga durată a generării, adesea câteva secunde per cerere. Clientul asincron cedează controlul în timpul așteptării, permițând unui singur proces să gestioneze zeci de cereri concurente.

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

# Execuție
result = asyncio.run(generate_response("Ce este Kubernetes?"))
print(result)

Apelarea de Funcții

Apelarea de funcții se comportă identic cu API-ul direct. Descrieți instrumentele disponibile, modelul decide dacă să apeleze unul, iar codul dumneavoastră execută efectiv funcția—modelul formulează doar intenția și argumentele.

import json

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Obține vremea pentru un oraș",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "Numele orașului"}
                },
                "required": ["city"]
            }
        }
    }
]

response = client.chat.complete(
    model="azureai",
    messages=[{"role": "user", "content": "Care este vremea în Paris?"}],
    tools=tools,
    tool_choice="auto"
)

# Verifică dacă modelul dorește să apeleze o funcție
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"Funcție apelată: {tool_call.function.name}")
    print(f"Argumente: {args}")

Gestionarea Erorilor

În producție, trei familii de erori reapar constant și necesită răspunsuri diferite. Un 429 semnalează o limită de rată și necesită o reîncercare cu backoff exponențial. Un 401 indică o cheie invalidă sau expirată: reîncercarea este inutilă, așa că eșuați imediat cu un mesaj clar. Un 404 indică aproape întotdeauna o variabilă AZUREAI_ENDPOINT configurată greșit. Distingerea acestor cazuri vă scutește de ore întregi de depanare a unei greșeli de tastare într-un URL.

import time
from mistralai.azure.client import MistralAzure

def robust_call(client, messages, max_retries=3):
    """Apel cu reîncercare exponențială și gestionarea erorilor."""
    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"Limită de rată — reîncercare în {wait}s")
                time.sleep(wait)
            elif "401" in error_str:
                raise ValueError("Cheie API invalidă sau expirată") from e
            elif "404" in error_str:
                raise ValueError("Endpoint negăsit — verificați AZUREAI_ENDPOINT") from e
            else:
                if attempt == max_retries - 1:
                    raise
                time.sleep(1)
    raise RuntimeError("Eșec după toate reîncercările")

Măsurarea Consumului

Fiecare răspuns include un obiect usage care detaliază tokenii consumați. Citiți acest lucru sistematic: este singura măsură fiabilă pentru estimarea costurilor și identificarea unui prompt de sistem care a devenit umflat din cauza editărilor repetate.

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

usage = response.usage
print(f"Tokeni prompt  : {usage.prompt_tokens}")
print(f"Tokeni răspuns : {usage.completion_tokens}")
print(f"Total tokeni   : {usage.total_tokens}")

Puncte cheie

  • Clientul MistralAzure funcționează ca clientul standard, folosind model="azureai"
  • Streaming-ul (chat.stream) este recomandat pentru interfețele cu utilizatorul
  • Apelurile asincrone (complete_async) sunt esențiale pentru serverele web
  • Apelarea de funcții și modul JSON funcționează identic cu API-ul direct
  • Implementați întotdeauna reîncercarea exponențială pentru a gestiona erorile 429