Straumēšanas optimizācija
Šajā lapā
Ko patiesībā maina straumēšana
Straumēšana nepaātrina modeļa darbību: tā padara gaidīšanu pieņemamu. Ja atbildes ģenerēšana ilgst piecas sekundes, lietotājs bez straumēšanas piecas sekundes skatās tukšā ekrānā, pirms saņem teksta bloku. Ar straumēšanu viņš pirmos vārdus redz pēc dažām simtdaļām sekundes un lasa līdzi, kamēr modelis raksta. Kopējais ilgums ir identisks, bet uztvere ir pilnīgi cita. Tieši tāpēc ražošanas vidē straumēšanas izlaišana gandrīz vienmēr ir dizaina kļūda, nevis apzināta izvēle.
Tomēr straumei jāplūst cauri visai tavai ķēdei. Ja API ģenerē straumi pareizi, bet tava lietotnes serveris to uzkrāj vai reversais starpniekserveris to buferē, lietotājs saņem visu vienā blokā: tu esi samaksājis par straumēšanas sarežģītību, negūstot tās priekšrocības. Tāpēc šī nodarbība izseko visu ceļu no API izsaukuma līdz pārlūkprogrammai.
Straumes patēriņš klienta pusē
Izmantojot Responses API, iestatot stream=True, atbilde pārvēršas tipētu notikumu secībā, caur kuru iterē, tiklīdz tie pienāk. Katrs teksta fragments nonāk response.output_text.delta notikumā; straumes beigas signalizē response.completed, kas nes pilnu atbildes objektu, noderīgu tokena lietojuma iegūšanai.
import openai
client = openai.OpenAI()
def generate_streaming(prompt: str):
"""Straumēta ģenerēšana, izmantojot 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() # Jauna rinda beigās
return event.response
Karogs flush=True nav kosmētisks: bez tā Python pats buferē izvadi, un tu nonāc pie tāda paša bloku uzvedības, no kuras centies izvairīties. Šī detaļa atkārtojas katrā ķēdes slānī, un tā ir galvenā straumēšanas grūtība.
Mehānisms attiecas arī uz funkciju izsaukumiem. Rīku argumenti tiek veidoti pakāpeniski, un tu vari tos attēlot ģenerēšanas laikā, lai signalizētu lietotājam, ka tiek formulēta meklēšana, nevis liktu viņam skatīties sasalušā saskarnē, kamēr modelis sagatavo savu izsaukumu.
tools = [
{
"type": "function",
"name": "search_product",
"description": "Meklē produktu katalogā.",
"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":
# Pašlaik ģenerētie funkcijas argumenti
print(f"[arg: {event.delta}]", end="")
case "response.function_call_arguments.done":
print(f"\n[Funkcijas izsaukums pabeigts]")
Straumes pārsūtīšana uz pārlūkprogrammu
Tavs frontends nerunā tieši ar OpenAI API – tas runā ar tavu serveri, kam tāpēc ir jāpārsūta straume. Servera nosūtītie notikumi (SSE) ir dabiskais formāts tam: HTTP atbilde, kas paliek atvērta, kur katra data: rinda nes JSON fragmentu. Tālāk redzamais piemērs pārsūta tekstu, tiklīdz tas pienāk, un pēc tam izsūtī gala ziņojumu ar tokena skaitu, ļaujot veikt rēķinu vai žurnālēšanu bez otrā izsaukuma.
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", # Svarīgi nginx
},
)
Tad nāk reversais starpniekserveris, parastais aizdomās turamais, ja „straumēšana nedarbojas ražošanas vidē, lai gan lokāli tā strādāja”. Pēc noklusējuma nginx uzkrāj backend atbildi pirms tās pārsūtīšanas. Tālāk redzamā konfigurācija atspējo šo uzvedību tikai konkrētajam maršrutam.
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;
}
Savienojuma uzturēšana laika gaitā
Straume, kas atvērta vairākas desmit sekundes, ir vairāk pakļauta riskam nekā īss izsaukums: tīkla pārtraukums, kvotas sasniegšana, un ģenerēšana apstājas teikuma vidū. Tavai atkārtošanas stratēģijai ir jānošķir šie divi gadījumi, jo tiem nepieciešamas atšķirīgas pieejas. Savienojuma kļūda ir jāatkārto ar eksponenciālu atkāpšanos, dodot tīklam laiku atgūties, nevis bombardējot API; kvotas pārsniegšana ir jāatkārto pēc fiksētas gaidīšanas, jo ātruma ierobežojuma logs tiek atiestatīts regulāros intervālos.
import openai
def resilient_streaming(prompt: str, max_attempts: int = 3):
"""Straumēšana ar kļūdu apstrādi un atkārtošanu."""
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 # Veiksme, iziešana
except openai.APIConnectionError:
if attempt < max_attempts - 1:
import time
time.sleep(2 ** attempt) # Eksponenciāla atkāpšanās
else:
raise
except openai.RateLimitError:
import time
time.sleep(5) # Fiksēta gaidīšana ātruma ierobežojumam
Viens pēdējais uzlabojums uzlabo lasīšanas komfortu. Katra tokena izsūtīšana rada trūkstošu tekstu, it īpaši, ja tava saskarne pielieto animāciju vai ja rezultāts tiek novirzīts uz teksta-runāšanu. Uzkrāšana līdz teikuma beigām dod ritmu, kas tuvāks cilvēka lasīšanai, par cenu nelielas papildu aizkaves pirmajā fragmentā.
def streaming_by_sentence(prompt: str):
"""Uzkrāj un izdod pa pilniem teikumiem."""
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
# Meklē teikuma beigas
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()
Ņem vērā noslēdzošo if buffer.strip(): bez tā atbilde, kas nebeidzas ar spēcīgu interpunkciju, zaudētu savus pēdējos vārdus. Šāda kļūda testēšanas laikā paliek nepamanīta un ražošanas vidē izpaužas atbildēs, kas apgrieztas ar max_output_tokens.
Galvenās atziņas
- Ražošanas vidē vienmēr izmanto straumēšanu, lai samazinātu uztverto latentumu
- Konfigurē nginx ar
proxy_buffering offpriekš SSE - Apstrādā kļūdas ar atkārtošanu un eksponenciālu atkāpšanos
- Uzkrāj pa teikumiem dabiskākai attēlošanai