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

Optimalizované streamování

Lekce 5 z 20 Aktualizováno 28. července 2026 Pokročilý
Na této stránce
  1. Co streamování skutečně mění
  2. Spotřeba streamu na straně klienta
  3. Předávání streamu do prohlížeče
  4. Udržování připojení v čase
  5. Klíčové poznatky

Co streamování skutečně mění

Streamování nezrychluje model: činí čekání snesitelným. U odpovědi, jejíž generování trvá pět sekund, se uživatel bez streamování dívá pět sekund na prázdnou obrazovku, než obdrží blok textu. Se streamováním vidí první slova po několika stovkách milisekund a čte si společně s modelem, jak píše. Celková doba trvání je totožná, ale vnímání je zcela odlišné. Proto je vynechání streamování v produkci téměř vždy chybou v návrhu, nikoliv vědomou volbou.

Stream však musí protékat celým tvým řetězcem. Stream správně generovaný API, ale akumulovaný tvým aplikačním serverem nebo bufferovaný reverzní proxy, dorazí k uživateli jako jeden blok: zaplatil jsi cenu za složitost streamování, aniž bys sklidil jeho výhody. Tato lekce proto sleduje kompletní cestu od volání API až po prohlížeč.

Spotřeba streamu na straně klienta

Pomocí Responses API nastavení stream=True transformuje odpověď na sekvenci typovaných událostí, kterými iteruješ, jak přicházejí. Každý fragment textu dorazí v události response.output_text.delta; konec streamu je signalizován událostí response.completed, která nese celý objekt odpovědi, což je užitečné pro získání využití tokenů.

import openai

client = openai.OpenAI()

def generate_streaming(prompt: str):
    """Streamované generování s Responses API."""
    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)
        elif event.type == "response.completed":
            print()  # Nový řádek na konci
            return event.response

Příznak flush=True není kosmetický: bez něj Python sám bufferuje výstup a skončíš s chováním bloku, kterému ses chtěl vyhnout. Tento detail se opakuje v každé vrstvě řetězce a je hlavní obtížností streamování.

Mechanismus také pokrývá volání funkcí. Argumenty nástrojů se budují postupně a můžeš je zobrazovat, jak se generují, abys signalizoval uživateli, že se formuluje vyhledávání, místo abys ho nechal zírat na zamrzlé rozhraní, zatímco model připravuje své volání.

tools = [
    {
        "type": "function",
        "name": "search_product",
        "description": "Searches for a product in the catalog.",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {"type": "string"},
                "category": {"type": "string"},
            },
            "required": ["query"],
        },
    }
]

def streaming_with_tools(prompt: str):
    stream = client.responses.create(
        model="gpt-5.6-terra",
        input=prompt,
        tools=tools,
        stream=True,
    )

    for event in stream:
        match event.type:
            case "response.output_text.delta":
                print(event.delta, end="", flush=True)
            case "response.function_call_arguments.delta":
                # Argumenty funkce právě generované
                print(f"[arg: {event.delta}]", end="")
            case "response.function_call_arguments.done":
                print(f"\n[Function call complete]")

Předávání streamu do prohlížeče

Tvůj frontend nekomunikuje přímo s OpenAI API – komunikuje s tvým serverem, který musí stream dále předávat. Server-Sent Events (SSE) jsou pro toto přirozeným formátem: HTTP odpověď, která zůstává otevřená, kde každý řádek data: nese fragment JSON. Následující příklad předává text, jak přichází, a poté vysílá závěrečnou zprávu obsahující počet tokenů, což ti umožňuje fakturovat nebo logovat bez druhého volání.

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

app = FastAPI()
client = openai.OpenAI()

@app.post("/api/chat")
async def chat_streaming(request: dict):
    prompt = request["message"]

    async def generate():
        stream = client.responses.create(
            model="gpt-5.6-terra",
            input=prompt,
            stream=True,
        )

        for event in stream:
            if event.type == "response.output_text.delta":
                data = json.dumps({"text": event.delta})
                yield f"data: {data}\n\n"
            elif event.type == "response.completed":
                usage = event.response.usage
                data = json.dumps({
                    "end": True,
                    "input_tokens": usage.input_tokens,
                    "output_tokens": usage.output_tokens,
                })
                yield f"data: {data}\n\n"

    return StreamingResponse(
        generate(),
        media_type="text/event-stream",
        headers={
            "Cache-Control": "no-cache",
            "X-Accel-Buffering": "no",  # Důležité pro nginx
        },
    )

Pak tu je reverzní proxy, obvyklý podezřelý, když „streamování nefunguje v produkci, přestože lokálně fungovalo.“ Ve výchozím nastavení nginx akumuluje odpověď backendu před jejím přenosem. Níže uvedená konfigurace toto chování zakazuje pouze pro konkrétní trasu.

location /api/chat {
    proxy_pass http://127.0.0.1:8000;
    proxy_buffering off;
    proxy_cache off;
    proxy_set_header Connection "";
    chunked_transfer_encoding on;
}

Udržování připojení v čase

Stream otevřený po několik desítek sekund je více vystaven než krátké volání: výpadek sítě, dosažení kvóty a generování se zastaví uprostřed věty. Tvá strategie opakování musí rozlišovat mezi těmito dvěma případy, protože vyžadují odlišné přístupy. Chyba připojení by měla být opakována s exponenciálním backoffem, aby se síti dal čas na obnovu bez zahlcování API; překročení kvóty by mělo být opakováno po pevné době čekání, protože okno limitu rychlosti se resetuje v pravidelných intervalech.

import openai

def resilient_streaming(prompt: str, max_attempts: int = 3):
    """Streamování s ošetřením chyb a opakováním."""
    for attempt in range(max_attempts):
        try:
            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
                    yield event.delta

            return  # Úspěch, konec

        except openai.APIConnectionError:
            if attempt < max_attempts - 1:
                import time
                time.sleep(2 ** attempt)  # Exponenciální backoff
            else:
                raise
        except openai.RateLimitError:
            import time
            time.sleep(5)  # Pevné čekání pro limit rychlosti

Jedna poslední úprava zlepšuje komfort čtení. Vysílání každého tokenu produkuje trhavý text, zejména pokud tvé rozhraní aplikuje animaci nebo pokud výsledek směřuje do převodu textu na řeč. Akumulace až do konce věty dává rytmus bližší lidskému čtení za cenu mírného dodatečného zpoždění u prvního fragmentu.

def streaming_by_sentence(prompt: str):
    """Akumuluje a vydává po celých větách."""
    buffer = ""

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

    for event in stream:
        if event.type == "response.output_text.delta":
            buffer += event.delta
            # Hledání konce věty
            for separator in [".\n", "!\n", "?\n", ". ", "! ", "? "]:
                if separator in buffer:
                    parts = buffer.split(separator, 1)
                    yield parts[0] + separator.rstrip()
                    buffer = parts[1] if len(parts) > 1 else ""

    if buffer.strip():
        yield buffer.strip()

Všimni si závěrečného if buffer.strip(): bez něj by odpověď, která nekončí silnou interpunkcí, přišla o svá poslední slova. Tento druh přehlédnutí zůstane při testování bez povšimnutí a projeví se v produkci u odpovědí zkrácených pomocí max_output_tokens.

Klíčové poznatky

  • V produkci vždy používej streamování ke snížení vnímané latence
  • Nakonfiguruj nginx s proxy_buffering off pro SSE
  • Ošetřuj chyby pomocí opakování a exponenciálního backoffu
  • Akumuluj po větách pro přirozenější zobrazení