> ## 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.

# Model Context Protocol (MCP)

> Integre servidores MCP ao Cascade para acessar ferramentas personalizadas, como GitHub, bancos de dados e APIs. Configure os transportes stdio, HTTP e SSE com controles de administrador para Teams.

**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](https://modelcontextprotocol.io/) para mais informações.

<Note>Os usuários Enterprise devem ativar isso manualmente nas configurações</Note>

<div id="adding-a-new-mcp">
  ## Adicionando um novo MCP
</div>

Novos MCPs podem ser adicionados pelo MCP Marketplace, que você acessa
clicando no ícone `MCPs` no menu superior direito do painel do Cascade, ou na
seção `Devin 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.

<div id="one-click-install-via-deeplink">
  ### Instalação em um clique via deeplink
</div>

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.

<Note>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.</Note>

O Devin Desktop oferece suporte a três [tipos de transporte](https://modelcontextprotocol.io/docs/concepts/transports) 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`.

<Frame>
  <img src="https://mintcdn.com/cognitionai/hxeMffzXgF_RWx-U/desktop/assets/windsurf/cascade/mcp/mcp-plugin-store.png?fit=max&auto=format&n=hxeMffzXgF_RWx-U&q=85&s=cedf7260fa823c72486f1c35faa542f0" width="955" height="774" data-path="desktop/assets/windsurf/cascade/mcp/mcp-plugin-store.png" />
</Frame>

<div id="configuring-mcp-tools">
  ## Configurando ferramentas MCP
</div>

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.

<Frame>
  <img src="https://mintcdn.com/cognitionai/hxeMffzXgF_RWx-U/desktop/assets/windsurf/cascade/mcp/mcp-manage-plugin-tools.png?fit=max&auto=format&n=hxeMffzXgF_RWx-U&q=85&s=81513e7073b00eb6d9c53017789b08c1" width="893" height="639" data-path="desktop/assets/windsurf/cascade/mcp/mcp-manage-plugin-tools.png" />
</Frame>

<div id="mcp_configjson">
  ## mcp\_config.json
</div>

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:

```json theme={null}
{
  "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](https://github.com/modelcontextprotocol/servers) ou o [OpenTools](https://opentools.com/) para ver alguns exemplos de servidores.

<div id="popular-mcp-server-examples">
  ### Exemplos populares de servidores MCP
</div>

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`.

<AccordionGroup>
  <Accordion title="GitHub" description="Gerenciamento de repositórios, operações de arquivo e integração com a API do GitHub.">
    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:**

    ```json theme={null}
    {
      "mcpServers": {
        "github": {
          "command": "npx",
          "args": ["-y", "@modelcontextprotocol/server-github"],
          "env": {
            "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_PERSONAL_ACCESS_TOKEN>"
          }
        }
      }
    }
    ```

    **Como usar com Docker:**

    ```json theme={null}
    {
      "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](https://github.com/settings/tokens).
  </Accordion>

  <Accordion title="Slack" description="Gerenciamento de canais e recursos de mensagens para workspaces do Slack.">
    O servidor MCP do Slack permite gerenciar canais, enviar mensagens e interagir com o workspace.

    ```json theme={null}
    {
      "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](https://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
  </Accordion>

  <Accordion title="PostgreSQL" description="Acesso somente leitura ao banco de dados com recursos de inspeção de esquema.">
    O servidor MCP do PostgreSQL fornece acesso somente leitura a bancos de dados PostgreSQL, incluindo inspeção de esquema e execução de consultas.

    ```json theme={null}
    {
      "mcpServers": {
        "postgres": {
          "command": "npx",
          "args": ["-y", "@modelcontextprotocol/server-postgres"],
          "env": {
            "POSTGRES_CONNECTION_STRING": "postgresql://user:password@localhost:5432/database"
          }
        }
      }
    }
    ```

    <Warning>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.</Warning>
  </Accordion>

  <Accordion title="Filesystem" description="Operações seguras com arquivos e controles de acesso configuráveis.">
    O servidor MCP do Filesystem fornece acesso seguro a arquivos e diretórios locais com controles de acesso configuráveis.

    ```json theme={null}
    {
      "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.
  </Accordion>

  <Accordion title="Brave Search" description="Pesquisa na web e local usando a Search API do Brave.">
    O servidor MCP do Brave Search ativa recursos de pesquisa na web usando a Search API do Brave.

    ```json theme={null}
    {
      "mcpServers": {
        "brave-search": {
          "command": "npx",
          "args": ["-y", "@anthropic/mcp-server-brave-search"],
          "env": {
            "BRAVE_API_KEY": "<YOUR_BRAVE_API_KEY>"
          }
        }
      }
    }
    ```

    Para obter uma Chave de API do Brave, cadastre-se em [brave.com/search/api](https://brave.com/search/api/).
  </Accordion>

  <Accordion title="Memory" description="Sistema de memória persistente baseado em grafo de conhecimento.">
    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.

    ```json theme={null}
    {
      "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.
  </Accordion>
</AccordionGroup>

<div id="remote-http-mcps">
  ### MCPs HTTP remotos
</div>

É 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:

```json theme={null}
{
  "mcpServers": {
    "remote-http-mcp": {
      "serverUrl": "<your-server-url>/mcp",
      "headers": {
        "API_KEY": "value"
      }
    }
  }
}
```

<div id="config-interpolation">
  ### Interpolação na configuração
</div>

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`:

```json theme={null}
{
  "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:

```json theme={null}
{
  "mcpServers": {
    "my-server": {
      "command": "node",
      "args": ["server.js"],
      "env": {
        "API_KEY": "${file:~/.secrets/api_key.txt}"
      }
    }
  }
}
```

<div id="admin-controls-teams-enterprises">
  ## Controles administrativos (Teams & Enterprises)
</div>

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:

<div id="mcp-registry">
  ### Registro de MCP
</div>

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.

<Note>Os registros são a abordagem preferida para gerenciar o acesso a MCPs, embora listas de permissões também funcionem.</Note>

<div id="configuring-custom-registries">
  #### Configurando registros personalizados
</div>

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.

<Note>Os registros personalizados devem seguir o [esquema oficial de registro de MCP](https://modelcontextprotocol.io/). Isso garante compatibilidade e definições padronizadas de servidor.</Note>

<div id="mcp-whitelist">
  ### Lista de permissões de MCP
</div>

<Card title="Configurações de MCP da equipe" horizontal={true} icon="hammer" href="https://windsurf.com/team/settings">
  Configurações de MCP para a sua equipe.
</Card>

<Warning>O link acima só funcionará se você tiver privilégios de administrador da sua equipe.</Warning>

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.

<Note>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.</Note>

<div id="how-server-matching-works">
  ### Como funciona a correspondência de servidores
</div>

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

<div id="configuration-options">
  ### Opções de configuração
</div>

<AccordionGroup>
  <Accordion title="Opção 1: Padrão da Plugin Store (recomendado)" description="Deixe o campo Configuração do servidor (JSON) vazio para permitir a configuração padrão da Devin Desktop MCP Plugin Store.">
    **Configuração da lista de permissões de admins:**

    * **ID do servidor**: `github-mcp-server`
    * **Configuração do servidor (JSON)**: *(deixe em branco)*

    ```json theme={null}
    {}
    ```

    **Configuração de usuário correspondente (`mcp_config.json`):**

    ```json theme={null}
    {
      "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.
  </Accordion>

  <Accordion title="Opção 2: Configuração de correspondência exata" description="Forneça a configuração exata que os usuários devem usar. Eles devem corresponder exatamente a essa configuração.">
    **Configuração da lista de permissões de admins:**

    * **ID do servidor**: `github-mcp-server`
    * **Configuração do servidor (JSON)**:

    ```json theme={null}
    {
      "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`):**

    ```json theme={null}
    {
      "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.
  </Accordion>

  <Accordion title="Opção 3: Padrões regex flexíveis" description="Use padrões regex para permitir variações nas configurações dos usuários, mantendo os controles de segurança.">
    **Configuração da lista de permissões de admins:**

    * **ID do servidor**: `python-mcp-server`
    * **Configuração do servidor (JSON)**:

    ```json theme={null}
    {
      "command": "python3",
      "args": ["/.*\\.py", "--port", "[0-9]+"]
    }
    ```

    **Configuração de usuário correspondente (`mcp_config.json`):**

    ```json theme={null}
    {
      "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
  </Accordion>
</AccordionGroup>

<div id="common-regex-patterns">
  ### Padrões comuns de regex
</div>

| Padrão          | Correspondência           | Exemplo                 |
| --------------- | ------------------------- | ----------------------- |
| `.*`            | Qualquer string           | `/home/user/script.py`  |
| `[0-9]+`        | Qualquer número           | `8080`, `3000`          |
| `[a-zA-Z0-9_]+` | Alfanumérico + sublinhado | `api_key_123`           |
| `\\$HOME`       | `$HOME` literal           | `$HOME` (não expandido) |
| `\\.py`         | `.py` literal             | `script.py`             |
| `\\[cli\\]`     | `[cli]` literal           | `mcp[cli]`              |

<div id="notes">
  ## Notas
</div>

<div id="admin-configuration-guidelines">
  ### Diretrizes de configuração do Admin
</div>

* **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

<div id="troubleshooting">
  ### Solução de problemas
</div>

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.

<div id="general-information">
  ### Informações gerais
</div>

* 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](https://modelcontextprotocol.io/docs/concepts/tools), aos [recursos](https://modelcontextprotocol.io/docs/concepts/resources) e aos [prompts](https://modelcontextprotocol.io/docs/concepts/prompts) de um servidor MCP.