Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Optimizuotas srautinis perdavimas

Paskaita 5 iš 20 Atnaujinta 2026 m. liepos 28 d. Pažengusiems
Šiame puslapyje
  1. Ką iš tikrųjų keičia srautinis perdavimas
  2. Srauto vartojimas kliento pusėje
  3. Srauto perdavimas į naršyklę
  4. Ryšio palaikymas ilgainiui
  5. Svarbiausi punktai

Ką iš tikrųjų keičia srautinis perdavimas

Srautinis perdavimas modelio neveikia greičiau: jis tiesiog padaro laukimą pakeliamą. Jei atsakymo generavimas trunka penkias sekundes, naudotojas be srautinio perdavimo penkias sekundes žiūri į tuščią ekraną ir tik tada gauna visą teksto bloką. Naudojant srautinį perdavimą, pirmieji žodžiai pasirodo po kelių šimtų milisekundžių, o naudotojas gali skaityti tekstą tuo pačiu metu, kai modelis jį rašo. Bendra trukmė lieka tokia pati, tačiau suvokimas yra visiškai kitoks. Štai kodėl gamybinėje aplinkoje atsisakyti srautinio perdavimo yra beveik visada dizaino klaida, o ne sąmoningas pasirinkimas.

Tačiau srautas turi tekėti per visą tavo grandinę. Jei API teisingai sugeneruoja srautą, bet tavo programos serveris jį surenka arba atvirkštinis proxy serveris buferizuoja, naudotojas viską gaus vienu bloku: sumokėjai už srautinio perdavimo sudėtingumą, bet negavai jokios naudos. Todėl šioje pamokoje nagrinėsime visą kelią – nuo API užklausos iki naršyklės.

Srauto vartojimas kliento pusėje

Naudojant „Responses“ API, nustatymas stream=True paverčia atsakymą tipizuotų įvykių seka, kurią iteruoji jiems atvykstant. Kiekvienas teksto fragmentas atkeliauja response.output_text.delta įvykyje; srauto pabaigą signalizuoja response.completed, kuriame yra visas atsakymo objektas – tai naudinga norint gauti informaciją apie sunaudotus tokenus.

import openai

client = openai.OpenAI()

def generate_streaming(prompt: str):
    """Srautinis generavimas naudojant 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()  # Nauja eilutė pabaigoje
            return event.response

flush=True žymė nėra tik kosmetinė: be jos „Python“ pats buferizuoja išvestį ir gauni tą patį blokų elgesį, kurio norėjai išvengti. Ši detalė kartojasi kiekviename grandinės sluoksnyje ir yra pagrindinis srautinio perdavimo sunkumas.

Šis mechanizmas taip pat apima funkcijų kvietimus. Įrankių argumentai kuriami palaipsniui, todėl gali juos rodyti generavimo metu, kad naudotojas matytų, jog vyksta paieškos formavimas, užuot palikęs jį žiūrėti į sustingusią sąsają, kol modelis ruošia savo kvietimą.

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":
                # Šiuo metu generuojami funkcijos argumentai
                print(f"[arg: {event.delta}]", end="")
            case "response.function_call_arguments.done":
                print(f"\n[Funkcijos kvietimas baigtas]")

Srauto perdavimas į naršyklę

Tavo „frontend“ tiesiogiai nesikreipia į „OpenAI“ API – jis bendrauja su tavo serveriu, kuris todėl turi perduoti srautą toliau. Serverio siunčiami įvykiai (SSE – Server-Sent Events) yra natūralus tam formatas: tai HTTP atsakymas, kuris lieka atviras, o kiekviena data: eilutė perneša JSON fragmentą. Toliau pateiktame pavyzdyje tekstas perduodamas jam atvykstant, o pabaigoje išsiunčiamas galutinis pranešimas su tokenų skaičiumi. Tai leidžia apskaičiuoti kainą arba įrašyti žurnalą be papildomo užklausos.

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",  # Svarbu nginx
        },
    )

Tada ateina eilė atvirkštiniam proxy serveriui – tai įprastas kaltininkas, kai „srautinis perdavimas neveikia gamyboje, nors lokaliai veikė“. Pagal nutylėjimą „nginx“ surenka backend atsakymą ir tik tada jį perduoda. Toliau pateikta konfigūracija išjungia šį elgesį tik konkrečiam maršrutui.

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;
}

Ryšio palaikymas ilgainiui

Keliasdešimt sekundžių atviras srautas yra labiau pažeidžiamas nei trumpas užklausimas: nutrūkus tinklui arba pasiekus kvotą, generavimas sustoja viduryje sakinio. Tavo bandymų iš naujo strategija turi atskirti šiuos du atvejus, nes jiems reikia skirtingo požiūrio. Ryšio klaidą reikia kartoti taikant eksponentinį delsą, kad tinklas spėtų atsistatyti neužgriovus API; o viršijus kvotą reikia laukti fiksuotą laiką, nes greičio ribos langas atsistato reguliariais intervalais.

import openai

def resilient_streaming(prompt: str, max_attempts: int = 3):
    """Srautinis perdavimas su klaidų apdorojimu ir kartojimu."""
    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  # Sėkmė, išeiname

        except openai.APIConnectionError:
            if attempt < max_attempts - 1:
                import time
                time.sleep(2 ** attempt)  # Eksponentinis delsa
            else:
                raise
        except openai.RateLimitError:
            import time
            time.sleep(5)  # Fiksuotas laukimas dėl greičio ribos

Dar vienas patobulinimas pagerina skaitymo komfortą. Kiekvieno tokeno siuntimas sukuria trūkčiojantį tekstą, ypač jei tavo sąsaja taiko animaciją arba jei rezultatas nukreipiamas į teksto kalbą (TTS). Kaupimas iki sakinio pabaigos suteikia ritmą, artimesnį žmogaus skaitymui, nors pirmasis fragmentas pasirodo šiek tiek vėliau.

def streaming_by_sentence(prompt: str):
    """Kaupia ir pateikia pilnus sakinius."""
    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
            # Ieškome sakinio pabaigos
            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()

Atkreipk dėmesį į galutinį if buffer.strip(): be jo atsakymas, kuris nesibaigia stipria skyryba, prarastų paskutinius žodžius. Tokia klaida testavimo metu dažnai lieka nepastebėta, o gamyboje pasireiškia atsakymuose, kurie buvo sutrumpinti dėl max_output_tokens.

Svarbiausi punktai

  • Gamyboje visada naudok srautinį perdavimą, kad sumažintum suvokiamą delsą
  • „Nginx“ sukonfigūruok naudodamas proxy_buffering off SSE perdavimui
  • Klaidas tvarkyk su kartojimu ir eksponentiniu delsos mechanizmu
  • Kaupk tekstą sakiniais, kad rodymas būtų natūralesnis