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

# Servidores MCP e marketplace do Devin

> Conecte o Devin a ferramentas externas com servidores MCP: instale plugins do marketplace ou adicione servidores STDIO, SSE ou HTTP personalizados.

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">
  <h2 id="why-use-mcp">
    Por que usar MCP?
  </h2>
</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!

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

Os servidores MCP são gerenciados na aba [**Customize → MCPs**](https://app.devin.ai/customize?tab=mcps), junto com plugins, skills, hooks e regras, no escopo pessoal, de organização ou de enterprise. (A antiga página Configurações → Conexões → servidores MCP redireciona para lá.)

A forma recomendada de adicionar uma integração é instalar seu **plugin** pelo plugin marketplace (**Browse marketplace** na página Customize): a maioria dos plugins oficiais consiste em um único servidor MCP, geralmente com skills que ensinam o Devin a usá-lo, e instalar um no escopo de organização o disponibiliza para todos. O MCP marketplace legado continua disponível na aba MCPs. Consulte o [guia de Plugins](/pt-BR/product-guides/plugins#mcps) para entender como funcionam os MCPs de plugins, as conexões e os escopos.

Para conectar um MCP fornecido por um plugin:

1. Instale o plugin no escopo **Personal**, **Organization** ou **Enterprise** em que deseja usá-lo.
2. Aguarde o indexing ler sua configuração de MCP. Se a configuração continuar indisponível, siga [Resolver problemas de indexing](/pt-BR/product-guides/plugins#resolve-indexing-issues).
3. Abra o MCP do plugin em **Customize → MCPs**, escolha **Connect** e forneça as credenciais necessárias ou conclua o OAuth. Conectar um MCP compartilhado exige as permissões para gerenciar MCPs nesse escopo.
4. Verifique o status da conexão antes de usá-lo em uma nova sessão. A instalação do plugin, por si só, não autoriza o acesso ao serviço externo.

Para MCPs de plugins da CLI, siga o [guia de configuração de MCP na CLI](/pt-BR/cli/extensibility/mcp/configuration); use `devin mcp login` para servidores OAuth executados localmente.

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

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

<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 **Add custom MCP** na aba Customize → MCPs. 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>

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

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

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

1. Acesse [Customize > MCPs](https://app.devin.ai/customize?tab=mcps).
2. Abra **Add MCP** e escolha **Adicionar um MCP personalizado**.
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. Verifique o servidor na página de configuração dele. A forma de verificação depende do transporte:
   * **SSE ou HTTP**: Clique em **Test tools**. Devin se conecta ao seu servidor e tenta listar as ferramentas disponíveis.
   * **STDIO**: **Test tools** fica desativado, porque servidores STDIO só podem ser testados dentro de uma sessão. Clique em **Use MCP** para iniciar uma sessão do Devin que coloque as ferramentas do servidor à prova.

<Note>
  **Test tools** e **Use MCP** ficam indisponíveis até que você salve sua configuração. Se **Test tools** 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">
  <h3 id="configuration-format">
    Formato de configuração
  </h3>
</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">
  <h4 id="stdio-transport">
    Transporte STDIO
  </h4>
</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"
  }
}
```

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

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**: Salve a configuração e use **Connect** em **Customize → MCPs** para concluir a autorizaçã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 à lista de permissões de URI de redirecionamento nas configurações da sua aplicação OAuth. Copie o valor exato do campo **OAuth callback URL** nessa seção. No app.devin.ai, ele é `https://api.devin.ai/mcp/oauth/callback`; deployments dedicados e com domínio personalizado usam uma origem de API diferente, então sempre use o valor exibido pelo seu deployment.
* **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">
  <h2 id="common-patterns">
    Padrões comuns
  </h2>
</div>

<div id="connecting-to-an-internal-api">
  <h3 id="connecting-to-an-internal-api">
    Conectando a uma API interna
  </h3>
</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">
  <h3 id="connecting-to-a-database">
    Conectar-se a um banco de dados
  </h3>
</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">
  <h3 id="connecting-to-a-custom-tool-or-script">
    Conectando a uma ferramenta ou script personalizados
  </h3>
</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">
  <h3 id="using-environment-variables-for-secrets">
    Usando variáveis de ambiente para segredos
  </h3>
</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">
  <h2 id="troubleshooting-custom-mcp-servers">
    Solucionando problemas em servidores MCP personalizados
  </h2>
</div>

<h3 id="an-installed-plugins-mcp-is-missing-or-cannot-be-connected">
  O MCP de um plugin instalado está ausente ou não consegue se conectar
</h3>

* Verifique o escopo de instalação do plugin e o resultado do indexing em Customize. Declarações de MCP ausentes ou malformadas precisam ser corrigidas na origem do plugin e, em seguida, reindexadas. Consulte [Resolver problemas de indexing](/pt-BR/product-guides/plugins#resolve-indexing-issues).
* Depois que a configuração de MCP for indexada, abra as configurações de conexão do MCP e forneça as credenciais ou a autorização OAuth necessárias. Um indexing bem-sucedido não valida a conexão com o serviço externo.
* Se você não conseguir se conectar a um MCP compartilhado de organização ou enterprise, peça ajuda a um admin com as permissões adequadas de gerenciamento de MCP. Para um MCP com acesso OAuth **Personal**, cada member precisa conectar a própria conta.

<h3 id="test-tools-fails">
  "Test tools" falhou
</h3>

**Test tools** está disponível apenas para servidores SSE e HTTP. Para solucionar problemas de um servidor STDIO, consulte [Um servidor STDIO falha em uma sessão](#a-stdio-server-fails-in-a-session).

| 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) | O servidor retornou um erro ou travou ao listar as ferramentas | Verifique os logs do servidor e confirme se todas as credenciais referenciadas na URL ou nos cabeçalhos estão definidas |

<h3 id="a-stdio-server-fails-in-a-session">
  Um servidor STDIO falha em uma sessão
</h3>

Depois de clicar em **Use MCP**, verifique na sessão se há erros ao iniciar o servidor ou ao listar suas ferramentas:

* Confirme que o comando existe e é executado localmente, e que suas dependências estão disponíveis no ambiente do Devin.
* Verifique se todas as variáveis de ambiente necessárias estão definidas.

<div id="server-connects-but-tools-arent-available">
  <h3 id="server-connects-but-tools-arent-available">
    O servidor se conecta, mas as ferramentas não estão disponíveis
  </h3>
</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.

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

* 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 como URI de redirecionamento — muitos provedores rejeitam o fluxo OAuth se essa URL não estiver na lista de permissões. Copie o valor exato do campo **OAuth callback URL** nas credenciais OAuth do MCP em vez de presumir `https://api.devin.ai/mcp/oauth/callback`, que se aplica apenas ao app.devin.ai.
* No caso de uma conexão compartilhada de organização ou enterprise, entre em contato com o administrador se você não tiver as permissões necessárias de gerenciamento de MCP. Com acesso **Personal**, cada membro conecta sua própria conta.

<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">
  <h3 id="general-debugging-tips">
    Dicas gerais de depuração
  </h3>
</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">
  <h2 id="marketplace-mcps">
    MCPs do Marketplace
  </h2>
</div>

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

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

Encontre o serviço em **Browse marketplace**, em **Customize → MCPs**, e siga as instruções de instalação. No caso de um MCP fornecido por plugin, aguarde o indexing, depois abra as configurações de conexão dele e escolha **Connect**.

Conclua o OAuth antes de iniciar uma sessão. Use uma conta de serviço para acesso compartilhado de **Organization**; com acesso **Personal**, cada membro conecta a própria conta. Instalação e autorização são etapas separadas.

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>

<Note>
  **MongoDB**: Para executar o servidor MCP do MongoDB com `--readOnly` e `--indexCheck`, ou para dar ao Devin uma identidade do Atlas com escopo restrito e acesso à CLI do Atlas, consulte [Conectar o Devin ao MongoDB](/pt-BR/integrations/mongodb).
</Note>

<h3 id="datadog">
  Datadog
</h3>

O marketplace inclui conexões por chave de API e OAuth para o servidor MCP remoto oficial do Datadog. Selecione o site/região do Datadog entre as opções oferecidas pela conexão.

* **Datadog (API key)** usa os cabeçalhos `DD-API-KEY` e `DD-APPLICATION-KEY`.
* **Datadog (OAuth)** solicita que você autorize sua conta do Datadog via OAuth.

Siga as instruções de configuração da entrada selecionada e depois verifique o status da conexão em **Customize → MCPs**.

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

<h3 id="slack">
  Slack
</h3>

Este é o servidor MCP remoto oficial do Slack. Instale-o no marketplace e, em seguida, escolha **Connect** em **Customize → MCPs** para autorizar 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">
  <h3 id="supabase">
    Supabase
  </h3>
</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)

<h3 id="figma">
  Figma
</h3>

Este é o servidor MCP remoto oficial do Figma. Instale-o pelo marketplace e, em seguida, escolha **Connect** em **Customize → MCPs** para autorizar 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">
  <h3 id="stripe">
    Stripe
  </h3>
</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">
  <h3 id="zapier">
    Zapier
  </h3>
</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">
  <h3 id="airtable">
    Airtable
  </h3>
</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">
  <h3 id="docker-hub">
    Docker Hub
  </h3>
</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">
  <h3 id="sonarqube">
    SonarQube
  </h3>
</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">
  <h3 id="netlify">
    Netlify
  </h3>
</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">
  <h3 id="pulumi">
    Pulumi
  </h3>
</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">
  <h3 id="parallel">
    Parallel
  </h3>
</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">
  <h3 id="heroku">
    Heroku
  </h3>
</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">
  <h3 id="circleci">
    CircleCI
  </h3>
</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">
  <h3 id="cortex">
    Cortex
  </h3>
</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">
  <h3 id="square">
    Square
  </h3>
</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">
  <h3 id="hubspot">
    Hubspot
  </h3>
</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">
  <h3 id="redis">
    Redis
  </h3>
</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">
  <h3 id="google-maps">
    Google Maps
  </h3>
</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">
  <h3 id="playwright">
    Playwright
  </h3>
</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">
  <h3 id="firecrawl">
    Firecrawl
  </h3>
</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">
  <h3 id="elasticsearch">
    ElasticSearch
  </h3>
</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)

<h3 id="postgres">
  Postgres
</h3>

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

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

<h3 id="plaid">
  Plaid
</h3>

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">
  <h3 id="replicate">
    Replicate
  </h3>
</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">
  <h3 id="grafana">
    Grafana
  </h3>
</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">
  <h3 id="pinecone">
    Pinecone
  </h3>
</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">
  <h3 id="snyk">
    Snyk
  </h3>
</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)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.