Autenticação e Segurança de Servidores MCP no Cursor

Os servidores Model Context Protocol (MCP) estendem o Cursor com poderosos recursos externos, desde a consulta de plataformas de anúncios até a gestão de fluxos de pagamento. No entanto, cada conexão externa introduz considerações de autenticação e segurança. Este guia percorre todo o espectro da autenticação de servidores MCP no Cursor, cobrindo fluxos OAuth, gestão de chaves de API, camadas de aprovação humana para pagamentos orientados por IA e os desafios específicos que os usuários enfrentam com serviços como o Live Meta Ads MCP.

Por que a Autenticação MCP é Importante

Quando o Cursor se conecta a um servidor MCP, esse servidor pode precisar agir em seu nome: ler dados privados, publicar conteúdo ou até mesmo gastar dinheiro. A autenticação é o porteiro que determina o que o agente pode e não pode fazer.

O Modelo de Segurança em Resumo

Camada	Responsabilidade	Exemplo
Cursor	Hospeda o cliente MCP, gerencia conexões	Lê mcp.json, inicia processos do servidor
Servidor MCP	Lida com chamadas de API externas	Chama Meta Graph API, Stripe API
Provedor de Autenticação	Valida identidade	Token OAuth do Meta, chave de API do provedor
Aprovação Humana	Controla ações sensíveis	Aprovar antes que o pagamento seja enviado

aviso

Nunca armazene chaves de API de produção ou tokens OAuth em texto simples dentro do seu repositório. Sempre use variáveis de ambiente ou um gerenciador de segredos. Enviar credenciais para o git é um dos incidentes de segurança mais comuns que os desenvolvedores enfrentam.

Pré-requisitos

Antes de configurar a autenticação MCP no Cursor, certifique-se de ter:

1. Cursor instalado e atualizado para a versão mais recente
2. Node.js 18+ para executar servidores MCP baseados em npx
3. Uma conta com o serviço externo que deseja conectar (ex.: Meta for Developers, Stripe)
4. Credenciais de aplicativo do provedor (ID do cliente, segredo do cliente ou chave de API)

Compreendendo os Métodos de Autenticação MCP

O Cursor suporta dois padrões principais de autenticação para servidores MCP, e a escolha depende inteiramente do que o servidor ao qual você está se conectando suporta.

Método 1: Autenticação por Chave de API

O padrão mais simples. O servidor MCP espera uma chave de API estática passada por uma variável de ambiente ou cabeçalho.

{
  "mcpServers": {
    "my-api-server": {
      "command": "npx",
      "args": ["-y", "@my-org/api-mcp-server"],
      "env": {
        "API_KEY": "${MY_API_KEY}"
      }
    }
  }
}

A sintaxe ${MY_API_KEY} diz ao Cursor para ler o valor do seu ambiente. Defina-o no seu perfil de shell:

# ~/.zshrc ou ~/.bashrc
export MY_API_KEY="sk-your-actual-key-here"

dica

No Windows, defina variáveis de ambiente via PowerShell ou Propriedades do Sistema. No PowerShell:

[System.Environment]::SetEnvironmentVariable("MY_API_KEY", "sk-your-key", "User")

Depois reinicie o Cursor para que ele carregue a nova variável.

Método 2: Autenticação OAuth 2.0

OAuth é mais seguro porque evita chaves estáticas e suporta acesso com escopo definido e revogável. No entanto, é mais complexo de configurar. O servidor MCP inicia um fluxo OAuth que abre um navegador, pede que você faça login no provedor e retorna um token para o Cursor.

{
  "mcpServers": {
    "oauth-server": {
      "command": "npx",
      "args": ["-y", "@my-org/oauth-mcp-server"],
      "env": {
        "OAUTH_CLIENT_ID": "${CLIENT_ID}",
        "OAUTH_CLIENT_SECRET": "${CLIENT_SECRET}",
        "OAUTH_REDIRECT_URI": "http://localhost:3000/callback"
      }
    }
  }
}

O fluxo OAuth prossegue da seguinte forma:

1. O Cursor inicia o processo do servidor MCP
2. O servidor detecta nenhum token válido e inicia o OAuth
3. Seu navegador abre a página de login do provedor
4. Você autoriza o aplicativo
5. O provedor redireciona para localhost:3000/callback com um código de autorização
6. O servidor troca o código por tokens de acesso e atualização
7. Os tokens são armazenados localmente para uso futuro

Configurando o Live Meta Ads MCP

O Live Meta Ads MCP é uma das integrações MCP mais solicitadas para o Cursor. Ele se conecta à Meta Graph API para permitir que seu agente consulte o desempenho de anúncios, dados de campanha e insights de público. Usuários do forum relatam frequentemente que este MCP falha na autenticação. Veja como configurá-lo corretamente.

Passo 1: Criar um Aplicativo Meta

1. Vá para o portal Meta for Developers
2. Clique em Criar Aplicativo
3. Selecione Negócios como tipo de aplicativo
4. Adicione o produto Marketing API
5. Anote seu App ID e App Secret

Passo 2: Gerar um Token de Acesso de Longa Duração

Os tokens de acesso padrão do Meta expiram rapidamente. Para uso com MCP, você precisa de um token de longa duração:

# Trocar token de curta duração por token de longa duração
curl -X GET "https://graph.facebook.com/v19.0/oauth/access_token" \
  -d "grant_type=fb_exchange_token" \
  -d "client_id=$META_APP_ID" \
  -d "client_secret=$META_APP_SECRET" \
  -d "fb_exchange_token=$SHORT_LIVED_TOKEN"

A resposta inclui um token válido por aproximadamente 60 dias.

Passo 3: Configurar o Servidor MCP no Cursor

{
  "mcpServers": {
    "meta-ads": {
      "command": "npx",
      "args": ["-y", "@mcp/meta-ads-server"],
      "env": {
        "META_ACCESS_TOKEN": "${META_ACCESS_TOKEN}",
        "META_APP_ID": "${META_APP_ID}",
        "META_APP_SECRET": "${META_APP_SECRET}",
        "META_API_VERSION": "v19.0"
      }
    }
  }
}

Passo 4: Verificar a Conexão

Reinicie o Cursor, depois abra as Configurações do Cursor e navegue até a seção MCP. Você deve ver meta-ads listado com um indicador de status verde. Se mostrar um erro, consulte a seção de solução de problemas abaixo.

aviso

Os tokens de longa duração do Meta expiram após 60 dias. Defina um lembrete de calendário para atualizar o token antes de expirar. Se o token expirar, seu agente falhará silenciosamente ao buscar dados de anúncios, e o único sintoma pode ser resultados vazios ou erros de autenticação ocultos nos logs do MCP.

Falhas Comuns de Autenticação MCP

Usuários do fórum relatam vários problemas recorrents com a autenticação MCP no Cursor. Aqui estão as falhas mais comuns e suas soluções.

Falha 1: Token Não Encontrado no Ambiente

Sintoma: O servidor MCP inicia, mas retorna 401 Unauthorized em cada solicitação.

Causa: O Cursor não carregou a variável de ambiente. Isso geralmente acontece quando a variável foi definida em um perfil de shell diferente ou depois que o Cursor já estava em execução.

Solução:

# Verificar se a variável existe
echo $META_ACCESS_TOKEN

# Se vazia, adicionar ao perfil de shell e reiniciar o Cursor
echo 'export META_ACCESS_TOKEN="your-token"' >> ~/.zshrc
source ~/.zshrc

Depois feche completamente e reabra o Cursor.

Falha 2: Incompatibilidade de URI de Redirecionamento OAuth

Sintoma: O fluxo OAuth abre o navegador, mas após autorizar, você vê uma página de erro.

Causa: O URI de redirecionamento na configuração do seu aplicativo Meta não corresponde ao que o servidor MCP usa.

Solução: No seu painel do Meta for Developers, vá para Configurações do Aplicativo > Avançado > Configurações OAuth e adicione http://localhost:3000/callback (ou qualquer URI que seu servidor MCP use) aos URIs de redirecionamento permitidos.

Falha 3: Token Expirado ou Inválido

Sintoma: O servidor MCP funcionava anteriormente, mas de repente retorna erros de autenticação.

Causa: O token de longa duração do Meta expirou (limite de 60 dias) ou foi revogado.

Solução: Re-execute o fluxo de troca de token e atualize a variável de ambiente.

Falha 4: Escopos de Permissão Ausentes

Sintoma: A autenticação é bem-sucedida, mas o agente não consegue acessar certos dados (ex.: pode ler campanhas, mas não dados de público).

Causa: O aplicativo Meta não tem as permissões de API necessárias.

Solução: No painel do aplicativo Meta, vá para Funções > Revisão de Aplicativo > Permissões e Recursos e solicite os escopos adicionais:

Escopo	O Que Habilita
ads_read	Ler dados de desempenho de campanhas
ads_management	Criar e gerenciar campanhas
read_insights	Acessar análises detalhadas
business_management	Gerenciar configurações de negócios

Construindo Camadas de Aprovação Humana para Pagamentos por Agentes de IA

Um dos casos de uso mais poderosos e perigosos do MCP no Cursor é conectar um agente de IA a sistemas de pagamento. Um agente que pode fazer compras ou transferir fundos precisa de um portão de aprovação humana. Usuários do fórum construíram camadas de aprovação personalizadas para resolver isso.

Por Que as Camadas de Aprovação São Essenciais

Sem uma camada de aprovação, um agente de IA com acesso ao MCP de pagamento poderia:

• Cobrar valores inesperados no seu cartão
• Enviar pagamentos para destinatários errados
• Acionar transações financeiras irreversíveis
• Acumular custos através de microtransações repetidas

Arquitetura para uma Camada de Aprovação de Pagamento

O padrão recomendado insere um gateway de aprovação entre o Cursor e o servidor MCP de pagamento:

Cursor Agent  -->  Approval Gateway  -->  Payment MCP Server  -->  Stripe/PayPal API
                     ^
                     |
                  Human Review

Implementando o Gateway de Aprovação

Crie um servidor MCP leve que envolve o servidor de pagamento real e exige aprovação:

// approval-gateway.ts
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new Server({
  name: "payment-approval-gateway",
  version: "1.0.0",
}, {
  capabilities: { tools: {} },
});

// Pending approvals stored in memory (use a database for production)
const pendingApprovals = new Map();

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: "request_payment",
      description: "Request a payment. Requires human approval before execution.",
      inputSchema: {
        type: "object",
        properties: {
          amount: { type: "number", description: "Amount in cents" },
          currency: { type: "string", description: "ISO currency code" },
          recipient: { type: "string", description: "Recipient identifier" },
          reason: { type: "string", description: "Why this payment is needed" },
        },
        required: ["amount", "currency", "recipient", "reason"],
      },
    },
    {
      name: "approve_payment",
      description: "Approve a pending payment by ID",
      inputSchema: {
        type: "object",
        properties: {
          approval_id: { type: "string" },
        },
        required: ["approval_id"],
      },
    },
  ],
}));

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name === "request_payment") {
    const { amount, currency, recipient, reason } = request.params.arguments;
    const approvalId = `appr_${Date.now()}`;
    
    pendingApprovals.set(approvalId, {
      amount,
      currency,
      recipient,
      reason,
      status: "pending",
      createdAt: new Date(),
    });

    return {
      content: [{
        type: "text",
        text: `Payment request created. Approval ID: ${approvalId}\n\n` +
              `Amount: ${amount/100} ${currency.toUpperCase()}\n` +
              `Recipient: ${recipient}\n` +
              `Reason: ${reason}\n\n` +
              `To execute this payment, a human must approve it using the approve_payment tool with approval_id: ${approvalId}`,
      }],
    };
  }

  if (request.params.name === "approve_payment") {
    const { approval_id } = request.params.arguments;
    const approval = pendingApprovals.get(approval_id);
    
    if (!approval) {
      return { content: [{ type: "text", text: "Error: Approval ID not found." }] };
    }

    // Forward to actual payment server here
    approval.status = "approved";
    return {
      content: [{
        type: "text",
        text: `Payment approved and forwarded to payment processor.\nAmount: ${approval.amount/100} ${approval.currency.toUpperCase()}`,
      }],
    };
  }
});

const transport = new StdioServerTransport();
await server.connect(transport);

Configurando o Gateway de Aprovação no Cursor

{
  "mcpServers": {
    "payments": {
      "command": "npx",
      "args": ["tsx", "./mcp-servers/approval-gateway.ts"],
      "env": {
        "STRIPE_SECRET_KEY": "${STRIPE_SECRET_KEY}",
        "APPROVAL_TIMEOUT_MS": "300000"
      }
    }
  }
}

dica

Defina um tempo limite de aprovação para que, se um humano não aprovar dentro de um prazo razoável, a solicitação expire automaticamente. Cinco minutos é um bom padrão. Isso evita que solicitações de pagamento desatualizadas se acumulem e sejam aprovadas fora de contexto.

aviso

O padrão de gateway de aprovação só funciona se o agente de IA não puder contorná-lo. Certifique-se de que o servidor MCP de pagamento direto NÃO esteja configurado no Cursor. Apenas o gateway deve ser exposto. Se ambos estiverem configurados, o agente poderia teoricamente chamar o servidor direto e pular a aprovação.

Configuração Segura do Servidor MCP

Além da autenticação, a forma como você configura os servidores MCP no Cursor tem implicações de segurança. Siga estas melhores práticas.

Usar Configuração de Escopo de Projeto vs Global

O Cursor suporta tanto configurações globais (~/.cursor/mcp.json) quanto de escopo de projeto (.cursor/mcp.json).

Escopo	Arquivo	Caso de Uso
Global	~/.cursor/mcp.json	Servidores pessoais usados em todos os projetos
Projeto	.cursor/mcp.json	Servidores específicos de um projeto

dica

Use a configuração de escopo de projeto para servidores sensíveis. Isso mantém as credenciais fora da sua configuração global e facilita a auditoria de quais projetos têm acesso a quais serviços. Adicione .cursor/mcp.json ao .gitignore se contiver segredos, ou use exclusivamente referências de variáveis de ambiente.

Restringindo o Acesso a Ferramentas MCP

Você pode limitar quais ferramentas um servidor MCP expõe ao Cursor usando o campo disabledTools:

{
  "mcpServers": {
    "meta-ads": {
      "command": "npx",
      "args": ["-y", "@mcp/meta-ads-server"],
      "env": {
        "META_ACCESS_TOKEN": "${META_ACCESS_TOKEN}"
      },
      "disabledTools": ["delete_campaign", "pause_all_campaigns"]
    }
  }
}

Isso impede que o agente use ferramentas destrutivas, mesmo que o servidor MCP as exponha.

Segurança de Transporte

Para servidores MCP remotos (baseados em SSE), sempre use HTTPS:

{
  "mcpServers": {
    "remote-server": {
      "url": "https://mcp.example.com/sse",
      "headers": {
        "Authorization": "Bearer ${REMOTE_MCP_TOKEN}"
      }
    }
  }
}

aviso

Nunca use HTTP (não criptografado) para servidores MCP remotos. A conexão transporta seus tokens de autenticação, e um invasor na rede pode interceptá-los. Sempre use HTTPS e verifique o certificado TLS do servidor.

Padrões de Atualização de Token

Muitos provedores OAuth emitem tokens de acesso de curta duração (1 hora) junto com tokens de atualização de longa duração. Seu servidor MCP deve lidar com a atualização automaticamente para evitar interrupções.

Padrão 1: Atualização do Lado do Servidor (Recomendado)

O servidor MCP lida com a atualização do token internamente. Quando um token de acesso expira, o servidor usa o token de atualização para obter um novo sem intervenção do usuário.

// Inside your MCP server
let accessToken = await loadToken();
let tokenExpiry = Date.now() + 3600 * 1000; // 1 hour

async function ensureValidToken() {
  if (Date.now() >= tokenExpiry - 60000) { // refresh 1 min before expiry
    const response = await fetch("https://oauth.provider.com/token", {
      method: "POST",
      headers: { "Content-Type": "application/x-www-form-urlencoded" },
      body: new URLSearchParams({
        grant_type: "refresh_token",
        refresh_token: process.env.REFRESH_TOKEN,
        client_id: process.env.CLIENT_ID,
        client_secret: process.env.CLIENT_SECRET,
      }),
    });
    const data = await response.json();
    accessToken = data.access_token;
    tokenExpiry = Date.now() + data.expires_in * 1000;
    await saveToken(accessToken, tokenExpiry);
  }
  return accessToken;
}

Padrão 2: Recarga de Ambiente no Lado do Cursor

Se seu servidor MCP não suporta atualização automática, você pode recarregar o ambiente no Cursor:

1. Atualizar o token externamente
2. Atualizar a variável de ambiente
3. Reiniciar o servidor MCP no Cursor via Configurações

Padrão 3: Script Wrapper

Crie um script wrapper que atualiza o token antes de iniciar o servidor MCP:

#!/bin/bash
# refresh-and-start.sh

# Refresh the Meta token
NEW_TOKEN=$(node /path/to/refresh-token.js)
export META_ACCESS_TOKEN=$NEW_TOKEN

# Start the MCP server
exec npx -y @mcp/meta-ads-server

Configure o Cursor para usar o wrapper:

{
  "mcpServers": {
    "meta-ads": {
      "command": "bash",
      "args": ["/path/to/refresh-and-start.sh"]
    }
  }
}

dica

Para o Live Meta Ads MCP especificamente, a expiração do token de 60 dias é a causa mais comum de relatórios de "deixou de funcionar de repente". Automatize o processo de atualização usando um cron job ou tarefa agendada. No macOS/Linux, use cron. No Windows, use o Agendador de Tarefas.

Solução de Problemas de Autenticação MCP

Verificar Logs do Servidor MCP

O Cursor nem sempre exibe erros do servidor MCP na interface. Para ver o que está acontecendo:

1. Abra a Paleta de Comandos (Cmd/Ctrl + Shift + P)
2. Pesquise por Output: Show Output Channels
3. Selecione MCP no menu suspenso
4. Revise os logs em busca de erros de autenticação

Testar Autenticação Independentemente

Antes de depurar através do Cursor, teste o servidor MCP diretamente:

# Run the server manually
npx -y @mcp/meta-ads-server

# In another terminal, send a test request
echo '{"jsonrpc":"2.0","method":"tools/list","id":1}' | npx -y @mcp/meta-ads-server

Se o servidor falhar na autenticação fora do Cursor, o problema está nas suas credenciais, não no Cursor.

Verificar se as Variáveis de Ambiente Foram Carregadas

# Create a test script
cat > test-env.js << 'EOF'
console.log("META_ACCESS_TOKEN:", process.env.META_ACCESS_TOKEN ? "SET" : "NOT SET");
console.log("META_APP_ID:", process.env.META_APP_ID ? "SET" : "NOT SET");
console.log("META_APP_SECRET:", process.env.META_APP_SECRET ? "SET" : "NOT SET");
EOF

# Run with the MCP server's environment
node test-env.js

Se as variáveis aparecerem como NOT SET, o problema está no seu perfil de shell ou na forma como o Cursor carrega o ambiente.

Lista de Verificação de Segurança

Antes de implantar servidores MCP em um contexto de produção, passe por esta lista de verificação:

• Chaves de API armazenadas em variáveis de ambiente, nunca em arquivos de configuração
• .cursor/mcp.json adicionado ao .gitignore se contiver segredos
• URIs de redirecionamento OAuth restritos a localhost
• Ferramentas destrutivas desativadas via disabledTools
• Servidores MCP de pagamento envolvidos com gateways de aprovação
• Atualização de token automatizada para evitar falhas silenciosas
• Servidores MCP remotos usam apenas HTTPS
• Logs do servidor MCP monitorados quanto a falhas de autenticação inesperadas
• Tokens de acesso com escopo limitado às permissões mínimas necessárias
• Servidores MCP não utilizados removidos da configuração

Resumo

A autenticação MCP no Cursor abrange um espectro que vai de simples variáveis de ambiente de chave de API a fluxos OAuth complexos com atualização automática de token. O Live Meta Ads MCP é um ponto problemático comum devido à expiração do token em 60 dias e aos requisitos de escopo de permissão. Seguindo os padrões deste guia, você pode construir integrações MCP seguras e confiáveis que protegem ações sensíveis atrás de camadas de aprovação humana e mantêm suas credenciais seguras.