Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Postupná migrácia na Responses API

Lekcia 12 z 12 Aktualizované 3. novembra 2026 Vývojár
Na tejto strane
  1. Prečo a kedy migrovať
  2. Krok 1: Identifikuj funkcie, ktoré používaš
  3. Krok 2: Migruj základné volania
  4. Krok 3: Migruj viacnásobné konverzácie
  5. Krok 4: Využi nové funkcie
  6. Odporúčaná stratégia migrácie
  7. Kľúčové poznatky
  8. Otestuj si svoje vedomosti

Aktualizované 3. novembra 2026: Mapovanie parametrov predtým uvádzalo, že max_tokens si v Responses API zachováva svoj názov; tabuľka xAI ho však mení na max_output_tokens a menia sa aj názvy počítadiel využitia. Zdroj: Porovnanie s Chat Completions.

Prečo a kedy migrovať

Koncový bod Chat Completions je označený ako zastaraný (legacy). Bude síce naďalej fungovať, ale nebudú sa doň pridávať nové funkcie. Ak tvoja aplikácia potrebuje nástroje na strane servera (webové vyhľadávanie, vykonávanie kódu), ukladanie konverzácií alebo šifrované uvažovanie, migrácia na Responses API sa stáva nevyhnutnou.

Dobrou správou je, že táto migrácia môže prebehnúť postupne. Nemusíš prepisovať všetko naraz.

Krok 1: Identifikuj funkcie, ktoré používaš

Pred migráciou si urob prehľad toho, čo tvoja aplikácia využíva pri Chat Completions:

# Audituj svoj existujúci kód
# Hľadaj tieto vzory:

# 1. Základné volania (jednoduchý text)
client.chat.completions.create(model=..., messages=...)

# 2. Streamovanie
client.chat.completions.create(..., stream=True)

# 3. Volanie funkcií
client.chat.completions.create(..., tools=[...])

# 4. Vízia (obrázky)
# správy s obsahom ako pole [text, image_url]

# 5. Parametre generovania
# temperature, max_tokens, top_p, stop, seed

Základné volania a streamovanie sú najjednoduchšie na migráciu. Volanie funkcií si vyžaduje úpravu formátu. Vízia funguje podobne.

Krok 2: Migruj základné volania

Migrácia jednoduchého volania nasleduje tento vzor:

# PREDTÝM — 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

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

Mapovanie polí

Hlavné zmeny sú:

  • messages s rolou system → instructions (vyhradený parameter)
  • messages s rolou user → input (jednoduchý reťazec)
  • response.choices[0].message.content → response.output_text
  • max_tokens → max_output_tokens, podľa mapovacej tabuľky xAI; temperature si zachováva svoj názov
  • response.usage.prompt_tokens a completion_tokens → input_tokens a output_tokens (podrobnosti: input_tokens_details.cached_tokens, output_tokens_details.reasoning_tokens)

Krok 3: Migruj viacnásobné konverzácie

Tu Responses API veci zjednodušuje. Namiesto toho, aby si pri každej požiadavke reconštruoval históriu, spájaš ich pomocou ID:

# PREDTÝM — Chat Completions (spravuj históriu sám)
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

# POTOM — Responses API (históriu spravuje server)
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

Kód je jednoduchší a už nemusíš manuálne spravovať pole správ.

Krok 4: Využi nové funkcie

Po migrácii môžeš využiť funkcie exkluzívne dostupné v Responses API:

Vstavané webové vyhľadávanie

response = client.responses.create(
    model="grok-4.20-0309-reasoning",
    input="What are the latest developments in generative AI?",
    tools=[{"type": "web_search"}]
)
# Odpoveď obsahuje citácie so zdrojovými URL

Ukladanie odpovedí

response = client.responses.create(
    model="grok-4.20-0309-reasoning",
    input="Analyze this document...",
    store=True  # Uchováva sa 30 dní
)

# Neskoršie načítanie
stored = client.responses.retrieve(response.id)

Šifrované uvažovanie

response = client.responses.create(
    model="grok-4.20-0309-reasoning",
    input="Solve this complex problem...",
    include=["reasoning.encrypted_content"]
)
# Šifrované uvažovanie možno znovu použiť v nasledujúcich požiadavkách

Odporúčaná stratégia migrácie

Namiesto migrácie všetkého naraz postupuj krok za krokom:

  1. Identifikuj volania Chat Completions vo svojom kóde
  2. Klasifikuj ich podľa zložitosti (základné → streamovanie → volanie funkcií)
  3. Najprv migruj nové koncové body alebo funkcie (greenfield)
  4. Potom migruj najjednoduchšie existujúce volania
  5. Ponechaj Chat Completions pre integrácie tretích strán, ktoré si to vyžadujú (LangChain atď.)

Dočasná koexistencia

Počas prechodu je úplne prijateľné prevádzkovať oba koncové body vedľa seba:

# Wrapper, ktorý abstrahuje používaný koncový bod
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

Tento prístup ti umožňuje postupný prechod testovaním každej migrácie jednotlivo.

Kľúčové poznatky

  • Migrácia môže byť postupná: nie je potrebné prepisovať všetko naraz
  • Hlavné zmeny: messages → input/instructions, choices[0].message.content → output_text
  • Viacnásobné konverzácie prechádzajú z poľa správ na jednoduché previous_response_id
  • Responses API poskytuje prístup k exkluzívnym funkciám (web_search, ukladanie, šifrované uvažovanie)
  • Počas prechodu prevádzkuj oba koncové body vedľa seba a migruj podľa zložitosti

Otestuj si svoje vedomosti

Zastarané API pochopené – a migrácia pripravená.

1. Čo znamená status legacy a stateless pre Chat Completions?

Odpoveď: Koncový bod zostáva podporovaný, ale už sa nevyvíja: keďže je stateless, vyžaduje si opätovné odoslanie celej histórie pri každom volaní – Responses API je modernou cestou.

2. Ktoré roly štruktúrujú správy?

Odpoveď: system (a developer), user, assistant – rámec, požiadavky, odpovede: celá história sa pri každej požiadavke reštartuje.

3. Ako použiješ existujúci kód OpenAI s Grok?

Odpoveď: Zmenou base_url na https://api.x.ai/v1 a API kľúča – kompatibilita formátu vybaví zvyšok, vrátane OpenAI SDK a Vercel AI SDK.

4. Čo čítaš v odpovedi a využití?

Odpoveď: choices nesie odpovede s finish_reason; usage detailne uvádza tokeny, vrátane reasoning_tokens pre modely uvažovania – základ pre sledovanie nákladov.

5. Ako čistě migrovať na Responses API?

Odpoveď: Postupne: nový vývoj v Responses, existujúce koncové body konvertované jeden po druhom s opätovným testovaním promptov – porovnanie oboch formátov vedie konverziu.

Pochopte zastarané, budujte pre moderné: plán postupnej migrácie tohto kurzu je vaším sprievodcom – bez veľkého tresku.