Responses API vs Chat Completions: Dlaczego warto migrować
Na tej stronie
Responses API vs Chat Completions
Przez lata API Chat Completions stanowiło standard, a większość kodu dostępnego w sieci nadal z niego korzysta. Jednak od 2025 roku OpenAI oznaczyło je jako przestarzałe (legacy) i rekomenduje używanie Responses API we wszystkich nowych projektach. Ta lekcja porównuje oba interfejsy, skupiając się na różnicach, które realnie wpływają na Twój kod.
Fundamentalne zmiany
W przypadku Chat Completions budowałeś listę wiadomości i wysyłałeś ją w całości przy każdym wywołaniu. Stan konwersacji przechowywany był w Twojej aplikacji, nigdy na serwerze:
from openai import OpenAI
client = OpenAI()
# Stary model — Chat Completions (przestarzały)
response = client.chat.completions.create(
model="gpt-5.6-terra",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "What is the capital of France?"},
]
)
print(response.choices[0].message.content)
# Wynik: "The capital of France is Paris."
Responses API redukuje to samo wywołanie do dwóch parametrów i zapewnia bezpośredni dostęp do wygenerowanego tekstu. Wiadomość systemowa staje się parametrem instructions, a ekstrakcja treści nie wymaga już żmudnego przechodzenia przez choices[0].message.content:
from openai import OpenAI
client = OpenAI()
# Nowy model — Responses API
response = client.responses.create(
model="gpt-5.6-terra",
input="What is the capital of France?"
)
print(response.output_text)
# Wynik: "The capital of France is Paris."
Zarządzanie sesją po stronie serwera
To przynosi najbardziej natychmiastowe korzyści. API utrzymuje stan konwersacji, więc wystarczy, że odwołasz się do poprzedniej odpowiedzi za pomocą jej identyfikatora. Wyobraź sobie asystenta wsparcia: przy dziesiątym obrocie rozmowy podejście Chat Completions zmuszało Cię do ponownego wysłania poprzednich dziewięciu wymian, co oznaczało, że płaciłeś za te tokeny jeszcze raz. Tutaj wystarczy jedno pole:
# Pierwsze pytanie
response = client.responses.create(
model="gpt-5.6-terra",
input="My name is Marie."
)
# Drugie pytanie — kontekst jest zachowywany automatycznie
followup = client.responses.create(
model="gpt-5.6-terra",
input="What is my name?",
previous_response_id=response.id
)
print(followup.output_text)
# Wynik: "Your name is Marie."
Gwarantowany JSON, a nie „JSON z nadzieją“
Druga kluczowa poprawka dotyczy wyjścia strukturalnego. Opisujesz oczekiwany format, a Responses API gwarantuje, że odpowiedź będzie zgodna z Twoim schematem JSON – pozwala to na deserializację bez dodatkowych zabezpieczeń. Formularz rejestracyjny ekstrahujący dane z wolnego tekstu nie przestanie działać tylko dlatego, że model zdecyduje się dodać zdanie wstępne przed właściwym JSON-em:
from pydantic import BaseModel
class City(BaseModel):
name: str
country: str
population: int
response = client.responses.create(
model="gpt-5.6-terra",
input="Give me information about Paris.",
text={"format": {"type": "json_schema", "json_schema": {
"name": "city",
"strict": True,
"schema": City.model_json_schema()
}}}
)
print(response.output_text)
# Wynik: {"name": "Paris", "country": "France", "population": 2161000}
Wywoływanie funkcji i strumieniowanie
Deklaracja narzędzi podlega tej samej logice uproszczenia: deskryptor funkcji deklarowany jest płasko w tools, a wywołanie żądane przez model pojawia się bezpośrednio w response.output, bez dodatkowych poziomów zagnieżdżenia.
response = client.responses.create(
model="gpt-5.6-terra",
input="What is the weather like in Lyon?",
tools=[{
"type": "function",
"name": "get_meteo",
"description": "Get the weather for a city",
"parameters": {
"type": "object",
"properties": {
"city": {"type": "string", "description": "Name of the city"}
},
"required": ["city"]
}
}]
)
# API zwraca wywołanie funkcji do wykonania bezpośrednio
for item in response.output:
if item.type == "function_call":
print(f"Function: {item.name}, Arguments: {item.arguments}")
# Wynik: Function: get_meteo, Arguments: {"city": "Lyon"}
Strumieniowanie nie zwraca już potoku nieodróżnialnych fragmentów, lecz zdarzenia typowane. Filtrujesz po event.type i wiesz dokładnie, co przetwarzasz – fragment tekstu, argument funkcji czy koniec generowania:
stream = client.responses.create(
model="gpt-5.6-terra",
input="Tell a short story.",
stream=True
)
for event in stream:
if event.type == "response.output_text.delta":
print(event.delta, end="", flush=True)
Szybki przewodnik migracyjny
| Chat Completions | Responses API |
|---|---|
client.chat.completions.create() | client.responses.create() |
messages=[...] | input="..." lub input=[...] |
response.choices[0].message.content | response.output_text |
| Ręczna historia | previous_response_id |
response_format | text={"format": {...}} |
tools + tool_choice | tools (uproszczone) |
Czy migrować natychmiast?
API Chat Completions nadal działa i nie zostanie usunięte. Istniejący kod, który działa, nie wymaga zmian, a jeśli opierasz się na pipeline testowym zbudowanym wokół starego formatu, nic nie zyskasz na pilnym przepisaniu go. Podobnie, jeśli zależysz od biblioteki zewnętrznej, która jeszcze nie obsługuje Responses API, poczekaj na jej aktualizację. Jednak w przypadku każdego nowego projektu odpowiedź jest jasna: Responses API to punkt wyjścia i reszta tego kursu wychodzi z tego założenia.
Kluczowe wnioski
- Responses API zastępuje Chat Completions prostszym interfejsem
- Zarządzanie sesją po stronie serwera eliminuje konieczność ponownego wysyłania historii
- Wyjście strukturalne i wywoływanie funkcji są zintegrowane natywnie
- Migracja jest prosta: koncepcje pozostają te same, zmienia się tylko składnia