Respuestas en streaming en Python
En esta página
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.
| Aspecto | chat.complete() | chat.stream() |
|---|---|---|
| Retorno | Objeto completo | Iterador de trozos |
| Latencia percibida | Alta (espera total) | Baja (primer token rápido) |
| Acceso al texto | response.choices[0].message.content | chunk.data.choices[0].delta.content |
| Uso de tokens | Disponible en la respuesta | Disponible 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=Trueen tus llamadas aprint()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