Använd Azure OpenAI Responses API

Använd Azure OpenAI Responses API för att generera tillståndsbevarande, flervändningssvar. Den samlar funktioner från chattkompletteringar och assistenter-API:et i en enhetlig upplevelse. Svars-API:et stöder också den computer-use-preview modell som driver datoranvändning.

Förutsättningar

  • En distribuerad Azure OpenAI-modell.
  • En autentiseringsmetod:
    • API-nyckel (till exempel AZURE_OPENAI_API_KEY), eller
    • Microsoft Entra ID (rekommenderas).
  • Installera klientbiblioteket för ditt språk:
    • Python:pip install openai azure-identity
    • .NET: dotnet add package OpenAI och dotnet add package Azure.Identity
    • JavaScript/TypeScript: npm install openai @azure/identity
    • Java: Lägg till com.openai:openai-java och com.azure:azure-identity i projektet.
  • För REST-exempel anger du AZURE_OPENAI_API_KEY (API-nyckelflöde) eller AZURE_OPENAI_AUTH_TOKEN (Microsoft Entra ID flöde).

Regioner som stöds

Innan du kör exemplen i den här artikeln kontrollerar du att resursregionen stöder API:et Svar. V1-API:et krävs för att få åtkomst till de senaste funktionerna – mer information finns i livscykeln för API-versionen. Svars-API:et är för närvarande tillgängligt i följande regioner:

  • australiaeast
  • brazilsouth
  • canadacentral
  • canadaeast
  • eastus
  • eastus2
  • francecentral
  • germanywestcentral
  • italynorth
  • japaneast
  • koreacentral
  • northcentralus
  • norwayeast
  • polencentral
  • southafricanorth
  • southcentralus
  • southeastasia
  • Södra Indien
  • spaincentral
  • swedencentral
  • Schweiznord
  • uaenorth
  • uksouth
  • westus
  • westus3

Modeller som stöds

Svars-API:et stöder följande modeller:

  • gpt-chat-latest (Versioner: 2026-05-28, 2026-05-05)
  • gpt-5.5 (Version: 2026-04-24)
  • gpt-5.4-nano (Version: 2026-03-17)
  • gpt-5.4-mini (Version: 2026-03-17)
  • gpt-5.4-pro (Version:2026-03-05)
  • gpt-5.4 (Version:2026-03-05)
  • gpt-5.3-chat (Version: 2026-03-03)
  • gpt-5.3-codex (Version: 2026-02-24)
  • gpt-5.2-codex (Version: 2026-01-14)
  • gpt-5.2 (Version: 2025-12-11)
  • gpt-5.2-chat (Version: 2025-12-11)
  • gpt-5.2-chat (Version: 2026-02-10)
  • gpt-5.1-codex-max (Version: 2025-12-04)
  • gpt-5.1 (Version: 2025-11-13)
  • gpt-5.1-chat (Version: 2025-11-13)
  • gpt-5.1-codex (Version: 2025-11-13)
  • gpt-5.1-codex-mini (Version: 2025-11-13)
  • gpt-5-pro (Version: 2025-10-06)
  • gpt-5-codex (Version: 2025-09-11)
  • gpt-5 (Version: 2025-08-07)
  • gpt-5-mini (Version: 2025-08-07)
  • gpt-5-nano (Version: 2025-08-07)
  • gpt-5-chat (Version: 2025-08-07)
  • gpt-5-chat (Version: 2025-10-03)
  • gpt-5-codex (Version: 2025-09-15)
  • gpt-4o (Versioner: 2024-11-20, 2024-08-06, 2024-05-13)
  • gpt-4o-mini (Version: 2024-07-18)
  • computer-use-preview
  • gpt-4.1 (Version: 2025-04-14)
  • gpt-4.1-nano (Version: 2025-04-14)
  • gpt-4.1-mini (Version: 2025-04-14)
  • gpt-image-1 (Version: 2025-04-15)
  • gpt-image-1-mini (Version: 2025-10-06)
  • gpt-image-1.5 (Version: 2025-12-16)
  • o1 (Version: 2024-12-17)
  • o3-mini (Version: 2025-01-31)
  • o3 (Version: 2025-04-16)
  • o4-mini (Version: 2025-04-16)

Alla modeller är inte tillgängliga i alla regioner som stöds. Kontrollera modellsidan för tillgänglighet för modellregion. Den fullständiga uppsättningen med parametrar för begäran och svar finns i referensdokumentationen för Svars-API.

Observera

Stöds inte för närvarande:

  • Bildgenerering med flerstegsredigering och strömning.
  • Bilder kan inte laddas upp som en fil och refereras sedan som indata.

Det finns ett känt problem med följande:

  • PDF som indatafil stöds nu, men det finns för närvarande inte stöd för att user_data ange filuppladdningssyfte.
  • Prestandaproblem när bakgrundsläget används med strömning. Microsoft arbetar med att lösa problemet.

Generera ett textsvar

Generera ett enkelt textsvar med hjälp av svars-API:et. Ersätt YOUR-RESOURCE-NAME och MODEL_NAME med dina distributionsvärden.

import os
from openai import OpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

# API key authentication
client = OpenAI(
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
)
response = client.responses.create(
    model="MODEL_NAME",
    input="This is a test."
)
print(response.model_dump_json(indent=2))

# Microsoft Entra ID authentication (recommended)
token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://ai.azure.com/.default"
)
client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=token_provider(),
)
response = client.responses.create(
    model="MODEL_NAME",
    input="This is a test."
)
print(response.model_dump_json(indent=2))

Exempelsvar

{
  "id": "resp_67cb32528d6881909eb2859a55e18a85",
  "created_at": 1741369938.0,
  "output_text": "Great! How can I help you today?",
  ...
}

Hämta ett svar

Hämta ett svar med dess ID från ett tidigare API-anrop för svar.

import os
from openai import OpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

# API key authentication
client = OpenAI(
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
)
response = client.responses.retrieve("<response_id>")
print(response.model_dump_json(indent=2))

# Microsoft Entra ID authentication
token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://ai.azure.com/.default"
)
client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=token_provider,
)
response = client.responses.retrieve("<response_id>")
print(response.model_dump_json(indent=2))

Exempelsvar

{
  "id": "resp_67cb61fa3a448190bcf2c42d96f0d1a8",
  "output_text": "Hello! How can I assist you today?",
  ...
}

Ta bort ett svar

Som standard behålls svarsdata i 30 dagar. Ta bort ett lagrat svar med ID.

import os
from openai import OpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

# API key authentication
client = OpenAI(
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
)
response = client.responses.delete("<response_id>")
print(response)

# Microsoft Entra ID authentication
token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://ai.azure.com/.default"
)
client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=token_provider,
)
response = client.responses.delete("<response_id>")
print(response)

Sammanlänka svar

Kedjan vänder genom att skicka föregående svars-ID till previous_response_id.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=os.getenv("AZURE_OPENAI_API_KEY")
)

first_response = client.responses.create(
    model="MODEL_NAME",
    input="Define catastrophic forgetting."
)

second_response = client.responses.create(
    model="MODEL_NAME",
    previous_response_id=first_response.id,
    input="Explain it for a college freshman."
)

print(second_response.output_text)

Manuell kedjning av svar

Du kan också manuellt överföra utdataobjekt i nästa begäran.

import os
from openai import OpenAI

client = OpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
  api_key=os.getenv("AZURE_OPENAI_API_KEY")  
)

inputs = [{"type": "message", "role": "user", "content": "Define and explain the concept of catastrophic forgetting?"}] 
  
response = client.responses.create(  
    model="gpt-4o",  # replace with your model deployment name  
    input=inputs  
)  
  
inputs += response.output

inputs.append({"role": "user", "type": "message", "content": "Explain this at a level that could be understood by a college freshman"}) 
               

second_response = client.responses.create(
  model="MODEL_NAME",
    input=inputs
)

print(second_response.model_dump_json(indent=2))

Komprimera ett svar

Komprimering minskar indatakontexten samtidigt som viktigt tillstånd bevaras för senare svängar.

import os
from openai import OpenAI

client = OpenAI(
  base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
  api_key=os.getenv("AZURE_OPENAI_API_KEY")
)

compacted = client.responses.compact(
  model="MODEL_NAME",
  input=[
    {"role": "user", "content": "Create a simple landing page for a dog cafe."},
    {
      "id": "msg_001",
      "type": "message",
      "status": "completed",
      "role": "assistant",
      "content": [{"type": "output_text", "text": "..."}],
    },
  ]
)

follow_up = client.responses.create(
  model="MODEL_NAME",
  input=[*compacted.output, {"role": "user", "content": "Add a booking form."}]
)
print(follow_up.output_text)

Komprimera med returnerade varor

Du kan komprimera alla objekt som returneras från tidigare begäranden som resonemang, meddelande, funktionsanrop osv.

curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses/compact \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
  -d '{
        "model": "MODEL_NAME",
        "input": [
          {
            "role"   : "user",
            "content": "Create a simple landing page for a dog petting café."
          },
          {
            "id": "msg_001",
            "type": "message",
            "status": "completed",
            "content": [
              {
                "type": "output_text",
                "annotations": [],
                "logprobs": [],
                "text": "Below is a single file, ready-to-use landing page for a dog petting café:..."
              }
            ],
            "role": "assistant"
          }
        ]
    }'

# Use the compacted output as input for the next turn.
next_response = client.responses.create(
  model="MODEL_NAME",
  input=[*compacted.output, {"role": "user", "content": "Add opening hours."}],
)
print(next_response.output_text)

Använd föregående svars-ID för att komprimera

Du kan också komprimera med ett tidigare svars-ID.

initial_response = client.responses.create(
  model="MODEL_NAME",
  input="What is the size of France?"
)

compacted_response = client.responses.compact(
  model="MODEL_NAME",
  previous_response_id=initial_response.id
)

follow_up_response = client.responses.create(
  model="MODEL_NAME",
  input=[
    *compacted_response.output,
    {"role": "user", "content": "What is the capital?"}
  ]
)
print(follow_up_response.output_text)

Komprimering på serversidan

Du kan också använda komprimering på serversidan direkt i Svar (POST /responses eller client.responses.create) genom att ange context_management med en compact_threshold.

  • När antalet utdatatoken överskrider det konfigurerade tröskelvärdet kör svars-API:et automatiskt komprimering.
  • I det här läget behöver du inte anropa /responses/compact separat.
  • Svaret innehåller ett krypterat komprimeringsobjekt.
  • Komprimering på serversidan fungerar när du ställer in store=false på dina skapa svarsbegäranden.

Komprimeringsobjektet vidarebefordrar det väsentliga tidigare tillståndet och resonemanget till nästa tur med färre token. Det är ogenomskinligt och inte avsett att vara läsbart för människor.

Om du använder tillståndslös indatamatrislänkning lägger du till utdataobjekt som vanligt. Om du använder previous_response_idskickar du bara det nya användarmeddelandet på varje tur. I båda mönstren bär komprimeringsobjektet den kontext som behövs för nästa fönster.

Tips

När du har lagt till utdataobjekt till föregående indataobjekt kan du släppa objekt som kom före det senaste komprimeringsobjektet för att hålla begäranden mindre och minska långa svarstider. Det senaste komprimeringsobjektet har den kontext som krävs för att fortsätta konversationen. Om du använder previous_response_id kedjning ska du inte beskära manuellt.

Flöde

  1. Ring responses som vanligt. Lägg till context_management med compact_threshold för att aktivera komprimering på serversidan.
  2. Om utdata överskrider tröskelvärdet utlöser tjänsten komprimering, genererar ett komprimeringsobjekt i utdataströmmen och rensar kontexten innan den fortsätter.
  3. Fortsätt konversationen med något av följande mönster:
    1. Tillståndslös koppling av indatamatriser: Bifoga utdataobjekt, inklusive packningsobjekt, till nästa indatamatris.
    2. previous_response_id kedjning: Skicka bara det nya användarmeddelandet vid varje tur och för det senaste svars-ID:t vidare.

Exempel

conversation = [
  {
    "type": "message",
    "role": "user",
    "content": "Let's begin a long coding task.",
  }
]

while keep_going:
  response = client.responses.create(
    model="MODEL_NAME",
    input=conversation,
    store=False,
    context_management=[{"type": "compaction", "compact_threshold": 200000}],
  )

  conversation.append(
    {
      "type": "message",
       "role": "user",
      "content": get_next_user_input(),
    }
  )

Streaming

Strömma svaret när det genereras genom att ange stream=true. Tjänsten skickar inkrementella händelser som du kan använda för att visa utdata token för token.

Observera

Vid strömning kan svars-API:et returnera en felhändelse ( 500, 429och liknande fel) om tjänsten stöter på ett fel, till exempel tokenbegränsningar eller parsningsproblem. Program bör identifiera den här händelsen och smidigt stoppa eller starta om strömning. Du debiteras inte för token som genereras under misslyckade strömningssvar.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=os.getenv("AZURE_OPENAI_API_KEY")
)

stream = client.responses.create(
    model="MODEL_NAME",
    input="Summarize Azure OpenAI Responses API in one sentence.",
    stream=True,
)

for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="")

Funktionsanrop

Svars-API:et stöder funktionsanrop.

import os
import json
from openai import OpenAI

client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=os.getenv("AZURE_OPENAI_API_KEY")
)

response = client.responses.create(
    model="MODEL_NAME",
    tools=[
        {
            "type": "function",
            "name": "get_weather",
            "description": "Get weather for a location",
            "parameters": {
                "type": "object",
                "properties": {"location": {"type": "string"}},
                "required": ["location"],
            },
        }
    ],
    input="What is the weather in San Francisco?",
)

tool_outputs = []
for item in response.output:
    if item.type == "function_call" and item.name == "get_weather":
        args = json.loads(item.arguments)
        weather = {"location": args["location"], "temperature": "70 F"}
        tool_outputs.append(
            {
                "type": "function_call_output",
                "call_id": item.call_id,
                "output": json.dumps(weather),
            }
        )

final_response = client.responses.create(
    model="MODEL_NAME",
    previous_response_id=response.id,
    input=tool_outputs,
)

print(final_response.output_text)

Hantera skyddsräcken och innehållsfiltrering

Skyddsräcken (innehållsfilter) tillämpas på distributionsnivå och körs automatiskt på varje API-anrop för svar, så de skyddar både de indata som du skickar och de utdata som modellen genererar. Du konfigurerar skyddsräcken separat. Mer information finns i Konfigurera skyddsräcken och kontroller. Det här avsnittet visar hur du identifierar och hanterar guardrail-resultat när du anropar svars-API:et.

Responses API:t presenterar guardrail-resultat på ett annat sätt än Chat Completions. I stället för fälten prompt_filter_results och content_filter_results som chattens slutföranden returnerar innehåller svarsobjektet en matris på den översta nivån content_filters . Varje post beskriver ett filterresultat.

Fält Description
blocked Om innehållet har blockerats.
source_type Om resultatet gäller för prompt (indata) eller completion (utdata).
content_filter_results Kategoriresultaten, till exempel hate, sexual, violenceoch self_harm med allvarlighetsgrad, plus valfria kategorier som jailbreak, indirect_attack, protected_material_textoch protected_material_code.
content_filter_offsets De teckenoffsetar som resultatet gäller för.

Observera

Matrisen content_filters är ett Microsoft Foundry-tillägg som inte är en del av bassvarsschemat för OpenAI, så SDK:erna exponerar inte en typad egenskap för den. Läs det som rådata eller som ett extra fält, såsom visas i följande exempel.

Identifiera blockerade indata

När skyddsräcken blockerar dina indata returnerar API:et ett HTTP 400-fel med koden content_filter. Fånga det här felet för att hantera blockerade prompter på ett smidigt sätt.

import os
from openai import OpenAI, BadRequestError

client = OpenAI(
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
)

# A blocked prompt raises BadRequestError with the code "content_filter"
try:
    response = client.responses.create(
        model="MODEL_NAME",
        input="This is a test."
    )
    print(response.output_text)
except BadRequestError as error:
    if error.code == "content_filter":
        print("The prompt was blocked by a guardrail.")
    else:
        raise

Läs skyddsräckesanteckningar

När en begäran lyckas läser du matrisen content_filters från svaret för att granska skyddsräckets resultat för indata och utdata.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
)
response = client.responses.create(
    model="MODEL_NAME",
    input="This is a test."
)

# content_filters is an Azure extension, so read it from model_extra
content_filters = response.model_extra.get("content_filters", [])
for result in content_filters:
    print(f"Source: {result['source_type']}, Blocked: {result['blocked']}")

Mer information om skyddsräckeskategorier och allvarlighetsnivåer finns i Översikt över skyddsräcken och Arbeta med anteckningar.

Kodtolkare

Med verktyget Kodtolkning kan modeller skriva och köra Python-kod i en säker, isolerad sandlådemiljö. Den stöder en rad avancerade uppgifter, bland annat:

  • Bearbeta filer med olika dataformat och strukturer
  • Generera filer som innehåller data och visualiseringar (till exempel grafer)
  • Iterativt skriva och köra kod för att lösa problem – modeller kan felsöka och försöka kod igen tills det lyckas
  • Förbättra det visuella resonemanget i modeller som stöds (till exempel o3, o4-mini) genom att aktivera bildtransformationer som beskärning, zoomning och rotation
  • Det här verktyget är särskilt användbart för scenarier som rör dataanalys, matematisk beräkning och kodgenerering.
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
  -H "Content-Type: application/json" \
  -H "api-key: $AZURE_OPENAI_API_KEY" \
  -d '{
        "model": "MODEL_NAME",
        "tools": [
            { "type": "code_interpreter", "container": {"type": "auto"} }
        ],
        "instructions": "You are a personal math tutor. When asked a math question, write and run code using the python tool to answer the question.",
        "input": "I need to solve the equation 3x + 11 = 14. Can you help me?"
    }'

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=os.getenv("AZURE_OPENAI_API_KEY")
)

response = client.responses.create(
    model="MODEL_NAME",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    instructions="You are a math tutor. Write and run Python code to solve math problems.",
    input="Solve 3x + 11 = 14."
)

print(response.output_text)

Behållare

Viktigt

Kodtolken har yrena avgifter utöver de tokenbaserade avgifterna för Azure OpenAI-användning. Om ditt svars-API anropar kodtolkaren samtidigt i två olika trådar skapas två kodtolkarsessioner. Varje session är aktiv som standard i 1 timme med en timeout på 20 minuter.

Kodtolkningsverktyget kräver en container – en helt sandboxad virtuell maskin där modellen kan köra Python-kod. Behållare kan innehålla uppladdade filer eller filer som genereras under körning.

Om du vill skapa en container anger du "container": { "type": "auto", "file_ids": ["file-1", "file-2"] } i verktygskonfigurationen när du skapar ett nytt svarsobjekt. Detta skapar automatiskt en ny container eller återanvänder en aktiv från en tidigare code_interpreter_call i modellens kontext. I code_interpreter_call utdata av API:t kommer att innehålla container_id som genererades. Den här containern upphör att gälla om den inte används på 20 minuter.

Filinmatning och utdata

När du kör kodtolkaren kan modellen skapa egna filer. Om du till exempel ber den att konstruera ett diagram eller skapa en CSV skapar den dessa avbildningar direkt i containern. De här filerna citeras i anteckningarna i nästa meddelande.

Alla filer i modellindata laddas upp automatiskt till containern. Du behöver inte uttryckligen ladda upp den till containern.

Filer som stöds

Filformat MIME-typ
.c text/x-c
.cs text/x-csharp
.cpp text/x-c++
.csv text/csv
.doc application/msword
.docx application/vnd.openxmlformats-officedocument.wordprocessingml.document
.html text/html
.java text/x-java
.json application/json
.md text/markdown
.pdf application/pdf
.php text/x-php
.pptx application/vnd.openxmlformats-officedocument.presentationml.presentation
.py text/x-python
.py text/x-script.python
.rb text/x-ruby
.tex text/x-tex
.txt text/oformaterad
.css text/css
.js text/JavaScript
.sh application/x-sh
.ts application/TypeScript
.csv application/csv
.jpeg bild/jpeg
.jpg bild/jpeg
.gif bild/gif
.pkl application/octet-stream
.png bild/png
.tar application/x-tar
.xlsx application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
.xml application/xml eller "text/xml"
.zip application/zip

Lista indataobjekt

Hämta de indataobjekt som skickades med i ett svar. Detta är användbart för att inspektera den fullständiga konversationskontexten, inklusive alla objekt som lagts till av modellen (till exempel funktionsanrop eller komprimeringsobjekt).

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=os.getenv("AZURE_OPENAI_API_KEY")
)

items = client.responses.input_items.list("<response_id>")
print(items.model_dump_json(indent=2))

Exempelsvar

{
  "object": "list",
  "data": [
    {
      "id": "msg_...",
      "type": "message",
      "role": "user",
      "content": [{"type": "input_text", "text": "This is a test."}]
    }
  ]
}

Bildinmatning

Visionsaktiverade modeller kan tolka bilder tillsammans med text. De kan identifiera objekt, former, färger och texturer och läsa text som finns i en bild, med förbehåll för de begränsningar som anges senare i den här artikeln.

Du kan ange en bild som indata till en begäran på något av följande sätt:

  • En fullständigt kvalificerad URL till en bildfil
  • En Base64-kodad data-URI
  • Ett fil-ID som skapats med Api:et Files

Bild-URL

Referera till en avbildning som finns på en offentlig URL. Modellen hämtar bilden och innehåller den som en del av indatainnehållet.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=os.getenv("AZURE_OPENAI_API_KEY")
)

response = client.responses.create(
    model="MODEL_NAME",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "What is in this image?"},
                {"type": "input_image", "image_url": "<image_url>"}
            ]
        }
    ]
)

print(response.output_text)

Base64-kodad bild

Skicka en bild direkt i texten genom att koda bildens byte till en data-URI i base64-format. Använd det här mönstret när avbildningen inte finns på en offentlig URL eller när du vill undvika extra nätverkshämtning.

import base64
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=os.getenv("AZURE_OPENAI_API_KEY")
)

with open("path_to_your_image.jpg", "rb") as image_file:
    base64_image = base64.b64encode(image_file.read()).decode("utf-8")

response = client.responses.create(
    model="MODEL_NAME",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "What is in this image?"},
                {"type": "input_image", "image_url": f"data:image/jpeg;base64,{base64_image}"}
            ]
        }
    ]
)

print(response.output_text)

Fil-id

Ladda upp en bild med Files API genom att använda purpose="vision", och referera sedan till det returnerade fil-ID:t i din begäran. Den här metoden är användbar när du vill återanvända samma bild över flera begäranden utan att skicka dess byte igen.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=os.getenv("AZURE_OPENAI_API_KEY")
)

def create_file(file_path):
    with open(file_path, "rb") as file_content:
        result = client.files.create(
            file=file_content,
            purpose="vision",
        )
        return result.id

file_id = create_file("path_to_your_image.jpg")

response = client.responses.create(
    model="MODEL_NAME",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "What is in this image?"},
                {"type": "input_image", "file_id": file_id},
            ],
        }
    ],
)

print(response.output_text)

Krav för bildinmatning

I följande tabell visas de filtyper som stöds för bildindata.

Filtyp MIME-typ
PNG image/png
JPEG image/jpeg
WebP image/webp
Icke-animerad GIF image/gif

I en enda begäran kan du inkludera upp till 100 bilder. Varje enskild bildfil måste vara under 50 MB och den sammanlagda storleken på alla bilder i begäran måste också vara under 50 MB.

Bilderna måste uppfylla följande ytterligare krav:

  • Bilden måste vara relevant för prompten. modellen är inte utformad för orelaterat visuellt innehåll.
  • Bilder får inte innehålla skadligt eller känsligt innehåll som bryter mot innehållsprinciper.
  • Bildfiler kan inte vara skadade eller olästa. Om modellen inte kan bearbeta en bild misslyckas begäran.

Välj en bildinformationsnivå

Använd egenskapen detail på en input_image innehållsdel för att styra hur modellen bearbetar avbildningen. Lägre information använder färre token och är snabbare, medan högre information använder fler token, men låter modellen fånga finare funktioner.

{
  "type": "input_image",
  "image_url": "<image_url>",
  "detail": "high"
}

I följande tabell beskrivs varje detaljnivå.

Detaljnivå Description
low Modellen använder en version med lägre upplösning av avbildningen. Det här alternativet använder minst antal token och ger det snabbaste svaret, men modellen kan missa detaljerad information.
high Modellen använder en version med högre upplösning av avbildningen. Det här alternativet samlar in finare information men använder fler token och tar längre tid att svara.
auto Standardvärdet. Modellen väljer lämplig detaljnivå baserat på bilden och prompten.

Begränsningar för bildindata

Visionsaktiverade modeller har följande begränsningar:

  • Medicinska bilder: Modellen är inte lämplig för att tolka specialiserade medicinska bilder som CT-skanningar och bör inte användas för medicinsk rådgivning.
  • Icke-engelsk text: Modellen kanske inte fungerar optimalt när du hanterar bilder som innehåller text i icke-latinska alfabet, till exempel japanska eller koreanska.
  • Liten text: Förstora text i en bild för att förbättra läsbarheten, men undvik att beskära viktig information.
  • Rotation: Modellen kan misstolka roterad eller upp och ned text och bilder.
  • Visuella element: Modellen kan ha problem med grafer eller text där färger eller format, till exempel fasta, streckade eller streckade linjer, varierar.
  • Rumsligt resonemang: Modellen har problem med uppgifter som kräver exakt rumslig lokalisering, till exempel att identifiera schackpositioner.
  • Noggrannhet: Modellen kan generera felaktiga beskrivningar eller bildtexter i vissa fall.
  • Bildform: Modellen har svårt med panorama- och fisheye-bilder.
  • Metadata och storleksändring: Modellen bearbetar inte ursprungliga filnamn eller metadata, och bilderna ändras innan analysen, vilket påverkar deras ursprungliga dimensioner.
  • Räkna: Modellen kan ge ungefärliga antal för objekt i bilder.
  • CAPTCHA: Av säkerhetsskäl finns ett system för att blockera inlämning av CAPTCHAs.

Filinmatning

Modeller med visionsfunktioner stöder PDF-indata. PDF-filer kan anges antingen som Base64-kodade data eller som fil-ID: er. För att hjälpa modeller att tolka PDF-innehåll inkluderas både den extraherade texten och en bild av varje sida i modellens kontext. Detta är användbart när viktig information förmedlas via diagram eller icke-textinnehåll.

Observera

  • All extraherad text och alla bilder placeras i modellens kontext. Se till att du förstår pris- och tokenanvändningskonsekvenserna av att använda PDF-filer som indata.
  • I en enda API-begäran kan du inkludera fler än en fil, men varje fil måste vara under 50 MB. Den kombinerade gränsen för alla filer i begäran är 50 MB.
  • Endast modeller som stöder både text- och bildindata kan acceptera PDF-filer som indata.
  • En purpose av user_data stöds för närvarande inte. Som en tillfällig lösning måste du ange syftet till assistants.

Konvertera PDF till Base64 och analysera

Skicka en PDF infogad direkt i meddelandet genom att koda dess byteinnehåll som en data-URI i base64-format. Modellen tar emot både den extraherade texten och en renderad bild av varje sida.

import base64
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=os.getenv("AZURE_OPENAI_API_KEY")
)

with open("PDF-FILE-NAME.pdf", "rb") as f:
    base64_string = base64.b64encode(f.read()).decode("utf-8")

response = client.responses.create(
    model="MODEL_NAME",
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_file",
                    "filename": "PDF-FILE-NAME.pdf",
                    "file_data": f"data:application/pdf;base64,{base64_string}",
                },
                {"type": "input_text", "text": "Summarize this PDF."},
            ],
        },
    ]
)

print(response.output_text)

Ladda upp PDF och analysera

Ladda upp PDF-filen med purpose="assistants". En purpose av user_data stöds inte för närvarande.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=os.getenv("AZURE_OPENAI_API_KEY")
)

file = client.files.create(
    file=open("nucleus_sampling.pdf", "rb"),
    purpose="assistants"
)

response = client.responses.create(
    model="MODEL_NAME",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_file", "file_id": file.id},
                {"type": "input_text", "text": "Summarize this PDF."},
            ],
        },
    ]
)

print(response.output_text)

Använda fjärranslutna MCP-servrar

Du kan utöka funktionerna i din modell genom att ansluta den till verktyg som finns på MCP-servrar (Remote Model Context Protocol). Dessa servrar underhålls av utvecklare och organisationer och exponerar verktyg som kan nås av MCP-kompatibla klienter, till exempel svars-API:et.

Model Context Protocol (MCP) är en öppen standard som definierar hur program tillhandahåller verktyg och kontextuella data till stora språkmodeller (LLM). Det möjliggör konsekvent och skalbar integrering av externa verktyg i modellarbetsflöden.

I följande exempel visas hur du använder en fjärransluten MCP-server för att fråga efter information om en Azure REST API-lagringsplats. Modellen hämtar och resonerar över lagringsplatsens innehåll i realtid.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=os.getenv("AZURE_OPENAI_API_KEY")
)

response = client.responses.create(
    model="MODEL_NAME",
    tools=[
        {
            "type": "mcp",
            "server_label": "github",
            "server_url": "https://contoso.com/Azure/azure-rest-api-specs",
            "require_approval": "never"
        }
    ],
    input="What transport protocols are supported in the 2025-03-26 version of the MCP spec?"
)

print(response.output_text)

MCP-verktyget fungerar endast i svars-API:et och är tillgängligt för alla nyare modeller (gpt-4o, gpt-4.1 och våra resonemangsmodeller). När du använder MCP-verktyget betalar du bara för token som används när du importerar verktygsdefinitioner eller gör verktygsanrop – det ingår inga ytterligare avgifter.

Godkännanden

Svars-API:et kräver som standard uttryckligt godkännande innan data delas med en fjärransluten MCP-server. Det här godkännandesteget hjälper till att säkerställa transparens och ger dig kontroll över vilken information som skickas externt.

Vi rekommenderar att du granskar alla data som delas med fjärranslutna MCP-servrar och om du vill logga dem i granskningssyfte.

När ett godkännande krävs returnerar modellen ett mcp_approval_request objekt i svarsutdata. Det här objektet innehåller information om den väntande begäran och gör att du kan inspektera eller ändra data innan du fortsätter.

{
  "id": "mcpr_682bd9cd428c8198b170dc6b549d66fc016e86a03f4cc828",
  "type": "mcp_approval_request",
  "arguments": {},
  "name": "fetch_azure_rest_api_docs",
  "server_label": "github"
}

Om du vill fortsätta med mcp-fjärranropet måste du svara på begäran om godkännande genom att skapa ett nytt svarsobjekt som innehåller ett mcp_approval_response objekt. Det här objektet bekräftar din avsikt att tillåta att modellen skickar angivna data till den fjärranslutna MCP-servern.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=os.getenv("AZURE_OPENAI_API_KEY")
)

response = client.responses.create(
    model="MODEL_NAME",
    tools=[
        {
            "type": "mcp",
            "server_label": "github",
            "server_url": "https://contoso.com/Azure/azure-rest-api-specs",
            "require_approval": "never"
        }
    ],
    previous_response_id="<previous_response_id>",
    input=[
        {
            "type": "mcp_approval_response",
            "approve": True,
            "approval_request_id": "<approval_request_id>"
        }
    ]
)

print(response.output_text)

Autentisering

Viktigt

  • MCP-klienten i svars-API:et kräver TLS 1.2 eller senare.
  • Ömsesidig TLS (mTLS) stöds för närvarande inte.
  • Azure tjänsttaggar stöds för närvarande inte för MCP-klienttrafik.

Till skillnad från den GitHub MCP-servern kräver de flesta fjärranslutna MCP-servrar autentisering. MCP-verktyget i svars-API:et stöder anpassade huvuden, så att du kan ansluta till dessa servrar på ett säkert sätt med det autentiseringsschema som krävs.

Du kan ange rubriker som API-nycklar, OAuth-åtkomsttoken eller andra autentiseringsuppgifter direkt i din begäran. Den vanligaste rubriken är Authorization rubriken.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=os.getenv("AZURE_OPENAI_API_KEY")
)

response = client.responses.create(
    model="MODEL_NAME",
    input="What is this repo in 100 words?",
    tools=[
        {
            "type": "mcp",
            "server_label": "github",
            "server_url": "https://contoso.com/Azure/azure-rest-api-specs",
            "headers": {"Authorization": "Bearer $YOUR_MCP_TOKEN"}
        }
    ]
)

print(response.output_text)

Bakgrundsaktiviteter

Med bakgrundsläge kan du köra långvariga uppgifter asynkront med resonemangsmodeller som o3 och o1-pro. Det är användbart för komplexa uppgifter som kan ta flera minuter att slutföra (till exempel Codex- eller Deep Research-agenter). När en begäran skickas med "background": truebearbetas uppgiften asynkront och du söker efter dess status.

Starta en bakgrundsaktivitet

Ange background=true i begäran för att köa uppgiften. Tjänsten returnerar omedelbart med ett svars-ID och en queued status – använd det ID:t för att avsöka, strömma eller avbryta uppgiften.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=os.getenv("AZURE_OPENAI_API_KEY")
)

response = client.responses.create(
    model="MODEL_NAME",
    input="Write me a very long story.",
    background=True
)

print(response.status)

Avsökning för slutförande

Fortsätt med polling så länge statusen är queued eller in_progress. När svaret når ett terminaltillstånd är det tillgängligt för hämtning.

from time import sleep

while response.status in {"queued", "in_progress"}:
    print(f"Current status: {response.status}")
    sleep(2)
    response = client.responses.retrieve(response.id)

print(f"Final status: {response.status}\nOutput:\n{response.output_text}")

Avbryta en bakgrundsaktivitet

Avbryt en pågående bakgrundsuppgift med endpointen cancel. Att avbryta är idempotent – efterföljande anrop returnerar det slutliga svarsobjektet.

response = client.responses.cancel("<response_id>")
print(response.status)

Om du vill strömma ett bakgrundssvar anger du både background och stream till true. Med det här mönstret kan du återuppta direktuppspelningen om anslutningen avbryts. Spåra din position med sequence_number från varje händelse.

stream = client.responses.create(
    model="MODEL_NAME",
    input="Write me a very long story.",
    background=True,
    stream=True,
)

cursor = None
for event in stream:
    print(event)
    cursor = event["sequence_number"]

Bakgrundssvar har för närvarande en högre svarstid för tid till första token än synkrona svar. Förbättringar pågår för att minska denna lucka.

Begränsningar

  • Bakgrundsläget kräver store=true. Tillståndslösa begäranden stöds inte.
  • Du kan bara återuppta direktuppspelningen om den ursprungliga begäran inkluderade stream=true.
  • Avsluta anslutningen direkt om du vill avbryta ett synkront svar.

Återuppta direktuppspelning från en viss punkt

Om en strömmande anslutning bryts kan du återuppta från en känd händelse genom att skicka stream=true tillsammans med starting_after=<sequence_number> på en GET i svaret. Tjänsten spelar upp händelser som genereras efter sekvensnumret.

curl -N -X GET "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses/<response_id>?stream=true&starting_after=42" \
  -H "Content-Type: application/json" \
  -H "api-key: $AZURE_OPENAI_API_KEY"

Krypterade resonemangsobjekt

När du använder API:et Svar i tillståndslöst läge (store=false) måste du fortfarande bevara resonemangskontexten mellan konversationssvängar. Det gör du genom att inkludera krypterade resonemangsobjekt i dina begäranden.

Om du vill behålla resonemangsobjekt över varv lägger du till reasoning.encrypted_content i parametern include . Svaret innehåller sedan en krypterad version av resonemangsspårningen, som du kan skicka till framtida begäranden.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=os.getenv("AZURE_OPENAI_API_KEY")
)

response = client.responses.create(
    model="MODEL_NAME",
    reasoning={"effort": "medium"},
    input="What is the weather like today?",
    tools=[
        # Replace with your function or tool definitions.
    ],
    include=["reasoning.encrypted_content"],
    store=False,
)

print(response.output_text)

Svars-API:et möjliggör bildgenerering som en del av konversationer och arbetsflöden i flera steg. Den stöder bildindata och utdata i kontexten och innehåller inbyggda verktyg för att generera och redigera bilder.

Jämfört med det fristående bild-API:et har svars-API:et två fördelar:

  • Direktuppspelning: Visa partiella bildutdata under genereringen för att förbättra den upplevda svarstiden.
  • Flexibla indata: Acceptera bildfils-ID:t som indata utöver råa bildbyte.

Observera

Bildgenereringsverktyget i svars-API:et stöds av gpt-image-1-series-modeller och du kan anropa det från en uppsättning kompatibla chatt- och resonemangsmodeller. Den aktuella listan över orkestreringsmodeller som stöds finns i avsnittet Modeller som stöds senare i den här artikeln.

Verktyget för bildgenerering stöder för närvarande inte strömningsläge. Om du vill streama delbilder anropar du API:et för bildgenerering direkt utanför Responses API.

Använd API:et Svar för att skapa konversationsbildupplevelser med GPT Image-modeller.

import base64
import os
from openai import OpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://ai.azure.com/.default"
)

client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=token_provider,
    default_headers={
        "x-ms-oai-image-generation-deployment": os.getenv("IMAGE_MODEL_NAME"),
        "api_version": "preview",
    },
)

response = client.responses.create(
    model="MODEL_NAME",
    input="Generate an image of a gray tabby cat hugging an otter with an orange scarf.",
    tools=[{"type": "image_generation"}],
)

image_data = [
    output.result
    for output in response.output
    if output.type == "image_generation_call"
]

if image_data:
    with open("otter.png", "wb") as f:
        f.write(base64.b64decode(image_data[0]))

Resonemangsmodeller

Exempel på hur du använder resonemangsmodeller med svars-API:et finns i guiden för resonemangsmodeller.

Datoranvändning

Datoranvändning med Playwright har flyttats till modellguiden för dedikerad datoranvändning.

Felsökning

  • 401/403: Om du använder Microsoft Entra ID kontrollerar du att din token är begränsad till https://ai.azure.com/.default. Om du använder en API-nyckel kontrollerar du att du använder rätt nyckel för resursen.
  • 404: Bekräfta att model överensstämmer med ditt distributionsnamn.

Relaterat innehåll

  • Last updated on