Transliavimas: atsakymų gavimas realiuoju laiku
Šiame puslapyje
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.deltaturi teksto fragmentusresponse.completedsignalizuoja pabaigą ir pateikia naudojimo statistiką- Asinchroninėse programose transliavimui naudokite
AsyncOpenAI - Visada tvarkykite klaidas, net ir transliavimo režimu