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

Responses API vs Chat Completions: Miért érdemes migrálni

2. lecke 22 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Responses API vs Chat Completions
  2. Alapvető változások
  3. Szerveroldali munkamenet-kezelés
  4. Garantált JSON, nem csak reménykedés
  5. Függvényhívás és streamelés
  6. Gyors migrációs útmutató
  7. Azonnal migrálj?
  8. Főbb megállapítások

Responses API vs Chat Completions

A Chat Completions API évekig az ipari szabványnak számított, és az interneten található kódok nagy része még mindig ezt használja. 2025 óta azonban az OpenAI elavultnak (legacy) minősítette, és minden új projekthez a Responses API-t javasolja. Ez a lecke összehasonlítja a két felületet, kiemelve azokat a különbségeket, amelyek ténylegesen hatással vannak a kódodra.

Alapvető változások

A Chat Completions esetén üzenetek listáját építetted fel, és minden híváskor elküldted a teljes listát. A beszélgetés állapota az alkalmazásodban élt, soha nem a szerveren:

from openai import OpenAI
client = OpenAI()

# Régi modell — Chat Completions (elavult)
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)
# Eredmény: "The capital of France is Paris."

A Responses API ezt a hívást két paraméterre egyszerűsíti, és közvetlen hozzáférést biztosít a generált szöveghez. A rendszerüzenet az instructions paraméterré válik, és a tartalom kinyeréséhez többé nem kell végigmenned a choices[0].message.content útvonalon:

from openai import OpenAI
client = OpenAI()

# Új modell — Responses API
response = client.responses.create(
    model="gpt-5.6-terra",
    input="What is the capital of France?"
)
print(response.output_text)
# Eredmény: "The capital of France is Paris."

Szerveroldali munkamenet-kezelés

Ez nyújtja a legazonnalibb előnyt. Az API tartja karban a beszélgetés állapotát, így neked csak az előző válasz ID-jára kell hivatkoznod. Képzelj el egy ügyfélszolgálati asszisztenst: a tizedik körnél a Chat Completions megközelítés arra kényszerített, hogy újra elküldd az előző kilenc váltást, ami azt jelentette, hogy újra fizettél ezekért a tokenekért. Itt egyetlen mező elegendő:

# Első kérdés
response = client.responses.create(
    model="gpt-5.6-terra",
    input="My name is Marie."
)

# Második kérdés — a kontextus automatikusan megmarad
followup = client.responses.create(
    model="gpt-5.6-terra",
    input="What is my name?",
    previous_response_id=response.id
)
print(followup.output_text)
# Eredmény: "Your name is Marie."

Garantált JSON, nem csak reménykedés

A második nagy fejlesztés a strukturált kimenetet érinti. Leírod a várt formátumot, és a Responses API garantálja, hogy a válasz megfelel a JSON sémádnak – így biztonsági hálók nélkül végezheted el a deszerializálást. Egy regisztrációs űrlap, amely szabad szövegből nyer ki adatokat, többé nem omlik össze csak azért, mert a modell úgy dönt, hogy bevezető mondatot fűz a JSON elé:

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)
# Eredmény: {"name": "Paris", "country": "France", "population": 2161000}

Függvényhívás és streamelés

Az eszközök deklarációja ugyanazt az egyszerűsítési logikát követi: a függvény leírását laposan deklarálod a tools paraméterben, és a modell által kért hívás közvetlenül a response.output elemben jelenik meg, extra beágyazási szintek nélkül.

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"]
        }
    }]
)

# Az API közvetlenül visszaadja a végrehajtandó függvényhívást
for item in response.output:
    if item.type == "function_call":
        print(f"Function: {item.name}, Arguments: {item.arguments}")
# Eredmény: Function: get_meteo, Arguments: {"city": "Lyon"}

A streamelés többé nem differenciálatlan darabok (chunkok) folyamát adja vissza, hanem típusos eseményeket. Az event.type alapján szűrhetsz, és pontosan tudod, mivel van dolgod – egy szövegrészlettel, egy függvényargumentummal vagy a generálás végével:

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)

Gyors migrációs útmutató

Chat CompletionsResponses API
client.chat.completions.create()client.responses.create()
messages=[...]input="..." vagy input=[...]
response.choices[0].message.contentresponse.output_text
Kézi előzménykezelésprevious_response_id
response_formattext={"format": {...}}
tools + tool_choicetools (egyszerűsítve)

Azonnal migrálj?

A Chat Completions API továbbra is működőképes, és nem tervezik a megszüntetését. Az existing kód, amely fut, nem igényel módosítást, és egy régi formátumra épülő tesztelési folyamatra támaszkodik, nem nyer semmit az azonnali átírással. Hasonlóképpen, ha olyan harmadik féltől származó könyvtárra támaszkodsz, amely még nem támogatja a Responses API-t, várj a frissítésre. Ugyanakkor bármely új projekt esetén a válasz egyértelmű: a Responses API a kiindulópont, és a tanfolyam hátralévő része is ebből a feltételezésből indul ki.

Főbb megállapítások

  • A Responses API egy egyszerűbb felülettel váltja fel a Chat Completionst
  • A szerveroldali munkamenet-kezelés megszünteti az előzmények újraküldésének szükségességét
  • A strukturált kimenet és a függvényhívás natívan integrált
  • A migráció egyszerű: a koncepciók ugyanazok maradnak, csak a szintaxis változik