Pular para o conteúdo principal

Documentation Index

Fetch the complete documentation index at: https://docs.devin.ai/llms.txt

Use this file to discover all available pages before exploring further.

MCP (Model Context Protocol) é um protocolo que permite que LLMs acessem ferramentas e serviços personalizados. Um cliente MCP (neste caso, o Cascade) pode fazer requisições a servidores MCP para acessar as ferramentas que eles oferecem. O Cascade agora se integra nativamente ao MCP, permitindo que você use sua própria seleção de servidores MCP no Cascade. Consulte a documentação oficial do MCP para mais informações.
Os usuários Enterprise devem ativar isso manualmente nas configurações

​
Adicionando um novo MCP

Novos MCPs podem ser adicionados pelo MCP Marketplace, que você acessa clicando no ícone MCPs no menu superior direito do painel Cascade, ou na seção Windsurf Settings > Cascade > MCP Servers. Se você não encontrar o MCP desejado, poderá adicioná-lo manualmente editando diretamente o arquivo mcp_config.json. Os MCPs oficiais aparecerão com uma marca de verificação azul, indicando que foram criados pela empresa responsável pelo serviço. Ao clicar em um MCP, basta clicar em Install para disponibilizar o servidor e suas ferramentas ao Cascade. O Devin Desktop oferece suporte à instalação de MCP em um clique por meio de deeplinks. Você pode usar esses links para abrir a página de registro de MCP diretamente no Devin Desktop, o que é útil para compartilhar recomendações de servidores MCP ou incorporar botões de instalação na documentação. O formato do deeplink é: 
windsurf://windsurf-mcp-registry?serverName=<server-name>
  • Com serverName: Abre a página de registro do MCP para o servidor especificado, onde o usuário pode analisá-lo e instalá-lo.
  • Sem serverName: Abre a página do MCP Marketplace.
Por exemplo, windsurf://windsurf-mcp-registry?serverName=github-mcp-server abrirá a página de registro do servidor MCP do GitHub no Devin Desktop.
Deeplinks de instalação com um clique exigem que a equipe do usuário tenha acesso ao MCP ativado. Se o acesso ao MCP estiver desativado por um administrador, o deeplink não abrirá a página de registro.
O Devin Desktop oferece suporte a três tipos de transporte para servidores MCP: stdio, Streamable HTTP e SSE. O Devin Desktop também oferece suporte a OAuth para cada tipo de transporte. Para servidores http, a URL deve corresponder à do endpoint e seguir um formato como https://<your-server-url>/mcp.

​
Configurando ferramentas MCP

Cada MCP tem acesso a um determinado número de ferramentas. O Cascade tem um limite de 100 ferramentas no total às quais pode ter acesso a qualquer momento. Na página de Configurações de cada MCP, você pode usar o controle para ativar as ferramentas desejadas. Para abrir as Configurações de um MCP, clique no ícone MCPs no menu superior direito do painel do Cascade e clique no MCP desejado.

​
mcp_config.json

O arquivo ~/.codeium/windsurf/mcp_config.json é um arquivo JSON que contém uma lista de servidores aos quais o Cascade pode se conectar. Veja um exemplo de configuração que define um único servidor para o GitHub: 
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_PERSONAL_ACCESS_TOKEN>"
      }
    }
  }
}
Certifique-se de fornecer os argumentos obrigatórios e as variáveis de ambiente necessárias para os servidores que você quer usar. Consulte o repositório oficial de referência de servidores MCP ou o OpenTools para ver alguns exemplos de servidores. A seguir, estão alguns exemplos de configuração de servidores MCP usados com frequência. Eles podem ser adicionados ao arquivo mcp_config.json.
O servidor MCP do GitHub fornece ferramentas para gerenciamento de repositórios, operações de arquivo, acompanhamento de problemas e gerenciamento de pull requests.Como usar com npx:
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_PERSONAL_ACCESS_TOKEN>"
      }
    }
  }
}
Como usar com 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_PERSONAL_ACCESS_TOKEN>"
      }
    }
  }
}
Para criar um personal access token, acesse GitHub Settings > Developer settings > Personal access tokens.
O servidor MCP do Slack permite gerenciar canais, enviar mensagens e interagir com o workspace.
{
  "mcpServers": {
    "slack": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-slack"],
      "env": {
        "SLACK_BOT_TOKEN": "<YOUR_SLACK_BOT_TOKEN>",
        "SLACK_TEAM_ID": "<YOUR_SLACK_TEAM_ID>"
      }
    }
  }
}
Para configurar um token de bot do Slack:
  1. Crie um Slack App em api.slack.com/apps
  2. Adicione os escopos OAuth necessários (por exemplo, channels:read, chat:write, users:read)
  3. Instale o app no seu workspace e copie o Bot User OAuth Token
O servidor MCP do PostgreSQL fornece acesso somente leitura a bancos de dados PostgreSQL, incluindo inspeção de esquema e execução de consultas.
{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "POSTGRES_CONNECTION_STRING": "postgresql://user:password@localhost:5432/database"
      }
    }
  }
}
O servidor PostgreSQL fornece acesso somente leitura por padrão, por segurança. Verifique se sua connection string usa credenciais apropriadas com permissões limitadas.
O servidor MCP do Filesystem fornece acesso seguro a arquivos e diretórios locais com controles de acesso configuráveis.
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y", "@modelcontextprotocol/server-filesystem",
        "/path/to/allowed/directory"
      ]
    }
  }
}
Você pode especificar vários diretórios permitidos adicionando argumentos de caminho extras. Somente os arquivos dentro desses diretórios poderão ser acessados.
O servidor MCP do Memory fornece um sistema de memória persistente usando um grafo de conhecimento, permitindo que o Cascade se lembre de informações entre sessões.
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    }
  }
}
O servidor de memória armazena dados localmente e os preserva entre sessões, o que o torna útil para manter o contexto sobre projetos, preferências e informações aprendidas.

​
MCPs HTTP remotos

É importante observar que, para MCPs HTTP remotos, a configuração é um pouco diferente e exige um campo serverUrl ou url. Aqui está um exemplo de configuração para um servidor HTTP: 
{
  "mcpServers": {
    "remote-http-mcp": {
      "serverUrl": "<your-server-url>/mcp",
      "headers": {
        "API_KEY": "value"
      }
    }
  }
}

​
Interpolação na configuração

O arquivo ~/.codeium/windsurf/mcp_config.json oferece suporte à interpolação de variáveis nos seguintes campos: command, args, env, serverUrl, url e headers. Isso permite evitar incluir segredos diretamente no arquivo de configuração. Há suporte a dois padrões de interpolação:
  • ${env:VAR_NAME} — substituído pelo valor da variável de ambiente VAR_NAME. Se a variável não estiver definida, será resolvido como uma string vazia.
  • ${file:/path/to/file} — substituído pelo conteúdo do arquivo no caminho especificado, com os espaços em branco no início e no fim removidos. Há suporte a caminhos com til (~) (por exemplo, ~/secrets/key.txt). Se não for possível ler o arquivo, o padrão permanecerá inalterado.
Aqui está um exemplo usando uma variável de ambiente em headers: 
{
  "mcpServers": {
    "remote-http-mcp": {
      "serverUrl": "<your-server-url>/mcp",
      "headers": {
        "API_KEY": "Bearer ${env:AUTH_TOKEN}"
      }
    }
  }
}
Aqui está um exemplo de como ler uma Chave de API de um arquivo: 
{
  "mcpServers": {
    "my-server": {
      "command": "node",
      "args": ["server.js"],
      "env": {
        "API_KEY": "${file:~/.secrets/api_key.txt}"
      }
    }
  }
}

​
Controles administrativos (Teams & Enterprises)

Os administradores da equipe podem ativar ou desativar o acesso ao MCP para a equipe, bem como adicionar à lista de permissões os servidores MCP aprovados para uso da equipe:

​
Registro de MCP

Equipes Enterprise podem configurar registros de MCP personalizados para substituir o marketplace padrão de MCP do Devin Desktop. As equipes podem vincular as URLs dos próprios registros para controlar quais MCPs ficam disponíveis para seus usuários.
Os registros são a abordagem preferida para gerenciar o acesso a MCPs, embora listas de permissões também funcionem.

​
Configurando registros personalizados

  1. Acesse as configurações da sua equipe
  2. Encontre a configuração URLs de registro de MCP
  3. Adicione uma ou mais URLs de registro
Quando várias URLs de registro são configuradas, o Devin Desktop usa a união de todos os registros — os usuários verão MCPs de todas as fontes configuradas, combinadas em um só lugar. O marketplace de MCP da equipe passará a buscar nesses registros internos em vez de usar o registro padrão do Devin Desktop.
Os registros personalizados devem seguir o esquema oficial de registro de MCP. Isso garante compatibilidade e definições padronizadas de servidor.

​
Lista de permissões de MCP

Configurações de MCP da equipe

Configurações de MCP para a sua equipe.
O link acima só funcionará se você tiver privilégios de administrador da sua equipe.
Por padrão, os usuários de uma equipe poderão configurar seus próprios servidores MCP. No entanto, depois que você incluir um único servidor MCP na lista de permissões, todos os servidores fora da lista de permissões serão bloqueados para a sua equipe.
O ID do servidor na lista de permissões deve corresponder, com distinção entre maiúsculas e minúsculas, ao nome da chave usado no mcp_config.json do usuário.

​
Como funciona a correspondência de servidores

Quando você coloca um servidor MCP na lista de permissões, o sistema usa correspondência por padrão regex com as seguintes regras:
  • Correspondência da string completa: todos os padrões são ancorados automaticamente (envolvidos por ^(?:pattern)$) para evitar correspondências parciais
  • Campo Command: deve corresponder exatamente ou de acordo com o seu padrão regex
  • Array Arguments: cada argumento é comparado individualmente com seu padrão correspondente
  • Comprimento do array: o número de argumentos deve corresponder exatamente entre a lista de permissões e a configuração do usuário
  • Caracteres especiais: caracteres como $, ., [, ], (, ) têm significado especial em regex e devem ser escapados com \\ se você quiser uma correspondência literal

​
Opções de configuração

Configuração da lista de permissões de admins:
  • ID do servidor: github-mcp-server
  • Configuração do servidor (JSON): (deixe em branco)
{}
Configuração de usuário correspondente (mcp_config.json):
{
  "mcpServers": {
    "github-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "GITHUB_PERSONAL_ACCESS_TOKEN",
        "ghcr.io/github/github-mcp-server"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
      }
    }
  }
}
Isso permite que os usuários instalem o servidor MCP do GitHub com qualquer configuração válida, desde que o ID do servidor corresponda à entrada na Plugin Store.
Configuração da lista de permissões de admins:
  • ID do servidor: github-mcp-server
  • Configuração do servidor (JSON):
{
  "command": "docker",
  "args": [
    "run",
    "-i",
    "--rm",
    "-e",
    "GITHUB_PERSONAL_ACCESS_TOKEN",
    "ghcr.io/github/github-mcp-server"
  ],
  "env": {
    "GITHUB_PERSONAL_ACCESS_TOKEN": ""
  }
}
Configuração de usuário correspondente (mcp_config.json):
{
  "mcpServers": {
    "github-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "GITHUB_PERSONAL_ACCESS_TOKEN",
        "ghcr.io/github/github-mcp-server"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
      }
    }
  }
}
Os usuários devem usar exatamente esta configuração — qualquer diferença em command ou args será bloqueada. A seção env pode ter valores diferentes.
Configuração da lista de permissões de admins:
  • ID do servidor: python-mcp-server
  • Configuração do servidor (JSON):
{
  "command": "python3",
  "args": ["/.*\\.py", "--port", "[0-9]+"]
}
Configuração de usuário correspondente (mcp_config.json):
{
  "mcpServers": {
    "python-mcp-server": {
      "command": "python3",
      "args": ["/home/user/my_server.py", "--port", "8080"],
      "env": {
        "PYTHONPATH": "/home/user/mcp"
      }
    }
  }
}
Este exemplo oferece flexibilidade aos usuários, sem comprometer a segurança:
  • A regex /.*\\.py corresponde a qualquer caminho de arquivo Python, como /home/user/my_server.py
  • A regex [0-9]+ corresponde a qualquer porta numérica, como 8080 ou 3000
  • Os usuários podem personalizar caminhos de arquivo e portas, enquanto os admins garantem que apenas scripts Python sejam executados

​
Padrões comuns de regex

PadrãoCorrespondênciaExemplo
.*Qualquer string/home/user/script.py
[0-9]+Qualquer número8080, 3000
[a-zA-Z0-9_]+Alfanumérico + sublinhadoapi_key_123
\\$HOME$HOME literal$HOME (não expandido)
\\.py.py literalscript.py
\\[cli\\][cli] literalmcp[cli]

​
Notas

​
Diretrizes de configuração do Admin

  • Variáveis de ambiente: A seção env não é verificada com regex e pode ser configurada livremente pelos usuários
  • Ferramentas desativadas: O array disabledTools é tratado separadamente e não faz parte da correspondência da lista de permissões
  • Diferenciação entre maiúsculas e minúsculas: Todas as correspondências diferenciam maiúsculas de minúsculas
  • Tratamento de erros: Padrões de regex inválidos serão registrados em log e resultarão na negação de acesso
  • Testes: Teste seus padrões de regex com cuidado — padrões excessivamente restritivos podem bloquear casos de uso legítimos

​
Solução de problemas

Se os usuários relatarem que seus servidores MCP não estão funcionando após a inclusão na lista de permissões:
  1. Verifique a Correspondência Exata: Certifique-se de que o padrão da lista de permissões corresponda exatamente à configuração do usuário
  2. Verifique o Escape de Regex: Caracteres especiais podem precisar de escape (ex.: \. para pontos literais)
  3. Revise os Logs: Padrões de regex inválidos são registrados nos logs com avisos
  4. Teste os Padrões: Use um testador de regex para verificar se seus padrões funcionam como esperado
Lembre-se: ao incluir qualquer servidor na lista de permissões, todos os outros servidores são automaticamente bloqueados para os membros da sua equipe.

​
Informações gerais

  • Como chamadas de ferramentas do MCP podem invocar código escrito por implementadores de servidores diversos, não nos responsabilizamos por falhas nessas chamadas de ferramentas do MCP. Reforçando:
  • No momento, oferecemos suporte às ferramentas, aos recursos e aos prompts de um servidor MCP.