Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Gradvis migration til Responses API

Lektion 12 af 12 Opdateret 3. november 2026 Udvikler
På denne side
  1. Hvorfor og hvornår du skal migrere
  2. Trin 1: Identificér de funktioner, du bruger
  3. Trin 2: Migrér enkle kald
  4. Trin 3: Migrér samtaler med flere tur
  5. Trin 4: Udnyt nye funktioner
  6. Anbefalet migrationsstrategi
  7. Vigtige pointer
  8. Test din viden

Opdateret 3. november 2026: Parameter-mapping angav tidligere, at max_tokens beholdt sit navn i Responses API; xAI’s tabel ændrer det til max_output_tokens, og tællere for brug ændrer også navn. Kilde: Sammenligning med Chat Completions.

Hvorfor og hvornår du skal migrere

Chat Completions-endpointet er markeret som forældet (legacy). Det vil fortsætte med at fungere, men der vil ikke blive tilføjet nye funktioner til det. Hvis din applikation har brug for server-side værktøjer (websøgning, kodeeksekvering), lagring af samtaler eller krypteret ræsonnement, bliver en migration til Responses API nødvendig.

De gode nyheder: Denne migration kan ske gradvist. Du behøver ikke omskrive alt på én gang.

Trin 1: Identificér de funktioner, du bruger

Før du migrerer, skal du gøre status over, hvad din applikation bruger i forbindelse med Chat Completions:

# Audit your existing code
# Look for these patterns:

# 1. Basic calls (simple text)
client.chat.completions.create(model=..., messages=...)

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

# 3. Function calling
client.chat.completions.create(..., tools=[...])

# 4. Vision (images)
# messages with content as array [text, image_url]

# 5. Generation parameters
# temperature, max_tokens, top_p, stop, seed

Enkle kald og streaming er de nemmeste at migrere. Funktionskald kræver tilpasning af formatet. Vision fungerer på lignende vis.

Trin 2: Migrér enkle kald

Migration af et simpelt kald følger dette mønster:

# BEFORE — 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

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

Field mapping

De vigtigste ændringer er:

  • messages med rollen system → instructions (dedikeret parameter)
  • messages med rollen user → input (simpel streng)
  • response.choices[0].message.content → response.output_text
  • max_tokens → max_output_tokens, ifølge xAI’s mapping-tabel; temperature beholder sit navn
  • response.usage.prompt_tokens og completion_tokens → input_tokens og output_tokens (detaljer: input_tokens_details.cached_tokens, output_tokens_details.reasoning_tokens)

Trin 3: Migrér samtaler med flere tur

Her er det, Responses API forenkler tingene. I stedet for at genopbygge historikken ved hver anmodning, kæder du dem sammen via ID:

# BEFORE — Chat Completions (manage history yourself)
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

# AFTER — Responses API (server manages history)
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

Koden bliver enklere, og du behøver ikke længere administrere messages-arrayet manuelt.

Trin 4: Udnyt nye funktioner

Når du er migreret, kan du udnytte funktioner, der er eksklusive for Responses API:

Indbygget websøgning

response = client.responses.create(
    model="grok-4.20-0309-reasoning",
    input="What are the latest developments in generative AI?",
    tools=[{"type": "web_search"}]
)
# The response includes citations with source URLs

Lagring af svar

response = client.responses.create(
    model="grok-4.20-0309-reasoning",
    input="Analyze this document...",
    store=True  # Keeps for 30 days
)

# Retrieve later
stored = client.responses.retrieve(response.id)

Krypteret ræsonnement

response = client.responses.create(
    model="grok-4.20-0309-reasoning",
    input="Solve this complex problem...",
    include=["reasoning.encrypted_content"]
)
# The encrypted reasoning can be reused in subsequent requests

Anbefalet migrationsstrategi

I stedet for at migrere alt på én gang, bør du proceede i trin:

  1. Identificér Chat Completions-kald i din kode
  2. Klassificér dem efter kompleksitet (enkelt → streaming → funktionskald)
  3. Migrér først nye endpoints eller funktioner (greenfield)
  4. Migrér derefter de enkleste eksisterende kald
  5. Behold Chat Completions til tredjepartsintegrationer, der kræver det (LangChain osv.)

Midlertidig sameksistens

Det er helt acceptabelt at køre begge endpoints sideløbende under overgangen:

# Wrapper that abstracts the endpoint used
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

Denne tilgang giver dig mulighed for at skifte gradvist ved at teste hver migration individuelt.

Vigtige pointer

  • Migration kan være gradvis: Du behøver ikke omskrive alt på én gang
  • Vigtigste ændringer: messages → input/instructions, choices[0].message.content → output_text
  • Samtaler med flere tur flytter fra et messages-array til et simpelt previous_response_id
  • Responses API giver adgang til eksklusive funktioner (web_search, lagring, krypteret ræsonnement)
  • Kør begge endpoints sideløbende under overgangen, og migrér efter kompleksitet

Test din viden

Det forældede API er forstået – og migrationen er forberedt.

1. Hvad betyder det, at Chat Completions har status som forældet og stateless?

Svar: Endpointet understøttes stadig, men udvikles ikke længere: Da det er stateless, kræver det, at du sender hele historikken ved hvert kald – Responses API er den moderne vej frem.

2. Hvilke roller strukturerer messages?

Svar: system (og developer), user, assistant – rammen, forespørgslerne, svarene: Hele historikken genstartes ved hver anmodning.

3. Hvordan bruger du eksisterende OpenAI-kode med Grok?

Svar: Ved at ændre base_url til https://api.x.ai/v1 og API-nøglen – formatkompatibiliteten håndterer resten, herunder OpenAI SDK og Vercel AI SDK.

4. Hvad læser du i svaret og brugsdataene?

Svar: choices indeholder svar med finish_reason; usage detaljerer tokens, inklusive reasoning_tokens for ræsonnementsmodeller – grundlaget for omkostningssporing.

5. Hvordan migrerer du rent til Responses API?

Svar: Gradvist: Ny udvikling i Responses, eksisterende endpoints konverteres én efter én med genafprøvning af prompts – sammenligning af de to formater guider konverteringen.

Forstå det forældede, byg til det moderne: Kursets gradvise migrationsplan er dit kørekort – uden et „big bang”.