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

Implementar streaming en Python

Lección 6 de 16 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. Del prototipo a producción
  2. El patrón básico
  3. Gestión exhaustiva de errores
  4. Streaming asíncrono con asyncio
  5. Integración con FastAPI
  6. Medición del rendimiento
  7. Puntos clave

Del prototipo a producción

La lección anterior cubrió los conceptos del streaming mediante SSE. La parte más compleja sigue pendiente: convertir un bucle de demostración en un cliente capaz de soportar carga, sobrevivir a errores de red y alimentar una interfaz web. Esta lección sigue la trayectoria real de un proyecto: primero el esqueleto, luego la gestión de errores, después la asincronía, la exposición HTTP y, finalmente, la medición.

El patrón básico

Todo comienza con este esqueleto de diez líneas, que adaptarás para cada proyecto. Hace dos cosas a la vez: muestra los tokens a medida que llegan y los acumula para devolverlos en la función.

from mistralai.client import Mistral
import os

client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))

def stream_chat(messages: list, model: str = "mistral-large-latest") -> str:
    """Envía una solicitud de streaming y muestra los tokens en tiempo real."""
    stream = client.chat.stream(
        model=model,
        messages=messages
    )

    full_text = ""
    for chunk in stream:
        content = chunk.data.choices[0].delta.content
        if content:
            full_text += content
            print(content, end="", flush=True)

    print()  # Nueva línea
    return full_text

Esta versión funciona para un script local. Tiene un fallo fatal en producción: imprime en la terminal, por lo que no puede hacer nada más que trabajo de terminal.

Gestión exhaustiva de errores

Los errores de red, los tiempos de espera agotados y los límites de tasa no son hipótesis: son certezas a escala de tráfico real. El cliente de abajo aborda ambos problemas. Reintenta automáticamente los errores 429 con retroceso exponencial y ya no imprime nada: emite eventos tipados mediante yield, dejando que quien llama decida qué hacer con ellos: mostrarlos, enviarlos a un WebSocket o escribirlos en una base de datos.

from mistralai.client import Mistral
from mistralai.client.errors import SDKError
import os
import time

client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))

def stream_with_retry(
    messages: list,
    model: str = "mistral-large-latest",
    max_retries: int = 3,
    max_tokens: int = 2000
) -> dict:
    """Streaming con reintento automático y métricas."""
    for attempt in range(max_retries):
        try:
            stream = client.chat.stream(
                model=model,
                messages=messages,
                max_tokens=max_tokens
            )

            full_text = ""
            finish_reason = None
            chunk_count = 0

            for chunk in stream:
                delta = chunk.data.choices[0].delta
                if delta.content:
                    full_text += delta.content
                    chunk_count += 1
                    yield {"type": "token", "content": delta.content}

                if chunk.data.choices[0].finish_reason:
                    finish_reason = chunk.data.choices[0].finish_reason

            yield {
                "type": "done",
                "full_text": full_text,
                "finish_reason": finish_reason,
                "chunks": chunk_count
            }
            return

        except SDKError as e:
            if e.status_code == 429 and attempt < max_retries - 1:
                wait_time = 2 ** attempt  # Retroceso exponencial
                yield {"type": "retry", "wait": wait_time, "attempt": attempt + 1}
                time.sleep(wait_time)
            else:
                yield {"type": "error", "message": str(e), "status": e.status_code}
                return

        except Exception as e:
            yield {"type": "error", "message": str(e), "status": None}
            return

El retroceso exponencial 2 ** attempt espera 1 segundo, luego 2 y después 4. Esta progresión no es decorativa: si todos tus clientes reintentaran al mismo ritmo fijo, golpearían la API en ráfagas sincronizadas y prolongarían la misma saturación que están sufriendo. Observa también que solo el error 429 desencadena un reintento; reintentar un 401 debido a una clave inválida solo retrasaría el diagnóstico.

Por parte de quien llama, el consumo se convierte en una simple lectura de eventos:

messages = [
    {"role": "system", "content": "Eres un asistente técnico."},
    {"role": "user", "content": "Explica los patrones de diseño en Python."}
]

for event in stream_with_retry(messages):
    if event["type"] == "token":
        print(event["content"], end="", flush=True)
    elif event["type"] == "retry":
        print(f"\n[Reintento {event['attempt']}, esperando {event['wait']}s...]")
    elif event["type"] == "done":
        print(f"\n\n--- Finalizado ({event['chunks']} fragmentos, {event['finish_reason']})")
    elif event["type"] == "error":
        print(f"\n[Error: {event['message']}]")

Streaming asíncrono con asyncio

El cliente síncrono bloquea su hilo durante toda la generación. En un servidor web que debe manejar cincuenta conversaciones simultáneas, esto significa inmovilizar cincuenta hilos solo para esperar. El cliente asíncrono elimina esta restricción:

from mistralai.client import Mistral
import asyncio
import os

client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))

async def async_stream_chat(messages: list) -> str:
    """Streaming asíncrono para aplicaciones concurrentes."""
    stream = await client.chat.stream_async(
        model="mistral-large-latest",
        messages=messages
    )

    full_text = ""
    async for chunk in stream:
        content = chunk.data.choices[0].delta.content
        if content:
            full_text += content
            print(content, end="", flush=True)

    print()
    return full_text

# Ejecución
async def main():
    messages = [{"role": "user", "content": "Hola, preséntate."}]
    result = await async_stream_chat(messages)
    print(f"\nTotal: {len(result)} caracteres")

asyncio.run(main())

La lógica es idéntica a la versión síncrona; solo cambian stream_async, el await en la llamada y el async for en el bucle.

Integración con FastAPI

A continuación, necesitas sacar este flujo de tu proceso Python y llevarlo al navegador. FastAPI se encarga de esto con StreamingResponse, siempre que reformatees cada fragmento al formato SSE visto en la lección anterior:

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from mistralai.client import Mistral
import os
import json

app = FastAPI()
client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))

async def generate_stream(prompt: str):
    """Generador SSE para FastAPI."""
    stream = await client.chat.stream_async(
        model="mistral-large-latest",
        messages=[{"role": "user", "content": prompt}]
    )

    async for chunk in stream:
        content = chunk.data.choices[0].delta.content
        if content:
            data = json.dumps({"content": content})
            yield f"data: {data}\n\n"

    yield "data: [DONE]\n\n"

@app.get("/chat/stream")
async def chat_stream(prompt: str):
    return StreamingResponse(
        generate_stream(prompt),
        media_type="text/event-stream"
    )

Dos detalles determinan si este endpoint funciona correctamente. El doble salto de línea \n\n que termina cada yield es lo que separa los eventos en el protocolo SSE: sin él, el navegador espera indefinidamente un evento que considera inacabado. Y media_type="text/event-stream" es lo que permite al cliente JavaScript consumir la respuesta con un EventSource en lugar de un fetch estándar.

Medición del rendimiento

Una vez implementado el streaming, querrás saber cómo rinde. Dos métricas bastan para impulsar la optimización:

import time

start = time.perf_counter()
first_token_time = None
token_count = 0

stream = client.chat.stream(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": "Escribe un párrafo sobre París."}]
)

for chunk in stream:
    if chunk.data.choices[0].delta.content:
        if first_token_time is None:
            first_token_time = time.perf_counter() - start
        token_count += 1

total_time = time.perf_counter() - start

print(f"Tiempo hasta el primer token (TTFT): {first_token_time:.3f}s")
print(f"Tokens generados: {token_count}")
print(f"Tiempo total: {total_time:.3f}s")
print(f"Tokens/segundo: {token_count / total_time:.1f}")

El TTFT (Time to First Token), es decir, el tiempo entre el envío de la solicitud y la visualización del primer carácter, es la métrica más importante para la experiencia de usuario. Tiene prioridad sobre el tiempo total: una generación de quince segundos cuya primera palabra aparece en tres décimas de segundo se sentirá rápida, mientras que una generación de cinco segundos entregada en un único bloque se sentirá lenta. Mídelo con tus indicaciones reales, incluido el mensaje de sistema; un mensaje de sistema de dos páginas alarga el TTFT antes incluso de que se genere el primer token.

Puntos clave

  • Usa un patrón de generador (yield) para propagar los tokens de streaming
  • Implementa retroceso exponencial para errores 429 (límite de tasa)
  • Prefiere stream_async para aplicaciones web concurrentes
  • Mide el TTFT y los tokens por segundo para optimizar el rendimiento
  • Con FastAPI, StreamingResponse + text/event-stream propaga SSE al navegador