Straumēšana: saņem atbildes reāllaikā
Šajā lapā
Straumēšana: saņem atbildes reāllaikā
Straumēšana ļauj saņemt atbildi pa vienam tokenim, negaidot, kamēr ģenerēšana ir pilnībā pabeigta. Tas nav tikai lietotāja saskarnes uzlabojums: tieši tas atšķir lēnu čatbotu no ātra, pat ja servera veiktspēja ir identiska.
Kāpēc straumēt
Bez straumēšanas lietotāji dažkārt skatās tukšā ekrānā desmit līdz trīsdesmit sekundes, pirms visa atbilde parādās vienlaikus. Ar straumēšanu pirmie vārdi parādās mazāk nekā sekundes laikā, un lasīšana sākas, kamēr ģenerēšana turpinās. Kopējais ilgums ir tāds pats, bet uztvere – nē. Lai to aktivizētu, pietiek ar vienu parametru stream=True, kas pārvērš create() atgriezto vērtību notikumu iteratorā.
from openai import OpenAI
client = OpenAI()
# BEZ straumēšanas — gaidi visu
response = client.responses.create(
model="gpt-5.6-terra",
input="Write a paragraph about artificial intelligence."
)
print(response.output_text) # Parādās viss vienlaikus pēc gaidīšanas
# AR straumēšanu — pa tokenim
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() # Jauna rinda beigās
Tipizēti notikumi, nevis nediferencēta plūsma
Plūsma nesatur tikai tekstu. Tā paziņo, kad atbilde ir izveidota, kad tiek pievienots katrs izvades elements, kad ierodas fragmenti un kad notiek pabeigšana – pēdējais notikums ietver lietojuma metrikas datus. Filtrē pēc event.type, lai zinātu, ar ko strādā. Šī struktūra ļauj, piemēram, parādīt ielādes indikatoru tiklīdz tiek aktivizēts response.created un beigās saskaitīt tokenus, neveicot otru API izsaukumu.
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"[Atbilde izveidota] ID: {event.response.id}")
case "response.output_item.added":
print(f"[Jauns izvades elements]")
case "response.output_text.delta":
print(f"[Teksts] {event.delta}", end="")
case "response.output_text.done":
print(f"\n[Teksts pabeigts]")
case "response.completed":
print(f"[Pabeigts] Tokeni: {event.response.usage.total_tokens}")
# Izvade:
# [Atbilde izveidota] ID: resp_abc123
# [Jauns izvades elements]
# [Teksts] Sveiki[Teksts] ! [Teksts] Kā[Teksts] es[Teksts] varu...
# [Teksts pabeigts]
# [Pabeigts] Tokeni: 25
Reālā lietotnē gandrīz vienmēr vēlēsies darīt divas lietas vienlaikus: rādīt fragmentus un rekonstruēt pilno tekstu, lai to arhivētu vai atgrieztu izsaukumam. Noteikums ir vienkāršs: uzkrāj iterācijas laikā, jo tiklīdz plūsma ir izlietota, to nevar atgriezt atpakaļ.
def stream_and_collect(prompt: str) -> str:
"""Straumē atbildi, vienlaikus to uzkrājot."""
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() # Jauna rinda
return full_text
result = stream_and_collect("Uzskaiti 3 Eiropas galvaspilsētas.")
print(f"\nSavāktais teksts ({len(result)} rakstzīmes)")
Straumēšana un funkciju izsaukumi
Arī funkciju izsaukumi tiek straumēti, izmantojot savus notikumus: argumenti ierodas fragmentos caur response.function_call_arguments.delta, bet response.function_call_arguments.done signalizē, ka JSON ir pabeigts. Tam ir svarīga praktiska sekas – nekad nemēģini deserializēt argumentus pirms done notikuma, citādi tev būs tikai saīsināts JSON.
stream = client.responses.create(
model="gpt-5.6-terra",
input="Cik ir pulkstenis Tokijā?",
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"[Arg] {event.delta}", end="")
case "response.function_call_arguments.done":
print(f"\n[Funkcijas izsaukums pabeigts]")
# Izvade:
# [Arg] {"city": "Tokyo"}
# [Funkcijas izsaukums pabeigts]
Asinhronais gadījums
Tiklīdz tava lietotne apkalpo vairākus lietotājus vienlaicīgi, pārej uz AsyncOpenAI: sinhronais klients bloķētu notikumu cilpu visas ģenerēšanas laikā, liekot pārējiem pieprasījumiem gaidīt. Sintakse atšķiras tikai ar diviem atslēgvārdiem – await izveides brīdī un async for iterācijas laikā.
from openai import AsyncOpenAI
import asyncio
async_client = AsyncOpenAI()
async def stream_async(prompt: str):
"""Atbildes asinhronā straumēšana."""
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("Izstāsti īsu joku."))
Tīmeklī straumēšana ir bezjēdzīga, ja tā apstājas pie tava servera: tev tā ir jāpagarina līdz pārlūkprogrammai. FastAPI to ļauj izdarīt ar StreamingResponse, ko baro ģenerators, kas tālāk nodod fragmentus, tiklīdz tie ierodas.
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")
Kļūdas straumēšanas laikā
Viena detaļa ir pelnījusi tavu uzmanību: straumēšanas laikā kļūda var rasties pēc tam, kad fragmenti jau ir parādīti. Lietotājs tad redz atbildi, kas sākas, bet tiek pēkšņi pārtraukta. Tāpēc aptver pašu iterāciju, ne tikai plūsmas izveidi, lai tīri signalizētu par pārtraukumu, nevis atstātu teikumu nepabeigtu.
from openai import APIError
def stream_with_errors(prompt: str):
"""Straumēšana ar robustu kļūdu apstrādi."""
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 kļūda straumēšanas laikā: {e.message}")
except Exception as e:
print(f"\nNegaidīta kļūda: {e}")
stream_with_errors("Paskaidro straumēšanu 2 teikumos.")
Galvenās atziņas
- Aktivizē straumēšanu ar
stream=True, lai nodrošinātu reāllaika pieredzi - Filtrē notikumus pēc
event.type, lai pareizi apstrādātu katru datu veidu response.output_text.deltasatur teksta fragmentusresponse.completedsignalizē beigas un ietver lietojuma metrikas datus- Izmanto
AsyncOpenAIstraumēšanai asinhronās lietotnēs - Vienmēr apstrādā kļūdas, pat straumēšanas režīmā