Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Transliavimas: atsakymų gavimas realiuoju laiku

Paskaita 8 iš 22 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Transliavimas: atsakymų gavimas realiuoju laiku
  2. Kodėl verta transliuoti
  3. Tipizuoti įvykiai, o ne beformis srautas
  4. Transliavimas ir funkcijų kvietimai
  5. Asinchroninis atvejis
  6. Klaidos transliavimo metu
  7. Svarbiausi punktai

Transliavimas: atsakymų gavimas realiuoju laiku

Transliavimas leidžia gauti atsakymą žyma po žymos, nelaukiant, kol visas generavimas baigsis. Tai ne tik vartotojo sąsajos patobulinimas: būtent tai atskiria lėtai atrodoiantį pokalbių robotą nuo greito ir reaktyvaus, net jei serverio našumas yra identiškas.

Kodėl verta transliuoti

Be transliavimo vartotojai kartais dešimt–trisdešimt sekundžių žiūri į tuščią ekraną, kol visas atsakymas atsiranda vienu metu. Įjungus transliavimą, pirmieji žodžiai pasirodo per mažiau nei sekundę, o skaityti galima jau generavimo metu. Bendra trukmė lieka ta pati, tačiau suvokimas – kitoks. Norint tai įgalinti, pakanka vieno parametro: stream=True, kuris paverčia create() grąžinamąją reikšmę įvykių iteratoriumi.

from openai import OpenAI
client = OpenAI()

# BE transliavimo — laukiame visko
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Write a paragraph about artificial intelligence."
)
print(response.output_text)  # Pasirodo vienu metu po laukimo

# SU transliavimu — žyma po žymos
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()  # Nauja eilutė pabaigoje

Tipizuoti įvykiai, o ne beformis srautas

Srautas perneša ne tik tekstą. Jis praneša, kai sukuriamas atsakymas, kai pridėtas kiekvienas išvesties elementas, kai atkeliauja fragmentai ir kai generavimas baigiamas – paskutiniame įvykyje pateikiama naudojimo statistika. Filtruokite pagal event.type, kad žinotumėte, su kuo dirbate. Tokia struktūra leidžia, pavyzdžiui, iškart rodyti įkrovos indikatorių, kai įvyksta response.created, o pabaigoje susumuoti žymas be papildomo API užklausos.

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}")

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

Realioje programoje beveik visada norėsite daryti du dalykus vienu metu: rodyti fragmentus ir kartu atkurti visą tekstą, kad galėtumėte jį archyvuoti arba grąžinti kvietėjui. Taisyklė paprasta: kaupkite duomenis iteracijos metu, nes srauto, kai jis jau suvartotas, „persukti“ atgal nebegalima.

def stream_and_collect(prompt: str) -> str:
    """Transliuoti atsakymą ir jį kaupiant."""
    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()  # Nauja eilutė
    return full_text

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

Transliavimas ir funkcijų kvietimai

Funkcijų kvietimai taip pat transliuojami ir turi savo įvykius: argumentai atkeliauja fragmentais per response.function_call_arguments.delta, o response.function_call_arguments.done signalizuoja, kad JSON yra pilnas. Tai turi svarbią praktinę pasekmę – niekada nebandykite deserializuoti argumentų prieš done įvykį, kitaip turėsite tik sutrumpintą 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]")

# Išvestis:
# [Args] {"city": "Tokyo"}
# [Function call complete]

Asinchroninis atvejis

Kai jūsų programa aptarnauja kelis vartotojus vienu metu, pereikite prie AsyncOpenAI: sinchroninis klientas užblokuotų įvykių kilpą visam generavimo laikui ir priverstų kitus užklausimus laukti. Sintaksė skiriasi tik dviem raktažodžiais – await kūrimo metu ir async for iteracijos metu.

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_async(prompt: str):
    """Asinchroninis atsakymo transliavimas."""
    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."))

Žiniatinklyje transliavimas yra beprasmis, jei jis sustoja ties jūsų serveriu: jį reikia pratęsti iki naršyklės. FastAPI tai leidžia padaryti naudojant StreamingResponse, maitinamą generatoriaus, kuris perduoda fragmentus jiems atkeliaujant.

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")

Klaidos transliavimo metu

Viena detalė nusipelno dėmesio: transliuojant klaida gali įvykti jau po to, kai dalis fragmentų buvo parodyta. Tuomet vartotojas mato atsakymą, kuris prasideda, bet staiga nutrūksta. Todėl apgaubkite ne tik srauto sukūrimą, bet ir pačią iteraciją – taip galėsite aiškiai pranešti apie pertraukimą, o ne palikti nebaigtą sakinį kaboti.

from openai import APIError

def stream_with_errors(prompt: str):
    """Transliavimas su patikimu klaidų apdorojimu."""
    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.")

Svarbiausi punktai

  • Įgalinkite transliavimą naudodami stream=True, kad užtikrintumėte realaus laiko patirtį
  • Filtruokite įvykius pagal event.type, kad tinkamai apdorotumėte kiekvieną duomenų tipą
  • response.output_text.delta turi teksto fragmentus
  • response.completed signalizuoja pabaigą ir pateikia naudojimo statistiką
  • Asinchroninėse programose transliavimui naudokite AsyncOpenAI
  • Visada tvarkykite klaidas, net ir transliavimo režimu