Przejdź do głównej treści
Polski— Wybierz język
Menu

Streaming SSE

Lekcja 5 z 16 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Odpowiedzi w czasie rzeczywistym dzięki Server-Sent Events
  2. Streaming kontra tryb niestreamingowy
  3. Protokół SSE w szczegółach
  4. Włączanie streamingu w Pythonie
  5. Struktura fragmentu (chunk)
  6. Rekonstrukcja pełnej odpowiedzi
  7. Kiedy używać streamingu
  8. Kluczowe wnioski

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życiaRekomendacja
Interaktywny chatbotStreaming (lepsze UX)
Przetwarzanie wsadoweNiestreamingowy (prostszy)
Backend API dla frontenduStreaming (SSE do przeglądarki)
Potok danych (Data pipeline)Niestreamingowy (przetwarzanie atomowe)
Ekstrakcja strukturalnaNiestreamingowy (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.content zamiast message.content
  • Akumuluj fragmenty po stronie klienta, aby zrekonstruować pełną odpowiedź
  • Preferuj streaming w interfejsach użytkownika, a tryb niestreamingowy w przetwarzaniu automatycznym