Streaming SSE
Na tej stronie
Odpowiedzi w czasie rzeczywistym dzięki Server-Sent Events
Domyślnie API Chat Completions czeka, aż model zakończy generowanie całej odpowiedzi, zanim ją do Ciebie wyśle. W przypadku krótkiego pytania nikt nie zauważy opóźnienia. Przy raporcie liczącym tysiąc słów oznacza to jednak kilka sekund pustego ekranu, przez co użytkownik może sądzić, że aplikacja uległa awarii. Streaming rozwiązuje ten problem, wysyłając tokeny w miarę ich generowania, co tworzy znany efekt maszyny do pisania widoczny w interfejsach konwersacyjnych.
Wykorzystywanym protokołem są Server-Sent Events (SSE), standard HTTP pozwalający serwerowi na ciągłe wypychanie danych do klienta przez trwałe połączenie. Nie ma tu nic egzotycznego: nie musisz instalować WebSocketów ani dodawać żadnych zależności.
Streaming kontra tryb niestreamingowy
W trybie niestreamingowym, który jest domyślny, klient wysyła żądanie i czeka na kompletną odpowiedź:
Client ──── request ────► Server
(wait 3-10s)
Client ◄── complete response ── Server
Zaletą jest prostota: odpowiedź jest atomowa, stanowi pojedynczy obiekt JSON, który łatwo przetworzyć, zwalidować i zapisać. Wadą jest równie oczywista kwestia: wysokie postrzegane opóźnienie, ponieważ użytkownik nie widzi niczego podczas całego procesu generowania.
W trybie streamingu serwer wysyła tokeny jeden po drugim lub w małych grupach:
Client ──── request ────► Server
Client ◄── chunk 1 ─────── Server (after ~200ms)
Client ◄── chunk 2 ─────── Server (after ~250ms)
Client ◄── chunk 3 ─────── Server (after ~300ms)
...
Client ◄── [DONE] ──────── Server
Postrzegane opóźnienie spada drastycznie – pierwszy znak pojawia się w ciągu kilkuset milisekund – co znacząco poprawia doświadczenia użytkownika. W zamian musisz zrekonstruować wiadomość po stronie klienta i zarządzać stanem, który nie przychodzi już jako jeden blok.
Protokół SSE w szczegółach
Oto jak faktycznie wygląda strumień HTTP, który otrzymujesz:
data: {"id":"cmpl-abc","choices":[{"delta":{"content":"Hello"}}],"usage":null}
data: {"id":"cmpl-abc","choices":[{"delta":{"content":" "}}],"usage":null}
data: {"id":"cmpl-abc","choices":[{"delta":{"content":"!"}}],"usage":null}
data: [DONE]
Każda linia zaczyna się od data: , po którym następuje obiekt JSON, a puste linie służą jako separatory między zdarzeniami. Zwróć uwagę na szczegół, który pułapkuje każdego przy pierwszej implementacji: fragment tekstu znajduje się w polu delta, a nie w message, jak w trybie klasycznym. Strumień kończy się zdarzeniem data: [DONE], które wyraźnie sygnalizuje koniec. Bez niego nie byłbyś w stanie odróżnić zakończonego generowania od przerwania połączenia.
Włączanie streamingu w Pythonie
Dzięki Mistral SDK włączasz streaming, wywołując chat.stream() zamiast chat.complete():
from mistralai.client import Mistral
import os
client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
stream = client.chat.stream(
model="mistral-large-latest",
messages=[
{"role": "user", "content": "Explain how an electric motor works."}
]
)
for chunk in stream:
content = chunk.data.choices[0].delta.content
if content:
print(content, end="", flush=True)
print() # Final newline
Argument flush=True zasługuje na wyjaśnienie, ponieważ jego pominięcie to klasyczna przyczyna „niedziałającego“ streamingu. Bez niego Python przechowuje znaki w buforze i wyświetla je w blokach. Wizualnie niweczy to wszystkie korzyści ze streamingu, mimo że fragmenty docierają poprawnie.
Struktura fragmentu (chunk)
Fragment strumieniowy nie wygląda jak kompletna odpowiedź, a ścieżki dostępu są inne:
# Non-streaming: response.choices[0].message.content
# Streaming: chunk.data.choices[0].delta.content
# The first chunk often contains the role
# chunk.data.choices[0].delta.role == "assistant"
# Subsequent chunks contain text fragments
# chunk.data.choices[0].delta.content == "Hello"
# The last chunk contains finish_reason
# chunk.data.choices[0].finish_reason == "stop"
Pierwszy fragment zazwyczaj niesie rolę bez tekstu, kolejne zawierają fragmenty tekstu, a ostatni dostarcza finish_reason. Dlatego sprawdzenie if content: w poprzednim kodzie nie jest zbędną ostrożnością: konkatenacja wartości None spowodowałaby błąd pętli już w pierwszej iteracji.
Rekonstrukcja pełnej odpowiedzi
Wyświetlanie fragmentów nie wystarczy, gdy musisz zachować odpowiedź – na przykład, aby dodać ją do historii rozmowy, zalogować ją lub zapisać w bazie danych. Musisz zatem akumulować tekst równolegle do jego wyświetlania:
from mistralai.client import Mistral
import os
client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
stream = client.chat.stream(
model="mistral-large-latest",
messages=[{"role": "user", "content": "List 5 programming languages."}]
)
full_response = ""
finish_reason = None
for chunk in stream:
delta = chunk.data.choices[0].delta
if delta.content:
full_response += delta.content
print(delta.content, end="", flush=True)
if chunk.data.choices[0].finish_reason:
finish_reason = chunk.data.choices[0].finish_reason
print(f"\n\nFinish reason: {finish_reason}")
print(f"Complete response ({len(full_response)} characters)")
Zmienna finish_reason jest przechwytywana w tej samej pętli z tego samego powodu co w trybie klasycznym: odpowiedź ucięta przez max_tokens pojawia się na ekranie dokładnie tak samo jak odpowiedź kompletna i tylko to pole powie Ci, jaka jest różnica.
Kiedy używać streamingu
Streaming nie zawsze jest lepszy. Jest wskazany zawsze, gdy człowiek patrzy na ekran, ale zbędny, a nawet szkodliwy, gdy dane przetwarza maszyna.
| Przypadek użycia | Rekomendacja |
|---|---|
| Interaktywny chatbot | Streaming (lepsze UX) |
| Przetwarzanie wsadowe | Niestreamingowy (prostszy) |
| Backend API dla frontendu | Streaming (SSE do przeglądarki) |
| Potok danych (Data pipeline) | Niestreamingowy (przetwarzanie atomowe) |
| Ekstrakcja strukturalna | Niestreamingowy (bardziej niezawodne parsowanie JSON) |
Ostatni przypadek jest najbardziej pouczający. Jeśli oczekujesz JSON-a, streaming nic nie wnosi: nie możesz sparsować niekompletnego obiektu i tak czy inaczej musisz poczekać na ostatni fragment. Równie dobrze możesz zachować wywołanie atomowe i uprościć kod.
Kluczowe wnioski
- Streaming redukuje postrzegane opóźnienie, wysyłając tokeny w miarę ich generowania
- Protokół SSE to prosty i solidny standard HTTP
- W trybie streamingu używaj
delta.contentzamiastmessage.content - Akumuluj fragmenty po stronie klienta, aby zrekonstruować pełną odpowiedź
- Preferuj streaming w interfejsach użytkownika, a tryb niestreamingowy w przetwarzaniu automatycznym