Compartir a través de

Uso de la API de respuestas de OpenAI de Azure

Use la API de Azure OpenAI Responses para generar respuestas con estado y de múltiples turnos. Reúne funcionalidades de finalizaciones de chat y la API de asistentes en una experiencia unificada. La API de respuestas también admite el modelo que impulsa el uso del equipo.

Prerrequisitos

  • Un modelo de OpenAI implementado Azure
  • Un método de autenticación:
    • Clave de API (por ejemplo, ) o
    • Microsoft Entra ID (recomendado).

Instalación o actualización del paquete openAI

Instale o actualice el paquete de Python 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))

Importante

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 usa una clave de API, almacénela de forma segura en Azure Key Vault. Para obtener más información sobre el uso de claves de API de forma segura en las aplicaciones, consulte CLAVESAPI con Azure Key Vault.

Para obtener más información sobre la seguridad de los servicios de inteligencia artificial, consulte Authenticate requests to Servicios de Azure AI (Solicitudes de autenticación a 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")

Importante

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 usa una clave de API, almacénela de forma segura en Azure Key Vault. Para obtener más información sobre el uso de claves de API de forma segura en las aplicaciones, consulte CLAVESAPI con Azure Key Vault.

Para obtener más información sobre la seguridad de los servicios de inteligencia artificial, consulte Authenticate requests to Servicios de Azure AI (Solicitudes de autenticación a Servicios de Azure AI.

Eliminar respuesta

De forma predeterminada, los datos de respuesta se conservan durante 30 días. Para eliminar una respuesta almacenada, llame a .

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 respuesta anterior al 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 , al usar , el modelo tiene el contexto completo de la pregunta anterior y la respuesta para abordar la nueva pregunta.

Salida:

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

Compactar una respuesta

La compactación permite reducir la ventana de contexto enviada al modelo a la vez que conserva la información esencial para la comprensión del modelo.

Compactar mediante elementos devueltos

Puede compactar todos los elementos devueltos de solicitudes anteriores, como razonamiento, mensaje, llamada a función, 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)

Compactación con el identificador de respuesta anterior

También puede compactar usando un identificador de respuesta anterior.

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

Transmisión en línea

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

Contenedores

Importante

El intérprete de código tiene cargos adicionales más allá de las tarifas que se basan 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 de Intérprete de Código requiere un contenedor: una máquina virtual completamente aislada donde el modelo puede ejecutar código Python. Los contenedores pueden incluir archivos cargados o archivos generados durante la ejecución.

Para crear un contenedor, especifique 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 contendrá el 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 imagen/gif
.pkl application/octet-stream
.png imagen/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))

Salida:

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

Nota:

  • 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 de actualmente no está admitido. Como solución temporal, deberá establecer el propósito en .

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 de actualmente no está admitido. Como solución alternativa, deberá establecer el propósito en .

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

Salida:

{
  "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 y lo pasará a un modelo para su procesamiento en :

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.

Aprobaciones

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

Autenticación

Importante

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

A diferencia del GitHub servidor MCP, 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 OAuth access u otras credenciales directamente en la solicitud. El encabezado más usado es el 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 , 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 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 -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}")

Puede cancelar una tarea en segundo plano en curso mediante el punto de conexión. 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 como 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"]

Nota:

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.

Limitaciones

  • El modo en segundo plano requiere . No se admiten solicitudes sin estado.
  • Solo puede reanudar el streaming si la solicitud original incluía .
  • 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 estableciendo en false, debe conservar el contexto de razonamiento entre turnos de conversación. Para hacer esto, incluya elementos cifrados de razonamiento en sus solicitudes de API.

Para conservar los elementos de razonamiento en turnos, agregue al parámetro en la 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.

Nota:

La herramienta de generación de imágenes de la API de respuestas solo es compatible con los modelos de la -serie. Sin embargo, puede llamar a este modelo desde esta lista de modelos admitidos: , , , , , , y modelos de la serie .

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

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

API de respuestas

Compatibilidad con API

  • Se requiere v1 API para el acceso a las características más recientes

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

  • (Versión:)
  • (Versión: )
  • (Versión: )
  • (Versión: )
  • (Versión: )
  • (Versión: )
  • (Versión: )
  • (Versión: )
  • (Versión: )
  • (Versión: )
  • (Versión: )
  • (Versión: )
  • (Versión: )
  • (Versión: )
  • (Versión: )
  • (Versión: )
  • (Versión: )
  • (Versión: )
  • (Versión: )
  • (Versión: )
  • (Versiones: , , )
  • (Versión: )
  • computer-use-preview
  • (Versión: )
  • (Versión: )
  • (Versión: )
  • (Versión: )
  • (Versión: )
  • (Versión: )
  • (Versión: )
  • (Versión: )
  • (Versión: )
  • (Versión: )

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

Nota:

Actualmente no se admite:

  • Compactación con
  • 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 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

  • Documentación de referencia de la API de Responses

Solución de problemas

  • 401/403: si usa Microsoft Entra ID, compruebe que el token está en el ámbito de https://cognitiveservices.azure.com/.default. Si usa una clave de API, confirme que usa la clave correcta para el recurso.
  • 404: Confirme que coincide con el nombre de la implementación.

Contenido relacionado

  • Last updated on