Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Responses API vs. Chat Completions: Hvorfor migrere?

Lektion 2 af 22 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Responses API vs. Chat Completions
  2. Fundamentale ændringer
  3. Server-side sessionshåndtering
  4. Garanteret JSON, ikke håbefuldt JSON
  5. Funktionskald og streaming
  6. Hurtig migrationsguide
  7. Skal du migrere med det samme?
  8. Vigtige pointer

Responses API vs. Chat Completions

Chat Completions API’en har været standarden i årevis, og meget af den kode, du finder online, bruger den stadig. Siden 2025 har OpenAI dog markeret den som forældet (legacy) og anbefaler Responses API’en til alle nye projekter. Denne lektion sammenligner de to grænseflader med fokus på de forskelle, der reelt påvirker din kode.

Fundamentale ændringer

Med Chat Completions opbyggede du en liste over beskeder og sendte hele listen med hvert kald. Samtaletilstanden levede i din applikation, aldrig på serveren:

from openai import OpenAI
client = OpenAI()

# Gammel model — Chat Completions (forældet)
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)
# Resultat: "The capital of France is Paris."

Responses API’en reducerer dette samme kald til to parametre og giver direkte adgang til den genererede tekst. Systembeskeden bliver til parameteren instructions, og udtrækning af indhold kræver ikke længere navigation gennem choices[0].message.content:

from openai import OpenAI
client = OpenAI()

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

Server-side sessionshåndtering

Dette giver den mest umiddelbare fordel. API’en vedligeholder samtaletilstanden, så du kun behøver at referere til det tidligere svar via dets ID. Forestil dig en support-assistent: Ved det tiende svar tvang Chat Completions-metoden dig til at gensende de tidligere ni udvekslinger, hvilket betød, at du betalte for disse tokens igen. Her er et enkelt felt nok:

# Første spørgsmål
response = client.responses.create(
    model="gpt-5.6-terra",
    input="My name is Marie."
)

# Andet spørgsmål — konteksten bevares automatisk
followup = client.responses.create(
    model="gpt-5.6-terra",
    input="What is my name?",
    previous_response_id=response.id
)
print(followup.output_text)
# Resultat: "Your name is Marie."

Garanteret JSON, ikke håbefuldt JSON

Den anden store forbedring vedrører struktureret output. Du beskriver det forventede format, og Responses API’en garanterer, at svaret overholder dit JSON-skema – hvilket giver dig mulighed for at deserialisere uden sikkerhedsnet. En registreringsformular, der udtrækker information fra fri tekst, bryder ikke længere, bare fordi modellen beslutter at tilføje en indledningssætning før sin JSON:

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

Funktionskald og streaming

Erklæring af værktøjer følger den samme forenklingslogik: Funktionsdeskriptoren erklæres fladt i tools, og kaldet, som modellen anmoder om, vises direkte i response.output uden ekstra nesting-niveauer.

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'en returnerer funktionskaldet til eksekvering direkte
for item in response.output:
    if item.type == "function_call":
        print(f"Function: {item.name}, Arguments: {item.arguments}")
# Resultat: Function: get_meteo, Arguments: {"city": "Lyon"}

Streaming returnerer ikke længere en strøm af udifferentierede bidder, men typede begivenheder. Du filtrerer på event.type og ved præcis, hvad du håndterer – et tekstfragment, et funktionsargument eller slutningen på genereringen:

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)

Hurtig migrationsguide

Chat CompletionsResponses API
client.chat.completions.create()client.responses.create()
messages=[...]input="..." eller input=[...]
response.choices[0].message.contentresponse.output_text
Manuel historikprevious_response_id
response_formattext={"format": {...}}
tools + tool_choicetools (forenklet)

Skal du migrere med det samme?

Chat Completions API’en fungerer stadig og bliver ikke fjernet. Eksisterende kode, der kører, kræver ingen ændringer og drager ingen fordel af en hurtig omskrivning, hvis den hviler på en testpipeline bygget omkring det gamle format. Hvis du desuden er afhængig af et tredjepartsbibliotek, der endnu ikke understøtter Responses API’en, bør du vente på dens opdatering. Men for ethvert nyt projekt er svaret klart: Responses API’en er udgangspunktet, og resten af dette kursus tager udgangspunkt i denne antagelse.

Vigtige pointer

  • Responses API’en erstatter Chat Completions med en simplere grænseflade
  • Server-side sessionshåndtering eliminerer behovet for at gensende historik
  • Struktureret output og funktionskald er integreret nativt
  • Migration er ligetil: Koncepterne forbliver de samme, kun syntaksen ændres