Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Streamování SSE

Lekce 5 z 16 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Odpovědi v reálném čase pomocí Server-Sent Events
  2. Streamování versus nestreamování
  3. Protokol SSE v detailu
  4. Povolení streamování v Pythonu
  5. Struktura chunku
  6. Rekonstrukce úplné odpovědi
  7. Kdy použít streamování
  8. Klíčové poznatky

Odpovědi v reálném čase pomocí Server-Sent Events

Ve výchozím nastavení API Chat Completions čeká, až model dokončí generování celé odpovědi, a teprve poté ji odešle zpět tobě. U krátkého dotazu si nikdo zpoždění nevšimne. U tisíslové zprávy to však znamená několik vteřin prázdné obrazovky, což uživatele nutí přemýšlet, zda aplikace nespadla. Streamování tento problém řeší odesíláním tokenů okamžitě, jak jsou generovány, čímž vytváří známý efekt psacího stroje viděný v konverzačních rozhraních.

Použitým protokolem jsou Server-Sent Events (SSE), standard HTTP, který umožňuje serveru nepřetržitě odesílat data klientovi přes trvalé připojení. Není na tom nic exotického: žádné WebSockets k instalaci, žádné další závislosti.

Streamování versus nestreamování

V režimu bez streamování, což je výchozí nastavení, klient odešle požadavek a čeká na úplnou odpověď:

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

Výhodou je jednoduchost: odpověď je atomická, jediný objekt JSON, který se snadno zpracovává, validuje a ukládá. Nevýhoda je stejně zřejmá: vnímaná latence je vysoká, protože uživatel během celého procesu generování nic nevidí.

V režimu streamování server odesílá tokeny jeden po druhém nebo 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á latence dramaticky klesá – první znak se objeví během několika set milisekund – což výrazně zlepšuje uživatelský zážitek. Na oplátku musíš zprávu rekonstruovat na straně klienta a spravovat stav, který již nepřichází jako jeden blok.

Protokol SSE v detailu

Takto ve skutečnosti vypadá HTTP stream, který přijímáš:

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ý řádek začíná řetězcem data: , za kterým následuje objekt JSON, a prázdné řádky slouží jako oddělovače mezi událostmi. Všimni si detailu, na kterém při první implementaci všichni narazí: textový fragment se nachází v poli delta, nikoli v message jako v klasickém režimu. Stream končí událostí data: [DONE], která explicitně signalizuje konec. Bez ní bys nedokázal rozlišit dokončené generování od přerušeného připojení.

Povolení streamování v Pythonu

Pomocí Mistral SDK povolíš streamování voláním chat.stream() místo 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 zaslouží vysvětlení, protože jeho zapomenutí je klasickou příčinou toho, že streamování „nefunguje“. Bez něj Python udržuje znaky ve vyrovnávací paměti a zobrazuje je v blocích. Tím se vizuálně zruší všechny výhody streamování, i když chunky přicházejí správně.

Struktura chunku

Streamingový chunk nevypadá jako úplná odpověď a cesty přístupu se liší:

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

První chunk obvykle nese roli bez textu, následující nesou fragmenty textu a poslední poskytuje finish_reason. Proto kontrola if content: v předchozím kódu není zbytečnou opatrností: zřetězení hodnoty None by způsobilo selhání smyčky již v první iteraci.

Rekonstrukce úplné odpovědi

Zobrazování fragmentů nestačí, když potřebuješ odpověď uchovat – například ji přidat do historie konverzace, zaznamenat do logu nebo uložit do databáze. Text musíš proto paralelně se zobrazováním akumulovat:

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

Proměnná finish_reason je zachycena ve stejné smyčce ze stejného důvodu jako v klasickém režimu: odpověď zkrácená kvůli max_tokens se na obrazovce zobrazí přesně jako úplná odpověď a pouze toto pole ti řekne rozdíl.

Kdy použít streamování

Streamování není vždy lepší. Je vhodné vždy, když se na obrazovku dívá člověk, ale je nadbytečné nebo dokonce škodlivé, když výstup zpracovává stroj.

Případ použitíDoporučení
Interaktivní chatbotStreamování (lepší UX)
Dávkové zpracováníBez streamování (jednodušší)
Backend API pro frontendStreamování (SSE do prohlížeče)
Datové potrubíBez streamování (atomické zpracování)
Strukturovaná extrakceBez streamování (spolehlivější parsování JSON)

Poslední případ je nejpoučnější. Pokud očekáváš JSON, streamování nic nepřidá: neúplný objekt nelze parsovat a stejně budeš muset počkat na poslední fragment. Stejně tak můžeš ponechat volání atomické a kód jednoduchý.

Klíčové poznatky

  • Streamování snižuje vnímanou latenci odesíláním tokenů, jak jsou generovány
  • Protokol SSE je jednoduchý a robustní standard HTTP
  • V režimu streamování používej delta.content místo message.content
  • Akumuluj fragmenty na straně klienta pro rekonstrukci úplné odpovědi
  • Upřednostni streamování pro uživatelská rozhraní a režim bez streamování pro automatizované zpracování