Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Streaming SSE

5. lecke 16 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Valós idejű válaszok Server-Sent Events segítségével
  2. Streaming vs. nem streaming mód
  3. Az SSE protokoll részletesen
  4. A streaming engedélyezése Pythonban
  5. Egy chunk szerkezete
  6. A teljes válasz újraösszerakása
  7. Mikor használj streaminget?
  8. Főbb megállapítások

Valós idejű válaszok Server-Sent Events segítségével

Alapértelmezés szerint a Chat Completions API megvárja, amíg a modell teljesen befejezi a válasz generálását, mielőtt visszaküldené azt neked. Egy rövid kérdés esetén senki nem veszi észre a késleltetést. Egy ezer szavas jelentés esetén azonban ez több másodpercnyi üres képernyőt jelent, amitől a felhasználód azt hiheti, hogy az alkalmazás lefagyott. A streaming megoldja ezt a problémát azáltal, hogy a tokeneket generálás közben küldi el, létrehozva azt a beszélgető felületekről ismerős írógép-hatást.

A használt protokoll a Server-Sent Events (SSE), egy HTTP-szabvány, amely lehetővé teszi a szerver számára, hogy folyamatos kapcsolaton keresztül adatokat küldjön a kliensnek. Nincs itt semmi egzotikus: nincs szükség WebSocket telepítésére, nincs szükség extra függőségekre.

Streaming vs. nem streaming mód

Nem streaming módban, ami az alapértelmezett, a kliens elküldi a kérést, és megvárja a teljes választ:

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

Előnye az egyszerűség: a válasz atomi, egyetlen JSON-objektum, amelyet könnyű feldolgozni, validálni és tárolni. A hátrány ugyanilyen egyértelmű: az érzékelt késleltetés magas, mert a felhasználó a teljes generálási folyamat alatt semmit sem lát.

Streaming módban a szerver tokenenként vagy kis csoportokban küldi az adatokat:

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

Az érzékelt késleltetés drasztikusan csökken – az első karakter néhány száz milliszekundumon belül megjelenik –, ami jelentősen javítja a felhasználói élményt. Cserébe neked kell újraösszeraknod az üzenetet a kliens oldalon, és kezelned az állapotot, amely már nem egyetlen blokkként érkezik.

Az SSE protokoll részletesen

Így néz ki valójában a fogadott HTTP adatfolyam:

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]

Minden sor a data: karaktersorozattal kezdődik, amelyet egy JSON-objektum követ, az üres sorok pedig elválasztóként szolgálnak az események között. Figyeld meg azt a részletet, amelybe mindenki belebukik az első implementáció során: a szövegrészlet a delta mezőben található, nem a message mezőben, mint a klasszikus módban. Az adatfolyam egy data: [DONE] eseménnyel végződik, amely expliciten jelzi a befejezést. Enélkül nem tudnád megkülönböztetni a befejezett generálást a megszakadt kapcsolattól.

A streaming engedélyezése Pythonban

A Mistral SDK-val a streaminget úgy engedélyezed, hogy a chat.complete() helyett a chat.stream() metódust hívod meg:

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

A flush=True argumentum magyarázatra szorul, mivel ennek elfelejtése a streaming „nem működik“ jellegű hibák klasszikus oka. Enélkül a Python a pufferekben tartja a karaktereket, és blokkokban jeleníti meg őket. Ez vizuálisan megszünteti a streaming összes előnyét, még akkor is, ha a chunkok megfelelően érkeznek.

Egy chunk szerkezete

Egy streaming chunk nem úgy olvasható, mint egy teljes válasz, és a hozzáférési utak is eltérnek:

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

Az első chunk általában a szerepet tartalmazza szöveg nélkül, a következők a szövegrészleteket, az utolsó pedig a finish_reason értéket szolgáltatja. Ezért nem felesleges óvintézkedés az előző kódban szereplő if content: ellenőrzés: egy None érték összefűzése miatt a ciklus már az első iterációnál elbukna.

A teljes válasz újraösszerakása

A részletek megjelenítése nem elég, ha meg kell őrizned a választ – például hogy hozzáadd a beszélgetés előzményeihez, naplózd, vagy elmentsd egy adatbázisba. Ezért párhuzamosan kell felhalmoznod a szöveget a megjelenítéssel:

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

A finish_reason változót ugyanazon okból rögzítjük ugyanabban a ciklusban, mint a klasszikus módban: a max_tokens által csonkított válasz pontosan úgy jelenik meg a képernyőn, mint egy teljes válasz, és csak ez a mező árulja el a különbséget.

Mikor használj streaminget?

A streaming nem mindig jobb. Ott javasolt, ahol emberi szem figyeli a képernyőt, de felesleges, sőt káros, amikor egy gép dolgozza fel a kimenetet.

Használati esetAjánlás
Interaktív chatbotStreaming (jobb UX)
Köteges feldolgozásNem streaming (egyszerűbb)
Backend API frontendhezStreaming (SSE a böngésző felé)
Adatfolyamat (Data pipeline)Nem streaming (atomi feldolgozás)
Strukturált kinyerésNem streaming (megbízhatóbb JSON-elemzés)

Az utolsó eset a legtanulságosabb. Ha JSON-t vársz, a streaming nem ad hozzá semmit: nem tudsz egy hiányos objektumot elemezni, és amúgy is meg kell várnod az utolsó részletet. Érdemes tehát atomi hívást megtartani, és a kódot egyszerűen hagyni.

Főbb megállapítások

  • A streaming csökkenti az érzékelt késleltetést azáltal, hogy a tokeneket generálás közben küldi el
  • Az SSE protokoll egy egyszerű és robusztus HTTP-szabvány
  • Streaming módban a delta.content használandó a message.content helyett
  • Halmozd fel a részleteket a kliens oldalon a teljes válasz újraösszerakásához
  • Részesítsd előnyben a streaminget a felhasználói felületeknél, a nem streaminget pedig az automatizált feldolgozásnál