Salt la conținutul principal
Română— Alege o limbă
Meniu

Modul de fundal

Lecția 9 din 20 Actualizată 28 iulie 2026 Avansat
Pe această pagină
  1. O a treia cale între sincron și lot
  2. Lansare și preluare
  3. Sarcini de raționament lung
  4. Alegerea modului potrivit
  5. Puncte cheie

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