Strumieniowanie odpowiedzi w Pythonie
Na tej stronie
Problem, który rozwiązuje strumieniowanie
Korzystając z chat.complete(), czekasz, aż model wygeneruje całą odpowiedź, zanim otrzymasz choćby jeden znak. Przy krótkiej odpowiedzi opóźnienie to pozostaje niezauważone. Jednak w przypadku szczegółowej analizy, długiego fragmentu kodu czy rozumowania rozłożonego na wiele akapitów, użytkownik wpatruje się w pusty ekran przez kilka sekund. W interfejsie czatu nawet kilka sekund ciszy może sprawić wrażenie, że aplikacja zawiesiła się.
Strumieniowanie zmienia to odczucie: odpowiedź dociera przyrostowo, kawałek po kawałku, i wyświetla się stopniowo, dokładnie tak jak w znanych Ci interfejsach czatu. Całkowity czas generowania nie skraca się ani o milisekundę, ale pierwsze słowo pojawia się niemal natychmiast. To właśnie to początkowe opóźnienie jest tym, co użytkownik faktycznie odczuwa.
Użycie chat.stream()
Mistral SDK V2 udostępnia metodę chat.stream(), która zwraca iterator fragmentów zamiast pojedynczego obiektu:
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()
Dwa szczegóły w tej pętli mają kluczowe znaczenie. Sprawdzenie if content jest niezbędne, ponieważ niektóre fragmenty docierają bez tekstu i w przeciwnym razie wypisałyby None. Z kolei flush=True wymusza na Pythonie natychmiastowe zapisanie danych na wyjściu, zamiast czekania na wypełnienie bufora. Bez tego cały tekst pojawiłby się jednym blokiem na samym końcu, co całkowicie niweczyłoby oczekiwany efekt.
| Aspekt | chat.complete() | chat.stream() |
|---|---|---|
| Zwrot | Kompletny obiekt | Iterator fragmentów |
| Postrzegane opóźnienie | Wysokie (całkowity czas oczekiwania) | Niskie (szybki pierwszy token) |
| Dostęp do tekstu | response.choices[0].message.content | chunk.data.choices[0].delta.content |
| Zużycie tokenów | Dostępne w odpowiedzi | Dostępne w ostatnim fragmencie |
Co zawiera fragment
Każdy fragment niesie ze sobą deltę, czyli ułamek tworzonej odpowiedzi. Analizując ją, uzyskujesz dostęp zarówno do tekstu, jak i metadanych oznaczających koniec strumienia:
for chunk in stream:
delta = chunk.data.choices[0].delta
# Treść tekstowa (może być None dla niektórych fragmentów)
text = delta.content
# Powód zatrzymania (None z wyjątkiem ostatniego fragmentu)
end = chunk.data.choices[0].finish_reason
if text:
print(text, end="", flush=True)
if end:
print(f"\n[Stream end: {end}]")
Przepływ zawsze podlega tej samej choreografii: pierwszy fragment zazwyczaj niesie rolę assistant, fragmenty pośrednie dostarczają tekst w małych kawałkach, a ostatni zawiera finish_reason. Sprawdzając ten końcowy fragment, ustalasz, czy odpowiedź zakończyła się normalnie, czy została ucięta przez limit max_tokens.
Wyświetlanie i zapisywanie jednocześnie
Strumieniowanie ma swoją wadę: tekst przewija się na ekranie, ale nigdzie go nie przechowujesz. Tymczasem aplikacja działająca w środowisku produkcyjnym często potrzebuje archiwizować odpowiedź w bazie danych dla celów historii rozmowy. Rozwiązaniem jest akumulowanie fragmentów podczas ich wyświetlania:
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()
# Odtworzona pełna odpowiedź
final_text = "".join(full_response)
print(f"\nTotal length: {len(final_text)} characters")
Zwróć uwagę na użycie listy, a następnie końcowego "".join() zamiast konkatenacji stringów w każdej iteracji pętli. Przy długiej odpowiedzi to drugie podejście kopiowałoby cały zgromadzony tekst dla każdego otrzymanego fragmentu, co jest nieefektywne.
Wariant asynchroniczny
W serwerze WWW – takim jak FastAPI czy aiohttp – wersja synchroniczna blokuje wątek podczas całego procesu generowania, zamrażając inne trwające żądania. Dlatego SDK udostępnia metodę 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 jest identyczna jak w wersji synchronicznej, z wyjątkiem słów kluczowych await i async for. Gdy tylko Twój kod działa w serwerze WWW, jest to wariant, którego musisz użyć.
Kiedy strumieniować, a kiedy tego nie robić
W interfejsie czatu strumieniowanie jest zawsze obowiązkowe: chodzi o komfort czytania. Po stronie backendowego API warto je włączyć, o ile Twój frontend potrafi konsumować zdarzenia Server-Sent Events. Przy każdej odpowiedzi dłuższej niż kilka zdań zysk na postrzeganym opóźnieniu usprawiedliwia dodatkowe komplikacje. Z drugiej strony, w skrypcie wsadowym przetwarzającym tysiąc dokumentów i zapisującym wyniki do pliku, nikt nie patrzy na ekran: chat.complete() pozostaje prostsze i w pełni wystarczające.
Kluczowe wnioski
chat.stream()zwraca iterator fragmentów do wyświetlania przyrostowego- Treść znajduje się w
chunk.data.choices[0].delta.content - Używaj
flush=Truew wywołaniachprint(), aby uzyskać wyświetlanie w czasie rzeczywistym - Odtwórz pełną odpowiedź, akumulując fragmenty, jeśli jest to konieczne
- Wersja asynchroniczna
chat.stream_async()jest zalecana w aplikacjach internetowych