Hintergrundmodus

Ein dritter Weg zwischen synchron und Batch

Der Hintergrundmodus der Responses API füllt eine spezifische Nische in Ihrem Werkzeugkasten. Ein synchroner Aufruf liefert Ihnen die Antwort sofort, zwingt Sie aber, die Verbindung während der gesamten Generierung offen zu halten. Die Batch API verarbeitet Tausende von Anfragen zur Hälfte des Preises, doch die Ergebnisse dauern Stunden. Der Hintergrundmodus liegt dazwischen: Er verarbeitet einzelne Anfragen zum Standardpreis, ohne dass eine offene Verbindung erforderlich ist. Sie übermitteln die Anfrage, erhalten eine ID und rufen das Ergebnis ab, sobald es bereit ist.

Dieser Kompromiss zielt auf einen präzisen Anwendungsfall ab: Eine einzelne Anfrage, die für einen blockierenden Aufruf zu lange dauert, aber nicht bis morgen warten kann. Dies ist genau die Situation, in der ein Modell mit hoher Schlussfolgerungsfähigkeit auf einem komplexen Dokument ausgeführt wird.

Starten und Abrufen

Die Aktivierung erfordert nur einen Parameter. Die sofortige Antwort enthält keinen Text; sie gibt eine ID und einen Status zurück, typischerweise queued oder in_progress.

import openai

client = openai.OpenAI()

# Starten Sie die Anfrage im Hintergrund
response = client.responses.create(
    model="gpt-5.6-sol",  # Ideal für langsame Aufgaben (hohe Schlussfolgerungsfähigkeit)
    input="Analysieren Sie die wirtschaftlichen Auswirkungen der europäischen KI-Regulierung "
          "für französische KMUs. Erstellen Sie einen 10-Punkte-Aktionsplan.",
    background=True,  # Hintergrundmodus
)

print(f"Antwort-ID: {response.id}")
print(f"Status: {response.status}")  # "queued" oder "in_progress"

Diese ID ist Ihr einziger Link zu der laufenden Arbeit: Speichern Sie sie, bevor Sie etwas anderes tun. Wenn Sie sie verlieren, zahlen Sie für eine Generierung, die Sie niemals abrufen können. Das Abrufen umfasst das Abfragen der API, bis der Status terminal ist, wobei Fehler und Absagen separat behandelt werden, da sie unterschiedliche geschäftliche Konsequenzen haben.

import time

def wait_for_response(response_id: str, interval: int = 5) -> str:
    """Wartet auf die Fertigstellung einer Hintergrundantwort."""
    while True:
        response = client.responses.retrieve(response_id)

        match response.status:
            case "completed":
                return response.output_text
            case "failed":
                raise RuntimeError(
                    f"Anfrage fehlgeschlagen: {response.error}"
                )
            case "cancelled":
                raise RuntimeError("Anfrage wurde abgebrochen.")
            case _:
                print(f"Status: {response.status}...")
                time.sleep(interval)

Aufgaben mit langwieriger Schlussfolgerung

Ein Modell wie GPT-5.6 Sol mit aktivierter hoher Schlussfolgerungsfähigkeit kann 30 Sekunden bis zwei Minuten dauern, bevor es sein erstes sichtbares Token erzeugt. Bei einem synchronen Aufruf treffen diese Dauerzeiten auf die Standard-Timeouts von HTTP-Clients, Proxys und Gateways. Der Hintergrundmodus beseitigt dieses Problem an der Wurzel und ermöglicht es Ihnen nebenbei, mehrere schwere Analysen zu starten, ohne so viele Verbindungen zu blockieren.

async def deep_analysis(document: str) -> str:
    """Startet eine Analyse mit GPT-5.6 Sol ohne Blockierung."""
    response = client.responses.create(
        model="gpt-5.6-sol",
        input=f"Führen Sie eine gründliche rechtliche Analyse dieses Vertrags durch. "
              f"Identifizieren Sie alle potenziellen Risiken, problematische Klauseln "
              f"und schlagen Sie Änderungen vor.\n\n{document}",
        background=True,
    )
    return response.id

# Starten Sie mehrere Analysen parallel
task_ids = []
for doc in documents:
    task_id = await deep_analysis(doc)
    task_ids.append(task_id)

# Ergebnisse später abrufen
results = {}
for task_id in task_ids:
    results[task_id] = wait_for_response(task_id)

Dieses Muster lässt sich natürlich auf Webhooks erweitern, wenn der Aufrufer ein anderer Dienst ist. Ihr Endpunkt startet die Anfrage, gibt die ID zurück und delegiert eine Hintergrundaufgabe zur Überwachung der Fertigstellung und zum Senden von Benachrichtigungen. Der Aufrufer fragt nicht ab; er wird benachrichtigt.

from fastapi import FastAPI, BackgroundTasks
import httpx

app = FastAPI()

@app.post("/api/long-analysis")
async def launch_analysis(request: dict, background_tasks: BackgroundTasks):
    """Startet eine Analyse und benachrichtigt über Webhook, wenn fertig."""
    response = client.responses.create(
        model="gpt-5.6-sol",
        input=request["prompt"],
        background=True,
    )

    # Überwachung im Hintergrund
    background_tasks.add_task(
        monitor_and_notify,
        response_id=response.id,
        webhook_url=request["webhook_url"],
    )

    return {"response_id": response.id, "status": "gestartet"}

async def monitor_and_notify(response_id: str, webhook_url: str):
    """Überwacht eine Hintergrundanfrage und benachrichtigt über 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,
        })

Die richtige Moduswahl treffen

Die Entscheidungsregel lässt sich auf zwei Fragen reduzieren. Wie viele Anfragen? Und wartet der Benutzer? Bei mehr als hundert Anfragen ohne Erfordernis der Unmittelbarkeit gewinnt die Batch API in puncto Preis: Ergebnisse in Stunden zur Hälfte des Kostenwerts. Wenn jemand am Bildschirm wartet, bleiben synchrone Aufrufe die einzige akzeptable Wahl zum Standardpreis. Der Hintergrundmodus füllt den Rest des Raums aus: wenige Anfragen, Ergebnisse in Minuten, Standardpreis. Es lohnt sich, diese Logik einmal zu kodifizieren, anstatt sie für jeden neuen Dienst erneut zu erläutern.

def choose_mode(
    num_requests: int,
    urgency: str,
    budget: str,
) -> str:
    """Empfehl den optimalen Ausführungsmodus."""
    if num_requests > 100 and urgency != "unmittelbar":
        return "batch"
    elif urgency == "unmittelbar":
        return "synchron"
    else:
        return "hintergrund"

Planen Sie abschließend eine Ausstiegsmöglichkeit. Eine Hintergrundanfrage, die ihre erwartete Dauer weit überschreitet, bindet Budget und verzögert den Rest Ihrer Pipeline; die API ermöglicht es Ihnen, sie explizit abzubrechen. Setzen Sie diese Obergrenze auf das Doppelte der Dauer, die Sie in der Praxis beobachten, nicht auf den Durchschnitt, oder Sie riskieren, Anfragen abzubrechen, die kurz vor dem Erfolg standen.

def cancel_if_too_long(response_id: str, timeout: int = 120):
    """Bricht eine Anfrage ab, wenn sie den Timeout überschreitet."""
    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 überschritten — abbrechen
    client.responses.cancel(response_id)
    raise TimeoutError(
        f"Anfrage {response_id} nach {timeout}s abgebrochen."
    )

Kernaussagen

• Der Hintergrundmodus startet Anfragen, ohne eine Verbindung offen zu halten
• Ideal für Einstellungen mit hoher Schlussfolgerungsfähigkeit (GPT-5.6 Sol) und langen Aufgaben
• Kombinieren Sie mit einem Webhook für eine ereignisgesteuerte Architektur
• Speichern Sie die Antwort-ID: Sie ist Ihr einziger Link zu der laufenden Arbeit
• Für kostengünstige Massenverarbeitung bevorzugen Sie die Batch API