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

Respuestas en streaming en Python

Lección 6 de 14 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. El problema que resuelve el streaming
  2. Uso de chat.stream()
  3. Qué contiene un trozo
  4. Mostrar y guardar simultáneamente
  5. La variante asíncrona
  6. Cuándo usar streaming y cuándo omitirlo
  7. Puntos clave

El problema que resuelve el streaming

Con chat.complete(), esperas a que el modelo genere toda la respuesta antes de recibir un solo carácter. Para una respuesta breve, este retraso pasa desapercibido. Sin embargo, para un análisis detallado, un fragmento de código extenso o un razonamiento de varios párrafos, el usuario se queda mirando una pantalla en blanco durante varios segundos. En una interfaz de chat, incluso unos pocos segundos de silencio pueden hacer que la aplicación parezca bloqueada.

El streaming cambia esta percepción: la respuesta llega de forma incremental, trozo a trozo, y se muestra progresivamente, igual que en las interfaces de chat que ya conoces. El tiempo total de generación no se reduce ni un milisegundo, pero la primera palabra aparece casi de inmediato. Ese retraso inicial es lo que el usuario percibe realmente.

Uso de chat.stream()

El SDK de Mistral V2 expone el método chat.stream(), que devuelve un iterador de trozos en lugar de un único objeto:

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

stream = client.chat.stream(
    model="mistral-small-latest",
    messages=[
        {
            "role": "user",
            "content": "Describe los pasos para desplegar una aplicación Flask en un servidor Linux."
        }
    ]
)

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

# Salto de línea final
print()

Dos detalles marcan la diferencia en este bucle. La comprobación if content es esencial porque algunos trozos llegan sin texto y, de otro modo, imprimirían None. Además, flush=True obliga a Python a escribir inmediatamente en la salida en lugar de esperar a que se llene su búfer. Sin esto, todo el texto aparecería de golpe al final, anulando por completo la ventaja que buscas.

Aspectochat.complete()chat.stream()
RetornoObjeto completoIterador de trozos
Latencia percibidaAlta (espera total)Baja (primer token rápido)
Acceso al textoresponse.choices[0].message.contentchunk.data.choices[0].delta.content
Uso de tokensDisponible en la respuestaDisponible en el último trozo

Qué contiene un trozo

Cada trozo lleva un delta, es decir, un fragmento de la respuesta en construcción. Al inspeccionarlo, accedes tanto al texto como a los metadatos de fin de flujo:

for chunk in stream:
    delta = chunk.data.choices[0].delta

    # Contenido de texto (puede ser None para algunos trozos)
    text = delta.content

    # Motivo de parada (None excepto en el último trozo)
    end = chunk.data.choices[0].finish_reason

    if text:
        print(text, end="", flush=True)

    if end:
        print(f"\n[Fin del stream: {end}]")

El flujo sigue siempre la misma coreografía: el primer trozo suele llevar el rol assistant, los trozos intermedios entregan el texto en pequeñas piezas y el último proporciona el finish_reason. Comprobando este último trozo determinas si la respuesta terminó con normalidad o fue cortada por max_tokens.

Mostrar y guardar simultáneamente

El streaming tiene un inconveniente: el texto se desplaza, pero no lo retienes en ningún sitio. Sin embargo, una aplicación real a menudo necesita archivar la respuesta en una base de datos para mantener el historial de la conversación. La solución consiste en acumular los fragmentos mientras se muestran:

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

stream = client.chat.stream(
    model="mistral-small-latest",
    messages=[
        {"role": "user", "content": "Enumera cinco frameworks web de Python."}
    ]
)

full_response = []

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

print()

# La respuesta completa reconstruida
final_text = "".join(full_response)
print(f"\nLongitud total: {len(final_text)} caracteres")

Observa el uso de una lista seguida de un "".join() final en lugar de concatenar cadenas en cada iteración del bucle. Para una respuesta larga, este último enfoque copia todo el texto acumulado por cada fragmento recibido, lo cual es ineficiente.

La variante asíncrona

En un servidor web (FastAPI, aiohttp), la versión síncrona bloquea el hilo durante toda la generación, congelando otras solicitudes en curso. Por ello, el SDK proporciona chat.stream_async():

import asyncio
import os
from mistralai.client import Mistral

async def generate_response():
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

    stream = await client.chat.stream_async(
        model="mistral-small-latest",
        messages=[
            {"role": "user", "content": "Explica el concepto de corrutina en Python."}
        ]
    )

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

    print()

asyncio.run(generate_response())

La estructura es idéntica a la versión síncrona, salvo por las palabras clave await y async for. En cuanto tu código se ejecute en un servidor web, esta es la variante que debes usar.

Cuándo usar streaming y cuándo omitirlo

En una interfaz de chat, el streaming es siempre obligatorio: está en juego la comodidad de lectura. Por parte de la API del backend, merece la pena activarlo siempre que tu frontend pueda consumir eventos enviados por el servidor (Server-Sent Events). Para cualquier respuesta más larga que unas pocas frases, la ganancia en latencia percibida justifica la complejidad añadida. Por el contrario, en un script por lotes que procesa mil documentos y escribe los resultados en un archivo, nadie está mirando la pantalla: chat.complete() sigue siendo más simple y perfectamente adecuado.

Puntos clave

  • chat.stream() devuelve un iterador de trozos para una visualización progresiva
  • El contenido reside en chunk.data.choices[0].delta.content
  • Usa flush=True en tus llamadas a print() para una visualización en tiempo real
  • Reconstruye la respuesta completa acumulando los trozos si es necesario
  • La versión asíncrona chat.stream_async() es recomendable para aplicaciones web