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

Streamovanie odpovedí v Pythone

Lekcia 6 z 14 Aktualizované 2. novembra 2026 Vývojár
Na tejto strane
  1. Problém, ktorý streamovanie rieši
  2. Používanie chat.stream()
  3. Čo obsahuje časť (chunk)
  4. Súčasné zobrazovanie a ukladanie
  5. Asynchrónny variant
  6. Kedy streamovať a kedy nie
  7. Kľúčové poznatky

Problém, ktorý streamovanie rieši

Pri použití chat.complete() čakáš, kým model vygeneruje celú odpoveď, než dostaneš jediný znak. Pri krátkej odpovedi si toto oneskorenie ani nevšimneš. No pri podrobnej analýze, dlhom úryvku kódu alebo logickom uvažovaní rozdelenom do viacerých odsekov sa používateľ pozerá na prázdnu obrazovku niekoľko sekúnd. V chatovom rozhraní môže aj pár sekúnd ticha spôsobiť, že aplikácia pôsobí zaseknuto.

Streamovanie mení tento dojem: odpoveď prichádza postupne, po častiach, a zobrazuje sa priebežne, presne ako v chatových rozhraniach, ktoré poznáš. Celkový čas generovania sa nezkrátí ani o milisekundu, ale prvé slovo sa objaví takmer okamžite. Práve toto počiatočné oneskorenie je to, čo používateľ skutočne vníma.

Používanie chat.stream()

Mistral SDK V2 poskytuje metódu chat.stream(), ktorá namiesto jedného objektu vráti iterátor častí:

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

stream = client.chat.stream(
    model="mistral-small-latest",
    messages=[
        {
            "role": "user",
            "content": "Describe the steps to deploy a Flask application on a Linux server."
        }
    ]
)

for chunk in stream:
    content = chunk.data.choices[0].delta.content
    if content:
        print(content, end="", flush=True)

# Final newline
print()

V tejto slučke robia rozdiel dva detaily. Kontrola if content je nevyhnutná, pretože niektoré časti prichádzajú bez textu a inak by sa vytlačilo None. A flush=True prinúti Python zapísať údaje okamžite na výstup namiesto čakania na naplnenie vyrovnávacej pamäte. Bez toho by sa celý text objavil naraz až na konci, čo by úplne zničilo výhodu, o ktorú sa usiluješ.

Aspektchat.complete()chat.stream()
Návratová hodnotaKompletný objektIterátor častí
Vnímaná latenciaVysoká (čakanie na celok)Nízka (rýchly prvý token)
Prístup k texturesponse.choices[0].message.contentchunk.data.choices[0].delta.content
Využitie tokenovDostupné v odpovediDostupné v poslednej časti

Čo obsahuje časť (chunk)

Každá časť nesie delta, čo znamená fragment práve vznikajúcej odpovede. Jej preskúmaním získaš prístup k textu aj k metadátam o konci streamu:

for chunk in stream:
    delta = chunk.data.choices[0].delta

    # Textový obsah (môže byť None pre niektoré časti)
    text = delta.content

    # Dôvod zastavenia (None okrem poslednej časti)
    end = chunk.data.choices[0].finish_reason

    if text:
        print(text, end="", flush=True)

    if end:
        print(f"\n[Stream end: {end}]")

Tok vždy prebieha podľa rovnakej choreografie: prvá časť zvyčajne nesie rolu assistant, stredné časti doručujú text v malých kúskoch a posledná poskytuje finish_reason. Kontrolou tejto poslednej časti zistíš, či odpoveď skončila normálne, alebo bola prerušená limitom max_tokens.

Súčasné zobrazovanie a ukladanie

Streamovanie má jednu nevýhodu: text sa míňa pred očami, ale nikde ho nemáš uložený. Reálna aplikácia však často potrebuje archivovať odpoveď v databáze kvôli histórii konverzácie. Riešením je akumulovať fragmenty počas ich zobrazovania:

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

stream = client.chat.stream(
    model="mistral-small-latest",
    messages=[
        {"role": "user", "content": "List five Python web frameworks."}
    ]
)

full_response = []

for chunk in stream:
    content = chunk.data.choices[0].delta.content
    if content:
        full_response.append(content)
        print(content, end="", flush=True)

print()

# Znovu zostavená kompletná odpoveď
final_text = "".join(full_response)
print(f"\nTotal length: {len(final_text)} characters")

Všimni si použitie zoznamu a následné volanie "".join() namiesto spájania reťazcov v každom kroku slučky. Pri dlhej odpovedi by druhý prístup kopíroval všetok doteraz nazbieraný text pre každý prijatý fragment, čo je neefektívne.

Asynchrónny variant

Vo webovom serveri (FastAPI, aiohttp) synchronná verzia blokuje vlákno počas celej generácie, čím zmrazí ostatné prebiehajúce požiadavky. SDK preto poskytuje chat.stream_async():

import asyncio
import os
from mistralai.client import Mistral

async def generate_response():
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

    stream = await client.chat.stream_async(
        model="mistral-small-latest",
        messages=[
            {"role": "user", "content": "Explain the concept of a coroutine in Python."}
        ]
    )

    async for chunk in stream:
        content = chunk.data.choices[0].delta.content
        if content:
            print(content, end="", flush=True)

    print()

asyncio.run(generate_response())

Štruktúra je totožná so synchronnou verziou, líši sa len kľúčovými slovami await a async for. Akonáhle tvoj kód beží vo webovom serveri, toto je variant, ktorý musíš použiť.

Kedy streamovať a kedy nie

V chatovom rozhraní je streamovanie vždy povinné: ide o komfort čítania. Na strane backendového API sa oplatí ho povoliť, pokiaľ tvoj frontend dokáže spracovávať Server-Sent Events. Pri akejkoľvek odpovedi dlhšej než pár viet prínos vo vnímanej latencii ospravedlňuje pridanú zložitosť. Naopak, v dávkovom skripte, ktorý spracováva tisíce dokumentov a zapisuje výsledky do súboru, sa nikto nepozerá na obrazovku: chat.complete() zostáva jednoduchšie a úplne postačujúce riešenie.

Kľúčové poznatky

  • chat.stream() vracia iterátor častí určený na postupné zobrazovanie
  • Obsah sa nachádza v chunk.data.choices[0].delta.content
  • Na zobrazovanie v reálnom čase používaj v príkazoch print() parameter flush=True
  • Ak je to potrebné, zrekonštruuj kompletnú odpoveď akumuláciou častí
  • Pre webové aplikácie sa odporúča asynchrónna verzia chat.stream_async()