Freigeben über

Azure OpenAI-Antwort-API

Die Responses-API ist eine neue zustandsbehaftete API von Azure OpenAI. Sie vereint die besten Funktionen aus den Chatabschluss- und Assistenten-APIs in einer einheitlichen Benutzeroberfläche. Die Antwort-API bietet außerdem Unterstützung für das neue computer-use-preview Modell, das die Computernutzungsfunktion unterstützt.

Antwort-API

API-Unterstützung

Regionale Verfügbarkeit

Die Antwort-API ist derzeit in den folgenden Regionen verfügbar:

  • australiaeast
  • Brasilien Süd
  • kanadacentral
  • Kanada Ost
  • eastus
  • eastus2
  • francecentral
  • Deutschland West-Zentral
  • italiennord
  • japaneast
  • koreacentral
  • Northcentralus
  • norwayeast
  • polandcentral
  • Südafrika Nord
  • southcentralus
  • southeastasia
  • southindia
  • spaincentral
  • swedencentral
  • switzerlandnorth
  • uaenorth
  • uksouth
  • westus
  • westus3

Modellunterstützung

  • 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 (Versionen: 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)
  • o1 (Version: 2024-12-17)
  • o3-mini (Version: 2025-01-31)
  • o3 (Version: 2025-04-16)
  • o4-mini (Version: 2025-04-16)

Nicht jedes Modell ist in den Regionen verfügbar, die von der Antwort-API unterstützt werden. Überprüfen Sie die Modellseite auf die Verfügbarkeit von Modellregionen.

Note

Derzeit nicht unterstützt:

  • Komprimierung mit /responses/compact
  • Bildgenerierung mit mehrstufiger Bearbeitung und Streaming.
  • Bilder können nicht als Datei hochgeladen und dann als Eingabe referenziert werden.

Es gibt ein bekanntes Problem mit Folgendem:

  • PDF als Eingabedatei wird jetzt unterstützt, das Festlegen des Dateiuploadzwecks user_data wird jedoch zurzeit nicht unterstützt.
  • Leistungsprobleme, wenn der Hintergrundmodus beim Streaming verwendet wird. Das Problem wird voraussichtlich bald behoben.

Referenzdokumentation

Erste Schritte mit der Antwort-API

Um auf die Antworten-API-Befehle zuzugreifen, müssen Sie ihre Version der OpenAI-Bibliothek aktualisieren.

pip install --upgrade openai

Generieren einer Textantwort

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="gpt-4.1-nano", # Replace with your model deployment name 
  input="This is a test.",
)

print(response.model_dump_json(indent=2))

Important

Verwenden Sie API-Schlüssel mit Vorsicht. Fügen Sie den API-Schlüssel nicht direkt in Ihren Code ein, und machen Sie ihn nicht öffentlich zugänglich. Wenn Sie einen API-Schlüssel verwenden, speichern Sie ihn sicher in Azure Key Vault. Weitere Informationen zur sicheren Verwendung von API-Schlüsseln in Ihren Apps finden Sie unter API-Schlüssel mit Azure Key Vault.

Weitere Informationen zur Sicherheit von KI-Diensten finden Sie unter Authentifizieren von Anforderungen an Azure AI-Dienste.

Abrufen einer Antwort

Zum Abrufen einer Antwort von einem vorherigen Aufruf der Antworten-API

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.retrieve("resp_67cb61fa3a448190bcf2c42d96f0d1a8")

Important

Verwenden Sie API-Schlüssel mit Vorsicht. Fügen Sie den API-Schlüssel nicht direkt in Ihren Code ein, und machen Sie ihn nicht öffentlich zugänglich. Wenn Sie einen API-Schlüssel verwenden, speichern Sie ihn sicher in Azure Key Vault. Weitere Informationen zur sicheren Verwendung von API-Schlüsseln in Ihren Apps finden Sie unter API-Schlüssel mit Azure Key Vault.

Weitere Informationen zur Sicherheit von KI-Diensten finden Sie unter Authentifizieren von Anforderungen an Azure AI-Dienste.

Antwort löschen

Standardmäßig werden Antwortdaten 30 Tage lang aufbewahrt. Zum Löschen einer Antwort können Sie dies verwenden. response.delete ("{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")  
)

response = client.responses.delete("resp_67cb61fa3a448190bcf2c42d96f0d1a8")

print(response)

Verketten von Antworten

Sie können Antworten verketten, indem Sie die response.id von der vorherigen Antwort an den previous_response_id Parameter übergeben.

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="gpt-4o",  # replace with your model deployment name
    input="Define and explain the concept of catastrophic forgetting?"
)

second_response = client.responses.create(
    model="gpt-4o",  # replace with your model deployment name
    previous_response_id=response.id,
    input=[{"role": "user", "content": "Explain this at a level that could be understood by a college freshman"}]
)
print(second_response.model_dump_json(indent=2))

Beachten Sie, dass aus der Ausgabe ersichtlich ist, dass obwohl wir die erste Eingabefrage nie mit dem second_response API-Aufruf geteilt haben, das previous_response_id Modell den vollständigen Kontext der vorherigen Frage und Antwort übergibt, um die neue Frage zu beantworten.

Output:

{
  "id": "resp_67cbc9705fc08190bbe455c5ba3d6daf",
  "created_at": 1741408624.0,
  "error": null,
  "incomplete_details": null,
  "instructions": null,
  "metadata": {},
  "model": "gpt-4o-2024-08-06",
  "object": "response",
  "output": [
    {
      "id": "msg_67cbc970fd0881908353a4298996b3f6",
      "content": [
        {
          "annotations": [],
          "text": "Sure! Imagine you are studying for exams in different subjects like math, history, and biology. You spend a lot of time studying math first and get really good at it. But then, you switch to studying history. If you spend all your time and focus on history, you might forget some of the math concepts you learned earlier because your brain fills up with all the new history facts. \n\nIn the world of artificial intelligence (AI) and machine learning, a similar thing can happen with computers. We use special programs called neural networks to help computers learn things, sort of like how our brain works. But when a neural network learns a new task, it can forget what it learned before. This is what we call \"catastrophic forgetting.\"\n\nSo, if a neural network learned how to recognize cats in pictures, and then you teach it how to recognize dogs, it might get really good at recognizing dogs but suddenly become worse at recognizing cats. This happens because the process of learning new information can overwrite or mess with the old information in its \"memory.\"\n\nScientists and engineers are working on ways to help computers remember everything they learn, even as they keep learning new things, just like students have to remember math, history, and biology all at the same time for their exams. They use different techniques to make sure the neural network doesn’t forget the important stuff it learned before, even when it gets new information.",
          "type": "output_text"
        }
      ],
      "role": "assistant",
      "status": null,
      "type": "message"
    }
  ],
  "parallel_tool_calls": null,
  "temperature": 1.0,
  "tool_choice": null,
  "tools": [],
  "top_p": 1.0,
  "max_output_tokens": null,
  "previous_response_id": "resp_67cbc96babbc8190b0f69aedc655f173",
  "reasoning": null,
  "status": "completed",
  "text": null,
  "truncation": null,
  "usage": {
    "input_tokens": 405,
    "output_tokens": 285,
    "output_tokens_details": {
      "reasoning_tokens": 0
    },
    "total_tokens": 690
  },
  "user": null,
  "reasoning_effort": null
}

Manuelles Verketten von Antworten

Alternativ können Sie Antworten mithilfe der folgenden Methode manuell verketten:

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="gpt-4o",  
    input=inputs
)  
      
print(second_response.model_dump_json(indent=2))

Streaming

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(
    input = "This is a test",
    model = "o4-mini", # replace with model deployment name
    stream = True
)

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

Aufrufen der Funktion

Die Antwort-API unterstützt Funktionsaufrufe.

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="gpt-4o",  # replace with your model deployment name  
    tools=[  
        {  
            "type": "function",  
            "name": "get_weather",  
            "description": "Get the weather for a location",  
            "parameters": {  
                "type": "object",  
                "properties": {  
                    "location": {"type": "string"},  
                },  
                "required": ["location"],  
            },  
        }  
    ],  
    input=[{"role": "user", "content": "What's the weather in San Francisco?"}],  
)  

print(response.model_dump_json(indent=2))  
  
# To provide output to tools, add a response for each tool call to an array passed  
# to the next response as `input`  
input = []  
for output in response.output:  
    if output.type == "function_call":  
        match output.name:  
            case "get_weather":  
                input.append(  
                    {  
                        "type": "function_call_output",  
                        "call_id": output.call_id,  
                        "output": '{"temperature": "70 degrees"}',  
                    }  
                )  
            case _:  
                raise ValueError(f"Unknown function call: {output.name}")  
  
second_response = client.responses.create(  
    model="gpt-4o",  
    previous_response_id=response.id,  
    input=input  
)  

print(second_response.model_dump_json(indent=2))

Codedolmetscher

Mit dem Code-Interpreter-Tool können Modelle Python-Code in einer sicheren Sandkastenumgebung schreiben und ausführen. Es unterstützt eine Reihe erweiterter Aufgaben, einschließlich:

  • Verarbeiten von Dateien mit unterschiedlichen Datenformaten und Strukturen
  • Generieren von Dateien, die Daten und Visualisierungen enthalten (z. B. Diagramme)
  • Iteratives Schreiben und Ausführen von Code zum Beheben von Problemen – Modelle können Code debuggen und wiederholen, bis die Ausführung erfolgreich war.
  • Verbessern der visuellen Begründung in unterstützten Modellen (z. B. o3, o4-mini) durch Aktivieren von Bildtransformationen wie Zuschneiden, Zoomen und Drehung
  • Dieses Tool eignet sich besonders für Szenarien mit Datenanalyse, mathematischer Berechnung und Codegenerierung.
curl https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses?api-version=preview \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
  -d '{
        "model": "gpt-4.1",
        "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")  
)

instructions = "You are a personal math tutor. When asked a math question, write and run code using the python tool to answer the question."

response = client.responses.create(
    model="gpt-4.1",
    tools=[
        {
            "type": "code_interpreter",
            "container": {"type": "auto"}
        }
    ],
    instructions=instructions,
    input="I need to solve the equation 3x + 11 = 14. Can you help me?",
)

print(response.output)

Containers

Important

Für den Codeinterpreter fallen zusätzliche Gebühren an, die über die tokenbasierten Gebühren für die Azure OpenAI-Nutzung hinausgehen. Wenn Ihre Antwort-API Code-Interpreter gleichzeitig in zwei verschiedenen Threads aufruft, werden zwei Codedolmetschersitzungen erstellt. Jede Sitzung ist standardmäßig für 1 Stunde mit einem Leerlauftimeout von 20 Minuten aktiv.

Das Code-Interpreter-Tool erfordert einen Container – einen vollständig sandkastenbasierten virtuellen Computer, auf dem das Modell Python-Code ausführen kann. Container können hochgeladene Dateien oder Dateien enthalten, die während der Ausführung generiert wurden.

Geben Sie zum Erstellen eines Containers in der Toolkonfiguration "container": { "type": "auto", "file_ids": ["file-1", "file-2"] } beim Erstellen eines neuen Antwortobjekts an. Dadurch wird automatisch ein neuer Container erstellt oder ein aktiver Container aus einem vorherigen code_interpreter_call im Kontext des Modells wiederverwendet. code_interpreter_call in der Ausgabe der API enthält das generierte container_id-Element. Dieser Container läuft ab, wenn er 20 Minuten nicht verwendet wird.

Dateieingaben und -ausgaben

Beim Ausführen des Codedolmetschers kann das Modell eigene Dateien erstellen. Wenn Sie z. B. aufgefordert werden, eine Zeichnung zu erstellen oder eine CSV-Datei zu erstellen, werden diese Images direkt in Ihrem Container erstellt. Sie wird diese Dateien in den Anmerkungen der nächsten Nachricht zitieren.

Alle Dateien in der Modelleingabe werden automatisch in den Container hochgeladen. Sie müssen sie nicht explizit in den Container hochladen.

Unterstützte Dateien

Dateiformat MIME type
.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/plain
.css text/css
.js text/JavaScript
.sh application/x-sh
.ts application/TypeScript
.csv application/csv
.jpeg image/jpeg
.jpg image/jpeg
.gif image/gif
.pkl application/octet-stream
.png image/png
.tar application/x-tar
.xlsx application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
.xml application/xml oder „text/xml“
.zip application/zip

Listeneingabeelemente

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.input_items.list("resp_67d856fcfba0819081fd3cffee2aa1c0")

print(response.model_dump_json(indent=2))

Output:

{
  "data": [
    {
      "id": "msg_67d856fcfc1c8190ad3102fc01994c5f",
      "content": [
        {
          "text": "This is a test.",
          "type": "input_text"
        }
      ],
      "role": "user",
      "status": "completed",
      "type": "message"
    }
  ],
  "has_more": false,
  "object": "list",
  "first_id": "msg_67d856fcfc1c8190ad3102fc01994c5f",
  "last_id": "msg_67d856fcfc1c8190ad3102fc01994c5f"
}

Bildeingabe

Für visionsfähige Modelle werden Bilder in PNG (.png), JPEG (.jpeg und .jpg), WEBP (.webp) unterstützt.

Bild-URL

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="gpt-4o",
    input=[
        {
            "role": "user",
            "content": [
                { "type": "input_text", "text": "what is in this image?" },
                {
                    "type": "input_image",
                    "image_url": "<image_URL>"
                }
            ]
        }
    ]
)

print(response)

Base64-codiertes Bild

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")  
)

def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")

# Path to your image
image_path = "path_to_your_image.jpg"

# Getting the Base64 string
base64_image = encode_image(image_path)

response = client.responses.create(
    model="gpt-4o",
    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)

Dateieingabe

Modelle mit Vision-Funktionen unterstützen die PDF-Eingabe. PDF-Dateien können entweder als Base64-codierte Daten oder als Datei-IDs bereitgestellt werden. Damit Modelle PDF-Inhalte interpretieren können, sind sowohl der extrahierte Text als auch ein Bild jeder Seite im Kontext des Modells enthalten. Dies ist nützlich, wenn wichtige Informationen über Diagramme oder nicht textbezogene Inhalte vermittelt werden.

Note

  • Alle extrahierten Texte und Bilder werden in den Kontext des Modells eingefügt. Stellen Sie sicher, dass Sie die Auswirkungen der Preis- und Tokennutzung bei der Verwendung von PDFs als Eingabe verstehen.

  • In einer einzelnen API-Anforderung sollte sich die Größe von Inhalten, die über mehrere Eingaben (Dateien) hochgeladen wurden, innerhalb der Kontextlänge des Modells befinden.

  • Nur Modelle, die Sowohl Text- als auch Bildeingaben unterstützen, können PDF-Dateien als Eingabe akzeptieren.

  • Ein purpose von user_data wird derzeit nicht unterstützt. Als temporäre Lösung müssen Sie den Zweck auf assistants festlegen.

Konvertieren von PDF in Base64 und Analysieren

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: # assumes PDF is in the same directory as the executing script
    data = f.read()

base64_string = base64.b64encode(data).decode("utf-8")

response = client.responses.create(
    model="gpt-4o-mini", # model deployment 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)

PDF hochladen und analysieren

Laden Sie die PDF-Datei hoch. Ein purpose von user_data wird derzeit nicht unterstützt. Als Umgehungslösung müssen Sie den Zweck auf assistants festlegen.

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")  
)


# Upload a file with a purpose of "assistants"
file = client.files.create(
  file=open("nucleus_sampling.pdf", "rb"), # This assumes a .pdf file in the same directory as the executing script
  purpose="assistants"
)

print(file.model_dump_json(indent=2))
file_id = file.id

Output:

{
  "id": "assistant-KaVLJQTiWEvdz8yJQHHkqJ",
  "bytes": 4691115,
  "created_at": 1752174469,
  "filename": "nucleus_sampling.pdf",
  "object": "file",
  "purpose": "assistants",
  "status": "processed",
  "expires_at": null,
  "status_details": null
}

Anschließend übernehmen Sie den Wert des id Und übergeben sie an ein Modell für die Verarbeitung unter file_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")  
)

response = client.responses.create(
    model="gpt-4o-mini",
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_file",
                    "file_id":"assistant-KaVLJQTiWEvdz8yJQHHkqJ"
                },
                {
                    "type": "input_text",
                    "text": "Summarize this PDF",
                },
            ],
        },
    ]
)

print(response.output_text)

curl https://YOUR-RESOURCE-NAME.openai.azure.com/openai/files \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
  -F purpose="assistants" \
  -F file="@your_file.pdf" \

curl https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
  -d '{
        "model": "gpt-4.1",
        "input": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "input_file",
                        "file_id": "assistant-123456789"
                    },
                    {
                        "type": "input_text",
                        "text": "ASK SOME QUESTION RELATED TO UPLOADED PDF"
                    }
                ]
            }
        ]
    }'

Verwenden von Remote-MCP-Servern

Sie können die Funktionen Ihres Modells erweitern, indem Sie es mit Tools verbinden, die auf McP-Servern (Remote Model Context Protocol) gehostet werden. Diese Server werden von Entwicklern und Organisationen verwaltet und stellen Tools bereit, auf die von MCP-kompatiblen Clients zugegriffen werden kann, z. B. die Antwort-API.

Model Context Protocol (MCP) ist ein offener Standard, der definiert, wie Anwendungen Tools und Kontextdaten für große Sprachmodelle (LLMs) bereitstellen. Sie ermöglicht eine konsistente, skalierbare Integration externer Tools in Modellworkflows.

Im folgenden Beispiel wird veranschaulicht, wie Sie den fiktiven MCP-Server verwenden, um Informationen zur Azure REST-API abzufragen. Auf diese Weise kann das Modell Repository-Inhalte in Echtzeit abrufen und analysieren.

curl https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
  -d '{
  "model": "gpt-4.1",
  "tools": [
    {
      "type": "mcp",
      "server_label": "github",
      "server_url": "https://contoso.com/Azure/azure-rest-api-specs",
      "require_approval": "never"
    }
  ],
  "input": "What is this repo in 100 words?"
}'

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="gpt-4.1", # replace with your model deployment 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)

Das MCP-Tool funktioniert nur in der Antwort-API und ist in allen neueren Modellen verfügbar (gpt-4o, gpt-4.1 und unsere Begründungsmodelle). Wenn Sie das MCP-Tool verwenden, zahlen Sie nur für Token, die beim Importieren von Tooldefinitionen oder Beim Tätigen von Toolaufrufen verwendet werden– es sind keine zusätzlichen Gebühren beteiligt.

Approvals

Standardmäßig erfordert die Antwort-API eine explizite Genehmigung, bevor Daten für einen Remote-MCP-Server freigegeben werden. Dieser Genehmigungsschritt trägt dazu bei, Transparenz zu gewährleisten und Ihnen die Kontrolle darüber zu geben, welche Informationen extern gesendet werden.

Es wird empfohlen, alle Daten zu überprüfen, die für Remote-MCP-Server freigegeben werden, und optional die Daten für Überwachungszwecke zu protokollieren.

Wenn eine Genehmigung erforderlich ist, gibt das Modell ein mcp_approval_request Element in der Antwortausgabe zurück. Dieses Objekt enthält die Details der ausstehenden Anforderung und ermöglicht es Ihnen, die Daten zu prüfen oder zu ändern, bevor Sie fortfahren.

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

Um mit dem Remote-MCP-Aufruf fortzufahren, müssen Sie auf die Genehmigungsanforderung reagieren, indem Sie ein neues Antwortobjekt erstellen, das ein mcp_approval_response Element enthält. Dieses Objekt bestätigt, dass das Modell die angegebenen Daten an den Remote-MCP-Server senden kann.

curl https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
  -d '{
  "model": "gpt-4.1",
  "tools": [
    {
      "type": "mcp",
      "server_label": "github",
      "server_url": "https://contoso.com/Azure/azure-rest-api-specs",
      "require_approval": "never"
    }
  ],
  "previous_response_id": "resp_682f750c5f9c8198aee5b480980b5cf60351aee697a7cd77",
  "input": [{
    "type": "mcp_approval_response",
    "approve": true,
    "approval_request_id": "mcpr_682bd9cd428c8198b170dc6b549d66fc016e86a03f4cc828"
  }]
}'

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="gpt-4.1", # replace with your model deployment name 
    tools=[
        {
            "type": "mcp",
            "server_label": "github",
            "server_url": "https://contoso.com/Azure/azure-rest-api-specs",
            "require_approval": "never"
        },
    ],
    previous_response_id="resp_682f750c5f9c8198aee5b480980b5cf60351aee697a7cd77",
    input=[{
        "type": "mcp_approval_response",
        "approve": True,
        "approval_request_id": "mcpr_682bd9cd428c8198b170dc6b549d66fc016e86a03f4cc828"
    }],
)

Authentication

Important

  • Der MCP-Client innerhalb der Antwort-API erfordert TLS 1.2 oder höher.
  • Mutual TLS (mTLS) wird derzeit nicht unterstützt.
  • Azure-Diensttags werden derzeit für MCP-Clientdatenverkehr nicht unterstützt.

Im Gegensatz zum GitHub MCP-Server benötigen die meisten REMOTE-MCP-Server Authentifizierung. Das MCP-Tool in der Antwort-API unterstützt benutzerdefinierte Header, sodass Sie mithilfe des erforderlichen Authentifizierungsschemas sicher eine Verbindung mit diesen Servern herstellen können.

Sie können Header wie API-Schlüssel, OAuth-Zugriffstoken oder andere Anmeldeinformationen direkt in Ihrer Anforderung angeben. Die am häufigsten verwendete Kopfzeile ist die Authorization Kopfzeile.

curl https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
  -d '{
        "model": "gpt-4.1",
        "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_API_KEY"
            }
        ]
    }'

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="gpt-4.1",
    input="What is this repo in 100 words?",
    tools=[
        {
            "type": "mcp",
            "server_label": "github",
            "server_url": "https://gitmcp.io/Azure/azure-rest-api-specs",
            "headers": {
                "Authorization": "Bearer $YOUR_API_KEY"
        }
    ]
)

print(response.output_text)

Hintergrundaufgaben

Im Hintergrundmodus können Sie langfristig laufende Aufgaben asynchron mit Modellen wie o3 und o1-pro bearbeiten. Dies ist besonders nützlich für komplexe Reasoning-Aufgaben, die mehrere Minuten dauern können, z. B. von Agents wie Codex oder Deep Research verarbeitete Aufgaben.

Durch aktivieren des Hintergrundmodus können Sie Timeouts vermeiden und die Zuverlässigkeit während erweiterter Vorgänge beibehalten. Wenn eine Anforderung mit "background": true gesendet wird, wird die Aufgabe asynchron verarbeitet, und Sie können den Status im Laufe der Zeit abfragen.

Um eine Hintergrundaufgabe zu starten, legen Sie den Hintergrundparameter in Ihrer Anforderung auf "true" fest:

curl https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
  -d '{
    "model": "o3",
    "input": "Write me a very long story",
    "background": true
  }'

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 = "o3",
    input = "Write me a very long story",
    background = True
)

print(response.status)

Verwenden Sie den GET Endpunkt, um den Status einer Hintergrundantwort zu überprüfen. Setzen Sie die Abfrage fort, während der Status „queued” oder „in_progress” lautet. Sobald die Antwort einen endgültigen (Terminal)-Zustand erreicht hat, steht sie für den Abruf zur Verfügung.

curl GET https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses/resp_1234567890 \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN"

from time import sleep
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 = "o3",
    input = "Write me a very long story",
    background = True
)

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}")

Sie können eine in Bearbeitung ausgeführte Hintergrundaufgabe mithilfe des cancel Endpunkts abbrechen. Das Abbrechen ist idempotent – nachfolgende Aufrufe geben das endgültige Antwortobjekt zurück.

curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses/resp_1234567890/cancel \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN"

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.cancel("resp_1234567890")

print(response.status)

Hintergrundantwort streamen

Um eine Hintergrundantwort zu streamen, legen Sie beide background und stream auf "true" fest. Dies ist nützlich, wenn Sie das Streaming später bei einer verworfenen Verbindung fortsetzen möchten. Verwenden Sie die sequence_number jedes Ereignisses, um Ihre Position nachzuverfolgen.

curl https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
  -d '{
    "model": "o3",
    "input": "Write me a very long story",
    "background": true,
    "stream": true
  }'


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")  
)

# Fire off an async response but also start streaming immediately
stream = client.responses.create(
    model="o3",
    input="Write me a very long story",
    background=True,
    stream=True,
)

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

Note

Hintergrundantworten weisen derzeit eine höhere Zeit-bis-zum-ersten-Token-Latenz auf als synchrone Antworten. Verbesserungen sind im Gange, um diese Lücke zu verringern.

Limitations

  • Der Hintergrundmodus erfordert store=true. Statuslose Anforderungen werden nicht unterstützt.
  • Sie können das Streaming nur fortsetzen, wenn die ursprüngliche Anforderung stream=true enthält.
  • Um eine synchrone Antwort abzubrechen, beenden Sie die Verbindung direkt.

Fortsetzen des Streamings von einem bestimmten Punkt

curl https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses/resp_1234567890?stream=true&starting_after=42 \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN"

Verschlüsselte Begründungselemente

Wenn Sie die Antworten-API im zustandslosen Modus verwenden – entweder indem Sie store auf FALSCH setzen oder wenn Ihre Organisation für Null-Datenaufbewahrung angemeldet ist – müssen Sie den Begründungskontext über Gesprächsrunden hinweg beibehalten. Fügen Sie dazu verschlüsselte Begründungselemente in Ihre API-Anforderungen ein.

Fügen Sie reasoning.encrypted_content zum Parameter include in Ihrer Anforderung hinzu, um Begründungen über mehrere Durchläufe hinweg beizubehalten. Dadurch wird sichergestellt, dass die Antwort eine verschlüsselte Version der Begründungsablaufverfolgung enthält, die in zukünftigen Anforderungen übergeben werden kann.

curl https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
  -d '{
    "model": "o4-mini",
    "reasoning": {"effort": "medium"},
    "input": "What is the weather like today?",
    "tools": [<YOUR_FUNCTION GOES HERE>],
    "include": ["reasoning.encrypted_content"]
  }'

Bildgenerierung (Vorschauversion)

Die Antwort-API ermöglicht die Bildgenerierung als Teil von Unterhaltungen und mehrstufigen Workflows. Es unterstützt Bildeingaben und -ausgaben im Kontext und enthält integrierte Tools zum Generieren und Bearbeiten von Bildern.

Im Vergleich zur eigenständigen Image-API bietet die Antwort-API mehrere Vorteile:

  • Streaming: Anzeigen von Teilbildausgaben während der Generation, um die wahrgenommene Latenz zu verbessern.
  • Flexible Eingaben: Akzeptieren Sie Bilddatei-IDs als Eingaben zusätzlich zu unformatierten Bildbytes.

Note

Das Bildgenerierungstool in der Responses-API wird nur von den gpt-image-1-Serienmodellen unterstützt. Sie können dieses Modell jedoch aus dieser Liste der unterstützten Modelle – gpt-4o, , gpt-4o-mini, gpt-4.1, gpt-4.1-minigpt-4.1-nano, , und o3gpt-5gpt-5.1 Serienmodelle – aufrufen.

Das Tool zur Bildgenerierung der Antwort-API unterstützt derzeit keinen Streamingmodus. Rufen Sie die Bildgenerierungs-API direkt außerhalb der Antwort-API auf, um den Streamingmodus zu verwenden und Teilbilder zu generieren.

Verwenden Sie die Antwort-API, wenn Sie Unterhaltungsbildfunktionen mit GPT Image erstellen möchten.

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

token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://cognitiveservices.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":"gpt-image-1", "api_version":"preview"}
)

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

# Save the image to a file
image_data = [
    output.result
    for output in response.output
    if output.type == "image_generation_call"
]
    
if image_data:
    image_base64 = image_data[0]
    with open("otter.png", "wb") as f:
        f.write(base64.b64decode(image_base64))

Denkmodelle

Beispiele für die Verwendung von Begründungsmodellen mit der Antwort-API finden Sie im Leitfaden zu Gründendenmodellen.

Computerverwendung

Die Nutzung von Computern mit Playwright wurde in den Leitfaden für das dedizierte Computernutzungsmodell aufgenommen.

  • Last updated on