Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Streamování: Přijímání odpovědí v reálném čase

Lekce 8 z 22 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Streamování: Přijímání odpovědí v reálném čase
  2. Proč streamovat
  3. Typované události, nikoliv beztvarý proud
  4. Streamování a volání funkcí
  5. Asynchronní případ
  6. Chyby uprostřed streamu
  7. Klíčové poznatky

Streamování: Přijímání odpovědí v reálném čase

Streamování ti umožňuje přijímat odpověď token po tokenu místo toho, abys čekal na dokončení celé generace. Nejde jen o vylepšení uživatelského rozhraní: právě to odděluje chatbota, který působí pomalu, od toho, který reaguje svižně, i když je výkon serveru totožný.

Proč streamovat

Bez streamování se uživatelé někdy dívají na prázdnou obrazovku deset až třicet sekund, než se najednou objeví celá odpověď. Při streamování se první slova zobrazí pod sekundu a čtení začíná ještě během generování. Celková doba trvání je stejná; vnímání nikoliv. Jeho povolení vyžaduje pouze jeden parametr, stream=True, který změní návratovou hodnotu create() na iterátor událostí.

from openai import OpenAI
client = OpenAI()

# BEZ streamování — čekej na vše
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Write a paragraph about artificial intelligence."
)
print(response.output_text)  # Objeví se najednou po čekání

# SE streamováním — token po tokenu
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ý řádek na konci

Typované události, nikoliv beztvarý proud

Stream nepřenáší pouze text. Upozorňuje tě, když je odpověď vytvořena, když je přidána každá výstupní položka, když přicházejí fragmenty a když dojde k dokončení — poslední událost zahrnuje metriky využití. Filtruješ podle event.type, abys věděl, s čím pracuješ. Tato struktura ti například umožňuje zobrazit indikátor načítání, jakmile se spustí response.created, a na konci sečíst tokeny bez druhého volání 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álné aplikaci budeš téměř vždy chtít dělat dvě věci najednou: zobrazovat fragmenty a rekonstruovat celý text, abys jej mohl archivovat nebo vrátit volajícímu. Pravidlo je jednoduché: akumuluj data během iterace, protože jakmile je stream spotřebován, nelze jej převinout zpět.

def stream_and_collect(prompt: str) -> str:
    """Streamuje odpověď a zároveň ji shromažď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ý řádek
    return full_text

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

Streamování a volání funkcí

Volání funkcí jsou také streamována s vlastními událostmi: argumenty přicházejí ve fragmentech přes response.function_call_arguments.delta a response.function_call_arguments.done signalizuje, že JSON je kompletní. To má důležitý praktický dopad — nikdy se nepokoušej deserializovat argumenty před událostí done, jinak budeš mít pouze oříznutý 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]

Asynchronní případ

Jakmile tvoje aplikace obsluhuje více uživatelů současně, přepni se na AsyncOpenAI: synchronní klient by blokoval smyčku událostí po celou dobu generování a způsobil by čekání tvých dalších požadavků. Syntaxe se liší pouze dvěma klíčovými slovy — await při vytváření a async for při iteraci.

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_async(prompt: str):
    """Asynchronní streamování odpovědi."""
    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 webu je streamování zbytečné, pokud skončí na tvém serveru: musíš jej rozšířit až do prohlížeče. FastAPI to umožňuje pomocí StreamingResponse, které je napájeno generátorem přeposílajícím fragmenty, jak přicházejí.

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 uprostřed streamu

Jeden detail si zaslouží tvou pozornost: při streamování může dojít k chybě poté, co již byly zobrazeny fragmenty. Uživatel pak vidí odpověď, která začala, ale byla přerušena. Proto obal samotnou iteraci, nejen vytvoření streamu, abys mohl čistě signalizovat přerušení, místo aby věta zůstala nedokončená.

from openai import APIError

def stream_with_errors(prompt: str):
    """Streamování s robustním ošetřením chyb."""
    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.")

Klíčové poznatky

  • Povol streamování pomocí stream=True pro zážitek v reálném čase
  • Filtruj události podle event.type, abys správně zpracoval každý typ dat
  • response.output_text.delta obsahuje textové fragmenty
  • response.completed signalizuje konec a zahrnuje metriky využití
  • Pro streamování v asynchronních aplikacích použij AsyncOpenAI
  • Vždy ošetřuj chyby, a to i v režimu streamování