Como configurar um servidor MCP no Claude Desktop — um guia prático

Desde a apresentação pública do Anthropic Protocolo de Contexto do Modelo (MCP) on 25 de novembro de 2024 O MCP evoluiu rapidamente de conceito para ecossistema prático: uma especificação aberta e múltiplos servidores de referência estão disponíveis, implementações da comunidade (servidores de memória, acesso ao sistema de arquivos, buscadores da web) estão no GitHub e no NPM, e o MCP já é suportado em clientes como... Claude para Desktop e ferramentas de terceiros. O protocolo evoluiu (a especificação e os exemplos de servidor foram atualizados até 2025), e fornecedores e engenheiros estão publicando padrões para integrações mais seguras e com uso eficiente de tokens.

Este artigo orienta você na criação de um servidor MCP e na sua conexão com... Claude DesktopAlém disso, dicas práticas, de segurança e de memória que você precisará na produção.

O que é o Protocolo de Contexto do Modelo (MCP)?

Uma definição em linguagem simples.

O Protocolo de Contexto do Modelo (MCP) é um protocolo aberto e padronizado Isso facilita para os hosts do LLM (os aplicativos que executam o modelo, por exemplo, o Claude Desktop) a chamada para serviços externos que expõem recursos (arquivos, linhas do banco de dados), ferramentas (funções que o modelo pode invocar), e solicita (modelos que o modelo pode usar). Em vez de implementar integrações N×M (cada modelo para cada ferramenta), o MCP fornece um esquema cliente-servidor consistente e um contrato de tempo de execução para que qualquer host de modelo compatível com MCP possa usar qualquer servidor compatível com MCP — assim, os desenvolvedores podem criar serviços uma vez e permitir que qualquer modelo ou interface de usuário compatível com MCP (por exemplo, Claude Desktop) os utilize.

Por que o MCP é importante agora?

Desde que a Anthropic tornou o MCP de código aberto no final de 2024, o protocolo rapidamente se tornou uma camada de interoperabilidade padrão para integrações de ferramentas (Claude, extensões do VS Code e outros ambientes de agentes). O MCP reduz o trabalho duplicado, acelera o desenvolvimento de conectores (Google Drive, GitHub, Slack etc.) e facilita a conexão de armazenamentos de memória persistentes a um assistente.

O que é a arquitetura MCP e como ela funciona?

Em linhas gerais, o MCP define três grupos de funções e vários padrões de interação.

Componentes principais: clientes, servidores e o registro.

• Cliente MCP (host): O host ou aplicativo LLM que deseja dados contextuais — Claude Desktop, um agente do VS Code ou um aplicativo da web. O cliente descobre e se conecta a um ou mais servidores MCP.
• Servidor MCP (provedor de recursos): Um serviço de rede que expõe recursos (arquivos, memórias, bancos de dados, ações) por meio do esquema MCP. Os servidores declaram suas capacidades e fornecem pontos de extremidade que o cliente pode chamar.
• Registro/Descoberta: Componentes opcionais ou arquivos de configuração que ajudam o cliente a descobrir servidores MCP disponíveis, listar recursos e gerenciar permissões ou instalação (as "extensões" da área de trabalho são uma camada de experiência do usuário para isso).

Fluxos de mensagens e negociação de capacidades

As interações MCP normalmente seguem este padrão:

1. Descoberta/registro: O cliente fica sabendo sobre os servidores disponíveis (locais, de rede ou registros selecionados).
2. Anúncio de novas funcionalidades: O servidor compartilha um manifesto que descreve os recursos, os métodos e os requisitos de autorização.
3. Solicitação/resposta: O cliente emite solicitações estruturadas (por exemplo, "ler arquivo X", "buscar Y na memória" ou "criar PR com esses arquivos") e o servidor responde com dados contextuais tipados.
4. Resultados das ações e transmissão ao vivo: Os servidores podem transmitir resultados ou fornecer endpoints para operações de longa duração. A especificação define esquemas para descritores de recursos tipados e respostas.

Modelo de segurança e limites de confiança

O MCP padroniza intencionalmente as superfícies de controle para que os LLMs possam agir sobre os dados do usuário e executar ações. Esse poder exige controles de segurança rigorosos:

• Consentimento explícito do usuário / avisos São recomendadas quando os servidores podem acessar dados privados ou executar ações privilegiadas (por exemplo, gravar em repositórios).
• O privilégio mínimo se manifesta da seguinte forma: Os servidores devem declarar escopos mínimos e os clientes devem solicitar apenas as funcionalidades necessárias.
• Transporte e autorização: Use TLS, credenciais tokenizadas e endpoints somente locais para integrações sensíveis. A comunidade e os fornecedores de plataformas (por exemplo, a Microsoft no Windows) estão experimentando com registros e recursos de interface do usuário para reduzir os riscos.

---

Por que integrar o Claude com os servidores MCP?

A integração do Claude com os servidores MCP desbloqueia três classes práticas de funcionalidades:

Contexto acionável em tempo real

Em vez de copiar e incorporar instantâneos desatualizados em prompts, Claude pode solicitar contexto atualizado (arquivos, histórico de conversas, linhas do banco de dados) no momento da consulta. Isso significa menos recuperações aproximadas e resultados mais recentes. As demonstrações da Anthropic mostram Claude realizando ações como criar PRs no GitHub ou ler arquivos locais via MCP.

Ferramentas pequenas e combináveis ​​em vez de um adaptador gigante.

Você pode criar servidores MCP focados — um para calendário, um para sistema de arquivos, um para armazenamento de memória vetorial — e reutilizá-los em diferentes instâncias ou clientes do Claude (desktop, IDE, web). Essa modularidade oferece melhor escalabilidade do que integrações personalizadas.

Memória persistente e padronizada

O MCP permite serviços de memória: armazenamentos persistentes que codificam o histórico de conversas, preferências pessoais e estado estruturado do usuário. Como o MCP padroniza o modelo de recursos, vários clientes podem reutilizar o mesmo servidor de memória e manter um contexto de usuário consistente entre os aplicativos. Já existem diversos serviços de memória e padrões de extensão da comunidade.

Melhor experiência do usuário e controle local (Claude Desktop)

Em clientes de desktop, o MCP permite que servidores locais acessem diretamente o sistema de arquivos do usuário (com consentimento), viabilizando integrações que respeitam a privacidade sem a necessidade de APIs em nuvem. As extensões de desktop da Anthropic são um exemplo de como simplificar a instalação e a detecção de servidores MCP em máquinas locais.

Como criar um servidor MCP

O que você precisa antes de começar

1. Claude DesktopInstale a versão mais recente do Claude Desktop para o seu sistema operacional e certifique-se de que o suporte a MCP/Extensões esteja ativado nas configurações. Alguns recursos podem exigir um plano pago (Claude Pro ou equivalente).
2. Máquina de revelaçãoNode.js (versão 16/18 ou superior recomendada) ou Python 3.10 ou superior, além de ngrok ou uma solução de tunelamento local caso deseje expor um servidor local à internet para testes. Utilize TLS em produção.
3. O projeto MCP fornece SDKs e modelos na documentação principal e no repositório do GitHub; instale o SDK para Python ou Node seguindo as instruções oficiais na documentação/repositório.

Opção A — Instalar um servidor MCP existente (exemplo)

A Anthropic fornece servidores de exemplo, incluindo memória, sistema de arquivos e ferramentas.

Clonar os servidores de referência:

git clone https://github.com/modelcontextprotocol/servers.git
cd servers

Lá dentro, você encontrará pastas como:

filesystem/
fetch/
memory/
weather/

Para instalar um servidor de exemplo:

cd memory
npm install
npm run dev

Isso inicia o servidor MCP, geralmente em:

http://localhost:3000

Confirme se o endpoint do manifesto funciona e se a chamada da ferramenta retorna um JSON tipado corretamente.

Opção B — Crie seu próprio servidor MCP (recomendado para aprendizado)

1) Crie uma pasta de projeto

mkdir my-mcp-server
cd my-mcp-server
npm init -y

2) Instale o SDK do servidor MCP

npm install @modelcontextprotocol/server

3) Crie um arquivo de servidor básico

Crie server.js:

touch server.js

Cole aqui a implementação mínima do servidor MCP:

import { createServer } from "@modelcontextprotocol/server";

const server = createServer({
  name: "my-custom-server",
  version: "0.1.0",

  tools: [
    {
      name: "hello_world",
      description: "Returns a simple greeting",
      input_schema: {
        type: "object",
        properties: {
          name: { type: "string" }
        },
        required: 
      },
      output_schema: {
        type: "object",
        properties: {
          message: { type: "string" }
        }
      },
      handler: async ({ name }) => {
        return { message: `Hello, ${name}!` };
      }
    }
  ]
});

server.listen(3000);
console.log("MCP server running on http://localhost:3000");

Isto é um Servidor MCP completo Expondo uma única ferramenta: hello_world.

Como conectar o Claude Desktop a um servidor MCP?

A seguir, apresentamos um passo a passo prático para criar um servidor MCP simples e registrá-lo no Claude Desktop. Esta seção é prática: aborda a configuração do ambiente, a criação do manifesto do servidor, a exposição dos endpoints esperados pelo cliente e a configuração do Claude Desktop para usar o servidor.

1) Abra a área de conexão do desenvolvedor do Claude Desktop.

No Claude Desktop: Configurações → Desenvolvedor (ou Configurações → Conectores (dependendo da versão do cliente). Há uma opção para adicionar um servidor MCP remoto/local ou "Adicionar conector". A interface exata pode mudar entre as versões; se você não a vir, verifique o menu "Desenvolvedor" na área de trabalho ou as notas de versão mais recentes.

2) Se você estiver configurando um servidor local: Crie ou localize o arquivo de configuração.

Após iniciar o aplicativo Claude para desktop, ele configura automaticamente todos os servidores MCP encontrados em um arquivo chamado ClaudeDesktopConfig.json. O primeiro passo é localizar e abrir este arquivo, ou criá-lo caso ainda não exista:

Para usuários do Windows, o arquivo está localizado em “%APPDATA%\Claude\claude_desktop_config.json”.

Para usuários de Mac, o arquivo está localizado em “~/Library/Application Support/Claude/claude_desktop_config.json”.

3) Adicione o servidor ao Claude Desktop.

Existem dois padrões de UX para informar o Claude Desktop sobre o seu servidor MCP:

Extensões para desktop / Instaladores com um cliqueA Anthropic documentou as "Extensões de Área de Trabalho", que empacotam manifestos e instaladores para que os usuários possam adicionar servidores com um único clique (recomendado para uma distribuição mais ampla). Você pode empacotar seu manifesto e metadados do servidor para facilitar a instalação.

**Registro no servidor local (modo desenvolvedor)**Para testes locais:

• Coloque o manifesto em um caminho local conhecido ou sirva-o em https://localhost:PORT/.well-known/mcp-manifest.json.
• Nas configurações do Claude Desktop, abra o painel MCP/Extensões e escolha “Adicionar servidor local” ou “Adicionar servidor por URL” e cole o URL do manifesto ou o token.
• Conceda as permissões necessárias quando o cliente solicitar. Claude irá enumerar os recursos do servidor e apresentá-los como ferramentas/memórias disponíveis.

Agora, optamos por instalar o MCP local:Adicione um mcpServers seção que lista o nome do seu servidor e um caminho/comando absoluto para iniciá-lo. Salve e reinicie o Claude Desktop.

Após a reinicialização, a interface do usuário do Claude exibirá as ferramentas do MCP (ícone de Pesquisa e Ferramentas) e permitirá que você teste as operações disponíveis (por exemplo, "Qual a previsão do tempo em Sacramento?"). Se o host não detectar seu servidor, consulte o manual de instruções. mcp.log arquivos e mcp-server-<name>.log para saída STDERR.

4) Teste a integração

No chat do Claude, digite:

Call the hello_world tool with name="Alice"

Claude irá invocar seu servidor MCP e responder usando a saída da ferramenta.

Como implementar um serviço de memória sobre MCP (dicas avançadas)?

Os serviços de memória estão entre os servidores MCP mais poderosos, pois persistem e expõem o contexto do usuário entre sessões. As seguintes práticas recomendadas e dicas de implementação refletem a especificação, a documentação do Claude e os padrões da comunidade.

Modelo e projeto de dados de memória

• Estruturado versus não estruturado: Armazene tanto informações estruturadas (por exemplo, nome, indicadores de preferência) quanto trechos de conversa não estruturados. Use metadados tipados para filtragem rápida.
• Fragmentação e incorporação: Divida documentos ou conversas longas em blocos semanticamente coesos e armazene representações vetoriais para facilitar a busca por similaridade. Isso melhora a recuperação de informações e reduz o uso de tokens durante a consulta.
• Sinais de recência e saliência: Registre os horários e as pontuações de saliência; permita consultas que priorizem memórias recentes ou de alta saliência.
• Etiquetas de privacidade: Identifique os itens com etiquetas de sensibilidade (privado, compartilhado, efêmero) para que o cliente possa solicitar o consentimento.

Padrões de API para operações de memória

Implemente pelo menos três operações:

• writeAceita um item de memória com metadados, retorna uma confirmação e o ID de armazenamento.
• queryAceita uma consulta em linguagem natural ou um filtro estruturado e retorna as k principais correspondências (opcionalmente com metadados de explicabilidade).
• delete/updateSuporte a operações de ciclo de vida e solicitações explícitas do usuário para esquecer.

Elabore respostas que incluam a proveniência (de onde veio a memória) e uma pontuação de confiança/similaridade para que o cliente e o modelo possam decidir com que intensidade usar a memória.

Estratégias de aumento da recuperação para Claude

• Janelas de contexto curtas: Retorna trechos concisos de memória em vez de documentos completos; permite que Claude solicite o contexto completo, se necessário.
• Camada de sumarização: Opcionalmente, armazene um breve resumo de cada item na memória para reduzir o número de tokens. Use sumarização incremental nas gravações.
• Injeção controlada: Forneça memória como um "pacote de contexto" anexável que o cliente pode injetar seletivamente nos prompts, em vez de inundar o modelo com tudo.

Segurança e governança para MCPs de memória

• Consentimento e registro de auditoria: Registre quando uma memória foi criada e se o usuário consentiu em compartilhá-la com o modelo. Apresente recursos de interface do usuário claros no Claude Desktop para revisar e revogar memórias.
• Limitação de taxa e validação: Proteja-se contra injeção ou exfiltração de código por meio da validação de tipos e do bloqueio de solicitações inesperadas de execução de código provenientes de servidores.
• Criptografia em repouso e em trânsito: Utilize criptografia forte para os itens armazenados e TLS para todos os endpoints do MCP. Para armazenamentos em nuvem, utilize criptografia de envelope ou chaves gerenciadas pelo cliente, se disponíveis.

Conclusão: Como construir um servidor MCP no Claude Desktop

Este artigo é um guia conciso e pragmático para ir do zero → com o Claude + servidor de memória funcionando no seu laptop:

• Teste um fluxo de trabalho: Peça a Claude para "lembrar" um fato breve e verifique se o servidor o armazenou; em seguida, peça a Claude para recordar esse fato em um prompt posterior. Observe os registros e ajuste a classificação de recuperação.
• Pré-requisitos de instalação: Node.js >= 18, Git, Claude Desktop (versão mais recente).
• Clonar um servidor de referência: bifurque o modelcontextprotocol/servers exemplos ou um servidor de memória da comunidade no GitHub.
• Instale e execute: npm install → npm run dev (ou siga as instruções do README do repositório). Confirme o endpoint do manifesto (por exemplo, http://localhost:3000/manifest) retorna JSON. ()
• Registrar conector no Claude Desktop: Configurações → Desenvolvedor / Conectores → Adicionar conector → apontar para http://localhost:3000 e aprovar escopos.

A integração do Claude (ou de qualquer host) com os servidores MCP permite criar um conector uma única vez e disponibilizá-lo em todos os clientes MCP — Claude Desktop, IDEs ou outras estruturas de agentes —, o que reduz drasticamente a manutenção e acelera a paridade de recursos entre as ferramentas.

Os desenvolvedores podem acessar a API mais recente da Claude AI (na data de publicação deste artigo), como por exemplo: Claude Soneto 4.5 API e API Claude Opus 4.1 através do CometAPI, a versão mais recente do modelo está sempre atualizado com o site oficial. Para começar, explore as capacidades do modelo no Playground e consulte o Guia de API para obter instruções detalhadas. Antes de acessar, certifique-se de ter feito login no CometAPI e obtido a chave da API. CometAPI oferecem um preço muito mais baixo que o preço oficial para ajudar você a se integrar.

Pronto para ir?→ Inscreva-se no CometAPI hoje mesmo !

Se você quiser saber mais dicas, guias e novidades sobre IA, siga-nos em VK, X e  Discord!