Compartilhar via

API de Respostas do Azure OpenAI

A API de Respostas é uma nova API com estado da OpenAI do Azure. Ele reúne os melhores recursos da API de conclusões de chat e assistentes em uma experiência unificada. A API de Respostas também adiciona suporte para o novo computer-use-preview modelo que alimenta a funcionalidade de uso do computador .

API de Respostas

Suporte de API

Disponibilidade de região

A API de respostas está disponível atualmente nas seguintes regiões:

  • australiaeast
  • Brasil Sul
  • canadacentral
  • Canadá Oriental
  • eastus
  • eastus2
  • francecentral
  • alemanhacentro-oeste
  • italynorth
  • japaneast
  • koreacentral
  • northcentralus
  • norwayeast
  • polandcentral
  • southafricanorth
  • southcentralus
  • southeastasia
  • southindia
  • spaincentral
  • swedencentral
  • switzerlandnorth
  • uaenorth
  • uksouth
  • westus
  • westus3

Suporte ao modelo

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

Nem todos os modelos estão disponíveis nas regiões compatíveis com a API de respostas. Verifique a página de modelos quanto à disponibilidade da região do modelo.

Note

Não há suporte no momento:

  • A ferramenta de pesquisa na Web
  • Geração de imagem usando edição em múltiplas etapas e transmissão – disponível em breve
  • As imagens não podem ser carregadas como um arquivo e, em seguida, referenciadas como entrada. Em breve.

Há um problema conhecido com o seguinte:

  • PDF como arquivo de entrada agora tem suporte, mas definir o propósito de upload de arquivo para user_data atualmente não tem suporte.
  • Problemas de desempenho quando o modo em segundo plano é usado com streaming. Espera-se que o problema seja resolvido em breve.

Documentação de referência

Introdução à API de respostas

Para acessar os comandos de API de respostas, você precisa atualizar sua versão da biblioteca OpenAI.

pip install --upgrade openai

Gerar uma resposta 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 as chaves de API com cuidado. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente. Se você usar uma chave de API, armazene-a com segurança no Azure Key Vault. Para obter mais informações sobre como usar chaves de API com segurança em seus aplicativos, confira Chaves de API com o Azure Key Vault.

Para obter mais informações sobre a segurança dos serviços de IA, veja Autenticar solicitações para serviços de IA do Azure.

Recuperar uma resposta

Para recuperar uma resposta de uma chamada anterior para a API de respostas.

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 as chaves de API com cuidado. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente. Se você usar uma chave de API, armazene-a com segurança no Azure Key Vault. Para obter mais informações sobre como usar chaves de API com segurança em seus aplicativos, confira Chaves de API com o Azure Key Vault.

Para obter mais informações sobre a segurança dos serviços de IA, veja Autenticar solicitações para serviços de IA do Azure.

Excluir resposta

Por padrão, os dados de resposta são mantidos por 30 dias. Para excluir uma resposta, você pode 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)

Encadeamento de respostas em conjunto

Você pode encadear respostas passando o response.id da resposta anterior para o parâmetro previous_response_id.

import os
from openai import OpenAI

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

response = client.responses.create(
    model="gpt-4o",  # replace with your model deployment name
    input="Define and explain the concept of catastrophic forgetting?"
)

second_response = client.responses.create(
    model="gpt-4o",  # replace with your model deployment name
    previous_response_id=response.id,
    input=[{"role": "user", "content": "Explain this at a level that could be understood by a college freshman"}]
)
print(second_response.model_dump_json(indent=2))

Observe na saída que, embora nunca tenhamos compartilhado a primeira pergunta de entrada com a chamada à API second_response, ao passar o previous_response_id, o modelo tem o contexto completo da pergunta e da resposta anteriores para responder à nova pergunta.

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
}

Encadeamento de respostas manualmente

Como alternativa, você pode encadear manualmente as respostas usando o método abaixo:

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

Chamada de função

A API de respostas dá suporte a chamadas de função.

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

Interpretador de Código

A ferramenta Interpretador de Código permite que os modelos escrevam e executem código Python em um ambiente seguro e em área restrita. Ele dá suporte a uma variedade de tarefas avançadas, incluindo:

  • Processando arquivos com formatos e estruturas de dados variados
  • Gerando arquivos que incluem dados e visualizações (por exemplo, grafos)
  • Escrever e executar código iterativamente para resolver problemas — os modelos podem depurar e tentar novamente o código até que sejam bem-sucedidos
  • Aprimorando o raciocínio visual em modelos com suporte (por exemplo, o3, o4-mini) habilitando transformações de imagem, como corte, zoom e rotação
  • Essa ferramenta é especialmente útil para cenários que envolvem análise de dados, computação matemática e geração 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)

Contêineres

Important

O Interpretador de Código tem encargos adicionais além das taxas baseadas em token para uso do OpenAI do Azure. Se a API de Respostas chamar o Interpretador de Código simultaneamente em dois threads diferentes, duas sessões de interpretador de código serão criadas. Cada sessão está ativa por padrão por 1 hora com um tempo limite ocioso de 20 minutos.

A ferramenta Interpretador de Código requer um contêiner , uma máquina virtual totalmente restrita em que o modelo pode executar código Python. Os contêineres podem incluir arquivos carregados ou arquivos gerados durante a execução.

Para criar um contêiner, especifique "container": { "type": "auto", "file_ids": ["file-1", "file-2"] } na configuração da ferramenta ao criar um novo objeto Response. Isso cria automaticamente um novo contêiner ou reutiliza um existente de uma chamada anterior de code_interpreter_call no contexto do modelo. A code_interpreter_call saída da API conterá o container_id que foi gerado. Esse contêiner expira se não for usado por 20 minutos.

Entradas e saídas de arquivo

Ao executar o Interpretador de Código, o modelo pode criar seus próprios arquivos. Por exemplo, se você solicitar que ele construa um gráfico ou crie um CSV, ele criará essas imagens diretamente em seu contêiner. Ele citará esses arquivos nas anotações de sua próxima mensagem.

Todos os arquivos na entrada do modelo são carregados automaticamente no contêiner. Você não precisa carregá-lo explicitamente no contêiner.

Arquivos com suporte

Formato de arquivo tipo de 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 text/plain
.css text/css
.js text/JavaScript
.sh application/x-sh
.ts application/TypeScript
.csv application/csv
.jpeg image/jpeg
.jpg image/jpeg
.gif image/gif
.pkl application/octet-stream
.png image/png
.tar application/x-tar
.xlsx application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
.xml application/xml ou "text/xml"
.zip application/zip

Listar itens 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 imagem

URL da imagem

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)

Imagem codificada em 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 arquivo

Modelos com recursos de visão dão suporte à entrada em PDF. Os arquivos PDF podem ser fornecidos como dados codificados em Base64 ou como IDs de arquivo. Para ajudar os modelos a interpretar o conteúdo em PDF, o texto extraído e uma imagem de cada página são incluídos no contexto do modelo. Isso é útil quando as informações principais são transmitidas por meio de diagramas ou conteúdo não textual.

Note

  • Todos os textos e imagens extraídos são colocados no contexto do modelo. Certifique-se de entender as implicações sobre preços e uso de tokens ao usar PDFs como entrada.

  • Em uma única solicitação de API, o tamanho do conteúdo carregado em várias entradas (arquivos) deve estar dentro do comprimento de contexto do modelo.

  • Somente os modelos que dão suporte a entradas de texto e imagem podem aceitar arquivos PDF como entrada.

  • Atualmente, não há suporte para purpose de user_data. Como uma solução alternativa temporária, você precisará definir a finalidade como assistants.

Converter PDF em Base64 e analisar

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)

Carregar PDF e analisar

Carregue o arquivo PDF. Atualmente, não há suporte para purpose de user_data. Como solução alternativa, você precisará definir a finalidade como 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
}

Em seguida, você pegará o valor do id e o passará para um modelo para processamento em 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"
                    }
                ]
            }
        ]
    }'

Usando servidores MCP remotos

Você pode estender os recursos do modelo conectando-o a ferramentas hospedadas em servidores remotos do PROTOCOLO MCP. Esses servidores são mantidos por desenvolvedores e organizações e expõem ferramentas que podem ser acessadas por clientes compatíveis com MCP, como a API de Respostas.

O PROTOCOLO MCP (Model Context Protocol) é um padrão aberto que define como os aplicativos fornecem ferramentas e dados contextuais para LLMs (modelos de linguagem grande). Ele permite uma integração consistente e escalonável de ferramentas externas em fluxos de trabalho de modelo.

O exemplo a seguir demonstra como usar o servidor MCP fictício para consultar informações sobre a API REST do Azure. Isso permite que o modelo recupere e raciocinar o conteúdo do repositório em tempo 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)

A ferramenta MCP funciona apenas na API de Respostas e está disponível em todos os modelos mais recentes (gpt-4o, gpt-4.1 e nossos modelos de raciocínio). Ao usar a ferramenta MCP, você paga apenas por tokens usados ao importar definições de ferramentas ou fazer chamadas de ferramentas. Não há taxas adicionais envolvidas.

Approvals

Por padrão, a API de Respostas requer aprovação explícita antes que qualquer dado seja compartilhado com um servidor MCP remoto. Essa etapa de aprovação ajuda a garantir a transparência e fornece controle sobre quais informações são enviadas externamente.

Recomendamos revisar todos os dados compartilhados com servidores MCP remotos e, opcionalmente, registrar em log para fins de auditoria.

Quando uma aprovação é necessária, o modelo retorna um mcp_approval_request item na saída de resposta. Esse objeto contém os detalhes da solicitação pendente e permite que você inspecione ou modifique os dados antes de prosseguir.

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

Para continuar com a chamada remota do MCP, você deve responder à solicitação de aprovação criando um novo objeto de resposta que inclua um item de mcp_approval_response. Esse objeto confirma sua intenção de permitir que o modelo envie os dados especificados para o 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

Ao contrário do servidor MCP do GitHub, a maioria dos servidores MCP remotos exige autenticação. A ferramenta MCP na API de Respostas dá suporte a cabeçalhos personalizados, permitindo que você se conecte com segurança a esses servidores usando o esquema de autenticação necessário.

Você pode especificar cabeçalhos como chaves de API, tokens de acesso OAuth ou outras credenciais diretamente em sua solicitação. O cabeçalho mais usado é o Authorization cabeçalho.

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)

Tarefas em segundo plano

O modo em segundo plano permite executar tarefas de execução prolongada de forma assíncrona usando modelos como o3 e o o1-pro. Isso é especialmente útil para tarefas complexas de raciocínio que podem levar vários minutos para serem concluídas, como aquelas tratadas por agentes como Codex ou Deep Research.

Ao habilitar o modo em segundo plano, você pode evitar tempos limite e manter a confiabilidade durante operações estendidas. Quando uma solicitação é enviada com "background": true, a tarefa é processada de forma assíncrona e você pode sondar seu status ao longo do tempo.

Para iniciar uma tarefa em segundo plano, defina o parâmetro em segundo plano como true em sua solicitação:

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)

Utilize o endpoint GET para verificar o status de uma resposta em segundo plano. Continue a sondagem enquanto o status estiver na fila ou in_progress. Depois que a resposta atingir um estado final (terminal), ela estará disponível para recuperação.

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

Você pode cancelar uma tarefa em segundo plano que está em andamento usando o endpoint cancel. O cancelamento é idempotente. As chamadas subsequentes retornarão o objeto de resposta 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)

Transmitir uma resposta em segundo plano

Para transmitir uma resposta em segundo plano, defina ambas background e stream como true. Isso é útil se você quiser retomar o streaming mais tarde no caso de uma conexão descartada. Use o sequence_number de cada evento para acompanhar sua posição.

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

Atualmente, as respostas em segundo plano têm uma latência de tempo para o primeiro token maior do que as respostas síncronas. Melhorias estão em andamento para reduzir essa lacuna.

Limitations

  • O modo em segundo plano requer store=true. Não há suporte para solicitações sem estado.
  • Você só poderá retomar o streaming se a solicitação original estiver incluída stream=true.
  • Para cancelar uma resposta síncrona, encerre a conexão diretamente.

Retomar o streaming de um ponto 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"

Itens de raciocínio criptografados

Ao usar a API de Respostas no modo sem estado — configurando store como false ou quando sua organização está registrada em retenção de dados zero — você ainda deve preservar o contexto de raciocínio em turnos de conversa. Para fazer isso, inclua itens de raciocínio criptografados em suas solicitações de API.

Para reter itens de raciocínio entre turnos, adicione reasoning.encrypted_content ao include parâmetro em sua solicitação. Isso garante que a resposta inclua uma versão criptografada do rastreamento de raciocínio, que pode ser transmitida em solicitações 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"]
  }'

Geração de imagem (versão prévia)

A API de Respostas permite a geração de imagem como parte de conversas e fluxos de trabalho de várias etapas. Ele dá suporte a entradas e saídas de imagem dentro do contexto e inclui ferramentas internas para gerar e editar imagens.

Em comparação com a API de Imagem autônoma, a API de Respostas oferece várias vantagens:

  • Streaming: exibir saídas parciais de imagem durante a geração para melhorar a latência percebida.
  • Entradas flexíveis: aceite IDs de arquivo de imagem como entradas, além de bytes de imagem brutos.

Note

A ferramenta de geração de imagem na API de Respostas é compatível apenas com os modelos série gpt-image-1. No entanto, você pode chamar esse modelo desta lista de modelos com suporte – gpt-4o, , gpt-4o-mini, gpt-4.1, gpt-4.1-mini, , gpt-4.1-nano, o3e gpt-5 modelos de série.

Atualmente, a ferramenta de geração de imagem da API de Respostas não dá suporte ao modo de streaming. Para usar o modo de streaming e gerar imagens parciais, chame a API de geração de imagem diretamente fora da API de Respostas.

Utilize a API de Respostas se quiser criar experiências de imagem conversacionais com Imagem GPT.

from openai import OpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://cognitiveservices.azure.com/.default"
)

client = OpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  api_key=token_provider,
  default_headers={"x-ms-oai-image-generation-deployment":"gpt-image-1", "api_version":"preview"}
)

response = client.responses.create(
    model="o3",
    input="Generate an image of gray tabby cat hugging an otter with an orange scarf",
    tools=[{"type": "image_generation"}],
)

# Save the image to a file
image_data = [
    output.result
    for output in response.output
    if output.type == "image_generation_call"
]
    
if image_data:
    image_base64 = image_data[0]
    with open("otter.png", "wb") as f:
        f.write(base64.b64decode(image_base64))

Modelos de raciocínio

Para obter exemplos de como usar modelos de raciocínio com a API de respostas, consulte o guia de modelos de raciocínio.

Uso do computador

O uso de computador com Playwright foi transferido para o guia de modelo de uso de computador dedicado

  • Last updated on