リアルタイムでのツールの使用

Realtime セッションにツールを追加すると、モデルがリアルタイムの会話中にデータを検索したり、アクションを実行したり、サービスを呼び出したりできるようになります。クライアントが WebRTC データチャネルと WebSocket のどちらを使用する場合も、ツールの構成には同じイベントインターフェースを使用します。

アプリケーション側でツールを実行して結果を返す場合は、関数ツールを使用します。Realtime API にリモートのツールサーバーへの接続を任せる場合は、MCP ツールを使用します。

ツールの種類の選択

ツールの種類	使用する場面	実行主体
`function`	アプリケーションがビジネスロジック、承認チェック、または非公開システムへのアクセスを担う場合。	クライアントまたはサーバーが関数呼び出しを受け取り、`function_call_output` を返します。
`server_url` を指定した `mcp`	リモート MCP サーバーが公開するツールをモデルに呼び出させたい場合。	Realtime API がリモート MCP サーバーを呼び出します。
`connector_id` を指定した `mcp`	既存のモデルでレガシーの組み込みコネクタを使用する場合。	Realtime API が、指定された認可情報を使ってコネクタを呼び出します。

ツールは 次の 2 か所のいずれかに追加します。

セッション全体でツールを利用できるようにする場合は、session.update の session.tools を使い、 セッションレベル で追加します。
1 ターンだけツールが必要な場合は、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)

Function Calling の流れをイベントごとに詳しく説明した手順については、会話の管理を参照してください。

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 日より後にリリースされたモデルでは非推奨です。リモート MCP サーバーに接続するには server_url を使用します。また、 tunnel_id を使用すると、セキュア MCP トンネルを介してローカル MCP サーバーに接続できます。既存のモデルでは、引き続きコネクタがサポートされます。以下の例では、この日付より前にリリースされた gpt-realtime-1.5 を使用します。

組み込みコネクタも同じ MCP ツールの構造を使用しますが、server_url の代わりに connector_id を渡します。たとえば、Google Calendar では connector_googlecalendar を使用します。 Realtime では、これらの組み込みコネクタを、予定やメールの検索・読み取りなどの読み取りアクションに使用します。ユーザーの OAuth アクセストークンを 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 のライフサイクルイベントを受信します。また、サーバーから承認を求められた場合は、必要に応じて承認応答を送信します。

一般的な処理の流れは次のとおりです。

type が mcp の tools エントリを含めて、session.update または response.create を送信します。
サーバーがツールのインポートを開始し、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 を待ち、少なくとも 1 つのツールがインポートされたことを確認するか、ツールを必要としないターンでは tool_choice に別の値を使用してください。
インポートの開始前に MCP ツール定義の検証が失敗します：よくある原因は、同じ tools 配列内での server_label の重複、server_url と connector_id の両方の設定、最初のセッション作成リクエストでの両方の省略、無効な connector_id の使用、または authorization と headers.Authorization の両方の送信です。コネクタの場合、headers.Authorization は一切送信しないでください。

MCP ツール呼び出しの承認または拒否

ツールに承認が必要な場合、Realtime API は会話に mcp_approval_request 項目を挿入します。 続行するには、item.type が mcp_approval_response の新しい conversation.item.create イベントを送信してください。

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 ツールオブジェクトを session.tools ではなく response.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

モデルの選び方

テキストとコード

プロンプト

推論

画像と動画

リアルタイムと音声

特化型モデル

Agents API

Agents 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

ID と認証

ワークスペースのアクセス、ポリシー、モデル

プラグインとコネクタの制御

利用状況、ガバナンス、コンプライアンス

展開とモデルプロバイダー

コミュニティ

ブログ

コミュニティ

ブログ