Blank white background with no objects or features visible.

Olá, EMEA! A TrueFoundry está expandindo sua presença pela Europa, Oriente Médio e África. Leia mais. →

O que é um MCP Client? Como os AI Agents se conectam a ferramentas

Published: novembro 20, 2026

Resumo
  • Um MCP client é o conector de protocolo dentro de uma aplicação de IA que abre e mantém exatamente uma conexão com um MCP server, negocia capacidades e faz o marshalling de cada requisição de tools/list e tools/call sobre JSON-RPC 2.0.
  • O host não é o client. Claude Desktop, Cursor e VS Code são hosts; cada um inicia um client por server ao qual se conecta. O host possui o modelo e o usuário; o client possui a transmissão na rede.
  • O ciclo de vida da conexão é fixo: descobrir o server, autenticar (OAuth 2.1 para servidores remotos), initialize para negociar capacidades, listar ferramentas e recursos, e então invocar e manipular os resultados. Pule uma etapa e o server o rejeitará.
  • A autenticação migrou para padrões reais. O MCP remoto agora se apoia em OAuth 2.1 com PKCE, metadados de recursos protegidos RFC 9728 e registro dinâmico de cliente; a revisão da especificação de 2026-07-28 impulsionou os clientes em direção a Streamable HTTP stateless e cabeçalhos de identidade Mcp-Name.
  • Em escala empresarial, você para de apontar clientes diretamente para servidores. Um gateway dá a cada client um único endpoint, um modelo de autenticação, descoberta centralizada e auditoria, em vez de N clientes mantendo N conjuntos de credenciais.

O Model Context Protocol (MCP) é frequentemente descrito como "USB-C para IA", o que é um termo chamativo e quase inútil quando você está realmente conectando um agent a um banco de dados. A metáfora da porta esconde a parte que faz o trabalho real: o componente no cabo que fala o protocolo. No MCP, esse componente é o client.

Se você está construindo ou operando AI agents, o client é o componente que você vai depurar às 2 da manhã quando uma chamada de ferramenta travar, quando um token OAuth expirar no meio da sessão ou quando um server anunciar uma ferramenta que seu host nunca exibe para o modelo. Entender exatamente o que o client faz, e o que ele não faz, é a diferença entre tratar o MCP como mágica e operá-lo como infraestrutura.

Este post define o MCP client com precisão: seu papel na tríade host/client/server, o ciclo de vida da conexão passo a passo, como os clientes se autenticam, onde os clientes realmente executam e por que, em qualquer escala séria, você coloca um gateway entre seus clientes e seus servidores.

Quer um único endpoint governado para cada MCP client na sua organização em vez de configurações dispersas? Agende uma demonstração.

A tríade host / client / server

O MCP possui três papéis, e confundi-los é a fonte mais comum de confusão.

Um host é a aplicação de IA com a qual o usuário interage. Ele possui o language model (ou a conexão com um), a conversa e a decisão sobre quais ferramentas expor ao modelo e quando. O Claude Desktop é um host. O Cursor é um host. Um agent personalizado que você escreveu com um SDK é um host.

Um client é um conector de protocolo instanciado pelo host. Seu único trabalho é manter uma conexão com um server e traduzir entre o mundo interno do host e o protocolo de rede do MCP. A relação é de um para um: um client, um server. Um host que se conecta a cinco servidores executa cinco clientes. Cada client mantém seu próprio estado de sessão, seu próprio conjunto de capacidades e suas próprias credenciais.

Um server expõe capacidades, ferramentas (funções que o modelo pode chamar), recursos (dados legíveis como arquivos ou linhas de banco de dados) e prompts (modelos reutilizáveis), sobre o protocolo. Um MCP server do GitHub expõe create_issue e list_pull_requests. Um server do Postgres expõe uma ferramenta de consulta e recursos de tabela.

The triad: a host such as Claude Desktop, Cursor, or a custom agent contains one or more MCP clients, each holding a dedicated connection to a single MCP server (GitHub, a database, an internal service).
A tríade: um host como Claude Desktop, Cursor ou um agent personalizado contém um ou mais clientes MCP, cada um mantendo uma conexão dedicada a um único MCP server (GitHub, um banco de dados, um serviço interno).

A divisão importa porque as responsabilidades não se sobrepõem. O host decide a política ("o modelo deve ter permissão para chamar delete_repo?"). O client aplica o protocolo ("este server está inicializado? a capacidade foi anunciada?"). O server realiza o trabalho e retorna um resultado. Quando algo quebra, você corrige na camada responsável. Uma ferramenta que nunca aparece para o modelo é geralmente um problema do host. Uma ferramenta que aparece, mas gera erro ao ser invocada, é geralmente um problema do client ou do server.

Por que um client por server

A regra de um para um não é um acidente. Cada conexão MCP é uma sessão com estado e capacidades negociadas. O Server A pode suportar assinaturas de recursos; o Server B pode não suportar. O Server A se autentica com um token OAuth do GitHub; o Server B usa uma credencial de banco de dados. Dar a cada conexão seu próprio client mantém esse estado isolado, para que uma capacidade ou um token expirado em uma conexão não corrompa outra. O host se torna o multiplexador: ele distribui uma única requisição de usuário para quaisquer clientes necessários, coleta os resultados e os envia de volta ao modelo.

Pelo que o client é responsável

Remova as metáforas e um MCP client em conformidade faz cinco coisas concretas.

Transport. Ele estabelece e mantém a conexão. O MCP define dois transportes padrão: stdio, onde o client inicia o server como um subprocesso e se comunica via entrada/saída padrão (stdio), e Streamable HTTP, onde o client faz requisições HTTP para uma URL de server e pode receber um fluxo de server-sent events na resposta. Ferramentas locais (um server de sistema de arquivos no seu laptop) normalmente usam stdio. Ferramentas remotas (um serviço hospedado) usam HTTP.

Enquadramento de mensagens. Cada mensagem MCP é JSON-RPC 2.0. O client constrói objetos de requisição com um id, um method e params, associa as respostas de volta às suas requisições por id e roteia notificações iniciadas pelo server. Se você já observou o tráfego bruto do MCP, é apenas um fluxo de envelopes JSON-RPC.

Negociação de capacidades. Na conexão, o client envia initialize com a versão do protocolo que ele fala e as capacidades que ele suporta (por exemplo, se ele pode lidar com requisições de amostragem ou elucidação). O server responde com as dele. A partir desse handshake, ambos os lados sabem o que é permitido. Um client que tenta usar uma capacidade que o server nunca anunciou é um erro de código (bug).

Invocação. Quando o host decide que o modelo deve chamar uma ferramenta, o client envia tools/call com o nome da ferramenta e os argumentos, aguarda o resultado e o entrega de volta. Ele faz o mesmo para resources/read e prompts/get.

Ciclo de vida e limpeza. O client gerencia a sessão desde o handshake até o encerramento, incluindo renovação de token (token refresh), reconexão e o encerramento limpo da conexão quando o host a fecha.

Observe o que não está nessa lista: decidir se uma chamada de ferramenta é segura, ocultar segredos de um resultado ou impedir que um agent fora de controle chame a mesma ferramenta 400 vezes. Essas são preocupações de governança e do host. O protocolo base oferece o encanamento, não a política. Essa lacuna é exatamente onde os controles empresariais, discutidos mais adiante, devem residir.

O ciclo de vida da conexão, passo a passo

Uma conexão de client passa por uma sequência fixa. Entendê-la transforma a maioria das falhas do MCP em uma pergunta rápida: "qual etapa falhou?".

The MCP client connection lifecycle: discover the server, authenticate, initialize and list capabilities, invoke tools, handle the result, then shut down cleanly.
O ciclo de vida da conexão do MCP client: descobrir o server, autenticar, inicializar e listar capacidades, invocar ferramentas, manipular o resultado e, em seguida, encerrar de forma limpa.

1. Descoberta (Discover). O client precisa de um server ao qual se conectar. Para um server stdio local, a "descoberta" é uma entrada de configuração: um comando e argumentos para iniciar. Para um server remoto, é uma URL. Em implantações maiores, a descoberta é dinâmica: o client pergunta a um registro ou a um gateway quais servidores existem e quais são seus endpoints, em vez de codificar cada um diretamente.

2. Autenticação (Authenticate). Para servidores HTTP remotos, o client deve provar quem é antes que o server aceite conversar. O modelo de autorização do MCP é o OAuth 2.1. O client descobre o servidor de autorização a partir de metadados de recursos protegidos (RFC 9728), opcionalmente se registra dinamicamente (RFC 7591), executa o fluxo de authorization-code com PKCE (RFC 7636) e anexa o bearer token resultante a cada requisição. Servidores stdio locais geralmente herdam a confiança do limite do processo e pulam esta etapa.

3. Inicialização (Initialize). O client envia a requisição initialize: sua versão de protocolo, informações do client e capacidades. O server responde com sua versão de protocolo, informações do server e capacidades. Se as versões forem incompatíveis, a conexão falha aqui, de forma limpa, o que é muito melhor do que falhar três chamadas de ferramenta depois. O client então envia uma notificação initialized para confirmar que a sessão está ativa.

4. Listagem de capacidades (List capabilities). O client chama tools/list e, conforme necessário, resources/list e prompts/list. O server retorna o nome de cada ferramenta, descrição e JSON Schema para suas entradas. Este é o catálogo que o host mostrará ao modelo. Os servidores também podem enviar uma notificação listChanged posteriormente se seu conjunto de ferramentas mudar, e um client bem-comportado lista novamente em resposta.

5. Invocação (Invoke). O host escolhe uma ferramenta (geralmente porque o modelo a solicitou) e o client envia tools/call com argumentos validados. Uma chamada de longa duração pode transmitir saída intermediária via streaming. O client correlaciona a resposta à requisição pelo id.

6. Manipulação do resultado (Handle the result). O client retorna o resultado da ferramenta para o host, que o formata para o modelo. Os resultados do MCP possuem uma flag que distingue um erro no nível da ferramenta (a ferramenta foi executada e falhou, ex: "repositório não encontrado") de um erro no nível do protocolo (a chamada em si estava malformada). Tratar esses dois erros da mesma forma é um bug frequente de client: um "não encontrado" é uma informação para o modelo, enquanto um erro de protocolo é algo que seu código deve tratar.

7. Encerramento (Shut down). Quando o host termina, o client fecha o transporte: encerrando o subprocesso no caso de stdio, ou finalizando a sessão HTTP para conexão remota.

Um fluxo mínimo, de forma concreta

Imagine um agent de codificação solicitado a "abrir uma issue intitulada 'Flaky CI' no repositório api". A sequência dentro do host é:

  1. O client já mantém uma sessão inicializada com o MCP server do GitHub, com um token OAuth válido.
  2. O host possui o catálogo de ferramentas obtido em tools/list; ele inclui create_issue com um schema exigindo owner, repo e title.
  3. O modelo emite uma chamada de ferramenta: create_issue({owner: "acme", repo: "api", title: "Flaky CI"}).
  4. O client envia tools/call, o server cria a issue e retorna {issue_number: 412, url: "..."} como um resultado sem erro.
  5. O client repassa isso de volta; o host fornece a informação ao modelo, que responde "Issue #412 aberta com sucesso."

Cada uma dessas etapas é um ponto onde algo pode dar errado: um token expirado (etapa 1), uma incompatibilidade de schema que o modelo adivinhou errado (etapa 3), uma falha de permissão no lado do server que retorna um erro de ferramenta (etapa 4). Conhecer o ciclo de vida indica exatamente onde procurar.

Como os clientes MCP se autenticam

As primeiras conexões MCP eram em sua maioria servidores stdio locais, onde a autenticação era implícita. Servidores remotos mudaram isso, e o protocolo padronizou no OAuth 2.1 em vez de inventar algo novo.

Concretamente, um client remoto:

  • Lê metadados de recursos protegidos (RFC 9728) do server para saber qual servidor de autorização o protege.
  • Opcionalmente realiza registro dinâmico de cliente (RFC 7591) para não precisar de um ID de cliente pré-configurado para cada server que possa encontrar.
  • Executa a concessão de código de autorização com PKCE (RFC 7636), que protege a troca mesmo para clientes públicos que não podem manter um segredo.
  • Anexa o bearer token emitido a cada requisição e o renova antes da expiração.

A revisão da especificação em 2026-07-28 continuou uma direção clara de evolução: em direção a Streamable HTTP stateless, onde um server não precisa vincular uma sessão de longa duração a um único processo, e em direção à identidade explícita do server via cabeçalhos Mcp-Name para que clientes e intermediários possam nomear e rotear para um server específico sem ambiguidade. O transporte stateless importa operacionalmente porque permite que os servidores escalem horizontalmente atrás de um balanceador de carga. Se você deseja uma análise mais aprofundada sobre fluxos de token, vinculação de público (audience binding) e modos de falha, consulte nosso guia sobre autenticação MCP.

A lição prática: um client é tão seguro quanto o seu manuseio de tokens. Um client que registra bearer tokens em logs, que falha ao validar o público do token ou que não faz o refresh corretamente vai vazar credenciais ou quebrar sessões. Essas são responsabilidades do client e são difíceis de acertar de forma isolada, outra razão pela qual o manuseio centralizado vence em escala.

Onde os clientes MCP residem: exemplos reais

"MCP client" parece abstrato até você perceber que provavelmente já usou vários. Aqui estão os mais comuns e o que cada um é, precisamente.

Client / hostO que éOnde o client rodaTransporte típico
Claude DesktopHost desktop que se conecta a servidores MCP locais e remotosDentro do aplicativo desktopstdio (local), Streamable HTTP (remoto)
CursorEditor de código com IA; conecta-se a servidores MCP para repositórios, docs e ferramentasDentro do editorstdio e HTTP
VS Code (com suporte a MCP)Host editor; o modo agent consome ferramentas MCPDentro do editor / host de extensãostdio e HTTP
ClineExtensão de agent de codificação open-source que atua como host MCPNo host de extensão do VS Codestdio e HTTP
Custom SDK agentSua própria aplicação usando uma biblioteca de MCP clientOnde quer que você a implanteSua escolha

A nuance importante nessa tabela: em todos os casos, o client é um componente em nível de biblioteca dentro do produto. O Claude Desktop é o host; o componente que realmente fala JSON-RPC com o server do GitHub é um objeto client criado pelo host. Quando você escreve um agent personalizado com um SDK MCP, você mesmo está instanciando esse objeto client, chamando connect(), list_tools() e call_tool() diretamente.

Isso também explica por que o mesmo server se comporta de maneira ligeiramente diferente entre hosts. O server é idêntico; os clientes diferem em quão agressivamente re-listam ferramentas, como exibem erros de ferramentas para o modelo e como lidam com a autenticação. "Funciona no Claude Desktop, mas não no meu agent" é quase sempre uma diferença de comportamento do client, não do server.

The TrueFoundry MCP Gateway architecture. Source: TrueFoundry docs.
A arquitetura do TrueFoundry MCP Gateway. Fonte: documentação da TrueFoundry.

Veja como a TrueFoundry centraliza autenticação, descoberta e auditoria para cada agent e MCP client. Agende uma demonstração.

Por que um gateway fica entre clientes e servidores em escala

Aponte um client para um server e o MCP será simples. Agora torne isso real: 200 desenvolvedores, 30 servidores MCP internos, cada host tentando manter seus próprios tokens OAuth, cada server acessível em sua própria URL e uma equipe de segurança que quer saber quem chamou qual ferramenta.

O modelo de conexão direta se desfaz rapidamente:

  • Proliferação de credenciais. Cada client possui credenciais para cada server. Rotacionar um segredo significa alterar a configuração de cada client.
  • Sem descoberta centralizada. Cada host codifica URLs de servidores diretamente. Adicionar ou mover um server significa reconfigurar cada client.
  • Sem governança. O protocolo base não tem o conceito de "equipe X pode usar o banco de dados, mas não o servidor de pagamentos", sem limite de taxa compartilhado, sem trilha de auditoria entre servidores.
  • Autenticação inconsistente. Cada client implementa OAuth de forma ligeiramente diferente; alguns fazem isso mal.

A solução é o mesmo padrão que resolveu o problema equivalente para APIs de LLM: colocar um gateway no meio. Um MCP gateway fornece a cada client um único endpoint. O client se autentica uma vez no gateway; o gateway mantém e rotaciona as credenciais para os servidores downstream. A descoberta se torna dinâmica: o client pergunta ao MCP registry do gateway o que existe, em vez de carregar uma lista estática. E como cada chamada flui por um único lugar, você obtém governança, controle de acesso, limites de taxa e auditoria que o próprio protocolo não fornece.

Arquiteturalmente, isso espelha um LLM proxy: uma porta de entrada lógica, muitos backends atrás dela, política aplicada no meio. O trabalho do client fica mais simples, não mais difícil: ele se conecta a um endpoint conhecido com uma credencial e deixa o gateway lidar com o roteamento para múltiplos destinos.

Para ambientes regulamentados, onde as ferramentas chamam sistemas internos que contêm dados sensíveis, isso não é opcional. Você precisa de governança de MCP empresarial: controle de acesso por equipe sobre quais servidores e ferramentas são acessíveis, auditoria completa de cada invocação de ferramenta e a capacidade de revogar o acesso centralmente. O gateway MCP e o registro da TrueFoundry oferecem exatamente isso: os clientes recebem um endpoint, autenticação e RBAC são aplicados centralmente, cada chamada de ferramenta é observável e etiquetada, e a descoberta de servidores roda por meio de um registro governado em vez de arquivos de configuração espalhados. Se você está avaliando opções, nosso resumo dos melhores MCP gateways cobre as vantagens e desvantagens, e a hospedagem de MCP server hosting cobre a execução dos próprios servidores.

Onde as equipes erram nisso

Tratar o host como se fosse o client. As equipes dizem "O Cursor é meu MCP client". O Cursor é o host; ele contém clientes. A distinção é importante no momento da depuração: uma ferramenta que nunca chega ao modelo é uma decisão de exposição do lado do host, enquanto uma ferramenta que gera erro ao ser chamada é um problema do client ou do server. Confundir os dois faz você procurar na camada errada.

Ignorar o handshake doinitialize. Desenvolvedores que escrevem clientes personalizados às vezes disparam uma requisição de tools/call antes que a negociação de capacidades seja concluída, ou presumem uma capacidade que o server nunca anunciou. O resultado são falhas intermitentes e confusas. O handshake não é uma mera formalidade; é o contrato. Honre-o ou espere um comportamento instável.

Confundir erros de ferramentas com erros de protocolo. Um resultado do MCP sinaliza se a ferramenta em si falhou (um erro 404 que o modelo deve ver e raciocinar sobre) em oposição a uma chamada malformada (um problema do seu código). Clientes que misturam esses erros ocultam sinais úteis do modelo ou quebram em condições recuperáveis.

Codificar URLs de servidores e credenciais diretamente em cada client. Funciona para três servidores e colapsa quando chegam a trinta. Configuração estática significa que cada rotação e cada alteração exigem modificações em toda a frota. A descoberta dinâmica por meio de um registro é a única abordagem escalável.

Deixar que cada client gerencie seu próprio OAuth. OAuth 2.1 com PKCE e renovação de token é fácil de implementar com pequenos erros sutis: tokens vazados em logs, validação de público ausente, falhas na renovação. Centralizar a autenticação em um gateway significa implementá-la uma vez, corretamente, em vez de N vezes com N bugs.

Conclusão

O MCP client é o componente discreto que faz o uso de ferramentas por agents funcionar: ele mantém a conexão, negocia capacidades, autentica e faz o marshalling de cada chamada de ferramenta sobre JSON-RPC. Ajuste o modelo mental — o host possui a política, o client possui a transmissão na rede, o server faz o trabalho — e o MCP deixa de ser mágica para se tornar algo que você pode operar e depurar.

Com um client e um server, o modelo direto funciona bem. Em escala empresarial, com dezenas de servidores e centenas de usuários, você para de apontar clientes diretamente para servidores e coloca um gateway no meio: um único endpoint, autenticação e descoberta centralizadas, e governança sobre cada chamada de ferramenta. Essa é a arquitetura que mantém uma frota crescente de agents útil e sob controle.

Forneça a cada MCP client um gateway seguro para se conectar. Agende uma demonstração.

Try now.

One gateway for all your models, MCP servers, and agents. No credit card needed.

Start free
Table of Contents

One Gateway for Every LLM, Agent and MCP Server

Book a 30-min with our AI expert

Book a Demo

The fastest way to build, govern and scale your AI

Book Demo
Summarize with
ChatGPT logo by OpenAI
Perplexity AI logo
Blurry red snowflake on white background, symmetrical frosty design with soft edges and abstract shape.

Discover More

No items found.
novembro 20, 2026
|
5 min read

Grok 4.3 no Amazon Bedrock: Roteamos Quatro Modelos de Fronteira por um Único Gateway e Medimos o Custo

Ferramentas de LLM
comparação
novembro 20, 2026
|
5 min read

GPT-6.1 Terra: API, Benchmarks, Preço & Como Usar

No items found.
TrueFoundry AI gateway is an enterprise alternative to Bifrost and Portkey
novembro 20, 2026
|
5 min read

Bifrost vs Portkey: Precificação, Recursos de Gateway e Adequação Enterprise Comparados

No items found.
novembro 20, 2026
|
5 min read

Evolução do Machine Learning: Um Mergulho Profundo na Jornada de Savin

True ML Talks
No items found.
Take a quick product tour
Start Product Tour
Product Tour