Streamování odpovědí v Pythonu
Na této stránce
Problém, který streamování řeší
Při použití chat.complete() čekáš, až model vygeneruje celou odpověď, než obdržíš jediný znak. U krátké odpovědi toto zpoždění nepostřehneš. U podrobné analýzy, dlouhého úryvku kódu nebo odůvodnění rozděleného do více odstavců však uživatel několik sekund zírá na prázdnou obrazovku. V chatovacím rozhraní může i několikasekundové ticho způsobit, že se aplikace bude zdát zaseknutá.
Streamování tuto percepci mění: odpověď přichází postupně, po částech (chunkách), a zobrazuje se průběžně, přesně jak jsi zvyklý z chatovacích rozhraní. Celkový čas generování se nezkrátí ani o milisekundu, ale první slovo se objeví téměř okamžitě. Právě toto počáteční zpoždění je to, co uživatel skutečně vnímá.
Použití chat.stream()
Mistral SDK V2 poskytuje metodu chat.stream(), která vrací iterátor částí místo jediného objektu:
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 the steps to deploy a Flask application on a Linux server."
}
]
)
for chunk in stream:
content = chunk.data.choices[0].delta.content
if content:
print(content, end="", flush=True)
# Final newline
print()
V této smyčce dělají rozdíl dva detaily. Kontrola if content je nezbytná, protože některé části přicházejí bez textu a jinak by se vytisklo None. A flush=True donutí Python zapsat data okamžitě na výstup, místo aby čekal na zaplnění vyrovnávací paměti. Bez toho by se celý text objevil najednou až na konci, což by zcela negovalo zamýšlený přínos.
| Aspekt | chat.complete() | chat.stream() |
|---|---|---|
| Návratová hodnota | Kompletní objekt | Iterátor částí |
| Vnímaná latence | Vysoká (čekání na konec) | Nízká (rychlý první token) |
| Přístup k textu | response.choices[0].message.content | chunk.data.choices[0].delta.content |
| Využití tokenů | Dostupné v odpovědi | Dostupné v poslední části |
Co obsahuje část (chunk)
Každá část nese delta, což znamená fragment odpovědi, která se teprve tvoří. Jejím prozkoumáním získáš přístup jak k textu, tak k metadatům označujícím konec streamu:
for chunk in stream:
delta = chunk.data.choices[0].delta
# Textový obsah (může být None pro některé části)
text = delta.content
# Důvod ukončení (None kromě poslední části)
end = chunk.data.choices[0].finish_reason
if text:
print(text, end="", flush=True)
if end:
print(f"\n[Stream end: {end}]")
Tok vždy následuje stejnou choreografii: první část obvykle nese roli assistant, střední části dodávají text v malých kouscích a poslední poskytuje finish_reason. Kontrolou této poslední části zjistíš, zda odpověď skončila normálně, nebo byla přerušena kvůli dosažení limitu max_tokens.
Současné zobrazování a ukládání
Streamování má jednu nevýhodu: text se odvíjí před očima, ale nikde ho nemáš uložený. Reálná aplikace však často potřebuje archivovat odpověď v databázi pro historii konverzace. Řešením je akumulovat fragmenty během jejich zobrazování:
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": "List five Python web frameworks."}
]
)
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()
# Rekonstruovaná úplná odpověď
final_text = "".join(full_response)
print(f"\nTotal length: {len(final_text)} characters")
Všimni si použití seznamu následovaného finálním "".join() namísto zřetězování řetězců v každé iteraci smyčky. U dlouhé odpovědi by druhý přístup kopíroval veškerý dosud nahromaděný text pro každý přijatý fragment, což je neefektivní.
Asynchronní varianta
Ve webovém serveru (FastAPI, aiohttp) synchronní verze blokuje vlákno po celou dobu generování, čímž zmrazí ostatní probíhající požadavky. SDK proto poskytuje 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": "Explain the concept of a coroutine in 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())
Struktura je totožná se synchronní verzí, až na klíčová slova await a async for. Jakmile tvůj kód běží ve webovém serveru, toto je varianta, kterou musíš použít.
Kdy streamovat a kdy ne
V chatovacím rozhraní je streamování vždy povinné: jde o komfort čtení. Na straně backendového API se vyplatí jej povolit, pokud tvůj frontend umí zpracovávat Server-Sent Events. U jakékoli odpovědi delší než několik vět přínos ve vnímané latenci ospravedlňuje přidanou složitost. Naopak u dávkového skriptu, který zpracovává tisíce dokumentů a zapisuje výsledky do souboru, se nikdo na obrazovku nedívá: chat.complete() zůstává jednodušší a zcela postačující řešení.
Klíčové poznatky
chat.stream()vrací iterátor částí pro postupné zobrazování- Obsah se nachází v
chunk.data.choices[0].delta.content - Pro zobrazení v reálném čase používej ve voláních
print()parametrflush=True - V případě potřeby rekonstruuj úplnou odpověď akumulací částí
- Pro webové aplikace se doporučuje asynchronní verze
chat.stream_async()