Modul de fundal
Pe această pagină
O a treia cale între sincron și lot
Modul de fundal al API-ului Responses ocupă o nișă specifică în trusa dumneavoastră de instrumente. Un apel sincron vă oferă răspunsul imediat, dar vă obligă să mențineți conexiunea deschisă pe întreaga durată a generării. API-ul Batch procesează mii de cereri la jumătate din preț, dar rezultatele sosesc după ore întregi. Modul de fundal se situează între cele două: gestionează cereri individuale la tariful standard, fără o conexiune deschisă. Trimiteți cererea, primiți un ID și preluați rezultatul când este gata.
Acest compromis vizează un caz de utilizare precis: o singură cerere care durează prea mult pentru un apel blocant, dar care nu poate aștepta până mâine. Acesta este exact scenariul întâlnit când rulați un model cu raționament avansat pe un document complex.
Lansare și preluare
Activarea necesită un singur parametru. Răspunsul imediat nu conține text; returnează un ID și o stare, de obicei queued sau in_progress.
import openai
client = openai.OpenAI()
# Lansarea cererii în fundal
response = client.responses.create(
model="gpt-5.6-sol", # Ideal pentru sarcini lente (raționament ridicat)
input="Analyze the economic implications of European AI regulation "
"for French SMEs. Propose a 10-point action plan.",
background=True, # Modul de fundal
)
print(f"Response ID: {response.id}")
print(f"Status: {response.status}") # "queued" sau "in_progress"
Acest ID este singura legătură cu lucrarea în curs: stocați-l înainte de a face orice altceva. Pierderea lui înseamnă plata unei generări pe care nu o veți putea recupera niciodată. Preluarea implică apoi interogarea periodică (polling) a API-ului până când starea devine terminală, gestionând eșecul și anularea separat, deoarece au consecințe comerciale diferite.
import time
def wait_for_response(response_id: str, interval: int = 5) -> str:
"""Așteaptă finalizarea unui răspuns în fundal."""
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)
Sarcini de raționament lung
Un model precum GPT-5.6 Sol, cu raționamentul activat la nivel ridicat, poate dura între 30 de secunde și două minute înainte de a produce primul token vizibil. Într-un apel sincron, aceste durate lovesc timeout-urile implicite ale clienților HTTP, proxy-urilor și gateway-urilor. Modul de fundal elimină această problemă de la rădăcină și, incidental, vă permite să lansați mai multe analize complexe fără a bloca atâtea conexiuni.
async def deep_analysis(document: str) -> str:
"""Lansează o analiză cu GPT-5.6 Sol fără blocare."""
response = client.responses.create(
model="gpt-5.6-sol",
input=f"Perform a thorough legal analysis of this contract. "
f"Identify all potential risks, problematic clauses, "
f"and propose modifications.\n\n{document}",
background=True,
)
return response.id
# Lansarea mai multor analize în paralel
task_ids = []
for doc in documents:
task_id = await deep_analysis(doc)
task_ids.append(task_id)
# Preluarea rezultatelor ulterior
results = {}
for task_id in task_ids:
results[task_id] = wait_for_response(task_id)
Acest model se extinde natural la webhook-uri atunci când apelantul este un alt serviciu. Endpoint-ul dumneavoastră lansează cererea, returnează ID-ul și deleagă o sarcină în fundal pentru a monitoriza finalizarea și a trimite notificări. Apelantul nu face polling; primește o notificare.
from fastapi import FastAPI, BackgroundTasks
import httpx
app = FastAPI()
@app.post("/api/long-analysis")
async def launch_analysis(request: dict, background_tasks: BackgroundTasks):
"""Lansează o analiză și notifică prin webhook la finalizare."""
response = client.responses.create(
model="gpt-5.6-sol",
input=request["prompt"],
background=True,
)
# Monitorizare în fundal
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):
"""Monitorizează o cerere în fundal și notifică prin 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,
})
Alegerea modului potrivit
Regula de decizie se reduce la două întrebări: Câte cereri sunt? Și așteaptă utilizatorul? Dincolo de o sută de cereri fără cerință de imediatitate, API-ul Batch câștigă la preț: rezultate în ore, la jumătate din cost. Dacă cineva așteaptă în fața ecranului, apelurile sincron rămân singura alegere acceptabilă la tariful standard. Modul de fundal umple restul spațiului: puține cereri, rezultate în minute, preț standard. Merită să codificați această logică o singură dată, în loc să o reanalizați pentru fiecare serviciu nou.
def choose_mode(
num_requests: int,
urgency: str,
budget: str,
) -> str:
"""Recomandă modul de execuție optim."""
if num_requests > 100 and urgency != "immediate":
return "batch"
elif urgency == "immediate":
return "synchronous"
else:
return "background"
În final, planificați o ieșire de urgență. O cerere în fundal care depășește cu mult durata așteptată blochează bugetul și întârzie restul pipeline-ului dumneavoastră; API-ul vă permite să o anulați explicit. Stabiliți acest plafon la dublul duratei observate în practică, nu la medie, altfel riscați să anulați cereri care erau pe punctul de a reuși.
def cancel_if_too_long(response_id: str, timeout: int = 120):
"""Anulează o cerere dacă depășește timeout-ul."""
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)
# Timeout depășit — anulare
client.responses.cancel(response_id)
raise TimeoutError(
f"Request {response_id} cancelled after {timeout}s."
)
Puncte cheie
- Modul de fundal lansează cereri fără a menține o conexiune deschisă
- Ideal pentru setări de raționament ridicat (GPT-5.6 Sol) și sarcini lungi
- Combinați-l cu un webhook pentru o arhitectură bazată pe evenimente
- Stocați ID-ul răspunsului: este singura legătură cu lucrarea în curs
- Pentru procesarea în lot la cost redus, preferați API-ul Batch