除了透過函式呼叫 提供工具給模型之外，你也可以使用 遠端 MCP 伺服器 或 安全 MCP 通道 ，為模型增添新的能力。這些工具讓模型能在回應使用者提示詞時，視需要連線至外部服務並加以控制。你可以自動允許這些工具呼叫，也可以加以限制，要求必須由你這位開發人員明確核准。
本指南說明如何在 Responses API 中使用 MCP 工具。現有模型仍支援內建連接器；如需瞭解棄用政策與相容性範例，請參閱舊版連接器 。若要在智慧體 API 工作階段中使用 MCP，請參閱 MCP 連線 ，其中說明如何從受管服務或你的沙盒建立連線。
如果你的 MCP 伺服器屬於私有伺服器、部署於地端，或位於防火牆後方，可以使用安全 MCP 通道 ，將其連線至支援的 OpenAI 產品，無須將伺服器暴露於公用網際網路。請從 openai/tunnel-client 下載最新的公開版本。
在 Responses API 中使用 mcp 工具類型。若要連線至遠端 MCP 伺服器，請設定 server_url；若要透過安全 MCP 通道 連線至本機 MCP 伺服器，則使用 tunnel_id。視伺服器而定，你可能還需要在 authorization 參數中提供 OAuth 存取 Token。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 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": "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
19 import 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
19 from 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
27 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("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
24 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("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
19 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: "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
19 require "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) 開發人員務必確保與
Responses API 搭配使用的所有遠端 MCP 伺服器都值得信任。惡意伺服器可能從
進入模型上下文的任何內容中竊取敏感資料。使用此工具前，請仔細閱讀下方的
風險與安全 章節。
API 會在模型回應的 output 陣列中傳回新的項目。如果模型決定使用 MCP 伺服器，它會先發出請求，列出該伺服器上的可用工具，並建立一個 mcp_list_tools 輸出項目。在上方的遠端 MCP 伺服器範例中，此項目只包含一個工具定義：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 { "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" } ] } 如果模型決定呼叫 MCP 伺服器上的某個可用工具，你還會看到 mcp_call 輸出，其中會顯示模型傳送給 MCP 工具的內容，以及 MCP 工具傳回的輸出。
1 2 3 4 5 6 7 8 9 10 { "id" : "mcp_68a6102d8948819c9b1490d36d5ffa4a0679e572a900e618" , "type" : "mcp_call" , "approval_request_id" : null , "arguments" : "{ \" diceRollExpression \" : \" 2d4 + 1 \" }" , "error" : null , "name" : "roll" , "output" : "4" , "server_label" : "dmcp" } 請繼續閱讀下方指南，進一步瞭解 MCP 工具的運作方式、如何篩選可用工具，以及如何處理工具呼叫的核准請求。
多數近期推出的模型都能在 Responses API 中使用 MCP 工具。你可以在這裡 查看模型是否相容於 MCP 工具。使用 MCP 工具時，你只需支付匯入工具定義或進行工具呼叫時所用的 Token 費用，每次工具呼叫不會另收費用。
以下將逐步說明 API 呼叫 MCP 工具時的處理流程。
當你在 tools 參數中指定遠端 MCP 伺服器時，API 會嘗試從該伺服器取得工具清單。Responses API 可與支援 Streamable HTTP 或 HTTP/SSE 傳輸通訊協定的遠端 MCP 伺服器搭配使用。
如果成功取得工具清單，模型回應的輸出中就會出現一個新的 mcp_list_tools 輸出項目。此物件的 tools 屬性會顯示成功匯入的工具。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 { "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" } ] } 只要 API 請求的上下文中保留了 mcp_list_tools 項目，
API 就不會在對話 的每一輪
都重新向 MCP 伺服器取得工具清單。
建議在每次對話或工作流程執行期間，
都將此項目保留在模型的上下文中，以降低延遲。
有些 MCP 伺服器可能提供數十種工具，向模型提供大量工具可能導致成本和延遲增加。如果你只需要 MCP 伺服器提供的部分工具，可以使用 allowed_tools 參數，只匯入這些工具。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 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": "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
20 import 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
20 from 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
28 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("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
26 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("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
20 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: "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
20 require "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) 模型取得這些工具定義後，可能會根據上下文的內容選擇呼叫工具。當模型決定呼叫 MCP 工具時，API 會向遠端 MCP 伺服器發出請求以呼叫該工具，並將工具輸出放入模型的上下文中。這會建立一個 mcp_call 項目，如下所示：
1 2 3 4 5 6 7 8 9 10 { "id" : "mcp_68a6102d8948819c9b1490d36d5ffa4a0679e572a900e618" , "type" : "mcp_call" , "approval_request_id" : null , "arguments" : "{ \" diceRollExpression \" : \" 2d4 + 1 \" }" , "error" : null , "name" : "roll" , "output" : "4" , "server_label" : "dmcp" } 此項目包含模型決定用於這次工具呼叫的引數，以及遠端 MCP 伺服器傳回的 output。所有模型都可以選擇進行多次 MCP 工具呼叫，因此單一 API 請求可能會產生多個這類項目。
工具呼叫失敗時，此項目的 error 欄位會填入 MCP 通訊協定錯誤、MCP 工具執行錯誤或一般連線錯誤。你可以在此處 的 MCP 規格中查看 MCP 錯誤的說明。
預設情況下，OpenAI 會在與連接器或遠端 MCP 伺服器分享任何資料之前，先要求你核准。核准機制讓你能掌握並控制傳送至 MCP 伺服器的資料。我們強烈建議你仔細審查與遠端 MCP 伺服器分享的所有資料，並可視需要記錄這些資料。要求核准 MCP 工具呼叫時，會在 Response 的輸出中建立一個 mcp_approval_request 項目，如下所示：
1 2 3 4 5 6 7 { "id" : "mcpr_68a619e1d82c8190b50c1ccba7ad18ef0d2d23a86136d339" , "type" : "mcp_approval_request" , "arguments" : "{ \" diceRollExpression \" : \" 2d4 + 1 \" }" , "name" : "roll" , "server_label" : "dmcp" } 接著，你可以建立新的 Response 物件，並在其中附加一個 mcp_approval_response 項目，以回覆這項核准請求。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 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": "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
27 import 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
26 from 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
30 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("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
37 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("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
31 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: "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
25 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: "dmcp",
server_url: "https://dmcp-server.deno.dev/mcp",
server_description: "A Dungeons and Dragons MCP server.",
require_approval: :always
}
]
)
puts(response.output_text) 這裡使用 previous_response_id 參數，將這次的新回應與先前產生核准請求的回應串接起來。你也可以將某次回應的輸出作為另一次回應的輸入 傳回，以便最大程度地掌控哪些內容會進入模型的上下文。
當你確定可以信任某個遠端 MCP 伺服器時，可以選擇略過核准以降低延遲。做法是如下所示，將 MCP 工具的 require_approval 參數設為一個物件，只列出你想略過核准的工具；或將其設為 'never'，略過該遠端 MCP 伺服器上所有工具的核准。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 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?"
}' 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 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); 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 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) 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 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())
} 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 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())); 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 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()); 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 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 伺服器 不同，大多數其他 MCP 伺服器都需要身分驗證。最常見的方式是使用 OAuth 存取 Token。請透過 MCP 工具的 authorization 欄位提供此 Token：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 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"
}
]
}' 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 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); 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 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) 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 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())
} 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 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())); 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 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()); 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 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) 為避免敏感 Token 外洩，Responses API 不會儲存你在 authorization 欄位中提供的值。建立的 Response 物件中也不會顯示此值。因此，每次透過 Responses API 發出建立請求時，你都必須傳送 authorization 值。
connector_id 在 2026 年 9 月 1 日之後
發布的模型中已棄用。請使用 server_url 連線至遠端 MCP 伺服器，或使用
tunnel_id 透過
安全 MCP 通道 連線至本機 MCP 伺服器。現有模型
仍支援連接器。本節範例使用
gpt-5.2，此模型於上述截止日期之前發布。
Responses API 內建支援有限種類的第三方服務連接器。這些連接器讓你能從 Dropbox 和 Gmail 等熱門應用程式匯入上下文，使模型能與熱門服務互動。
連接器的使用方式與遠端 MCP 伺服器相同。兩者都能讓 OpenAI 模型在 API 請求中存取額外的第三方工具。不過，呼叫遠端 MCP 伺服器時需要傳入 server_url，使用連接器時則傳入 connector_id，用來唯一識別 API 中可用的連接器。
連接器需要由你的應用程式在 authorization 參數中提供 OAuth 存取 Token。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 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."
}' 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 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); 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 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) 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 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())
} 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 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())); 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 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()); 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 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)
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 伺服器，你可以在 MCP 工具的 server_url 欄位中傳入 https://api.githubcopilot.com/mcp/ 來連線。
在 authorization 欄位中傳入 OAuth 存取權杖。OAuth 用戶端註冊與授權必須由你的應用程式另外處理。
測試時，你可以使用 Google 的 OAuth 2.0 Playground 產生暫時的存取權杖，並在 API 請求中使用。
若要使用 Playground 測試連接器的 API 功能，請先輸入：
https://www.googleapis.com/auth/calendar.events 此授權範圍可讓 API 讀取 Google Calendar 活動。請在介面的「步驟 1：選取並授權 API」中輸入。
使用 Google 帳戶授權應用程式後，你會進入 步驟 2：以授權碼換取 Token 。這個步驟會產生存取 Token，讓你在使用 Google Calendar 連接器的 API 請求中使用：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 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?"
}' 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 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); 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 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) 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 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())
} 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 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())); 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 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()); 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 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 工具呼叫與遠端 MCP 伺服器的 MCP 工具呼叫格式相同，都使用 mcp_call 輸出項目類型。在此範例中，傳給連接器的引數與連接器傳回的回應都是 JSON 字串：
1 2 3 4 5 6 7 8 9 10 { "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 Token 具備哪些授權範圍。展開下方表格，即可查看連線至各應用程式時可使用的工具。
Dropbox 工具
說明
授權範圍 search在 Dropbox 中搜尋符合查詢條件的檔案
files.metadata.read, account_info.read fetch依路徑擷取檔案，並可選擇下載原始檔案
files.content.read search_files搜尋 Dropbox 檔案並傳回結果
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取得目前使用者的 Dropbox 設定檔
account_info.read
Gmail 工具
說明
授權範圍 get_profile傳回目前 Gmail 使用者的設定檔
userinfo.email, userinfo.profile search_emails在 Gmail 中搜尋符合查詢條件或標籤的電子郵件
gmail.modify search_email_ids取得符合搜尋條件的 Gmail 郵件 ID
gmail.modify get_recent_emails傳回最近收到的 Gmail 郵件
gmail.modify read_email擷取單封 Gmail 郵件，包含內文
gmail.modify batch_read_email在一次呼叫中讀取多封 Gmail 郵件
gmail.modify
Google Calendar 工具
說明
授權範圍 get_profile傳回目前 Calendar 使用者的設定檔
userinfo.email, userinfo.profile search搜尋 Calendar 活動，並可選擇限定時間範圍
calendar.events fetch取得單一 Calendar 活動的詳細資料
calendar.events search_events使用篩選條件查找 Calendar 活動
calendar.events read_event依 ID 讀取 Google Calendar 活動
calendar.events
Google Drive 工具
說明
授權範圍 get_profile傳回目前 Drive 使用者的設定檔
userinfo.email, userinfo.profile list_drives列出使用者可存取的共用雲端硬碟
drive.readonly search依查詢條件搜尋 Drive 檔案
drive.readonly recent_documents傳回最近修改的文件
drive.readonly fetch下載 Drive 檔案的內容
drive.readonly
Microsoft Teams 工具
說明
授權範圍 search搜尋 Microsoft Teams 對話與頻道訊息
Chat.Read, ChannelMessage.Read.All fetch依路徑擷取 Teams 訊息
Chat.Read, ChannelMessage.Read.All get_chat_members列出 Teams 對話的成員
Chat.Read get_profile傳回已通過驗證的 Teams 使用者設定檔
User.Read
Outlook Calendar 工具
說明
授權範圍 search_events使用日期篩選條件搜尋 Outlook Calendar 活動
Calendars.Read fetch_event取得單一活動的詳細資料
Calendars.Read fetch_events_batch在一次呼叫中取得多個活動
Calendars.Read list_events列出日期範圍內的行事曆活動
Calendars.Read get_profile取得目前使用者的設定檔
User.Read
Outlook 電子郵件 工具
說明
授權範圍 get_profile傳回 Outlook 帳戶的設定檔資訊
User.Read list_messages從資料夾取得 Outlook 電子郵件
Mail.Read search_messages搜尋 Outlook 電子郵件，並可選擇套用篩選條件
Mail.Read get_recent_emails傳回最近收到的電子郵件
Mail.Read fetch_message依 ID 取得單封電子郵件
Mail.Read fetch_messages_batch在一次請求中取得多封電子郵件
Mail.Read
Sharepoint 工具
說明
授權範圍 get_site依主機名稱和路徑找出對應的 SharePoint 網站
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 伺服器提供的函式，直到模型判斷需要使用時才載入。只要在 MCP 伺服器的工具定義中設定 defer_loading: true 即可。
延後載入 MCP 伺服器時，模型仍可根據該伺服器的標籤和說明，判斷何時要搜尋其中的工具，但個別函式定義只會在需要時載入。這有助於減少整體 Token 用量，對提供大量函式的 MCP 伺服器尤其有用。
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"
} MCP 工具可讓你將 OpenAI 模型連接到外部服務。這項功能很強大，但也伴隨一些風險。
使用連接器時，可能會將敏感資料傳送給 OpenAI，或讓模型讀取這些服務中可能包含敏感資訊的資料。
遠端 MCP 伺服器同樣存在上述風險，而且尚未經過 OpenAI 驗證。這些伺服器可讓模型存取、傳送和接收資料，以及在這些服務中執行動作。所有 MCP 伺服器都是第三方服務，適用各自的條款與條件。
如果你發現惡意 MCP 伺服器，請向 security@openai.com 檢舉。
以下是整合連接器和遠端 MCP 伺服器時可參考的最佳實務。
提示注入 是所有 LLM 應用程式都必須重視的安全性問題，尤其是當你讓模型使用能存取敏感資料或執行動作的 MCP 伺服器和連接器時。如果提供給模型的提示詞包含使用者提供的內容，使用這些工具時應謹慎行事，並採取適當的防護措施。
使用 require_approval 和 allowed_tools 參數提供的組態選項，確保所有敏感動作都必須經過核准流程。
對連接器或遠端 MCP 伺服器的工具呼叫輸出所提供的 URL 發出請求，或嵌入其中的圖片 URL，都可能有風險。在應用程式的程式碼中嵌入或以其他方式使用這些 URL 前，請確認你信任提供這些 URL 的網域和服務。
請選擇由服務供應商自行代管的官方伺服器。例如，我們建議連接至 Stripe 在 mcp.stripe.com 代管的 Stripe 伺服器，而非第三方代管的 Stripe MCP 伺服器。由於目前官方遠端 MCP 伺服器仍不多，你可能會想使用由其他組織代管的 MCP 伺服器；該組織並未營運該伺服器，而是透過你的 API 將請求代理轉送至該服務。如果你必須這麼做，請格外謹慎地對這些「彙整服務商」進行盡職調查，並仔細審查他們如何使用你的資料。
MCP 伺服器會自行定義工具，因此可能要求取得你不一定願意與其代管方分享的資料。正因如此，Responses API 中的 MCP 工具預設會要求每次 MCP 工具呼叫都經過核准。開發應用程式時，請仔細且全面地審查與這些 MCP 伺服器分享的資料類型。當你確定可以信任某個 MCP 伺服器後，就可以略過這些核准，以降低執行延遲。
我們也建議記錄所有傳送至 MCP 伺服器的資料。如果你使用 Responses API 並設定 store=true，除非你的組織已啟用零資料保留，否則 API 會記錄這些資料並保留 30 天。你也可以在自己的系統中記錄這些資料，並定期審查，確保資料分享方式符合你的預期。
惡意 MCP 伺服器可能包含隱藏指令（提示注入），企圖讓 OpenAI 模型出現非預期行為。雖然 OpenAI 已內建防護措施，協助偵測並阻擋這些威脅，但你仍必須仔細審查輸入與輸出，並確保只與可信任的伺服器建立連線。
MCP 伺服器可能在你未預期的情況下更新工具行為，進而導致非預期或惡意行為。
MCP 工具與零資料保留和資料駐留相容，但請注意，MCP 伺服器是第三方服務，傳送至 MCP 伺服器的資料須遵循該服務的資料保留和資料駐留政策。
換句話說，如果你的組織將資料駐留區域設為歐洲，OpenAI 會將客戶內容的推理與儲存限制在歐洲境內進行，直到通訊或資料傳送至 MCP 伺服器為止。你有責任確保 MCP 伺服器也遵循你的所有零資料保留或資料駐留要求。請參閱此處 ，進一步瞭解零資料保留與資料駐留。
API 支援情況
速率限制
備註 第 1 級
第 2 級與第 3 級
第 4 級與第 5 級
定價 ZDR 與資料駐留
