Tryb asynchroniczny (background)
Na tej stronie
Trzecia ścieżka między wywołaniem synchronicznym a wsadowym
Tryb asynchroniczny (background) interfejsu API Responses wypełnia konkretną niszę w Twoim zestawie narzędzi. Wywołanie synchroniczne daje natychmiastową odpowiedź, ale zmusza do utrzymywania otwartego połączenia przez cały czas generowania. Interfejs API Batch przetwarza tysiące żądań za połowę ceny, ale wyniki pojawiają się po kilku godzinach. Tryb asynchroniczny znajduje się pomiędzy nimi: obsługuje pojedyncze żądania według standardowej stawki, ale bez konieczności utrzymywania otwartego połączenia. Wysyłasz żądanie, otrzymujesz identyfikator i pobierasz wynik, gdy będzie gotowy.
Kompromis ten celuje w precyzyjny przypadek użycia: pojedyncze żądanie, które trwa zbyt długo dla wywołania blokującego, ale nie może czekać do jutra. Jest to dokładnie scenariusz występujący podczas uruchamiania modelu o wysokich zdolnościach rozumowania na złożonym dokumencie.
Uruchamianie i pobieranie wyników
Aktywacja wymaga tylko jednego parametru. Natychmiastowa odpowiedź nie zawiera tekstu; zwraca identyfikator i status, zazwyczaj queued (w kolejce) lub in_progress (w toku).
import openai
client = openai.OpenAI()
# Uruchomienie żądania w trybie asynchronicznym
response = client.responses.create(
model="gpt-5.6-sol", # Idealny do wolnych zadań (wysokie rozumowanie)
input="Przeanalizuj gospodarcze konsekwencje europejskich regulacji dotyczących AI "
"dla francuskich MŚP. Zaproponuj 10-punktowy plan działania.",
background=True, # Tryb asynchroniczny
)
print(f"ID odpowiedzi: {response.id}")
print(f"Status: {response.status}") # "queued" lub "in_progress"
Ten identyfikator to Twoje jedyne połączenie z trwającym zadaniem: zapisz go trwale, zanim zrobisz cokolwiek innego. Utrata oznacza opłacenie generowania, którego nigdy nie odzyskasz. Pobieranie polega następnie na odpytywaniu API, aż status stanie się końcowy, obsługując osobno błędy i anulowania, ponieważ mają one różne konsekwencje biznesowe.
import time
def wait_for_response(response_id: str, interval: int = 5) -> str:
"""Oczekuje na zakończenie odpowiedzi w trybie asynchronicznym."""
while True:
response = client.responses.retrieve(response_id)
match response.status:
case "completed":
return response.output_text
case "failed":
raise RuntimeError(
f"Żądanie nie powiodło się: {response.error}"
)
case "cancelled":
raise RuntimeError("Żądanie zostało anulowane.")
case _:
print(f"Status: {response.status}...")
time.sleep(interval)
Długie zadania wymagające rozumowania
Model taki jak GPT-5.6 Sol z włączonym wysokim poziomem rozumowania może potrzebować od 30 sekund do dwóch minut, zanim wygeneruje pierwszy widoczny token. W wywołaniu synchronicznym czasy te uderzają w domyślne limity czasu klientów HTTP, serwerów proxy i bramek. Tryb asynchroniczny eliminuje ten problem u źródła i przy okazji pozwala uruchomić kilka ciężkich analiz bez blokowania tylu połączeń.
async def deep_analysis(document: str) -> str:
"""Uruchamia analizę za pomocą GPT-5.6 Sol bez blokowania."""
response = client.responses.create(
model="gpt-5.6-sol",
input=f"Przeprowadź dokładną analizę prawną tej umowy. "
f"Zidentyfikuj wszystkie potencjalne ryzyka, problematyczne klauzule "
f"i zaproponuj modyfikacje.\n\n{document}",
background=True,
)
return response.id
# Uruchomienie wielu analiz równolegle
task_ids = []
for doc in documents:
task_id = await deep_analysis(doc)
task_ids.append(task_id)
# Pobranie wyników później
results = {}
for task_id in task_ids:
results[task_id] = wait_for_response(task_id)
Wzorzec ten naturalnie rozszerza się na webhooki, gdy wywołującym jest inna usługa. Twój punkt końcowy uruchamia żądanie, zwraca identyfikator i deleguje zadanie w tle do monitorowania zakończenia oraz wysyłania powiadomień. Wywołujący nie odpytuje systemu; otrzymuje powiadomienie.
from fastapi import FastAPI, BackgroundTasks
import httpx
app = FastAPI()
@app.post("/api/long-analysis")
async def launch_analysis(request: dict, background_tasks: BackgroundTasks):
"""Uruchamia analizę i powiadamia przez webhook po zakończeniu."""
response = client.responses.create(
model="gpt-5.6-sol",
input=request["prompt"],
background=True,
)
# Monitorowanie w tle
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):
"""Monitoruje żądanie w tle i powiadamia przez 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,
})
Wybór odpowiedniego trybu
Zasada decyzji sprowadza się do dwóch pytań. Ile jest żądań? I czy użytkownik czeka? Przy ponad stu żądaniach bez wymogu natychmiastowości, Interfejs API Batch wygrywa ceną: wyniki w ciągu kilku godzin za połowę kosztu. Jeśli ktoś czeka przed ekranem, wywołania synchroniczne pozostają jedynym akceptowalnym wyborem według standardowej stawki. Tryb asynchroniczny wypełnia resztę przestrzeni: mało żądań, wyniki w minutach, standardowa cena. Warto zakodować tę logikę raz, zamiast przerabiać ją dla każdej nowej usługi.
def choose_mode(
num_requests: int,
urgency: str,
budget: str,
) -> str:
"""Rekomenduje optymalny tryb wykonania."""
if num_requests > 100 and urgency != "immediate":
return "batch"
elif urgency == "immediate":
return "synchronous"
else:
return "background"
Na koniec zaplanuj awaryjne wyjście (escape hatch). Żądanie asynchroniczne, które znacznie przekracza oczekiwany czas, blokuje budżet i opóźnia resztę Twojego potoku; API pozwala je wyraźnie anulować. Ustaw ten limit na podwojony czas, który obserwujesz w praktyce, a nie średni, inaczej ryzykujesz anulowanie żądań, które były bliskie sukcesu.
def cancel_if_too_long(response_id: str, timeout: int = 120):
"""Anuluje żądanie, jeśli przekroczy limit czasu."""
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)
# Przekroczono limit czasu — anuluj
client.responses.cancel(response_id)
raise TimeoutError(
f"Żądanie {response_id} anulowane po {timeout}s."
)
Kluczowe wnioski
- Tryb asynchroniczny uruchamia żądania bez utrzymywania otwartego połączenia
- Idealny do ustawień wysokiego rozumowania (GPT-5.6 Sol) i długich zadań
- Połącz z webhookiem, aby uzyskać architekturę sterowaną zdarzeniami
- Trwale zapisz ID odpowiedzi: to Twoje jedyne połączenie z trwającym zadaniem
- Do taniego przetwarzania masowego preferuj Interfejs API Batch