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

Streamovanie: Prijímanie odpovedí v reálnom čase

Lekcia 8 z 22 Aktualizované 29. júla 2026 Vývojár
Na tejto strane
  1. Streamovanie: Prijímanie odpovedí v reálnom čase
  2. Prečo streamovať
  3. Typované udalosti, nie nediferencovaný prúd
  4. Streamovanie a volanie funkcií
  5. Asynchrónny prípad
  6. Chyby počas streamovania
  7. Kľúčové poznatky

Streamovanie: Prijímanie odpovedí v reálnom čase

Streamovanie ti umožňuje prijímať odpoveď token po tokene namiesto čakania na dokončenie celej generácie. Nie je to len kozmetická úprava rozhrania: práve toto oddeľuje chatbota, ktorý pôsobí pomaly, od toho, ktorý pôsobí svižne, aj keď je výkon servera úplne rovnaký.

Prečo streamovať

Bez streamovania sa používatelia niekedy pozerajú na prázdnu obrazovku desať až tridsať sekúnd, kým sa celá odpoveď objaví naraz. So streamovaním sa prvé slová objavia za menej ako sekundu a čítanie začína ešte počas generovania. Celková dĺžka trvania je rovnaká, vnímanie však nie. Jeho aktivácia si vyžaduje len jeden parameter, stream=True, ktorý zmení návratovú hodnotu create() na iterátor udalostí.

from openai import OpenAI
client = OpenAI()

# BEZ streamovania — čakanie na všetko
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Write a paragraph about artificial intelligence."
)
print(response.output_text)  # Objaví sa naraz po čakání

# SO streamovaním — token po tokene
stream = client.responses.create(
    model="gpt-5.6-terra",
    input="Write a paragraph about artificial intelligence.",
    stream=True
)

for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)
print()  # Nový riadok na konci

Typované udalosti, nie nediferencovaný prúd

Stream neprenáša len text. Upozorňuje ťa, keď sa odpoveď vytvorí, keď sa pridá každá výstupná položka, keď prichádzajú fragmenty a keď dôjde k dokončeniu – posledná udalosť obsahuje metriky využitia. Filtruješ podľa event.type, aby si vedel, s čím pracuješ. Táto štruktúra ti umožňuje napríklad zobraziť indikátor načítania hneď, ako sa spustí response.created, a na konci spočítať tokeny bez ďalšieho volania API.

stream = client.responses.create(
    model="gpt-5.6-terra",
    input="Hello!",
    stream=True
)

for event in stream:
    match event.type:
        case "response.created":
            print(f"[Response created] ID: {event.response.id}")
        case "response.output_item.added":
            print(f"[New output item]")
        case "response.output_text.delta":
            print(f"[Text] {event.delta}", end="")
        case "response.output_text.done":
            print(f"\n[Text complete]")
        case "response.completed":
            print(f"[Done] Tokens: {event.response.usage.total_tokens}")

# Výstup:
# [Response created] ID: resp_abc123
# [New output item]
# [Text] Hello[Text] ! [Text] How[Text] can[Text] I...
# [Text complete]
# [Done] Tokens: 25

V reálnej aplikácii budeš takmer vždy chcieť robiť dve veci naraz: zobrazovať fragmenty a rekonštruovať celý text, aby si ho mohol archivovať alebo vrátiť volajúcemu. Pravidlo je jednoduché: akumuluj počas iterácie, pretože keď sa stream spotrebuje, nemožno ho previnúť späť.

def stream_and_collect(prompt: str) -> str:
    """Streamuje odpoveď a zároveň ju zhromažďuje."""
    stream = client.responses.create(
        model="gpt-5.6-terra",
        input=prompt,
        stream=True
    )

    full_text = ""
    for event in stream:
        if event.type == "response.output_text.delta":
            full_text += event.delta
            print(event.delta, end="", flush=True)

    print()  # Nový riadok
    return full_text

result = stream_and_collect("List 3 European capitals.")
print(f"\nCollected text ({len(result)} characters)")

Streamovanie a volanie funkcií

Volania funkcií sa tiež streamujú s vlastnými udalosťami: argumenty prichádzajú vo fragmentoch cez response.function_call_arguments.delta a response.function_call_arguments.done signalizuje, že JSON je kompletný. Má to dôležitý praktický dôsledok – nikdy sa nepokúšaj deserializovať argumenty pred udalosťou done, inak budeš mať len orezaný JSON.

stream = client.responses.create(
    model="gpt-5.6-terra",
    input="What time is it in Tokyo?",
    tools=[{
        "type": "function",
        "name": "get_time",
        "description": "Get the time in a city",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string"}
            },
            "required": ["city"]
        }
    }],
    stream=True
)

for event in stream:
    match event.type:
        case "response.output_text.delta":
            print(event.delta, end="")
        case "response.function_call_arguments.delta":
            print(f"[Args] {event.delta}", end="")
        case "response.function_call_arguments.done":
            print(f"\n[Function call complete]")

# Výstup:
# [Args] {"city": "Tokyo"}
# [Function call complete]

Asynchrónny prípad

Akonáhle tvoja aplikácia obsluhuje viacerých používateľov súčasne, prepnite na AsyncOpenAI: synchroný klient by blokoval slučku udalostí počas celej generácie, čo by spôsobilo čakanie ostatných požiadaviek. Syntax sa líši len dvoma kľúčovými slovami – await pri vytváraní a async for pri iterácii.

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_async(prompt: str):
    """Asynchrónne streamovanie odpovede."""
    stream = await async_client.responses.create(
        model="gpt-5.6-terra",
        input=prompt,
        stream=True
    )

    async for event in stream:
        if event.type == "response.output_text.delta":
            print(event.delta, end="", flush=True)
    print()

asyncio.run(stream_async("Tell a short joke."))

Na webe je streamovanie zbytočné, ak sa zastaví na tvojom serveri: musíš ho rozšíriť až do prehliadača. FastAPI to umožňuje pomocou StreamingResponse, ktorý je napájaný generátorom preposielajúcim fragmenty, ako prichádzajú.

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from openai import OpenAI

app = FastAPI()
client = OpenAI()

@app.get("/chat")
async def chat(question: str):
    def generate():
        stream = client.responses.create(
            model="gpt-5.6-terra",
            input=question,
            stream=True
        )
        for event in stream:
            if event.type == "response.output_text.delta":
                yield event.delta

    return StreamingResponse(generate(), media_type="text/plain")

Chyby počas streamovania

Jeden detail si zaslúži tvoju pozornosť: pri streamovaní môže dôjsť k chybe až po zobrazení fragmentov. Používateľ potom vidí odpoveď, ktorá začala, ale bola prerušená. Preto obal samotnú iteráciu, nielen vytvorenie streamu, aby si mohol čisto signalizovať prerušenie namiesto toho, aby si nechal vetu visieť vo vzduchu.

from openai import APIError

def stream_with_errors(prompt: str):
    """Streamovanie s robustným ošetrovaním chýb."""
    try:
        stream = client.responses.create(
            model="gpt-5.6-terra",
            input=prompt,
            stream=True
        )

        for event in stream:
            if event.type == "response.output_text.delta":
                print(event.delta, end="", flush=True)
        print()

    except APIError as e:
        print(f"\nAPI error during streaming: {e.message}")
    except Exception as e:
        print(f"\nUnexpected error: {e}")

stream_with_errors("Explain streaming in 2 sentences.")

Kľúčové poznatky

  • Povoľ streamovanie pomocou stream=True pre zážitok v reálnom čase
  • Filtruj udalosti podľa event.type, aby si správne spracoval každý typ dát
  • response.output_text.delta obsahuje textové fragmenty
  • response.completed signalizuje koniec a obsahuje metriky využitia
  • Použi AsyncOpenAI pre streamovanie v asynchrónnych aplikáciách
  • Vždy ošetruj chyby, aj v režime streamovania