Veikimas foniniame režime
Šiame puslapyje
Trečias kelias tarp sinchroninio ir grupinio apdorojimo
„Responses“ API foninis režimas užpildo specifinę nišą tavo įrankių rinkinyje. Sinchroninis užklausimas suteikia atsakymą iškart, tačiau verčia laikyti ryšį atvirą visos generavimo trukmės metu. Grupinis API (Batch API) apdoroja tūkstančius užklausų perpus mažesne kaina, tačiau rezultatus tenka laukti valandas. Foninis režimas yra tarpinis variantas: jis tvarko pavienes užklausas standartiniu tarifu be atviro ryšio. Tu pateiki užklausą, gauni ID ir atsiimi rezultatą, kai jis paruoštas.
Šis kompromisas skirtas tiksliai apibrėžtam naudojimui: vienai užklausai, kuri trunka per ilgai blokuojančiam skambučiui, bet negali laukti iki rytojaus. Tai būtent tas scenarijus, kai sudėtingam dokumentui taikai aukšto lygio samprotavimų modelį.
Paleidimas ir rezultatų gavimas
Aktyvavimui reikia tik vieno parametro. Momentaliame atsakyme teksto nėra; grąžinamas tik ID ir būsena, paprastai queued (eilėje) arba in_progress (vykdoma).
import openai
client = openai.OpenAI()
# Paleisti užklausą foniniame režime
response = client.responses.create(
model="gpt-5.6-sol", # Idealu lėtoms užduotims (aukštas samprotavimų lygis)
input="Išanalizuokite Europos DI reglamentavimo ekonominę įtaką "
"Prancūzijos MVĮ. Pasiūlykite 10 punktų veiksmų planą.",
background=True, # Foninis režimas
)
print(f"Response ID: {response.id}")
print(f"Status: {response.status}") # "queued" arba "in_progress"
Šis ID yra vienintelis tavo ryšys su vykdomu darbu: išsaugok jį prieš darant ką nors kita. Jį praradus reiškia sumokėti už generavimą, kurio rezultato niekada negausi. Rezultatų gavimas reiškia periodinį API tikrinimą (polling), kol būsena taps galutinė. Nesėkmę ir atšaukimą reikia tvarkyti atskirai, nes jie turi skirtingas verslo pasekmes.
import time
def wait_for_response(response_id: str, interval: int = 5) -> str:
"""Laukia, kol bus baigtas foninis atsakymas."""
while True:
response = client.responses.retrieve(response_id)
match response.status:
case "completed":
return response.output_text
case "failed":
raise RuntimeError(
f"Request failed: {response.error}"
)
case "cancelled":
raise RuntimeError("Request was cancelled.")
case _:
print(f"Status: {response.status}...")
time.sleep(interval)
Ilgos samprotavimų užduotys
Toks modelis kaip GPT-5.6 Sol su įjungtu aukšto lygio samprotavimu gali užtrukti nuo 30 sekundžių iki dviejų minučių, kol sugeneruos pirmąjį matomą tokeną. Sinchroninio skambučio metu ši trukmė viršija numatytąsias HTTP klientų, proxy serverių ir vartų laiko limitus. Foninis režimas pašalina šią problemą iš esmės ir kartu leidžia paleisti kelias sunkias analizes nesurišant tiek daug ryšių.
async def deep_analysis(document: str) -> str:
"""Paleidžia analizę su GPT-5.6 Sol neblokuojant."""
response = client.responses.create(
model="gpt-5.6-sol",
input=f"Atlikite išsamią šios sutarties teisinę analizę. "
f"Nustatykite visas potencialias rizikas, problemines nuostatas "
f"ir pasiūlykite pakeitimus.\n\n{document}",
background=True,
)
return response.id
# Paleisti kelias analizes lygiagrečiai
task_ids = []
for doc in documents:
task_id = await deep_analysis(doc)
task_ids.append(task_id)
# Gauti rezultatus vėliau
results = {}
for task_id in task_ids:
results[task_id] = wait_for_response(task_id)
Šis modelis natūraliai išplečiamas naudojant „webhook“, kai kviečiantysis yra kita tarnyba. Tavo galinis taškas (endpoint) paleidžia užklausą, grąžina ID ir deleguoja foninę užduotį stebėti užbaigimą bei siųsti pranešimus. Kvietėjas neatlieka periodinio tikrinimo; jis gauna pranešimą.
from fastapi import FastAPI, BackgroundTasks
import httpx
app = FastAPI()
@app.post("/api/long-analysis")
async def launch_analysis(request: dict, background_tasks: BackgroundTasks):
"""Paleidžia analizę ir praneša per webhook, kai baigta."""
response = client.responses.create(
model="gpt-5.6-sol",
input=request["prompt"],
background=True,
)
# Stebėti fone
background_tasks.add_task(
monitor_and_notify,
response_id=response.id,
webhook_url=request["webhook_url"],
)
return {"response_id": response.id, "status": "launched"}
async def monitor_and_notify(response_id: str, webhook_url: str):
"""Stebi foninę užklausą ir praneša per webhook."""
result = wait_for_response(response_id)
async with httpx.AsyncClient() as http:
await http.post(webhook_url, json={
"response_id": response_id,
"result": result,
})
Tinkamo režimo pasirinkimas
Sprendimo taisyklė remiasi dviem klausimais. Kiek užklausų? Ar vartotojas laukia? Jei užklausų daugiau nei šimtas ir nereikia skubos, Grupinis API (Batch API) laimi kainos atžvilgiu: rezultatai per valandas už pusę kainos. Jei kas nors laukia prie ekrano, sinchroniniai skambučiai lieka vieninteliu priimtinu pasirinkimu standartiniu tarifu. Foninis režimas užpildo likusią erdvę: nedaug užklausų, rezultatai per minutes, standartinė kaina. Verta šią logiką įtvirtinti kodu vieną kartą, o ne svarstyti iš naujo kiekvienai naujai tarnybai.
def choose_mode(
num_requests: int,
urgency: str,
budget: str,
) -> str:
"""Rekomenduoja optimalų vykdymo režimą."""
if num_requests > 100 and urgency != "immediate":
return "batch"
elif urgency == "immediate":
return "synchronous"
else:
return "background"
Galiausiai numatyk atsarginį išėjimą. Foninė užklausa, kuri gerokai viršija numatomą trukmę, suriša biudžetą ir delsia visą tavo vamzdyną; API leidžia ją aiškiai atšaukti. Nustatyk šią ribą ties dviguba praktiškai stebima trukme, o ne vidurkiu, kitaip rizikuoji atšaukti užklausas, kurios buvo beveik sėkmingai baigtos.
def cancel_if_too_long(response_id: str, timeout: int = 120):
"""Atšaukia užklausą, jei ji viršija laiko limitą."""
start = time.time()
while time.time() - start < timeout:
response = client.responses.retrieve(response_id)
if response.status == "completed":
return response.output_text
time.sleep(5)
# Laiko limitas viršytas – atšaukti
client.responses.cancel(response_id)
raise TimeoutError(
f"Request {response_id} cancelled after {timeout}s."
)
Svarbiausi punktai
- Foninis režimas paleidžia užklausas neatidarant nuolatinio ryšio
- Idealus aukšto lygio samprotavimų nustatymams (GPT-5.6 Sol) ir ilgoms užduotims
- Derink su „webhook“ įvykiais grįstai architektūrai kurti
- Išsaugok atsakymo ID: tai vienintelis tavo ryšys su vykdomu darbu
- Pigiam masiniam apdorojimui rinkis Grupinį API (Batch API)