Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

SSE straumēšana

Nodarbība 5 no 16 Atjaunota 2026. gada 2. novembris Programmētājs
Šajā lapā
  1. Reāllaika atbildes, izmantojot Server-Sent Events
  2. Straumēšana pretī nestrāmēšanai
  3. SSE protokols detalizēti
  4. Straumēšanas iespējošana Python valodā
  5. Čunka (fragmenta) struktūra
  6. Pilnas atbildes rekonstruēšana
  7. Kad izmantot straumēšanu
  8. Galvenās atziņas

Reāllaika atbildes, izmantojot Server-Sent Events

Pēc noklusējuma Chat Completions API gaida, līdz modelis ir beidzis ģenerēt visu savu atbildi, pirms tā tiek nosūtīta tev atpakaļ. Īsam jautājumam neviens šo aizkavi nepamanīs. Tomēr tūkstoš vārdu garam ziņojumam tas nozīmē vairākas sekundes ar tukšu ekrānu, liekot lietotājam brīnīties, vai lietotne nav sabrukusi. Straumēšana atrisina šo problēmu, nosūtot tokenus to ģenerēšanas brīdī, radot pazīstamo rakstāmmašīnas efektu, ko redzam sarunu saskarnēs.

Izmantotais protokols ir Server-Sent Events (SSE) – HTTP standarts, kas ļauj serverim nepārtraukti sūtīt datus klientam, izmantojot pastāvīgu savienojumu. Šeit nav nekā eksotiska: nav jāinstalē WebSockets, nav vajadzīgas papildu atkarības.

Straumēšana pretī nestrāmēšanai

Nestrāmēšanas režīmā, kas ir noklusējums, klients nosūta pieprasījumu un gaida pilnu atbildi:

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

Priekšrocība ir vienkāršība: atbilde ir atomāra, viens JSON objekts, ko ir viegli apstrādāt, validēt un saglabāt. Trūkums ir tikpat acīmredzams: uztvertā latentitāte ir augsta, jo lietotājs visā ģenerēšanas procesā neredz neko.

Straumēšanas režīmā serveris nosūta tokenus pa vienam vai mazās grupās:

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

Uztvertā latentitāte krītas dramatiski – pirmā zīme parādās dažu simtu milisekunžu laikā, ievērojami uzlabojot lietotāja pieredzi. Pretī tam tev ir jārekonstruē ziņojums klienta pusē un jāpārvalda stāvoklis, kas vairs nenāk kā viens bloks.

SSE protokols detalizēti

Lūk, kā izskatās HTTP straume, ko saņemsi:

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]

Katra rinda sākas ar data: , kam seko JSON objekts, bet tukšās rindas kalpo kā atdalītāji starp notikumiem. Pievērs uzmanību detaļai, kurā iekrīt ikviens savā pirmajā implementācijā: teksta fragments atrodas laukā delta, nevis message, kā tas ir klasiskajā režīmā. Straume beidzas ar notikumu data: [DONE], kas skaidri signalizē beigās. Bez tā tu nevarētu atšķirt pabeigtu ģenerēšanu no pārtraukta savienojuma.

Straumēšanas iespējošana Python valodā

Izmantojot Mistral SDK, tu iespējo straumēšanu, izsaucot chat.stream() chat.complete() vietā:

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

Arguments flush=True ir pelnījis skaidrojumu, jo tā aizmirstšana ir klasiskais iemesls, kāpēc straumēšana „nestrādā”. Bez tā Python glabā zīmes buferī un attēlo tās blokos. Tas vizuāli anulē visus straumēšanas ieguvumus, lai gan čunki (fragmenti) pienāk pareizi.

Čunka (fragmenta) struktūra

Straumēšanas čunks nelasās kā pilna atbilde, un piekļuves ceļi atšķiras:

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

Pirmais čunks parasti nes lomu bez teksta, nākamie nes teksta fragmentus, bet pēdējais nodrošina finish_reason. Tieši tāpēc if content: pārbaude iepriekšējā kodā nav lieka piesardzība: None vērtības konkatenācija liktu ciklam izgāzties jau pirmajā iterācijā.

Pilnas atbildes rekonstruēšana

Fragmentu attēlošana nepietiek, ja tev ir jāglabā atbilde – piemēram, lai pievienotu to sarunas vēsturei, reģistrētu žurnālā vai saglabātu datubāzē. Tāpēc tev ir paralēli attēlošanai jāuzkrāj teksts:

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

Mainīgais finish_reason tiek fiksēts tajā pašā ciklā tāda paša iemesla dēļ kā klasiskajā režīmā: atbilde, kas apgriezta ar max_tokens, ekrānā izskatās tieši tāpat kā pilna atbilde, un tikai šis lauks tev pateiks starpību.

Kad izmantot straumēšanu

Straumēšana ne vienmēr ir labāka. Tā ir indicēta, kad ekrānu vēro cilvēks, bet lieka vai pat kaitīga, kad izvadi apstrādā mašīna.

Lietojuma gadījumsIeteikums
Interaktīvs čatbotsStraumēšana (labāka lietotāja pieredze)
Apjomu apstrāde (Batch processing)Nestrāmēšana (vienkāršāk)
Backend API priekš frontendStraumēšana (SSE uz pārlūku)
Datu konveijersNestrāmēšana (atomāra apstrāde)
Strukturēta ekstrakcijaNestrāmēšana (uzticamāka JSON parsēšana)

Pēdējais gadījums ir vispamācošākais. Ja tu gaidi JSON, straumēšana nedod nekādu labumu: tu nevari parsēt nepabeigtu objektu, un tāpat nāksies gaidīt pēdējo fragmentu. Vienkārši atstāj izsaukumu atomāru un kodu vienkāršu.

Galvenās atziņas

  • Straumēšana samazina uztverto latentitāti, nosūtot tokenus to ģenerēšanas brīdī
  • SSE protokols ir vienkāršs un robusts HTTP standarts
  • Straumēšanas režīmā izmanto delta.content message.content vietā
  • Uzkrāj fragmentus klienta pusē, lai rekonstruētu pilnu atbildi
  • Dod priekšroku straumēšanai lietotāja saskarnēm, bet nestrāmēšanai – automatizētai apstrādei