codecamp

OpenAI MCP 服务器

除函数调用外,也可用远程MCP或安全MCP隧道扩展模型,连接并控制外部服务。调用可自动允许,也可要求开发者明确批准。

远程MCP是公共互联网中实现远程模型上下文协议的服务器;安全MCP隧道可连接本地或私有服务器,无需公开暴露。

本文针对Responses API。内置连接器仍兼容既有模型,弃用范围与示例见旧连接器。Agents API会话应采用MCP连接,支持托管服务端或沙箱发起连接。

安全MCP隧道

私有、本地部署或防火墙内服务器可用安全MCP隧道连接受支持的OpenAI产品,无需公开服务器。从openai/tunnel-client获取当前公开发行版。

快速开始

Responses请求使用 type: mcp。远程服务器设置 server_url,隧道连接本地服务器使用 tunnel_id。某些服务器还需在 authorization 提供OAuth访问令牌。

以下查询公共OpenAI文档MCP中的Responses流式文档。该服务只读、无需认证,因此示例跳过调用审批;涉及敏感数据时应保留审批。

来源示例1(bash)

程序中的自然语言译释29:

在OpenAI文档中搜索Responses API流式输出,并返回相关链接。

程序中的自然语言译释30:

搜索并读取公开的OpenAI文档。

## [中文] 配置公开文档MCP的server_url并提交文档查询;此示例无敏感数据且跳过审批。
curl 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": "openai_docs",
        "server_description": "Search and read the public OpenAI documentation.",
        "server_url": "https://developers.openai.com/mcp",
        "require_approval": "never"
      }
    ],
    "input": "Search the OpenAI docs for Responses API streaming and return the relevant links."
  }'

来源示例2(javascript)

本段复用的中文释义:译释29、译释30。

// [中文] 配置公开文档MCP的server_url并提交文档查询;此示例无敏感数据且跳过审批。
import OpenAI from "openai";
const client = new OpenAI();

const resp = await client.responses.create({
  model: "gpt-6-astra",
  tools: [
    {
      type: "mcp",
      server_label: "openai_docs",
      server_description: "Search and read the public OpenAI documentation.",
      server_url: "https://developers.openai.com/mcp",
      require_approval: "never",
    },
  ],
  input:
    "Search the OpenAI docs for Responses API streaming and return the relevant links.",
});

console.log(resp.output_text);

来源示例3(python)

本段复用的中文释义:译释29、译释30。

## [中文] 配置公开文档MCP的server_url并提交文档查询;此示例无敏感数据且跳过审批。
from openai import OpenAI

client = OpenAI()

resp = client.responses.create(
    model="gpt-6-astra",
    tools=[
        {
            "type": "mcp",
            "server_label": "openai_docs",
            "server_description": "Search and read the public OpenAI documentation.",
            "server_url": "https://developers.openai.com/mcp",
            "require_approval": "never",
        },
    ],
    input="Search the OpenAI docs for Responses API streaming and return the relevant links.",
)

print(resp.output_text)

来源示例4(go)

本段复用的中文释义:译释29、译释30。

// [中文] 配置公开文档MCP的server_url并提交文档查询;此示例无敏感数据且跳过审批。
package 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("openai_docs")
    tool.OfMcp.ServerDescription = openai.String("Search and read the public OpenAI documentation.")
    tool.OfMcp.ServerURL = openai.String("https://developers.openai.com/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("Search the OpenAI docs for Responses API streaming and return the relevant links.")},
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(response.OutputText())
}

来源示例5(java)

本段复用的中文释义:译释29、译释30。

// [中文] 配置公开文档MCP的server_url并提交文档查询;此示例无敏感数据且跳过审批。
import 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(
            "Search the OpenAI docs for Responses API streaming and return the relevant links.")
        .addTool(
            Tool.Mcp.builder()
                .serverLabel("openai_docs")
                .serverDescription("Search and read the public OpenAI documentation.")
                .serverUrl("https://developers.openai.com/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()));

来源示例6(csharp)

本段复用的中文释义:译释29。

// [中文] 配置公开文档MCP的server_url并提交文档查询;此示例无敏感数据且跳过审批。
using 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: "openai_docs",
        serverUri: new Uri("https://developers.openai.com/mcp"),
        toolCallApprovalPolicy: DefaultMcpToolCallApprovalPolicy.NeverRequireApproval
    )
);
options.InputItems.Add(ResponseItem.CreateUserMessageItem("Search the OpenAI docs for Responses API streaming and return the relevant links."));

ResponseResult response = await client.CreateResponseAsync(options);

Console.WriteLine(response.GetOutputText());

来源示例7(ruby)

本段复用的中文释义:译释29、译释30。

## [中文] 配置公开文档MCP的server_url并提交文档查询;此示例无敏感数据且跳过审批。
require "openai"

openai = OpenAI::Client.new

response = openai.responses.create(
  model: "gpt-6-astra",
  tools: [
    {
      type: "mcp",
      server_label: "openai_docs",
      server_description: "Search and read the public OpenAI documentation.",
      server_url: "https://developers.openai.com/mcp",
      require_approval: "never"
    }
  ],
  input: "Search the OpenAI docs for Responses API streaming and return the relevant links."
)

puts(response.output_text)

必须信任连接的服务器,恶意服务器可能外传上下文中的敏感数据。使用前阅读风险与安全。

模型决定使用MCP时,先列出工具,在output产生 mcp_list_tools。以下示意只列搜索工具并缩短描述,实际还提供其他文档工具。

来源示例8(json):以下保留协议载荷、配置、返回示意或语法定义;省略号及片段不代表完整可运行程序。

{
  "id": "mcpl_68a6102a4968819c8177b05584dd627b0679e572a900e618",
  "type": "mcp_list_tools",
  "server_label": "openai_docs",
  "tools": [
    {
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false
      },
      "description": "Search the public OpenAI documentation.",
      "input_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "type": "object",
        "properties": {
          "query": {
            "type": "string",
            "minLength": 1
          },
          "limit": {
            "type": "integer",
            "minimum": 1,
            "maximum": 50
          },
          "cursor": {
            "type": "string"
          }
        },
        "required": ["query"]
      },
      "name": "search_openai_docs"
    }
  ]
}

随后调用工具会产生 mcp_call,记录发给工具的内容及工具返回结果。

来源示例9(json):以下保留协议载荷、配置、返回示意或语法定义;省略号及片段不代表完整可运行程序。

{
  "id": "mcp_68a6102d8948819c9b1490d36d5ffa4a0679e572a900e618",
  "type": "mcp_call",
  "approval_request_id": null,
  "arguments": "{\"query\":\"Responses API streaming\",\"limit\":1}",
  "error": null,
  "name": "search_openai_docs",
  "output": "{\"hits\":[{\"url\":\"https://developers.openai.com/api/docs/guides/streaming-responses\"}]}",
  "server_label": "openai_docs"
}

工作原理

近期模型中多数支持Responses MCP,具体核对模型兼容性。OpenAI侧按导入工具定义和调用消耗的词元计费,不额外逐MCP调用收费。

步骤1:列出可用工具

在tools指定远程服务器后,API尝试获取工具清单。支持Streamable HTTP或HTTP/SSE传输。成功后产生mcp_list_tools,其tools列出成功导入的定义。

来源示例10(json):以下保留协议载荷、配置、返回示意或语法定义;省略号及片段不代表完整可运行程序。

{
  "id": "mcpl_68a6102a4968819c8177b05584dd627b0679e572a900e618",
  "type": "mcp_list_tools",
  "server_label": "openai_docs",
  "tools": [
    {
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false
      },
      "description": "Search the public OpenAI documentation.",
      "input_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "type": "object",
        "properties": {
          "query": {
            "type": "string",
            "minLength": 1
          },
          "limit": {
            "type": "integer",
            "minimum": 1,
            "maximum": 50
          },
          "cursor": {
            "type": "string"
          }
        },
        "required": ["query"]
      },
      "name": "search_openai_docs"
    }
  ]
}

只要该项保留在请求上下文中,后续轮次无需重新获取清单。建议在会话或工作流中保留,减少延迟。

筛选工具

服务器工具可能很多,增加成本和延迟。只需子集时用allowed_tools限制导入;这里仅导入search_openai_docs查文档链接。

来源示例11(bash)

本段复用的中文释义:译释29、译释30。

## [中文] 用allowed_tools限制只导入文档搜索工具,不开放服务器全部工具。
curl 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": "openai_docs",
        "server_description": "Search and read the public OpenAI documentation.",
        "server_url": "https://developers.openai.com/mcp",
        "require_approval": "never",
        "allowed_tools": ["search_openai_docs"]
      }
    ],
    "input": "Search the OpenAI docs for Responses API streaming and return the relevant links."
  }'

来源示例12(javascript)

本段复用的中文释义:译释29、译释30。

// [中文] 用allowed_tools限制只导入文档搜索工具,不开放服务器全部工具。
import OpenAI from "openai";
const client = new OpenAI();

const resp = await client.responses.create({
  model: "gpt-6-astra",
  tools: [
    {
      type: "mcp",
      server_label: "openai_docs",
      server_description: "Search and read the public OpenAI documentation.",
      server_url: "https://developers.openai.com/mcp",
      require_approval: "never",
      allowed_tools: ["search_openai_docs"],
    },
  ],
  input:
    "Search the OpenAI docs for Responses API streaming and return the relevant links.",
});

console.log(resp.output_text);

来源示例13(python)

本段复用的中文释义:译释29、译释30。

## [中文] 用allowed_tools限制只导入文档搜索工具,不开放服务器全部工具。
from openai import OpenAI

client = OpenAI()

resp = client.responses.create(
    model="gpt-6-astra",
    tools=[
        {
            "type": "mcp",
            "server_label": "openai_docs",
            "server_description": "Search and read the public OpenAI documentation.",
            "server_url": "https://developers.openai.com/mcp",
            "require_approval": "never",
            "allowed_tools": ["search_openai_docs"],
        }
    ],
    input="Search the OpenAI docs for Responses API streaming and return the relevant links.",
)

print(resp.output_text)

来源示例14(go)

本段复用的中文释义:译释29、译释30。

// [中文] 用allowed_tools限制只导入文档搜索工具,不开放服务器全部工具。
package 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("openai_docs")
    tool.OfMcp.ServerDescription = openai.String("Search and read the public OpenAI documentation.")
    tool.OfMcp.ServerURL = openai.String("https://developers.openai.com/mcp")
    tool.OfMcp.RequireApproval = responses.ToolMcpRequireApprovalUnionParam{OfMcpToolApprovalSetting: openai.String("never")}
    tool.OfMcp.AllowedTools = responses.ToolMcpAllowedToolsUnionParam{OfMcpAllowedTools: []string{"search_openai_docs"}}

    response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
        Model: "gpt-6-astra",
        Tools: []responses.ToolUnionParam{tool},
        Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Search the OpenAI docs for Responses API streaming and return the relevant links.")},
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(response.OutputText())
}

来源示例15(java)

本段复用的中文释义:译释29、译释30。

// [中文] 用allowed_tools限制只导入文档搜索工具,不开放服务器全部工具。
import 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(
            "Search the OpenAI docs for Responses API streaming and return the relevant links.")
        .addTool(
            Tool.Mcp.builder()
                .serverLabel("openai_docs")
                .serverDescription("Search and read the public OpenAI documentation.")
                .serverUrl("https://developers.openai.com/mcp")
                .requireApproval(Tool.Mcp.RequireApproval.McpToolApprovalSetting.NEVER)
                .allowedToolsOfMcp(List.of("search_openai_docs"))
                .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()));

来源示例16(csharp)

本段复用的中文释义:译释29。

// [中文] 用allowed_tools限制只导入文档搜索工具,不开放服务器全部工具。
using 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: "openai_docs",
        serverUri: new Uri("https://developers.openai.com/mcp"),
        allowedTools: new McpToolFilter() { ToolNames = { "search_openai_docs" } },
        toolCallApprovalPolicy: DefaultMcpToolCallApprovalPolicy.NeverRequireApproval
    )
);
options.InputItems.Add(ResponseItem.CreateUserMessageItem("Search the OpenAI docs for Responses API streaming and return the relevant links."));

ResponseResult response = await client.CreateResponseAsync(options);

Console.WriteLine(response.GetOutputText());

来源示例17(ruby)

本段复用的中文释义:译释29、译释30。

## [中文] 用allowed_tools限制只导入文档搜索工具,不开放服务器全部工具。
require "openai"

client = OpenAI::Client.new

response = client.responses.create(
  model: "gpt-6-astra",
  input: "Search the OpenAI docs for Responses API streaming and return the relevant links.",
  tools: [
    {
      type: :mcp,
      server_label: "openai_docs",
      server_description: "Search and read the public OpenAI documentation.",
      server_url: "https://developers.openai.com/mcp",
      require_approval: :never,
      allowed_tools: ["search_openai_docs"]
    }
  ]
)

puts(response.output_text)

步骤2:调用工具

模型根据上下文决定调用,API请求远程MCP并把输出放回上下文,产生mcp_call。

来源示例18(json):以下保留协议载荷、配置、返回示意或语法定义;省略号及片段不代表完整可运行程序。

{
  "id": "mcp_68a6102d8948819c9b1490d36d5ffa4a0679e572a900e618",
  "type": "mcp_call",
  "approval_request_id": null,
  "arguments": "{\"query\":\"Responses API streaming\",\"limit\":1}",
  "error": null,
  "name": "search_openai_docs",
  "output": "{\"hits\":[{\"url\":\"https://developers.openai.com/api/docs/guides/streaming-responses\"}]}",
  "server_label": "openai_docs"
}

项中包含参数与output。模型可多次调用,因此一次API请求可能有多个项。失败时error含协议错误、工具执行错误或连接错误,参见MCP错误规范。

批准

默认在向连接器或远程服务器分享数据前请求批准,便于控制与观察共享内容,建议仔细审核并可记录。将快速开始的require_approval从never改为always,可体验审批。输出会出现mcp_approval_request:

来源示例19(json):以下保留协议载荷、配置、返回示意或语法定义;省略号及片段不代表完整可运行程序。

{
  "id": "mcpr_682d498e3bd4819196a0ce1664f8e77b04ad1e533afccbfa",
  "type": "mcp_approval_request",
  "arguments": "{\"query\":\"Responses API streaming\",\"limit\":1}",
  "name": "search_openai_docs",
  "server_label": "openai_docs"
}

审核工具与参数,再创建新响应并加入mcp_approval_response。将示意响应ID和请求ID换为真实值;.NET示例从首个响应读取。每次批准仅对应一次调用,后续请求照样处理。

来源示例20(bash)

本段复用的中文释义:译释30。

## [中文] 批准指定的MCP请求;approval_request_id及previous_response_id必须来自真实响应。
curl 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": "openai_docs",
        "server_description": "Search and read the public OpenAI documentation.",
        "server_url": "https://developers.openai.com/mcp",
        "require_approval": "always"
      }
    ],
    "previous_response_id": "resp_682d498bdefc81918b4a6aa477bfafd904ad1e533afccbfa",
    "input": [{
      "type": "mcp_approval_response",
      "approve": true,
      "approval_request_id": "mcpr_682d498e3bd4819196a0ce1664f8e77b04ad1e533afccbfa"
    }]
  }'

来源示例21(javascript)

本段复用的中文释义:译释30。

// [中文] 批准指定的MCP请求;approval_request_id及previous_response_id必须来自真实响应。
import OpenAI from "openai";
const client = new OpenAI();

const resp = await client.responses.create({
  model: "gpt-6-astra",
  tools: [
    {
      type: "mcp",
      server_label: "openai_docs",
      server_description: "Search and read the public OpenAI documentation.",
      server_url: "https://developers.openai.com/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);

来源示例22(python)

本段复用的中文释义:译释30。

## [中文] 批准指定的MCP请求;approval_request_id及previous_response_id必须来自真实响应。
from openai import OpenAI

client = OpenAI()

resp = client.responses.create(
    model="gpt-6-astra",
    tools=[
        {
            "type": "mcp",
            "server_label": "openai_docs",
            "server_description": "Search and read the public OpenAI documentation.",
            "server_url": "https://developers.openai.com/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)

来源示例23(go)

本段复用的中文释义:译释30。

// [中文] 批准指定的MCP请求;approval_request_id及previous_response_id必须来自真实响应。
package 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("openai_docs")
    tool.OfMcp.ServerDescription = openai.String("Search and read the public OpenAI documentation.")
    tool.OfMcp.ServerURL = openai.String("https://developers.openai.com/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())
}

来源示例24(java)

本段复用的中文释义:译释30。

// [中文] 批准指定的MCP请求;approval_request_id及previous_response_id必须来自真实响应。
import 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("openai_docs")
                .serverDescription("Search and read the public OpenAI documentation.")
                .serverUrl("https://developers.openai.com/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()));

来源示例25(csharp)

本段复用的中文释义:译释29。

// [中文] 批准指定的MCP请求;approval_request_id及previous_response_id必须来自真实响应。
using 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: "openai_docs",
        serverUri: new Uri("https://developers.openai.com/mcp"),
        toolCallApprovalPolicy: DefaultMcpToolCallApprovalPolicy.AlwaysRequireApproval
    )
);

// [中文] 步骤1:创建会请求工具批准的响应。
// 第 1 步:创建请求审批工具调用的响应。
options.InputItems.Add(ResponseItem.CreateUserMessageItem("Search the OpenAI docs for Responses API streaming and return the relevant links."));
ResponseResult response1 = await client.CreateResponseAsync(options);

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

// [中文] 步骤2:批准该调用,再读取最终响应。
// 第 2 步:批准工具调用并获取最终响应。
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());

来源示例26(ruby)

本段复用的中文释义:译释30。

## [中文] 批准指定的MCP请求;approval_request_id及previous_response_id必须来自真实响应。
require "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: "openai_docs",
      server_url: "https://developers.openai.com/mcp",
      server_description: "Search and read the public OpenAI documentation.",
      require_approval: :always
    }
  ]
)

puts(response.output_text)

通过previous_response_id关联发起审批的响应,也可手动把前次输出作为下次输入,以精细控制上下文。

建立信任后,可在require_approval对象中列出可跳过审批的工具,或设never跳过整个服务器全部工具,以降低延迟。

来源示例27(bash)

程序中的自然语言译释70:

2025-03-26版MCP规范支持哪些传输协议?

## [中文] 配置部分工具免审批;这里是策略配置,不等于所有数据都适合外传。
curl 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?"
  }'

来源示例28(javascript)

本段复用的中文释义:译释70。

// [中文] 配置部分工具免审批;这里是策略配置,不等于所有数据都适合外传。
import 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);

来源示例29(python)

本段复用的中文释义:译释70。

## [中文] 配置部分工具免审批;这里是策略配置,不等于所有数据都适合外传。
from 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)

来源示例30(go)

本段复用的中文释义:译释70。

// [中文] 配置部分工具免审批;这里是策略配置,不等于所有数据都适合外传。
package 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())
}

来源示例31(java)

程序中的自然语言译释130:

2025-03-26版MCP规范支持哪些传输协议?

// [中文] 配置部分工具免审批;这里是策略配置,不等于所有数据都适合外传。
import 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()));

来源示例32(csharp)

本段复用的中文释义:译释70。

// [中文] 配置部分工具免审批;这里是策略配置,不等于所有数据都适合外传。
using 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());

来源示例33(ruby)

本段复用的中文释义:译释130。

## [中文] 配置部分工具免审批;这里是策略配置,不等于所有数据都适合外传。
require "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)

身份验证

公共文档MCP无需认证,其他服务通常使用OAuth访问令牌,通过authorization传入。Stripe示例:

来源示例34(bash)

程序中的自然语言译释71:

创建金额为20美元的支付链接。

## [中文] 通过authorization给Stripe MCP提供令牌,并请求创建支付链接;真实运行具有外部副作用。
curl 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"
      }
    ]
  }'

来源示例35(javascript)

本段复用的中文释义:译释71。

// [中文] 通过authorization给Stripe MCP提供令牌,并请求创建支付链接;真实运行具有外部副作用。
import 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);

来源示例36(python)

本段复用的中文释义:译释71。

## [中文] 通过authorization给Stripe MCP提供令牌,并请求创建支付链接;真实运行具有外部副作用。
import 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)

来源示例37(go)

本段复用的中文释义:译释71。

// [中文] 通过authorization给Stripe MCP提供令牌,并请求创建支付链接;真实运行具有外部副作用。
package 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())
}

来源示例38(java)

本段复用的中文释义:译释71。

// [中文] 通过authorization给Stripe MCP提供令牌,并请求创建支付链接;真实运行具有外部副作用。
import 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()));

来源示例39(csharp)

本段复用的中文释义:译释71。

// [中文] 通过authorization给Stripe MCP提供令牌,并请求创建支付链接;真实运行具有外部副作用。
using 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());

来源示例40(ruby)

本段复用的中文释义:译释71。

## [中文] 通过authorization给Stripe MCP提供令牌,并请求创建支付链接;真实运行具有外部副作用。
require "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)

为避免敏感令牌泄漏,Responses不保存authorization值,返回的Response对象也不显示。因此每次创建响应都必须重新提供。

旧连接器

对于2026年9月1日之后发布的模型,connector_id 已弃用,应以server_url连接远程MCP,或tunnel_id经安全隧道连接本地MCP。已有模型保留连接器支持,以下使用早于截止日的gpt-5.2。

Responses内置有限的第三方连接器,可引入Dropbox、Gmail等上下文。与远程MCP作用相近,但以唯一connector_id代替server_url。应用必须通过authorization提供OAuth令牌。

来源示例41(bash)

程序中的自然语言译释72:

总结第二季度财报。

## [中文] 使用旧connector_id和兼容的gpt-5.2,凭证由OAuth流程提供。
curl 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."
  }'

来源示例42(javascript)

本段复用的中文释义:译释72。

// [中文] 使用旧connector_id和兼容的gpt-5.2,凭证由OAuth流程提供。
import 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);

来源示例43(python)

本段复用的中文释义:译释72。

## [中文] 使用旧connector_id和兼容的gpt-5.2,凭证由OAuth流程提供。
import 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)

来源示例44(go)

本段复用的中文释义:译释72。

// [中文] 使用旧connector_id和兼容的gpt-5.2,凭证由OAuth流程提供。
package 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())
}

来源示例45(java)

本段复用的中文释义:译释72。

// [中文] 使用旧connector_id和兼容的gpt-5.2,凭证由OAuth流程提供。
import 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()));

来源示例46(csharp)

本段复用的中文释义:译释72。

// [中文] 使用旧connector_id和兼容的gpt-5.2,凭证由OAuth流程提供。
using 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());

来源示例47(ruby)

本段复用的中文释义:译释72。

## [中文] 使用旧connector_id和兼容的gpt-5.2,凭证由OAuth流程提供。
require "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)

可用连接器

应用 ID
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

来源优先提供尚无官方远程MCP的服务。GitHub已有官方MCP,可向server_url传 https://api.githubcopilot.com/mcp/。

为连接器授权

OAuth客户端注册和授权由应用单独完成,再把访问令牌放入authorization。测试可用Google OAuth 2.0 Playground生成临时令牌,在Step 1: Select and authorize APIs(选择并授权API)输入以下作用域以读取日历事件:

来源示例48(text):以下保留协议载荷、配置、返回示意或语法定义;省略号及片段不代表完整可运行程序。

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

以Google账户授权后,在Step 2: Exchange authorization code for tokens(用授权码交换令牌)取得令牌,用日历连接器测试:

来源示例49(bash)

## [中文] 用OAuth令牌连接Google Calendar,提交查看今日日程的请求。
curl 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?"
  }'

来源示例50(javascript)

程序中的自然语言译释73:

我今天的Google日历里有什么安排?

// [中文] 用OAuth令牌连接Google Calendar,提交查看今日日程的请求。
import 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);

来源示例51(python)

本段复用的中文释义:译释73。

## [中文] 用OAuth令牌连接Google Calendar,提交查看今日日程的请求。
import 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)

来源示例52(go)

本段复用的中文释义:译释73。

// [中文] 用OAuth令牌连接Google Calendar,提交查看今日日程的请求。
package 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())
}

来源示例53(java)

本段复用的中文释义:译释73。

// [中文] 用OAuth令牌连接Google Calendar,提交查看今日日程的请求。
import 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()));

来源示例54(csharp)

本段复用的中文释义:译释73。

// [中文] 用OAuth令牌连接Google Calendar,提交查看今日日程的请求。
using 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());

来源示例55(ruby)

本段复用的中文释义:译释73。

## [中文] 用OAuth令牌连接Google Calendar,提交查看今日日程的请求。
require "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)

连接器调用同样返回mcp_call,本例参数和响应均为JSON字符串。

来源示例56(json):以下保留协议载荷、配置、返回示意或语法定义;省略号及片段不代表完整可运行程序。

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

各连接器可用工具

工具取决于OAuth令牌的作用域,以下保留来源的工具及权限对应。

Dropbox

工具 说明 Scopes
search 搜索匹配查询的文件 files.metadata.read, account_info.read
fetch 按路径取文件,可选原始下载 files.content.read
search_files 搜索并返回文件结果 files.metadata.read, account_info.read
fetch_file 读取文本或原始内容 files.content.read, account_info.read
list_recent_files 最近修改的可访问文件 files.metadata.read, account_info.read
get_profile 当前用户资料 account_info.read

Gmail

工具 说明 Scopes
get_profile 当前Gmail用户资料 userinfo.email, userinfo.profile
search_emails 按查询或标签搜索邮件 gmail.modify
search_email_ids 取匹配搜索的消息ID gmail.modify
get_recent_emails 最近收到的邮件 gmail.modify
read_email 读取邮件及正文 gmail.modify
batch_read_email 一次读取多封邮件 gmail.modify

Google Calendar

工具 说明 Scopes
get_profile 当前日历用户资料 userinfo.email, userinfo.profile
search 在可选时间窗搜索事件 calendar.events
fetch 单个事件详情 calendar.events
search_events 按条件查事件 calendar.events
read_event 按ID读事件 calendar.events

Google Drive

工具 说明 Scopes
get_profile 当前Drive用户资料 userinfo.email, userinfo.profile
list_drives 可访问的共享云端硬盘 drive.readonly
search 按查询搜索文件 drive.readonly
recent_documents 最近修改的文档 drive.readonly
fetch 下载文件内容 drive.readonly

Microsoft Teams

工具 说明 Scopes
search 搜索聊天和频道消息 Chat.Read, ChannelMessage.Read.All
fetch 按路径读取消息 Chat.Read, ChannelMessage.Read.All
get_chat_members 列出聊天成员 Chat.Read
get_profile 已认证用户资料 User.Read

Outlook Calendar

工具 说明 Scopes
search_events 按日期筛选事件 Calendars.Read
fetch_event 单个事件详情 Calendars.Read
fetch_events_batch 批量读取事件 Calendars.Read
list_events 列出日期范围内事件 Calendars.Read
get_profile 当前用户资料 User.Read

Outlook Email

工具 说明 Scopes
get_profile Outlook账户资料 User.Read
list_messages 从文件夹读取邮件 Mail.Read
search_messages 可选筛选条件搜索邮件 Mail.Read
get_recent_emails 最近收到的邮件 Mail.Read
fetch_message 按ID读取邮件 Mail.Read
fetch_messages_batch 批量读取邮件 Mail.Read

SharePoint

工具 说明 Scopes
get_site 按主机名及路径解析站点 Sites.Read.All
search 按关键字搜索SharePoint/OneDrive文档 Sites.Read.All, Files.Read.All
list_recent_documents 最近访问的文档 Files.Read.All
fetch 从Graph文件下载URL读取内容 Files.Read.All
get_profile 当前用户资料 User.Read

延迟加载MCP服务器中的工具

使用工具搜索时,在服务器定义设置defer_loading:true。模型仍看到服务器标签与描述以决定何时搜索,内部函数定义按需加载,可减少词元,对函数众多的服务器尤为有用。

来源示例57(json):以下保留协议载荷、配置、返回示意或语法定义;省略号及片段不代表完整可运行程序。

本段复用的中文释义:译释30。

{
    "type": "mcp",
    "server_label": "openai_docs",
    "server_description": "Search and read the public OpenAI documentation.",
    "server_url": "https://developers.openai.com/mcp",
// highlight-start:subtle
    "defer_loading": true,
// highlight-end
    "require_approval": "never"
}

风险与安全

连接器可能向OpenAI发送敏感数据,或让模型读取第三方敏感数据。远程MCP还有未经OpenAI验证的风险,可读写数据并执行动作,受各自第三方条款约束。发现恶意服务器可向security@openai.com报告。

提示注入

模型输入含用户提供内容、工具又可读敏感数据或操作服务时,应防范隐藏指令和工具滥用,使用适当保护。

敏感操作始终要求批准

通过require_approval及allowed_tools确保敏感操作进入审批。

工具调用和输出中的URL

请求输出提供的URL或嵌入其图像可能有危险,使用前确认域名与服务可信。

连接可信服务器

优先服务提供方自行托管的官方服务器,例如Stripe的mcp.stripe.com。第三方代理或聚合器需额外尽调,仔细核对数据使用。

记录和审查共享数据

服务器定义自己的工具,可能请求你不愿共享的信息,因此Responses默认每次调用审批。仔细审查共享范围,建立信任后再考虑跳过以降低延迟。建议记录发送数据并定期复查;来源说明store=true通常记录30天,组织启用ZDR时另有规则,也可在自己的系统保存日志。

恶意MCP可能在返回中藏指令,平台防护不能替代输入输出审查;只连接可信服务器。服务器工具行为也可能突然变化,产生意外或恶意行为。

ZDR与数据驻留的影响

MCP工具兼容ZDR及数据驻留,但第三方收到的数据受其自己的政策约束。例如欧洲驻留组织,OpenAI在向MCP发送前将客户内容推理及存储限制在欧洲;第三方是否也满足要求由应用负责核实。参见数据控制。

使用说明

来源表列出Responses、Chat Completions、Assistants入口;Build为1000 RPM,Launch and Grow为2000 RPM,并链接价格和数据要求。正文流程针对Responses,不能据此将其MCP请求结构直接用于其他接口。

OpenAI 浏览器与桌面驱动
OpenAI 程序化工具调用
温馨提示
下载编程狮App,免费阅读超1000+编程语言教程
取消
确定
目录

其他能力与进阶指南

Embeddings 接口参考

审计日志接口参考

关闭

MIP.setData({ 'pageTheme' : getCookie('pageTheme') || {'day':true, 'night':false}, 'pageFontSize' : getCookie('pageFontSize') || 20 }); MIP.watch('pageTheme', function(newValue){ setCookie('pageTheme', JSON.stringify(newValue)) }); MIP.watch('pageFontSize', function(newValue){ setCookie('pageFontSize', newValue) }); function setCookie(name, value){ var days = 1; var exp = new Date(); exp.setTime(exp.getTime() + days*24*60*60*1000); document.cookie = name + '=' + value + ';expires=' + exp.toUTCString(); } function getCookie(name){ var reg = new RegExp('(^| )' + name + '=([^;]*)(;|$)'); return document.cookie.match(reg) ? JSON.parse(document.cookie.match(reg)[2]) : null; }