> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devinenterprise.com/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. **Recomendamos fortemente o uso de uma conta de serviço**, e não da sua conta pessoal, já que o acesso será compartilhado com a sua organização.
</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.

**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** (HTTP com streaming). 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.
* 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, **use uma conta de serviço** em vez da sua conta pessoal. O acesso é compartilhado em toda a sua organização, e todas as sessões dos membros usarão a mesma conexão autenticada.
</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-enterprise/oqBYXWmkhuOhl3HZ/images/Zapier_MCP.png?fit=max&auto=format&n=oqBYXWmkhuOhl3HZ&q=85&s=4369b99546ea6d4168d1c6a3e186195b" 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-enterprise/JQ4gdhcxD51zUhW4/images/dockermcp.png?fit=max&auto=format&n=JQ4gdhcxD51zUhW4&q=85&s=93ca26c0361a410120b0ed9c313a930a" 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-enterprise/A1NrXl_1--Cgx5nh/images/sonarqubemcp.png?fit=max&auto=format&n=A1NrXl_1--Cgx5nh&q=85&s=e5054e50938f9c50e35ecb01b5336ffd" 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-enterprise/oD-FO9nMcsNLafKf/images/netlify.png?fit=max&auto=format&n=oD-FO9nMcsNLafKf&q=85&s=a84824c48aae17d32da4f0d410cf2bfd" 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-enterprise/p6mfZwd14EeP9cx_/images/pulumi.png?fit=max&auto=format&n=p6mfZwd14EeP9cx_&q=85&s=7365b1d99d3036bd1b8967eff22a06c0" 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-enterprise/oqBYXWmkhuOhl3HZ/images/Heroku.png?fit=max&auto=format&n=oqBYXWmkhuOhl3HZ&q=85&s=f8d4fc8875f4698fb4d8f4aa66dd7a45" 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-enterprise/oqBYXWmkhuOhl3HZ/images/CircleCI.png?fit=max&auto=format&n=oqBYXWmkhuOhl3HZ&q=85&s=519e872376d5a77abc06b28c681090f9" 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-enterprise/oqBYXWmkhuOhl3HZ/images/MapsMCP1.png?fit=max&auto=format&n=oqBYXWmkhuOhl3HZ&q=85&s=5054d6697f072d088d531f4b42aa2975" alt="Devin" width="1602" height="957" data-path="images/MapsMCP1.png" />
</Frame>

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

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/oqBYXWmkhuOhl3HZ/images/MapsMCP4.png?fit=max&auto=format&n=oqBYXWmkhuOhl3HZ&q=85&s=ff52adfbdecdd26b72d592420c6d8f56" 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-enterprise/JQ4gdhcxD51zUhW4/images/elasticsearch.png?fit=max&auto=format&n=JQ4gdhcxD51zUhW4&q=85&s=eb064fe58f44f992873b29a086e731b1" 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-enterprise/JQ4gdhcxD51zUhW4/images/grafana.png?fit=max&auto=format&n=JQ4gdhcxD51zUhW4&q=85&s=07d1f8c4160b53743368c0c7cc6df2bf" 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-enterprise/oD-FO9nMcsNLafKf/images/pinecone.png?fit=max&auto=format&n=oD-FO9nMcsNLafKf&q=85&s=b5141e1593f2cb0479ec040802280762" 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-enterprise/fh-R0_T65dbpUS2r/images/snyk.png?fit=max&auto=format&n=fh-R0_T65dbpUS2r&q=85&s=1c5a165b7e2ccdac68beaacf0a413c3d" 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-enterprise/fh-R0_T65dbpUS2r/images/synk-example.png?fit=max&auto=format&n=fh-R0_T65dbpUS2r&q=85&s=b1e3752ddfc4c1d5f7cbf9d56c11d630" 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)