Freigeben über

Azure OpenAI-Antwort-API (Vorschau)

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
  • eastus
  • Eastus2
  • francecentral
  • Japan Ost
  • Norwegen Ost
  • Südindien
  • schwedencentral
  • uaenorth
  • uksouth
  • westus
  • westus3

Modellunterstützung

  • 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)
  • 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.

Hinweis

Derzeit nicht unterstützt:

  • Das Websuchtool
  • Optimierte Modelle
  • Bildgenerierung über Streaming. Bald verfügbar.
  • Bilder können nicht als Datei hochgeladen und dann als Eingabe referenziert werden. Bald verfügbar.
  • Es gibt ein bekanntes Problem mit der Leistung, 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

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

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

client = AzureOpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  azure_ad_token_provider=token_provider,
  api_version="preview"
)

response = client.responses.create(
    model="gpt-4.1-nano",
    input= "This is a test" 
)

print(response.model_dump_json(indent=2))

Abrufen einer Antwort

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

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

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

client = AzureOpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  azure_ad_token_provider=token_provider,
  api_version="preview"
)

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

print(response.model_dump_json(indent=2))

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

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

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

client = AzureOpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  azure_ad_token_provider=token_provider,
  api_version="preview"
)

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.

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

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

client = AzureOpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  azure_ad_token_provider=token_provider,
  api_version="preview"
)

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.

Ausgabe:

{
  "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:

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

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

client = AzureOpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  azure_ad_token_provider=token_provider,
  api_version="preview"
)


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

Streamen

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

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

client = AzureOpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  azure_ad_token_provider=token_provider,
  api_version="preview"
)

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.

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

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

client = AzureOpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  azure_ad_token_provider=token_provider,
  api_version="preview"
)

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

Listeneingabeelemente

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

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

client = AzureOpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  azure_ad_token_provider=token_provider,
  api_version="preview"
)

response = client.responses.input_items.list("resp_67d856fcfba0819081fd3cffee2aa1c0")

print(response.model_dump_json(indent=2))

Ausgabe:

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

Bild-URL

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

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

client = AzureOpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  azure_ad_token_provider=token_provider,
  api_version="preview"
)

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
from openai import AzureOpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

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

client = AzureOpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  azure_ad_token_provider=token_provider,
  api_version="preview"
)

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)

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?api-version=preview \
  -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?"
}'

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

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

client = AzureOpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  azure_ad_token_provider=token_provider,
  api_version="preview"
)

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.

Genehmigungen

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?api-version=preview \
  -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"
  }]
}'

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

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

client = AzureOpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  azure_ad_token_provider=token_provider,
  api_version="preview"
)

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

Authentifizierung

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?api-version=preview \
  -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"
            }
        ]
    }'

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

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

client = AzureOpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  azure_ad_token_provider=token_provider,
  api_version="preview"
)

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 Denkaufgaben, die mehrere Minuten dauern können, um abgeschlossen zu werden, z. B. Aufgaben, die von Agenten wie Codex oder Deep Research verarbeitet werden.

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?api-version=preview \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
  -d '{
    "model": "o3",
    "input": "Write me a very long story",
    "background": true
  }'

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

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

client = AzureOpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  azure_ad_token_provider=token_provider,
  api_version="preview"
)

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?api-version=preview \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN"

from openai import AzureOpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider
from time import sleep

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

client = AzureOpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  azure_ad_token_provider=token_provider,
  api_version="preview"
)

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 Abbruchendpunkts 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?api-version=preview \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN"

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

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

client = AzureOpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  azure_ad_token_provider=token_provider,
  api_version="preview"
)

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?api-version=preview \
  -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
  }'


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

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

client = AzureOpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  azure_ad_token_provider=token_provider,
  api_version="preview"
)

# 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"]

Hinweis

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.

Einschränkungen

  • 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&api-version=2025-04-01-preview \
  -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?api-version=preview \
  -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

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:

  • Mehrfachbearbeitung: Iteratives Verfeinern und Bearbeiten von Bildern mithilfe von Prompts in natürlicher Sprache.
  • 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.

Hinweis

Das Tool zur Bildgenerierung in der Antwort-API wird nur vom gpt-image-1 Modell unterstützt. Sie können dieses Modell jedoch aus dieser Liste der unterstützten Modelle aufrufen - gpt-4o, , gpt-4o-mini, , gpt-4.1gpt-4.1-mini, . gpt-4.1-nanoo3.

Verwenden Sie die Antwort-API, wenn Sie möchten:

  • Erstellen Sie Unterhaltungsbilderfahrungen mit GPT Image.
  • Aktivieren Sie die iterative Bildbearbeitung mittels mehrstufiger Aufforderungen.
  • Streamen Sie teilbildergebnisse während der Generierung, um eine reibungslosere Benutzererfahrung zu erzielen.

Generieren eines Images

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

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

client = AzureOpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  azure_ad_token_provider=token_provider,
  api_version="preview",
  default_headers={"x-ms-oai-image-generation-deployment":"YOUR-GPT-IMAGE1-DEPLOYMENT-NAME"}
)

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

Sie können Mehrfachbildgenerierung durchführen, indem Sie die Ausgabe der Bildgenerierung in nachfolgenden Abrufen verwenden oder einfach 1previous_response_id verwenden.

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

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

client = AzureOpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  azure_ad_token_provider=token_provider,
  api_version="preview",
  default_headers={"x-ms-oai-image-generation-deployment":"YOUR-GPT-IMAGE1-DEPLOYMENT-NAME"}
)

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("cat_and_otter.png", "wb") as f:
        f.write(base64.b64decode(image_base64))


# Follow up

response_followup = client.responses.create(
    model="gpt-4.1-mini",
    previous_response_id=response.id,
    input="Now make it look realistic",
    tools=[{"type": "image_generation"}],
)

image_data_followup = [
    output.result
    for output in response_followup.output
    if output.type == "image_generation_call"
]

if image_data_followup:
    image_base64 = image_data_followup[0]
    with open("cat_and_otter_realistic.png", "wb") as f:
        f.write(base64.b64decode(image_base64))

Streamen

Sie können Teilbilder mithilfe der Antwort-API streamen. Dies partial_images kann verwendet werden, um 1-3 Teilbilder zu empfangen.

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

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

client = AzureOpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  azure_ad_token_provider=token_provider,
  api_version="preview",
  default_headers={"x-ms-oai-image-generation-deployment":"YOUR-GPT-IMAGE1-DEPLOYMENT-NAME"}
)

stream = client.responses.create(
    model="gpt-4.1",
    input="Draw a gorgeous image of a river made of white owl feathers, snaking its way through a serene winter landscape",
    stream=True,
    tools=[{"type": "image_generation", "partial_images": 2}],
)

for event in stream:
    if event.type == "response.image_generation_call.partial_image":
        idx = event.partial_image_index
        image_base64 = event.partial_image_b64
        image_bytes = base64.b64decode(image_base64)
        with open(f"river{idx}.png", "wb") as f:
            f.write(image_bytes)

Bearbeiten von Bildern

from openai import AzureOpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider
import base64

client = AzureOpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  azure_ad_token_provider=token_provider,
  api_version="preview",
  default_headers={"x-ms-oai-image-generation-deployment":"YOUR-GPT-IMAGE1-DEPLOYMENT-NAME"}
)

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

def encode_image(file_path):
    with open(file_path, "rb") as f:
        base64_image = base64.b64encode(f.read()).decode("utf-8")
    return base64_image

prompt = """Generate a photorealistic image of a gift basket on a white background 
labeled 'Relax & Unwind' with a ribbon and handwriting-like font, 
containing all the items in the reference pictures."""

base64_image1 = encode_image("image1.png")
base64_image2 = encode_image("image2.png")
file_id1 = create_file("image3.png")
file_id2 = create_file("image4.png")

response = client.responses.create(
    model="gpt-4.1",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": prompt},
                {
                    "type": "input_image",
                    "image_url": f"data:image/jpeg;base64,{base64_image1}",
                },
                {
                    "type": "input_image",
                    "image_url": f"data:image/jpeg;base64,{base64_image2}",
                },
                {
                    "type": "input_image",
                    "file_id": file_id1,
                },
                {
                    "type": "input_image",
                    "file_id": file_id2,
                }
            ],
        }
    ],
    tools=[{"type": "image_generation"}],
)

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

image_data = [output.result for output in image_generation_calls]

if image_data:
    image_base64 = image_data[0]
    with open("gift-basket.png", "wb") as f:
        f.write(base64.b64decode(image_base64))
else:
    print(response.output.content)

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.