Tool Calling vs MCP: diferenças e quando usar

Tool Calling é um recurso de API de modelo de linguagem em que o modelo solicita uma chamada de função e sua aplicação executa o código. Model Context Protocol (MCP) é um padrão aberto JSON-RPC que permite a aplicações de IA descobrir e invocar ferramentas expostas por servidores externos. MCP usa Tool Calling como base, em vez de substituí-lo.

Desenvolvedores que criam agentes de IA ou backends baseados em LLM encontram os dois termos com frequência na documentação dos fornecedores. Para entender Tool Calling e MCP, é preciso separar como um modelo decide executar uma função de como uma aplicação se conecta ao sistema em que essa função está.

O que é Tool Calling em APIs de LLM?

Tool Calling (também chamado de function calling) é um recurso de API de modelo que transforma um prompt em linguagem natural em uma invocação estruturada de função. Você passa definições de função na solicitação à API usando nome, descrição e parâmetros JSON Schema, e o modelo decide se retorna uma chamada estruturada contendo o nome da função e os argumentos.

O modelo não executa a função por conta própria. Tool Calling funciona como uma conversa em várias etapas entre sua aplicação e o modelo:

Enviar declarações de ferramentas: sua aplicação faz uma solicitação ao modelo e inclui as definições JSON Schema das ferramentas que ele pode chamar.
Receber uma chamada estruturada: o modelo responde com uma chamada contendo o nome da função escolhida e argumentos JSON (por exemplo, Anthropic retorna um motivo de parada e um bloco tool_use).
Executar código no lado da aplicação: seu backend valida os argumentos e executa a função local ou a solicitação de API interna.
Retornar a saída da ferramenta: sua aplicação faz uma segunda solicitação ao modelo com o resultado, como um bloco tool_result.
Receber a resposta final: o modelo usa a saída para responder ao usuário ou solicita outras chamadas de ferramentas.

Uma definição de função OpenAI usa parameters de JSON Schema e oferece suporte a strict: true para impor a conformidade com o esquema:

{
  "type": "function",
  "name": "get_weather",
  "description": "Get the current weather for a given location.",
  "strict": true,
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string"
      }
    },
    "required": ["location"],
    "additionalProperties": false
  }
}

As principais APIs de modelos oferecem controle detalhado sobre como o modelo seleciona funções. Nas APIs de OpenAI e Google Gemini, tool_choice permite manter a seleção em auto (padrão), forçar uma ou mais chamadas (required na OpenAI, any no Gemini), desativar ferramentas (none), restringir o modelo a um subconjunto com allowed_tools ou usar o modo validated do Gemini para garantir a conformidade com o esquema da função. OpenAI e Gemini oferecem chamadas paralelas de funções, permitindo que um modelo invoque várias funções em um único turno. A OpenAI permite definir parallel_tool_calls como false para ter no máximo uma chamada por turno. O Gemini também oferece chamadas composicionais para execuções sequenciais em várias etapas.

A Anthropic divide o uso de ferramentas conforme o local de execução do código. Ferramentas de cliente (incluindo suas funções personalizadas e ferramentas no esquema Anthropic como bash e text_editor) executam dentro da aplicação. Ferramentas de servidor (como web_search, web_fetch, code_execution e tool_search) executam diretamente na infraestrutura da Anthropic.

O que é Model Context Protocol (MCP)?

Model Context Protocol (MCP) é um padrão de código aberto para conectar aplicações de IA a sistemas externos por JSON-RPC 2.0. Inspirada no Language Server Protocol, a especificação MCP (versão 2026-07-28) funciona como uma porta USB-C para aplicações de IA, permitindo que uma única integração de servidor funcione com ChatGPT, Claude, Visual Studio Code, Cursor e agentes personalizados.

MCP separa as responsabilidades em três papéis:

Hosts: aplicações LLM, como uma IDE ou interface de chat, que iniciam conexões.
Clientes (Clients): conectores de protocolo executados dentro da aplicação host.
Servidores (Servers): serviços externos que disponibilizam recursos e contexto ao cliente.

Na especificação 2026-07-28, o protocolo básico usa solicitações JSON-RPC 2.0 independentes e sem estado, com negociação de capacidades a cada solicitação. MCP define dois transportes padrão: stdio, que transmite mensagens delimitadas por quebras de linha pela entrada e saída padrão de um subprocesso iniciado pelo cliente, e Streamable HTTP, em que cada mensagem é um POST HTTP para um único endpoint MCP. Desenvolvedores também podem implementar transportes personalizados.

Enquanto Tool Calling de LLM lida apenas com funções, servidores MCP podem expor três recursos principais:

Tools: funções que o modelo de IA pode executar.
Resources: contexto e dados que a aplicação pode ler.
Prompts: modelos de mensagens e fluxos de trabalho para usuários.

No lado do cliente, MCP oferece Elicitation, que permite a um servidor solicitar informações adicionais ao usuário. A especificação 2026-07-28 também inclui extensões opcionais negociadas para Tasks (operações assíncronas de longa duração), Skills over MCP e MCP Apps (elementos interativos de interface exibidos no conteúdo).

Para executar ferramentas, um cliente MCP descobre as disponíveis chamando tools/list, que suporta paginação e cache. Servidores que declaram a capacidade listChanged podem avisar os clientes quando suas ferramentas disponíveis mudam. Cada definição de ferramenta MCP inclui um name sensível a maiúsculas e minúsculas (recomendam-se de 1 a 128 caracteres), um title opcional, uma description, icons opcionais, um inputSchema (por padrão JSON Schema 2020-12), um outputSchema opcional e anotações opcionais.

Quando o modelo decide usar uma ferramenta MCP, o cliente envia ao servidor uma solicitação JSON-RPC tools/call:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "get_weather",
    "arguments": {
      "location": "San Francisco, CA"
    }
  }
}

Se a execução de uma ferramenta falhar no servidor, MCP retorna o erro dentro do resultado com isError: true, para que o modelo de linguagem possa ler a falha e se corrigir.

Tool Calling vs MCP: comparação

A comparação direta entre Tool Calling de LLM e MCP mostra como os dois operam em camadas diferentes da arquitetura. Em novembro de 2026, estas são as diferenças entre Tool Calling nativo e Model Context Protocol em sete aspectos arquiteturais:

Aspecto	Tool Calling (Function Calling)	Model Context Protocol (MCP)
O que é	Recurso de API de modelo em que um LLM produz argumentos estruturados de função	Protocolo aberto JSON-RPC 2.0 que conecta hosts e clientes de IA a servidores externos
Quem define ferramentas	O código da aplicação (ou ferramentas de servidor do fornecedor) na solicitação à API do modelo	Um servidor MCP que expõe Tools, Resources e Prompts
Onde o código executa	O backend da aplicação (ou a nuvem do fornecedor do LLM para ferramentas de servidor)	Um subprocesso local (`stdio`) ou serviço remoto (Streamable HTTP)
Descoberta	Estática por solicitação de API; o código fixa ou seleciona esquemas antes de chamar o modelo	Dinâmica em tempo de execução via `tools/list` e notificações `listChanged`
Transporte	API HTTPS do fornecedor (OpenAI, Anthropic, Google Gemini)	`stdio`, Streamable HTTP ou transportes personalizados
Portabilidade entre clientes	Vinculada ao aplicativo e ao formato de esquema do fornecedor específico de LLM	Portável entre hosts compatíveis com MCP (Claude, ChatGPT, VS Code, Cursor, aplicativos personalizados)
Custo	Tokens de entrada para definições, tokens de saída para chamadas e taxas extras para ferramentas de servidor do fornecedor	Tokens de entrada para cada esquema carregado e infraestrutura para hospedar ou executar o servidor MCP

MCP substitui Function Calling?

MCP não substitui Function Calling porque o modelo de linguagem ainda usa Tool Calling para selecionar e invocar cada ferramenta MCP. Tool Calling e MCP são camadas complementares no mesmo ciclo de vida de uma solicitação.

Quando uma aplicação de IA se conecta a um servidor MCP, o fluxo combina os dois sistemas:

Descoberta via MCP: o cliente MCP da aplicação host envia uma solicitação tools/list ao servidor MCP e recebe nomes, descrições e objetos inputSchema JSON Schema das ferramentas do servidor.
Formatação para o LLM: o host traduz essas definições de ferramentas MCP para o array tools nativo do fornecedor do LLM e as envia junto com o prompt do usuário.
Seleção via Tool Calling: o modelo de linguagem avalia o prompt e emite uma chamada de ferramenta padrão com o nome e os argumentos escolhidos.
Execução via MCP: o host intercepta a chamada do modelo, associa-a a uma solicitação MCP tools/call e a envia ao servidor MCP via stdio ou Streamable HTTP.
Conclusão: o servidor MCP retorna o resultado (com isError: true se a execução falhou), o host o passa ao modelo como resultado da ferramenta e o modelo gera a resposta final.

Sem Tool Calling na API do modelo, o LLM não teria mecanismo para acionar uma ferramenta MCP. Sem MCP, sua aplicação precisa conectar manualmente cada esquema de ferramenta e controlador de execução.

Como OpenAI, Anthropic e Google oferecem suporte direto a MCP?

OpenAI, Anthropic e Google agora permitem passar servidores MCP remotos diretamente às APIs de seus modelos como um tipo de ferramenta integrado. Em vez de escrever seu próprio loop de cliente MCP para conectar tools/list e tools/call, a API do fornecedor do modelo conecta-se ao servidor MCP por você.

Em novembro de 2026, cada fornecedor implementa conexões diretas com servidores MCP com capacidades específicas e limites documentados:

OpenAI Responses API

Na OpenAI Responses API, você pode conectar um servidor MCP especificando "type": "mcp" no array de ferramentas junto com server_label e server_url. A OpenAI inclui dois controles importantes para produção:

allowed_tools: importa apenas um subconjunto específico de ferramentas do servidor MCP para não sobrecarregar o contexto do modelo.
require_approval: configura se as invocações são executadas automaticamente ou aguardam aprovação humana explícita.

Para serviços locais ou privados, a OpenAI oferece Secure MCP Tunnel, permitindo conectar servidores MCP internos sem expô-los à internet pública.

Anthropic MCP Connector

A Anthropic oferece um MCP connector em beta na Messages API (mcp_servers e mcp_toolset) que se conecta a servidores MCP remotos sem exigir uma implementação de cliente separada. Considere quatro limitações documentadas:

Somente ferramentas: o conector aceita apenas chamadas de ferramentas da especificação MCP, não Resources nem Prompts MCP.
HTTP público obrigatório: o servidor MCP deve ser exposto publicamente por HTTP, com suporte a Streamable HTTP e SSE.
Sem stdio local direto: servidores stdio locais não podem se conectar diretamente à Messages API, embora os SDKs da Anthropic ofereçam auxiliares no cliente para servidores locais.
Exclusões de conformidade: o MCP connector beta não é elegível para cargas de trabalho Zero Data Retention (ZDR) ou HIPAA.

Google Gemini Interactions API

A Gemini Interactions API do Google aceita servidores MCP externos pela declaração "type": "mcp_server", configurada com name, url, headers e allowed_tools. O Google impõe duas regras rigorosas a essa integração:

Somente Streamable HTTP: a Gemini Interactions API aceita servidores Streamable HTTP e não aceita transportes SSE.
Sintaxe dos nomes: nomes de servidores devem usar snake_case e não podem conter hífens.

Quando usar Tool Calling ou MCP?

A escolha entre MCP e Tool Calling depende de quem mantém as integrações e de quantas aplicações precisam compartilhá-las. Avalie as restrições do projeto em três padrões comuns.

Quando Tool Calling simples é suficiente

Use Tool Calling nativo do LLM quando suas ferramentas estiverem no backend de uma única aplicação e nenhum cliente externo precisar chamá-las. Se estou criando um aplicativo web com cinco consultas internas ao banco de dados e uma ação de checkout Stripe, escrever um servidor MCP adiciona uma etapa de rede ou um subprocesso desnecessário.

Tool Calling simples é mais adequado quando:

Você tem apenas um pequeno número de funções que consultam seu próprio banco de dados ou microsserviços internos.
Você controla toda a base de código e quer baixa latência e validação direta no mesmo processo.
Nenhum outro assistente de IA, IDE ou equipe precisa descobrir ou reutilizar essas funções.

Quando um servidor MCP compensa

Crie ou adote um servidor MCP quando as mesmas ferramentas precisarem funcionar em vários clientes de IA ou quando outra equipe for responsável pelo sistema subjacente. Se sua plataforma de engenharia expõe acompanhamento de problemas e logs de implantação via MCP, desenvolvedores podem conectar exatamente o mesmo servidor ao Claude, ChatGPT, Visual Studio Code, Cursor e ao seu agente interno sem reescrever esquemas.

MCP compensa quando:

Você quer escrever uma vez e obter portabilidade entre vários hosts de IA e IDEs de desenvolvimento.
Um fornecedor externo ou outra equipe interna mantém a integração.
Seu agente depende da descoberta dinâmica de ferramentas (tools/list e listChanged) quando as capacidades mudam em tempo de execução.
Seu fluxo precisa de Resources MCP, modelos de prompt para usuários ou solicitação de informações ao usuário além da execução de funções.

A configuração híbrida

Um padrão comum para equipes que levam agentes de IA do piloto à produção combina as duas abordagens. Uma aplicação típica define no código algumas ferramentas de função nativas sensíveis à latência e conecta um ou dois servidores MCP externos para integrações SaaS de terceiros, usando allowed_tools para filtrar endpoints desnecessários.

Compensações de segurança, latência e custo de tokens

Adicionar ferramentas a uma aplicação LLM, por declarações nativas ou servidores MCP, traz custos de tokens, questões de cache e limites de segurança que precisam ser gerenciados com cuidado.

Custos de tokens de entrada e cache de prompts

Cada definição de ferramenta passada a uma API de modelo conta como tokens de entrada. A Anthropic documenta que as definições no parâmetro tools contam como tokens de entrada, e a OpenAI observa que alguns servidores MCP expõem dezenas de ferramentas de uma vez, o que pode aumentar tanto o custo quanto a latência.

Para manter previsíveis os gastos com tokens:

Filtre as ferramentas importadas: OpenAI e Google usam allowed_tools, enquanto o MCP connector da Anthropic permite incluir, bloquear ou configurar ferramentas individuais no mcp_toolset.
Mantenha determinística a ordem da lista de ferramentas. A especificação MCP observa que uma ordem determinística em tools/list ajuda os clientes a armazenar a lista em cache e melhora a taxa de acertos do cache de prompts do LLM quando as definições estão no contexto do modelo.

Limites de confiança e aprovação humana

Ferramentas envolvem execução de código arbitrário, uma preocupação ainda maior se você também implantar agentes de IA que usam computadores e interagem com sistemas operacionais completos. Ao conectar um servidor MCP de terceiros, você cruza um limite de confiança no qual descrições de ferramentas ou respostas do servidor não confiáveis podem servir como vetor de injeção de prompt.

A especificação MCP alerta explicitamente que anotações de ferramentas devem ser tratadas como não confiáveis, a menos que venham de um servidor confiável. Como MCP não pode impor segurança no nível do protocolo de comunicação, a especificação afirma que aplicações host devem obter consentimento explícito do usuário antes de invocar qualquer ferramenta e deveriam sempre manter uma pessoa no processo com capacidade de negar invocações. Ao usar integrações diretas de API como a Responses API da OpenAI, ative require_approval em ferramentas sensíveis para que uma pessoa revise os argumentos antes da execução.

FAQ

MCP é igual a Function Calling?

Não. Function Calling (Tool Calling) é o mecanismo da API de modelo em que um LLM emite uma solicitação JSON estruturada para executar uma função nomeada. Model Context Protocol (MCP) é um padrão aberto de comunicação que permite a aplicações de IA descobrir e invocar Tools, Resources e Prompts hospedados em servidores externos.

É possível usar MCP sem Tool Calling?

Você pode usar Resources e modelos de prompt MCP sem Tool Calling do modelo, pois esses recursos são lidos ou acionados pela aplicação host ou pelo usuário. Porém, sempre que um modelo de IA invoca autonomamente uma ferramenta MCP por tools/call, ele usa sua capacidade nativa de Tool Calling para selecioná-la.

MCP custa mais tokens que Tool Calling nativo?

Uma definição individual de ferramenta custa o mesmo número de tokens de entrada, seja carregada pelo aplicativo a partir de código local ou de um servidor MCP. Na prática, configurações MCP costumam consumir mais tokens porque um único servidor MCP pode expor dezenas de ferramentas de uma vez, a menos que você filtre a lista com allowed_tools.

Quais fornecedores de LLM oferecem suporte nativo a servidores MCP em suas APIs?

Em novembro de 2026, OpenAI, Anthropic e Google aceitam servidores MCP remotos diretamente em suas APIs. A OpenAI aceita "type": "mcp" na Responses API, a Anthropic oferece o MCP connector beta (mcp_servers e mcp_toolset) na Messages API e o Google aceita "type": "mcp_server" na Gemini Interactions API.

A API da Anthropic pode se conectar diretamente a um servidor MCP stdio local?

Não. O MCP connector beta da Anthropic na Messages API só se conecta a servidores MCP remotos expostos publicamente por HTTP (Streamable HTTP e SSE). Para usar um servidor MCP stdio local com Claude, você deve executar a conexão no cliente usando os auxiliares do SDK da Anthropic.

Tool Calling vs MCP: diferenças e quando usar cada um

O que é Tool Calling em APIs de LLM?

O que é Model Context Protocol (MCP)?

Tool Calling vs MCP: comparação

MCP substitui Function Calling?