Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Achtergrondmodus

Les 9 van 20 Bijgewerkt op 28 juli 2026 Gevorderd
Op deze pagina
  1. Een derde weg tussen synchroon en batch
  2. Starten en ophalen
  3. Lange redeneertaken
  4. De juiste modus kiezen
  5. Belangrijkste punten

Een derde weg tussen synchroon en batch

De achtergrondmodus van de Responses API vult een specifieke niche in uw toolkit. Een synchrone oproep geeft u direct het antwoord, maar dwingt u om de verbinding tijdens de volledige generatie open te houden. De Batch API verwerkt duizenden verzoeken tegen de halve prijs, maar de resultaten duren uren. De achtergrondmodus zit daar tussenin: hij behandelt individuele verzoeken tegen het standaardtarief zonder een open verbinding. U dient het verzoek in, ontvangt een ID en haalt het resultaat op wanneer het klaar is.

Dit compromis richt zich op een precies gebruiksscenario: een enkel verzoek dat te lang duurt voor een blokkerende oproep, maar niet tot morgen kan wachten. Dit is exact het scenario wanneer u een model met hoge redeneercapaciteit uitvoert op een complex document.

Starten en ophalen

Activering vereist slechts één parameter. De directe respons bevat geen tekst; deze retourneert een ID en een status, doorgaans queued of in_progress.

import openai

client = openai.OpenAI()

# Start het verzoek op de achtergrond
response = client.responses.create(
    model="gpt-5.6-sol",  # Ideaal voor trage taken (hoge redenering)
    input="Analyseer de economische implicaties van Europese AI-regelgeving "
          "voor Franse MKB-bedrijven. Stel een actieplan met 10 punten op.",
    background=True,  # Achtergrondmodus
)

print(f"Response ID: {response.id}")
print(f"Status: {response.status}")  # "queued" of "in_progress"

Deze ID is uw enige link naar het lopende werk: sla deze op voordat u iets anders doet. Verlies ervan betekent dat u betaalt voor een generatie die u nooit zult ophalen. Ophalen vereist vervolgens dat u de API peilt totdat de status definitief wordt, waarbij u falen en annulering apart behandelt omdat deze verschillende zakelijke gevolgen hebben.

import time

def wait_for_response(response_id: str, interval: int = 5) -> str:
    """Wacht tot een achtergrondrespons is voltooid."""
    while True:
        response = client.responses.retrieve(response_id)

        match response.status:
            case "completed":
                return response.output_text
            case "failed":
                raise RuntimeError(
                    f"Verzoek mislukt: {response.error}"
                )
            case "cancelled":
                raise RuntimeError("Verzoek is geannuleerd.")
            case _:
                print(f"Status: {response.status}...")
                time.sleep(interval)

Lange redeneertaken

Een model zoals GPT-5.6 Sol met ingeschakelde hoge redeneercapaciteit kan 30 seconden tot twee minuten duren voordat het eerste zichtbare token wordt geproduceerd. Bij een synchrone oproep botsen deze duurtes op de standaardtime-outs van HTTP-clients, proxies en gateways. De achtergrondmodus elimineert dit probleem bij de bron en stelt u incidenteel in staat om meerdere zware analyses te starten zonder evenveel verbindingen vast te leggen.

async def deep_analysis(document: str) -> str:
    """Start een analyse met GPT-5.6 Sol zonder te blokkeren."""
    response = client.responses.create(
        model="gpt-5.6-sol",
        input=f"Voer een grondige juridische analyse van dit contract uit. "
              f"Identificeer alle potentiële risico's, problematische clausules "
              f"en stel wijzigingen voor.\n\n{document}",
        background=True,
    )
    return response.id

# Start meerdere analyses parallel
task_ids = []
for doc in documents:
    task_id = await deep_analysis(doc)
    task_ids.append(task_id)

# Haal resultaten later op
results = {}
for task_id in task_ids:
    results[task_id] = wait_for_response(task_id)

Dit patroon breidt zich natuurlijk uit naar webhooks wanneer de beller een andere service is. Uw endpoint start het verzoek, retourneert de ID en delegeert een achtergrondtaak om de voltooiing te bewaken en meldingen te verzenden. De beller peilt niet; deze krijgt een melding.

from fastapi import FastAPI, BackgroundTasks
import httpx

app = FastAPI()

@app.post("/api/long-analysis")
async def launch_analysis(request: dict, background_tasks: BackgroundTasks):
    """Start een analyse en stelt via webhook op de hoogte wanneer klaar."""
    response = client.responses.create(
        model="gpt-5.6-sol",
        input=request["prompt"],
        background=True,
    )

    # Bewaak op de achtergrond
    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):
    """Bewaakt een achtergrondverzoek en stelt via webhook op de hoogte."""
    result = wait_for_response(response_id)

    async with httpx.AsyncClient() as http:
        await http.post(webhook_url, json={
            "response_id": response_id,
            "result": result,
        })

De juiste modus kiezen

De beslissingsregel komt neer op twee vragen. Hoeveel verzoeken? En wacht de gebruiker? Bij meer dan honderd verzoeken zonder vereiste voor directheid wint de Batch API het qua prijs: resultaten binnen uren tegen de halve kosten. Als iemand wacht achter zijn scherm, blijven synchrone oproepen de enige aanvaardbare keuze tegen het standaardtarief. De achtergrondmodus vult de rest van de ruimte: weinig verzoeken, resultaten binnen minuten, standaardprijs. Het loont de moeite om deze logica eenmaal vast te leggen in plaats van deze voor elke nieuwe service opnieuw te bespreken.

def choose_mode(
    num_requests: int,
    urgency: str,
    budget: str,
) -> str:
    """Beveelt de optimale uitvoeringsmodus aan."""
    if num_requests > 100 and urgency != "immediate":
        return "batch"
    elif urgency == "immediate":
        return "synchronous"
    else:
        return "background"

Plan tot slot een uitweg. Een achtergrondverzoek dat zijn verwachte duur ver overschrijdt, legt budget vast en vertraagt de rest van uw pipeline; de API laat u toe dit expliciet te annuleren. Stel dit plafond op het dubbele van de duur die u in de praktijk observeert, niet het gemiddelde, anders riskeert u verzoeken te annuleren die op het punt stonden te slagen.

def cancel_if_too_long(response_id: str, timeout: int = 120):
    """Annuleert een verzoek als het de time-out overschrijdt."""
    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)

    # Time-out overschreden — annuleren
    client.responses.cancel(response_id)
    raise TimeoutError(
        f"Verzoek {response_id} geannuleerd na {timeout}s."
    )

Belangrijkste punten

  • De achtergrondmodus start verzoeken zonder een verbinding open te houden
  • Ideaal voor instellingen met hoge redeneercapaciteit (GPT-5.6 Sol) en lange taken
  • Combineer met een webhook voor een event-driven architectuur
  • Sla de response-ID op: dit is uw enige link naar het lopende werk
  • Voor goedkope bulkverwerking geeft u de voorkeur aan de Batch API