Optimeeritud voogedastus
Sellel lehel
Mida voogedastus tegelikult muudab
Voogedastus ei tee mudelit kiiremaks: see muudab ootamise talutavaks. Vastuse puhul, mille genereerimine võtab viis sekundit, vaatab kasutaja ilma voogedastuseta viis sekundit tühjale ekraanile, enne kui saab kätte tekstiploki. Voogedastuse korral näeb ta esimesi sõnu juba mõne sadama millisekundi pärast ja loeb kaasa, kui mudel kirjutab. Kogukestus on identne, kuid tajumine on täiesti erinev. Seetõttu on voogedastuse vahelejätmine tootmises peaaegu alati disainiviga, mitte teadlik valik.
Voog peab aga voolama läbi kogu sinu ahela. API poolt korrektselt genereeritud voog, mille sinu rakenduse server kogub või pöördproksi puhverdamisel jõuab kasutajani ühe plokina: oled maksnud voogedastuse keerukuse hinna, saamata sellest kasu. See tund käsitleb seega kogu teekonda alates API väljakutsest kuni brauserini.
Voo tarbimine kliendipoolses osas
Responses API puhul muudab stream=True määramine vastuse tüübitud sündmuste jadaks, mida iterreerid nende saabumisel. Iga tekstifragment saabub response.output_text.delta sündmusena; voo lõppu annab märku response.completed, mis kannab endas täielikku vastuse objekti – see on kasulik tokenite kasutuse väljaselgitamiseks.
import openai
client = openai.OpenAI()
def generate_streaming(prompt: str):
"""Voogedastusega genereerimine Responses API abil."""
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() # Reavahetus lõpus
return event.response
Lipp flush=True ei ole kosmeetiline: ilma selleta puhverdab Python väljundi ise ja lõpetad plokk-käitumisega, mida püüdsid vältida. See detail kordub ahela igas kihis ja see on voogedastuse peamine raskusaste.
Mehhanism hõlmab ka funktsioonikutsed. Tööriista argumendid koostatakse järk-järgult ja saad neid kuvada genereerimise käigus, et anda kasutajale märku otsingu formuleerimisest, selle asemel et jätta ta vaatama külmutatud liidest, kui mudel ette valmistab oma kutset.
tools = [
{
"type": "function",
"name": "search_product",
"description": "Otsib toodet kataloogist.",
"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":
# Parajasti genereeritavad funktsiooni argumendid
print(f"[arg: {event.delta}]", end="")
case "response.function_call_arguments.done":
print(f"\n[Funktsioonikutsed lõpetatud]")
Voo edastamine brauserisse
Sinu frontend ei suhtle otse OpenAI API-ga – see suhtleb sinu serveriga, mis peab seetõttu voo edasi andma. Serveri saadetud sündmused (SSE) on selleks loomulik formaat: HTTP vastus, mis jääb avatuks, kus iga data: rida kannab JSON fragmenti. Järgnev näide edastab teksti saabumisel ja väljastab lõpuks sõnumi, mis sisaldab tokenite arvu, võimaldades arveldada või logida ilma teist väljakutset tegemata.
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", # Oluline nginxi jaoks
},
)
Siis tuleb pöördproksi, tavaline kahtlusalune, kui „voogedastus ei tööta tootmises, kuigi kohalikult töötas“. Vaikimisi kogub nginx tagarakenduse vastuse enne edastamist. Alltoodud konfiguratsioon keelab selle käitumise ainult konkreetsele teele.
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;
}
Ühenduse hoidmine aja jooksul
Mitukümmend sekundit avatud voog on rohkem ohustatud kui lühike väljakutse: võrgukatkestus, kvoodi täitumine ja genereerimine peatub keset lauset. Sinu uuesti proovimise strateegia peab neid kaht juhtumit eristama, sest need nõuavad erinevat lähenemist. Ühendusviga tuleks proovida uuesti eksponentsiaalse tagasipöördumisega (exponential backoff), andes võrgule aega taastuda ilma API-t pommitamata; kvoodi ületamist tuleks proovida uuesti pärast fikseeritud ooteaega, kuna kiirusepiirangu aken lähtestub regulaarsete intervallide tagant.
import openai
def resilient_streaming(prompt: str, max_attempts: int = 3):
"""Voogedastus veakäitluse ja uuesti proovimisega."""
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 # Õnnestus, välju
except openai.APIConnectionError:
if attempt < max_attempts - 1:
import time
time.sleep(2 ** attempt) # Eksponentsiaalne tagasipöördumine
else:
raise
except openai.RateLimitError:
import time
time.sleep(5) # Fikseeritud oode kiirusepiirangu jaoks
Viimane nüanss parandab lugemismugavust. Iga tokeni väljastamine tekitab hakitud teksti, eriti kui sinu liides rakendab animatsiooni või kui tulemus suunatakse tekst-kõneks muutmisele. Akumuleerimine kuni lause lõpuni annab rütmi, mis on inimlikule lugemisele lähedasem, esimese fragmendi puhul väikese lisaviivituse hinnaga.
def streaming_by_sentence(prompt: str):
"""Akumuleerib ja väljastab tervete lausetena."""
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
# Otsi lause lõppu
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()
Pane tähele lõplikku if buffer.strip(): ilma selleta kaotaks vastus, mis ei lõpe tugeva kirjavahemärgiga, oma viimased sõnad. Selline tähelepanematus jääb testimisel märkamata ja avaldub tootmises vastustes, mida on lühendanud max_output_tokens.
Peamised punktid
- Kasuta tootmises alati voogedastust, et vähendada tajutavat latentsust
- Konfigureeri nginx parameetriga
proxy_buffering offSSE jaoks - Käitle vigu uuesti proovimise ja eksponentsiaalse tagasipöördumisega
- Akumuleeri lausetena loomulikumaks kuvamiseks