Udostępnij za pomocą

API odpowiedzi Azure OpenAI

Interfejs API odpowiedzi to nowy stanowy interfejs API z poziomu usługi Azure OpenAI. Łączy to najlepsze możliwości z API uzupełniania czatów i API asystentów w jednym ujednoliconym środowisku. Interfejs API odpowiedzi dodaje obsługę nowego modelu computer-use-preview, który umożliwia korzystanie z komputera.

Odpowiedzi API

Obsługa interfejsu API

Dostępność w danym regionie

Interfejs API odpowiedzi jest obecnie dostępny w następujących regionach:

  • australiaeast
  • Brazylia Południe
  • Kanada Środkowa
  • wschód Kanady
  • eastus
  • eastus2
  • francecentral
  • Niemcy Zachodnio-Środkowe
  • północne Włochy
  • japaneast
  • koreacentral
  • northcentralus
  • norwayeast
  • polandcentral
  • southafricanorth
  • southcentralus
  • southeastasia
  • southindia
  • spaincentral
  • swedencentral
  • switzerlandnorth
  • uaenorth
  • uksouth
  • westus
  • westus3

Obsługa modelu

  • gpt-5.1 (Wersja: 2025-11-13)
  • gpt-5.1-chat (Wersja: 2025-11-13)
  • gpt-5.1-codex (Wersja: 2025-11-13)
  • gpt-5.1-codex-mini (Wersja: 2025-11-13)
  • gpt-5-pro (Wersja: 2025-10-06)
  • gpt-5-codex (Wersja: 2025-09-11)
  • gpt-5 (Wersja: 2025-08-07)
  • gpt-5-mini (Wersja: 2025-08-07)
  • gpt-5-nano (Wersja: 2025-08-07)
  • gpt-5-chat (Wersja: 2025-08-07)
  • gpt-5-chat (Wersja: 2025-10-03)
  • gpt-5-codex (Wersja: 2025-09-15)
  • gpt-4o(Wersje: 2024-11-20, , 2024-08-062024-05-13)
  • gpt-4o-mini (Wersja: 2024-07-18)
  • computer-use-preview
  • gpt-4.1 (Wersja: 2025-04-14)
  • gpt-4.1-nano (Wersja: 2025-04-14)
  • gpt-4.1-mini (Wersja: 2025-04-14)
  • gpt-image-1 (Wersja: 2025-04-15)
  • gpt-image-1-mini (Wersja: 2025-10-06)
  • o1 (Wersja: 2024-12-17)
  • o3-mini (Wersja: 2025-01-31)
  • o3 (Wersja: 2025-04-16)
  • o4-mini (Wersja: 2025-04-16)

Nie każdy model jest dostępny w regionach obsługiwanych przez API odpowiedzi. Sprawdź stronę modeli pod kątem dostępności regionu modelu.

Note

Obecnie brak wsparcia:

  • Narzędzie wyszukiwania w Internecie
  • Generowanie obrazów przy użyciu wielokrotnej edycji i przesyłania strumieniowego — wkrótce
  • Nie można przesyłać obrazów jako plików, a następnie odwoływać się do nich jako do danych wejściowych. Wkrótce.

Istnieje znany problem z następującymi elementami:

  • Plik PDF jako plik wejściowy jest teraz obsługiwany, ale ustawienie przeznaczenia przekazywania plików na user_data nie jest obecnie obsługiwane.
  • Problemy z wydajnością, gdy tryb w tle jest używany z przesyłaniem strumieniowym. Oczekuje się, że problem zostanie wkrótce rozwiązany.

Dokumentacja referencyjna

Rozpoczęcie pracy z interfejsem API odpowiedzi

Aby uzyskać dostęp do komend interfejsu API odpowiedzi, należy zaktualizować wersję biblioteki OpenAI.

pip install --upgrade openai

Generowanie odpowiedzi tekstowej

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

Używaj kluczy interfejsu API z ostrożnością. Nie dołączaj klucza interfejsu API bezpośrednio do kodu i nigdy nie publikuj go publicznie. Jeśli używasz klucza interfejsu API, zapisz go bezpiecznie w usłudze Azure Key Vault. Aby uzyskać więcej informacji na temat bezpiecznego używania kluczy interfejsu API w aplikacjach, zobacz Klucze interfejsu API w usłudze Azure Key Vault.

Aby uzyskać więcej informacji na temat zabezpieczeń usług sztucznej inteligencji, zobacz Uwierzytelnianie żądań w usługach Azure AI.

Pobieranie odpowiedzi

Aby pobrać odpowiedź z poprzedniego wywołania API odpowiedzi.

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

Używaj kluczy interfejsu API z ostrożnością. Nie dołączaj klucza interfejsu API bezpośrednio do kodu i nigdy nie publikuj go publicznie. Jeśli używasz klucza interfejsu API, zapisz go bezpiecznie w usłudze Azure Key Vault. Aby uzyskać więcej informacji na temat bezpiecznego używania kluczy interfejsu API w aplikacjach, zobacz Klucze interfejsu API w usłudze Azure Key Vault.

Aby uzyskać więcej informacji na temat zabezpieczeń usług sztucznej inteligencji, zobacz Uwierzytelnianie żądań w usługach Azure AI.

Usuń odpowiedź

Domyślnie dane odpowiedzi są przechowywane przez 30 dni. Aby usunąć odpowiedź, możesz użyć polecenia 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)

Łączenie łańcuchów odpowiedzi

Odpowiedzi można połączyć ze sobą, przekazując element response.id z poprzedniej odpowiedzi do parametru previous_response_id .

import os
from openai import OpenAI

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

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

Zauważ z danych wyjściowych, że mimo że nigdy nie udostępniliśmy pierwszego pytania wejściowego wywołaniu interfejsu second_response API, przekazując previous_response_id, model uzyskuje pełny kontekst poprzedniego pytania i odpowiedzi, aby odpowiedzieć na nowe pytanie.

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
}

Ręczne łączenie odpowiedzi

Alternatywnie możesz ręcznie połączyć odpowiedzi, korzystając z poniższej metody:

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

Wywoływanie funkcji

Interfejs API odpowiedzi obsługuje wywoływanie funkcji.

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

Interpreter kodów

Narzędzie Interpretera Kodu umożliwia modelom pisanie i wykonywanie kodu w języku Python w bezpiecznym, izolowanym środowisku. Obsługuje szereg zaawansowanych zadań, w tym:

  • Przetwarzanie plików o różnych formatach danych i strukturach
  • Generowanie plików zawierających dane i wizualizacje (na przykład grafy)
  • Iteracyjne pisanie i uruchamianie kodu w celu rozwiązania problemów — modele mogą debugować i ponawiać próbę kodu do momentu pomyślnego
  • Ulepszanie rozumowania wizualnego w obsługiwanych modelach (na przykład o3, o4-mini) przez włączenie przekształceń obrazów, takich jak przycinanie, powiększanie i obracanie
  • To narzędzie jest szczególnie przydatne w scenariuszach obejmujących analizę danych, obliczenia matematyczne i generowanie kodu.
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

Z interpreterem kodów wiążą się dodatkowe opłaty poza opłatami opartymi na tokenach za użycie usługi Azure OpenAI. Jeśli interfejs API odpowiedzi wywołuje interpreter kodu jednocześnie w dwóch różnych wątkach, tworzone są dwie sesje interpretera kodu. Każda sesja jest domyślnie aktywna przez 1 godzinę z limitem czasu bezczynności 20 minut.

Narzędzie interpretacji kodu wymaga kontenera — w pełni odizolowanej maszynie wirtualnej w trybie piaskownicy, na której modelu może wykonywać kod języka Python. Kontenery mogą zawierać przekazane pliki lub pliki wygenerowane podczas wykonywania.

Aby utworzyć kontener, określ "container": { "type": "auto", "file_ids": ["file-1", "file-2"] } w konfiguracji narzędzia podczas tworzenia nowego obiektu Response. Spowoduje to automatyczne utworzenie nowego kontenera lub ponowne użycie aktywnego kontenera z poprzedniego wywołania code_interpreter_call w kontekście modelu. W danych wyjściowych API wartość code_interpreter_call będzie zawierać wygenerowaną wartość container_id. Ten kontener wygasa, jeśli nie jest używany przez 20 minut.

Dane wejściowe i wyjściowe pliku

Podczas uruchamiania interpretera kodu model może utworzyć własne pliki. Jeśli na przykład zostanie wyświetlony monit o utworzenie wykresu lub utworzenie woluminu CSV, spowoduje to utworzenie tych obrazów bezpośrednio w kontenerze. Przytacza te pliki w adnotacjach kolejnej wiadomości.

Wszystkie pliki w danych wejściowych modelu są automatycznie przekazywane do kontenera. Nie trzeba jawnie przekazywać go do kontenera.

Obsługiwane pliki

Format pliku typ MIME
.c text/x-c
.cs text/x-csharp
.cpp text/x-c++
.csv tekst/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 lub "text/xml"
.zip application/zip

Wyświetlanie listy elementów wejściowych

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

Dane wejściowe obrazu

Adres URL obrazu

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)

Obraz zakodowany w formacie Base64

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)

Wejście plików

Modele z możliwościami przetwarzania obrazów obsługują dane wejściowe w formacie PDF. Pliki PDF mogą być dostarczane jako dane zakodowane w formacie Base64 lub jako identyfikatory plików. Aby ułatwić modelom interpretowanie zawartości PDF, wyodrębniony tekst i obraz każdej strony są uwzględniane w kontekście modelu. Jest to przydatne, gdy kluczowe informacje są przekazywane za pośrednictwem diagramów lub zawartości nietekstowej.

Note

  • Cały wyodrębniony tekst i obrazy są umieszczane w kontekście modelu. Upewnij się, że rozumiesz wpływ cen i użycia tokenów na używanie plików PDF jako danych wejściowych.

  • W pojedynczym żądaniu interfejsu API rozmiar zawartości przekazanej przez wiele danych wejściowych (plików) powinien mieścić się w długości kontekstu modelu.

  • Tylko modele, które obsługują zarówno dane wejściowe tekstu, jak i obrazów, mogą akceptować pliki PDF jako dane wejściowe.

  • "purpose z user_data nie jest obecnie wspierane." Jako tymczasowe rozwiązanie należy ustawić przeznaczenie na assistants.

Konwertowanie formatu PDF na format Base64 i analizowanie

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)

Przekazywanie plików PDF i analizowanie

Przekaż plik PDF. "purpose z user_data nie jest obecnie wspierane." Aby obejść ten problem, należy ustawić cel na assistants.

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
}

Następnie użyjesz wartości id i przekażesz je do modelu do przetwarzania w obszarze 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"
                    }
                ]
            }
        ]
    }'

Używanie zdalnych serwerów MCP

Możliwości modelu można rozszerzyć, łącząc go z narzędziami hostowanymi na zdalnych serwerach protokołu KONTEKSTU modelu (MCP). Te serwery są obsługiwane przez deweloperów i organizacje i udostępniają narzędzia, do których można uzyskiwać dostęp przez klientów kompatybilnych z MCP, takich jak API Responses.

Model Context Protocol (MCP) to otwarty standard, który definiuje sposób, w jaki aplikacje udostępniają narzędzia i dane kontekstowe dużym modelom językowym (LLMs). Umożliwia spójną, skalowalną integrację narzędzi zewnętrznych z przepływami pracy modelu.

W poniższym przykładzie pokazano, jak używać fikcyjnego serwera MCP do wykonywania zapytań o informacje o interfejsie API REST platformy Azure. Dzięki temu model może pobierać zawartość repozytorium i dokonywać rozumowania nad nią w czasie rzeczywistym.

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)

Narzędzie MCP działa tylko w interfejsie API odpowiedzi i jest dostępne we wszystkich nowszych modelach (gpt-4o, gpt-4.1 i naszych modelach rozumowania). W przypadku korzystania z narzędzia MCP płacisz tylko za tokeny używane podczas importowania definicji narzędzi lub wykonywania wywołań narzędzi — nie są naliczane żadne dodatkowe opłaty.

Approvals

Domyślnie API odpowiedzi wymaga jawnego zatwierdzenia przed udostępnieniem danych zdalnemu serwerowi MCP. Ten krok zatwierdzania pomaga zapewnić przejrzystość i zapewnia kontrolę nad tym, jakie informacje są wysyłane zewnętrznie.

Zalecamy przejrzenie wszystkich danych udostępnianych zdalnym serwerom MCP i opcjonalne rejestrowanie ich na potrzeby inspekcji.

Gdy zatwierdzenie jest wymagane, w odpowiedzi model zwraca element mcp_approval_request. Ten obiekt zawiera szczegóły oczekującego żądania i umożliwia inspekcję lub modyfikowanie danych przed kontynuowaniem.

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

Aby kontynuować zdalne wywołanie MCP, należy odpowiedzieć na żądanie zatwierdzenia, tworząc nowy obiekt odpowiedzi zawierający element mcp_approval_response. Ten obiekt potwierdza zamiar umożliwienia modelowi wysyłania określonych danych do zdalnego serwera MCP.

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

  • Klient MCP w interfejsie API odpowiedzi wymaga protokołu TLS 1.2 lub nowszego.
  • wzajemne TLS (mTLS) nie jest obecnie obsługiwane.
  • Tagi usług platformy Azure nie są obecnie obsługiwane w przypadku ruchu klienta MCP.

W przeciwieństwie do serwera MCP usługi GitHub większość zdalnych serwerów MCP wymaga uwierzytelniania. Narzędzie MCP w interfejsie API odpowiedzi obsługuje nagłówki niestandardowe, co umożliwia bezpieczne łączenie się z tymi serwerami przy użyciu wymaganego schematu uwierzytelniania.

Możesz określić nagłówki, takie jak klucze interfejsu API, tokeny dostępu OAuth lub inne poświadczenia bezpośrednio w swoim żądaniu. Najczęściej używanym nagłówkiem jest nagłówek Authorization.

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)

Zadania w tle

Tryb w tle umożliwia asynchroniczne uruchamianie długotrwałych zadań przy użyciu modeli, takich jak o3 i o1-pro. Jest to szczególnie przydatne w przypadku złożonych zadań rozumowania, które mogą potrwać kilka minut, takich jak te obsługiwane przez agentów, takich jak Codex lub Deep Research.

Włączając tryb w tle, można uniknąć przekroczenia limitu czasu i zachować niezawodność podczas operacji rozszerzonych. Gdy żądanie jest wysyłane za pomocą "background": true, zadanie jest przetwarzane asynchronicznie i można sondować jego stan z czasem.

Aby uruchomić zadanie w tle, ustaw parametr w tle na wartość true w żądaniu:

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)

Użyj punktu końcowego GET aby sprawdzić stan odpowiedzi w tle. Kontynuuj sprawdzanie, gdy stan jest w kolejce lub w toku. Po osiągnięciu stanu końcowego (terminalu) odpowiedź będzie dostępna do pobrania.

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

Zadanie w tle w toku można anulować przy użyciu punktu końcowego cancel . Anulowanie jest idempotentne — kolejne wywołania będą zwracać końcowy obiekt odpowiedzi.

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)

Strumieniowanie odpowiedzi w tle

Aby przesłać strumieniowo odpowiedź w tle, ustaw wartość zarówno, background jak i stream na true. Jest to przydatne, jeśli chcesz wznowić przesyłanie strumieniowe później w przypadku porzuconego połączenia. Użyj numer_sekwencji z każdego zdarzenia, aby śledzić położenie.

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

Odpowiedzi w tle mają obecnie większe opóźnienie od pierwszego tokenu niż odpowiedzi synchroniczne. W toku wprowadzono ulepszenia w celu zmniejszenia tej luki.

Limitations

  • Tryb tła wymaga store=true. Żądania bezstanowe nie są obsługiwane.
  • Przesyłanie strumieniowe można wznowić tylko wtedy, gdy oryginalne żądanie zawiera element stream=true.
  • Aby anulować synchroniczną odpowiedź, zakończ połączenie bezpośrednio.

Wznawianie przesyłania strumieniowego z określonego punktu

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"

Zaszyfrowane elementy rozumowania

W przypadku korzystania z interfejsu API odpowiedzi w trybie bezstanowym — przez ustawienie wartości store na false lub gdy organizacja jest zarejestrowana w programie zerowego przechowywania danych — nadal należy zachować kontekst rozumowania w kolejnych odpowiedziach dialogu. W tym celu uwzględnij zaszyfrowane elementy rozumowania w żądaniach interfejsu API.

Aby zachować elementy logiczne pomiędzy etapami, dodaj reasoning.encrypted_content do parametru include w żądaniu. Dzięki temu odpowiedź zawiera zaszyfrowaną wersję trasy rozumowania, którą można przekazać w przyszłych żądaniach.

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"]
  }'

Generowanie obrazów (wersja zapoznawcza)

Interfejs API odpowiedzi umożliwia generowanie obrazów w ramach konwersacji i wieloetapowych przepływów pracy. Obsługuje wejścia i wyjścia obrazów w ramach kontekstu oraz zawiera wbudowane narzędzia do tworzenia i edycji obrazów.

W porównaniu z samodzielnym API obrazów, API odpowiedzi oferuje kilka zalet.

  • Przesyłanie strumieniowe: wyświetlanie częściowych danych wyjściowych obrazu w trakcie generowania w celu zwiększenia widocznego opóźnienia.
  • Elastyczne dane wejściowe: akceptuj identyfikatory plików obrazów jako dane wejściowe oprócz nieprzetworzonych bajtów obrazów.

Note

Narzędzie generowania obrazów w API Odpowiedzi jest obsługiwane tylko przez modele z serii gpt-image-1. Ten model można jednak wywołać z tej listy obsługiwanych modeli — gpt-4o, , gpt-4o-minigpt-4.1, gpt-4.1-minigpt-4.1-nano, , o3gpt-5 , i gpt-5.1 modeli serii.

Narzędzie interfejsu API do generowania obrazów w odpowiedziach nie obsługuje obecnie trybu przesyłania strumieniowego. Aby użyć trybu przesyłania strumieniowego i wygenerować częściowe obrazy, wywołaj interfejs API generowania obrazów bezpośrednio, nie korzystając z interfejsu API odpowiedzi.

Użyj API odpowiedzi, aby tworzyć konwersacyjne doświadczenia obrazowe z wykorzystaniem GPT Image.

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

Modele rozumowania

Aby zapoznać się z przykładami używania modeli rozumowania z interfejsem API odpowiedzi, zobacz przewodnik po modelach rozumowania.

Korzystanie z komputera

Użycie komputera z Playwright zostało przeniesione do przewodnika po dedykowanym modelu użytkowania komputera

  • Last updated on