Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Läge för bakgrundsbearbetning

Lektion 9 av 20 Uppdaterad 28 juli 2026 Avancerad
På denna sida
  1. En tredje väg mellan synkront och batch
  2. Starta och hämta
  3. Långa resonemangsuppgifter
  4. Välja rätt läge
  5. Viktiga punkter

En tredje väg mellan synkront och batch

Responses API:s läge för bakgrundsbearbetning fyller en specifik nisch i din verktygslåda. Ett synkront anrop ger dig svaret omedelbart men tvingar dig att hålla anslutningen öppen under hela genereringen. Batch-API:t bearbetar tusentals förfrågningar till halva priset, men resultaten tar timmar. Bakgrundsläget ligger mitt emellan: det hanterar enskilda förfrågningar till standardtaxa utan en öppen anslutning. Du skickar in förfrågan, får en ID tillbaka och hämtar resultatet när det är klart.

Denna kompromiss riktar sig till ett precist användningsfall: en enskild förfrågan som tar för lång tid för ett blockerande anrop men som inte kan vänta till imorgon. Detta är exakt scenariot när du kör en modell med hög resonemangsförmåga på ett komplext dokument.

Starta och hämta

Aktivering kräver bara en parameter. Det omedelbara svaret innehåller ingen text; det returnerar en ID och en status, vanligtvis queued eller in_progress.

import openai

client = openai.OpenAI()

# Starta förfrågan i bakgrunden
response = client.responses.create(
    model="gpt-5.6-sol",  # Idealiskt för långsamma uppgifter (hög resonemangsförmåga)
    input="Analysera de ekonomiska konsekvenserna av europeisk AI-reglering "
          "för franska små och medelstora företag. Föreslå en handlingsplan med 10 punkter.",
    background=True,  # Bakgrundsläge
)

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

Detta ID är din enda länk till det pågående arbetet: spara det innan du gör något annat. Att tappa bort det innebär att du betalar för en generering som du aldrig kommer att hämta. Hämtning innebär sedan att du frågar API:t tills statusen blir terminal, där du hanterar fel och avbrott separat eftersom de har olika affärsmässiga konsekvenser.

import time

def wait_for_response(response_id: str, interval: int = 5) -> str:
    """Väntar på att ett bakgrundssvar ska slutföras."""
    while True:
        response = client.responses.retrieve(response_id)

        match response.status:
            case "completed":
                return response.output_text
            case "failed":
                raise RuntimeError(
                    f"Förfrågan misslyckades: {response.error}"
                )
            case "cancelled":
                raise RuntimeError("Förfrågan avbröts.")
            case _:
                print(f"Status: {response.status}...")
                time.sleep(interval)

Långa resonemangsuppgifter

En modell som GPT-5.6 Sol med aktiverad hög resonemangsförmåga kan ta mellan 30 sekunder och två minuter innan den producerar sin första synliga token. I ett synkront anrop överskrider dessa tider standardtimeouts för HTTP-klienter, proxyserverrar och gateways. Bakgrundsläget eliminerar detta problem vid roten och låter dig dessutom starta flera tunga analyser utan att binda upp lika många anslutningar.

async def deep_analysis(document: str) -> str:
    """Startar en analys med GPT-5.6 Sol utan blockering."""
    response = client.responses.create(
        model="gpt-5.6-sol",
        input=f"Utför en grundlig juridisk analys av detta kontrakt. "
              f"Identifiera alla potentiella risker, problematiska klausuler, "
              f"och föreslå modifieringar.\n\n{document}",
        background=True,
    )
    return response.id

# Starta flera analyser parallellt
task_ids = []
for doc in documents:
    task_id = await deep_analysis(doc)
    task_ids.append(task_id)

# Hämta resultat senare
results = {}
for task_id in task_ids:
    results[task_id] = wait_for_response(task_id)

Detta mönster utvidgas naturligt till webhooks när anroparen är en annan tjänst. Din endpoint startar förfrågan, returnerar ID:t och delegerar en bakgrundsuppgift för att övervaka slutförandet och skicka notifieringar. Anroparen behöver inte fråga (polling); den blir notifierad.

from fastapi import FastAPI, BackgroundTasks
import httpx

app = FastAPI()

@app.post("/api/long-analysis")
async def launch_analysis(request: dict, background_tasks: BackgroundTasks):
    """Startar en analys och notifierar via webhook när den är klar."""
    response = client.responses.create(
        model="gpt-5.6-sol",
        input=request["prompt"],
        background=True,
    )

    # Övervaka i bakgrunden
    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):
    """Övervakar en bakgrundsförfrågan och notifierar via 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,
        })

Välja rätt läge

Beslutsregeln kokar ner till två frågor. Hur många förfrågningar? Och väntar användaren? Vid fler än hundra förfrågningar utan krav på omedelbarhet vinner Batch-API:t på pris: resultat om timmar till halva kostnaden. Om någon väntar vid sin skärm är synkrona anrop fortfarande det enda acceptabla valet till standardtaxa. Bakgrundsläget fyller resten av utrymmet: få förfrågningar, resultat på några minuter, standardpris. Det lönar sig att kodifiera denna logik en gång istället för att återupprepa den för varje ny tjänst.

def choose_mode(
    num_requests: int,
    urgency: str,
    budget: str,
) -> str:
    """Rekommenderar det optimala exekveringsläget."""
    if num_requests > 100 and urgency != "immediate":
        return "batch"
    elif urgency == "immediate":
        return "synchronous"
    else:
        return "background"

Planera slutligen en nödutgång. En bakgrundsförfrågan som vida överskrider sin förväntade duration binder upp budget och försenar resten av din pipeline; API:t låter dig avbryta den explicit. Sätt detta tak vid dubbla den duration du observerar i praktiken, inte genomsnittet, annars riskerar du att avbryta förfrågningar som höll på att lyckas.

def cancel_if_too_long(response_id: str, timeout: int = 120):
    """Avbryter en förfrågan om den överskrider timeout."""
    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 överskriden — avbryt
    client.responses.cancel(response_id)
    raise TimeoutError(
        f"Förfrågan {response_id} avbruten efter {timeout}s."
    )

Viktiga punkter

  • Bakgrundsläget startar förfrågningar utan att hålla en anslutning öppen
  • Idealiskt för inställningar med hög resonemangsförmåga (GPT-5.6 Sol) och långa uppgifter
  • Kombinera med en webhook för en händelsestyrd arkitektur
  • Spara svars-ID:t: det är din enda länk till det pågående arbetet
  • För kostnadseffektiv bulkbearbetning, föredra Batch-API:t