Verwenden der Azure OpenAI-Antwort-API

Verwenden Sie die Azure OpenAI-Antwort-API, um Zustands-, Multi-Turn-Antworten zu generieren. Es vereint Funktionen von Chatabschlussen und der Assistenten-API in einer einheitlichen Benutzeroberfläche. Die Antwort-API unterstützt auch das computer-use-preview Modell, das die Computernutzung ermöglicht.

Voraussetzungen

• Ein bereitgestelltes Azure OpenAI-Modell
• Eine Authentifizierungsmethode:
  • API-Schlüssel (z. B AZURE_OPENAI_API_KEY. ) oder
  • Microsoft Entra ID (empfohlen).

Installieren oder Aktualisieren des OpenAI-Pakets

Installieren oder aktualisieren Sie das OpenAI-Python-Paket.

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

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

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

print(response.model_dump_json(indent=2)) 

curl -X POST 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-4o",
     "input": "This is a test"
    }'

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": "gpt-4.1-nano",
     "input": "This is a test"
    }'

{
  "id": "resp_67cb32528d6881909eb2859a55e18a85",
  "created_at": 1741369938.0,
  "error": null,
  "incomplete_details": null,
  "instructions": null,
  "metadata": {},
  "model": "gpt-4o-2024-08-06",
  "object": "response",
  "output": [
    {
      "id": "msg_67cb3252cfac8190865744873aada798",
      "content": [
        {
          "annotations": [],
          "text": "Great! How can I help you today?",
          "type": "output_text"
        }
      ],
      "role": "assistant",
      "status": null,
      "type": "message"
    }
  ],
  "output_text": "Great! How can I help you today?",
  "parallel_tool_calls": null,
  "temperature": 1.0,
  "tool_choice": null,
  "tools": [],
  "top_p": 1.0,
  "max_output_tokens": null,
  "previous_response_id": null,
  "reasoning": null,
  "status": "completed",
  "text": null,
  "truncation": null,
  "usage": {
    "input_tokens": 20,
    "output_tokens": 11,
    "output_tokens_details": {
      "reasoning_tokens": 0
    },
    "total_tokens": 31
  },
  "user": null,
  "reasoning_effort": null
}

Abrufen einer Antwort

So rufen Sie eine Antwort von einem vorherigen Aufruf der Antwort-API ab.

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

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

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

print(response.model_dump_json(indent=2))

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

curl -X GET https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses/{response_id} \
  -H "Content-Type: application/json" \
  -H "api-key: $AZURE_OPENAI_API_KEY" 

{
  "id": "resp_67cb61fa3a448190bcf2c42d96f0d1a8",
  "created_at": 1741382138.0,
  "error": null,
  "incomplete_details": null,
  "instructions": null,
  "metadata": {},
  "model": "gpt-4o-2024-08-06",
  "object": "response",
  "output": [
    {
      "id": "msg_67cb61fa95588190baf22ffbdbbaaa9d",
      "content": [
        {
          "annotations": [],
          "text": "Hello! How can I assist you today?",
          "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": null,
  "reasoning": null,
  "status": "completed",
  "text": null,
  "truncation": null,
  "usage": {
    "input_tokens": 20,
    "output_tokens": 11,
    "output_tokens_details": {
      "reasoning_tokens": 0
    },
    "total_tokens": 31
  },
  "user": null,
  "reasoning_effort": null
}

Antwort löschen

Standardmäßig werden Antwortdaten 30 Tage lang aufbewahrt. Rufen Sie client.responses.delete("{response_id}") auf, um eine gespeicherte Antwort zu löschen.

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 aus der Ausgabe, dass, obwohl wir die erste Eingabefrage nie mit dem second_response API-Aufruf geteilt haben, das previous_response_id Modell durch die Übergabe den vollständigen Kontext der vorherigen Frage und Antwort für die Beantwortung der neuen Frage hat.

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:

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

Komprimen einer Antwort

Mit der Komprimierung können Sie das an das Modell gesendete Kontextfenster verkleinern und dabei die wesentlichen Informationen für das Verständnis des Modells beibehalten.

Komprimieren unter Verwendung der zurückgegebenen Elemente

Sie können alle elemente komprimieren, die von vorherigen Anforderungen zurückgegeben werden, z. B. Gründe, Nachricht, Funktionsaufruf usw.

curl 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": "gpt-4.1",
        "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"
          }
        ]
    }'

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_response = client.responses.compact(
    model="gpt-4.1",
    input=[
    {
        "role": "user",
        "content": "Create a simple landing page for a dog petting cafe.",
    },
    # All items returned from previous requests are included here, like reasoning, message, function call, etc.
    {
        "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",
    },
    ]
)
# Pass the compacted_response.output as input to the next request
print(compacted_response)

Komprimieren mit vorheriger Antwort-ID

Sie können auch eine vorherige Antwort-ID verwenden, um zu komprimieren.

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

# Get back a full response
initial_response = client.responses.create(
        model="gpt-4.1",
        input="What is the size of France?"
    )

print(f"Initial Response: {initial_response.output_text}")

# Now compact the response
compacted_response = client.responses.compact(
    model="gpt-4.1",
    previous_response_id=initial_response.id
)

# use the compacted response in a follow up
followup_response = client.responses.create(
    model="gpt-4.1",
    input=[
        *compacted_response.output,
        {"role": "user", "content": "And what is the capital/major city"}
    ]
)
print(f"Follow-up Response: {followup_response.output_text}")

Serverseitige Komprimierung

Sie können auch die serverseitige Komprimierung direkt in Antworten (POST /responses oder client.responses.create) verwenden, indem Sie context_management mit einem compact_threshold einstellen.

• Wenn die Anzahl des Ausgabetokens den konfigurierten Schwellenwert überschreitet, wird die Antwort-API automatisch komprimiert.
• In diesem Modus müssen Sie nicht separat anrufen /responses/compact .
• Die Antwort enthält ein verschlüsseltes Komprimierungselement.
• Die serverseitige Komprimierung funktioniert, wenn Sie "store=false" bei der Erstellung von Antwortanfragen festlegen.

Das Komprimierungselement trägt den wesentlichen vorherigen Zustand und die Überlegungen in die nächste Runde, indem weniger Token verwendet werden. Es ist undurchsichtig und nicht für die menschliche Lesbarkeit vorgesehen.

Wenn Sie eine zustandslose Eingabearray-Verkettung verwenden, fügen Sie Ausgabeelemente wie gewohnt an. Wenn Sie previous_response_id verwenden, übergeben Sie jeweils nur die neue Benutzernachricht. In beiden Mustern trägt das Komprimierungselement den für das nächste Fenster erforderlichen Kontext.

Fluss

1. Rufen Sie responses wie gewohnt an. context_management hinzufügen compact_threshold, um die serverseitige Komprimierung zu aktivieren.
2. Wenn die Ausgabe den Schwellenwert überschreitet, löst der Dienst die Komprimierung aus, emittiert ein Komprimierungselement im Ausgabedatenstrom und schneidet den Kontext ab, bevor die Rückschlüsse fortgesetzt werden.
3. Führen Sie die Unterhaltung mit einem der folgenden Muster weiter.
   1. Zustandslose Eingabearray-Verkettung: Es werden Ausgabeelemente, darunter Verdichtungselemente, an das nächste Eingabearray angefügt.
   2. previous_response_id Verkettung: Übergeben Sie bei jedem Schritt nur die neue Benutzernachricht und führen Sie die neueste Antwort-ID weiter.

Beispiel

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

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

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

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

Funktionsaufrufe

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

Container

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 "container": { "type": "auto", "file_ids": ["file-1", "file-2"] } zum Erstellen eines Containers beim Erstellen eines neuen Antwortobjekts in der Toolkonfiguration an. Dadurch wird automatisch ein neuer Container erstellt oder ein aktiver Container aus einem vorherigen code_interpreter_call im Kontext des Modells wiederverwendet. Die code_interpreter_call in der Ausgabe der API enthält das container_id, das generiert wurde. 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

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

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

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.

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 Problemumgehung sollen 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

Ausgabe:

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

Zulassungen

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

Authentifizierung

Im Gegensatz zum GitHub MCP-Servers erfordern die meisten REMOTE-MCP-Server eine 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 lang andauernde Aufgaben asynchron mit Modellen wie o3 und o1-pro ausführen. 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. Fahren Sie mit der Abfrage fort, solange der Status auf "Warteschlange" oder "in Bearbeitung" gesetzt ist. Sobald die Antwort einen endgültigen (Terminal)-Zustand erreicht hat, steht sie für den Abruf zur Verfügung.

curl -X 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 liefern 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"]

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

Verschlüsselte Begründungselemente

Wenn Sie die Responses-API im zustandslosen Modus verwenden, indem Sie store auf 'false' setzen, müssen Sie den Kontext der Begründung über Gesprächswechsel hinweg beibehalten. Fügen Sie dazu verschlüsselte Begründungselemente in Ihre API-Anforderungen ein.

Fügen Sie reasoning.encrypted_content zum include-Parameter in Ihrer Anforderung hinzu, um Begründungselemente über Gesprächsrunden 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 (Vorschau)

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: Anzeige von Teilbildausgaben während der Generierung, um die wahrgenommene Latenz zu verbessern.
• Flexible Eingaben: Akzeptieren Sie Bilddatei-IDs als Eingaben zusätzlich zu unformatierten Bildbytes.

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://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":"gpt-image-1.5", "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))

Reasoning-Modelle

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

Computerverwendung

Die Verwendung von Computern mit Playwright wurde in den speziellen Computerverwendungsmodell-Leitfaden verschoben.

Antwort-API

API-Unterstützung

• v1-API ist für den Zugriff auf die neuesten Features erforderlich.

Verfügbarkeit der Region

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

• australiaeast
• brasiliensouth
• kanadacentral
• canadaeast
• eastus
• Eastus2
• francecentral
• Deutschland Westzentral
• Italien-Nord
• Japaneast
• koreacentral
• Northcentralus
• norwayeast
• Polenzentral
• südafricanorth
• southcentralus
• Südostasien
• Südindien
• spaniencentral
• schwedencentral
• schweiznorth
• uaenorth
• uksouth
• Westus
• westus3

Modellunterstützung

• gpt-chat-latest (Version: 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 (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)
• 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)

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.

Referenzdokumentation

• Referenzdokumentation zur Antwort-API

Problembehandlung

• 401/403: Wenn Sie Microsoft Entra ID verwenden, überprüfen Sie, ob Ihr Token auf https://ai.azure.com/.default festgelegt ist. Wenn Sie einen API-Schlüssel verwenden, bestätigen Sie, dass Sie den richtigen Schlüssel für die Ressource verwenden.
• 404: Bestätigen Sie, dass model mit Ihrem Bereitstellungsnamen übereinstimmt.

Verwandte Inhalte

• API-Versionslebenszyklus
• Azure OpenAI REST API-Referenz
• Computerverwendung