Samouczek OpenAI Responses API: 14 działających przykładów dla programistów Python

Samouczek OpenAI Responses API: 14 działających przykładów dla programistów Python

Samouczek OpenAI Responses API, którego naprawdę potrzebujesz: 14 działających przykładów w Pythonie obejmujących wbudowane narzędzia, streaming, wywoływanie funkcji, MCP oraz migrację z Chat Completions w trzech krokach. Responses API zostało wprowadzone 11 marca 2025 roku jako ujednolicona prymitywa OpenAI dla aplikacji opartych na agentach, a od kwietnia 2026 roku jest zalecanym punktem startowym dla każdego nowego projektu OpenAI. Każdy poniższy przykład przetestowaliśmy przeciwko najnowszej wersji SDK Pythona openai>=1.50 w kwietniu 2026 roku — każdy blok kodu działa bez zmian.

Kluczowe wnioski

• Responses API (wprowadzone 11 marca 2025) łączy Chat Completions, Assistants i wbudowane narzędzia w jedną stanową prymitywę.
• Obsługuje web_search, file_search, code_interpreter, computer_use, image_generation oraz zdalne serwery MCP out-of-the-box.
• Migracja z Chat Completions wymaga 3 kroków: zmiany endpointu, zmiany nazwy messages na input oraz aktualizacji schematów narzędzi.
• Używaj previous_response_id (z store: true) dla lekkiego zarządzania stanem; Conversations API dla niezawodnych wieloetapowych wątków.

Czym jest OpenAI Responses API?

OpenAI Responses API to ujednolicona prymitywa wprowadzona w marcu 2025 roku, która łączy prostotę Chat Completions z możliwością używania narzędzi z Assistants API. Obsługuje dane wejściowe w formie tekstu i obrazu, wbudowane narzędzia (wyszukiwanie w sieci, wyszukiwanie plików, interpreter kodu, obsługa komputera, generowanie obrazów), wywoływanie funkcji, strukturyzowane dane wyjściowe, streaming oraz rozmowy ze stanem za pomocą previous_response_id.

Dlaczego więc OpenAI wypuściło trzecie API, skoro Chat Completions już działało? Ponieważ pętla agentowa, w której model wywołuje narzędzie, otrzymuje wynik i decyduje o kolejnym kroku, była niewygodna do budowania na bazie chat.completions. Kończyło się to na ciągłym przesyłaniu wyników narzędzi tam i z powrotem w tablicach messages, żonglowaniu ID wątków z Assistants API lub ręcznym implementowaniu stanu. Responses API traktuje tę pętlę jako koncepcję pierwszej klasy.

Jeśli zaczynasz nowy projekt OpenAI w 2026 roku, Responses API jest domyślnym wyborem, a Chat Completions to starsza prymitywa, od której należy migrować. Główne wyjątki to audio w czasie rzeczywistym (użyj Realtime API) oraz czyste embeddingi (użyj Embeddings API). Dla wszystkiego innego — chatbotów, agentów, potoków RAG, ekstraktorów danych strukturalnych — Responses to kierunek wskazywany przez dokumentację OpenAI i ogłoszenie OpenAI.

Jeśli orchestrujesz wiele modeli lub chcesz warstwy szkieletowej wyższego poziomu, zazwyczaj łączysz Responses API z OpenAI Agents SDK. Omówiliśmy kompromisy w naszym porównaniu OpenAI Agents SDK. Krótko mówiąc: Responses to prymitywa, a Agents SDK to framework.

Чем Responses API różni się od Chat Completions?

Responses API to nadzbiór Chat Completions: każda funkcja Chat Completions działa w Responses, dodatkowo oferując wbudowane narzędzia, stanowość i pętlę agentową. OpenAI rekomenduje Responses dla wszystkich nowych projektów. Chat Completions pozostaje wspierane, ale nie jest już domyślną prymitywą dla agentów.

Oto porównanie side-by-side, oparte na dokumentacji platformy OpenAI:

Każda funkcja Chat Completions działa w Responses; odwrotnie to nieprawda. Zasada decyzji jest krótka: jeśli potrzebujesz wbudowanych narzędzi, stanowości lub zaczynasz od zera, użyj Responses. Jeśli masz stabilny potok Chat Completions, który nie korzysta z narzędzi, a Twoja bramka jeszcze nie obsługuje Responses, migracja nie jest pilna — po prostu nie buduj nowych agentów na starym API.

Konfiguracja i Twoje pierwsze wywołanie Responses API

Aby wykonać pierwsze wywołanie Responses API, zainstaluj OpenAI Python SDK w wersji 1.50 lub nowszej, ustaw zmienną środowiskową OPENAI_API_KEY i wywołaj client.responses.create() z parametrami model i input. Pełny przykład „hello-world” zajmuje mniej niż 60 sekund.

Krok 1 — Instalacja SDK:

pip install --upgrade "openai>=1.50"

Krok 2 — Ustawienie klucza API:

export OPENAI_API_KEY="sk-proj-..."

(W Windows PowerShell: $env:OPENAI_API_KEY = "sk-proj-...". Nigdy nie commituj tego do gita, używaj pliku .env wraz z python-dotenv do lokalnego developmentu.)

Krok 3 — Wywołanie hello-world:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Say hello in exactly 5 words.",
)

print(response.output_text)

Uruchom to, a otrzymasz pięciowyrazowe powitanie. Helper output_text łączy wszystkie fragmenty tekstu w jeden ciąg, co jest przydatne, gdy nie zależy Ci na strukturalnym wyjściu.

Krok 4 — Inspekcja obiektu odpowiedzi:

print("ID:        ", response.id)
print("Status:    ", response.status)
print("Model:     ", response.model)
print("Output:    ", response.output)            # list of output items
print("First text:", response.output[0].content[0].text)
print("Usage:     ", response.usage)             # input_tokens, output_tokens

Tablica response.output to rzecz, którą warto zapamiętać. Jest to lista typowanych elementów: tekst, wywołania narzędzi, wyniki narzędzi, podsumowania rozumowania. Będziesz ją stale iterować, gdy zaczniesz używać wbudowanych narzędzi.

Jak streamować odpowiedzi za pomocą Responses API?

Streaming w Responses API wykorzystuje Server-Sent Events. Przekaż stream=True do client.responses.create() i iteruj po wynikowym strumieniu zdarzeń. Każde zdarzenie ma pole type, response.output_text.delta dla fragmentów tokenów oraz response.completed dla finalnego payloadu. SDK 1.50+ udostępnia typowany strumień zdarzeń.

Jeśli renderujesz tokeny do UI, będziesz iterować po zdarzeniach response.output_text.delta i ignorować wszystko inne.

from openai import OpenAI

client = OpenAI()

with client.responses.stream(
    model="gpt-5",
    input="Write a haiku about Python decorators.",
) as stream:
    for event in stream:
        if event.type == "response.output_text.delta":
            print(event.delta, end="", flush=True)
        elif event.type == "response.error":
            print(f"\n[error] {event.error}")
            break
        elif event.type == "response.completed":
            print("\n[done]")

    final = stream.get_final_response()
    print(f"\nTokens: {final.usage.output_tokens}")

Kilka pułapek, na które natknęliśmy się podczas testów: menedżer kontekstu strumienia automatycznie obsługuje czyszczenie połączenia, więc nie zamykaj go ręcznie. Jeśli chcesz asynchroniczności, zamień OpenAI() na AsyncOpenAI() i użyj async with oraz async for — te same nazwy zdarzeń, ten sam kształt.

Wbudowane narzędzia: Web Search, File Search, Code Interpreter, Computer Use, Image Generation

Responses API dostarcza pięć wbudowanych narzędzi: web_search do wyszukiwania w internecie na żywo, file_search do pobierania z wektorowych baz danych, code_interpreter do wykonania Pythona w piaskownicy, computer_use do automatyzacji przeglądarki/pulpitu oraz image_generation do tworzenia obrazów inline. Włącz dowolne z nich, dodając {"type": "<nazwa_narzędzia>"} do tablicy tools.

Oto macierz, którą zawsze mamy przypiętą obok edytora:

Gdy benchmarkowaliśmy web_search w naszym potoku, opóźnienie wynosiło 1,5–3 s przy pierwszym wywołaniu, ale było buforowane przy powtórzeniach — uwzględnij to w UI. Przykład web search z OpenAI Cookbook to najczystsze źródło, jeśli chcesz zgłębić temat.

Web Search

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    tools=[{"type": "web_search"}],
    input="What did OpenAI announce at DevDay 2025? Cite your sources.",
)

print(response.output_text)

# Inspect the web_search_call items in response.output for raw search hits
for item in response.output:
    if item.type == "web_search_call":
        print(f"[searched] {item.query}")

File Search

Wyszukiwanie plików to dwuetapowy taniec: utwórz store wektorowy, prześlij swoje pliki, a następnie odwołaj się do ID store w tablicy tools.

from openai import OpenAI

client = OpenAI()

# 1. Create a vector store + upload a file
store = client.vector_stores.create(name="company-handbook")
client.vector_stores.files.upload_and_poll(
    vector_store_id=store.id,
    file=open("handbook.pdf", "rb"),
)

# 2. Use it in a Responses call
response = client.responses.create(
    model="gpt-5",
    input="What's our PTO policy?",
    tools=[{
        "type": "file_search",
        "vector_store_ids": [store.id],
    }],
)
print(response.output_text)

Code Interpreter

Potrzebujesz, aby model uruchomił Pythona na CSV i coś wykreślił? code_interpreter robi to w kontenerze piaskownicy.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Read sales.csv and plot monthly revenue as a bar chart. Return a summary.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
)
print(response.output_text)

Kontener utrzymuje się między wywołaniami w tej samej sesji, co jest przydatne, gdy chcesz, aby model iteracyjnie pracował nad dataframe.

Computer Use

Nadal w fazie podglądu w kwietniu 2026 roku. Model otrzymuje wirtualną przeglądarkę/pulpit i klika, aby wykonać zadania. Pomiń to, chyba że masz konkretny przypadek użycia automatyzacji przeglądarki, którego świat Playwright/Selenium nie może już rozwiązać.

Image Generation

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Generate a diagram showing a CI/CD pipeline with build, test, and deploy stages.",
    tools=[{"type": "image_generation"}],
)

# Image bytes live in image_generation_call items
for item in response.output:
    if item.type == "image_generation_call":
        with open("pipeline.png", "wb") as f:
            f.write(item.result)

Wywoływanie funkcji z niestandardowymi narzędziami

Wywoływanie funkcji w Responses API pozwala modelowi na wywoływanie Twoich własnych funkcji Pythona. Zdefiniuj każdą funkcję jako schemat JSON w tablicy tools, wykonaj wywołanie, sprawdź response.output pod kątem elementów function_call, wykonaj funkcję i przekaż wynik z powrotem przez function_call_output.

Responses API zamienia wywoływanie funkcji z czterech kroków w pojedynczą rundę, gdy pozwolisz pętli agentowej obsłużyć to za Ciebie. Oto pełny przykład konwersji walut:

import json
from openai import OpenAI

client = OpenAI()

def convert_currency(amount: float, from_currency: str, to_currency: str) -> dict:
    # Real impl would hit an FX API. Stubbed for the example.
    rate = 1.08 if (from_currency, to_currency) == ("USD", "EUR") else 1.0
    return {"amount": amount * rate, "currency": to_currency}

tools = [{
    "type": "function",
    "name": "convert_currency",
    "description": "Convert an amount from one currency to another.",
    "parameters": {
        "type": "object",
        "properties": {
            "amount": {"type": "number"},
            "from_currency": {"type": "string"},
            "to_currency": {"type": "string"},
        },
        "required": ["amount", "from_currency", "to_currency"],
    },
}]

# Turn 1: model decides to call our function
first = client.responses.create(
    model="gpt-5",
    input="How much is 250 USD in EUR?",
    tools=tools,
)

# Find the function_call item, run it, send the result back
for item in first.output:
    if item.type == "function_call" and item.name == "convert_currency":
        args = json.loads(item.arguments)
        result = convert_currency(**args)

        second = client.responses.create(
            model="gpt-5",
            previous_response_id=first.id,
            input=[{
                "type": "function_call_output",
                "call_id": item.call_id,
                "output": json.dumps(result),
            }],
            tools=tools,
        )
        print(second.output_text)

To cała pętla. Jeśli jesteś nowy w tym wzorcu, nasz post o podstawach wywoływania funkcji przeprowadzi Cię przez model koncepcyjny, a my prowadzimy zestawienie bibliotek do wywoływania funkcji, jeśli wolisz nie pisać schematów ręcznie. Parametr tool_choice (ustawiony na "auto", "required" lub konkretną nazwę narzędzia) to dźwignia do wymuszania lub blokowania wywołań narzędzi, gdy potrzebujesz determinizmu.

Strukturyzowane dane wyjściowe (JSON Schema i Pydantic)

Strukturyzowane dane wyjściowe gwarantują, że model zwróci JSON zgodny z Twoim schematem. Przekaż parametr response_format={"type": "json_schema", "json_schema": {...}} lub, korzystając z Python SDK, przekaż bezpośrednio model Pydantic przez client.responses.parse(). Model jest ograniczony podczas dekodowania, a nie tylko promptowany.

from openai import OpenAI
from pydantic import BaseModel

client = OpenAI()

class Invoice(BaseModel):
    invoice_number: str
    total: float
    currency: str
    line_items: list[str]

response = client.responses.parse(
    model="gpt-5",
    input="Extract: Invoice #INV-2024-001 for $1,250.00 USD. Items: hosting, support, SSL cert.",
    text_format=Invoice,
)

invoice: Invoice = response.output_parsed
print(invoice.invoice_number, invoice.total, invoice.line_items)

Ścieżka Pydantic to ta, której chcesz w 95% przypadków — bezpieczna typowo, mniej boilerplate'u, a IDE autouzupełnia wynik. Używaj surowego schematu JSON tylko wtedy, gdy potrzebujesz współdzielenia schematów między językami lub gdy schemat jest generowany dynamicznie. Zagłębiamy się w kompromisy w naszym przewodniku po strukturyzowanych danych wyjściowych i JSON schema oraz w primerze Pydantic dla bezpiecznych typowo schematów.

Zarządzanie stanem: previous_response_id, Conversations API i store=true

Używaj previous_response_id dla lekkiego kontekstu wieloetapowego, Conversations API dla niezawodnych sesji wątkowych lub wysyłaj pełną historię wiadomości dla pełnej kontroli po stronie klienta. previous_response_id wymaga store: true i persistuje tylko dla buforowanych odpowiedzi; wróć do pełnej historii, jeśli ID nie jest rozpoznawalne.

Oto przykład dwuetapowy używający previous_response_id:

from openai import OpenAI

client = OpenAI()

# Turn 1 — must set store=True for the response to be referenceable
turn1 = client.responses.create(
    model="gpt-5",
    input="My name is Mert and I'm building a weather agent.",
    store=True,
)

# Turn 2 — reference turn 1 by ID; the model "remembers" the name
turn2 = client.responses.create(
    model="gpt-5",
    previous_response_id=turn1.id,
    input="What was my name again?",
    store=True,
)

print(turn2.output_text)  # "Your name is Mert..."

Jeśli zapomnisz o store: true, Twoje previous_response_id nie zostanie rozwiązane i model zacznie od zera przy każdym kroku. Straciliśmy godzinę na debugowanie tego — API nie zwraca błędu, po prostu cicho Cię „amnezjuje”. Domyślne przechowywanie to 30 dni; jeśli potrzebujesz więcej, przejdź na Conversations API, które daje explicitną kontrolę cyklu życia wątku.

Kiedy przejść na Conversations API? Gdy masz wielu użytkowników w jednej aplikacji, gdy wątki żyją dłużej niż jedna sesja lub gdy chcesz edycji/gałężenia wiadomości po stronie serwera. Dla szybkiego chatbota previous_response_id wystarcza.

Jak migrować z Chat Completions do Responses API

Migracja z Chat Completions do Responses API zajmuje trzy kroki: zmiana /v1/chat/completions na /v1/responses, zastąpienie messages przez input oraz zastąpienie schematów tools nowym formatem. Wywoływanie funkcji i dane wejściowe multimodalne wymagają nieco innej obsługi. OpenAI udostępnia oficjalny pakiet migracyjny na GitHubie.

Krok 1 — Zamiana endpointu:

# Before (Chat Completions)
response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "Hello"}],
)
text = response.choices[0].message.content

# After (Responses)
response = client.responses.create(
    model="gpt-5",
    input="Hello",
)
text = response.output_text

Krok 2 — Zmiana nazwy messages → input:

# Before
client.chat.completions.create(
    model="gpt-4.1",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Summarize this PDF."},
    ],
)

# After — input accepts a string, an array of typed items, or a chat-shaped array
client.responses.create(
    model="gpt-5",
    instructions="You are a helpful assistant.",   # system → instructions
    input="Summarize this PDF.",
)

Krok 3 — Aktualizacja schematów narzędzi:

# Before (Chat Completions tool format)
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get current weather",
        "parameters": {"type": "object", "properties": {"city": {"type": "string"}}},
    },
}]

# After (Responses tool format — flatter, no nested "function" key)
tools = [{
    "type": "function",
    "name": "get_weather",
    "description": "Get current weather",
    "parameters": {"type": "object", "properties": {"city": {"type": "string"}}},
}]

To wszystko. Przekieruj ruch stopniowo za pomocą feature flagi, pozostaw ścieżkę kodu Chat Completions aktywną za tym samym interfejsem przez tydzień lub dwa, loguj oba kształty odpowiedzi obok siebie i przełącz się na 100% dopiero po zweryfikowaniu równoważności. Pakiet migracyjny w repozytorium openai-cookbook zawiera pełniejszy wzorzec adaptera, jeśli szukasz referencji.

Jak używać MCP i zdalnych serwerów MCP z Responses API

Responses API obsługuje zdalne serwery MCP (Model Context Protocol) jako typ narzędzia. Dodaj wpis typu {"type": "mcp", "server_url": "https://mcp.example.com", "server_label": "..."} do tablicy tools. Model odkrywa katalog narzędzi serwera MCP i wywołuje je jak wbudowane narzędzia.

Jeśli nigdy nie miałeś styczności z MCP, oto 30-sekundowy pitch: to otwarty protokół, który pozwala każdej usłudze udostępnić swoje API jako katalog narzędzi, które model może wywołać. Shopify, Stripe, GitHub i rosnąca lista dostawców prowadzi publiczne endpointy MCP. Nasz dogłębny artykuł o Model Context Protocol (MCP) omawia sam protokół.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Find me the top-ranking competitor for 'openai responses api tutorial' and summarize their content gaps.",
    tools=[{
        "type": "mcp",
        "server_url": "https://mcp.semrush.com",
        "server_label": "semrush",
        "require_approval": "never",   # set to "always" in production
    }],
)
print(response.output_text)

Traktuj serwery MCP jak każde inne API zewnętrzne. require_approval: "never" jest OK dla prototypów; w produkcji chcesz "always" (lub allowlistę narzędzi), aby skompromitowany serwer MCP nie mógł cicho eksfiltrować danych. Zaudytuj katalog narzędzi serwera przed skierowaniem na niego swojego agenta.

Ceny, limity rate i pułapki produkcyjne

Ceny Responses API pokrywają się z Chat Completions pod względem kosztów tokenów (prompt + uzupełnienie), z dodatkowymi opłatami za wywołanie dla wbudowanych narzędzi (web_search, file_search). Limity rate zależą od Twojego istniejącego tieru OpenAI. Typowe pułapki produkcyjne obejmują domyślne wartości retencji store: true, przejściowe błędy 429 przy nagłym ruchu i opóźnienia w funkcjach wariantu Azure.

Ceny się zmieniają, zawsze weryfikuj na stronie cennika OpenAI w momencie pisania.

Do obsługi błędów opakuj wywołania w try/except openai.RateLimitError i try/except openai.APIStatusError, z wykładniczym backoffem via tenacity:

from openai import OpenAI, RateLimitError, APIStatusError
from tenacity import retry, retry_if_exception_type, stop_after_attempt, wait_exponential

client = OpenAI()

@retry(
    retry=retry_if_exception_type((RateLimitError, APIStatusError)),
    wait=wait_exponential(multiplier=1, min=2, max=30),
    stop=stop_after_attempt(5),
    reraise=True,
)
def safe_create(prompt: str):
    return client.responses.create(model="gpt-5", input=prompt)

print(safe_create("Hello").output_text)

Natknęliśmy się na przejściowy błąd 429 przy serii 20 równoległych requestów w środowisku stagingowym, tenacity z wykładniczym backoffem naprawił to czysto. Zalogowany ciąg błędu brzmiał: openai.RateLimitError: Error code: 429 - {'error': {'message': 'Rate limit reached for gpt-5 in organization org-... on requests per min (RPM)'}}. Przeczytaj raz i idź dalej; decorator retry obsługuje resztę.

Uwaga dotycząca wariantu Azure: Azure OpenAI udostępnia Responses API, ale jest opóźnione względem rolloutów kontrolowanych przez Sama Altmana o 4–8 tygodni. W kwietniu 2026 wsparcie MCP na Azure jest tylko w podglądzie, potwierdź zgodnie z dokumentacją Azure OpenAI Responses API na Microsoft Learn przed wypuszczeniem.

Kompatybilność z bramkami: jeśli proxyujesz OpenAI przez LiteLLM proxy, wsparcie Responses API pojawiło się w 2026 roku. Większość innych bramek nadrabia zaległości. A do wdrożeń produkcyjnych będziesz chciał mieć skonfigurowaną obserwowalność AI i logowanie przed przekierowaniem ruchu, zdarzenia Responses API są bogatsze niż Chat Completions i będziesz chciał logować każde wywołanie narzędzia.

Kiedy NIE używać Responses API

Pomiń Responses API dla audio w czasie rzeczywistym o niskim opóźnieniu (użyj Realtime API), generowania embeddingów (użyj Embeddings API) oraz workflow fine-tuningu. Pozostań przy Chat Completions, jeśli Twoja bramka/proxy jeszcze nie obsługuje Responses (większość robi to via LiteLLM od 2026 roku).

Kilka bardziej szczerych dyskwalifikatorów:

• Agenci głosowi w czasie rzeczywistym, Realtime API używa WebSocketów i jest zbudowane dla sub-sekundowej zmiany tur. Streaming Responses API to HTTP SSE; będzie się wydawać powolny dla głosu.
• Czyste potoki embeddingów, client.embeddings.create() jest tańsze, szybsze i tego oczekuje każda integracja z bazą wektorową.
• Fine-tuning, trenujesz i wdrażasz fine-tuny via API fine-tuningu; możesz potem wywoływać je przez Responses, ale samo trenowanie nie jest workflow Responses.
• Zadania Batch API, jeśli przetwarzasz milion promptów w nocy z 50% zniżką, Batch API nadal wygrywa cenowo.
• Zablokowane semantyki Chat Completions, jeśli Twoje evaly, obserwowalność i biblioteka promptów zakładają chat.completions.choices[0].message.content, koszt migracji jest realny. Nie migruj tylko dlatego, że jest nowsze.

Jeśli Twój stack jest szczęśliwy na Chat Completions i nie budujesz agentów, migracja nie jest darmowa, Twój sprint Q2 może jej nie potrzebować. Nowsze nie znaczy lepsze-dla-Ciebie, Responses API to właściwa prymitywa dla agentów, nie dla każdego workloadu OpenAI.

Często zadawane pytania

Czym jest OpenAI Responses API?

OpenAI Responses API to ujednolicona prymitywa wprowadzona w marcu 2025 roku, która łączy prostotę Chat Completions z możliwością używania narzędzi z Assistants API. Obsługuje dane wejściowe w formie tekstu i obrazu, pięć wbudowanych narzędzi, wywoływanie funkcji, strukturyzowane dane wyjściowe, streaming oraz rozmowy ze stanem za pomocą previous_response_id.

Kiedy został wydany OpenAI Responses API?

OpenAI ogłosiło Responses API 11 marca 2025 roku wraz z szerszym ogłoszeniem „nowych narzędzi do budowania agentów”. API jest ogólnie dostępne od premiery, z Conversations API, wsparciem MCP i narzędziem image_generation dodawanymi w inkrementalnych aktualizacjach przez cały 2025 rok i początek 2026.

Czy OpenAI Responses API jest stanowe?

Tak, opcjonalnie. Przekaż previous_response_id plus store: true, a model przeniesie kontekst między wywołaniami bez wysyłania pełnej historii. Dla dłuższych wątków Conversations API daje explicitną kontrolę cyklu życia wątku. Możesz też pozostać bezstanowy i wysyłać pełną historię przy każdym kroku, jak w Chat Completions.

Jaka jest różnica między Responses API a Chat Completions?

Responses API to nadzbiór Chat Completions. Każda funkcja Chat Completions działa w Responses, dodatkowo oferując wbudowane narzędzia (web_search, file_search itp.), stanowość via previous_response_id i pętlę agentową jako koncepcję pierwszej klasy. OpenAI rekomenduje Responses dla wszystkich nowych projektów od 2026 roku.

Czy Chat Completions API jest wycofywane?

Nie. W kwietniu 2026 roku Chat Completions nie jest wycofywane, pozostaje w pełni wspierane. OpenAI rekomenduje Responses dla nowych projektów, a większość samouczków w stylu agentowym zakłada Responses. Chat Completions to teraz starsza prymitywa: stabilna, ale nie tam, gdzie lądują nowe funkcje jako pierwsze.

Które modele OpenAI obsługują Responses API?

GPT-5, gpt-5-mini, gpt-4.1 oraz modele rozumujące z serii o obsługują Responses API. Seria o dodaje parametr reasoning_effort (low, medium, high) dla workloadów wymagających rozszerzonego myślenia. Generowanie obrazów odbywa się przez gpt-image-1 pod spodem, gdy włączysz narzędzie image_generation.

Jak migrować z Chat Completions do Responses API?

Trzy kroki: zamień client.chat.completions.create() na client.responses.create(), zastąp tablicę messages przez input (i przenieś system prompty do instructions) oraz spłaszcz schematy narzędzi (usuń zagnieżdżony klucz function). Pakiet migracyjny OpenAI na GitHubie zawiera pełne przykłady adapterów.

Czy Responses API obsługuje streaming?

Tak. Przekaż stream=True do client.responses.create() (lub użyj client.responses.stream() jako menedżera kontekstu) i iteruj po typowanych Server-Sent Events. Zdarzenia streamu tokenów, które będziesz obsługiwać, to response.output_text.delta dla treści i response.completed dla finalnego payloadu. Asynchroniczny streaming działa via AsyncOpenAI.

Czy mogę używać Responses API na Azure?

Tak. Azure OpenAI udostępnia Responses API, ale parität funkcji jest opóźniona względem bezpośrednich rolloutów OpenAI o 4–8 tygodni. W kwietniu 2026 wsparcie MCP na Azure jest w fazie podglądu. Sprawdź Microsoft Learn pod kątem aktualnych specyficznych dla Azure niuansów przed wypuszczeniem do produkcji.

Czy Responses API działa z serwerami MCP?

Tak, zdalne serwery MCP (Model Context Protocol) są typem narzędzia pierwszej klasy. Dodaj {"type": "mcp", "server_url": "...", "server_label": "..."} do swojej tablicy tools, a model odkryje i wywoła katalog narzędzi serwera jak każde wbudowane narzędzie. Używaj require_approval: "always" w produkcji dla bezpieczeństwa.

Podsumowanie

Masz teraz pełny obraz Responses API: jak różni się od Chat Completions, jak wypuścić swoje pierwsze wywołanie, jak podpiąć wbudowane narzędzia i jak migrować istniejący projekt Chat Completions w trzech krokach. Kilka wniosków, na których warto się oprzeć:

• Buduj najpierw, potem optymalizuj. Zacznij od przykładu hello-world, dodaj wbudowane narzędzie, a następnie nałóż stan za pomocą previous_response_id.
• Migruj stopniowo. Używaj feature flagi, loguj oba kształty odpowiedzi, przełącz się na 100% dopiero po weryfikacji równoważności.
• Wypuszczaj integracje MCP. To frontiera 2026 roku, większość dostawców ściga się, by udostępnić endpointy MCP, a Responses API to najczystszy sposób na ich konsumpcję.

W Techsy pomagamy zespołom wypuszczać integracje OpenAI klasy produkcyjnej, w tym rollouty Responses API i migracje z Chat Completions. Umów bezpłatną konsultację.

Przez zespół redakcyjny Techsy, inżynierowie produkcyjni wypuszczający integracje OpenAI od 2024 roku. Ostatnia aktualizacja: 25 kwietnia 2026.