Servidores MCP no Cursor: Instalação, Configuração e Segurança (Guia 2026)

Por padrão, o agente de IA do Cursor conhece apenas sua base de código. Só isso. Ele não consegue ver suas tabelas Postgres, não tem ideia de quais problemas do GitHub estão se acumulando e definitivamente não consegue extrair tokens de design do Figma. Os servidores MCP são o que preenchem essa lacuna. São programas leves que conectam ferramentas externas ao Cursor através de um protocolo padronizado — o Protocolo de Contexto do Modelo—para que o agente possa consultar bancos de dados, registrar problemas ou buscar dados de API diretamente do editor.

Uma breve história. A Anthropic tornou o MCP de código aberto em Novembro de 2024. OpenAI o adotou em maio de 2025, e Google DeepMind trouxe suporte para Gemini em abril. Então, em dezembro de 2025, a Anthropic doou tudo para a Fundação de IA Agêntica (sob a Linux Foundation), co-fundada com a Block e a OpenAI. Essa mudança foi significativa. O MCP deixou de ser um projeto da Anthropic para se tornar um padrão verdadeiramente neutro em relação a fornecedores.

O Cursor surgiu como um dos clientes MCP preferidos entre as IDEs. Mas configurá-lo corretamente — e entender o que pode dar errado tanto do ponto de vista de configuração quanto de segurança — exige mais do que apenas colar um trecho de JSON que você encontrou no Reddit.

Como o MCP Realmente Funciona Dentro do Cursor

Esta é uma das razões pelas quais MCP vs API importa para agentes de IDE: APIs exigem lógica de integração explícita, enquanto MCP permite que o Cursor carregue dinamicamente as ferramentas disponíveis dos servidores conectados.

O MCP define três componentes móveis. Hosts são a aplicação—Cursor. Clientes são conectores dentro do host que gerenciam conexões de servidor individuais. Servidores são os programas leves na outra ponta, expondo ferramentas via JSON-RPC 2.0.

Fonte da imagem

Na prática? Você abre o Cursor. O Agente dele escaneia seus servidores MCP habilitados, carrega as ferramentas que eles expõem e descobre quais chamar como parte de qualquer tarefa em que esteja trabalhando. Vá para Configurações do Cursor > Ferramentas e MCP e você verá cada servidor carregado com um indicador de status. Você pode ativar ou desativar ferramentas individuais a partir desse painel.

Os servidores podem expor três tipos de coisas:

• Ferramentas são o principal—funções executáveis como create_issue ou run_query. O Cursor tem suportado ferramentas desde os primeiros dias de sua integração com o MCP.
• Recursos são dados contextuais: conteúdo de arquivos, esquemas de banco de dados, detalhes de configuração. O suporte a recursos chegou em Cursor v1.6 (Setembro de 2025).
• Prompts permitem que os servidores ofereçam modelos reutilizáveis e fluxos de trabalho predefinidos ao cliente.

Para uma análise mais aprofundada da arquitetura MCP e dos primitivos de servidor, consulte nosso guia sobre MCP e Como Funciona.

Tipos de Transporte: Como o Cursor se Comunica com Servidores MCP

Três opções aqui. Qual delas você escolhe depende de uma pergunta simples — servidor local ou remoto?

Nossa recomendação: stdio para experimentação local. HTTP streamable para literalmente todo o resto.

Configurando Servidores MCP

O Caminho Fácil: Links Diretos de Um Clique

Cada vez mais servidores MCP agora têm um botão "Adicionar ao Cursor" diretamente em sua página de documentação. Clique nele, e o Cursor abrirá uma caixa de diálogo com o nome do servidor, transporte e URL já preenchidos. Clique em Instalar. Esse é todo o processo.

Servidores que exigem autenticação acionarão um fluxo OAuth baseado em navegador, e o Cursor armazenará as credenciais resultantes para você. Se você é um desenvolvedor de servidor que deseja adicionar esses links diretos, a documentação do Cursor MCP explica como.

Configuração Manual: stdio para Servidores Locais

Abra Configurações do Cursor > Ferramentas e MCP, clique em Novo Servidor MCP (que o leva para mcp.json), ou simplesmente crie o arquivo manualmente. Coloque-o em .cursor/mcp.json dentro do seu projeto para configuração específica do projeto, ou em ~/.cursor/mcp.json para configuração global.

Veja como é um servidor GitHub MCP executando via Docker:

{
  "mcpServers": {
    "github": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "GITHUB_PERSONAL_ACCESS_TOKEN",
        "ghcr.io/github/github-mcp-server"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_TOKEN>"
      }
    }
  }
}

Os campos, em resumo:

• "command" — O que o Cursor executa para iniciar o servidor. npx, docker, python, node — o que o servidor esperar.
• "args" — Argumentos encaminhados para esse comando.
• "env" — Variáveis de ambiente passadas em tempo de execução. Coloque as chaves de API aqui. Não no seu perfil de shell, nem em um arquivo .env que possa ser commitado acidentalmente — aqui.

Configuração Manual: HTTP com Streaming para Servidores Remotos

Muito mais simples. Apenas uma URL e cabeçalhos opcionais:

{
  "mcpServers": {
    "remote-api": {
      "url": "https://mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_API_KEY>"
      }
    }
  }
}

Sem comando. Sem argumentos. O Cursor acessa o endpoint HTTP diretamente.

Configuração de Projeto vs. Global

A configuração de projeto (.cursor/mcp.json na raiz do repositório) afeta apenas aquele projeto. A configuração global (~/.cursor/mcp.json) aplica-se em todo lugar. Mesmo servidor definido em ambos os arquivos? A configuração de projeto tem prioridade.

Quando as Coisas Dão Errado: Resolução de Problemas do MCP no Cursor

O Limite de 40 Ferramentas

O Cursor tem um limite de aproximadamente 40 ferramentas ativas em todos os seus servidores MCP combinados. Exceda-o e duas coisas acontecem: você recebe um aviso, e o agente perde silenciosamente o acesso a algumas ferramentas. Ele simplesmente não consegue mais vê-las.

Por que o limite existe? Cada definição de ferramenta consome tokens de contexto. E uma vez que você coloca mais de 40 descrições de ferramentas em um prompt, a capacidade do LLM de escolher a ferramenta certa se deteriora visivelmente.

O que fazer a respeito: abra cada servidor nas configurações e desative as ferramentas que você não está usando ativamente. E como regra geral, um servidor que expõe de 5 a 10 ferramentas bem definidas o servirá melhor do que um megasservidor tentando fazer 30 coisas.

"Nenhuma Ferramenta Encontrada" ou Falhas Silenciosas

Seu Servidor MCP não iniciou. O Cursor não mostra erro. Nem aviso. Nada. Você apenas percebe que as ferramentas não estão aparecendo.

Nove em cada dez vezes, o problema é um destes: Node.js ou Python não está instalado (ou não está no seu PATH). A versão do pacote na sua configuração não existe. Ou uma variável de ambiente que você referenciou está vazia ou completamente ausente.

A maneira mais rápida de depurar: copie o comando do seu mcp.json literalmente e execute-o em um terminal. Assim: npx -y @modelcontextprotocol/server-postgres postgresql://localhost/mydb. Qualquer erro que o Cursor estava "engolindo" será impresso diretamente na sua tela.

SSH e Ambientes Remotos

O transporte stdio e os ambientes remotos não se dão bem. O subprocesso é iniciado no lado remoto, mas o Cursor o espera localmente. Você acaba com falhas de conexão intermitentes que são incrivelmente irritantes de rastrear.

Basta usar HTTP Transmissível (Streamable HTTP). Implante o servidor MCP como um endpoint hospedado e aponte o Cursor para a URL. Isso economiza horas de depuração.

Pequenos Erros de Configuração Que Desperdiçam Sua Tarde

Continuamos encontrando os mesmos três:

• Nome do servidor + nome da ferramenta com mais de 60 caracteres. O Cursor lança um erro, mas a mensagem não é particularmente útil.
• Chave raiz "mcpServers" ausente. Sem erro. Sem aviso. O Cursor simplesmente ignora o arquivo inteiro. Você ficará olhando para o seu JSON perfeitamente formatado, perguntando-se por que nada está carregando.
• Esquecer o -y com npx. O processo trava para sempre. Por quê? Porque o npx está esperando que você confirme a instalação de um pacote, mas não há um terminal interativo para você digitar "y".

Segurança MCP: A Parte Que Você Não Pode Se Dar ao Luxo de Pular

Servidores MCP executam código com suas credenciais. Deixe isso assentar por um momento. Quaisquer permissões que você conceda a um servidor — acesso a banco de dados, tokens do GitHub, chaves de API — ele as usará. Cada servidor MCP é, para todos os efeitos práticos, uma integração totalmente confiável. Se um servidor for comprometido ou malicioso, ele terá tudo o que você lhe deu.

2025 foi um ano difícil para o Cursor Segurança do MCP. Pesquisadores publicaram múltiplas CVEs críticas, e cada uma expôs uma superfície de ataque fundamentalmente diferente:

• CVE-2025-54136, apelidada de "MCPoison" — Check Point Research descobriu que o Cursor fixava a confiança no nome da chave do servidor MCP no arquivo de configuração, e não no comando real que estava sendo executado. Impacto concreto: alguém poderia enviar um .cursor/mcp.json modificado para um repositório compartilhado, trocando um comando legítimo por um malicioso. O Cursor ainda o executaria sem pedir aprovação, porque o nome da chave não havia mudado. Corrigido no Cursor 1.3, julho de 2025.
• CVE-2025-54135, chamada de "CurXecute" — AIM Security conseguiu algo surpreendente. Eles demonstraram que conteúdo envenenado dentro de mensagens do Slack, quando resumido pelo agente do Cursor, poderia reescrever seu arquivo de configuração MCP e iniciar automaticamente servidores maliciosos. Uma mensagem do Slack. Esse é o vetor de ataque. Corrigido no Cursor 1.3.9.
• CVE-2025-59944 — Lakera encontrou um truque de sensibilidade a maiúsculas e minúsculas que visava macOS e Windows. Atacantes poderiam sobrescrever .cursor/mcp.json escrevendo em .cUrSoR/mcp.json — o sistema de arquivos os tratava como o mesmo caminho. Corrigido no Cursor 1.7.
• CVE-2025-64106 — Cyata Security descobriu que o diálogo de instalação do MCP no Cursor poderia ser falsificado. Ele mostraria um nome confiável como "Playwright" ao usuário enquanto executava comandos completamente diferentes e controlados por atacantes nos bastidores. O Cursor lançou uma correção na versão 2.0. Levaram apenas 48 horas desde a divulgação.

Melhores Práticas de Segurança

• Desative o modo de execução automática. Forçar o agente a obter aprovação explícita antes de cada invocação de ferramenta. Sim, de cada uma delas. O atrito vale a pena.
• Privilégio mínimo para credenciais, sempre. Tokens de GitHub somente leitura para qualquer coisa relacionada a pesquisa. Usuários de banco de dados somente leitura para navegação de esquema. Nunca conceda acesso de escrita a menos que o caso de uso o exija absolutamente.
• Fixe as versões dos pacotes. npx -y mcp-server@1.2.3—não @latest. Uma tag `latest` comprometida é um vetor real de ataque à cadeia de suprimentos, e você não vai querer descobrir da maneira mais difícil.
• Leia o código-fonte de servidores de terceiros. Se você não executaria um pacote npm não verificado em produção, você também não deveria executar um servidor MCP não verificado em seu IDE. Mesmo perfil de risco.
• Mantenha-se na versão mais recente do Cursor. Todo o crédito à equipe do Cursor—eles corrigiram cada uma dessas CVEs em questão de dias. Mas essas correções só ajudam se você realmente atualizar.
• Trate as alterações em .cursor/mcp.json no Git como alterações de infraestrutura. O mesmo rigor de revisão que você aplicaria a um arquivo Terraform ou a um fluxo de trabalho do GitHub Actions.

Mais detalhes sobre esses tópicos em nossos guias sobre segurança empresarial do MCP e padrões de controle de acesso.

Escalando o MCP do Desenvolvedor ao Nível Empresarial

Para um único desenvolvedor, o MCP é ótimo. Configure-o uma vez, aproveite o aumento de produtividade e siga em frente. Mas escalar para uma equipe de 20? Ou 200? É aí que a dor começa.

Chaves de API acabam espalhadas por laptops individuais. Não há uma visão centralizada de quais servidores e ferramentas estão ativos em toda a organização. Nenhuma trilha de auditoria. E quando alguém sai da empresa—ou mesmo apenas muda de equipe—você fica preso à rotação de credenciais em dezenas de arquivos de configuração individuais do Cursor espalhados por sabe-se lá quantas máquinas.

Um Gateway MCP coloca uma camada entre os seus agentes e os seus servidores MCP que lida com tudo o que foi mencionado acima: autenticação centralizada, acesso baseado em funções, observabilidade e aplicação de políticas.

O Gateway MCP da TrueFoundry faz exatamente isso. Os desenvolvedores autenticam-se uma vez no gateway. A partir desse ponto, o gateway gerencia todos os tokens OAuth e credenciais subsequentes para eles. Os administradores definem controles de acesso e permissões por servidor através RBAC. Cada chamada de ferramenta — cada uma delas — é registrada com rastreamento completo no nível da solicitação.

Uma funcionalidade que vale a pena destacar especificamente: Servidores MCP Virtuais. O gateway pode expor um subconjunto de ferramentas com escopo definido dos servidores por trás dele. Suponha que você queira um agente que possa ler problemas do GitHub, mas que nunca, sob nenhuma circunstância, possa excluir um repositório. Você não impõe isso por meio de um prompt de sistema que o LLM possa ignorar. O gateway impõe isso no nível do protocolo. A ferramenta "excluir repositório" simplesmente não existe da perspectiva do agente.

Organizações que já utilizam o AI Gateway da TrueFoundry para roteamento de LLM e controle de custos obtêm integração nativa com o Gateway MCP. Um único painel de controle abrangendo modelos, ferramentas e agentes.

O Cursor também pode se conectar diretamente ao AI Gateway da TrueFoundry para roteamento centralizado de LLM, rastreamento de custos e gerenciamento de chaves.

Conclusão

O MCP dá ao Cursor a capacidade de interagir com ferramentas reais e externas — não apenas com seus arquivos de origem. A configuração individual leva minutos. O verdadeiro desafio de engenharia surge mais tarde: governança, gerenciamento de credenciais, controle de acesso e observabilidade em escala de equipe.

Comece pequeno. Um ou dois servidores. Use links diretos quando disponíveis. Respeite o limite de 40 ferramentas. Mantenha-se atualizado para estar à frente das correções de segurança. E se você estiver implantando o MCP em uma equipe ou organização, considere um Gateway MCP antes que o problema de proliferação de credenciais se resolva transformando-se em um incidente de segurança.

Explore o Gateway MCP da TrueFoundry ou agende uma demonstração para vê-lo em ação.

Perguntas Frequentes

O que exatamente é um servidor MCP no Cursor?

Um programa leve que conecta o agente de IA do Cursor a uma ferramenta externa ou fonte de dados através do Protocolo de Contexto do Modelo. Ele expõe funções (chamadas "ferramentas") que o agente descobre e invoca durante os fluxos de trabalho. GitHub, Postgres, Figma, Slack — todos eles têm servidores MCP disponíveis.

Como adiciono um ao Cursor?

Três maneiras. Botões de link direto de um clique na página de documentação do servidor (a mais fácil). A Configurações do Cursor > Ferramentas e MCP > Novo Servidor MCP UI. Ou criando manualmente .cursor/mcp.json (com escopo de projeto) ou ~/.cursor/mcp.json (global).

Qual é o limite de ferramentas?

Cerca de 40 ferramentas ativas em todos os servidores. Ultrapassando isso, o agente piora na escolha da ferramenta certa porque o contexto se esgota. Desative o que você não está usando.

O Cursor lida com recursos e elicitação de MCP?

Sim. Recursos enviados em v1.6 (Setembro de 2025) — dados contextuais como esquemas e conteúdos de arquivos. A elicitação foi implementada em v1.5 (Agosto de 2025) — os servidores podem solicitar entrada estruturada do usuário durante a execução.

É seguro usar servidores MCP no Cursor?

Depende da sua configuração. Servidores MCP executam código com as permissões que você fornece. Pesquisadores encontraram múltiplas vulnerabilidades críticas em 2025, todas corrigidas rapidamente. Mantenha o Cursor atualizado, desative a execução automática, restrinja credenciais, fixe as versões dos pacotes e audite servidores de terceiros antes de adicioná-los.

Como grandes equipes gerenciam servidores MCP?

Através de um Gateway MCP. O gateway da TrueFoundry centraliza a autenticação, impõe o RBAC e registra cada invocação de ferramenta. Os administradores controlam exatamente quais equipes têm acesso a quais servidores. Consulte nossa comparação de gateways MCP para uma análise detalhada.