OpenAI Responses API Tutorial: 14 Køreklare Eksempler til Python-udviklere

OpenAI Responses API Tutorial: 14 Køreklare Eksempler til Python-udviklere

Den OpenAI Responses API-tutorial, du faktisk har brug for: 14 køreklare Python-eksempler, der dækker indbyggede værktøjer, streaming, funktionskald, MCP og en 3-trins migration fra Chat Completions. Responses API blev lanceret den 11. marts 2025 som OpenAI's samlede primitive for agent-baserede apps, og pr. april 2026 er det det anbefalede udgangspunkt for ethvert nyt OpenAI-projekt. Vi har testet hvert eneste eksempel nedenfor mod den nyeste openai>=1.50 Python SDK i april 2026 — alle kodeblokke kører, som de er.

Vigtigste pointer

• Responses API (lanceret 11. marts 2025) samler Chat Completions, Assistants og indbyggede værktøjer i én tilstandsbevidst primitiv.
• Den understøtter web_search, file_search, code_interpreter, computer_use, image_generation og eksterne MCP-servere out of the box.
• Migration fra Chat Completions tager 3 trin: skift endpoint, omdøb messages → input, opdater værktøjsskemaer.
• Brug previous_response_id (med store: true) til letvægts tilstand; Conversations API til pålidelige multi-turn tråde.

Hvad er OpenAI Responses API?

OpenAI Responses API er en samlet primitiv, der blev lanceret i marts 2025, og som kombinerer enkelheden fra Chat Completions med Assistants API'ens værktøjsbrug. Den understøtter tekst- og billedinput, indbyggede værktøjer (websøgning, filsøgning, kodefortolker, computerbrug, billedgenerering), funktionskald, strukturerede outputs, streaming og tilstandsbevidste samtaler via previous_response_id.

Så hvorfor lancerede OpenAI en tredje API, når Chat Completions allerede virkede? Fordi det agentiske loop — hvor modellen kalder et værktøj, får et resultat og beslutter næste træk — var besværligt at bygge oven på chat.completions. Du endte med at skulle shuttle værktøjsresultater frem og tilbage i messages-arrays, jonglere med thread-ID'er via Assistants API eller rulle din egen tilstandshåndtering. Responses API behandler dette loop som et førsteklasses koncept.

Hvis du starter et nyt OpenAI-projekt i 2026, er Responses API standarden, mens Chat Completions er den legacy-primitiv, du migrerer væk fra. De store undtagelser er realtidsaudio (brug Realtime API) og rene embeddings (brug Embeddings API). Til alt andet — chatbots, agenter, RAG-pipelines, strukturerede data-ekstraktorer — peger OpenAI's dokumentation og OpenAI's annonceringsindlæg dig mod Responses.

Hvis du orkestrerer flere modeller eller ønsker et højere niveau af stillads-lag, vil du typisk parre Responses API med OpenAI Agents SDK. Vi har dækket trade-offs i vores sammenligning af OpenAI Agents SDK. Kort sagt: Responses er primitiven, Agents SDK er frameworket.

Hvordan adskiller Responses API sig fra Chat Completions?

Responses API er et supersæt af Chat Completions: enhver funktion fra Chat Completions fungerer i Responses, plus indbyggede værktøjer, tilstandsbevidsthed og det agentiske loop. OpenAI anbefaler Responses til alle nye projekter. Chat Completions understøttes fortsat, men er ikke længere standardprimitiven for agenter.

Her er sammenligningen side om side, baseret på OpenAI platform docs:

Enhver funktion fra Chat Completions fungerer i Responses; det modsatte gælder ikke. Beslutningsreglen er kort: hvis du har brug for indbyggede værktøjer, tilstandsbevidsthed, eller hvis du starter fra bunden, skal du bruge Responses. Hvis du har en stabil Chat Completions-pipeline, der ikke rører ved værktøjer, og din gateway endnu ikke understøtter Responses, er migrationen ikke akut — men bygg ikke nye agenter på den gamle API.

Opsætning og dit første Responses API-kald

For at foretage dit første Responses API-kald skal du installere OpenAI Python SDK version 1.50 eller nyere, sætte din OPENAI_API_KEY miljøvariabel og kalde client.responses.create() med en model og input. Hele hello-world-eksemplet tager under 60 sekunder.

Trin 1 — Installer SDK'en:

pip install --upgrade "openai>=1.50"

Trin 2 — Sæt din API-nøgle:

export OPENAI_API_KEY="sk-proj-..."

(På Windows PowerShell: $env:OPENAI_API_KEY = "sk-proj-...". Commit aldrig dette til git; brug en .env-fil plus python-dotenv til lokal udvikling.)

Trin 3 — Hello-world-kald:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Say hello in exactly 5 words.",
)

print(response.output_text)

Kør det, og du får en hilsen på 5 ord tilbage. Hjælpefunktionen output_text sammenkæder hver tekstchunk til én streng, hvilket er praktisk, når du ikke bekymrer dig om det strukturerede output.

Trin 4 — Inspicer response-objektet:

print("ID:        ", response.id)
print("Status:    ", response.status)
print("Model:     ", response.model)
print("Output:    ", response.output)            # list of output items
print("First text:", response.output[0].content[0].text)
print("Usage:     ", response.usage)             # input_tokens, output_tokens

Det response.output-array er det, du skal huske. Det er en liste over typede elementer: tekst, værktøjskald, værktøjsresultater, resonneringssammendrag. Du vil iterere over det konstant, når du begynder at bruge indbyggede værktøjer.

Hvordan streamer du responses med Responses API?

Streaming med Responses API bruger Server-Sent Events. Send stream=True til client.responses.create() og iterér over den resulterende event-strøm. Hver event har et type-felt, response.output_text.delta for token-chunks og response.completed for det endelige payload. SDK 1.50+ eksponerer en typet event-strøm.

Hvis du renderer tokens til en UI, vil du iterere over response.output_text.delta-events og ignorere alt andet.

from openai import OpenAI

client = OpenAI()

with client.responses.stream(
    model="gpt-5",
    input="Write a haiku about Python decorators.",
) as stream:
    for event in stream:
        if event.type == "response.output_text.delta":
            print(event.delta, end="", flush=True)
        elif event.type == "response.error":
            print(f"\n[error] {event.error}")
            break
        elif event.type == "response.completed":
            print("\n[done]")

    final = stream.get_final_response()
    print(f"\nTokens: {final.usage.output_tokens}")

Et par faldgruber, vi stødte på under test: stream-kontekstmanageren håndterer forbindelse-oprydning automatisk, så luk den ikke manuelt. Hvis du vil have async, skal du bytte OpenAI() ud med AsyncOpenAI() og bruge async with plus async for; samme event-navne, samme struktur.

Indbyggede værktøjer: Websøgning, Filsøgning, Kodefortolker, Computerbrug, Billedgenerering

Responses API leveres med fem indbyggede værktøjer: web_search til live internetsøgning, file_search til vektorlager-hentning, code_interpreter til sandkasset Python-eksekvering, computer_use til browser/desktop-automatisering og image_generation til inline billedoprettelse. Aktiver cualquiera af dem ved at tilføje {"type": "<tool_name>"} til tools-arrayet.

Her er den matrix, vi altid har pinned ved siden af vores editor:

Da vi benchmarkede web_search i vores pipeline, tilføjede latensen 1,5–3 sekunder på det første kald, men det blev cachelagret til gentagelser. Planlæg efter det i UI'en. OpenAI Cookbook web search-eksemplet er den reneste reference, hvis du vil dybere ned.

Websøgning

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    tools=[{"type": "web_search"}],
    input="What did OpenAI announce at DevDay 2025? Cite your sources.",
)

print(response.output_text)

# Inspect the web_search_call items in response.output for raw search hits
for item in response.output:
    if item.type == "web_search_call":
        print(f"[searched] {item.query}")

Filsøgning

Filsøgning er en to-trins dans: opret et vektorlager, upload dine filer, og referer derefter til lager-ID'et i dit tools-array.

from openai import OpenAI

client = OpenAI()

# 1. Create a vector store + upload a file
store = client.vector_stores.create(name="company-handbook")
client.vector_stores.files.upload_and_poll(
    vector_store_id=store.id,
    file=open("handbook.pdf", "rb"),
)

# 2. Use it in a Responses call
response = client.responses.create(
    model="gpt-5",
    input="What's our PTO policy?",
    tools=[{
        "type": "file_search",
        "vector_store_ids": [store.id],
    }],
)
print(response.output_text)

Kodefortolker

Har du brug for, at modellen kører Python på en CSV-fil og charte noget? code_interpreter gør det i en sandkasset container.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Read sales.csv and plot monthly revenue as a bar chart. Return a summary.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
)
print(response.output_text)

Containeren persistere på tværs af kald i samme session, hvilket er nyttigt, når du vil have modellen til at blive ved med at iterere på en dataframe.

Computerbrug

Stadig i preview pr. april 2026. Modellen får en virtuel browser/desktop og klikker rundt for at fuldføre opgaver. Spring det over, medmindre du har et specifikt browser-automatiseringsuse case, som Playwright/Selenium-verdenen ikke allerede kan løse.

Billedgenerering

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Generate a diagram showing a CI/CD pipeline with build, test, and deploy stages.",
    tools=[{"type": "image_generation"}],
)

# Image bytes live in image_generation_call items
for item in response.output:
    if item.type == "image_generation_call":
        with open("pipeline.png", "wb") as f:
            f.write(item.result)

Funktionskald med brugerdefinerede værktøjer

Funktionskald i Responses API lader modellen invocere dine egne Python-funktioner. Definer hver funktion som et JSON-skema i tools-arrayet, kør kaldet, tjek response.output for function_call-elementer, udfør funktionen, og send resultatet tilbage via function_call_output.

Responses API ændrer funktionskald fra en 4-trins dans til en enkelt round-trip, når du lader det agentiske loop håndtere det for dig. Her er et fuld valutaomregningseksempel:

import json
from openai import OpenAI

client = OpenAI()

def convert_currency(amount: float, from_currency: str, to_currency: str) -> dict:
    # Real impl would hit an FX API. Stubbed for the example.
    rate = 1.08 if (from_currency, to_currency) == ("USD", "EUR") else 1.0
    return {"amount": amount * rate, "currency": to_currency}

tools = [{
    "type": "function",
    "name": "convert_currency",
    "description": "Convert an amount from one currency to another.",
    "parameters": {
        "type": "object",
        "properties": {
            "amount": {"type": "number"},
            "from_currency": {"type": "string"},
            "to_currency": {"type": "string"},
        },
        "required": ["amount", "from_currency", "to_currency"],
    },
}]

# Turn 1: model decides to call our function
first = client.responses.create(
    model="gpt-5",
    input="How much is 250 USD in EUR?",
    tools=tools,
)

# Find the function_call item, run it, send the result back
for item in first.output:
    if item.type == "function_call" and item.name == "convert_currency":
        args = json.loads(item.arguments)
        result = convert_currency(**args)

        second = client.responses.create(
            model="gpt-5",
            previous_response_id=first.id,
            input=[{
                "type": "function_call_output",
                "call_id": item.call_id,
                "output": json.dumps(result),
            }],
            tools=tools,
        )
        print(second.output_text)

Det er hele loopen. Hvis du er ny til mønsteret, går vores indlæg om grundlæggende funktionskald gennem den konceptuelle model, og vi vedligeholder en oversigt over biblioteker til funktionskald, hvis du hellere vil undgå at håndkode skemaer. Parameteren tool_choice (sat til "auto", "required" eller et specifikt værktøjsnavn) er din håndtag til at tvinge eller forbyde et værktøjskald, når du har brug for determinisme.

Strukturerede outputs (JSON-skema og Pydantic)

Strukturerede outputs garanterer, at modellen returnerer JSON, der overholder dit skema. Send en response_format={"type": "json_schema", "json_schema": {...}}-parameter, eller giv den med Python SDK'en en Pydantic-model direkte via client.responses.parse(). Modellen begrænses ved afkodningstidspunktet, ikke kun via prompting.

from openai import OpenAI
from pydantic import BaseModel

client = OpenAI()

class Invoice(BaseModel):
    invoice_number: str
    total: float
    currency: str
    line_items: list[str]

response = client.responses.parse(
    model="gpt-5",
    input="Extract: Invoice #INV-2024-001 for $1,250.00 USD. Items: hosting, support, SSL cert.",
    text_format=Invoice,
)

invoice: Invoice = response.output_parsed
print(invoice.invoice_number, invoice.total, invoice.line_items)

Pydantic-stien er den, du vil have 95 % af tiden: typesikker, mindre boilerplate, og din IDE autoudfylder resultatet. Brug rå JSON-skema kun, når du har brug for cross-language skemadeling, eller når skemaet genereres dynamisk. Vi dykker ned i trade-offs i vores guide om strukturerede outputs og JSON-skema og vores primer om Pydantic til typesikre skemaer.

Tilstandshåndtering: previous_response_id, Conversations API og store=true

Brug previous_response_id til letvægts multi-turn kontekst, Conversations API til pålidelige threaded sessions, eller send fuld beskedhistorik for fuld client-side kontrol. previous_response_id kræver store: true og persisterer kun for cachelagrede responses; falb tilbage til fuld historik, hvis ID'et ikke kan resolves.

Her er et to-turns eksempel ved brug af previous_response_id:

from openai import OpenAI

client = OpenAI()

# Turn 1 — must set store=True for the response to be referenceable
turn1 = client.responses.create(
    model="gpt-5",
    input="My name is Mert and I'm building a weather agent.",
    store=True,
)

# Turn 2 — reference turn 1 by ID; the model "remembers" the name
turn2 = client.responses.create(
    model="gpt-5",
    previous_response_id=turn1.id,
    input="What was my name again?",
    store=True,
)

print(turn2.output_text)  # "Your name is Mert..."

Hvis du glemmer store: true, resolverer dit previous_response_id til ingenting, og modellen starter koldt hver gang. Vi har spildt en time på at debugge dette; API'en fejler ikke, den giver dig blot stille amnesi. Standardopbevaring er 30 dage; hvis du har brug for længere tid, skal du gå over til Conversations API, som giver dig eksplicit kontrol over thread-livscyklus.

Hvornår skal du opgradere til Conversations API? Når du har flere brugere i én app, når tråde overlever en enkelt session, eller når du vil have server-side beskedredigering/grening. Til en hurtig chatbot er previous_response_id rigeligt.

Sådan migrerer du fra Chat Completions til Responses API

Migration fra Chat Completions til Responses API tager tre trin: skift /v1/chat/completions til /v1/responses, erstat messages med input, og erstat tools-skemaer med det nye format. Funktionskald og multimodale inputs kræver lidt anderledes håndtering. OpenAI leverer en officiel migrationspakke på GitHub.

Trin 1 — Endpoint-swap:

# Before (Chat Completions)
response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "Hello"}],
)
text = response.choices[0].message.content

# After (Responses)
response = client.responses.create(
    model="gpt-5",
    input="Hello",
)
text = response.output_text

Trin 2 — Omdøb messages → input:

# Before
client.chat.completions.create(
    model="gpt-4.1",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Summarize this PDF."},
    ],
)

# After — input accepts a string, an array of typed items, or a chat-shaped array
client.responses.create(
    model="gpt-5",
    instructions="You are a helpful assistant.",   # system → instructions
    input="Summarize this PDF.",
)

Trin 3 — Opdater værktøjsskemaer:

# Before (Chat Completions tool format)
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get current weather",
        "parameters": {"type": "object", "properties": {"city": {"type": "string"}}},
    },
}]

# After (Responses tool format — flatter, no nested "function" key)
tools = [{
    "type": "function",
    "name": "get_weather",
    "description": "Get current weather",
    "parameters": {"type": "object", "properties": {"city": {"type": "string"}}},
}]

Det var det. Rul trafikken gradvist med et feature-flag, hold din Chat Completions-kodevej live bag samme interface i en uge eller to, log begge response-formater side om side, og skift først til 100 %, når du har verificeret paritet. Migrationspakken på openai-cookbook-repoet har et fyldigere adaptermønster, hvis du vil have en reference.

Sådan bruger du MCP og eksterne MCP-servere med Responses API

Responses API understøtter eksterne MCP (Model Context Protocol)-servere som en værktøjstype. Tilføj en post som {"type": "mcp", "server_url": "https://mcp.example.com", "server_label": "..."} til tools-arrayet. Modellen opdager MCP-serverens værktøjskatalog og kalder dem som indbyggede værktøjer.

Hvis du aldrig har rørt MCP, her er pitchet på 30 sekunder: det er en åben protokol, der lader enhver tjeneste eksponere sin API som et værktøjskatalog, som modellen kan kalde. Shopify, Stripe, GitHub og en voksende liste af leverandører kører offentlige MCP-endpoints. Vores deep-dive om Model Context Protocol (MCP) dækker selve protokollen.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Find me the top-ranking competitor for 'openai responses api tutorial' and summarize their content gaps.",
    tools=[{
        "type": "mcp",
        "server_url": "https://mcp.semrush.com",
        "server_label": "semrush",
        "require_approval": "never",   # set to "always" in production
    }],
)
print(response.output_text)

Behandl MCP-servere som enhver tredjeparts-API. require_approval: "never" er fint til prototyper; i produktion vil du have "always" (eller en tilladelsesliste over værktøjer), så en kompromitteret MCP-server ikke stille kan exfiltrere data. Revider serverens værktøjskatalog, før du peger din agent mod den.

Priser, Rate Limits og produktionsfaldgruber

Responses API-priser matcher Chat Completions på token-omkostninger (prompt + kompletion), med surcharges per kald på indbyggede værktøjer (web_search, file_search). Rate limits følger dit eksisterende OpenAI-tier. Almindelige produktionsfaldgruber inkluderer store: true opbevaringsstandarder, forbigående 429-fejl ved burst-trafik og Azure-variantens funktionsforsinkelse.

Priser ændrer sig; verifikér altid på OpenAI's prisside på skrivetidspunktet.

Til fejlhåndtering skal du wrappe kald i try/except openai.RateLimitError og try/except openai.APIStatusError med eksponentiel backoff via tenacity:

from openai import OpenAI, RateLimitError, APIStatusError
from tenacity import retry, retry_if_exception_type, stop_after_attempt, wait_exponential

client = OpenAI()

@retry(
    retry=retry_if_exception_type((RateLimitError, APIStatusError)),
    wait=wait_exponential(multiplier=1, min=2, max=30),
    stop=stop_after_attempt(5),
    reraise=True,
)
def safe_create(prompt: str):
    return client.responses.create(model="gpt-5", input=prompt)

print(safe_create("Hello").output_text)

Vi stødte på en forbigående 429-fejl ved en burst på 20 parallelle requests i vores staging-miljø; tenacity med eksponentiel backoff løste det rent. Fejlstrengen, vi loggede, var openai.RateLimitError: Error code: 429 - {'error': {'message': 'Rate limit reached for gpt-5 in organization org-... on requests per min (RPM)'}}. Læs den én gang og gå videre; retry-dekoratøren håndterer resten.

Bemærkning om Azure-varianten: Azure OpenAI eksponerer Responses API, men ligger 4–8 uger efter Sam Altman-kontrollerede udrulninger. Pr. april 2026 er MCP-support på Azure kun i preview; bekræft det mod Microsoft Learn's Azure OpenAI Responses API-dokumentation, før du shipper.

Gateway-kompatibilitet: Hvis du proxyer OpenAI gennem LiteLLM proxy, landede Responses API-support i 2026. De fleste andre gateways er ved at hale ind. Og til produktionsudrulninger vil du have AI-observability og logging koblet op, før du flipper trafikken; Responses API-events er rigere end Chat Completions, og du vil have hvert eneste værktøjskald logget.

Hvornår du IKKE skal bruge Responses API

Spring Responses API over til lav-latens realtidsaudio (brug Realtime API), embedding-generering (brug Embeddings API) og fine-tuning workflows. Bliv på Chat Completions, hvis din gateway/proxy endnu ikke understøtter Responses (de fleste gør via LiteLLM pr. 2026).

Nogle flere ærlige diskvalifikatorer:

• Realtids voice-agenter, Realtime API bruger WebSockets og er bygget til sub-sekunds tur-tagning. Responses API-streaming er HTTP SSE; det vil føles sløvt til voice.
• Rene embeddings-pipelines, client.embeddings.create() er billigere, hurtigere, og det er hvad enhver vektor-DB-integration forventer.
• Fine-tuning, du træner og deployer fine-tunes via fine-tuning API'en; du kan derefter kalde dem gennem Responses, men selve træningen er ikke en Responses-workflow.
• Batch API-jobs, hvis du behandler en million prompts natten over til 50 % rabat, vinder Batch API stadig på pris.
• Låste Chat Completions-semantikker, hvis din eval-brug, observability og prompt-bibliotek alle antager chat.completions.choices[0].message.content, er migrationsomkostningen reel. Migrer ikke bare fordi det er nyere.

Hvis din stack er glad for Chat Completions, og du ikke bygger agenter, er migrationen ikke gratis; din Q2-sprint har måske ikke brug for det. Nyere betyder ikke nødvendigvis bedre-for-dig; Responses API er den rigtige primitiv til agenter, ikke til enhver OpenAI-workload.

Ofte stillede spørgsmål

Hvad er OpenAI Responses API?

OpenAI Responses API er en samlet primitiv, der blev lanceret i marts 2025, og som kombinerer enkelheden fra Chat Completions med Assistants API'ens værktøjsbrug. Den understøtter tekst- og billedinput, fem indbyggede værktøjer, funktionskald, strukturerede outputs, streaming og tilstandsbevidste samtaler via previous_response_id.

Hvornår blev OpenAI Responses API udgivet?

OpenAI annoncerede Responses API den 11. marts 2025 sammen med deres bredere "nye værktøjer til bygning af agenter"-annoncering. API'en har været generelt tilgængelig siden lanceringen, med Conversations API, MCP-support og image_generation-værktøjet tilføjet i inkrementelle opdateringer gennem 2025 og begyndelsen af 2026.

Er OpenAI Responses API tilstandsbevidst?

Ja, valgfrit. Send previous_response_id plus store: true, og modellen bærer konteksten over kald uden, at du sender den fulde historik. Til længerevarende tråde giver Conversations API dig eksplicit thread-livscyklusstyring. Du kan også forblive stateless og sende fuld historik hver tur, ligesom Chat Completions.

Hvad er forskellen mellem Responses API og Chat Completions?

Responses API er et supersæt af Chat Completions. Enhver funktion fra Chat Completions fungerer i Responses, plus indbyggede værktøjer (web_search, file_search osv.), tilstandsbevidsthed via previous_response_id og det agentiske loop som et førsteklasses koncept. OpenAI anbefaler Responses til alle nye projekter pr. 2026.

Er Chat Completions API deprecated?

Nej. Pr. april 2026 er Chat Completions ikke deprecated; den understøttes fuldt ud. OpenAI anbefaler Responses til nye projekter, og de fleste agent-stil tutorials antager Responses. Chat Completions er nu den legacy-primitiv: stabil, men ikke længere hvor nye funktioner lander først.

Hvilke OpenAI-modeller understøtter Responses API?

GPT-5, gpt-5-mini, gpt-4.1 og o-seriens resonneringsmodeller understøtter alle Responses API. O-serien tilføjer parameteren reasoning_effort (low, medium, high) til extended-thinking workloads. Billedgenerering routes gennem gpt-image-1 under motorhjelmen, når du aktiverer image_generation-værktøjet.

Hvordan migrerer jeg fra Chat Completions til Responses API?

Tre trin: skift client.chat.completions.create() til client.responses.create(), erstat messages-arrayet med input (og flyt system-prompts til instructions), og flad dine værktøjsskemaer ud (drop den nestede function-nøgle). OpenAI's migrationspakke på GitHub har fulde adaptereksempler.

Understøtter Responses API streaming?

Ja. Send stream=True til client.responses.create() (eller brug client.responses.stream() som kontekstmanager) og iterér de typede Server-Sent Events. De token-stream events, du vil håndtere, er response.output_text.delta for indhold og response.completed for det endelige payload. Async-streaming fungerer via AsyncOpenAI.

Kan jeg bruge Responses API på Azure?

Ja. Azure OpenAI eksponerer Responses API, men funktionspariteten ligger 4–8 uger efter OpenAI's direkte udrulninger. Pr. april 2026 er MCP-support på Azure i preview. Tjek Microsoft Learn for de aktuelle Azure-specifikke ejendommeligheder, før du shipper til produktion.

Fungerer Responses API med MCP-servere?

Ja, eksterne MCP (Model Context Protocol)-servere er en førsteklasses værktøjstype. Tilføj {"type": "mcp", "server_url": "...", "server_label": "..."} til dit tools-array, og modellen opdager og kalder serverens værktøjskatalog ligesom ethvert indbygget værktøj. Brug require_approval: "always" i produktion af sikkerhedsmæssige årsager.

Afrunding

Du har nu det fulde overblik over Responses API: hvordan den adskiller sig fra Chat Completions, hvordan du shipper dit første kald, hvordan du kobler indbyggede værktøjer på, og hvordan du migrerer et eksisterende Chat Completions-projekt på tre trin. Nogle pointer at hæfte sig ved:

• Byg først, optimer derefter. Start med hello-world-eksemplet, tilføj et indbygget værktøj, og læg derefter tilstand på med previous_response_id.
• Migrer gradvist. Brug et feature-flag, log begge response-formater, og skift til 100 % først efter verifikation af paritet.
• Ship MCP-integrationer. Dette er 2026-fronten; de fleste leverandører kæmper om at eksponere MCP-endpoints, og Responses API er den reneste måde at konsumere dem på.

Hos Techsy hjælper vi teams med at shippe produktionsklare OpenAI-integrationer, herunder Responses API-udrulninger og Chat Completions-migrationer. Få en gratis konsultation.

Af Techsys redaktionelle team, produktionsingeniører der har shipped OpenAI-integrationer siden 2024. Sidst opdateret: 25. april 2026.