> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devin.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# MCP (Model Context Protocol) Marketplace

MCP is an open protocol that enables Devin to use hundreds of external tools and data sources. Devin supports 3 transport methods (stdio, SSE, and HTTP).

## Why use MCP?

With MCP, Devin can help you:

* dig through Sentry, Datadog and Vercel logs
* [use Devin as a data analyst](https://devin.ai/ai-data-analyst-1) in Slack with database MCPs
* dig into SonarQube, CircleCI, and Jam issues
* bulk create Linear tickets, Notion docs, Google Docs (through Zapier) and more
* pull in context from and interact with Airtable, Stripe, and Hubspot
* a lot more!

## Get started with MCPs

Navigate to [Settings > MCP Marketplace](https://app.devin.ai/settings/mcp-marketplace) to enable an MCP.

<CardGroup cols={2}>
  <Card title="Use Devin for data analysis in Slack by connecting Devin to database MCPs" icon="chart-simple" href="https://devin.ai/ai-data-analyst-1/">
    Check out our step-by-step guide!
  </Card>

  <Card title="Browse MCP use cases" icon="grid-2" href="/use-cases/gallery/index">
    Explore practical examples of Devin with MCPs like Datadog, Sentry, Linear, Figma, and more.
  </Card>
</CardGroup>

## Configuration tips

<Note>
  For MCPs that authenticate with OAuth, Devin will prompt you to visit a URL to connect your account. **We strongly recommend using a service account**, not your personal account, as access will be shared within your organization.
</Note>

<Note>
  Don't see the MCP you're looking for? Set it up using the "Add Your Own" option!

  Having trouble? Contact us via our [support page](https://app.devin.ai/settings/support) or via [support@cognition.ai](mailto:support@cognition.ai).
</Note>

## Setting up a custom MCP server

If the MCP you need isn't in the marketplace, you can add any MCP server using the **Add Your Own** option. Devin supports three transport types for custom servers:

| Transport | Best for                                             | Required fields              |
| --------- | ---------------------------------------------------- | ---------------------------- |
| **STDIO** | Local CLI-based servers (e.g., `npx`, `uvx`, Docker) | Command, args, env variables |
| **SSE**   | Remote servers using Server-Sent Events              | Server URL, headers          |
| **HTTP**  | Remote servers using Streamable HTTP                 | Server URL, headers          |

### Step-by-step: Adding a custom MCP server

1. Navigate to [Settings > MCP Marketplace](https://app.devin.ai/settings/mcp-marketplace).
2. Click **Add Your Own** at the top of the page.
3. Fill in the server details:
   * **Server Name**: A descriptive name for the server (e.g., "Internal API Gateway").
   * **Icon** (optional): An emoji or URL to use as the server's icon.
   * **Short Description**: A brief summary of what the server does.
4. Select the **transport type** (STDIO, SSE, or HTTP).
5. Fill in the transport-specific configuration fields (see [Configuration format](#configuration-format) below).
6. Click **Save** to create the server.
7. Click **Test listing tools** to verify the connection. Devin will spin up an isolated test environment, connect to your server, and attempt to discover its available tools.

<Note>
  The **Test listing tools** button is disabled until you save your configuration. If validation fails, check the error message displayed — it will indicate whether the issue is with connectivity, authentication, or a timeout.
</Note>

### Configuration format

<Note>
  The examples below show JSON representations of each transport's configuration fields. In practice, you fill these in through the web form — you do not need to write or paste JSON. The JSON format is shown here for clarity and as a reference for API-based or programmatic setups.
</Note>

#### STDIO transport

Use STDIO for servers that run as local processes. You provide the command to launch the server, along with any arguments and environment variables.

**Fields:**

* **Command** (required): The executable to run (e.g., `npx`, `uvx`, `docker`).
* **Arguments**: Command-line arguments passed to the server.
* **Environment Variables**: Key-value pairs set in the server's process environment. Use these to pass API keys, tokens, or configuration values.

**Example — a custom STDIO server using `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"
  }
}
```

**Example — a custom STDIO server using 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"
  }
}
```

#### SSE and HTTP transports

Use SSE or HTTP for remote servers accessible over the network. HTTP (Streamable HTTP) is recommended for new integrations; SSE is supported for legacy servers.

**Fields:**

* **Server URL** (required): The endpoint URL of the MCP server.
* **Authentication method**: Choose between `None`, `Auth Header`, or `OAuth`.
  * For **Auth Header**: Provide the header key (defaults to `Authorization`) and the header value (e.g., `Bearer your-token`).
  * For **OAuth**: Devin will prompt you to complete an OAuth flow during your first session.

**Example — a remote HTTP server with bearer token auth:**

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

**Example — a remote SSE server with no auth:**

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

<Tip>
  When choosing between SSE and HTTP, prefer **HTTP** (Streamable HTTP). SSE is a legacy protocol and is being deprecated across the MCP ecosystem.
</Tip>

## Common patterns

### Connecting to an internal API

Expose your internal API as an MCP server so Devin can query it directly. Use the STDIO transport with a wrapper that translates MCP tool calls into API requests.

```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"
  }
}
```

Alternatively, if your internal API is reachable over the network, use the HTTP transport:

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

### Connecting to a database

Use a database MCP server to give Devin read or write access to your data. Many community-maintained servers exist for common databases.

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

<Note>
  For production databases, use a **read-only** connection string or a database user with restricted permissions. Devin executes queries based on user instructions, so scoping access appropriately is important.
</Note>

### Connecting to a custom tool or script

Wrap any CLI tool or script as an MCP server. For example, a Python-based server using `uvx`:

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

Or a Docker-based server for isolated execution:

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

### Using environment variables for secrets

Pass sensitive values through environment variables rather than hardcoding them in arguments. Devin's [Secrets](/product-guides/secrets) feature can manage these values — store your API keys or tokens as secrets, then reference them in your MCP server configuration.

## Troubleshooting custom MCP servers

### "Test listing tools" fails

| Symptom                                                 | Likely cause                                             | Fix                                                                                                          |
| ------------------------------------------------------- | -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
| "Verify server URL and network connectivity"            | The server URL is unreachable                            | Check that the URL is correct and accessible from the internet (or from Devin's network if using VPN)        |
| "Check authentication credentials and permissions"      | Invalid or missing auth credentials                      | Verify your API key, token, or OAuth configuration                                                           |
| "Server took too long to respond - check server status" | The server didn't respond within the timeout             | Ensure the server is running and responsive; check for firewall rules blocking the connection                |
| "MCP server validation failed" (generic)                | Command not found, missing dependencies, or server crash | For STDIO servers, verify the command exists and runs locally; check that all required env variables are set |

### Server connects but tools aren't available

* Verify the server correctly implements the MCP protocol's `tools/list` method.
* For STDIO servers, ensure the process writes valid JSON-RPC messages to stdout and reads from stdin — logging or debug output to stdout will break the protocol.
* Check that environment variables are set correctly. Missing values (e.g., a blank API key) can cause the server to start but fail to register tools.

### OAuth authentication issues

* When prompted to authenticate, complete the OAuth flow in the browser window that opens. Devin will wait for the callback.
* If authentication fails, check that the OAuth redirect URI is configured correctly on the provider side.
* Only organization admins can authenticate OAuth-based MCP servers. If you see a permissions error, contact your org admin.

<Note>
  For OAuth-based MCPs, **use a service account** rather than your personal account. Access is shared across your organization, and all members' sessions will use the same authenticated connection.
</Note>

### General debugging tips

* **Check the server locally first.** Before adding a custom server to Devin, verify it works by running the command or hitting the URL from your own machine.
* **Review Devin's session logs.** If a server fails during a session, Devin will log the error. Look for MCP-related messages in the session output.
* **Simplify and iterate.** Start with the minimal configuration (e.g., no auth, default settings) and add complexity once the basic connection works.
* **Verify environment variables.** A common issue is missing or misnamed env variables. Double-check that every required variable is set in the configuration.

<Tip>
  If you're building your own MCP server, the [Model Context Protocol specification](https://modelcontextprotocol.io/introduction) has detailed documentation on the protocol, transport types, and tool definitions.
</Tip>

***

## Marketplace MCPs

Below are configuration details for specific MCPs available in the marketplace.

### Vercel, Atlassian, Notion, Sentry, Neon, Asana, Jam and many more

Many MCPs in our marketplace can be enabled without configuration with 1 click!

Just click "Enable". You'll be prompted to connect a service account during your Devin session, or when you click "Test listing tools".

Available MCPs include:

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

<Note>
  **Linear**: If you have the [Linear integration](/integrations/linear) connected, Devin already has native Linear tools and you do not need to configure the Linear MCP separately.
</Note>

### Datadog

This is the official Datadog MCP server. You'll need to provide 2 headers:

* DD-API-KEY - Datadog API key, which can be found on the [Organization Settings > API Keys](https://app.datadoghq.com/organization-settings/api-keys) page in Datadog
* DD-APPLICATION-KEY - Datadog Application key, which can be found on the [Organization Settings > Application Keys](https://app.datadoghq.com/organization-settings/application-keys) page in Datadog

You'll also need to select your Datadog site/region (e.g. US1, US3, US5, EU, AP1, AP2, US1-FED) when enabling the MCP.

[Documentation](https://docs.datadoghq.com/bits_ai/mcp_server/)

### Slack

To get the necessary credentials:

*Slack bot token*:
To start, navigate to to [api.slack.com/apps](http://api.slack.com/apps) and select your app. Then:

* In the sidebar, navigate to Oauth & Permissions
* Look for the Bot User OAuth Token (should start with “xoxb-”).
* If you don't see your Bot User Oauth Token, make sure you've configured app-level tokens (in Settings > Basic Information), added at least 1 scope (in Settings > Oauth & Permissions), and installed your app to your workspace.

*Slack team ID*:

* Use the curl command: `curl -H "Authorization: Bearer xoxb-your-token" https://slack.com/api/auth.test` where `xoxb-your-token` should be replaced with your OAuth token

*Slack channel IDs*:

* Use the curl command: `curl -H "Authorization: Bearer xoxb-your-token" https://slack.com/api/conversations.list` where `xoxb-your-token` is replaced with your OAuth token
* For this command to work, you'll need to add at least the following scopes: channels:read,groups:read,mpim:read,im:read

[Documentation](https://www.npmjs.com/package/@modelcontextprotocol/server-slack)

### Supabase

You'll need to provide a personal access token, which you can find and create at [https://supabase.com/dashboard/account/tokens](https://supabase.com/dashboard/account/tokens)

[Documentation](https://mcpservers.org/servers/supabase-community/supabase-mcp)

### Figma

You'll need to provide a Figma API key to enable this MCP:

1. From the home page in Figma, click the profile icon in the top left corner and select Settings from the dropdown.
2. In the settings menu, select the Security tab.
3. Scroll down to the Personal access tokens section and click Generate new token.
4. Enter a name for the token and make sure you provide the appropriate permissions. We recommend at least read permissions on File content and Dev resources.
5. Click Generate token.

When using this MCP, make sure to send Devin a link to your Figma file.

**NOTE: This is a third-party MCP integration not built or maintained by Figma.**

[Documentation](https://github.com/thirdstrandstudio/mcp-figma)

### Stripe

You'll need to provide an authorization header which follows the format `Bearer <TOKEN>`, where `<TOKEN>` is your Stripe API key. More info at: [https://docs.stripe.com/mcp#bearer-token](https://docs.stripe.com/mcp#bearer-token)

[Documentation](https://docs.stripe.com/mcp)

### Zapier

You'll need to provide an authorization header which follows the format `Bearer <TOKEN>`.

You'll need to extract your Bearer token from the Server URL provided at [https://mcp.zapier.com/mcp/servers](https://mcp.zapier.com/mcp/servers) > Connect

Your Server URL will look like: [https://mcp.zapier.com/api/mcp/s/\*\*\*\*\*/mcp](https://mcp.zapier.com/api/mcp/s/*****/mcp)

Extract the starred section (\*\*\*\*\*) and use it in the authorization header you provide: `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>

[Documentation](https://zapier.com/mcp)

### Airtable

You'll need to provide an Airtable API key. You can find your API keys at: [https://airtable.com/create/tokens](https://airtable.com/create/tokens)

[Documentation](https://www.npmjs.com/package/airtable-mcp-server)

### Docker Hub

Credentials required:

* Docker Hub username: This can be obtained from My Hub
* Personal Access Token: Go to Account settings > Personal access tokens and create a 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>

[Documentation](https://hub.docker.com/r/mcp/dockerhub)

### SonarQube

To get the required credentials:

* Sonarqube token: Go to my Account > Security and generate your API token
* Sonarqube org: This is your username, example shown in the below image
  <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:
  * For self hosted: format is [http://localhost:9000](http://localhost:9000/)  OR [https://sonarqube.mycompany.com](https://sonarqube.mycompany.com/)
  * For SonarCloud: use [https://sonarcloud.io](https://sonarcloud.io/)

[Documentation](https://github.com/SonarSource/sonarqube-mcp-server)

### Netlify

You’ll need to provide a Personal Access Token, which you can view and create at [https://app.netlify.com/user/applications#personal-access-tokens](https://app.netlify.com/user/applications#personal-access-tokens). Make sure to copy the PAT as soon as it is created. You won't be able to see it again!

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

[Documentation](https://docs.netlify.com/welcome/build-with-ai/netlify-mcp-server/)

### Pulumi

A Pulumi access token can be obtained from the Access tokens section in the sidebar of the Pulumi dashboard.

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

[Documentation](https://www.pulumi.com/docs/iac/using-pulumi/mcp-server/)

### Parallel

You'll need to provide an API key, which you can generate at [https://platform.parallel.ai/](https://platform.parallel.ai/)

[Documentation](https://docs.parallel.ai/features/remote-mcp)

### Heroku

You’ll need to provide an API Key, which you can find at [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>

[Documentation](https://www.heroku.com/blog/introducing-official-heroku-mcp-server/)

### CircleCI

You'll need to provide 2 environment variables:

* `CIRCLECI_TOKEN` - CircleCI API Token, which can be created at [https://app.circleci.com/settings/user/tokens](https://app.circleci.com/settings/user/tokens). Make sure to copy the API token as soon as it is created. You won't be able to see it again!

<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` \[Optional] - This is optional and is required for on-prem customers only. The default value is  `"https://circleci.com"`

[Documentation](https://hub.docker.com/r/mcp/circleci)

### Cortex

You'll need to provide a Cortex personal access token to enable this MCP:

1. Log in to your Cortex instance.
2. From the left-hand menu, go to *Settings → My access tokens*.
3. Click *Create new token*.
4. Enter a name for the token and description.
5. Click *Create token* and copy the token.

When using this MCP, make sure Devin is configured with the correct Cortex API URL (defaults to `https://api.getcortexapp.com`).

[Documentation](https://docs.cortex.io/get-started/mcp)

### Square

You'll need to provide an authorization header which follows the format `Bearer <TOKEN>`, where `<TOKEN>` is your Square access token. More info at: [https://developer.squareup.com/docs/build-basics/access-tokens](https://developer.squareup.com/docs/build-basics/access-tokens)

[Documentation](https://developer.squareup.com/docs/mcp)

### Hubspot

You'll need to provide an access token as an environment variable. To get your access token:

1. Create a private app in HubSpot:
2. Go to Settings > Integrations > Private Apps
3. Click "Create private app"
4. Name your app and set required scopes
5. Click "Create app"
6. Copy the generated access token from the "Auth" tab

[Documentation](https://www.npmjs.com/package/@hubspot/mcp-server)

### Redis

Required credentials:

* Redis host
* Redis port
* Redis username
* Redis password

[Documentation](https://redis.io/docs/latest/integrate/redis-mcp/client-conf/)

### Google Maps

You'll need to (1) provide an API key (2) enable the individual APIs you'd like Devin to have access to.

To get your API key, navigate to [https://console.cloud.google.com/apis/credentials](https://console.cloud.google.com/apis/credentials) and open the sidebar > APIs and services > Credentials.

To enable an individual API, search for the API and click 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>

[Documentation](https://www.npmjs.com/package/@modelcontextprotocol/server-google-maps)

### Playwright

No environment variables needed for this! Simply enable the integration.

[Documentation](https://hub.docker.com/r/mcp/playwright)

### Firecrawl

You’ll need to provide an API Key (`FIRECRAWL_API_KEY`), which you can view and create at [https://www.firecrawl.dev/app/api-keys](https://www.firecrawl.dev/app/api-keys).

[Documentation](https://hub.docker.com/r/mcp/firecrawl#use-this-mcp-server)

### ElasticSearch

You’ll need to provide 2 environment variables:

* `ES_URL` - ElasticSearch URL or endpoint, which can be found on the /overview page in Elasticsearch.
* `ES_API_KEY` - ElasticSearch API key, which can be created on the `/indices/index_details/<name>/data` page in 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` is an optional environment variable. When set to `true` , it skips SSL/TLS certificate verification when connecting to Elasticsearch.

[Documentation](https://hub.docker.com/r/mcp/elasticsearch)

### Postgres

The only credential needed is the Postgres connection string.

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

### Plaid

The only credential required is an Oauth bearer access token that can be obtained by running the following code:

```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"
}'
```

To obtain the client ID and client production secret, go to [https://dashboard.plaid.com/developers/keys](https://dashboard.plaid.com/developers/keys)

[Documentation](https://plaid.com/docs/resources/mcp/)

### Replicate

The only required credential is the API token which can be found at [https://replicate.com/account/api-tokens](https://replicate.com/account/api-tokens)

[Documentation](https://replicate.com/docs/reference/mcp)

### Grafana

You'll need to provide 2 environment variables:

* Grafana URL
* Grafana service account token: To obtain the token, in the sidebar, go to Administration > Users and access > Service accounts > Add service account (if you don’t already have one added) > 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>

### Pinecone

NOTE: The Pinecone MCP supports only indexes with integrated embedding. Indexes for vectors you create with external embedding models are not yet supported as of 7/16/25.

The only credential required is the Pinecone API key, which can be obtained via the API keys page in the Pinecone dashboard as seen below:

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

### Snyk

1. First, configure the MCP server. Documentation is available [here](https://docs.snyk.io/integrations/developer-guardrails-for-agentic-workflows/quickstart-guides-for-mcp/devin-guide). Note: Make sure to add a env variable at the bottom (not listed in documentation guide).
   <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. Install the Snyk CLI on Devin's machine. Documentation is available [here](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
```

Note: some Snyk tests require trust to operate - install on machine after homebrew is installed. Documentation is available [here](https://docs.snyk.io/integrations/developer-guardrails-for-agentic-workflows/troubleshooting-for-the-snyk-mcp-server#folder-trust).

**Tip**:
If configured correctly - the full list of Snyk scans should run on the first pass. However, depending on Framework, some scans require an “unmanaged: true” flag (ex: C++) to be passed. Currently you can set this in knowledge or during your Devin session - here’s an example:

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

**Tip**: We've written an [example playbook](https://app.devin.ai/settings/playbooks/163db5ecab7e47e6a82c71bf8d338678) to help you get started.

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