Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Pretakanje SSE

Lekcija 5 od 16 Posodobljeno 2. november 2026 Razvijalec
Na tej strani
  1. Odzivi v realnem času s strežniškimi dogodki (SSE)
  2. Pretakanje proti nepretakanju
  3. Protokol SSE podrobneje
  4. Omogočanje pretakanja v Pythonu
  5. Struktura kosov (chunk)
  6. Rekonstrukcija popolnega odgovora
  7. Kdaj uporabiti pretakanje
  8. Ključne ugotovitve

Odzivi v realnem času s strežniškimi dogodki (SSE)

Privzeto API za dopolnjevanje klepetov počaka, da model v celoti ustvari odgovor, šele nato pa ga pošlje nazaj tebi. Pri kratkem vprašanju nihče ne opazi zamika. Pri tisoč besed dolgem poročilu pa to pomeni več sekund praznega zaslona, zaradi česar se uporabnik sprašuje, ali se je aplikacija sesula. Pretakanje reši ta problem tako, da pošilja žetone sproti, medtem ko nastajajo, kar ustvari znan učinek pisalnega stroja, ki ga vidimo v pogovornih vmesnikih.

Uporabljeni protokol so strežniški dogodki (Server-Sent Events – SSE), standard HTTP, ki strežniku omogoča neprekinjeno potiskanje podatkov odjemalcu prek trajne povezave. Tu ni nič eksotičnega: ni treba nameščati vtičnikov WebSocket ali dodajati dodatnih odvisnosti.

Pretakanje proti nepretakanju

V načinu brez pretakanja, ki je privzet, odjemalec pošlje zahtevo in čaka na popoln odgovor:

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

Prednost je preprostost: odgovor je atomaren, en sam objekt JSON, ki ga je enostavno obdelati, preveriti in shraniti. Slabost je enako očitna: zaznana zakasnitev je velika, saj uporabnik med celotnim postopkom ustvarjanja ne vidi ničesar.

V načinu pretakanja strežnik pošilja žetone enega za drugim ali v majhnih skupinah:

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

Zaznana zakasnitev se drastično zmanjša – prvi znak se prikaže v nekaj sto milisekundah – kar bistveno izboljša uporabniško izkušnjo. V zameno moraš na strani odjemalca znova sestaviti sporočilo in upravljati stanje, ki ne prihaja več kot en sam blok.

Protokol SSE podrobneje

Tako dejansko izgleda tok HTTP, ki ga prejmeš:

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]

Vsaka vrstica se začne z data: , ki mu sledi objekt JSON, prazne vrstice pa služijo kot ločila med dogodki. Opazi podrobnost, ki ujame vsakogar ob prvi implementaciji: besedilni delček se nahaja v polju delta, ne v message, kot je značilno za klasični način. Tok se konča z dogodkom data: [DONE], ki izrecno signalizira konec. Brez tega ne bi mogel razlikovati med končanim ustvarjanjem in prekinjeno povezavo.

Omogočanje pretakanja v Pythonu

Z SDK-jem Mistral pretakanje omogočiš tako, da pokličeš chat.stream() namesto 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 zasluži razlago, saj je njegovo pozabljanje klasičen vzrok za pretakanje, ki „ne deluje”. Brez njega Python znake zadržuje v medpomnilniku in jih prikazuje v blokih. To vizualno poniči vse prednosti pretakanja, čeprav žetoni prihajajo pravilno.

Struktura kosov (chunk)

Kos pri pretakanju se ne bere kot popoln odgovor, poti dostopa pa so drugačne:

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

Prvi kos običajno nosi vlogo brez besedila, naslednji vsebujejo besedilne delčke, zadnji pa zagotavlja finish_reason. Zato preverjanje if content: v prejšnji kodi ni nepotrebna previdnost: združevanje vrednosti None bi povzročilo napako zanke že v prvi iteraciji.

Rekonstrukcija popolnega odgovora

Prikazovanje delčkov ni dovolj, ko moraš odgovor ohraniti – na primer, da ga dodaš v zgodovino pogovora, ga zabeležiš ali shraniš v zbirko podatkov. Zato moraš besedilo kopičiti vzporedno s prikazovanjem:

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

Spremenljivko finish_reason zajameš v isti zanki iz istega razloga kot v klasičnem načinu: odgovor, okrnjen zaradi max_tokens, se na zaslonu prikaže popolnoma enako kot popoln odgovor, in le to polje ti bo povedalo razliko.

Kdaj uporabiti pretakanje

Pretakanje ni vedno boljše. Priporočljivo je, kadar človek gleda zaslon, odvečno ali celo škodljivo pa, ko izhod obdeluje stroj.

Primer uporabePriporočilo
Interaktivni klepetalni botPretakanje (boljša UX)
Serijska obdelavaBrez pretakanja (preprosteje)
Zaledni API za spletni vmesnikPretakanje (SSE do brskalnika)
Podatkovni cevovodBrez pretakanja (atomarna obdelava)
Strukturirana ekstrakcijaBrez pretakanja (zanesljivejše razčlenjevanje JSON)

Zadnji primer je najbolj poučen. Če pričakuješ JSON, pretakanje ne doda ničesar: nepopolnega objekta ne moreš razčleniti in tako ali tako moraš počakati na zadnji delček. Prav tako dobro lahko ohraniš klic atomaren in kodo preprosto.

Ključne ugotovitve

  • Pretakanje zmanjša zaznano zakasnitev s pošiljanjem žetonov sproti, medtem ko nastajajo
  • Protokol SSE je preprost in robusten standard HTTP
  • V načinu pretakanja uporabi delta.content namesto message.content
  • Kopiči delčke na strani odjemalca, da rekonstruiraš popoln odgovor
  • Pretakanje raje uporabi za uporabniške vmesnike, nepretakanje pa za avtomatizirano obdelavo