Compartir a través de

API de respuestas de Azure OpenAI

La API de respuestas es una nueva API de estado persistente de Azure OpenAI. Reúne las mejores funcionalidades de las finalizaciones de chat y la API de asistentes en una experiencia unificada. La API de respuestas también agrega compatibilidad con el nuevo computer-use-preview modelo que habilita la funcionalidad de uso del ordenador.

API de respuestas

Compatibilidad con API

Disponibilidad regional

La API de respuestas está disponible actualmente en las siguientes regiones:

  • 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

Compatibilidad con los modelos

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

No todos los modelos están disponibles en las regiones admitidas por la API de respuestas. Compruebe la página modelos para ver la disponibilidad de la región del modelo.

Note

Actualmente no se admite:

  • Compactación con /responses/compact
  • Generación de imágenes con edición en múltiples etapas y streaming.
  • Las imágenes no se pueden cargar como un archivo y, a continuación, se hace referencia a ellas como entrada.

Hay un problema conocido con lo siguiente:

  • Ahora se admite PDF como archivo de entrada, pero la configuración del propósito de carga de archivos en user_data no se admite actualmente.
  • Problemas de rendimiento cuando se usa el modo en segundo plano con streaming. Se espera que el problema se resuelva pronto.

Documentación de referencia

Introducción a la API de respuestas

Para acceder a los comandos de api de respuestas, debe actualizar la versión de la biblioteca de OpenAI.

pip install --upgrade openai

Generación de una respuesta de texto

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

Use las claves de API con precaución. No incluya la clave de API directamente en el código ni la exponga nunca públicamente. Si está usando una clave de API, almacénela de forma segura en Azure Key Vault. Para más información sobre cómo utilizar las claves de API de forma segura en sus aplicaciones, consulte Claves de API con Azure Key Vault.

Para más información sobre la seguridad de los servicios de AI, consulte Autenticación de solicitudes a los servicios de Azure AI.

Recuperación de una respuesta

Para recuperar una respuesta de una llamada anterior a la API de respuestas.

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

Use las claves de API con precaución. No incluya la clave de API directamente en el código ni la exponga nunca públicamente. Si está usando una clave de API, almacénela de forma segura en Azure Key Vault. Para más información sobre cómo utilizar las claves de API de forma segura en sus aplicaciones, consulte Claves de API con Azure Key Vault.

Para más información sobre la seguridad de los servicios de AI, consulte Autenticación de solicitudes a los servicios de Azure AI.

Eliminar respuesta

De forma predeterminada, los datos de respuesta se conservan durante 30 días. Para eliminar una respuesta, puede usar 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)

Encadenar respuestas

Puede encadenar las respuestas al pasar la response.id respuesta anterior al previous_response_id parámetro .

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

Tenga en cuenta que, aunque nunca compartimos la primera pregunta de entrada en la llamada de la API second_response, al usar previous_response_id, el modelo tiene el contexto completo de la pregunta anterior y la respuesta para abordar la nueva pregunta.

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
}

Encadenar respuestas manualmente

Como alternativa, puede encadenar manualmente las respuestas mediante el método siguiente:

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

Llamada a funciones

La API de respuestas admite llamadas a funciones.

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

Intérprete de código

La herramienta De intérprete de código permite a los modelos escribir y ejecutar código de Python en un entorno seguro y de espacio aislado. Admite una variedad de tareas avanzadas, entre las que se incluyen:

  • Procesamiento de archivos con formatos y estructuras de datos variados
  • Generación de archivos que incluyen datos y visualizaciones (por ejemplo, gráficos)
  • Escribir y ejecutar código iterativamente para resolver problemas: los modelos pueden depurar y reintentar código hasta que se realice correctamente.
  • Mejorar el razonamiento visual en los modelos admitidos (por ejemplo, o3, o4-mini) habilitando transformaciones de imagen como recorte, zoom y rotación
  • Esta herramienta es especialmente útil para escenarios que implican análisis de datos, cálculo matemático y generación de código.
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

El intérprete de código tiene cargos adicionales más allá de las tarifas basadas en tokens para el uso de Azure OpenAI. Si la API de respuestas llama al intérprete de código simultáneamente en dos subprocesos diferentes, se crean dos sesiones de intérprete de código. Cada sesión está activa de forma predeterminada durante 1 hora con un tiempo de espera de inactividad de 20 minutos.

La herramienta Intérprete de código requiere un contenedor: una máquina virtual completamente aislada donde el modelo puede ejecutar código en Python. Los contenedores pueden incluir archivos cargados o archivos generados durante la ejecución.

Para crear un contenedor, especifique "container": { "type": "auto", "file_ids": ["file-1", "file-2"] } en la configuración de la herramienta al crear un nuevo objeto Response. Esto crea automáticamente un nuevo contenedor o reutiliza uno activo de un code_interpreter_call anterior en el contexto del modelo. En la salida de la API, el code_interpreter_call contendrá el container_id que se generó. Este contenedor expira si no se usa durante 20 minutos.

Entradas y salidas de archivo

Al ejecutar el intérprete de código, el modelo puede crear sus propios archivos. Por ejemplo, si le pide que construya un trazado o cree un CSV, crea estas imágenes directamente en el contenedor. Citará estos archivos en las anotaciones de su siguiente mensaje.

Los archivos de la entrada del modelo se cargan automáticamente en el contenedor. No es necesario cargarlo explícitamente en el contenedor.

Archivos admitidos

Formato de archivo 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 o "text/xml"
.zip application/zip

Enumerar elementos de entrada

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

Entrada de imagen

Para los modelos habilitados para visión, se admiten imágenes en PNG (.png), JPEG (.jpeg y .jpg), WEBP (.webp).

Dirección URL de la imagen

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)

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

Entrada de archivo

Los modelos con funcionalidades de visión admiten la entrada pdf. Los archivos PDF se pueden proporcionar como datos codificados en Base64 o como identificadores de archivo. Para ayudar a los modelos a interpretar el contenido PDF, tanto el texto extraído como una imagen de cada página se incluyen en el contexto del modelo. Esto resulta útil cuando la información clave se transmite a través de diagramas o contenido no textual.

Note

  • Todo el texto extraído y las imágenes se colocan en el contexto del modelo. Asegúrese de comprender las implicaciones de los precios y el uso de tokens al utilizar archivos PDF como input.

  • En una única solicitud de API, el tamaño del contenido cargado en varias entradas (archivos) debe estar dentro de la longitud del contexto del modelo.

  • Solo los modelos que admiten entradas de texto e imagen pueden aceptar archivos PDF como entrada.

  • Un purpose de user_data actualmente no está admitido. Como solución temporal, deberá establecer el propósito en assistants.

Conversión de PDF a Base64 y análisis

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)

Carga de PDF y análisis

Cargue el archivo PDF. Un purpose de user_data actualmente no está admitido. Como solución alternativa, deberá establecer el propósito en 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
}

A continuación, tomará el valor de id y lo pasará a un modelo para su procesamiento en 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"
                    }
                ]
            }
        ]
    }'

Uso de servidores MCP remotos

Puede ampliar las funcionalidades del modelo mediante la conexión a herramientas hospedadas en servidores remotos del Protocolo de contexto de modelo (MCP). Los desarrolladores y las organizaciones mantienen estos servidores y exponen herramientas a las que pueden acceder los clientes compatibles con MCP, como la API de respuestas.

El Protocolo de contexto de modelo (MCP) es un estándar abierto que define cómo las aplicaciones proporcionan herramientas y datos contextuales a modelos de lenguaje grandes (LLM). Permite una integración coherente y escalable de herramientas externas en flujos de trabajo de modelo.

En el ejemplo siguiente se muestra cómo usar el servidor MCP ficticio para consultar información sobre la API REST de Azure. Esto permite que el modelo recupere y analice el contenido del repositorio en tiempo real.

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)

La herramienta MCP solo funciona en la API de respuestas y está disponible en todos los modelos más recientes (gpt-4o, gpt-4.1 y nuestros modelos de razonamiento). Cuando se usa la herramienta MCP, solo se pagan los tokens que se usan al importar definiciones de herramientas o realizar llamadas a herramientas, no hay cargos adicionales.

Approvals

De forma predeterminada, la API de respuestas requiere aprobación explícita antes de que los datos se compartan con un servidor MCP remoto. Este paso de aprobación ayuda a garantizar la transparencia y le proporciona control sobre qué información se envía externamente.

Se recomienda revisar todos los datos que se comparten con servidores MCP remotos y, opcionalmente, registrarlos con fines de auditoría.

Cuando se requiere una aprobación, el modelo devuelve un mcp_approval_request elemento en la salida de la respuesta. Este objeto contiene los detalles de la solicitud pendiente y permite inspeccionar o modificar los datos antes de continuar.

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

Para continuar con la llamada a MCP remota, debe responder a la solicitud de aprobación mediante la creación de un nuevo objeto de respuesta que incluya un elemento de mcp_approval_response. Este objeto confirma la intención de permitir que el modelo envíe los datos especificados al servidor MCP remoto.

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

  • El cliente MCP dentro de la API de respuestas requiere TLS 1.2 o posterior.
  • TLS mutuo (mTLS) no se admite actualmente.
  • Actualmente no se admiten etiquetas de servicio de Azure para el tráfico de cliente MCP.

A diferencia del servidor MCP de GitHub, la mayoría de los servidores MCP remotos requieren autenticación. La herramienta MCP de la API de respuestas admite encabezados personalizados, lo que le permite conectarse de forma segura a estos servidores mediante el esquema de autenticación que requieren.

Puede especificar encabezados como claves de API, tokens de acceso de OAuth u otras credenciales directamente en la solicitud. El encabezado más usado es el Authorization encabezado .

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)

Tareas en segundo plano

El modo en segundo plano permite ejecutar tareas de larga duración de forma asincrónica mediante modelos como o3 y o1-pro. Esto es especialmente útil para tareas de razonamiento complejas que pueden tardar varios minutos en completarse, como las que manejan agentes como El Codex o La investigación profunda.

Al habilitar el modo en segundo plano, puede evitar tiempos de espera y mantener la confiabilidad durante las operaciones extendidas. Cuando se envía una solicitud con "background": true, la tarea se procesa de forma asincrónica y puede sondear su estado con el tiempo.

Para iniciar una tarea en segundo plano, establezca el parámetro background en true en la solicitud:

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)

Use el GET punto de conexión para comprobar el estado de una respuesta en segundo plano. Continúe sondeando mientras el estado está en cola o in_progress. Una vez que la respuesta alcanza un estado final (terminal), estará disponible para su recuperación.

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

Puede cancelar una tarea en segundo plano en curso mediante el punto de conexióncancel. La cancelación es idempotente: las llamadas posteriores devolverán el objeto de respuesta 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)

Transmisión de una respuesta en segundo plano

Para transmitir una respuesta en segundo plano, establezca tanto background como stream en true. Esto es útil si desea reanudar el streaming más adelante en caso de una conexión eliminada. Utiliza el sequence_number de cada evento para seguir tu posición.

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

Actualmente, las respuestas en segundo plano tienen una latencia de tiempo a primer token mayor que las respuestas sincrónicas. Se están llevando a cabo mejoras para reducir esta brecha.

Limitations

  • El modo en segundo plano requiere store=true. No se admiten solicitudes sin estado.
  • Solo puede reanudar el streaming si la solicitud original incluía stream=true.
  • Para cancelar una respuesta sincrónica, finalice la conexión directamente.

Reanudación del streaming desde un punto específico

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"

Elementos de razonamiento cifrado

Al usar la API de respuestas en modo sin estado ( ya sea estableciendo store en falso o cuando la organización está inscrita en cero retención de datos), debe conservar el contexto de razonamiento en los turnos de conversación. Para ello, incluya elementos de razonamiento cifrados en las solicitudes de API.

Para conservar los elementos de razonamiento en turnos, agregue reasoning.encrypted_content al parámetro en la include solicitud. Esto garantiza que la respuesta incluya una versión cifrada del trazado de razonamiento, la cual se puede transmitir en solicitudes futuras.

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

Generación de imágenes (versión preliminar)

La API de respuestas habilita la generación de imágenes como parte de conversaciones y flujos de trabajo de varios pasos. Admite entradas y salidas de imagen dentro del contexto e incluye herramientas integradas para generar y editar imágenes.

En comparación con la API de imágenes independiente, la API de respuestas ofrece varias ventajas.

  • Streaming: muestra salidas parciales de imágenes durante la generación para mejorar la latencia percibida.
  • Entradas flexibles: acepte identificadores de archivo de imagen como entradas, además de bytes de imagen sin procesar.

Note

La herramienta de generación de imágenes de la API de respuestas solo es compatible con los modelos de la gpt-image-1-serie. Sin embargo, puede llamar a este modelo desde esta lista de modelos admitidos: gpt-4o, gpt-4o-mini, gpt-4.1, gpt-4.1-mini, gpt-4.1-nano, o3, gpt-5 y modelos de la serie gpt-5.1.

La herramienta de generación de imágenes de La API de respuestas no admite actualmente el modo de streaming. Para usar el modo de streaming y generar imágenes parciales, llame a la API de generación de imágenes directamente fuera de la API de respuestas.

Use API de Respuestas si desea crear experiencias conversacionales de imagen con 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))

Modelos de razonamiento

Para obtener ejemplos de cómo usar modelos de razonamiento con la API de respuestas, consulte la guía de modelos de razonamiento.

Uso del equipo

El uso de equipos con Playwright se ha movido a la guía del modelo de uso de equipos dedicado

  • Last updated on