Streaming ottimizzat
F'din il-paġna
X’ibiddel is-streaming fil-fatt
Is-streaming ma jagħmilx il-mudell iktar mgħaġġel: jagħmel l-istennija sopportabbli. Għal tweġiba li tieħu ħames sekondi biex tiġġenera, utent mingħajr streaming jħares lejn skrin vojt għal ħames sekondi qabel ma jirċievi blokk ta’ test. Bis-streaming, jaraw l-ewwel kliem wara ftit mijiet ta’ millisekondi u jaqraw hekk kif il-mudell jikteb. It-tul totali huwa identiku, iżda l-perċezzjoni hija kompletament differenti. Għalhekk, fil-produzzjoni, li ma tużax is-streaming huwa kważi dejjem difett fid-disinn aktar milli għażla konxja.
Madankollu, is-stream irid jgħaddi mill-katina kollha tiegħek. Stream iġġenerat korrettament mill-API iżda akkumulat mis-server tal-applikazzjoni tiegħek jew ibbufferjat mill-proxy invers tiegħek jasal għand l-utent f’blokk waħda: ħallast il-prezz tal-kumplessità għas-streaming mingħajr ma ġejt il-benefiċċji. Għalhekk, din il-lezzjoni ssegwi l-mogħdija sħiħa, mis-sejħa tal-API sal-browser.
Il-konsum tas-stream fuq in-naħa tal-klijent
Bl-API tar-Risposti, li tissettja stream=True tibdel ir-risposta f’sekwenza ta’ avvenimenti ttajpjati li tgħaddi minnhom hekk kif jaslu. Kull framment ta’ test jasal f’avveniment response.output_text.delta; it-tmiem tas-stream huwa sinjalat minn response.completed, li jġib l-oġġett sħiħ tar-risposta, utli biex tirrikupra l-użu tat-tokens.
import openai
client = openai.OpenAI()
def generate_streaming(prompt: str):
"""Ġenerazzjoni b'streaming bl-API tar-Risposti."""
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() # Linja ġdida fl-aħħar
return event.response
Il-flag flush=True mhuwiex kożmetiku: mingħajru, Python jibbufferja l-output waħdu, u tispiċċa bl-imġiba tal-blokk li kont qed tipprova tevita. Dan id-dettall jirrepeti f’kull saff tal-katina, u hija d-diffikultà ewlenija tas-streaming.
Il-mekkaniżmu jkopri wkoll is-sejħiet tal-funzjonijiet. L-argumenti tal-għodod jinbnew progressivament, u tista’ twerihom hekk kif jiġġeneraw biex tissinjala lill-utent li qed tiġi fformulata tfittxija, minflok ma tħallihom iħarsu lejn interfaċċa ffriżata waqt li l-mudell iħejji s-sejħa tiegħu.
tools = [
{
"type": "function",
"name": "search_product",
"description": "Searches for a product in the catalog.",
"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":
# Argumenti tal-funzjoni li qed jiġu ġġenerati bħalissa
print(f"[arg: {event.delta}]", end="")
case "response.function_call_arguments.done":
print(f"\n[Sejħa tal-funzjoni kompluta]")
It-trażmissjoni tas-stream lejn il-browser
Il-frontend tiegħek ma jkellimx l-API ta’ OpenAI direttament—jiklem is-server tiegħek, li għalhekk irid jittrażmetti s-stream. Is-Server-Sent Events (SSE) huma l-format naturali għal dan: tweġiba HTTP li tibqa’ miftuħa, fejn kull linja data: iġġib framment JSON. L-eżempju li ġej jittrażmetti t-test hekk kif jasal, imbagħad jemetti messaġġ finali li fih in-numru ta’ tokens, li jippermettilek tifattura jew tirreġistra mingħajr sejħa oħra.
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", # Importanti għal nginx
},
)
Imbagħad hemm il-proxy invers, is-suspettat tas-soltu meta “s-streaming ma jaħdimx fil-produzzjoni għalkemm ħadem lokalment.” B’mod predefinit, nginx jakkumula r-risposta tal-backend qabel ma jittrażmettiha. Il-konfigurazzjoni hawn taħt tiddiżattiva dan l-imġiba għar-rotta speċifika biss.
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;
}
Iż-żamma tal-konnessjoni matul iż-żmien
Stream miftuħ għal diversi għexieren ta’ sekondi huwa aktar espost minn sejħa qasira: qtugħ fin-netwerk, laqgħa ta’ kwota, u l-ġenerazzjoni tieqaf f’nofs sentenza. L-istrateġija ta’ retry tiegħek trid tagħmel distinzjoni bejn dawn iż-żewġ każijiet, għax jeħtieġu approċċi differenti. Żball fil-konnessjoni għandu jiġi ppruvat mill-ġdid b’backoff esponenzjali, u jagħti ż-żmien lin-netwerk biex jirkupra mingħajr ma jħabbat l-API; qbiż tal-kwota għandu jiġi ppruvat mill-ġdid wara stennija fissa, peress li t-tieqa tal-limitu tar-rata tirrisettja f’intervalli regolari.
import openai
def resilient_streaming(prompt: str, max_attempts: int = 3):
"""Streaming b'ġestjoni tal-iżbalji u retry."""
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 # Suċċess, oħroġ
except openai.APIConnectionError:
if attempt < max_attempts - 1:
import time
time.sleep(2 ** attempt) # Backoff esponenzjali
else:
raise
except openai.RateLimitError:
import time
time.sleep(5) # Stennija fissa għal-limitu tar-rata
Aġġustament finali jtejjeb il-kumdità tal-qari. L-emissjoni ta’ kull token tipproduċi test imqatta’, speċjalment jekk l-interfaċċa tiegħek tapplika animazzjoni jew jekk ir-riżultat imur għat-test-għal-kliem (text-to-speech). L-akkumulazzjoni sal-aħħar ta’ sentenza tagħti ritmu aktar qrib il-qari uman, bl-ispiża ta’ dewmien żgħir addizzjonali fuq l-ewwel framment.
def streaming_by_sentence(prompt: str):
"""Jakkumula u jipproduċi b'sentenza sħiħa."""
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
# Fittex tmiem is-sentenza
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()
Innota l-if buffer.strip() finali: mingħajru, tweġiba li ma tispiċċax b’punteġġjatura qawwija titlef l-aħħar kliem tagħha. Dan it-tip ta’ żball jinnota ftit fit-testijiet u jidher fil-produzzjoni fuq tweġibiet imqassra minn max_output_tokens.
Punti Ewlenin
- Dejjem uża s-streaming fil-produzzjoni biex tnaqqas il-latenza perċepita
- Ikkonfigura nginx b’
proxy_buffering offgħal SSE - Immaniġġja l-iżbalji b’retry u backoff esponenzjali
- Akkumula skont is-sentenza għal wiri aktar naturali