Servidores MCP | OpenAI API

Además de las herramientas que pones a disposición del modelo mediante la llamada a funciones, puedes darles nuevas capacidades a los modelos usando servidores MCP remotos o el Túnel MCP seguro. Estas herramientas permiten que el modelo se conecte a servicios externos y los controle cuando sea necesario para responder al prompt de un usuario. Puedes permitir estas llamadas a herramientas automáticamente o restringirlas para exigir tu aprobación explícita como desarrollador.

Los servidores MCP remotos pueden ser cualquier servidor en la internet pública que implemente un servidor remoto del Model Context Protocol (MCP).
El Túnel MCP seguro conecta un servidor MCP local o privado sin exponerlo a la internet pública.

Esta guía muestra cómo usar herramientas MCP con la API Responses. Los conectores integrados siguen siendo compatibles con los modelos existentes; consulta Conectores heredados para conocer la política de obsolescencia y ver ejemplos de compatibilidad. Para las sesiones de la API de agentes, consulta Conexiones MCP, donde se explican las conexiones desde el servicio administrado o desde tu sandbox.

Túnel MCP seguro

Si tu servidor MCP es privado, está en tus instalaciones o detrás de un firewall, usa el Túnel MCP seguro para conectarlo a productos compatibles de OpenAI sin exponerlo a la internet pública. Descarga la versión pública más reciente desde openai/tunnel-client.

Inicio rápido

Usa el tipo de herramienta mcp en la API Responses. Configura server_url para un servidor MCP remoto, o usa tunnel_id para un servidor MCP local mediante el Túnel MCP seguro. Según el servidor, es posible que también necesites un token de acceso OAuth en el parámetro authorization.

Uso de un servidor MCP remoto en la API Responses

curl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16curl https://api.openai.com/v1/responses \ 
-H "Content-Type: application/json" \ 
-H "Authorization: Bearer $OPENAI_API_KEY" \ 
-d '{
  "model": "gpt-6-astra",
    "tools": [
      {
        "type": "mcp",
        "server_label": "dmcp",
        "server_description": "A Dungeons and Dragons MCP server to assist with dice rolling.",
        "server_url": "https://dmcp-server.deno.dev/mcp",
        "require_approval": "never"
      }
    ],
    "input": "Roll 2d4+1"
  }'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19import OpenAI from "openai";
const client = new OpenAI();

const resp = await client.responses.create({
  model: "gpt-6-astra",
  tools: [
    {
      type: "mcp",
      server_label: "dmcp",
      server_description:
        "A Dungeons and Dragons MCP server to assist with dice rolling.",
      server_url: "https://dmcp-server.deno.dev/mcp",
      require_approval: "never",
    },
  ],
  input: "Roll 2d4+1",
});

console.log(resp.output_text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19from openai import OpenAI

client = OpenAI()

resp = client.responses.create(
    model="gpt-6-astra",
    tools=[
        {
            "type": "mcp",
            "server_label": "dmcp",
            "server_description": "A Dungeons and Dragons MCP server to assist with dice rolling.",
            "server_url": "https://dmcp-server.deno.dev/mcp",
            "require_approval": "never",
        },
    ],
    input="Roll 2d4+1",
)

print(resp.output_text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client := openai.NewClient()
	tool := responses.ToolParamOfMcp("dmcp")
	tool.OfMcp.ServerDescription = openai.String("A Dungeons and Dragons MCP server to assist with dice rolling.")
	tool.OfMcp.ServerURL = openai.String("https://dmcp-server.deno.dev/mcp")
	tool.OfMcp.RequireApproval = responses.ToolMcpRequireApprovalUnionParam{OfMcpToolApprovalSetting: openai.String("never")}

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-6-astra",
		Tools: []responses.ToolUnionParam{tool},
		Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Roll 2d4+1")},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.OutputText())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.Tool;

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .input("Roll 2d4+1")
        .addTool(
            Tool.Mcp.builder()
                .serverLabel("dmcp")
                .serverDescription(
                    "A Dungeons and Dragons MCP server to assist with dice rolling.")
                .serverUrl("https://dmcp-server.deno.dev/mcp")
                .requireApproval(Tool.Mcp.RequireApproval.McpToolApprovalSetting.NEVER)
                .build())
        .build();

client.responses().create(params).output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CreateResponseOptions options = new() { Model = "gpt-6-astra" };
options.Tools.Add(
    ResponseTool.CreateMcpTool(
        serverLabel: "dmcp",
        serverUri: new Uri("https://dmcp-server.deno.dev/mcp"),
        toolCallApprovalPolicy: DefaultMcpToolCallApprovalPolicy.NeverRequireApproval
    )
);
options.InputItems.Add(ResponseItem.CreateUserMessageItem("Roll 2d4+1"));

ResponseResult response = await client.CreateResponseAsync(options);

Console.WriteLine(response.GetOutputText());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19require "openai"

openai = OpenAI::Client.new

response = openai.responses.create(
  model: "gpt-6-astra",
  tools: [
    {
      type: "mcp",
      server_label: "dmcp",
      server_description: "A Dungeons and Dragons MCP server to assist with dice rolling.",
      server_url: "https://dmcp-server.deno.dev/mcp",
      require_approval: "never"
    }
  ],
  input: "Roll 2d4+1"
)

puts(response.output_text)

Es muy importante que los desarrolladores confíen en cualquier servidor MCP remoto que usen con la API Responses. Un servidor malicioso puede extraer datos sensibles de cualquier contenido que entre en el contexto del modelo. Antes de usar esta herramienta, revisa detenidamente la sección Riesgos y seguridad que aparece más adelante.

La API devolverá nuevos elementos en el arreglo output de la respuesta del modelo. Si el modelo decide usar un servidor MCP, primero hará una solicitud para obtener la lista de herramientas disponibles en el servidor, lo que creará un elemento de salida mcp_list_tools. En el ejemplo anterior del servidor MCP remoto, este elemento contiene una sola definición de herramienta:

1234567891011121314151617181920212223{
  "id": "mcpl_68a6102a4968819c8177b05584dd627b0679e572a900e618",
  "type": "mcp_list_tools",
  "server_label": "dmcp",
  "tools": [
    {
      "annotations": null,
      "description": "Given a string of text describing a dice roll...",
      "input_schema": {
        "$schema": "https://json-schema.org/draft/2020-12/schema",
        "type": "object",
        "properties": {
          "diceRollExpression": {
            "type": "string"
          }
        },
        "required": ["diceRollExpression"],
        "additionalProperties": false
      },
      "name": "roll"
    }
  ]
}

Si el modelo decide llamar a una de las herramientas disponibles en el servidor MCP, también encontrarás una salida mcp_call que mostrará lo que el modelo envió a la herramienta MCP y lo que esta devolvió como salida.

12345678910{
  "id": "mcp_68a6102d8948819c9b1490d36d5ffa4a0679e572a900e618",
  "type": "mcp_call",
  "approval_request_id": null,
  "arguments": "{\"diceRollExpression\":\"2d4 + 1\"}",
  "error": null,
  "name": "roll",
  "output": "4",
  "server_label": "dmcp"
}

Sigue leyendo esta guía para obtener más información sobre cómo funciona la herramienta MCP, cómo filtrar las herramientas disponibles y cómo gestionar las solicitudes de aprobación de llamadas a herramientas.

Cómo funciona

La herramienta MCP está disponible en la API Responses para la mayoría de los modelos recientes. Consulta aquí la compatibilidad de tu modelo con la herramienta MCP. Al usar la herramienta MCP, solo pagas por los tokens utilizados al importar definiciones de herramientas o realizar llamadas a herramientas. No se aplican cargos adicionales por llamada a herramienta.

A continuación, veremos paso a paso el proceso que sigue la API al llamar a una herramienta MCP.

Paso 1: obtener la lista de herramientas disponibles

Cuando especificas un servidor MCP remoto en el parámetro tools, la API intentará obtener una lista de herramientas del servidor. La API Responses funciona con servidores MCP remotos compatibles con los protocolos de transporte Streamable HTTP o HTTP/SSE.

Si la lista de herramientas se obtiene correctamente, aparecerá un nuevo elemento de salida mcp_list_tools en la salida de la respuesta del modelo. La propiedad tools de este objeto mostrará las herramientas que se importaron correctamente.

1234567891011121314151617181920212223{
  "id": "mcpl_68a6102a4968819c8177b05584dd627b0679e572a900e618",
  "type": "mcp_list_tools",
  "server_label": "dmcp",
  "tools": [
    {
      "annotations": null,
      "description": "Given a string of text describing a dice roll...",
      "input_schema": {
        "$schema": "https://json-schema.org/draft/2020-12/schema",
        "type": "object",
        "properties": {
          "diceRollExpression": {
            "type": "string"
          }
        },
        "required": ["diceRollExpression"],
        "additionalProperties": false
      },
      "name": "roll"
    }
  ]
}

Mientras el elemento mcp_list_tools esté presente en el contexto de una solicitud a la API, la API no volverá a obtener la lista de herramientas del servidor MCP en cada turno de una conversación. Te recomendamos mantener este elemento en el contexto del modelo en cada conversación o ejecución de un flujo de trabajo para reducir la latencia.

Filtrar herramientas

Algunos servidores MCP pueden tener decenas de herramientas, y poner muchas herramientas a disposición del modelo puede generar costos y latencia elevados. Si solo te interesa un subconjunto de las herramientas que ofrece un servidor MCP, puedes usar el parámetro allowed_tools para importar únicamente esas herramientas.

Restringir las herramientas permitidas

curl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17curl https://api.openai.com/v1/responses \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
    "model": "gpt-6-astra",
    "tools": [
      {
        "type": "mcp",
        "server_label": "dmcp",
        "server_description": "A Dungeons and Dragons MCP server to assist with dice rolling.",
        "server_url": "https://dmcp-server.deno.dev/mcp",
        "require_approval": "never",
        "allowed_tools": ["roll"]
      }
    ],
    "input": "Roll 2d4+1"
  }'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20import OpenAI from "openai";
const client = new OpenAI();

const resp = await client.responses.create({
  model: "gpt-6-astra",
  tools: [
    {
      type: "mcp",
      server_label: "dmcp",
      server_description:
        "A Dungeons and Dragons MCP server to assist with dice rolling.",
      server_url: "https://dmcp-server.deno.dev/mcp",
      require_approval: "never",
      allowed_tools: ["roll"],
    },
  ],
  input: "Roll 2d4+1",
});

console.log(resp.output_text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20from openai import OpenAI

client = OpenAI()

resp = client.responses.create(
    model="gpt-6-astra",
    tools=[
        {
            "type": "mcp",
            "server_label": "dmcp",
            "server_description": "A Dungeons and Dragons MCP server to assist with dice rolling.",
            "server_url": "https://dmcp-server.deno.dev/mcp",
            "require_approval": "never",
            "allowed_tools": ["roll"],
        }
    ],
    input="Roll 2d4+1",
)

print(resp.output_text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client := openai.NewClient()
	tool := responses.ToolParamOfMcp("dmcp")
	tool.OfMcp.ServerDescription = openai.String("A Dungeons and Dragons MCP server to assist with dice rolling.")
	tool.OfMcp.ServerURL = openai.String("https://dmcp-server.deno.dev/mcp")
	tool.OfMcp.RequireApproval = responses.ToolMcpRequireApprovalUnionParam{OfMcpToolApprovalSetting: openai.String("never")}
	tool.OfMcp.AllowedTools = responses.ToolMcpAllowedToolsUnionParam{OfMcpAllowedTools: []string{"roll"}}

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-6-astra",
		Tools: []responses.ToolUnionParam{tool},
		Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Roll 2d4+1")},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.OutputText())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.Tool;
import java.util.List;

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .input("Roll 2d4+1")
        .addTool(
            Tool.Mcp.builder()
                .serverLabel("dmcp")
                .serverDescription(
                    "A Dungeons and Dragons MCP server to assist with dice rolling.")
                .serverUrl("https://dmcp-server.deno.dev/mcp")
                .requireApproval(Tool.Mcp.RequireApproval.McpToolApprovalSetting.NEVER)
                .allowedToolsOfMcp(List.of("roll"))
                .build())
        .build();

client.responses().create(params).output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CreateResponseOptions options = new() { Model = "gpt-6-astra" };
options.Tools.Add(
    ResponseTool.CreateMcpTool(
        serverLabel: "dmcp",
        serverUri: new Uri("https://dmcp-server.deno.dev/mcp"),
        allowedTools: new McpToolFilter() { ToolNames = { "roll" } },
        toolCallApprovalPolicy: DefaultMcpToolCallApprovalPolicy.NeverRequireApproval
    )
);
options.InputItems.Add(ResponseItem.CreateUserMessageItem("Roll 2d4+1"));

ResponseResult response = await client.CreateResponseAsync(options);

Console.WriteLine(response.GetOutputText());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20require "openai"

client = OpenAI::Client.new

response = client.responses.create(
  model: "gpt-6-astra",
  input: "Roll 2d4+1",
  tools: [
    {
      type: :mcp,
      server_label: "dmcp",
      server_description: "A Dungeons and Dragons MCP server to assist with dice rolling.",
      server_url: "https://dmcp-server.deno.dev/mcp",
      require_approval: :never,
      allowed_tools: ["roll"]
    }
  ]
)

puts(response.output_text)

Paso 2: llamar a herramientas

Una vez que el modelo tiene acceso a estas definiciones de herramientas, puede decidir llamarlas según lo que haya en su contexto. Cuando el modelo decide llamar a una herramienta MCP, la API enviará una solicitud al servidor MCP remoto para llamar a la herramienta e incluir su salida en el contexto del modelo. Esto crea un elemento mcp_call con el siguiente aspecto:

12345678910{
  "id": "mcp_68a6102d8948819c9b1490d36d5ffa4a0679e572a900e618",
  "type": "mcp_call",
  "approval_request_id": null,
  "arguments": "{\"diceRollExpression\":\"2d4 + 1\"}",
  "error": null,
  "name": "roll",
  "output": "4",
  "server_label": "dmcp"
}

Este elemento incluye tanto los argumentos que el modelo decidió usar para esta llamada a herramienta como el valor de output que devolvió el servidor MCP remoto. Todos los modelos pueden decidir realizar varias llamadas a herramientas MCP, por lo que podrías ver varios de estos elementos generados en una sola solicitud a la API.

Cuando una llamada a herramienta falla, el campo error de este elemento contendrá errores del protocolo MCP, errores de ejecución de herramientas MCP o errores generales de conectividad. Los errores de MCP están documentados en la especificación de MCP, aquí.

Aprobaciones

De forma predeterminada, OpenAI solicitará tu aprobación antes de compartir cualquier dato con un conector o servidor MCP remoto. Las aprobaciones te ayudan a mantener el control y la visibilidad sobre los datos que se envían a un servidor MCP. Te recomendamos encarecidamente que revises con atención (y, de manera opcional, registres) todos los datos que se comparten con un servidor MCP remoto. Una solicitud de aprobación para realizar una llamada a herramienta MCP crea un elemento mcp_approval_request en la salida de Response con el siguiente aspecto:

1234567{
  "id": "mcpr_68a619e1d82c8190b50c1ccba7ad18ef0d2d23a86136d339",
  "type": "mcp_approval_request",
  "arguments": "{\"diceRollExpression\":\"2d4 + 1\"}",
  "name": "roll",
  "server_label": "dmcp"
}

Luego puedes responder a esta solicitud creando un nuevo objeto Response y agregándole un elemento mcp_approval_response.

Aprobar el uso de herramientas en una solicitud a la API

curl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21curl https://api.openai.com/v1/responses \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
    "model": "gpt-6-astra",
    "tools": [
      {
        "type": "mcp",
        "server_label": "dmcp",
        "server_description": "A Dungeons and Dragons MCP server to assist with dice rolling.",
        "server_url": "https://dmcp-server.deno.dev/mcp",
        "require_approval": "always",
      }
    ],
    "previous_response_id": "resp_682d498bdefc81918b4a6aa477bfafd904ad1e533afccbfa",
    "input": [{
      "type": "mcp_approval_response",
      "approve": true,
      "approval_request_id": "mcpr_682d498e3bd4819196a0ce1664f8e77b04ad1e533afccbfa"
    }]
  }'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27import OpenAI from "openai";
const client = new OpenAI();

const resp = await client.responses.create({
  model: "gpt-6-astra",
  tools: [
    {
      type: "mcp",
      server_label: "dmcp",
      server_description:
        "A Dungeons and Dragons MCP server to assist with dice rolling.",
      server_url: "https://dmcp-server.deno.dev/mcp",
      require_approval: "always",
    },
  ],
  previous_response_id: "resp_682d498bdefc81918b4a6aa477bfafd904ad1e533afccbfa",
  input: [
    {
      type: "mcp_approval_response",
      approve: true,
      approval_request_id:
        "mcpr_682d498e3bd4819196a0ce1664f8e77b04ad1e533afccbfa",
    },
  ],
});

console.log(resp.output_text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26from openai import OpenAI

client = OpenAI()

resp = client.responses.create(
    model="gpt-6-astra",
    tools=[
        {
            "type": "mcp",
            "server_label": "dmcp",
            "server_description": "A Dungeons and Dragons MCP server to assist with dice rolling.",
            "server_url": "https://dmcp-server.deno.dev/mcp",
            "require_approval": "always",
        }
    ],
    previous_response_id="resp_682d498bdefc81918b4a6aa477bfafd904ad1e533afccbfa",
    input=[
        {
            "type": "mcp_approval_response",
            "approve": True,
            "approval_request_id": "mcpr_682d498e3bd4819196a0ce1664f8e77b04ad1e533afccbfa",
        }
    ],
)

print(resp.output_text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client := openai.NewClient()
	tool := responses.ToolParamOfMcp("dmcp")
	tool.OfMcp.ServerDescription = openai.String("A Dungeons and Dragons MCP server to assist with dice rolling.")
	tool.OfMcp.ServerURL = openai.String("https://dmcp-server.deno.dev/mcp")
	tool.OfMcp.RequireApproval = responses.ToolMcpRequireApprovalUnionParam{OfMcpToolApprovalSetting: openai.String("always")}

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model:              "gpt-6-astra",
		PreviousResponseID: openai.String("resp_682d498bdefc81918b4a6aa477bfafd904ad1e533afccbfa"),
		Tools:              []responses.ToolUnionParam{tool},
		Input: responses.ResponseNewParamsInputUnion{OfInputItemList: responses.ResponseInputParam{
			responses.ResponseInputItemParamOfMcpApprovalResponse("mcpr_682d498e3bd4819196a0ce1664f8e77b04ad1e533afccbfa", true),
		}},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.OutputText())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputItem;
import com.openai.models.responses.Tool;
import java.util.List;

String responseId = "resp_682d498bdefc81918b4a6aa477bfafd904ad1e533afccbfa";

String approvalRequestId = "mcpr_682d498e3bd4819196a0ce1664f8e77b04ad1e533afccbfa";

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .input(
            ResponseCreateParams.Input.ofResponse(
                List.of(
                    ResponseInputItem.ofMcpApprovalResponse(
                        ResponseInputItem.McpApprovalResponse.builder()
                            .approvalRequestId(approvalRequestId)
                            .approve(true)
                            .build()))))
        .previousResponseId(responseId)
        .addTool(
            Tool.Mcp.builder()
                .serverLabel("dmcp")
                .serverDescription("A Dungeons and Dragons MCP server.")
                .serverUrl("https://dmcp-server.deno.dev/mcp")
                .requireApproval(Tool.Mcp.RequireApproval.McpToolApprovalSetting.ALWAYS)
                .build())
        .build();

client.responses().create(params).output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CreateResponseOptions options = new() { Model = "gpt-6-astra" };
options.Tools.Add(
    ResponseTool.CreateMcpTool(
        serverLabel: "dmcp",
        serverUri: new Uri("https://dmcp-server.deno.dev/mcp"),
        toolCallApprovalPolicy: DefaultMcpToolCallApprovalPolicy.AlwaysRequireApproval
    )
);

// Step 1: Create a response that requests tool-call approval.
options.InputItems.Add(ResponseItem.CreateUserMessageItem("Roll 2d4+1"));
ResponseResult response1 = await client.CreateResponseAsync(options);

McpToolCallApprovalRequestItem approvalRequest =
    response1.OutputItems.OfType<McpToolCallApprovalRequestItem>().Single();

// Step 2: Approve the tool call and get the final response.
options.PreviousResponseId = response1.Id;
options.InputItems.Clear();
options.InputItems.Add(
    ResponseItem.CreateMcpApprovalResponseItem(approvalRequest.Id, approved: true)
);
ResponseResult response2 = await client.CreateResponseAsync(options);

Console.WriteLine(response2.GetOutputText());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25require "openai"

client = OpenAI::Client.new
response = client.responses.create(
  model: "gpt-6-astra",
  previous_response_id: "resp_682d498bdefc81918b4a6aa477bfafd904ad1e533afccbfa",
  input: [
    {
      type: :mcp_approval_response,
      approval_request_id: "mcpr_682d498e3bd4819196a0ce1664f8e77b04ad1e533afccbfa",
      approve: true
    }
  ],
  tools: [
    {
      type: :mcp,
      server_label: "dmcp",
      server_url: "https://dmcp-server.deno.dev/mcp",
      server_description: "A Dungeons and Dragons MCP server.",
      require_approval: :always
    }
  ]
)

puts(response.output_text)

Aquí usamos el parámetro previous_response_id para encadenar esta nueva respuesta con la respuesta anterior que generó la solicitud de aprobación. También puedes pasar las salidas de una respuesta como entradas de otra para tener el máximo control sobre lo que se incluye en el contexto del modelo.

Si en algún momento tienes suficiente confianza en un servidor MCP remoto, puedes optar por omitir las aprobaciones para reducir la latencia. Para hacerlo, puedes establecer el parámetro require_approval de la herramienta MCP en un objeto que enumere únicamente las herramientas para las que quieres omitir las aprobaciones, como se muestra a continuación, o establecerlo en el valor 'never' para omitir las aprobaciones de todas las herramientas de ese servidor MCP remoto.

No requerir nunca aprobación para ciertas herramientas

curl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19curl https://api.openai.com/v1/responses \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
    "model": "gpt-6-astra",
    "tools": [
      {
        "type": "mcp",
        "server_label": "deepwiki",
        "server_url": "https://mcp.deepwiki.com/mcp",
        "require_approval": {
          "never": {
            "tool_names": ["ask_question", "read_wiki_structure"]
          }
        }
      }
    ],
    "input": "What transport protocols does the 2025-03-26 version of the MCP spec (modelcontextprotocol/modelcontextprotocol) support?"
  }'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22import OpenAI from "openai";
const client = new OpenAI();

const resp = await client.responses.create({
  model: "gpt-6-astra",
  tools: [
    {
      type: "mcp",
      server_label: "deepwiki",
      server_url: "https://mcp.deepwiki.com/mcp",
      require_approval: {
        never: {
          tool_names: ["ask_question", "read_wiki_structure"],
        },
      },
    },
  ],
  input:
    "What transport protocols does the 2025-03-26 version of the MCP spec (modelcontextprotocol/modelcontextprotocol) support?",
});

console.log(resp.output_text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20from openai import OpenAI

client = OpenAI()

resp = client.responses.create(
    model="gpt-6-astra",
    tools=[
        {
            "type": "mcp",
            "server_label": "deepwiki",
            "server_url": "https://mcp.deepwiki.com/mcp",
            "require_approval": {
                "never": {"tool_names": ["ask_question", "read_wiki_structure"]}
            },
        },
    ],
    input="What transport protocols does the 2025-03-26 version of the MCP spec (modelcontextprotocol/modelcontextprotocol) support?",
)

print(resp.output_text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client := openai.NewClient()
	tool := responses.ToolParamOfMcp("deepwiki")
	tool.OfMcp.ServerURL = openai.String("https://mcp.deepwiki.com/mcp")
	tool.OfMcp.RequireApproval = responses.ToolMcpRequireApprovalUnionParam{
		OfMcpToolApprovalFilter: &responses.ToolMcpRequireApprovalMcpToolApprovalFilterParam{
			Never: responses.ToolMcpRequireApprovalMcpToolApprovalFilterNeverParam{
				ToolNames: []string{"ask_question", "read_wiki_structure"},
			},
		},
	}

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-6-astra",
		Tools: []responses.ToolUnionParam{tool},
		Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("What transport protocols does the 2025-03-26 version of the MCP spec (modelcontextprotocol/modelcontextprotocol) support?")},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.OutputText())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.Tool;

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .input("What transport protocols does the 2025-03-26 version of the MCP spec support?")
        .addTool(
            Tool.Mcp.builder()
                .serverLabel("deepwiki")
                .serverUrl("https://mcp.deepwiki.com/mcp")
                .requireApproval(
                    Tool.Mcp.RequireApproval.McpToolApprovalFilter.builder()
                        .never(
                            Tool.Mcp.RequireApproval.McpToolApprovalFilter.Never.builder()
                                .addToolName("ask_question")
                                .addToolName("read_wiki_structure")
                                .build())
                        .build())
                .build())
        .build();

client.responses().create(params).output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CreateResponseOptions options = new() { Model = "gpt-6-astra" };
options.Tools.Add(
    ResponseTool.CreateMcpTool(
        serverLabel: "deepwiki",
        serverUri: new Uri("https://mcp.deepwiki.com/mcp"),
        toolCallApprovalPolicy: new CustomMcpToolCallApprovalPolicy
        {
            ToolsNeverRequiringApproval = new McpToolFilter
            {
                ToolNames = { "ask_question", "read_wiki_structure" },
            },
        }
    )
);
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem(
        "What transport protocols does the 2025-03-26 version of the MCP spec (modelcontextprotocol/modelcontextprotocol) support?"
    )
);

ResponseResult response = await client.CreateResponseAsync(options);

Console.WriteLine(response.GetOutputText());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20require "openai"

client = OpenAI::Client.new

response = client.responses.create(
  model: "gpt-6-astra",
  input: "What transport protocols does the 2025-03-26 version of the MCP spec support?",
  tools: [
    {
      type: :mcp,
      server_label: "deepwiki",
      server_url: "https://mcp.deepwiki.com/mcp",
      require_approval: {
        never: { tool_names: ["ask_question", "read_wiki_structure"] }
      }
    }
  ]
)

puts(response.output_text)

Autenticación

A diferencia del servidor MCP de ejemplo que usamos antes, la mayoría de los demás servidores MCP requieren autenticación. El método más común es un token de acceso de OAuth. Proporciona este token mediante el campo authorization de la herramienta MCP:

Usar la herramienta MCP de Stripe

curl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15curl https://api.openai.com/v1/responses \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
    "model": "gpt-6-astra",
    "input": "Create a payment link for $20",
    "tools": [
      {
        "type": "mcp",
        "server_label": "stripe",
        "server_url": "https://mcp.stripe.com",
        "authorization": "$STRIPE_OAUTH_ACCESS_TOKEN"
      }
    ]
  }'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17import OpenAI from "openai";
const client = new OpenAI();

const resp = await client.responses.create({
  model: "gpt-6-astra",
  input: "Create a payment link for $20",
  tools: [
    {
      type: "mcp",
      server_label: "stripe",
      server_url: "https://mcp.stripe.com",
      authorization: "$STRIPE_OAUTH_ACCESS_TOKEN",
    },
  ],
});

console.log(resp.output_text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20import os
from openai import OpenAI

client = OpenAI()
authorization = os.environ["STRIPE_OAUTH_ACCESS_TOKEN"]

resp = client.responses.create(
    model="gpt-6-astra",
    input="Create a payment link for $20",
    tools=[
        {
            "type": "mcp",
            "server_label": "stripe",
            "server_url": "https://mcp.stripe.com",
            "authorization": authorization,
        }
    ],
)

print(resp.output_text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31package main

import (
	"context"
	"fmt"
	"os"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	authorization := os.Getenv("STRIPE_OAUTH_ACCESS_TOKEN")
	if authorization == "" {
		panic("STRIPE_OAUTH_ACCESS_TOKEN is required")
	}
	client := openai.NewClient()
	tool := responses.ToolParamOfMcp("stripe")
	tool.OfMcp.ServerURL = openai.String("https://mcp.stripe.com")
	tool.OfMcp.Authorization = openai.String(authorization)

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-6-astra",
		Tools: []responses.ToolUnionParam{tool},
		Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Create a payment link for $20")},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.OutputText())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.Tool;

String stripeAccessToken = System.getenv("STRIPE_OAUTH_ACCESS_TOKEN");

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .input("Create a payment link for $20.")
        .addTool(
            Tool.Mcp.builder()
                .serverLabel("stripe")
                .serverUrl("https://mcp.stripe.com")
                .authorization(stripeAccessToken)
                .build())
        .build();

client.responses().create(params).output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23using OpenAI.Responses;
#pragma warning disable OPENAI001

string authToken =
    Environment.GetEnvironmentVariable("STRIPE_OAUTH_ACCESS_TOKEN")!;
string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CreateResponseOptions options = new() { Model = "gpt-6-astra" };
options.Tools.Add(
    ResponseTool.CreateMcpTool(
        serverLabel: "stripe",
        serverUri: new Uri("https://mcp.stripe.com"),
        authorizationToken: authToken
    )
);
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem("Create a payment link for $20")
);

ResponseResult response = await client.CreateResponseAsync(options);

Console.WriteLine(response.GetOutputText());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17require "openai"

client = OpenAI::Client.new
response = client.responses.create(
  model: "gpt-6-astra",
  input: "Create a payment link for $20.",
  tools: [
    {
      type: :mcp,
      server_label: "stripe",
      server_url: "https://mcp.stripe.com",
      authorization: ENV.fetch("STRIPE_OAUTH_ACCESS_TOKEN")
    }
  ]
)

puts(response.output_text)

Para evitar la filtración de tokens sensibles, la API Responses no almacena el valor que proporcionas en el campo authorization. Este valor tampoco será visible en el objeto Response creado. Por eso, debes enviar el valor de authorization en cada solicitud de creación que hagas a la API Responses.

Conectores heredados

connector_id está obsoleto para los modelos lanzados después del 1 de septiembre de 2026. Usa server_url para conectarte a un servidor MCP remoto, o tunnel_id para conectarte a un servidor MCP local mediante el Túnel MCP seguro. Los modelos existentes conservan la compatibilidad con conectores. Los ejemplos de esta sección usan gpt-5.2, que se lanzó antes de esa fecha límite.

La API Responses tiene compatibilidad integrada con un conjunto limitado de conectores a servicios de terceros. Estos conectores te permiten incorporar contexto de aplicaciones populares, como Dropbox y Gmail, para que el modelo pueda interactuar con servicios populares.

Los conectores se pueden usar de la misma manera que los servidores MCP remotos. Ambos permiten que un modelo de OpenAI acceda a herramientas adicionales de terceros en una solicitud a la API. Sin embargo, en lugar de pasar un server_url como lo harías para llamar a un servidor MCP remoto, pasas un connector_id que identifica de forma única un conector disponible en la API.

Los conectores requieren un token de acceso OAuth que tu aplicación debe proporcionar en el parámetro authorization.

Usa un conector heredado con GPT-5.2

curl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16curl https://api.openai.com/v1/responses \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
    "model": "gpt-5.2",
    "tools": [
      {
        "type": "mcp",
        "server_label": "Dropbox",
        "connector_id": "connector_dropbox",
        "authorization": "<oauth access token>",
        "require_approval": "never"
      }
    ],
    "input": "Summarize the Q2 earnings report."
  }'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18import OpenAI from "openai";
const client = new OpenAI();

const resp = await client.responses.create({
  model: "gpt-5.2",
  tools: [
    {
      type: "mcp",
      server_label: "Dropbox",
      connector_id: "connector_dropbox",
      authorization: "<oauth access token>",
      require_approval: "never",
    },
  ],
  input: "Summarize the Q2 earnings report.",
});

console.log(resp.output_text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22import os

from openai import OpenAI

client = OpenAI()
connector_authorization = os.environ["OPENAI_CONNECTOR_AUTHORIZATION"]

resp = client.responses.create(
    model="gpt-5.2",
    tools=[
        {
            "type": "mcp",
            "server_label": "Dropbox",
            "connector_id": "connector_dropbox",
            "authorization": connector_authorization,
            "require_approval": "never",
        },
    ],
    input="Summarize the Q2 earnings report.",
)

print(resp.output_text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client := openai.NewClient()
	tool := responses.ToolParamOfMcp("Dropbox")
	tool.OfMcp.ConnectorID = "connector_dropbox"
	tool.OfMcp.Authorization = openai.String("<oauth access token>")
	tool.OfMcp.RequireApproval = responses.ToolMcpRequireApprovalUnionParam{OfMcpToolApprovalSetting: openai.String("never")}

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-5.2",
		Tools: []responses.ToolUnionParam{tool},
		Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Summarize the Q2 earnings report.")},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.OutputText())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.Tool;

String oauthAccessToken = "<oauth access token>";

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-5.2")
        .input("Summarize the Q2 earnings report.")
        .addTool(
            Tool.Mcp.builder()
                .serverLabel("Dropbox")
                .connectorId(Tool.Mcp.ConnectorId.of("connector_dropbox"))
                .authorization(oauthAccessToken)
                .requireApproval(Tool.Mcp.RequireApproval.McpToolApprovalSetting.NEVER)
                .build())
        .build();

client.responses().create(params).output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24using OpenAI.Responses;
#pragma warning disable OPENAI001

string dropboxToken =
    Environment.GetEnvironmentVariable("DROPBOX_OAUTH_ACCESS_TOKEN")!;
string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CreateResponseOptions options = new() { Model = "gpt-5.2" };
options.Tools.Add(
    ResponseTool.CreateMcpTool(
        serverLabel: "Dropbox",
        connectorId: McpToolConnectorId.Dropbox,
        authorizationToken: dropboxToken,
        toolCallApprovalPolicy: DefaultMcpToolCallApprovalPolicy.NeverRequireApproval
    )
);
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem("Summarize the Q2 earnings report.")
);

ResponseResult response = await client.CreateResponseAsync(options);

Console.WriteLine(response.GetOutputText());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18require "openai"

client = OpenAI::Client.new
response = client.responses.create(
  model: "gpt-5.2",
  input: "Summarize the Q2 earnings report.",
  tools: [
    {
      type: :mcp,
      server_label: "Dropbox",
      connector_id: "connector_dropbox",
      authorization: "<oauth access token>",
      require_approval: :never
    }
  ]
)

puts(response.output_text)

Conectores disponibles

Dropbox: connector_dropbox
Gmail: connector_gmail
Google Calendar: connector_googlecalendar
Google Drive: connector_googledrive
Microsoft Teams: connector_microsoftteams
Outlook Calendar: connector_outlookcalendar
Outlook Email: connector_outlookemail
SharePoint: connector_sharepoint

Priorizamos los servicios que no tienen servidores MCP remotos oficiales. GitHub, por ejemplo, tiene un servidor MCP oficial al que puedes conectarte pasando https://api.githubcopilot.com/mcp/ en el campo server_url de la herramienta MCP.

Autorizar un conector

En el campo authorization, pasa un token de acceso OAuth. Tu aplicación debe gestionar por separado el registro y la autorización del cliente OAuth.

Para realizar pruebas, puedes usar OAuth 2.0 Playground de Google para generar tokens de acceso temporales que puedes utilizar en una solicitud a la API.

Para usar el Playground y probar la funcionalidad de los conectores en la API, comienza por ingresar:

https://www.googleapis.com/auth/calendar.events

Este alcance de autorización permitirá que la API lea eventos de Google Calendar. En la interfaz, en “Paso 1: seleccionar y autorizar APIs”.

Después de autorizar la aplicación con tu cuenta de Google, llegarás al Paso 2: intercambiar el código de autorización por tokens. Esto generará un token de acceso que puedes usar en una solicitud a la API con el conector de Google Calendar:

Usar el conector de Google Calendar

curl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16curl https://api.openai.com/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-5.2",
    "tools": [
      {
        "type": "mcp",
        "server_label": "google_calendar",
        "connector_id": "connector_googlecalendar",
        "authorization": "ya29.A0AS3H6...",
        "require_approval": "never"
      }
    ],
    "input": "What is on my Google Calendar for today?"
  }'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18import OpenAI from "openai";
const client = new OpenAI();

const resp = await client.responses.create({
  model: "gpt-5.2",
  tools: [
    {
      type: "mcp",
      server_label: "google_calendar",
      connector_id: "connector_googlecalendar",
      authorization: "ya29.A0AS3H6...",
      require_approval: "never",
    },
  ],
  input: "What's on my Google Calendar for today?",
});

console.log(resp.output_text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21import os
from openai import OpenAI

client = OpenAI()
authorization = os.environ["GOOGLE_CALENDAR_OAUTH_ACCESS_TOKEN"]

resp = client.responses.create(
    model="gpt-5.2",
    tools=[
        {
            "type": "mcp",
            "server_label": "google_calendar",
            "connector_id": "connector_googlecalendar",
            "authorization": authorization,
            "require_approval": "never",
        },
    ],
    input="What's on my Google Calendar for today?",
)

print(resp.output_text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client := openai.NewClient()
	tool := responses.ToolParamOfMcp("google_calendar")
	tool.OfMcp.ConnectorID = "connector_googlecalendar"
	tool.OfMcp.Authorization = openai.String("<oauth access token>")
	tool.OfMcp.RequireApproval = responses.ToolMcpRequireApprovalUnionParam{OfMcpToolApprovalSetting: openai.String("never")}

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-5.2",
		Tools: []responses.ToolUnionParam{tool},
		Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("What's on my Google Calendar for today?")},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.OutputText())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.Tool;

String oauthAccessToken = "<oauth access token>";

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-5.2")
        .input("What's on my Google Calendar for today?")
        .addTool(
            Tool.Mcp.builder()
                .serverLabel("google_calendar")
                .connectorId(Tool.Mcp.ConnectorId.of("connector_googlecalendar"))
                .authorization(oauthAccessToken)
                .requireApproval(Tool.Mcp.RequireApproval.McpToolApprovalSetting.NEVER)
                .build())
        .build();

client.responses().create(params).output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24using OpenAI.Responses;
#pragma warning disable OPENAI001

string authToken =
    Environment.GetEnvironmentVariable("GOOGLE_CALENDAR_OAUTH_ACCESS_TOKEN")!;
string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CreateResponseOptions options = new() { Model = "gpt-5.2" };
options.Tools.Add(
    ResponseTool.CreateMcpTool(
        serverLabel: "google_calendar",
        connectorId: McpToolConnectorId.GoogleCalendar,
        authorizationToken: authToken,
        toolCallApprovalPolicy: DefaultMcpToolCallApprovalPolicy.NeverRequireApproval
    )
);
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem("What's on my Google Calendar for today?")
);

ResponseResult response = await client.CreateResponseAsync(options);

Console.WriteLine(response.GetOutputText());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18require "openai"

client = OpenAI::Client.new
response = client.responses.create(
  model: "gpt-5.2",
  input: "What's on my Google Calendar for today?",
  tools: [
    {
      type: :mcp,
      server_label: "google_calendar",
      connector_id: "connector_googlecalendar",
      authorization: "<oauth access token>",
      require_approval: :never
    }
  ]
)

puts(response.output_text)

Una llamada a una herramienta MCP de un conector tendrá el mismo formato que una llamada a una herramienta MCP de un servidor MCP remoto y usará el tipo de elemento de salida mcp_call. En este caso, tanto los argumentos enviados al conector como su respuesta son cadenas JSON:

12345678910{
  "id": "mcp_68a62ae1c93c81a2b98c29340aa3ed8800e9b63986850588",
  "type": "mcp_call",
  "approval_request_id": null,
  "arguments": "{\"time_min\":\"2025-08-20T00:00:00\",\"time_max\":\"2025-08-21T00:00:00\",\"timezone_str\":null,\"max_results\":50,\"query\":null,\"calendar_id\":null,\"next_page_token\":null}",
  "error": null,
  "name": "search_events",
  "output": "{\"events\": [{\"id\": \"2n8ni54ani58pc3ii6soelupcs_20250820\", \"summary\": \"Home\", \"location\": null, \"start\": \"2025-08-20T00:00:00\", \"end\": \"2025-08-21T00:00:00\", \"url\": \"https://www.google.com/calendar/event?eid=Mm44bmk1NGFuaTU4cGMzaWk2c29lbHVwY3NfMjAyNTA4MjAga3doaW5uZXJ5QG9wZW5haS5jb20&ctz=America/Los_Angeles\", \"description\": \"\\n\\n\", \"transparency\": \"transparent\", \"display_url\": \"https://www.google.com/calendar/event?eid=Mm44bmk1NGFuaTU4cGMzaWk2c29lbHVwY3NfMjAyNTA4MjAga3doaW5uZXJ5QG9wZW5haS5jb20&ctz=America/Los_Angeles\", \"display_title\": \"Home\"}], \"next_page_token\": null}",
  "server_label": "Google_Calendar"
}

Herramientas disponibles en cada conector

Las herramientas disponibles dependen de los alcances que tenga tu token OAuth. Expande las tablas siguientes para ver qué herramientas puedes usar al conectarte a cada aplicación.

Herramienta	Descripción	Ámbitos
`search`	Busca en Dropbox archivos que coincidan con una consulta	files.metadata.read, account_info.read
`fetch`	Obtiene un archivo por su ruta, con la opción de descargarlo sin procesar	files.content.read
`search_files`	Busca archivos en Dropbox y devuelve los resultados	files.metadata.read, account_info.read
`fetch_file`	Obtiene el texto o el contenido sin procesar de un archivo	files.content.read, account_info.read
`list_recent_files`	Devuelve los archivos modificados más recientemente a los que el usuario tiene acceso	files.metadata.read, account_info.read
`get_profile`	Obtiene el perfil de Dropbox del usuario actual	account_info.read

Herramienta	Descripción	Ámbitos
`get_profile`	Devuelve el perfil del usuario actual de Gmail	userinfo.email, userinfo.profile
`search_emails`	Busca en Gmail correos que coincidan con una consulta o etiqueta	gmail.modify
`search_email_ids`	Obtiene los ID de los mensajes de Gmail que coincidan con una búsqueda	gmail.modify
`get_recent_emails`	Devuelve los mensajes de Gmail recibidos más recientemente	gmail.modify
`read_email`	Obtiene un solo mensaje de Gmail, incluido su cuerpo	gmail.modify
`batch_read_email`	Lee varios mensajes de Gmail en una sola llamada	gmail.modify

Herramienta	Descripción	Ámbitos
`get_profile`	Devuelve el perfil del usuario actual de Calendar	userinfo.email, userinfo.profile
`search`	Busca eventos de Calendar con la opción de limitar la búsqueda a un intervalo de tiempo	calendar.events
`fetch`	Obtiene los detalles de un solo evento de Calendar	calendar.events
`search_events`	Busca eventos de Calendar mediante filtros	calendar.events
`read_event`	Lee un evento de Google Calendar por su ID	calendar.events

Herramienta	Descripción	Ámbitos
`get_profile`	Devuelve el perfil del usuario actual de Drive	userinfo.email, userinfo.profile
`list_drives`	Enumera las unidades compartidas a las que el usuario tiene acceso	drive.readonly
`search`	Busca archivos en Drive mediante una consulta	drive.readonly
`recent_documents`	Devuelve los documentos modificados más recientemente	drive.readonly
`fetch`	Descarga el contenido de un archivo de Drive	drive.readonly

Herramienta	Descripción	Ámbitos
`search`	Busca en los chats y mensajes de canales de Microsoft Teams	Chat.Read, ChannelMessage.Read.All
`fetch`	Obtiene un mensaje de Teams por su ruta	Chat.Read, ChannelMessage.Read.All
`get_chat_members`	Enumera los miembros de un chat de Teams	Chat.Read
`get_profile`	Devuelve el perfil del usuario autenticado de Teams	User.Read

Herramienta	Descripción	Ámbitos
`search_events`	Busca eventos de Outlook Calendar con filtros de fecha	Calendars.Read
`fetch_event`	Obtiene los detalles de un solo evento	Calendars.Read
`fetch_events_batch`	Obtiene varios eventos en una sola llamada	Calendars.Read
`list_events`	Enumera los eventos del calendario dentro de un rango de fechas	Calendars.Read
`get_profile`	Obtener el perfil del usuario actual	User.Read

Herramienta	Descripción	Ámbitos
`get_profile`	Devolver información del perfil de la cuenta de Outlook	User.Read
`list_messages`	Obtener correos electrónicos de Outlook de una carpeta	Mail.Read
`search_messages`	Buscar correos electrónicos de Outlook con filtros opcionales	Mail.Read
`get_recent_emails`	Devolver los correos electrónicos recibidos más recientemente	Mail.Read
`fetch_message`	Obtener un correo electrónico por su ID	Mail.Read
`fetch_messages_batch`	Obtener varios correos electrónicos en una sola solicitud	Mail.Read

Herramienta	Descripción	Ámbitos
`get_site`	Localizar un sitio de SharePoint por nombre de host y ruta	Sites.Read.All
`search`	Buscar documentos de SharePoint/OneDrive por palabra clave	Sites.Read.All, Files.Read.All
`list_recent_documents`	Devolver documentos a los que se accedió recientemente	Files.Read.All
`fetch`	Obtener contenido de una URL de descarga de archivos de Graph	Files.Read.All
`get_profile`	Obtener el perfil del usuario actual	User.Read

Diferir la carga de herramientas de un servidor MCP

Si usas la búsqueda de herramientas, puedes diferir la carga de las funciones que expone un servidor MCP hasta que el modelo decida que las necesita. Para hacerlo, establece defer_loading: true en la definición de la herramienta del servidor MCP.

Cuando difieres la carga de un servidor MCP, el modelo puede seguir usando la etiqueta y la descripción del servidor MCP para decidir cuándo buscar en él, pero las definiciones de cada función se cargan solo cuando se necesitan. Esto puede ayudar a reducir el consumo total de tokens y resulta especialmente útil para los servidores MCP que exponen una gran cantidad de funciones.

1
2
3
4
5
6
7
8{
    "type": "mcp",
    "server_label": "dmcp",
    "server_description": "A Dungeons and Dragons MCP server to assist with dice rolling.",
    "server_url": "https://dmcp-server.deno.dev/mcp",
    "defer_loading": true,
    "require_approval": "never"
}

Riesgos y seguridad

La herramienta MCP te permite conectar los modelos de OpenAI a servicios externos. Es una función potente que conlleva algunos riesgos.

En el caso de los conectores, existe el riesgo de enviar datos sensibles a OpenAI o de permitir que los modelos lean datos potencialmente sensibles en esos servicios.

Los servidores MCP remotos conllevan esos mismos riesgos y, además, no han sido verificados por OpenAI. Estos servidores pueden permitir que los modelos accedan a datos, los envíen y los reciban, y realicen acciones en esos servicios. Todos los servidores MCP son servicios de terceros sujetos a sus propios términos y condiciones.

Si encuentras un servidor MCP malicioso, repórtalo a security@openai.com.

A continuación, se presentan algunas prácticas recomendadas que debes considerar al integrar conectores y servidores MCP remotos.

Inyección de prompts

La inyección de prompts es un aspecto de seguridad importante en cualquier aplicación basada en LLM, especialmente cuando le das al modelo acceso a servidores MCP y conectores que pueden acceder a datos sensibles o realizar acciones. Usa estas herramientas con la precaución y las medidas de protección adecuadas si el prompt del modelo contiene contenido proporcionado por el usuario.

Exige siempre aprobación para las acciones sensibles

Usa las configuraciones disponibles de los parámetros require_approval y allowed_tools para garantizar que todas las acciones sensibles requieran un flujo de aprobación.

URL en las llamadas a herramientas MCP y sus resultados

Puede ser peligroso realizar solicitudes a URL o insertar URL de imágenes proporcionadas en los resultados de llamadas a herramientas, ya sean de conectores o de servidores MCP remotos. Asegúrate de confiar en los dominios y servicios que proporcionan esas URL antes de insertarlas o usarlas de cualquier otra forma en el código de tu aplicación.

Conectarse a servidores de confianza

Elige servidores oficiales alojados por los propios proveedores de servicios (por ejemplo, recomendamos conectarte al servidor de Stripe alojado por Stripe en mcp.stripe.com, en lugar de un servidor MCP de Stripe alojado por un tercero). Como actualmente no hay muchos servidores MCP remotos oficiales, podrías sentir la tentación de usar un servidor MCP alojado por una organización que no opera ese servidor y que actúa como intermediaria para enviar solicitudes a ese servicio a través de tu API. Si necesitas hacerlo, investiga con especial cuidado a estos “agregadores” y revisa detenidamente cómo usan tus datos.

Registra y revisa los datos que se comparten con servidores MCP de terceros.

Como los servidores MCP establecen sus propias definiciones de herramientas, pueden solicitar datos que no siempre te sientas cómodo compartiendo con el host de ese servidor MCP. Por este motivo, la herramienta MCP de la API Responses requiere, de forma predeterminada, la aprobación de cada llamada a una herramienta MCP. Al desarrollar tu aplicación, revisa de forma cuidadosa y exhaustiva el tipo de datos que se comparten con estos servidores MCP. Una vez que tengas suficiente confianza en ese servidor MCP, puedes omitir estas aprobaciones para reducir la latencia de ejecución.

También recomendamos registrar todos los datos que se envíen a los servidores MCP. Si usas la API Responses con store=true, estos datos ya se registran a través de la API durante 30 días, a menos que tu organización tenga habilitada la retención cero de datos. También puedes registrar estos datos en tus propios sistemas y revisarlos periódicamente para asegurarte de que se compartan según lo previsto.

Los servidores MCP maliciosos pueden incluir instrucciones ocultas (inyecciones de prompts) diseñadas para que los modelos de OpenAI se comporten de forma inesperada. Si bien OpenAI ha implementado protecciones integradas para ayudar a detectar y bloquear estas amenazas, es fundamental revisar cuidadosamente las entradas y salidas, y asegurarse de establecer conexiones únicamente con servidores de confianza.

Los servidores MCP pueden actualizar el comportamiento de las herramientas de forma inesperada, lo que podría dar lugar a comportamientos no deseados o maliciosos.

Implicaciones para la retención cero de datos y la residencia de datos

La herramienta MCP es compatible con la retención cero de datos y la residencia de datos, pero ten en cuenta que los servidores MCP son servicios de terceros y que los datos enviados a un servidor MCP están sujetos a las políticas de retención y residencia de datos de ese servicio.

En otras palabras, si tu organización tiene residencia de datos en Europa, OpenAI limitará la inferencia y el almacenamiento del Contenido del cliente a Europa hasta el momento en que se envíen comunicaciones o datos al servidor MCP. Es tu responsabilidad asegurarte de que el servidor MCP también cumpla con los requisitos de retención cero de datos o residencia de datos que puedas tener. Obtén más información sobre la retención cero de datos y la residencia de datos aquí.

Notas de uso

Disponibilidad de la API	Límites de solicitudes	Notas
Responses Chat Completions Assistants	Nivel 1 200 RPM Niveles 2 y 3 1000 RPM Niveles 4 y 5 2000 RPM	Precios ZDR y residencia de datos

Disponibilidad de la API

Límites de solicitudes

Notas

Responses

Chat Completions

Assistants

Nivel 1
200 RPM

Niveles 2 y 3
1000 RPM

Niveles 4 y 5
2000 RPM

Precios
ZDR y residencia de datos

Sugerencias

Primeros pasos

Conceptos fundamentales

SDK y CLI

Recursos

API heredadas

Elige un modelo

Texto y código

Diseño de prompts

Razonamiento

Imágenes y video

Tiempo real y audio

Modelos especializados

API de agentes

SDK de agentes

ChatKit

Búsqueda y recuperación

Conecta herramientas y datos

Crea flujos de trabajo con herramientas

Computadora y código

Contenido multimedia

GPT-Live

Realtime API

Desarrollar con voz

Conexiones

Procesamiento de audio

Pasa a producción

Rendimiento y calidad

Costo y rendimiento

Seguridad y gobernanza

Infraestructura y acceso

Operaciones

Conceptos fundamentales

Plan

Build

Test and publish

Conversion specs

Guías

Recursos

Primeros pasos

Guías

File Upload

API

Measurement

Advertiser API

Referencia de la API

Primeros pasos

Fundamentos

Explorar

Disponible en

Versiones

Flujos de trabajo

Capacidades

Referencia

Personalización

Archivo de configuración

Configuración de agentes

Ampliar las capacidades de ChatGPT y Codex

Linux

Windows

Flujos de trabajo de desarrollo

Extender y automatizar

Entornos

Crear con Codex

Integraciones de terceros

Referencia

Permisos

Codex Security

Seguridad cibernética

Primeros pasos

ChatGPT Work

Identidad y autenticación

Acceso, políticas y modelos del espacio de trabajo

Controles de complementos y conectores

Uso, gobernanza y cumplimiento

Implementación y proveedores de modelos

Comunidad

Blog

Comunidad

Blog