在即時互動中使用工具

你可以在 Realtime 工作階段中加入工具，讓模型在即時對話期間查詢資料、執行動作或呼叫服務。無論你的用戶端使用的是 WebRTC 資料通道還是 WebSocket，工具組態都使用相同的事件介面。

如果需要由你的應用程式執行工具並傳回結果，請使用函式工具。如果需要由 Realtime API 代你連線至遠端工具伺服器，請使用 MCP 工具。

選擇工具類型

工具類型	適用情境	執行方
`function`	你的應用程式負責商業邏輯、核准檢查或私有系統存取。	你的用戶端或伺服器接收函式呼叫，並回傳 `function_call_output`。
`mcp` 搭配 `server_url`	你希望模型呼叫遠端 MCP 伺服器提供的工具。	Realtime API 呼叫遠端 MCP 伺服器。
`mcp` 搭配 `connector_id`	你使用既有模型搭配舊版內建連接器。	Realtime API 使用你提供的授權呼叫連接器。

在 以下兩個位置擇一新增工具：

如果希望工具在整個工作階段中都可用，請透過 session.update 中的 session.tools，在 工作階段層級 新增工具。
如果只需要在單一回合中使用工具，請透過 response.create 中的 response.tools，在 回應層級 新增工具。

設定函式工具

當工具應在你的應用程式中執行時，函式工具是合適的預設選擇。模型會輸出函式呼叫引數，由你的程式碼執行動作，再透過 function_call_output 項目將結果傳回。

使用 session.update 設定函式工具

JavaScript

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
27const event = {
  type: "session.update",
  session: {
    type: "realtime",
    model: "gpt-realtime-2.1",
    tools: [
      {
        type: "function",
        name: "lookup_order",
        description: "Look up an order by its order number.",
        parameters: {
          type: "object",
          properties: {
            order_number: {
              type: "string",
              description: "The customer-facing order number.",
            },
          },
          required: ["order_number"],
        },
      },
    ],
    tool_choice: "auto",
  },
};

ws.send(JSON.stringify(event));

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
27event = {
    "type": "session.update",
    "session": {
        "type": "realtime",
        "model": "gpt-realtime-2.1",
        "tools": [
            {
                "type": "function",
                "name": "lookup_order",
                "description": "Look up an order by its order number.",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "order_number": {
                            "type": "string",
                            "description": "The customer-facing order number.",
                        }
                    },
                    "required": ["order_number"],
                },
            }
        ],
        "tool_choice": "auto",
    },
}

ws.send(json.dumps(event))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22connection.session.update(
  type: :realtime,
  model: "gpt-realtime-2.1",
  tools: [
    {
      type: :function,
      name: "lookup_order",
      description: "Look up an order by its order number.",
      parameters: {
        type: "object",
        properties: {
          order_number: {
            type: "string",
            description: "The customer-facing order number."
          }
        },
        required: ["order_number"]
      }
    }
  ],
  tool_choice: :auto
)

當模型呼叫函式時，請監聽函式呼叫項目、執行應用程式邏輯，然後將輸出傳回：

傳送函式呼叫輸出

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14const event = {
  type: "conversation.item.create",
  item: {
    type: "function_call_output",
    call_id: functionCall.call_id,
    output: JSON.stringify({
      status: "shipped",
      delivery_date: "2026-05-09",
    }),
  },
};

ws.send(JSON.stringify(event));
ws.send(JSON.stringify({ type: "response.create" }));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16event = {
    "type": "conversation.item.create",
    "item": {
        "type": "function_call_output",
        "call_id": function_call["call_id"],
        "output": json.dumps(
            {
                "status": "shipped",
                "delivery_date": "2026-05-09",
            }
        ),
    },
}

ws.send(json.dumps(event))
ws.send(json.dumps({"type": "response.create"}))

1
2
3
4
5
6connection.conversation.items.create(
  type: :function_call_output,
  call_id: call_id,
  output: JSON.generate(status: "shipped", delivery_date: "2026-05-09")
)
connection.response.create(tool_choice: :none)

如需依事件逐步說明函式呼叫的完整流程，請參閱管理對話。

設定 MCP 工具

如果工具已由遠端 MCP 伺服器提供，或既有模型使用舊版內建連接器，就適合使用 MCP 工具。與函式工具不同，MCP 工具由 Realtime API 本身執行。

在 Realtime 中，MCP 工具的結構如下：

type: "mcp"
server_label
server_url 或 connector_id，擇一使用
選用的 authorization 和 headers
選用的 allowed_tools
選用的 require_approval
選用的 server_description

此範例讓提供文件的 MCP 伺服器在整個工作階段中都可用：

使用 session.update 設定 MCP 工具

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19const event = {
  type: "session.update",
  session: {
    type: "realtime",
    model: "gpt-realtime-2.1",
    output_modalities: ["text"],
    tools: [
      {
        type: "mcp",
        server_label: "openai_docs",
        server_url: "https://developers.openai.com/mcp",
        allowed_tools: ["search_openai_docs", "fetch_openai_doc"],
        require_approval: "never",
      },
    ],
  },
};

ws.send(JSON.stringify(event));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19event = {
    "type": "session.update",
    "session": {
        "type": "realtime",
        "model": "gpt-realtime-2.1",
        "output_modalities": ["text"],
        "tools": [
            {
                "type": "mcp",
                "server_label": "openai_docs",
                "server_url": "https://developers.openai.com/mcp",
                "allowed_tools": ["search_openai_docs", "fetch_openai_doc"],
                "require_approval": "never",
            }
        ],
    },
}

ws.send(json.dumps(event))

1
2
3
4
5
6
7
8
9
10
11
12
13
14connection.session.update(
  type: :realtime,
  model: "gpt-realtime-2.1",
  output_modalities: [:text],
  tools: [
    {
      type: :mcp,
      server_label: "openai_docs",
      server_url: "https://developers.openai.com/mcp",
      allowed_tools: ["search_openai_docs", "fetch_openai_doc"],
      require_approval: :never
    }
  ]
)

舊版連接器

connector_id 在 2026 年 9 月 1 日之後發布的模型中已棄用。請使用 server_url 連線至遠端 MCP 伺服器，或使用 tunnel_id 透過安全 MCP 通道連線至本機 MCP 伺服器。既有模型仍支援連接器。以下範例使用 gpt-realtime-1.5，此模型於上述截止日期之前發布。

內建連接器使用相同的 MCP 工具結構，但傳入的是 connector_id，而非 server_url。例如，Google Calendar 使用 connector_googlecalendar。在 Realtime 中，請使用這些內建連接器執行讀取動作，例如搜尋或讀取活動或電子郵件。將使用者的 OAuth 存取 Token 傳入 authorization，並盡可能透過 allowed_tools 限縮可用工具範圍：

設定 Google Calendar 連接器

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20const event = {
  type: "session.update",
  session: {
    type: "realtime",
    model: "gpt-realtime-1.5",
    output_modalities: ["text"],
    tools: [
      {
        type: "mcp",
        server_label: "google_calendar",
        connector_id: "connector_googlecalendar",
        authorization: "<google-oauth-access-token>",
        allowed_tools: ["search_events", "read_event"],
        require_approval: "never",
      },
    ],
  },
};

ws.send(JSON.stringify(event));

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

connector_authorization = os.environ["OPENAI_CONNECTOR_AUTHORIZATION"]

event = {
    "type": "session.update",
    "session": {
        "type": "realtime",
        "model": "gpt-realtime-1.5",
        "output_modalities": ["text"],
        "tools": [
            {
                "type": "mcp",
                "server_label": "google_calendar",
                "connector_id": "connector_googlecalendar",
                "authorization": connector_authorization,
                "allowed_tools": ["search_events", "read_event"],
                "require_approval": "never",
            }
        ],
    },
}

ws.send(json.dumps(event))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17access_token = ENV.fetch("OPENAI_MCP_ACCESS_TOKEN")

connection.session.update(
  type: :realtime,
  model: "gpt-realtime-1.5",
  output_modalities: [:text],
  tools: [
    {
      type: :mcp,
      server_label: "google_calendar",
      connector_id: "connector_googlecalendar",
      authorization: access_token,
      allowed_tools: ["search_events", "read_event"],
      require_approval: :never
    }
  ]
)

遠端 MCP 伺服器 不會自動接收完整的對話上下文，但能看到模型在工具呼叫中傳送的任何資料。請使用 allowed_tools 限縮可用工具範圍，並對任何你不會自動執行的動作要求核准。

Realtime MCP 流程

與 Realtime 的 function 工具不同，遠端 MCP 工具 由 Realtime API 本身執行。 你的用戶端不會執行遠端工具 並回傳 function_call_output，而是負責設定存取權、監聽 MCP 生命週期事件，以及在伺服器要求核准時視需要傳送核准回應。

典型流程如下：

你傳送 session.update 或 response.create，其中包含一個 type 為 mcp 的 tools 項目。
伺服器開始匯入工具，並發出 mcp_list_tools.in_progress。
在工具清單仍在載入時，模型無法呼叫尚未載入的工具。如果你希望等工具就緒後，再開始需要使用這些工具的回合，請監聽 mcp_list_tools.completed。item.type 為 mcp_list_tools 的 conversation.item.done 事件會顯示實際匯入的工具名稱。如果匯入失敗，你會收到 mcp_list_tools.failed。
使用者說話或傳送文字後，由你的用戶端建立回應，或根據工作階段組態自動建立回應。
如果模型選擇 MCP 工具，你會看到 response.mcp_call_arguments.delta 和 response.mcp_call_arguments.done。
如果需要核准，伺服器會新增一個 item.type 為 mcp_approval_request 的對話項目。你的用戶端必須以 mcp_approval_response 項目回覆。
工具開始執行後，你會看到 response.mcp_call.in_progress。若執行成功，稍後會收到 item.type 為 mcp_call 的 response.output_item.done 事件；若失敗，則會收到 response.mcp_call.failed。
回應的 response.done 可能會在其 MCP 呼叫完成前抵達。當回應結束且其所有 MCP 呼叫都完成後，請再傳送一個 response.create 事件，讓模型使用結果並繼續對話。如果模型再次發出 MCP 呼叫，請重複此步驟。Realtime API 不會自動建立這些後續回應。

此事件處理常式會記錄主要的 MCP 生命週期事件，但不會管理後續回應：

在 Realtime 工作階段中監聽 MCP 事件

JavaScript

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82function parseRealtimeEvent(rawMessage) {
  if (typeof rawMessage === "string") {
    return JSON.parse(rawMessage);
  }

  if (typeof rawMessage?.data === "string") {
    return JSON.parse(rawMessage.data);
  }

  return JSON.parse(rawMessage.toString());
}

function getOutputText(item) {
  if (item.type !== "message") return "";

  return (item.content ?? [])
    .filter((part) => part.type === "output_text")
    .map((part) => part.text)
    .join("");
}

ws.on("message", (rawMessage) => {
  const event = parseRealtimeEvent(rawMessage);

  switch (event.type) {
    case "mcp_list_tools.in_progress":
      console.log("Listing MCP tools for item:", event.item_id);
      break;

    case "mcp_list_tools.completed":
      console.log("MCP tool listing complete for item:", event.item_id);
      break;

    case "mcp_list_tools.failed":
      console.error("MCP tool listing failed for item:", event.item_id);
      break;

    case "conversation.item.done":
      if (event.item.type === "mcp_list_tools") {
        const names = event.item.tools.map((tool) => tool.name).join(", ");
        console.log(`MCP tools ready on ${event.item.server_label}: ${names}`);
      }

      if (event.item.type === "mcp_approval_request") {
        console.log(
          "Approval required for:",
          event.item.name,
          event.item.arguments
        );
      }
      break;

    case "response.mcp_call_arguments.done":
      console.log("Final MCP call arguments:", event.arguments);
      break;

    case "response.mcp_call.in_progress":
      console.log("Running MCP tool for item:", event.item_id);
      break;

    case "response.mcp_call.failed":
      console.error("MCP tool call failed for item:", event.item_id);
      break;

    case "response.output_item.done":
      if (event.item.type === "mcp_call") {
        console.log(
          `MCP output from ${event.item.server_label}.${event.item.name}:`,
          event.item.output
        );
      }

      if (event.item.type === "message") {
        console.log("Assistant:", getOutputText(event.item));
      }
      break;

    case "response.done":
      console.log("Realtime turn complete.");
      break;
  }
});

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61def on_message(ws, message):
    event = json.loads(message)
    event_type = event["type"]

    if event_type == "mcp_list_tools.in_progress":
        print("Listing MCP tools for item:", event["item_id"])
        return

    if event_type == "mcp_list_tools.completed":
        print("MCP tool listing complete for item:", event["item_id"])
        return

    if event_type == "mcp_list_tools.failed":
        print("MCP tool listing failed for item:", event["item_id"])
        return

    if event_type == "conversation.item.done":
        item = event["item"]

        if item["type"] == "mcp_list_tools":
            names = ", ".join(tool["name"] for tool in item["tools"])
            print(f"MCP tools ready on {item['server_label']}: {names}")
            return

        if item["type"] == "mcp_approval_request":
            print("Approval required for:", item["name"], item["arguments"])
            return

    if event_type == "response.mcp_call_arguments.done":
        print("Final MCP call arguments:", event["arguments"])
        return

    if event_type == "response.mcp_call.in_progress":
        print("Running MCP tool for item:", event["item_id"])
        return

    if event_type == "response.mcp_call.failed":
        print("MCP tool call failed for item:", event["item_id"])
        return

    if event_type == "response.output_item.done":
        item = event["item"]

        if item["type"] == "mcp_call":
            print(
                f"MCP output from {item['server_label']}.{item['name']}:",
                item.get("output"),
            )
            return

        if item["type"] == "message":
            text_parts = [
                part["text"]
                for part in item.get("content", [])
                if part["type"] == "output_text"
            ]
            print("Assistant:", "".join(text_parts))
            return

    if event_type == "response.done":
        print("Realtime turn complete.")

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62connection.each do |event|
  case event
  when OpenAI::Realtime::McpListToolsInProgress
    puts("Listing MCP tools for item: #{event.item_id}")
  when OpenAI::Realtime::McpListToolsFailed
    warn("MCP tool listing failed for item: #{event.item_id}")
    break
  when OpenAI::Realtime::McpListToolsCompleted
    puts("MCP tools ready for item: #{event.item_id}")
    connection.response.create(
      output_modalities: [:text],
      input: [
        {
          type: :message,
          role: :user,
          content: [
            {
              type: :input_text,
              text: "Which Realtime API transport should browser clients use?"
            }
          ]
        }
      ],
      tool_choice: :required
    )
  when OpenAI::Realtime::ConversationItemDone
    item = event.item
    case item
    when OpenAI::Realtime::RealtimeMcpListTools
      names = item.tools.map(&:name).join(", ")
      puts("MCP tools ready on #{item.server_label}: #{names}")
    when OpenAI::Realtime::RealtimeMcpApprovalRequest
      puts("Approval required for: #{item.name} #{item.arguments}")
    end
  when OpenAI::Realtime::ResponseMcpCallArgumentsDone
    puts("Final MCP call arguments: #{event.arguments}")
  when OpenAI::Realtime::ResponseMcpCallInProgress
    puts("Running MCP tool for item: #{event.item_id}")
  when OpenAI::Realtime::ResponseMcpCallCompleted
    puts("MCP tool call completed: #{event.item_id}")
  when OpenAI::Realtime::ResponseMcpCallFailed
    warn("MCP tool call failed: #{event.item_id}")
    break
  when OpenAI::Realtime::ResponseOutputItemDoneEvent
    item = event.item
    case item
    when OpenAI::Realtime::RealtimeMcpToolCall
      puts("MCP output from #{item.server_label}.#{item.name}: #{item.output}")
    when OpenAI::Realtime::RealtimeConversationItemAssistantMessage
      text = item.content.filter_map do |content|
        content.text if content.type == :output_text
      end.join
      puts("Assistant: #{text}")
    end
  when OpenAI::Realtime::RealtimeErrorEvent
    warn("Realtime API error: #{event.error.message}")
    break
  when OpenAI::Realtime::ResponseDoneEvent
    puts("Realtime turn complete.")
    break
  end
end

常見失敗情況

mcp_list_tools.failed：Realtime API 無法從遠端伺服器或連接器匯入工具。請檢查 server_url 或 connector_id、身分驗證、伺服器連線，以及你在 allowed_tools 中指定的所有名稱。
response.mcp_call.failed：模型已選取工具，但工具呼叫未完成。請檢查事件承載內容和後續的 mcp_call 項目，確認是否有 MCP 通訊協定、執行或傳輸錯誤。
mcp_approval_request 沒有對應的 mcp_approval_response：用戶端必須明確核准或拒絕，工具呼叫才能繼續。
回合開始時，mcp_list_tools.in_progress 仍在進行中：該回合只能使用已完成載入的工具。
回應使用了 tool_choice: "required"，但目前沒有可用的工具：模型沒有符合條件的工具可供呼叫。請等待 mcp_list_tools.completed，確認至少已匯入一個工具，或針對不需要工具的回合使用其他 tool_choice 設定。
MCP 工具定義在開始匯入前未通過驗證：常見原因包括同一個 tools 陣列中有重複的 server_label、同時設定 server_url 和 connector_id、在首次建立工作階段的請求中省略這兩個欄位、使用無效的 connector_id，或同時傳送 authorization 和 headers.Authorization。使用連接器時，請勿傳送 headers.Authorization。

核准或拒絕 MCP 工具呼叫

如果工具需要核准，Realtime API 會在對話中插入一個 mcp_approval_request 項目。 若要繼續，請傳送新的 conversation.item.create 事件，並將其中的 item.type 設為 mcp_approval_response。

核准 MCP 請求

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13function approveMcpRequest(approvalRequestId) {
  const event = {
    type: "conversation.item.create",
    item: {
      id: `mcp_approval_${approvalRequestId}`,
      type: "mcp_approval_response",
      approval_request_id: approvalRequestId,
      approve: true,
    },
  };

  ws.send(JSON.stringify(event));
}

1
2
3
4
5
6
7
8
9
10
11
12
13# Use the ID from the received MCP approval-request item.
def approve_mcp_request(ws, approval_request_id):
    event = {
        "type": "conversation.item.create",
        "item": {
            "id": f"mcp_approval_{approval_request_id}",
            "type": "mcp_approval_response",
            "approval_request_id": approval_request_id,
            "approve": True,
        },
    }

    ws.send(json.dumps(event))

1
2
3
4
5
6
7
8
9# Use the ID from the received MCP approval-request item.
approval_request_id = item.id

connection.conversation.items.create(
  type: :mcp_approval_response,
  id: "mcp_approval_#{approval_request_id}",
  approval_request_id: approval_request_id,
  approve: true
)

如果要拒絕請求，請將 approve 設為 false，並可視需要附上 reason。

僅在單一回應中使用 MCP

如果 MCP 應 僅在單一回合中可用，請將相同的 MCP 工具物件加入 response.tools，而非 session.tools：

為單一回應加入 MCP 工具

JavaScript

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
29const event = {
  type: "response.create",
  response: {
    output_modalities: ["text"],
    input: [
      {
        type: "message",
        role: "user",
        content: [
          {
            type: "input_text",
            text: "Which transport should I use for browser clients in the Realtime API?",
          },
        ],
      },
    ],
    tools: [
      {
        type: "mcp",
        server_label: "openai_docs",
        server_url: "https://developers.openai.com/mcp",
        allowed_tools: ["search_openai_docs", "fetch_openai_doc"],
        require_approval: "never",
      },
    ],
  },
};

ws.send(JSON.stringify(event));

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
29event = {
    "type": "response.create",
    "response": {
        "output_modalities": ["text"],
        "input": [
            {
                "type": "message",
                "role": "user",
                "content": [
                    {
                        "type": "input_text",
                        "text": "Which transport should I use for browser clients in the Realtime API?",
                    }
                ],
            }
        ],
        "tools": [
            {
                "type": "mcp",
                "server_label": "openai_docs",
                "server_url": "https://developers.openai.com/mcp",
                "allowed_tools": ["search_openai_docs", "fetch_openai_doc"],
                "require_approval": "never",
            }
        ],
    },
}

ws.send(json.dumps(event))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24connection.response.create(
  output_modalities: [:text],
  input: [
    {
      type: :message,
      role: :user,
      content: [
        {
          type: :input_text,
          text: "Which Realtime API transport should browser clients use?"
        }
      ]
    }
  ],
  tools: [
    {
      type: :mcp,
      server_label: "openai_docs",
      server_url: "https://developers.openai.com/mcp",
      allowed_tools: ["search_openai_docs", "fetch_openai_doc"],
      require_approval: :never
    }
  ]
)

當只有一個回應需要外部上下文，或不同回合應使用不同的 MCP 伺服器時，這種做法很實用。

重複使用先前定義的伺服器標籤

server_label 是目前 Realtime 工作階段中用來參照工具定義的固定識別代號。只要使用 server_label 搭配 server_url 或 connector_id 定義過伺服器或連接器，後續的 session.update 或 response.create 事件就只需參照同一個 server_label， Realtime API 便會重複使用先前的定義，無須再次傳送完整的工具物件。

重複使用先前定義的連接器

JavaScript

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
27const event = {
  type: "response.create",
  response: {
    output_modalities: ["text"],
    input: [
      {
        type: "message",
        role: "user",
        content: [
          {
            type: "input_text",
            text: "Check my schedule for this afternoon.",
          },
        ],
      },
    ],
    // Reuses the google_calendar connector defined earlier in this session.
    tools: [
      {
        type: "mcp",
        server_label: "google_calendar",
      },
    ],
  },
};

ws.send(JSON.stringify(event));

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
27event = {
    "type": "response.create",
    "response": {
        "output_modalities": ["text"],
        "input": [
            {
                "type": "message",
                "role": "user",
                "content": [
                    {
                        "type": "input_text",
                        "text": "Check my schedule for this afternoon.",
                    }
                ],
            }
        ],
        # Reuses the google_calendar connector defined earlier in this session.
        "tools": [
            {
                "type": "mcp",
                "server_label": "google_calendar",
            }
        ],
    },
}

ws.send(json.dumps(event))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21connection.response.create(
  output_modalities: [:text],
  input: [
    {
      type: :message,
      role: :user,
      content: [
        {
          type: :input_text,
          text: "Check my schedule this afternoon."
        }
      ]
    }
  ],
  tools: [
    {
      type: :mcp,
      server_label: "google_calendar"
    }
  ]
)

這種重複使用方式僅限於同一個工作階段。如果開始新的 Realtime 工作階段，請再次傳送完整的 MCP 定義，讓伺服器能夠匯入其工具清單。

建議

開始使用

核心概念

SDK 與 CLI

資源

舊版 API

選擇模型

文字與程式碼

提示詞

推理

圖像與影片

即時互動與音訊

專用模型

智慧體 API

智慧體 SDK

ChatKit

搜尋與檢索

連接工具與資料

建立工具工作流程

電腦與程式碼

媒體

GPT-Live

Realtime API

開發語音應用

連線

音訊處理

正式上線

效能與品質

成本與吞吐量

安全與治理

基礎架構與存取

營運

核心概念

Plan

Build

Test and publish

Conversion specs

指南

資源

開始使用

指南

File Upload

API

Measurement

Advertiser API

API 參考文件

開始使用

基礎

探索

適用平台

版本資訊

工作流程

能力

參考資料

自訂

設定檔

智慧體組態

擴充 ChatGPT 與 Codex 的功能

Linux

Windows

開發工作流程

擴充與自動化

環境

使用 Codex 進行建置

第三方整合

參考資料

權限

Codex Security

網路安全

開始使用

ChatGPT Work

身分識別與身分驗證

工作區存取權、政策與模型

外掛程式與連接器控制措施

使用情況、治理與合規

部署與模型供應商

社群

部落格

社群

部落格