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

Optimalizované streamovanie

Lekcia 5 z 20 Aktualizované 28. júla 2026 Pokročilý
Na tejto strane
  1. Čo streamovanie skutočne mení
  2. Spracovanie streamu na strane klienta
  3. Preposielanie streamu do prehliadača
  4. Udržiavanie pripojenia v čase
  5. Kľúčové poznatky

Čo streamovanie skutočne mení

Streamovanie nezrýchľuje model: robí čakanie znesiteľným. Pri odpovedi, ktorej generovanie trvá päť sekúnd, sa používateľ bez streamovania pozerá päť sekúnd na prázdnu obrazovku, kým dostane blok textu. So streamovaním vidí prvé slová po niekoľkých stovkách milisekúnd a číta ich súčasne s tým, ako ich model píše. Celková dĺžka trvania je identická, ale vnímanie je úplne odlišné. Preto je vynechanie streamovania v produkcii takmer vždy chybou v dizajne, nie vedomou voľbou.

Stream však musí pretekať celým tvojím reťazcom. Stream správne vygenerovaný API, ale akumulovaný tvojím aplikačným serverom alebo bufferovaný reverznou proxy, dorazí k používateľovi v jednom bloku: zaplatil si cenu za zložitosť streamovania, bez toho, aby si zožal jeho výhody. Táto lekcia preto sleduje kompletnú cestu od volania API až po prehliadač.

Spracovanie streamu na strane klienta

Pri Responses API nastavenie stream=True transformuje odpoveď na sekvenciu typovaných udalostí, ktorými iteruješ, ako prichádzajú. Každý fragment textu dorazí v udalosti response.output_text.delta; koniec streamu signalizuje response.completed, ktorá nesie celý objekt odpovede, čo je užitočné na získanie využitia tokenov.

import openai

client = openai.OpenAI()

def generate_streaming(prompt: str):
    """Streamované generovanie pomocou 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ý riadok na konci
            return event.response

Príznak flush=True nie je kozmetický: bez neho si Python sám bufferuje výstup a skončíš s blokovým správaním, ktorému si sa chcel vyhnúť. Tento detail sa opakuje na každej vrstve reťazca a je hlavnou ťažkosťou streamovania.

Mechanizmus pokrýva aj volania funkcií. Argumenty nástrojov sa budujú postupne a môžeš ich zobrazovať počas generovania, aby si používateľovi signalizoval, že sa formuluje vyhľadávanie, namiesto toho, aby ho nechal pozerať na zamrznuté rozhranie, kým model pripravuje svoje volanie.

tools = [
    {
        "type": "function",
        "name": "search_product",
        "description": "Vyhľadá produkt v katalógu.",
        "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 funkcie sa práve generujú
                print(f"[arg: {event.delta}]", end="")
            case "response.function_call_arguments.done":
                print(f"\n[Volanie funkcie dokončené]")

Preposielanie streamu do prehliadača

Tvoj frontend nekomunikuje priamo s API OpenAI – komunikuje s tvojim serverom, ktorý musí stream preposlať ďalej. Server-Sent Events (SSE) sú pre toto prirodzeným formátom: HTTP odpoveď, ktorá zostáva otvorená, kde každý riadok data: nesie JSON fragment. Nasledujúci príklad preposiela text, ako prichádza, a následne vysiela finálnu správu obsahujúcu počet tokenov, čo ti umožňuje fakturovať alebo logovať bez druhého volania.

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é pre nginx
        },
    )

Potom tu máme reverznú proxy, obvyklého podozrivého, keď „streamovanie nefunguje v produkcii, hoci lokálne fungovalo.“ Predvolene nginx akumuluje odpoveď z backendu pred jej odoslaním. Nižšie uvedená konfigurácia vypína toto správanie len pre konkrétnu 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žiavanie pripojenia v čase

Stream otvorený niekoľko desiatok sekúnd je viac vystavený riziku ako krátke volanie: výpadok siete, dosiahnutie kvóty a generovanie sa zastaví v polovici vety. Tvoja stratégia opakovania musí rozlišovať medzi týmito dvoma prípadmi, pretože vyžadujú odlišný prístup. Chyba pripojenia by sa mala opakovať s exponenciálnym oneskorením (exponential backoff), čím sa sieti dá čas na zotavenie bez zahlcovania API; prekročenie kvóty by sa malo opakovať po pevnej čakacej dobe, keďže okno limitu rýchlosti sa resetuje v pravidelných intervaloch.

import openai

def resilient_streaming(prompt: str, max_attempts: int = 3):
    """Streamovanie s ošetrením chýb a opakovaní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  # Úspech, ukončenie

        except openai.APIConnectionError:
            if attempt < max_attempts - 1:
                import time
                time.sleep(2 ** attempt)  # Exponenciálne oneskorenie
            else:
                raise
        except openai.RateLimitError:
            import time
            time.sleep(5)  # Pevné čakanie na limit rýchlosti

Jedna posledná úprava zlepšuje komfort čítania. Vysielanie každého tokenu produkuje trhavý text, najmä ak tvoje rozhranie aplikuje animáciu alebo ak výsledok smeruje do prevodu textu na reč. Akumulácia až do konca vety poskytuje rytmus bližší ľudskému čítaniu, za cenu mierneho dodatočného oneskorenia pri prvom fragmente.

def streaming_by_sentence(prompt: str):
    """Akumuluje a vysiela po celých vetá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
            # Hľadanie konca vety
            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áverečné if buffer.strip(): bez neho by odpoveď, ktorá nekončí silnou interpunkciou, stratila svoje posledné slová. Tento druh prehliadnutia zostane pri testovaní nepovšimnutý a v produkcii sa prejaví pri odpovediach orezaných pomocou max_output_tokens.

Kľúčové poznatky

  • V produkcii vždy používaj streamovanie na zníženie vnímanej latencie
  • Nakonfiguruj nginx s proxy_buffering off pre SSE
  • Spracúvaj chyby pomocou opakovania a exponenciálneho oneskorenia
  • Akumuluj po vetách pre prirodzenejšie zobrazenie