Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Streamovanie SSE

Lekcia 5 z 16 Aktualizované 2. novembra 2026 Vývojár
Na tejto strane
  1. Odpovede v reálnom čase pomocou Server-Sent Events
  2. Streamovanie verzus nestreamovanie
  3. Protokol SSE v detailoch
  4. Povolenie streamovania v Pythone
  5. Štruktúra chunku
  6. Rekonštrukcia úplnej odpovede
  7. Kedy použiť streamovanie
  8. Kľúčové poznatky

Odpovede v reálnom čase pomocou Server-Sent Events

Štandardne Chat Completions API čaká, kým model dokončí generovanie celej odpovede, až potom ju pošle späť tebe. Pri krátkej otázke si nikto oneskorenie nevšimne. Pri tisíc slov dlhej správe to však znamená niekoľko sekúnd prázdnej obrazovky, čo používateľa núti premýšľať, či sa aplikácia nezasekla. Streamovanie tento problém rieši odosielaním tokenov hneď, ako sú vygenerované, čím vytvára známy efekt písacieho stroja viditeľný v konverzačných rozhraniach.

Použitým protokolom sú Server-Sent Events (SSE), HTTP štandard, ktorý umožňuje serveru nepretržite posielať dáta klientovi cez trvalé pripojenie. Nie je tu nič exotické: žiadne WebSockets na inštaláciu, žiadne ďalšie závislosti.

Streamovanie verzus nestreamovanie

V režime bez streamovania, ktorý je predvolený, klient odošle požiadavku a čaká na úplnú odpoveď:

Client ──── request ────► Server
         (wait 3-10s)
Client ◄── complete response ── Server

Výhodou je jednoduchosť: odpoveď je atómová, ide o jeden JSON objekt, ktorý sa ľahko spracúva, overuje a ukladá. Nevýhoda je rovnako zrejmá: vnímaná latencia je vysoká, pretože používateľ počas celého procesu generovania nevidí nič.

V režime streamovania server posiela tokeny jeden po druhom alebo v malých skupinách:

Client ──── request ────► Server
Client ◄── chunk 1 ─────── Server  (after ~200ms)
Client ◄── chunk 2 ─────── Server  (after ~250ms)
Client ◄── chunk 3 ─────── Server  (after ~300ms)
...
Client ◄── [DONE] ──────── Server

Vnímaná latencia dramaticky klesá – prvý znak sa objaví v priebehu niekoľkých stoviek milisekúnd – čo výrazne zlepšuje používateľskú skúsenosť. Na oplátku musíš správu rekonštruovať na strane klienta a spravovať stav, ktorý už neprichádza ako jeden blok.

Protokol SSE v detailoch

Takto vyzerá HTTP stream, ktorý prijímaš:

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ždý riadok začína data: , za ktorým nasleduje JSON objekt, a prázdne riadky slúžia ako oddeľovače medzi udalosťami. Všimni si detail, do ktorého pri prvej implementácii spadne každý: textový fragment sa nachádza v poli delta, nie v message ako v klasickom režime. Stream končí udalosťou data: [DONE], ktorá explicitne signalizuje koniec. Bez nej by si nedokázal rozlíšiť dokončené generovanie od prerušeného pripojenia.

Povolenie streamovania v Pythone

S Mistral SDK povolíš streamovanie volaním chat.stream() namiesto 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 si zaslúži vysvetlenie, pretože jeho zabudnutie je klasickou príčinou toho, že streamovanie „nefunguje“. Bez neho Python drží znaky vo vyrovnávacej pamäti a zobrazuje ich v blokoch. To vizuálne ruší všetky výhody streamovania, hoci chunky prichádzajú správne.

Štruktúra chunku

Streamingový chunk nečítaš ako úplnú odpoveď a cesty prístupu sa líšia:

# 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"

Prvý chunk zvyčajne nesie rolu bez textu, nasledujúce nesú fragmenty a posledný poskytuje finish_reason. Preto kontrola if content: v predchádzajúcom kóde nie je zbytočnou opatrnosťou: zreťazenie hodnoty None by spôsobilo zlyhanie slučky už v prvej iterácii.

Rekonštrukcia úplnej odpovede

Zobrazovanie fragmentov nestačí, keď potrebuješ odpoveď zachovať – napríklad na pridanie do histórie konverzácie, jej zaznamenanie alebo uloženie do databázy. Preto musíš text akumulovať paralelne so zobrazovaním:

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)")

Premenná finish_reason sa zachytáva v rovnakej slučke z rovnakého dôvodu ako v klasickom režime: odpoveď orezaná podľa max_tokens sa na obrazovke javí presne ako úplná odpoveď a len toto pole ti povie rozdiel.

Kedy použiť streamovanie

Streamovanie nie je vždy lepšie. Je vhodné vždy, keď sa človek pozerá na obrazovku, ale je nadbytočné alebo dokonca škodlivé, keď výstup spracúva stroj.

Prípad použitiaOdporúčanie
Interaktívny chatbotStreamovanie (lepšie UX)
Dávkové spracovanieBez streamovania (jednoduchšie)
Backend API pre frontendStreamovanie (SSE do prehliadača)
Dátové potrubieBez streamovania (atómové spracovanie)
Štruktúrovaná extrakciaBez streamovania (spoľahlivejšie parsovanie JSON)

Posledný prípad je najpoučnejší. Ak očakávaš JSON, streamovanie nič nepridá: neúplný objekt nemôžeš parsovať a rovnako budeš musieť počkať na posledný fragment. Rovnako dobre môžeš ponechať volanie atómové a kód jednoduchý.

Kľúčové poznatky

  • Streamovanie znižuje vnímanú latenciu odosielaním tokenov hneď, ako sú vygenerované
  • Protokol SSE je jednoduchý a robustný HTTP štandard
  • V režime streamovania používaj delta.content namiesto message.content
  • Akumuluj fragmenty na strane klienta, aby si rekonštruoval úplnú odpoveď
  • Uprednostni streamovanie pre používateľské rozhrania a režim bez streamovania pre automatizované spracovanie