Utiliser l'API Azure OpenAI Responses

Utilisez l'API Azure OpenAI Responses pour générer des réponses d'état et à plusieurs tours. Il réunit les fonctionnalités des achèvements de conversation et de l’API Assistants dans une expérience unifiée. L’API Réponses prend également en charge le computer-use-preview modèle qui alimente l’utilisation de l’ordinateur.

Conditions préalables

  • Modèle OpenAI déployé Azure
  • Méthode d’authentification :
    • Clé API (par exemple, AZURE_OPENAI_API_KEY) ou
    • Microsoft Entra ID (recommandé).

Installer ou mettre à niveau le package OpenAI

Installez ou mettez à niveau le package openAI Python.

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 des clés API avec précaution. N’incluez pas la clé API directement dans votre code et ne la publiez jamais publiquement. Si vous utilisez une clé API, stockez-la en toute sécurité dans Azure Key Vault. Pour plus d’informations sur l’utilisation sécurisée des clés API dans vos applications, consultez les API avec Azure Key Vault.

Pour plus d’informations sur la sécurité des services d’INTELLIGENCE artificielle, consultez Demandes d’authentification à 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 des clés API avec précaution. N’incluez pas la clé API directement dans votre code et ne la publiez jamais publiquement. Si vous utilisez une clé API, stockez-la en toute sécurité dans Azure Key Vault. Pour plus d’informations sur l’utilisation sécurisée des clés API dans vos applications, consultez les API avec Azure Key Vault.

Pour plus d’informations sur la sécurité des services d’INTELLIGENCE artificielle, consultez Demandes d’authentification à 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 stockée, appelez client.responses.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 dans la sortie que, même si nous n’avons jamais partagé la première question d’entrée avec l’appel second_response d’API, en transmettant le modèle previous_response_id, celui-ci dispose d’un contexte complet de la question précédente et de la réponse pour répondre à la nouvelle question.

Sortie:

{
  "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îner les 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))

Compresser une réponse

Le compactage vous permet de réduire la fenêtre de contexte envoyée au modèle tout en préservant les informations essentielles pour la compréhension du modèle.

Compacter en utilisant les éléments retournés

Vous pouvez compacter tous les éléments retournés par les requêtes précédentes, comme le raisonnement, le message, l’appel de fonction, etc.

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)

Compresser en utilisant l'identifiant de réponse précédent

Vous pouvez également compresser avec un ID de réponse précédent.

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

Compactage côté serveur

Vous pouvez également utiliser le compactage côté serveur directement dans Les réponses (POST /responses ou client.responses.create) en définissant context_management avec un compact_threshold.

  • Lorsque le nombre de jetons de sortie dépasse le seuil configuré, l’API Réponses exécute automatiquement la compaction.
  • Dans ce mode, vous n’avez pas besoin d’appeler /responses/compact séparément.
  • La réponse inclut un élément de compactage chiffré.
  • Le compactage côté serveur fonctionne lorsque vous définissez store=false sur vos requêtes de création de réponses.

Le module de compactage transpose l’état antérieur essentiel et le raisonnement à la prochaine étape en utilisant moins de jetons. Il est opaque et n’est pas destiné à être lisible par l’homme.

Si vous utilisez le chaînage sans état du tableau d’entrée, ajoutez des éléments de sortie comme d’habitude. Si vous utilisez previous_response_id, transmettez uniquement le nouveau message utilisateur à chaque tour. Dans les deux schémas, l’élément de compactage porte le contexte nécessaire pour la fenêtre suivante.

Conseil

Après avoir ajouté des éléments de sortie aux éléments d'entrée précédents, vous pouvez supprimer les éléments qui sont arrivés avant le plus récent élément de compactage afin de garder les requêtes plus petites et de réduire la latence de la traîne. Le plus récent élément de compactage contient le contexte nécessaire pour poursuivre la conversation. Si vous utilisez le chaînage previous_response_id, ne pas effectuer de suppression manuelle.

Flux

  1. Appelez responses comme d’habitude. Ajoutez context_management avec compact_threshold pour activer le compactage côté serveur.
  2. Si la sortie dépasse le seuil, le service déclenche un compactage, émet un élément de compactage dans le flux de sortie et supprime le contexte avant de poursuivre l’inférence.
  3. Poursuivez la conversation à l’aide de l’un de ces modèles :
    1. Chaînage sans état du tableau d’entrée : ajoutez des éléments de sortie, y compris des éléments de compactage, au tableau d’entrée suivant.
    2. previous_response_id chaînage : transmettez uniquement le nouveau message utilisateur à chaque tour et transférez l’ID de réponse le plus récent.

Exemple

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

Note

Pendant la diffusion en continu, l’API Réponses peut retourner un événement d’erreur ( 500, 429et des erreurs similaires) si le service rencontre une erreur, telle que des limites de jetons ou des problèmes d’analyse. Les applications doivent détecter cet événement et arrêter ou redémarrer la diffusion en continu. Vous n’êtes pas facturé pour les jetons générés lors des réponses de streaming échouées.

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

Appel de fonction

L’API des réponses permet 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)

Conteneurs

Important

L’interpréteur de code a des frais additionnels au-delà des frais basés sur les jetons 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 complètement isolée où 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 la container_id qui a été générée. 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 Type MIME
.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 texte/plat
.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))

Sortie:

{
  "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. Vérifiez que vous comprenez les implications de la tarification et de l'utilisation des jetons lorsqu'on utilise des fichiers PDF en tant qu'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(e) purpose de user_data n'est actuellement pas pris(e) 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(e) purpose de user_data n'est actuellement pas pris(e) 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

Sortie:

{
  "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 de id et la transmettre à un modèle pour le traitement avec 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.

Approbations

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

Authentification

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.
  • Azure balises de service ne sont actuellement pas prises en charge pour le trafic client MCP.

Contrairement au serveur GITHUB MCP, 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 l’endpoint GET pour vérifier l’état d’une réponse de fond. Poursuivez l’interrogation pendant que l’état est en file d’attente ou en cours. Une fois que la réponse atteint un état final (terminal), elle sera disponible pour la récupération.

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

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 renvoient l’objet final de la réponse.

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 demande d’origine contenait 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 en définissant store la valeur false, vous devez conserver le contexte de raisonnement entre les tours 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 à travers les 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 (aperçu)

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 dans l’API Responses 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://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))

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é

API Réponses

Prise en charge des API

Disponibilité de la région

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

  • australiaeast
  • brésilsouth
  • canadacentral
  • canadaeast
  • eastus
  • eastus2
  • francecentral
  • allemagnewestcentral
  • italynorth
  • japaneast
  • koreacentral
  • northcentralus
  • norwayeast
  • polognecentral
  • southafricanorth
  • southcentralus
  • sud-estasia
  • sud de l'Inde
  • spaincentral
  • Sweden Central
  • Suisse-Nord
  • uaenorth
  • uksouth
  • westus
  • westus3

Prise en charge des modèles

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

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 :

  • Génération d’images en utilisant la modification et le traitement en continu à plusieurs tours.
  • 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

Dépannage

  • 401/403 : si vous utilisez Microsoft Entra ID, vérifiez que votre jeton est limité à https://ai.azure.com/.default. Si vous utilisez une clé API, vérifiez que vous utilisez la clé correcte pour la ressource.
  • 404 : Vérifiez que cela model correspond à votre nom de déploiement.

Contenu connexe

  • Last updated on