Partager via

API Azure OpenAI Responses

L’API Réponses est une nouvelle API avec état d’Azure OpenAI. Il réunit les meilleures fonctionnalités des achèvements de conversation et de l’API Assistants dans une expérience unifiée. L’API Responses ajoute également la prise en charge du nouveau modèle computer-use-preview qui alimente la fonctionnalité d’Utilisation d’ordinateur.

API Responses

Prise en charge des API

Disponibilité dans les régions

L’API réponses est actuellement disponible dans les régions suivantes :

  • australiaeast
  • brazilsouth
  • canadacentral
  • canadaeast
  • eastus
  • eastus2
  • francecentral
  • germanywestcentral
  • italynorth
  • japaneast
  • koreacentral
  • northcentralus
  • norwayeast
  • polandcentral
  • southafricanorth
  • southcentralus
  • southeastasia
  • southindia
  • spaincentral
  • swedencentral
  • switzerlandnorth
  • uaenorth
  • uksouth
  • westus
  • westus3

Prise en charge des modèles

  • 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 (Versions : 2024-11-20, 2024-08-06, 2024-05-13)
  • gpt-4o-mini (Version : 2024-07-18)
  • computer-use-preview
  • gpt-4.1 (Version : 2025-04-14)
  • gpt-4.1-nano (Version : 2025-04-14)
  • gpt-4.1-mini (Version : 2025-04-14)
  • gpt-image-1 (Version : 2025-04-15)
  • gpt-image-1-mini (Version : 2025-10-06)
  • o1 (Version : 2024-12-17)
  • o3-mini (Version : 2025-01-31)
  • o3 (Version : 2025-04-16)
  • o4-mini (Version : 2025-04-16)

Tous les modèles ne sont pas disponibles dans les régions prises en charge par l’API de réponses. Consultez la page modèles pour la disponibilité de la région de modèle.

Note

Non pris en charge actuellement :

  • Compactage avec /responses/compact
  • Génération d’images à l’aide de l’édition en plusieurs tours et de la diffusion en continu.
  • Les images ne peuvent pas être chargées en tant que fichier, puis référencées comme entrée.

Voici un problème connu :

  • Le fichier PDF en tant que fichier d’entrée est désormais pris en charge, mais la définition de l’objectif user_data de chargement de fichier n’est pas prise en charge actuellement.
  • Problèmes de performances lorsque le mode en arrière-plan est utilisé avec la diffusion en continu. Le problème devrait bientôt être résolu.

Documentation de référence

Premiers pas avec l’API de réponses

Pour accéder aux commandes de l’API réponses, vous devez mettre à niveau votre version de la bibliothèque OpenAI.

pip install --upgrade openai

Générer une réponse de texte

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

Utilisez les clés API avec précaution. N'incluez pas la clé API directement dans votre code et ne la diffusez jamais publiquement. Si vous utilisez une clé API, stockez-la en lieu sûr dans Azure Key Vault. Pour plus d’informations sur l’utilisation sécurisée des clés API dans vos applications, consultez Clés API avec Azure Key Vault.

Pour plus d’informations sur la sécurité des services IA, consultez Authentifier les demandes auprès d’Azure AI services.

Récupérer une réponse

Pour récupérer une réponse à partir d’un appel précédent à l’API de réponses.

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

Utilisez les clés API avec précaution. N'incluez pas la clé API directement dans votre code et ne la diffusez jamais publiquement. Si vous utilisez une clé API, stockez-la en lieu sûr dans Azure Key Vault. Pour plus d’informations sur l’utilisation sécurisée des clés API dans vos applications, consultez Clés API avec Azure Key Vault.

Pour plus d’informations sur la sécurité des services IA, consultez Authentifier les demandes auprès d’Azure AI services.

Supprimer la réponse

Par défaut, les données de réponse sont conservées pendant 30 jours. Pour supprimer une réponse, vous pouvez utiliser 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)

Chaînage des réponses

Vous pouvez chaîner les réponses ensemble en passant la response.id réponse précédente au previous_response_id paramètre.

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

Notez à partir de la sortie que bien que nous n'ayons jamais partagé la première question d'entrée avec l'appel second_response d'API, en passant par previous_response_id, le modèle dispose du contexte complet de la question précédente et de la réponse pour répondre à la nouvelle question.

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
}

Chaînage des réponses manuellement

Vous pouvez également chaîner manuellement des réponses à l’aide de la méthode ci-dessous :

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

Appeler une fonction

L’API Réponses prend en charge l’appel de fonction.

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

Interpréteur de code

L’outil Interpréteur de code permet aux modèles d’écrire et d’exécuter du code Python dans un environnement sécurisé et en bac à sable. Il prend en charge une gamme de tâches avancées, notamment :

  • Traitement de fichiers avec des formats et structures de données variés
  • Génération de fichiers incluant des données et des visualisations (par exemple, des graphiques)
  • Écriture itérative et exécution de code pour résoudre les problèmes : les modèles peuvent déboguer et réessayer du code jusqu’à ce qu’ils réussissent
  • Amélioration du raisonnement visuel dans les modèles pris en charge (par exemple, o3, o4-mini) en activant des transformations d’image telles que rognage, zoom et rotation
  • Cet outil est particulièrement utile pour les scénarios impliquant l’analyse des données, le calcul mathématique et la génération de code.
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

L’Interpréteur de code comporte des frais supplémentaires au-delà des frais basés sur le jeton pour l’utilisation d’Azure OpenAI. Si votre API Réponses appelle l’interpréteur de code simultanément dans deux threads différents, deux sessions d’interpréteur de code sont créées. Chaque session est active par défaut pendant 1 heure avec un délai d’inactivité de 20 minutes.

L’outil Interpréteur de code nécessite un conteneur , une machine virtuelle entièrement en bac à sable dans laquelle le modèle peut exécuter du code Python. Les conteneurs peuvent inclure des fichiers chargés ou des fichiers générés pendant l’exécution.

Pour créer un conteneur, spécifiez "container": { "type": "auto", "file_ids": ["file-1", "file-2"] } dans la configuration de l’outil lors de la création d’un objet Response. Cela crée automatiquement un conteneur ou réutilise un conteneur actif à partir d’un code_interpreter_call précédent dans le contexte du modèle. La code_interpreter_call dans la sortie de l’API contiendra le container_id qui a été généré. Ce conteneur expire s’il n’est pas utilisé pendant 20 minutes.

Entrées et sorties de fichier

Lors de l’exécution de l’interpréteur de code, le modèle peut créer ses propres fichiers. Par exemple, si vous lui demandez de construire un tracé ou de créer un fichier CSV, il crée ces images directement sur votre conteneur. Il cite ces fichiers dans les annotations de son message suivant.

Tous les fichiers de l’entrée du modèle sont automatiquement chargés dans le conteneur. Vous n’avez pas besoin de le charger explicitement dans le conteneur.

Fichiers pris en charge

Format de fichier MIME type
.c text/x-c
.cs text/x-csharp
.cpp text/x-c++
.csv text/csv
.doc application/msword
.docx application/vnd.openxmlformats-officedocument.wordprocessingml.document
.html text/html
.java text/x-java
.json application/json
.md text/markdown
.pdf application/pdf
.php text/x-php
.pptx application/vnd.openxmlformats-officedocument.presentationml.presentation
.py text/x-python
.py text/x-script.python
.rb text/x-ruby
.tex text/x-tex
.txt text/plain
.css text/css
.js text/JavaScript
.sh application/x-sh
.ts application/TypeScript
.csv application/csv
.jpeg image/jpeg
.jpg image/jpeg
.gif image/gif
.pkl application/octet-stream
.png image/png
.tar application/x-tar
.xlsx application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
.xml application/xml ou « text/xml »
.zip application/zip

Répertorier les éléments d’entrée

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

Entrée d’image

Pour les modèles compatibles avec la vision, les images en PNG (.png), JPEG (.jpeg et .jpg), WEBP (.webp) sont prises en charge.

URL de l’image

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)

Image encodée en 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)

Entrée de fichier

Les modèles avec fonctionnalités de vision prennent en charge l’entrée PDF. Les fichiers PDF peuvent être fournis en tant que données encodées en Base64 ou en tant qu’ID de fichier. Pour aider les modèles à interpréter le contenu PDF, le texte extrait et une image de chaque page sont inclus dans le contexte du modèle. Cela est utile lorsque des informations clés sont transmises via des diagrammes ou du contenu non textuel.

Note

  • Tous les textes et images extraits sont placés dans le contexte du modèle. Assurez-vous de comprendre les implications relatives à la tarification et à l’utilisation des jetons lors de l'utilisation des fichiers PDF comme entrée.

  • Dans une requête d’API unique, la taille du contenu chargé sur plusieurs entrées (fichiers) doit se trouver dans la longueur du contexte du modèle.

  • Seuls les modèles qui prennent en charge les entrées de texte et d’image peuvent accepter des fichiers PDF comme entrée.

  • Un des purpose sur user_data n’est actuellement pas pris en charge. En guise de solution de contournement temporaire, vous devez définir l’objectif sur assistants.

Convertir pdf en Base64 et analyser

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)

Charger pdf et analyser

Chargez le fichier PDF. Un des purpose sur user_data n’est actuellement pas pris en charge. Pour contourner ce problème, vous devez définir l’objectif sur 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
}

Vous allez ensuite prendre la valeur du id et la transmettre à un modèle pour traitement sous 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"
                    }
                ]
            }
        ]
    }'

Utilisation de serveurs MCP distants

Vous pouvez étendre les fonctionnalités de votre modèle en la connectant à des outils hébergés sur des serveurs MCP (Remote Model Context Protocol). Ces serveurs sont gérés par les développeurs et les organisations et exposent des outils accessibles par des clients compatibles MCP, tels que l’API Réponses.

Le protocole MCP (Model Context Protocol) est une norme ouverte qui définit la façon dont les applications fournissent des outils et des données contextuelles aux modèles de langage volumineux (LLMs). Il permet une intégration cohérente et évolutive d’outils externes dans des flux de travail de modèle.

L’exemple suivant montre comment utiliser le serveur MCP fictif pour interroger des informations sur l’API REST Azure. Cela permet au modèle de récupérer et de raisonner sur le contenu du référentiel en temps réel.

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)

L’outil MCP fonctionne uniquement dans l’API Réponses et est disponible sur tous les modèles plus récents (gpt-4o, gpt-4.1 et nos modèles de raisonnement). Lorsque vous utilisez l’outil MCP, vous payez uniquement les jetons utilisés lors de l’importation de définitions d’outils ou lors de l’appel d’outils, il n’y a pas de frais supplémentaires impliqués.

Approvals

Par défaut, l’API Réponses nécessite une approbation explicite avant que toutes les données ne soient partagées avec un serveur MCP distant. Cette étape d’approbation vous permet de garantir la transparence et de contrôler les informations envoyées en externe.

Nous vous recommandons d’examiner toutes les données partagées avec des serveurs MCP distants et de les journaliser éventuellement à des fins d’audit.

Lorsqu’une approbation est requise, le modèle retourne un mcp_approval_request élément dans la sortie de la réponse. Cet objet contient les détails de la demande en attente et vous permet d’inspecter ou de modifier les données avant de continuer.

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

Pour passer à l’appel MCP distant, vous devez répondre à la demande d’approbation en créant un objet de réponse qui inclut un élément mcp_approval_response. Cet objet confirme votre intention d’autoriser le modèle à envoyer les données spécifiées au serveur MCP distant.

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

  • Le client MCP au sein de l’API Réponses nécessite TLS 1.2 ou une version ultérieure.
  • le protocole TLS mutuel (mTLS) n’est actuellement pas pris en charge.
  • Les balises de service Azure ne sont actuellement pas prises en charge pour le trafic client MCP.

Contrairement au serveur MCP GitHub, la plupart des serveurs MCP distants nécessitent une authentification. L’outil MCP de l’API Réponses prend en charge les en-têtes personnalisés, ce qui vous permet de vous connecter en toute sécurité à ces serveurs à l’aide du schéma d’authentification dont ils ont besoin.

Vous pouvez spécifier des en-têtes tels que des clés API, des jetons d’accès OAuth ou d’autres informations d’identification directement dans votre demande. L’en-tête le plus couramment utilisé est l’en-tête 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)

Tâches en arrière-plan

Le mode en arrière-plan vous permet d’exécuter des tâches de longue durée de manière asynchrone à l’aide de modèles comme o3 et o1-pro. Cela est particulièrement utile pour les tâches de raisonnement complexes qui peuvent prendre plusieurs minutes, telles que celles gérées par des agents tels que Le Codex ou la Recherche approfondie.

En activant le mode en arrière-plan, vous pouvez éviter les délais d’expiration et maintenir la fiabilité pendant les opérations étendues. Lorsqu’une demande est envoyée avec "background": true, la tâche est traitée de manière asynchrone et vous pouvez interroger son état au fil du temps.

Pour démarrer une tâche en arrière-plan, définissez le paramètre d’arrière-plan sur true dans votre demande :

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)

Utilisez le GET point de terminaison pour contrôler l’état d’une réponse d’arrière-plan. Poursuivez l’interrogation pendant que l’état est mis en file d’attente ou in_progress. Une fois que la réponse atteint un état final (terminal), elle sera disponible pour la récupération.

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

Vous pouvez annuler une tâche en arrière-plan en cours à l’aide du cancel point de terminaison. L’annulation est idempotente : les appels suivants retournent l’objet de réponse final.

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)

Diffuser en continu une réponse en arrière-plan

Pour diffuser en continu une réponse en arrière-plan, définissez à la fois background et stream sur true. Cela est utile si vous souhaitez reprendre la diffusion en continu ultérieurement en cas de connexion supprimée. Utilisez le sequence_number de chaque événement pour suivre votre position.

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

Actuellement, les réponses en arrière-plan ont une latence de temps à premier jeton plus élevée que les réponses synchrones. Des améliorations sont en cours pour réduire cet écart.

Limitations

  • Le mode en arrière-plan nécessite store=true. Les demandes sans état ne sont pas prises en charge.
  • Vous ne pouvez reprendre la diffusion en continu que si la requête d'origine incluait stream=true.
  • Pour annuler une réponse synchrone, terminez la connexion directement.

Reprendre la diffusion en continu à partir d’un point spécifique

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"

Éléments de raisonnement chiffrés

Lorsque vous utilisez l'API Réponses en mode sans état, soit en définissant store sur false, soit lorsque votre organisation est inscrite dans un programme de rétention nulle des données, vous devez toujours conserver le contexte de raisonnement tout au long des échanges de conversation. Pour ce faire, incluez des éléments de raisonnement chiffrés dans vos requêtes d’API.

Pour conserver les éléments de raisonnement à plusieurs tours, ajoutez reasoning.encrypted_content au paramètre include dans votre demande. Cela garantit que la réponse inclut une version chiffrée de la trace de raisonnement, qui peut être transmise dans les requêtes futures.

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

Génération d’image (préversion)

L’API Réponses active la génération d’images dans le cadre de conversations et de flux de travail en plusieurs étapes. Il prend en charge les entrées et sorties d’image dans le contexte et inclut des outils intégrés pour générer et modifier des images.

Par rapport à l’API Image autonome, l’API Réponses offre plusieurs avantages :

  • Streaming : affichez des sorties d’image partielles pendant la génération pour améliorer la latence perçue.
  • Entrées flexibles : acceptez les ID de fichier image en tant qu’entrées, en plus des octets d’image bruts.

Note

L’outil de génération d’images de l’API Réponses n’est pris en charge que par les modèles de la série gpt-image-1. Vous pouvez toutefois appeler ce modèle à partir de cette liste de modèles pris en charge : gpt-4o, gpt-4o-mini, gpt-4.1, gpt-4.1-mini, gpt-4.1-nanoo3et gpt-5gpt-5.1 modèles de série.

L’outil de génération d’images de l’API Réponses ne prend actuellement pas en charge le mode de diffusion en continu. Pour utiliser le mode streaming et générer des images partielles, appelez l’API de génération d’images directement en dehors de l’API Réponses.

Utilisez l’API Réponses si vous souhaitez créer des expériences d’image conversationnelle avec l’image GPT.

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

Modèles de raisonnement

Pour obtenir des exemples d’utilisation de modèles de raisonnement avec l’API réponses, consultez le guide des modèles de raisonnement.

Utilisation de l’ordinateur

L’utilisation de l’ordinateur avec Playwright a été déplacée vers le guide de modèle d’utilisation de l’ordinateur dédié

  • Last updated on