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

# Marketplace de MCP (Model Context Protocol)

MCP é um protocolo aberto que permite que Devin use centenas de ferramentas externas e fontes de dados. Devin oferece suporte a 3 métodos de transporte (stdio, SSE e HTTP).

<div id="why-use-mcp">
  ## Por que usar MCP?
</div>

Com MCP, o Devin pode ajudar você a:

* vasculhar logs do Sentry, Datadog e Vercel
* [usar o Devin como analista de dados](https://devin.ai/ai-data-analyst-1) no Slack com MCPs de banco de dados
* investigar problemas no SonarQube, CircleCI e Jam
* criar em massa tickets no Linear, documentos no Notion, Google Docs (via Zapier) e mais
* trazer contexto de e interagir com Airtable, Stripe e Hubspot
* muito mais!

<div id="get-started-with-mcps">
  ## Comece a usar MCPs
</div>

Acesse [Configurações > Conexões > servidores MCP](https://app.devin.ai/settings/connections?tab=mcps) para navegar e ativar MCPs.

<CardGroup cols={2}>
  <Card title="Use o Devin para análise de dados no Slack conectando-o a MCPs de banco de dados" icon="chart-simple" href="https://devin.ai/ai-data-analyst-1/">
    Confira nosso guia passo a passo!
  </Card>

  <Card title="Navegue por casos de uso de MCPs" icon="grid-2" href="/pt-BR/use-cases/gallery/index">
    Explore exemplos práticos do Devin com MCPs como Datadog, Sentry, Linear, Figma e mais.
  </Card>
</CardGroup>

<div id="configuration-tips">
  ## Dicas de configuração
</div>

<Note>
  Para MCPs que fazem autenticação via OAuth, o Devin solicitará que você acesse uma URL para conectar sua conta. Como a conexão é compartilhada depende da configuração de **Access** do servidor:

  * **Organization**: todos os membros compartilham uma única conexão autenticada. **Recomendamos fortemente o uso de uma conta de serviço**, e não da sua conta pessoal, já que as sessões de todos os membros a utilizarão.
  * **Personal**: cada membro da organização autentica individualmente com a própria conta, então não há problema em conectar sua conta pessoal. Observe que outros usuários ainda podem interagir com as suas sessões, portanto isso não deve ser tratado como um limite de segurança.
</Note>

<Note>
  Não encontra o MCP que está procurando? Os admins da organização podem adicionar qualquer servidor MCP usando o botão **Adicionar um MCP personalizado**. Se você não tiver permissões de admin, use **Sugerir integração MCP** para solicitar uma.

  Está com problemas? Fale conosco pela nossa [página de suporte](https://app.devin.ai/settings/support) ou pelo e-mail [support@cognition.ai](mailto:support@cognition.ai).
</Note>

<div id="setting-up-a-custom-mcp-server">
  ## Configurando um servidor MCP personalizado
</div>

Se o MCP que você precisa não estiver no marketplace, admins da organização podem adicionar qualquer servidor MCP usando o botão **Adicionar um MCP personalizado**. Devin oferece suporte a três tipos de transporte para servidores personalizados:

<Note>
  Adicionar servidores MCP personalizados exige a permissão **Gerenciar servidores MCP**. Se você não vir o botão **Adicionar um MCP personalizado**, entre em contato com um admin da organização ou use a opção **Sugerir integração MCP** para solicitar um novo servidor.
</Note>

| Transporte | Melhor para                                                           | Campos obrigatórios                        |
| ---------- | --------------------------------------------------------------------- | ------------------------------------------ |
| **STDIO**  | Servidores locais baseados em CLI (por exemplo, `npx`, `uvx`, Docker) | Comando, argumentos, variáveis de ambiente |
| **SSE**    | Servidores remotos usando Server-Sent Events                          | URL do servidor, cabeçalhos                |
| **HTTP**   | Servidores remotos usando Streamable HTTP                             | URL do servidor, cabeçalhos                |

<div id="step-by-step-adding-a-custom-mcp-server">
  ### Passo a passo: adicionando um servidor MCP personalizado
</div>

1. Acesse [Configurações > Conexões > servidores MCP](https://app.devin.ai/settings/connections?tab=mcps).
2. Clique em **Adicionar um MCP personalizado** no topo da página.
3. Preencha os detalhes do servidor:
   * **Server Name**: Um nome descritivo para o servidor (por exemplo, "Internal API Gateway").
   * **Icon** (opcional): Um emoji ou URL para usar como ícone do servidor.
   * **Short Description**: Um breve resumo do que o servidor faz.
4. Selecione o **transport type** (STDIO, SSE ou HTTP).
5. Preencha os campos de configuração específicos do transporte (veja o [Formato de configuração](#configuration-format) abaixo).
6. Clique em **Save** para criar o servidor.
7. Clique em **Test listing tools** para verificar a conexão. Devin criará um ambiente de teste isolado, vai se conectar ao seu servidor e tentará descobrir as ferramentas disponíveis.

<Note>
  O botão **Test listing tools** ficará desativado até que você salve sua configuração. Se a validação falhar, verifique a mensagem de erro exibida — ela indicará se o problema está na conectividade, autenticação ou em um timeout.
</Note>

<div id="configuration-format">
  ### Formato de configuração
</div>

<Note>
  Os exemplos abaixo mostram representações em JSON dos campos de configuração de cada transporte. Na prática, você preenche esses campos por meio do formulário na interface web — não é necessário escrever ou colar JSON. O formato JSON é mostrado aqui para fins de clareza e como referência para configurações baseadas em API ou programáticas.
</Note>

<div id="stdio-transport">
  #### Transporte STDIO
</div>

Use STDIO para servidores que são executados como processos locais. Forneça o comando para iniciar o servidor, junto com quaisquer argumentos e variáveis de ambiente.

**Campos:**

* **Command** (obrigatório): O executável a ser iniciado (por exemplo, `npx`, `uvx`, `docker`).
* **Arguments**: Argumentos de linha de comando passados para o servidor.
* **Environment Variables**: Pares chave-valor definidos no ambiente de processo do servidor. Use-as para passar chaves de API, tokens ou valores de configuração.

**Exemplo — um servidor STDIO personalizado usando `npx`:**

```json theme={null}
{
  "transport": "STDIO",
  "command": "npx",
  "args": ["-y", "@example/my-mcp-server"],
  "env_variables": {
    "API_KEY": "your-api-key",
    "API_BASE_URL": "https://internal-api.example.com"
  }
}
```

**Exemplo — um servidor STDIO personalizado com Docker:**

```json theme={null}
{
  "transport": "STDIO",
  "command": "docker",
  "args": ["run", "-i", "--rm", "-e", "DB_CONNECTION_STRING", "my-org/my-mcp-server:latest"],
  "env_variables": {
    "DB_CONNECTION_STRING": "postgresql://user:pass@host:5432/mydb"
  }
}
```

<div id="sse-and-http-transports">
  #### Transportes SSE e HTTP
</div>

Use SSE ou HTTP para servidores remotos acessíveis pela rede. HTTP (Streamable HTTP) é recomendado para novas integrações; SSE é compatível para servidores legados.

**Campos:**

* **Server URL** (obrigatório): A URL do endpoint do servidor MCP.
* **Authentication method**: Escolha entre `None`, `Auth Header` ou `OAuth`.
  * Para **Auth Header**: Forneça a chave do cabeçalho (padrão `Authorization`) e o valor do cabeçalho (por exemplo, `Bearer your-token`).
  * Para **OAuth**: Devin solicitará que você conclua um fluxo OAuth durante sua primeira sessão. Se o seu provedor exigir aplicações OAuth pré-registradas (sem registro dinâmico de cliente), forneça seu próprio Client ID e segredo em **OAuth credentials** e adicione a URL de callback do Devin `https://api.devin.ai/mcp/oauth/callback` à lista de permissões de URI de redirecionamento nas configurações da sua aplicação OAuth.
* **Access** (somente OAuth): Escolha quem usa a conexão autenticada.
  * **Organization**: Todos os membros compartilham uma única conexão. Conecte uma conta de serviço em vez de uma conta pessoal.
  * **Personal**: Cada membro da organização se autentica individualmente com sua própria conta.

**Exemplo — um servidor HTTP remoto com autenticação por bearer token:**

```json theme={null}
{
  "transport": "HTTP",
  "url": "https://mcp.internal-service.example.com/mcp",
  "auth_method": "auth_header",
  "headers": {
    "Authorization": "Bearer your-api-token"
  }
}
```

**Exemplo — um servidor SSE remoto sem autenticação:**

```json theme={null}
{
  "transport": "SSE",
  "url": "https://mcp.example.com/sse"
}
```

<Tip>
  Ao escolher entre SSE e HTTP, dê preferência a **HTTP** (Streamable HTTP). SSE é um protocolo legado e está sendo descontinuado em todo o ecossistema MCP.
</Tip>

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

<div id="connecting-to-an-internal-api">
  ### Conectando a uma API interna
</div>

Exponha sua API interna como um servidor MCP para que o Devin possa acessá-la diretamente. Use o transporte via STDIO com um wrapper que converta chamadas de ferramentas MCP em requisições para a API.

```json theme={null}
{
  "transport": "STDIO",
  "command": "npx",
  "args": ["-y", "@example/api-mcp-bridge"],
  "env_variables": {
    "API_BASE_URL": "https://api.internal.example.com",
    "API_TOKEN": "your-internal-api-token"
  }
}
```

Alternativamente, se sua API interna estiver acessível na rede, use o transporte HTTP:

```json theme={null}
{
  "transport": "HTTP",
  "url": "https://api.internal.example.com/mcp",
  "headers": {
    "Authorization": "Bearer your-internal-api-token"
  }
}
```

<div id="connecting-to-a-database">
  ### Conectar-se a um banco de dados
</div>

Use um servidor MCP de banco de dados para conceder ao Devin acesso de leitura e gravação aos seus dados. Existem muitos servidores mantidos pela comunidade para bancos de dados populares.

```json theme={null}
{
  "transport": "STDIO",
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://user:password@host:5432/database"]
}
```

<Note>
  Para bancos de dados de produção, use uma string de conexão **somente leitura** ou um usuário de banco de dados com permissões restritas. Devin executa consultas com base nas instruções do usuário, por isso é importante restringir corretamente o acesso.
</Note>

<div id="connecting-to-a-custom-tool-or-script">
  ### Conectando a uma ferramenta ou script personalizados
</div>

Transforme qualquer ferramenta de CLI ou script em um servidor MCP. Por exemplo, um servidor em Python usando `uvx`:

```json theme={null}
{
  "transport": "STDIO",
  "command": "uvx",
  "args": ["my-custom-mcp-server"],
  "env_variables": {
    "CONFIG_PATH": "/path/to/config.json"
  }
}
```

Ou um servidor com Docker para execução isolada:

```json theme={null}
{
  "transport": "STDIO",
  "command": "docker",
  "args": ["run", "-i", "--rm", "my-org/custom-mcp-server:latest"]
}
```

<div id="using-environment-variables-for-secrets">
  ### Usando variáveis de ambiente para segredos
</div>

Passe valores sensíveis por variáveis de ambiente em vez de codificá-los diretamente nos argumentos. O recurso de [Segredos](/pt-BR/product-guides/secrets) do Devin pode gerenciar esses valores — armazene suas chaves de API ou tokens como segredos e, em seguida, faça referência a eles na configuração do seu servidor MCP.

<div id="troubleshooting-custom-mcp-servers">
  ## Solucionando problemas em servidores MCP personalizados
</div>

<div id="test-listing-tools-fails">
  ### "Test listing tools" falhou
</div>

| Sintoma                                                 | Causa provável                                                     | Correção                                                                                                                                             |
| ------------------------------------------------------- | ------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| "Verify server URL and network connectivity"            | A URL do servidor está inacessível                                 | Verifique se a URL está correta e acessível na internet (ou na rede do Devin, se estiver usando VPN)                                                 |
| "Check authentication credentials and permissions"      | Credenciais de autenticação inválidas ou ausentes                  | Verifique sua chave de API, token ou configuração de OAuth                                                                                           |
| "Server took too long to respond - check server status" | O servidor não respondeu dentro do tempo limite                    | Confirme que o servidor está em execução e responsivo; verifique se há regras de firewall bloqueando a conexão                                       |
| "MCP server validation failed" (genérico)               | Comando não encontrado, dependências ausentes ou falha do servidor | Para servidores STDIO, verifique se o comando existe e é executado localmente; confira se todas as variáveis de ambiente necessárias estão definidas |

<div id="server-connects-but-tools-arent-available">
  ### O servidor se conecta, mas as ferramentas não estão disponíveis
</div>

* Verifique se o servidor implementa corretamente o método `tools/list` do protocolo MCP.
* Para servidores STDIO, certifique-se de que o processo escreva mensagens JSON-RPC válidas em stdout e leia de stdin — logs ou saída de depuração em stdout vão interromper o protocolo.
* Confira se as variáveis de ambiente estão configuradas corretamente. Valores ausentes (por exemplo, uma chave de API em branco) podem fazer com que o servidor inicie, mas falhe ao registrar ferramentas.

<div id="oauth-authentication-issues">
  ### Problemas de autenticação OAuth
</div>

* Quando for solicitado a se autenticar, conclua o fluxo OAuth na janela do navegador que for aberta. Devin aguardará o callback.
* Se a autenticação falhar, verifique se o URI de redirecionamento OAuth está configurado corretamente no provedor. Ao usar as credenciais do seu próprio cliente OAuth, o provedor deve permitir a URL de callback do Devin `https://api.devin.ai/mcp/oauth/callback` como URI de redirecionamento — muitos provedores rejeitam o fluxo OAuth se essa URL não estiver na lista de permissões.
* Somente usuários com a permissão **Gerenciar servidores MCP** podem autenticar servidores MCP baseados em OAuth. Se você receber um erro de permissão, entre em contato com o administrador da sua organização.

<Note>
  Para MCPs baseados em OAuth com acesso de **Organization**, **use uma conta de serviço** em vez da sua conta pessoal — todas as sessões dos membros usarão a mesma conexão autenticada. Com acesso **Personal**, cada membro autentica com sua própria conta, então uma conta pessoal é adequada.
</Note>

<div id="general-debugging-tips">
  ### Dicas gerais de depuração
</div>

* **Verifique o servidor localmente primeiro.** Antes de adicionar um servidor personalizado ao Devin, confirme que ele funciona executando o comando ou acessando a URL a partir da sua própria máquina.
* **Revise os logs de sessão do Devin.** Se um servidor falhar durante uma sessão, o Devin registrará o erro. Procure mensagens relacionadas a MCP na saída da sessão.
* **Simplifique e itere.** Comece com a configuração mínima (por exemplo, sem autenticação, configurações padrão) e adicione complexidade depois que a conexão básica estiver funcionando.
* **Verifique as variáveis de ambiente.** Um problema comum é a ausência de variáveis de ambiente ou nomes incorretos. Confira se cada variável necessária está definida na configuração.

<Tip>
  Se você estiver criando seu próprio servidor MCP, a [especificação do Model Context Protocol](https://modelcontextprotocol.io/introduction) possui documentação detalhada sobre o protocolo, tipos de transporte e definições de ferramentas.
</Tip>

***

<div id="marketplace-mcps">
  ## MCPs do Marketplace
</div>

A seguir estão os detalhes de configuração de MCPs específicos disponíveis no Marketplace.

<div id="vercel-atlassian-notion-sentry-neon-asana-jam-and-many-more">
  ### Vercel, Atlassian, Notion, Sentry, Neon, Asana, Jam e muito mais
</div>

Muitos MCPs em nosso marketplace podem ser ativados sem configuração, com apenas um clique!

Basta clicar em "Enable". Você será solicitado a conectar uma conta de serviço durante sua sessão com o Devin ou ao clicar em "Test listing tools".

Os MCPs disponíveis incluem:

* AlloyDB
* Asana
* Atlassian
* BigQuery
* Cloud SQL (MySQL)
* Cloud SQL (PostgreSQL)
* Cloud SQL (SQL Server)
* Cloudflare
* Cortex
* Dataplex
* Figma
* Fireflies
* Firestore
* Jam
* Linear
* Looker
* Metabase
* MySQL
* Neon
* Notion
* PostgreSQL
* Prisma
* Sentry
* Spanner
* SQL Server
* Vercel
* Veja mais abaixo!

<Note>
  **Linear**: Se você tiver a [integração com Linear](/pt-BR/integrations/linear) conectada, o Devin já conta com ferramentas nativas do Linear e você não precisará configurar o MCP do Linear separadamente.
</Note>

<div id="datadog">
  ### Datadog
</div>

Este é o servidor MCP remoto oficial da Datadog. Quando você o ativar pelo marketplace, será solicitado que faça autenticação com sua conta da Datadog via OAuth.

Você também precisará selecionar seu site/região da Datadog (por exemplo, US1, US3, US5, EU, AP1, AP2, US1-FED) ao ativar o MCP.

[Documentação](https://docs.datadoghq.com/bits_ai/mcp_server/)

<div id="slack">
  ### Slack
</div>

Este é o servidor MCP remoto oficial do Slack. Quando você o ativar no marketplace, será solicitado que se autentique com sua conta do Slack via OAuth.

Observe que ele usa OAuth em nível de usuário: se for conectado com acesso para toda a organização, todos os membros da organização compartilharão a mesma identidade de usuário, por isso recomendamos usar acesso pessoal.

[Documentação](https://docs.slack.dev/ai/slack-mcp-server)

<div id="supabase">
  ### Supabase
</div>

Você precisará fornecer um token de acesso pessoal, que você pode encontrar e criar em [https://supabase.com/dashboard/account/tokens](https://supabase.com/dashboard/account/tokens)

[Documentação](https://mcpservers.org/servers/supabase-community/supabase-mcp)

<div id="figma">
  ### Figma
</div>

Este é o servidor MCP remoto oficial do Figma. Quando você ativar o MCP no marketplace, será solicitado que autentique sua conta do Figma via OAuth.

Ao usar este MCP, certifique-se de enviar ao Devin um link para o seu arquivo do Figma.

[Documentação](https://developers.figma.com/docs/figma-mcp-server/remote-server-installation/)

<div id="stripe">
  ### Stripe
</div>

Você precisará fornecer um cabeçalho de autorização no formato `Bearer <TOKEN>`, onde `<TOKEN>` é sua chave de API do Stripe. Mais informações em: [https://docs.stripe.com/mcp#bearer-token](https://docs.stripe.com/mcp#bearer-token)

[Documentação](https://docs.stripe.com/mcp)

<div id="zapier">
  ### Zapier
</div>

Você precisará fornecer um cabeçalho de autorização no formato `Bearer <TOKEN>`.

Você precisará extrair seu token Bearer da URL do servidor (Server URL) fornecida em [https://mcp.zapier.com/mcp/servers](https://mcp.zapier.com/mcp/servers) > Connect.

Sua URL do servidor terá o seguinte formato: [https://mcp.zapier.com/api/mcp/s/\*\*\*\*\*/mcp](https://mcp.zapier.com/api/mcp/s/*****/mcp)

Extraia a parte indicada pelos asteriscos (\*\*\*\*\*) e use-a no cabeçalho de autorização que você fornecer: `Bearer *****`

<Frame>
  <img src="https://mintcdn.com/cognitionai/a0js040y87FuBerW/images/Zapier_MCP.png?fit=max&auto=format&n=a0js040y87FuBerW&q=85&s=5214ff282660e04757b9169fae807cfa" alt="Devin" width="1201" height="649" data-path="images/Zapier_MCP.png" />
</Frame>

[Documentação](https://zapier.com/mcp)

<div id="airtable">
  ### Airtable
</div>

Você precisará fornecer uma chave de API do Airtable. Você pode encontrar suas chaves de API em: [https://airtable.com/create/tokens](https://airtable.com/create/tokens)

[Documentação](https://www.npmjs.com/package/airtable-mcp-server)

<div id="docker-hub">
  ### Docker Hub
</div>

Credenciais necessárias:

* Nome de usuário do Docker Hub: você pode obtê-lo em My Hub
* Personal Access Token: acesse Account settings > Personal access tokens e crie um token
  <Frame>
    <img src="https://mintcdn.com/cognitionai/ifLkKLaMB-vvINwf/images/dockermcp.png?fit=max&auto=format&n=ifLkKLaMB-vvINwf&q=85&s=82758d25926fe6644f01b6d4e058b6f7" alt="Devin" width="1836" height="942" data-path="images/dockermcp.png" />
  </Frame>

[Documentação](https://hub.docker.com/r/mcp/dockerhub)

<div id="sonarqube">
  ### SonarQube
</div>

Para obter as credenciais necessárias:

* SonarQube token: Acesse My Account > Security e gere seu token de API
* SonarQube org: Este é o seu nome de usuário; exemplo mostrado na imagem abaixo
  <Frame>
    <img src="https://mintcdn.com/cognitionai/k89q9Lsp7DOurdC0/images/sonarqubemcp.png?fit=max&auto=format&n=k89q9Lsp7DOurdC0&q=85&s=6067e168952a0a54ff703e95bf3a4453" alt="Devin" width="1836" height="652" data-path="images/sonarqubemcp.png" />
  </Frame>
* SonarQube URL:
  * Para instâncias self-hosted: o formato é [http://localhost:9000](http://localhost:9000/) OU [https://sonarqube.mycompany.com](https://sonarqube.mycompany.com/)
  * Para SonarCloud: use [https://sonarcloud.io](https://sonarcloud.io/)

[Documentação](https://github.com/SonarSource/sonarqube-mcp-server)

<div id="netlify">
  ### Netlify
</div>

Você precisará fornecer um Personal Access Token (PAT), que pode ser visualizado e criado em [https://app.netlify.com/user/applications#personal-access-tokens](https://app.netlify.com/user/applications#personal-access-tokens). Certifique-se de copiar o PAT assim que ele for gerado. Depois disso, não será mais possível visualizá-lo!

<Frame>
  <img src="https://mintcdn.com/cognitionai/s_eAbNGhbOgn5ZqZ/images/netlify.png?fit=max&auto=format&n=s_eAbNGhbOgn5ZqZ&q=85&s=485845854f9cd20aa1cf15e857fae2b5" alt="Devin" width="1334" height="782" data-path="images/netlify.png" />
</Frame>

[Documentação](https://docs.netlify.com/welcome/build-with-ai/netlify-mcp-server/)

<div id="pulumi">
  ### Pulumi
</div>

Um token de acesso do Pulumi pode ser obtido na seção **Access tokens** na barra lateral do painel do Pulumi.

<Frame>
  <img src="https://mintcdn.com/cognitionai/gfRQhyCSwUhbMkzA/images/pulumi.png?fit=max&auto=format&n=gfRQhyCSwUhbMkzA&q=85&s=0a8b46d0f5110776741d3414abcd7350" alt="Devin" width="1827" height="902" data-path="images/pulumi.png" />
</Frame>

[Documentação](https://www.pulumi.com/docs/iac/using-pulumi/mcp-server/)

<div id="parallel">
  ### Parallel
</div>

Você precisará fornecer uma chave de API, que você pode gerar em [https://platform.parallel.ai/](https://platform.parallel.ai/)

[Documentação](https://docs.parallel.ai/features/remote-mcp)

<div id="heroku">
  ### Heroku
</div>

Você precisará fornecer uma chave de API, que pode ser encontrada em [https://dashboard.heroku.com/account](https://dashboard.heroku.com/account)

<Frame>
  <img src="https://mintcdn.com/cognitionai/a0js040y87FuBerW/images/Heroku.png?fit=max&auto=format&n=a0js040y87FuBerW&q=85&s=0ccdfe37f97537389a3810301be2e50d" alt="Devin" width="1087" height="672" data-path="images/Heroku.png" />
</Frame>

[Documentação](https://www.heroku.com/blog/introducing-official-heroku-mcp-server/)

<div id="circleci">
  ### CircleCI
</div>

Você precisará fornecer 2 variáveis de ambiente:

* `CIRCLECI_TOKEN` - Token de API do CircleCI, que pode ser criado em [https://app.circleci.com/settings/user/tokens](https://app.circleci.com/settings/user/tokens). Certifique-se de copiar o token de API assim que ele for criado. Você não poderá visualizá-lo novamente!

<Frame>
  <img src="https://mintcdn.com/cognitionai/a0js040y87FuBerW/images/CircleCI.png?fit=max&auto=format&n=a0js040y87FuBerW&q=85&s=6eb8d1a812f6a8b715a196f0fe3a01d3" alt="Devin" width="1301" height="893" data-path="images/CircleCI.png" />
</Frame>

* `CIRCLECI_BASE_URL` \[Opcional] - Essa variável é opcional e necessária apenas para clientes on-prem. O valor padrão é `"https://circleci.com"`

[Documentação](https://hub.docker.com/r/mcp/circleci)

<div id="cortex">
  ### Cortex
</div>

Você precisará fornecer um token de acesso pessoal do Cortex para habilitar este MCP:

1. Faça login na sua instância do Cortex.
2. No menu à esquerda, vá para *Settings → My access tokens*.
3. Clique em *Create new token*.
4. Insira um nome e uma descrição para o token.
5. Clique em *Create token* e copie o token.

Ao usar este MCP, certifique-se de que o Devin está configurado com a URL correta da API do Cortex (o padrão é `https://api.getcortexapp.com`).

[Documentação](https://docs.cortex.io/get-started/mcp)

<div id="square">
  ### Square
</div>

Você precisará fornecer um cabeçalho de autorização no formato `Bearer <TOKEN>`, em que `<TOKEN>` é o seu token de acesso do Square. Mais informações em: [https://developer.squareup.com/docs/build-basics/access-tokens](https://developer.squareup.com/docs/build-basics/access-tokens)

[Documentação](https://developer.squareup.com/docs/mcp)

<div id="hubspot">
  ### Hubspot
</div>

Você precisará fornecer um token de acesso como variável de ambiente. Para obter seu token de acesso:

1. Crie um aplicativo privado no HubSpot:
2. Vá para Settings > Integrations > Private Apps
3. Clique em "Create private app"
4. Dê um nome ao aplicativo e defina os escopos necessários
5. Clique em "Create app"
6. Copie o token de acesso gerado na aba "Auth"

[Documentação](https://www.npmjs.com/package/@hubspot/mcp-server)

<div id="redis">
  ### Redis
</div>

Credenciais necessárias:

* Host do Redis
* Porta do Redis
* Usuário do Redis
* Senha do Redis

[Documentação](https://redis.io/docs/latest/integrate/redis-mcp/client-conf/)

<div id="google-maps">
  ### Google Maps
</div>

Você precisará (1) fornecer uma chave de API e (2) ativar as APIs específicas às quais deseja que o Devin tenha acesso.

Para obter sua chave de API, acesse [https://console.cloud.google.com/apis/credentials](https://console.cloud.google.com/apis/credentials) e abra a barra lateral > APIs e serviços > Credenciais.

Para ativar uma API específica, pesquise pela API e clique em **Enable**.

<Frame>
  <img src="https://mintcdn.com/cognitionai/a0js040y87FuBerW/images/MapsMCP1.png?fit=max&auto=format&n=a0js040y87FuBerW&q=85&s=3d20b29ef11e1b713f435f87402aa962" alt="Devin" width="1602" height="957" data-path="images/MapsMCP1.png" />
</Frame>

<Frame>
  <img src="https://mintcdn.com/cognitionai/a0js040y87FuBerW/images/MapsMCP2.png?fit=max&auto=format&n=a0js040y87FuBerW&q=85&s=cd8849a5e0366b76cc91616bdff550a0" alt="Devin" width="1840" height="885" data-path="images/MapsMCP2.png" />
</Frame>

<Frame>
  <img src="https://mintcdn.com/cognitionai/a0js040y87FuBerW/images/MapsMCP4.png?fit=max&auto=format&n=a0js040y87FuBerW&q=85&s=fc8243ef585f3f57ecb716ade31c5ff1" alt="Devin" width="1088" height="831" data-path="images/MapsMCP4.png" />
</Frame>

[Documentação](https://www.npmjs.com/package/@modelcontextprotocol/server-google-maps)

<div id="playwright">
  ### Playwright
</div>

Não são necessárias variáveis de ambiente para isso! Basta habilitar a integração.

[Documentação](https://hub.docker.com/r/mcp/playwright)

<div id="firecrawl">
  ### Firecrawl
</div>

Você precisará fornecer uma chave de API (`FIRECRAWL_API_KEY`), que você pode visualizar e criar em [https://www.firecrawl.dev/app/api-keys](https://www.firecrawl.dev/app/api-keys).

[Documentação](https://hub.docker.com/r/mcp/firecrawl#use-this-mcp-server)

<div id="elasticsearch">
  ### ElasticSearch
</div>

Você precisará fornecer duas variáveis de ambiente:

* `ES_URL` - URL ou endpoint do Elasticsearch, que pode ser encontrado na página `/overview` no Elasticsearch.
* `ES_API_KEY` - chave de API do Elasticsearch, que pode ser criada na página `/indices/index_details/<name>/data` no Elasticsearch.

<Frame>
  <img src="https://mintcdn.com/cognitionai/ifLkKLaMB-vvINwf/images/elasticsearch.png?fit=max&auto=format&n=ifLkKLaMB-vvINwf&q=85&s=5e0cab4b8525d2377c6353f95f94fbbc" alt="Devin" width="1383" height="637" data-path="images/elasticsearch.png" />
</Frame>

`ES_SSL_SKIP_VERIFY` é uma variável de ambiente opcional. Quando definida como `true`, ela ignora a verificação do certificado SSL/TLS ao se conectar ao Elasticsearch.

[Documentação](https://hub.docker.com/r/mcp/elasticsearch)

<div id="postgres">
  ### Postgres
</div>

A única credencial necessária é a string de conexão do Postgres.

[Documentação](https://www.npmjs.com/package/@modelcontextprotocol/server-postgres?activeTab=readme)

<div id="plaid">
  ### Plaid
</div>

A única credencial necessária é um token de acesso OAuth Bearer, que pode ser obtido ao executar o código a seguir:

```jsx theme={null}
curl -X POST https://production.plaid.com/oauth/token \
-H 'Content-Type: application/json' \
-d '{
"client_id": "YOUR_PLAID_CLIENT_ID",
"client_secret": "YOUR_PRODUCTION_SECRET",
"grant_type": "client_credentials",
"scope": "mcp:dashboard"
}'
```

Para obter o client ID e o client secret de produção, acesse [https://dashboard.plaid.com/developers/keys](https://dashboard.plaid.com/developers/keys)

[Documentação](https://plaid.com/docs/resources/mcp/)

<div id="replicate">
  ### Replicate
</div>

A única credencial necessária é o token de API, que pode ser encontrado em [https://replicate.com/account/api-tokens](https://replicate.com/account/api-tokens)

[Documentação](https://replicate.com/docs/reference/mcp)

<div id="grafana">
  ### Grafana
</div>

Você precisará fornecer 2 variáveis de ambiente:

* URL do Grafana
* Token de conta de serviço do Grafana: para obter o token, na barra lateral, vá em Administration > Users and access > Service accounts > Add service account (se você ainda não tiver uma) > Add service account token

<Frame>
  <img src="https://mintcdn.com/cognitionai/ifLkKLaMB-vvINwf/images/grafana.png?fit=max&auto=format&n=ifLkKLaMB-vvINwf&q=85&s=e16f4c261b07fda96ad235d4be993367" alt="Devin" width="1862" height="987" data-path="images/grafana.png" />
</Frame>

<div id="pinecone">
  ### Pinecone
</div>

Nota: o MCP do Pinecone oferece suporte apenas a índices com embeddings integrados. Índices para vetores criados com modelos de embedding externos ainda não são compatíveis a partir de 16/07/25.

A única credencial necessária é a chave de API do Pinecone, que pode ser obtida na página de chaves de API no painel do Pinecone, conforme mostrado abaixo:

<Frame>
  <img src="https://mintcdn.com/cognitionai/s_eAbNGhbOgn5ZqZ/images/pinecone.png?fit=max&auto=format&n=s_eAbNGhbOgn5ZqZ&q=85&s=8229b659a0e8f78eee7cb145e49d2d0e" alt="Devin" width="1840" height="947" data-path="images/pinecone.png" />
</Frame>

<div id="snyk">
  ### Snyk
</div>

1. Primeiro, configure o servidor MCP. A documentação está disponível [aqui](https://docs.snyk.io/integrations/developer-guardrails-for-agentic-workflows/quickstart-guides-for-mcp/devin-guide). Observação: verifique se você adicionou uma variável de ambiente ao final (ela não está listada no guia).
   <Frame>
     <img src="https://mintcdn.com/cognitionai/F6MIT2LaffywIXqC/images/snyk.png?fit=max&auto=format&n=F6MIT2LaffywIXqC&q=85&s=50fde971b376243d74fcf09ee4014993" alt="Devin" width="939" height="797" data-path="images/snyk.png" />
   </Frame>
2. Instale a CLI do Snyk na máquina do Devin. A documentação está disponível [aqui](https://docs.snyk.io/developer-tools/snyk-cli/install-or-update-the-snyk-cli)

```jsx theme={null}
brew tap snyk/tap
brew install snyk-cli

snyk --disable-trust
```

Observação: alguns testes do Snyk exigem que a pasta seja marcada como confiável para funcionar — instale-o na máquina depois que o Homebrew estiver instalado. A documentação está disponível [aqui](https://docs.snyk.io/integrations/developer-guardrails-for-agentic-workflows/troubleshooting-for-the-snyk-mcp-server#folder-trust).

**Dica**:
Se estiver configurado corretamente, a lista completa de scans do Snyk deve ser executada já na primeira execução. No entanto, dependendo do framework, alguns scans exigem que a flag `unmanaged: true` (ex.: C++) seja passada. Atualmente você pode definir isso no Knowledge ou durante sua sessão com o Devin — aqui está um exemplo:

<Frame>
  <img src="https://mintcdn.com/cognitionai/F6MIT2LaffywIXqC/images/synk-example.png?fit=max&auto=format&n=F6MIT2LaffywIXqC&q=85&s=b7d4e1923f90e00e1c7106515fa2ee20" alt="Devin" width="1020" height="158" data-path="images/synk-example.png" />
</Frame>

**Dica**: Criamos um [playbook de exemplo](https://app.devin.ai/settings/playbooks/163db5ecab7e47e6a82c71bf8d338678) para ajudar você a começar.

[Documentação](https://docs.snyk.io/integrations/developer-guardrails-for-agentic-workflows/quickstart-guides-for-mcp/devin-guide)