Responses API vs Chat Completions: Varför migrera
På denna sida
Responses API vs Chat Completions
Chat Completions API:et har varit standarden i åratal, och mycket av koden du hittar online använder det fortfarande. Sedan 2025 har OpenAI dock klassificerat det som föråldrat (legacy) och rekommenderar Responses API för alla nya projekt. Denna lektion jämför de två gränssnitten med fokus på skillnader som faktiskt påverkar din kod.
Grundläggande förändringar
Med Chat Completions byggde du en lista med meddelanden och skickade hela listan vid varje anrop. Konversationstillståndet levde i din applikation, aldrig på servern:
from openai import OpenAI
client = OpenAI()
# Gammal modell — Chat Completions (föråldrad)
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 reducerar detta samma anrop till två parametrar och ger direkt åtkomst till den genererade texten. Systemmeddelandet blir parametern instructions, och för att extrahera innehåll behöver du inte längre navigera genom choices[0].message.content:
from openai import OpenAI
client = OpenAI()
# Ny modell — 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."
Sessionshantering på serversidan
Detta ger den mest omedelbara fördelen. API:et underhåller konversationstillståndet, så du behöver bara referera till föregående svar via dess ID. Tänk dig en supportassistent: vid det tionde turtagandet tvingade Chat Completions-metoden dig att skicka om de tidigare nio utbytena, vilket innebar att du betalade för dessa tokens igen. Här räcker ett enda fält:
# Första frågan
response = client.responses.create(
model="gpt-5.6-terra",
input="My name is Marie."
)
# Andra frågan — kontexten bevaras automatiskt
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."
Garanterad JSON, inte hoppfull JSON
Den andra stora förbättringen gäller strukturerad utdata. Du beskriver det förväntade formatet, och Responses API garanterar att svaret följer ditt JSON-schema – vilket låter dig deserialisera utan säkerhetsnät. Ett registreringsformulär som extraherar information från fri text slutar krasha bara för att modellen bestämmer sig för att lägga till en inledande mening före 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}
Funktionsanrop och strömning
Deklaration av verktyg följer samma förenklingslogik: funktionsbeskrivningen deklareras plant i tools, och anropet som begärs av modellen visas direkt i response.output, utan extra nästlingsnivåer.
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:et returnerar funktionsanropet som ska köras direkt
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"}
Strömning returnerar inte längre en ström av odifferentierade bitar utan typade händelser. Du filtrerar på event.type och vet exakt vad du hanterar – ett textfragment, ett funktionsargument eller slutet 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)
Snabbguide för migrering
| Chat Completions | Responses API |
|---|---|
client.chat.completions.create() | client.responses.create() |
messages=[...] | input="..." eller input=[...] |
response.choices[0].message.content | response.output_text |
| Manuell historik | previous_response_id |
response_format | text={"format": {...}} |
tools + tool_choice | tools (förenklad) |
Bör du migrera omedelbart?
Chat Completions API:et fungerar fortfarande och tas inte bort. Befintlig kod som körs, inte kräver ändringar och förlitar sig på en testpipeline byggd kring det gamla formatet vinner inget på en brådskande omskrivning. På samma sätt, om du är beroende av ett tredjepartsbibliotek som ännu inte stöder Responses API, bör du vänta på dess uppdatering. För alla nya projekt är svaret dock tydligt: Responses API är utgångspunkten, och resten av denna kurs utgår från det antagandet.
Viktiga punkter
- Responses API ersätter Chat Completions med ett enklare gränssnitt
- Sessionshantering på serversidan eliminerar behovet av att skicka om historik
- Strukturerad utdata och funktionsanrop är integrerade från grunden
- Migrering är enkel: koncepten förblir desamma, endast syntaxen ändras