Pretakanje: prejemanje odgovorov v realnem času
Na tej strani
Pretakanje: prejemanje odgovorov v realnem času
Pretakanje (streaming) ti omogoča prejemanje odgovora žeton za žetonom, namesto da bi čakal na konec celotnega generiranja. To ni le kozmetični dodatek uporabniškemu vmesniku: prav to loči klepetalnega bota, ki deluje okorno, od tistega, ki deluje odzivno, tudi če je zmogljivost strežnika popolnoma enaka.
Zakaj uporabljati pretakanje
Brez pretakanja uporabniki včasih gledajo v prazen zaslon deset do trideset sekund, preden se celoten odgovor prikaže naenkrat. S pretakanjem se prve besede pojavijo v manj kot sekundi, branje pa se začne, medtem ko generiranje še poteka. Skupno trajanje je enako; zaznava pa ne. Omogočitev zahteva le en parameter, stream=True, ki povratno vrednost funkcije create() spremeni v iterator dogodkov.
from openai import OpenAI
client = OpenAI()
# BREZ pretakanja — počakaj na vse
response = client.responses.create(
model="gpt-5.6-terra",
input="Write a paragraph about artificial intelligence."
)
print(response.output_text) # Prikaže se vse naenkrat po čakanju
# S pretakanjem — žeton za žetonom
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() # Nova vrstica na koncu
Tipizirani dogodki, ne nediferenciran tok
Tok ne prenaša le besedila. Obvesti te, ko je odgovor ustvarjen, ko je dodan vsak izhodni element, ko prispejo fragmenti in ko pride do zaključka – končni dogodek vključuje metrike uporabe. Filtriraš glede na event.type, da veš, s čim imaš opravka. Ta struktura ti omogoča, da na primer prikažeš indikator nalaganja, takoj ko se sproži response.created, in na koncu sešteješ žetone brez dodatnega klica API-ja.
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}")
# Output:
# [Response created] ID: resp_abc123
# [New output item]
# [Text] Hello[Text] ! [Text] How[Text] can[Text] I...
# [Text complete]
# [Done] Tokens: 25
V realni aplikaciji boš skoraj vedno želel početi dve stvari hkrati: prikazovati fragmente in rekonstruirati celotno besedilo, da ga lahko arhiviraš ali vrneš klicatelju. Pravilo je preprosto: kopiči med iteracijo, saj toka po porabi ni mogoče prevrniti nazaj.
def stream_and_collect(prompt: str) -> str:
"""Pretakaj odgovor in ga hkrati zbiraj."""
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() # Nova vrstica
return full_text
result = stream_and_collect("List 3 European capitals.")
print(f"\nCollected text ({len(result)} characters)")
Pretakanje in klicanje funkcij
Tudi klici funkcij so pretočeni, z lastnimi dogodki: argumenti prispejo v fragmentih prek response.function_call_arguments.delta, response.function_call_arguments.done pa signalizira, da je JSON končan. To ima pomembno praktično posledico – nikoli ne poskušaj deserializirati argumentov pred dogodkom done, sicer boš imel le okrnjen 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]")
# Output:
# [Args] {"city": "Tokyo"}
# [Function call complete]
Asinhroni primer
Takoj ko tvoja aplikacija hkrati streže več uporabnikom, preklopi na AsyncOpenAI: sinhroni klient bi blokiral zanko dogodkov za celoten čas generiranja, zaradi česar bi morala druga zahteve čakati. Sintaksa se razlikuje le v dveh ključnih besedah – await ob ustvarjanju in async for pri iteraciji.
from openai import AsyncOpenAI
import asyncio
async_client = AsyncOpenAI()
async def stream_async(prompt: str):
"""Asinhrono pretakanje odgovora."""
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."))
Na spletu je pretakanje neuporabno, če se ustavi na tvojem strežniku: razširiti ga moraš do brskalnika. FastAPI to omogoča z StreamingResponse, ki ga napaja generator, ki posreduje fragmente, ko prispejo.
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")
Napake med pretakanjem
Ena podrobnost si zasluži tvojo pozornost: pri pretakanju lahko do napake pride, ko so bili fragmenti že prikazani. Uporabnik tako vidi odgovor, ki se začne, a se nenadoma prekine. Zato ovij samo iteracijo, ne le ustvarjanja toka, da lahko čisto signaliziraš prekinitev, namesto da bi pustil stavek nedokončan.
from openai import APIError
def stream_with_errors(prompt: str):
"""Pretakanje z robustnim ravnanjem z napakami."""
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.")
Ključne ugotovitve
- Omogoči pretakanje s
stream=Trueza izkušnjo v realnem času - Filtriraj dogodke po
event.type, da pravilno obravnavaš vsako vrsto podatkov response.output_text.deltavsebuje fragmente besedilaresponse.completedsignalizira konec in vključuje metrike uporabe- Uporabi
AsyncOpenAIza pretakanje v asinhronih aplikacijah - Vedno obravnavaj napake, tudi v načinu pretakanja