Ir al contenido principal
Español— Elegir un idioma
Menú

El cliente MistralAzure en Python

Lección 5 de 14 Actualizado el 2 de noviembre de 2026 Avanzado
En esta página
  1. Programación con MistralAzure
  2. Instalación y configuración
  3. Completados de chat
  4. Streaming
  5. Llamadas asíncronas
  6. Llamada a funciones
  7. Gestión de errores
  8. Medición del consumo
  9. Puntos clave

Programación con MistralAzure

Tu punto final (endpoint) de Azure está desplegado y respondiendo; ahora necesitas escribir el código que lo utilice de forma fiable. Esta lección detalla el cliente Python MistralAzure: inicialización, los patrones que usarás a diario (llamadas simples, streaming, ejecución asíncrona y llamada a funciones) y las pocas particularidades que distinguen a Azure de la API directa.

Instalación y configuración

Actualizado el 2 de noviembre de 2026 — Mistral SDK 2 y versiones posteriores. Desde la versión 2.0 del SDK de Python (marzo de 2026), el cliente de Azure se importa desde mistralai.azure.client, y sus parámetros de la versión 1, azure_endpoint y azure_api_key, han pasado a ser server_url y api_key. El código de esta lección sigue la versión actual (3.7.0, 1 de noviembre de 2026). Fuentes: notas de la versión v2.0.0 · Mistral en Azure.

El cliente de Azure está incluido en el paquete mistralai; no se requieren dependencias adicionales.

pip install mistralai

La inicialización requiere dos parámetros:

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 — La URL de tu punto final de Azure
  • api_key — La clave de autenticación del punto final

Un tercer parámetro opcional, api_version, tiene por defecto 2024-05-01-preview. El SDK añade este valor automáticamente a cada solicitud como un parámetro de URL.

Completados de chat

A partir de aquí, la experiencia es idéntica a la del cliente estándar. Usa un mensaje de sistema para definir el rol del modelo, un mensaje de usuario para la pregunta y lee la respuesta desde choices[0].message.content.

response = client.chat.complete(
    model="azureai",
    messages=[
        {"role": "system", "content": "Eres un asistente técnico especializado en Python."},
        {"role": "user", "content": "¿Cómo implemento un decorador de caché?"}
    ]
)

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

Los parámetros de generación se comportan exactamente igual que con la API directa de Mistral. Si una respuesta es demasiado impredecible o verbosa, corrígelo aquí, no en el prompt.

response = client.chat.complete(
    model="azureai",
    messages=[
        {"role": "user", "content": "Genera un haiku sobre la computación en la nube."}
    ],
    temperature=0.7,
    max_tokens=150,
    top_p=0.95
)
  • temperature — Controla la creatividad (0,0 = determinista, 1,0 = creativo)
  • max_tokens — Limita la longitud de la respuesta
  • top_p — Muestreo de núcleo (nucleus sampling)

Streaming

Para respuestas de varios cientos de palabras, una llamada estándar deja al usuario mirando una pantalla congelada durante varios segundos. El streaming elimina esta espera percibida mostrando el texto a medida que se genera. Este es el modo predeterminado siempre que haya una interfaz humana involucrada.

stream = client.chat.stream(
    model="azureai",
    messages=[
        {"role": "user", "content": "Explica cómo funciona un equilibrador de carga."}
    ]
)

for chunk in stream:
    content = chunk.data.choices[0].delta.content
    if content:
        print(content, end="", flush=True)
print()  # Nueva línea al final

Observa la comprobación if content: algunos fragmentos llegan vacíos y, sin esta precaución, imprimirían None en la pantalla.

Llamadas asíncronas

En un servidor web (FastAPI, Django async), una llamada bloqueante ocupa un worker durante toda la duración de la generación, a menudo varios segundos por solicitud. El cliente asíncrono cede el control durante la espera, permitiendo que un único proceso gestione docenas de solicitudes concurrentes.

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

# Ejecución
result = asyncio.run(generate_response("¿Qué es Kubernetes?"))
print(result)

Llamada a funciones

La llamada a funciones se comporta de forma idéntica a la API directa. Describes las herramientas disponibles, el modelo decide si llamar a una y tu código ejecuta realmente la función; el modelo solo formula la intención y los argumentos.

import json

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Obtener el tiempo meteorológico de una ciudad",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "Nombre de la ciudad"}
                },
                "required": ["city"]
            }
        }
    }
]

response = client.chat.complete(
    model="azureai",
    messages=[{"role": "user", "content": "¿Qué tiempo hace en París?"}],
    tools=tools,
    tool_choice="auto"
)

# Comprobar si el modelo quiere llamar a una función
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"Función llamada: {tool_call.function.name}")
    print(f"Argumentos: {args}")

Gestión de errores

En producción, recurran tres familias de errores que exigen respuestas distintas. Un 429 indica un límite de tasa y requiere un reintento con retroceso exponencial. Un 401 señala una clave inválida o caducada: reintentar es inútil, así que falla inmediatamente con un mensaje claro. Un 404 casi siempre apunta a una variable AZUREAI_ENDPOINT mal configurada. Distinguir estos casos te evita pasar una hora depurando un error tipográfico en una URL.

import time
from mistralai.azure.client import MistralAzure

def robust_call(client, messages, max_retries=3):
    """Llamada con reintento exponencial y gestión de errores."""
    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"Límite de tasa — reintentando en {wait}s")
                time.sleep(wait)
            elif "401" in error_str:
                raise ValueError("Clave de API inválida o caducada") from e
            elif "404" in error_str:
                raise ValueError("Punto final no encontrado — comprueba AZUREAI_ENDPOINT") from e
            else:
                if attempt == max_retries - 1:
                    raise
                time.sleep(1)
    raise RuntimeError("Fallo tras todos los reintentos")

Medición del consumo

Cada respuesta incluye un objeto usage que detalla los tokens consumidos. Léelo sistemáticamente: es la única medida fiable para estimar costes y detectar un prompt de sistema que se ha hinchado por ediciones repetidas.

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

usage = response.usage
print(f"Tokens del prompt  : {usage.prompt_tokens}")
print(f"Tokens de respuesta: {usage.completion_tokens}")
print(f"Tokens totales     : {usage.total_tokens}")

Puntos clave

  • El cliente MistralAzure funciona como el cliente estándar, usando model="azureai"
  • Se recomienda el streaming (chat.stream) para interfaces de usuario
  • Las llamadas asíncronas (complete_async) son esenciales para servidores web
  • La llamada a funciones y el modo JSON funcionan de forma idéntica a la API directa
  • Implementa siempre un reintento exponencial para gestionar errores 429