Háttérmód
Ezen az oldalon
Egy harmadik út a szinkron és a kötegelt feldolgozás között
A Responses API háttérmódja egy specifikus rést tölt be az eszköztáradban. A szinkron hívás azonnal megadja a választ, de arra kényszerít, hogy a generálás teljes ideje alatt nyitva tartsd a kapcsolatot. A Batch API ezreknyi kérést dolgoz fel az ár feléért, cserébe az eredmények órákig tartanak. A háttérmód e kettő között helyezkedik el: egyedi kéréseket kezel szabványos áron, nyitott kapcsolat nélkül. Beküldöd a kérést, kapsz egy azonosítót, és akkor retrieving az eredményt, amikor elkészült.
Ez a kompromisszum egy pontos használati esetet céloz meg: olyan egyedi kérést, amely túl hosszú egy blokkoló híváshoz, de nem várhat holnapig. Pontosan ez a helyzet áll fenn, amikor egy magas szintű következtetési képességgel rendelkező modellt futtatsz egy összetett dokumentumon.
Indítás és lekérdezés
Az aktiváláshoz mindössze egyetlen paraméter szükséges. Az azonnali válasz nem tartalmaz szöveget; csak egy azonosítót és egy állapotot ad vissza, amely jellemzően queued (sorban álló) vagy in_progress (folyamatban).
import openai
client = openai.OpenAI()
# Kérés indítása háttérben
response = client.responses.create(
model="gpt-5.6-sol", # Ideális lassú feladatokhoz (magas szintű következtetés)
input="Elemezd az európai AI-szabályozás gazdasági hatásait "
"a francia KKV-kra. Javasolj egy 10 pontos cselekvési tervet.",
background=True, # Háttérmód
)
print(f"Válasz azonosító: {response.id}")
print(f"Állapot: {response.status}") # "queued" vagy "in_progress"
Ez az azonosító az egyetlen kapocsod a folyamatban lévő munkához: mentsd el, mielőtt bármi mást tennél. Ha elveszíted, akkor egy olyan generálásért fizettél, amit sosem tudsz lekérni. A lekérdezés ezután az API periodikus lekérdezését (polling) jelenti, amíg az állapot véglegessé nem válik. A hibát és a megszakítást külön kell kezelni, mivel ezek üzleti következményei eltérőek.
import time
def wait_for_response(response_id: str, interval: int = 5) -> str:
"""Megvárja, amíg egy háttérben futó válasz elkészül."""
while True:
response = client.responses.retrieve(response_id)
match response.status:
case "completed":
return response.output_text
case "failed":
raise RuntimeError(
f"A kérés sikertelen: {response.error}"
)
case "cancelled":
raise RuntimeError("A kérést megszakították.")
case _:
print(f"Állapot: {response.status}...")
time.sleep(interval)
Hosszú következtetési feladatok
Egy olyan modell, mint a GPT-5.6 Sol a magas szintű következtetés engedélyezésével, 30 másodperctől két percig is eltarthat, mire az első látható tokent előállítja. Szinkron hívás esetén ezek az időtartamok elérhetik a HTTP-kliensek, proxyk és átjárók alapértelmezett időtúllépési limiteit. A háttérmód gyökerében szünteti meg ezt a problémát, és mellékesen lehetővé teszi több nehéz elemzés párhuzamos indítását anélkül, hogy annyi kapcsolatot lekötnél.
async def deep_analysis(document: str) -> str:
"""Elemzést indít a GPT-5.6 Sol modellel blokkolás nélkül."""
response = client.responses.create(
model="gpt-5.6-sol",
input=f"Végezz alapos jogi elemzést erről a szerződésről. "
f"Azonosítsd az összes potenciális kockázatot, problémás záradékot, "
f"és javasolj módosításokat.\n\n{document}",
background=True,
)
return response.id
# Több elemzés párhuzamos indítása
task_ids = []
for doc in documents:
task_id = await deep_analysis(doc)
task_ids.append(task_id)
# Eredmények későbbi lekérdezése
results = {}
for task_id in task_ids:
results[task_id] = wait_for_response(task_id)
Ez a minta természetesen kiterjeszthető webhookokra is, amikor a hívó fél egy másik szolgáltatás. A végpontod elindítja a kérést, visszaadja az azonosítót, és egy háttérfeladatra bízza a befejezés figyelését, valamint az értesítések küldését. A hívó fél nem végez lekérdezést (polling); helyette értesítést kap.
from fastapi import FastAPI, BackgroundTasks
import httpx
app = FastAPI()
@app.post("/api/long-analysis")
async def launch_analysis(request: dict, background_tasks: BackgroundTasks):
"""Elemzést indít, és webhookon keresztül értesít, ha kész."""
response = client.responses.create(
model="gpt-5.6-sol",
input=request["prompt"],
background=True,
)
# Figyelés háttérben
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):
"""Figyel egy háttérben futó kérést, és webhookon értesít."""
result = wait_for_response(response_id)
async with httpx.AsyncClient() as http:
await http.post(webhook_url, json={
"response_id": response_id,
"result": result,
})
A megfelelő mód kiválasztása
A döntési szabály két kérdésre vezethető vissza. Hány kérésről van szó? És vár-e a felhasználó? Száz kérés felett, ahol nincs szükség azonnaliságra, a Batch API nyer az áron: az eredmények órák alatt készülnek el, féláron. Ha valaki a képernyő előtt vár, a szinkron hívások maradnak az egyetlen elfogadható választás szabványos áron. A háttérmód tölti ki a maradék teret: kevés kérés, perces eredményidő, szabványos ár. Érdemes ezt a logikát egyszer kódolni, ahelyett, hogy minden új szolgáltatásnál újra átvennéd.
def choose_mode(
num_requests: int,
urgency: str,
budget: str,
) -> str:
"""Ajánlást tesz a optimális végrehajtási módra."""
if num_requests > 100 and urgency != "immediate":
return "batch"
elif urgency == "immediate":
return "synchronous"
else:
return "background"
Végül tervezz vészkijáratot is. Egy olyan háttérben futó kérés, amely messze meghaladja a várt időtartamot, leköti a költségkeretet és késlelteti a többi folyamatot; az API lehetővé teszi ezek explicit megszakítását. Ezt a felső határt a gyakorlatban megfigyelt időtartam kétszeresénél állítsd be, ne az átlagnál, különben kockáztatod, hogy olyan kéréseket szakítasz meg, amelyek éppen sikerrel jártak volna.
def cancel_if_too_long(response_id: str, timeout: int = 120):
"""Megszakít egy kérést, ha túllépi az időkorlátot."""
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)
# Időtúllépés — megszakítás
client.responses.cancel(response_id)
raise TimeoutError(
f"A(z) {response_id} azonosítójú kérés megszakítva {timeout}s után."
)
Főbb megállapítások
- A háttérmód nyitott kapcsolat fenntartása nélkül indít kéréseket
- Ideális magas szintű következtetési beállításokhoz (GPT-5.6 Sol) és hosszú feladatokhoz
- Kombináld webhookkal az eseményvezérelt architektúrákhoz
- Mentsd el a válasz azonosítóját: ez az egyetlen kapocs a folyamatban lévő munkához
- Alacsony költségű tömeges feldolgozáshoz részesítsd előnyben a Batch API-t