Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Háttérmód

9. lecke 20 közül Frissítve 2026. július 28. Haladó
Ezen az oldalon
  1. Egy harmadik út a szinkron és a kötegelt feldolgozás között
  2. Indítás és lekérdezés
  3. Hosszú következtetési feladatok
  4. A megfelelő mód kiválasztása
  5. Főbb megállapítások

Egy harmadik út a szinkron és a kötegelt feldolgozás között

A Responses API háttérmódja egy specifikus rést tölt be az eszköztáradban. A szinkron hívás azonnal megadja a választ, de arra kényszerít, hogy a generálás teljes ideje alatt nyitva tartsd a kapcsolatot. A Batch API ezreknyi kérést dolgoz fel az ár feléért, cserébe az eredmények órákig tartanak. A háttérmód e kettő között helyezkedik el: egyedi kéréseket kezel szabványos áron, nyitott kapcsolat nélkül. Beküldöd a kérést, kapsz egy azonosítót, és akkor retrieving az eredményt, amikor elkészült.

Ez a kompromisszum egy pontos használati esetet céloz meg: olyan egyedi kérést, amely túl hosszú egy blokkoló híváshoz, de nem várhat holnapig. Pontosan ez a helyzet áll fenn, amikor egy magas szintű következtetési képességgel rendelkező modellt futtatsz egy összetett dokumentumon.

Indítás és lekérdezés

Az aktiváláshoz mindössze egyetlen paraméter szükséges. Az azonnali válasz nem tartalmaz szöveget; csak egy azonosítót és egy állapotot ad vissza, amely jellemzően queued (sorban álló) vagy in_progress (folyamatban).

import openai

client = openai.OpenAI()

# Kérés indítása háttérben
response = client.responses.create(
    model="gpt-5.6-sol",  # Ideális lassú feladatokhoz (magas szintű következtetés)
    input="Elemezd az európai AI-szabályozás gazdasági hatásait "
          "a francia KKV-kra. Javasolj egy 10 pontos cselekvési tervet.",
    background=True,  # Háttérmód
)

print(f"Válasz azonosító: {response.id}")
print(f"Állapot: {response.status}")  # "queued" vagy "in_progress"

Ez az azonosító az egyetlen kapocsod a folyamatban lévő munkához: mentsd el, mielőtt bármi mást tennél. Ha elveszíted, akkor egy olyan generálásért fizettél, amit sosem tudsz lekérni. A lekérdezés ezután az API periodikus lekérdezését (polling) jelenti, amíg az állapot véglegessé nem válik. A hibát és a megszakítást külön kell kezelni, mivel ezek üzleti következményei eltérőek.

import time

def wait_for_response(response_id: str, interval: int = 5) -> str:
    """Megvárja, amíg egy háttérben futó válasz elkészül."""
    while True:
        response = client.responses.retrieve(response_id)

        match response.status:
            case "completed":
                return response.output_text
            case "failed":
                raise RuntimeError(
                    f"A kérés sikertelen: {response.error}"
                )
            case "cancelled":
                raise RuntimeError("A kérést megszakították.")
            case _:
                print(f"Állapot: {response.status}...")
                time.sleep(interval)

Hosszú következtetési feladatok

Egy olyan modell, mint a GPT-5.6 Sol a magas szintű következtetés engedélyezésével, 30 másodperctől két percig is eltarthat, mire az első látható tokent előállítja. Szinkron hívás esetén ezek az időtartamok elérhetik a HTTP-kliensek, proxyk és átjárók alapértelmezett időtúllépési limiteit. A háttérmód gyökerében szünteti meg ezt a problémát, és mellékesen lehetővé teszi több nehéz elemzés párhuzamos indítását anélkül, hogy annyi kapcsolatot lekötnél.

async def deep_analysis(document: str) -> str:
    """Elemzést indít a GPT-5.6 Sol modellel blokkolás nélkül."""
    response = client.responses.create(
        model="gpt-5.6-sol",
        input=f"Végezz alapos jogi elemzést erről a szerződésről. "
              f"Azonosítsd az összes potenciális kockázatot, problémás záradékot, "
              f"és javasolj módosításokat.\n\n{document}",
        background=True,
    )
    return response.id

# Több elemzés párhuzamos indítása
task_ids = []
for doc in documents:
    task_id = await deep_analysis(doc)
    task_ids.append(task_id)

# Eredmények későbbi lekérdezése
results = {}
for task_id in task_ids:
    results[task_id] = wait_for_response(task_id)

Ez a minta természetesen kiterjeszthető webhookokra is, amikor a hívó fél egy másik szolgáltatás. A végpontod elindítja a kérést, visszaadja az azonosítót, és egy háttérfeladatra bízza a befejezés figyelését, valamint az értesítések küldését. A hívó fél nem végez lekérdezést (polling); helyette értesítést kap.

from fastapi import FastAPI, BackgroundTasks
import httpx

app = FastAPI()

@app.post("/api/long-analysis")
async def launch_analysis(request: dict, background_tasks: BackgroundTasks):
    """Elemzést indít, és webhookon keresztül értesít, ha kész."""
    response = client.responses.create(
        model="gpt-5.6-sol",
        input=request["prompt"],
        background=True,
    )

    # Figyelés háttérben
    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):
    """Figyel egy háttérben futó kérést, és webhookon értesít."""
    result = wait_for_response(response_id)

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

A megfelelő mód kiválasztása

A döntési szabály két kérdésre vezethető vissza. Hány kérésről van szó? És vár-e a felhasználó? Száz kérés felett, ahol nincs szükség azonnaliságra, a Batch API nyer az áron: az eredmények órák alatt készülnek el, féláron. Ha valaki a képernyő előtt vár, a szinkron hívások maradnak az egyetlen elfogadható választás szabványos áron. A háttérmód tölti ki a maradék teret: kevés kérés, perces eredményidő, szabványos ár. Érdemes ezt a logikát egyszer kódolni, ahelyett, hogy minden új szolgáltatásnál újra átvennéd.

def choose_mode(
    num_requests: int,
    urgency: str,
    budget: str,
) -> str:
    """Ajánlást tesz a optimális végrehajtási módra."""
    if num_requests > 100 and urgency != "immediate":
        return "batch"
    elif urgency == "immediate":
        return "synchronous"
    else:
        return "background"

Végül tervezz vészkijáratot is. Egy olyan háttérben futó kérés, amely messze meghaladja a várt időtartamot, leköti a költségkeretet és késlelteti a többi folyamatot; az API lehetővé teszi ezek explicit megszakítását. Ezt a felső határt a gyakorlatban megfigyelt időtartam kétszeresénél állítsd be, ne az átlagnál, különben kockáztatod, hogy olyan kéréseket szakítasz meg, amelyek éppen sikerrel jártak volna.

def cancel_if_too_long(response_id: str, timeout: int = 120):
    """Megszakít egy kérést, ha túllépi az időkorlátot."""
    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)

    # Időtúllépés — megszakítás
    client.responses.cancel(response_id)
    raise TimeoutError(
        f"A(z) {response_id} azonosítójú kérés megszakítva {timeout}s után."
    )

Főbb megállapítások

  • A háttérmód nyitott kapcsolat fenntartása nélkül indít kéréseket
  • Ideális magas szintű következtetési beállításokhoz (GPT-5.6 Sol) és hosszú feladatokhoz
  • Kombináld webhookkal az eseményvezérelt architektúrákhoz
  • Mentsd el a válasz azonosítóját: ez az egyetlen kapocs a folyamatban lévő munkához
  • Alacsony költségű tömeges feldolgozáshoz részesítsd előnyben a Batch API-t