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

Fokozatos átállás a Responses API-ra

12. lecke 12 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Miért és mikor érdemes átállni
  2. 1. lépés: Azonosítsd a használt funkciókat
  3. 2. lépés: Alapvető hívások migrálása
  4. 3. lépés: Több körös beszélgetések migrálása
  5. 4. lépés: Használd ki az új funkciókat
  6. Ajánlott migrációs stratégia
  7. Főbb megállapítások
  8. Teszteld a tudásod

Frissítve: 2026. november 3.: A paraméterleképezés korábban azt jelezte, hogy a max_tokens neve változatlan marad a Responses API-ban; az xAI táblázata azonban max_output_tokens-ra módosítja, és a használati számlálók nevei is megváltoznak. Forrás: Összehasonlítás a Chat Completions-szel.

Miért és mikor érdemes átállni

A Chat Completions végpontot elavultnak (legacy) minősítették. Továbbra is működni fog, de új funkciókat már nem adnak hozzá. Ha az alkalmazásodnak szüksége van szerveroldali eszközökre (webes keresés, kódvégrehajtás), beszélgetés-tárolásra vagy titkosított következtetésre (encrypted reasoning), akkor szükségessé válik az átállás a Responses API-ra.

A jó hír: ez az átállás megtörténhet fokozatosan. Nem kell mindent egyszerre átírnod.

1. lépés: Azonosítsd a használt funkciókat

Mielőtt átállnál, vedd számba, hogy az alkalmazásod milyen elemeket használ a Chat Completions segítségével:

# Auditáld a meglévő kódodat
# Keresd ezeket a mintázatokat:

# 1. Alapvető hívások (egyszerű szöveg)
client.chat.completions.create(model=..., messages=...)

# 2. Streamelés
client.chat.completions.create(..., stream=True)

# 3. Függvényhívás
client.chat.completions.create(..., tools=[...])

# 4. Vízió (képek)
# üzenetek tartalommal tömbként [text, image_url]

# 5. Generálási paraméterek
# temperature, max_tokens, top_p, stop, seed

Az alapvető hívások és a streamelés a legegyszerűbben migrálhatók. A függvényhívás formátumának igazítását igényli. A vízió hasonlóan működik.

2. lépés: Alapvető hívások migrálása

Egy egyszerű hívás migrálása ezt a mintázatot követi:

# ELŐTTE — Chat Completions
response = client.chat.completions.create(
    model="grok-4.20-0309-reasoning",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello!"}
    ]
)
texte = response.choices[0].message.content

# UTÁNA — Responses API
response = client.responses.create(
    model="grok-4.20-0309-reasoning",
    instructions="You are a helpful assistant.",
    input="Hello!"
)
texte = response.output_text

Mezők leképezése

A főbb változások a következők:

  • messages a system szereppel → instructions (dedikált paraméter)
  • messages a user szereppel → input (egyszerű karakterlánc)
  • response.choices[0].message.content → response.output_text
  • max_tokens → max_output_tokens az xAI leképezési táblázata szerint; a temperature neve változatlan marad
  • response.usage.prompt_tokens és completion_tokens → input_tokens és output_tokens (részletek: input_tokens_details.cached_tokens, output_tokens_details.reasoning_tokens)

3. lépés: Több körös beszélgetések migrálása

Itt egyszerűsíti le a dolgokat a Responses API. Ahelyett, hogy minden kéréssel újjáépítenéd az előzményeket, ID alapján láncolod őket:

# ELŐTTE — Chat Completions (kezeld magad az előzményeket)
historique = [
    {"role": "system", "content": "You are a helpful assistant."}
]

def envoyer_message(texte: str) -> str:
    historique.append({"role": "user", "content": texte})
    response = client.chat.completions.create(
        model="grok-4.20-0309-reasoning",
        messages=historique
    )
    reponse = response.choices[0].message.content
    historique.append({"role": "assistant", "content": reponse})
    return reponse

# UTÁNA — Responses API (a szerver kezeli az előzményeket)
dernier_id = None

def envoyer_message(texte: str) -> str:
    response = client.responses.create(
        model="grok-4.20-0309-reasoning",
        instructions="You are a helpful assistant.",
        input=texte,
        previous_response_id=dernier_id
    )
    dernier_id = response.id
    return response.output_text

A kód egyszerűbb, és többé nem kell manuálisan kezelned az üzenetek tömbjét.

4. lépés: Használd ki az új funkciókat

Miután átálltál, kiaknázhatod a kizárólag a Responses API-ban elérhető funkciókat:

Beépített webes keresés

response = client.responses.create(
    model="grok-4.20-0309-reasoning",
    input="What are the latest developments in generative AI?",
    tools=[{"type": "web_search"}]
)
# A válasz hivatkozásokat tartalmaz forrás URL-ekkel

Válaszok tárolása

response = client.responses.create(
    model="grok-4.20-0309-reasoning",
    input="Analyze this document...",
    store=True  # 30 napig megőrzi
)

# Lekérés később
stored = client.responses.retrieve(response.id)

Titkosított következtetés

response = client.responses.create(
    model="grok-4.20-0309-reasoning",
    input="Solve this complex problem...",
    include=["reasoning.encrypted_content"]
)
# A titkosított következtetés újra felhasználható a későbbi kérésekben

Ajánlott migrációs stratégia

Ahelyett, hogy mindent egyszerre migrálnál, lépj fel szakaszosan:

  1. Azonosítsd a Chat Completions hívásokat a kódodban
  2. Osztályozd őket bonyolultság szerint (alapvető → streamelés → függvényhívás)
  3. Először migráld az új végpontokat vagy funkciókat (greenfield)
  4. Ezután migráld a legegyszerűbb meglévő hívásokat
  5. Tartsd meg a Chat Completions-t olyan harmadik féltől származó integrációkhoz, amelyek megkövetelik azt (LangChain stb.)

Ideiglenes együttélés

Teljesen elfogadható, hogy az átmenet során mindkét végpontot párhuzamosan futtasd:

# Wrapper, amely elvonatkoztat a használt végponttól
class GrokClient:
    def __init__(self, use_responses: bool = False):
        self.use_responses = use_responses
        self.client = OpenAI(
            api_key=os.getenv("XAI_API_KEY"),
            base_url="https://api.x.ai/v1"
        )

    def generate(self, system: str, user_message: str) -> str:
        if self.use_responses:
            response = self.client.responses.create(
                model="grok-4.20-0309-reasoning",
                instructions=system,
                input=user_message
            )
            return response.output_text
        else:
            response = self.client.chat.completions.create(
                model="grok-4.20-0309-reasoning",
                messages=[
                    {"role": "system", "content": system},
                    {"role": "user", "content": user_message}
                ]
            )
            return response.choices[0].message.content

Ez a megközelítés lehetővé teszi, hogy fokozatosan válts, minden egyes migrációt külön-külön tesztelve.

Főbb megállapítások

  • A migráció lehet fokozatos: nem kell mindent egyszerre átírnod
  • Fő változások: messages → input/instructions, choices[0].message.content → output_text
  • A több körös beszélgetések az üzenetek tömbjéről egy egyszerű previous_response_id-ra váltanak
  • A Responses API hozzáférést biztosít a kizárólagos funkciókhoz (web_search, tárolás, titkosított következtetés)
  • Az átmenet során futtasd mindkét végpontot párhuzamosan, és bonyolultság szerint migrálj

Teszteld a tudásod

Az elavult API megértve – és a migráció előkészítve.

1. Mit jelent a Chat Completions elavult és állapot nélküli státusza?

Válasz: A végpont továbbra is támogatott, de már nem fejlődik: állapot nélküli, így minden hívással újra el kell küldeni a teljes előzményt – a Responses API a modern út.

2. Mely szerepek strukturálják az üzeneteket?

Válasz: system (és developer), user, assistant – a keretrendszer, a kérések, a válaszok: a teljes előzmény minden kéréssel újraindul.

3. Hogyan használhatod a meglévő OpenAI kódot Grok-kal?

Válasz: A base_url megváltoztatásával erre: https://api.x.ai/v1, valamint az API-kulcs cseréjével – a formátum-kompatibilitás intézi a többit, beleértve az OpenAI SDK-t és a Vercel AI SDK-t is.

4. Mit olvasol ki a válaszból és a használati adatokból?

Válasz: A choices tartalmazza a válaszokat a finish_reason-nel; a usage részletezi a tokeneket, beleértve a reasoning_tokens-t a következtető modelleknél – ez a költségnyomon követés alapja.

5. Hogyan migrálhatsz tisztán a Responses API-ra?

Válasz: Fokozatosan: az új fejlesztések a Responses API-ban, a meglévő végpontok egyesével konvertálva, a promptok újratesztelésével – a két formátum összehasonlítása vezérli az átalakítást.

Értsd meg az elavultat, építs a modernre: a tanfolyam fokozatos migrációs terve a te útiterved – nagy durranás nélkül.