Uso de ferramentas em tempo real

Você pode adicionar ferramentas a uma sessão Realtime para que o modelo consulte dados, execute ações ou chame serviços durante uma conversa em tempo real. A configuração das ferramentas usa a mesma interface de eventos, independentemente de o cliente usar um canal de dados WebRTC ou um WebSocket.

Use ferramentas de função quando seu aplicativo precisar executar a ferramenta e retornar o resultado. Use ferramentas MCP quando a Realtime API precisar se conectar a um servidor remoto de ferramentas para você.

Escolha um tipo de ferramenta

Tipo de ferramenta	Quando usar	Quem executa
`function`	Seu aplicativo é responsável pela lógica de negócios, pelas verificações de aprovação ou pelo acesso a sistemas privados.	Seu cliente ou servidor recebe uma chamada de função e retorna `function_call_output`.
`mcp` com `server_url`	Você quer que o modelo chame ferramentas disponibilizadas por um servidor MCP remoto.	A Realtime API chama o servidor MCP remoto.
`mcp` com `connector_id`	Você usa um conector integrado legado com um modelo existente.	A Realtime API chama o conector com a autorização que você fornece.

Adicione ferramentas em um de dois lugares:

No nível da sessão , com session.tools em session.update, se quiser que a ferramenta fique disponível durante toda a sessão.
No nível da resposta , com response.tools em response.create, se precisar da ferramenta apenas para um turno.

Configure uma ferramenta de função

Ferramentas de função são a opção padrão adequada quando a ferramenta deve ser executada no seu aplicativo. O modelo emite os argumentos da chamada de função, seu código executa a ação e envia o resultado de volta em um item function_call_output.

Configure uma ferramenta de função com 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
)

Quando o modelo chamar a função, aguarde o item de chamada de função, execute a lógica do seu aplicativo e envie a saída de volta:

Envie a saída da chamada de função

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)

Para um passo a passo completo da chamada de função, evento por evento, consulte Gerenciamento de conversas.

Configure uma ferramenta MCP

As ferramentas MCP são úteis quando a ferramenta já está disponível por meio de um servidor MCP remoto ou quando um modelo existente usa um conector integrado legado. Ao contrário das ferramentas de função, as ferramentas MCP são executadas pela própria Realtime API.

No Realtime, a estrutura de uma ferramenta MCP é:

type: "mcp"
server_label
Um dos campos: server_url ou connector_id
authorization e headers opcionais
allowed_tools opcional
require_approval opcional
server_description opcional

Este exemplo disponibiliza um servidor MCP de documentação durante toda a sessão:

Configure uma ferramenta MCP com session.update

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
    }
  ]
)

Conectores legados

connector_id está obsoleto para modelos lançados após 1º de setembro de 2026. Use server_url para se conectar a um servidor MCP remoto ou tunnel_id para se conectar a um servidor MCP local por meio do Túnel MCP seguro. Os modelos existentes mantêm o suporte a conectores. O exemplo abaixo usa gpt-realtime-1.5, lançado antes dessa data.

Os conectores integrados usam a mesma estrutura de ferramenta MCP, mas passam connector_id em vez de server_url. Por exemplo, o Google Calendar usa connector_googlecalendar. No Realtime, use esses conectores integrados para ações de leitura, como pesquisar ou ler eventos ou e-mails. Passe o token de acesso OAuth do usuário em authorization e restrinja as ferramentas disponíveis com allowed_tools sempre que possível:

Configure um conector do 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
    }
  ]
)

Servidores MCP remotos não recebem automaticamente todo o contexto da conversa, mas podem ver quaisquer dados que o modelo envie em uma chamada de ferramenta. Restrinja as ferramentas disponíveis com allowed_tools, e exija aprovação para qualquer ação que você não executaria automaticamente.

Fluxo de MCP no Realtime

Ao contrário das ferramentas function do Realtime, as ferramentas MCP remotas são executadas pela própria Realtime API. Seu cliente não executa a ferramenta remota nem retorna um function_call_output. Em vez disso, ele configura o acesso, escuta os eventos do ciclo de vida do MCP e, opcionalmente, envia uma resposta de aprovação se o servidor solicitar.

Um fluxo típico funciona assim:

Você envia session.update ou response.create com uma entrada em tools cujo type é mcp.
O servidor começa a importar as ferramentas e emite mcp_list_tools.in_progress.
Enquanto a listagem estiver em andamento, o modelo não poderá chamar uma ferramenta que ainda não tenha sido carregada. Se quiser aguardar antes de iniciar um turno que dependa dessas ferramentas, escute mcp_list_tools.completed. O evento conversation.item.done cujo item.type é mcp_list_tools mostra os nomes das ferramentas que foram efetivamente importadas. Se a importação falhar, você receberá mcp_list_tools.failed.
O usuário fala ou envia texto, e uma resposta é criada pelo seu cliente ou automaticamente, conforme a configuração da sessão.
Se o modelo escolher uma ferramenta MCP, você verá response.mcp_call_arguments.delta e response.mcp_call_arguments.done.
Se for necessária aprovação, o servidor adicionará um item à conversa cujo item.type é mcp_approval_request. Seu cliente deverá responder a ele com um item mcp_approval_response.
Quando a ferramenta for executada, você verá response.mcp_call.in_progress. Em caso de sucesso, você receberá depois um evento response.output_item.done cujo item.type é mcp_call; em caso de falha, receberá response.mcp_call.failed.
O evento response.done de uma resposta pode chegar antes que as chamadas MCP dessa resposta terminem. Depois que a resposta e todas as suas chamadas MCP forem concluídas, envie outro evento response.create para que o modelo use os resultados e prossiga com a conversa. Repita essa etapa se o modelo fizer outras chamadas MCP. A Realtime API não cria essas respostas de continuação automaticamente.

Este manipulador de eventos registra os principais eventos do ciclo de vida do MCP; ele não gerencia as respostas de continuação:

Escute eventos MCP durante uma sessão Realtime

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

Falhas comuns

mcp_list_tools.failed: a Realtime API não conseguiu importar ferramentas do servidor remoto ou do conector. Verifique server_url ou connector_id, a autenticação, a conectividade do servidor e os nomes que você especificou em allowed_tools.
response.mcp_call.failed: o modelo selecionou uma ferramenta, mas a chamada da ferramenta não foi concluída. Inspecione o payload do evento e o item mcp_call recebido posteriormente para identificar erros de protocolo MCP, execução ou transporte.
mcp_approval_request sem um mcp_approval_response correspondente: a chamada da ferramenta não pode continuar até que seu cliente a aprove ou rejeite explicitamente.
Um turno começa enquanto mcp_list_tools.in_progress ainda está ativo: somente ferramentas que já terminaram de carregar podem ser usadas nesse turno.
Uma resposta usa tool_choice: "required", mas nenhuma ferramenta está disponível no momento: o modelo não tem nenhuma ferramenta que possa chamar. Aguarde mcp_list_tools.completed, confirme que pelo menos uma ferramenta foi importada ou use outro valor de tool_choice para turnos que não exigem uma ferramenta.
A validação da definição da ferramenta MCP falha antes do início da importação: as causas comuns são um server_label duplicado no mesmo array tools, definir tanto server_url quanto connector_id, omitir ambos na solicitação inicial de criação da sessão, usar um connector_id inválido ou enviar tanto authorization quanto headers.Authorization. Para conectores, nunca envie headers.Authorization.

Aprove ou rejeite chamadas de ferramentas MCP

Se uma ferramenta exigir aprovação, a Realtime API insere um item mcp_approval_request na conversa. Para continuar, envie um novo evento conversation.item.create cujo item.type seja mcp_approval_response.

Aprove uma solicitação 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
)

Se você rejeitar a solicitação, defina approve como false e, opcionalmente, inclua um reason.

Use MCP em apenas uma resposta

Se o MCP deve ficar disponível apenas em um único turno, adicione o mesmo objeto de ferramenta MCP a response.tools em vez de session.tools:

Adicione ferramentas MCP a uma única resposta

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
    }
  ]
)

Isso é útil quando apenas uma resposta precisa de contexto externo ou quando turnos diferentes devem usar servidores MCP diferentes.

Reutilize um rótulo de servidor definido anteriormente

server_label é o identificador estável de uma definição de ferramenta na sessão Realtime atual. Depois de definir um servidor ou conector uma vez com server_label e server_url ou connector_id, eventos posteriores de session.update ou response.create podem fazer referência apenas a esse mesmo server_label, e a Realtime API reutilizará a definição anterior sem exigir que você envie o objeto completo da ferramenta novamente.

Reutilize um conector definido anteriormente

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"
    }
  ]
)

Essa reutilização se limita à sessão. Se você iniciar uma nova sessão Realtime, envie a definição completa do MCP novamente para que o servidor possa importar sua lista de ferramentas.

Sugestões

Primeiros passos

Conceitos fundamentais

SDKs e CLI

Recursos

APIs legadas

Escolha um modelo

Texto e código

Criação de prompts

Raciocínio

Imagens e vídeo

Tempo real e áudio

Modelos especializados

API de Agentes

SDK de Agentes

ChatKit

Pesquisa e recuperação

Conecte ferramentas e dados

Crie fluxos de trabalho com ferramentas

Computador e código

Mídia

GPT-Live

Realtime API

Desenvolva com voz

Conexões

Processamento de áudio

Entre em produção

Desempenho e qualidade

Custo e taxa de processamento

Segurança e governança

Infraestrutura e acesso

Operações

Conceitos fundamentais

Plan

Build

Test and publish

Conversion specs

Guias

Recursos

Primeiros passos

Guias

File Upload

API

Measurement

Advertiser API

Referência da API

Primeiros passos

Fundamentos

Explorar

Disponível em

Versões

Fluxos de trabalho

Capacidades

Referência

Personalização

Arquivo de configuração

Configuração de agentes

Amplie os recursos do ChatGPT e do Codex

Linux

Windows

Fluxos de trabalho de desenvolvimento

Amplie e automatize

Ambientes

Desenvolva com o Codex

Integrações de terceiros

Referência

Permissões

Codex Security

Segurança cibernética

Primeiros passos

ChatGPT Work

Identidade e autenticação

Acesso, política e modelos do workspace

Controles de plug-ins e conectores

Uso, governança e conformidade

Implantação e provedores de modelos

Comunidade

Blog

Comunidade

Blog