> ## 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 es un protocolo abierto que permite que Devin utilice cientos de herramientas externas y fuentes de datos. Devin admite 3 métodos de transporte (stdio, SSE y HTTP).

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

Con MCP, Devin puede ayudarte a:

* explorar registros de Sentry, Datadog y Vercel
* [usar Devin como analista de datos](https://devin.ai/ai-data-analyst-1) en Slack con MCPs de bases de datos
* investigar problemas en SonarQube, CircleCI y Jam
* crear en lote tickets en Linear, documentos en Notion, Google Docs (a través de Zapier) y más
* obtener contexto de e interactuar con Airtable, Stripe y Hubspot
* ¡mucho más!

<div id="get-started-with-mcps">
  ## Primeros pasos con los MCP
</div>

Ve a [Settings > Connections > servidores MCP](https://app.devin.ai/settings/connections?tab=mcps) para explorar y activar MCPs.

<CardGroup cols={2}>
  <Card title="Usa Devin para el análisis de datos en Slack conectándolo a MCPs de base de datos" icon="chart-simple" href="https://devin.ai/ai-data-analyst-1/">
    ¡Consulta nuestra guía paso a paso!
  </Card>

  <Card title="Explorar casos de uso con MCP" icon="grid-2" href="/es/use-cases/gallery/index">
    Explora ejemplos prácticos de Devin con MCPs como Datadog, Sentry, Linear, Figma y más.
  </Card>
</CardGroup>

<div id="configuration-tips">
  ## Consejos de configuración
</div>

<Note>
  Para los MCP que se autentican con OAuth, Devin te pedirá que visites una URL para conectar tu cuenta. **Recomendamos encarecidamente usar una cuenta de servicio**, y no tu cuenta personal, ya que el acceso se compartirá dentro de tu organización.
</Note>

<Note>
  ¿No ves el MCP que estás buscando? Los Admin de la organización pueden agregar cualquier servidor MCP con el botón **Add a custom MCP**. Si no tienes permisos de admin, usa **Suggest MCP Integration** para solicitarlo.

  ¿Tienes problemas? Contáctanos a través de nuestra [página de soporte](https://app.devin.ai/settings/support) o en [support@cognition.ai](mailto:support@cognition.ai).
</Note>

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

Si el MCP que necesitas no está en el marketplace, los Admin de la organización pueden agregar cualquier servidor MCP usando el botón **Add a custom MCP**. Devin es compatible con tres tipos de transporte para servidores personalizados:

<Note>
  Agregar servidores MCP personalizados requiere el permiso **servidor MCP**. Si no ves el botón **Add a custom MCP**, contacta a tu Admin de la organización o usa la opción **Suggest MCP Integration** para solicitar un nuevo servidor.
</Note>

| Transporte | Mejor para                                                       | Campos obligatorios                       |
| ---------- | ---------------------------------------------------------------- | ----------------------------------------- |
| **STDIO**  | Servidores locales basados en CLI (p. ej., `npx`, `uvx`, Docker) | Comando, argumentos, variables de entorno |
| **SSE**    | Servidores remotos que utilizan Server-Sent Events               | URL del servidor, encabezados             |
| **HTTP**   | Servidores remotos que utilizan Streamable HTTP                  | URL del servidor, encabezados             |

<div id="step-by-step-adding-a-custom-mcp-server">
  ### Paso a paso: agregar un servidor MCP personalizado
</div>

1. Ve a [Settings > Connections > servidor MCP](https://app.devin.ai/settings/connections?tab=mcps).
2. Haz clic en **Add a custom MCP** en la parte superior de la página.
3. Completa los detalles del servidor:
   * **Server Name**: Un nombre descriptivo para el servidor (por ejemplo, "Internal API Gateway").
   * **Icon** (opcional): Un emoji o una URL para utilizar como ícono del servidor.
   * **Short Description**: Un breve resumen de lo que hace el servidor.
4. Selecciona el **tipo de transporte** (STDIO, SSE o HTTP).
5. Completa los campos de configuración específicos del transporte (consulta el [formato de configuración](#configuration-format) más abajo).
6. Haz clic en **Save** para crear el servidor.
7. Haz clic en **Test listing tools** para verificar la conexión. Devin creará un entorno de prueba aislado, se conectará a tu servidor e intentará descubrir las herramientas disponibles.

<Note>
  El botón **Test listing tools** está deshabilitado hasta que guardes tu configuración. Si la validación falla, revisa el mensaje de error mostrado: indicará si el problema está relacionado con la conectividad, la autenticación o un tiempo de espera.
</Note>

<div id="configuration-format">
  ### Formato de configuración
</div>

<Note>
  Los ejemplos siguientes muestran representaciones JSON de los campos de configuración de cada transporte. En la práctica, los completarás mediante el formulario web: no necesitas escribir ni pegar JSON. El formato JSON se muestra aquí para mayor claridad y como referencia para configuraciones programáticas o basadas en API.
</Note>

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

Utiliza STDIO para servidores que se ejecutan como procesos locales. Proporciona el comando para iniciar el servidor, junto con cualquier argumento y variable de entorno.

**Campos:**

* **Command** (obligatorio): El ejecutable que se debe ejecutar (por ejemplo, `npx`, `uvx`, `docker`).
* **Arguments**: Argumentos de la línea de comandos que se pasan al servidor.
* **Environment Variables**: Pares clave-valor definidos en el entorno de proceso del servidor. Úsalas para pasar API keys, tokens o valores de configuración.

**Ejemplo — servidor STDIO personalizado con `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"
  }
}
```

**Ejemplo: servidor STDIO personalizado con 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 y HTTP
</div>

Utiliza SSE o HTTP para servidores remotos accesibles a través de la red. Se recomienda HTTP (HTTP en streaming) para nuevas integraciones; SSE se admite para servidores heredados.

**Campos:**

* **Server URL** (obligatorio): La URL del endpoint del servidor MCP.
* **Authentication method**: Elige entre `None`, `Auth Header` u `OAuth`.
  * Para **Auth Header**: Proporciona la clave del encabezado (por defecto `Authorization`) y el valor del encabezado (por ejemplo, `Bearer your-token`).
  * Para **OAuth**: Devin te pedirá que completes un flujo de OAuth durante tu primera sesión.

**Ejemplo: servidor HTTP remoto con autenticación mediante token Bearer:**

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

**Ejemplo — servidor SSE remoto sin autenticación:**

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

<Tip>
  Al elegir entre SSE y HTTP, prefiere **HTTP** (HTTP con transmisión continua). SSE es un protocolo legado y se está dejando de usar en todo el ecosistema de MCP.
</Tip>

<div id="common-patterns">
  ## Patrones comunes
</div>

<div id="connecting-to-an-internal-api">
  ### Conexión a una API interna
</div>

Expón tu API interna como un servidor MCP para que Devin pueda consultarla directamente. Usa el transporte STDIO con un adaptador que traduzca las llamadas a herramientas MCP en solicitudes a la 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"
  }
}
```

Como alternativa, si tu API interna es accesible a través de la red, usa el 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">
  ### Conexión a una base de datos
</div>

Usa un servidor MCP de base de datos para otorgar a Devin acceso de lectura o escritura a tus datos. Existen muchos servidores mantenidos por la comunidad para las bases de datos más comunes.

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

<Note>
  En bases de datos de producción, utiliza una cadena de conexión de **solo lectura** o un usuario de base de datos con permisos restringidos. Devin ejecuta consultas basadas en las instrucciones del usuario, por lo que es importante configurar adecuadamente el nivel de acceso.
</Note>

<div id="connecting-to-a-custom-tool-or-script">
  ### Conectar una herramienta o script personalizado
</div>

Envuelve cualquier herramienta de línea de comandos (CLI) o script como un servidor MCP. Por ejemplo, un servidor basado en Python usando `uvx`:

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

O un servidor basado en Docker para ejecuciones aisladas:

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

<div id="using-environment-variables-for-secrets">
  ### Uso de variables de entorno para secretos
</div>

Pasa valores confidenciales mediante variables de entorno en lugar de codificarlos de forma fija en los argumentos. La funcionalidad de [Secrets](/es/product-guides/secrets) de Devin puede administrar estos valores: guarda tus API keys o tokens como secretos y luego haz referencia a ellos en la configuración de tu servidor MCP.

<div id="troubleshooting-custom-mcp-servers">
  ## Solución de problemas en servidores MCP personalizados
</div>

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

| Symptom                                                 | Likely cause                                                       | Fix                                                                                                                                                       |
| ------------------------------------------------------- | ------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
| "Verify server URL and network connectivity"            | La URL del servidor no es accesible                                | Verifica que la URL sea correcta y accesible desde Internet (o desde la red de Devin si usas una VPN)                                                     |
| "Check authentication credentials and permissions"      | Credenciales de autenticación no válidas o faltantes               | Verifica tu API key, token o configuración de OAuth                                                                                                       |
| "Server took too long to respond - check server status" | El servidor no respondió dentro del tiempo de espera               | Asegúrate de que el servidor esté en ejecución y respondiendo; revisa si hay reglas de firewall que bloqueen la conexión                                  |
| "MCP server validation failed" (generic)                | Comando no encontrado, dependencias faltantes o caída del servidor | Para servidores STDIO, verifica que el comando exista y se ejecute localmente; comprueba que todas las variables de entorno requeridas estén configuradas |

<div id="server-connects-but-tools-arent-available">
  ### El servidor se conecta pero las herramientas no están disponibles
</div>

* Verifica que el servidor implemente correctamente el método `tools/list` del protocolo MCP.
* Para servidores STDIO, asegúrate de que el proceso escriba mensajes JSON-RPC válidos en stdout y lea desde stdin — el registro o la salida de depuración en stdout romperá el protocolo.
* Comprueba que las variables de entorno estén configuradas correctamente. La falta de valores (por ejemplo, una API key en blanco) puede hacer que el servidor se inicie pero falle al registrar herramientas.

<div id="oauth-authentication-issues">
  ### Problemas de autenticación OAuth
</div>

* Cuando se solicite la autenticación, completa el flujo de OAuth en la ventana del navegador que se abra. Devin esperará el callback.
* Si la autenticación falla, comprueba que el URI de redirección de OAuth esté configurado correctamente en el proveedor.
* Solo los usuarios con el permiso **servidor MCP** pueden autenticar servidores MCP basados en OAuth. Si aparece un error de permisos, ponte en contacto con el administrador de la organización.

<Note>
  Para los MCP basados en OAuth, **usa una cuenta de servicio** en lugar de una cuenta personal. El acceso se comparte en toda la organización y las sesiones de todos los miembros usarán la misma conexión autenticada.
</Note>

<div id="general-debugging-tips">
  ### Consejos generales de depuración
</div>

* **Comprueba primero el servidor de forma local.** Antes de añadir un servidor personalizado a Devin, verifica que funcione ejecutando el comando o accediendo a la URL desde tu propia máquina.
* **Revisa los registros de sesión de Devin.** Si un servidor falla durante una sesión, Devin registrará el error. Busca mensajes relacionados con MCP en la salida de la sesión.
* **Simplifica e itera.** Comienza con la configuración mínima (por ejemplo, sin autenticación, ajustes predeterminados) y añade complejidad una vez que la conexión básica funcione.
* **Verifica las variables de entorno.** Un problema habitual son las variables de entorno que faltan o están mal definidas. Vuelve a comprobar que cada variable requerida esté establecida en la configuración.

<Tip>
  Si estás creando tu propio servidor MCP, la [especificación de Model Context Protocol](https://modelcontextprotocol.io/introduction) contiene documentación detallada sobre el protocolo, los tipos de transporte y las definiciones de herramientas.
</Tip>

***

<div id="marketplace-mcps">
  ## MCP del marketplace
</div>

A continuación se muestran los detalles de configuración de MCP específicos disponibles en el marketplace.

<div id="vercel-atlassian-notion-sentry-neon-asana-jam-and-many-more">
  ### Vercel, Atlassian, Notion, Sentry, Neon, Asana, Jam y muchos más
</div>

Muchos MCPs en nuestro marketplace se pueden habilitar sin necesidad de configuración, con un solo clic!

Solo haz clic en "Enable". Se te pedirá conectar una cuenta de servicio durante tu sesión con Devin o cuando hagas clic en "Test listing tools".

Los MCPs disponibles incluyen:

* 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
* ¡Y más a continuación!

<Note>
  **Linear**: Si tienes la [integración de Linear](/es/integrations/linear) conectada, Devin ya dispone de herramientas nativas de Linear y no necesitas configurar por separado el MCP de Linear.
</Note>

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

Este es el servidor MCP remoto oficial de Datadog. Cuando lo habilites desde el marketplace, se te pedirá que te autentiques con tu cuenta de Datadog mediante OAuth.

También tendrás que seleccionar tu sitio o región de Datadog (p. ej., US1, US3, US5, EU, AP1, AP2, US1-FED) al habilitar el MCP.

[Documentación](https://docs.datadoghq.com/bits_ai/mcp_server/)

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

Este es el servidor MCP remoto oficial de Slack. Cuando lo habilites desde el marketplace, se te pedirá que te autentiques con tu cuenta de Slack mediante OAuth.

Ten en cuenta que usa OAuth a nivel de usuario: si lo conectas con acceso para toda la organización, todos los miembros de la organización comparten la misma identidad de usuario, así que recomendamos usar acceso personal.

[Documentación](https://docs.slack.dev/ai/slack-mcp-server)

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

Necesitarás proporcionar un token de acceso personal, que puedes encontrar y crear en [https://supabase.com/dashboard/account/tokens](https://supabase.com/dashboard/account/tokens)

[Documentación](https://mcpservers.org/servers/supabase-community/supabase-mcp)

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

Este es el servidor MCP remoto oficial de Figma. Cuando habilites el MCP desde el marketplace, se te pedirá que te autentiques con tu cuenta de Figma mediante OAuth.

Al usar este MCP, asegúrate de enviar a Devin un enlace a tu archivo de Figma.

[Documentación](https://developers.figma.com/docs/figma-mcp-server/remote-server-installation/)

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

Deberás proporcionar un encabezado de autorización que siga el formato `Bearer <TOKEN>`, donde `<TOKEN>` es tu clave de API de Stripe. Más información en: [https://docs.stripe.com/mcp#bearer-token](https://docs.stripe.com/mcp#bearer-token)

[Documentación](https://docs.stripe.com/mcp)

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

Debes proporcionar un encabezado de autorización con el formato `Bearer <TOKEN>`.

Necesitas extraer tu token Bearer de la URL del servidor proporcionada en [https://mcp.zapier.com/mcp/servers](https://mcp.zapier.com/mcp/servers) > Connect

Tu URL de servidor tendrá un aspecto similar a: [https://mcp.zapier.com/api/mcp/s/\*\*\*\*\*/mcp](https://mcp.zapier.com/api/mcp/s/*****/mcp)

Extrae la sección con asteriscos (\*\*\*\*\*) y úsala en el encabezado de autorización que proporciones: `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>

[Documentación](https://zapier.com/mcp)

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

Debes proporcionar una clave de API de Airtable. Puedes encontrar tus claves de API en: [https://airtable.com/create/tokens](https://airtable.com/create/tokens)

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

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

Credenciales requeridas:

* Nombre de usuario de Docker Hub: Puedes obtenerlo en My Hub
* Token de acceso personal (Personal Access Token): Ve a Account settings > Personal access tokens y crea un 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>

[Documentación](https://hub.docker.com/r/mcp/dockerhub)

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

Para obtener las credenciales necesarias:

* Token de SonarQube: ve a **My Account > Security** y genera tu token de API.
* Organización de SonarQube: es tu nombre de usuario, como se muestra en la imagen a continuación.
  <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>
* URL de SonarQube:
  * Para instancias self-hosted: el formato es [http://localhost:9000](http://localhost:9000/) o [https://sonarqube.mycompany.com](https://sonarqube.mycompany.com/)
  * Para SonarCloud: usa [https://sonarcloud.io](https://sonarcloud.io/)

[Documentación](https://github.com/SonarSource/sonarqube-mcp-server)

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

Debes proporcionar un token de acceso personal (PAT), que puedes ver y crear en [https://app.netlify.com/user/applications#personal-access-tokens](https://app.netlify.com/user/applications#personal-access-tokens). Asegúrate de copiar el PAT en cuanto se cree. ¡No podrás volver a verlo!

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

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

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

Puedes obtener un token de acceso de Pulumi desde la sección Access tokens en la barra lateral del panel de control de 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>

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

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

Deberás proporcionar una clave de API, que puedes generar en [https://platform.parallel.ai/](https://platform.parallel.ai/)

[Documentación](https://docs.parallel.ai/features/remote-mcp)

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

Necesitas proporcionar una clave de API, que puedes encontrar en [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>

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

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

Deberás proporcionar 2 variables de entorno:

* `CIRCLECI_TOKEN` - Token de la API de CircleCI, que se puede crear en [https://app.circleci.com/settings/user/tokens](https://app.circleci.com/settings/user/tokens). Asegúrate de copiar el token de la API tan pronto como se cree. ¡No podrás verlo nuevamente!

<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] - Esta variable es opcional y solo se requiere para clientes on-prem. El valor predeterminado es `"https://circleci.com"`

[Documentación](https://hub.docker.com/r/mcp/circleci)

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

Debes proporcionar un token de acceso personal de Cortex para habilitar este MCP:

1. Inicia sesión en tu instancia de Cortex.
2. En el menú de la izquierda, ve a *Settings → My access tokens*.
3. Haz clic en *Create new token*.
4. Introduce un nombre y una descripción para el token.
5. Haz clic en *Create token* y copia el token.

Al usar este MCP, asegúrate de que Devin esté configurado con la URL correcta de la API de Cortex (de forma predeterminada es `https://api.getcortexapp.com`).

[Documentación](https://docs.cortex.io/get-started/mcp)

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

Debes proporcionar un encabezado de autorización con el formato `Bearer <TOKEN>`, donde `<TOKEN>` es tu token de acceso de Square. Más información en: [https://developer.squareup.com/docs/build-basics/access-tokens](https://developer.squareup.com/docs/build-basics/access-tokens)

[Documentación](https://developer.squareup.com/docs/mcp)

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

Debes proporcionar un token de acceso como variable de entorno. Para obtener tu token de acceso:

1. Crea una aplicación privada en HubSpot:
2. Ve a Settings > Integrations > Private Apps
3. Haz clic en "Create private app"
4. Asigna un nombre a tu aplicación y configura los scopes necesarios
5. Haz clic en "Create app"
6. Copia el token de acceso generado desde la pestaña "Auth"

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

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

Credenciales requeridas:

* Host de Redis
* Puerto de Redis
* Nombre de usuario de Redis
* Contraseña de Redis

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

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

Necesitas (1) proporcionar una clave de API y (2) habilitar las API individuales a las que quieras que Devin tenga acceso.

Para obtener tu clave de API, ve a [https://console.cloud.google.com/apis/credentials](https://console.cloud.google.com/apis/credentials) y abre la barra lateral > APIs and services > Credentials.

Para habilitar una API individual, busca la API y haz clic en Habilitar.

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

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

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

No se requieren variables de entorno para esto. Simplemente habilita la integración.

[Documentación](https://hub.docker.com/r/mcp/playwright)

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

Debes proporcionar una clave de API (`FIRECRAWL_API_KEY`), que puedes ver y crear en [https://www.firecrawl.dev/app/api-keys](https://www.firecrawl.dev/app/api-keys).

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

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

Deberás proporcionar 2 variables de entorno:

* `ES_URL` - URL o endpoint de ElasticSearch, que se puede encontrar en la página `/overview` en Elasticsearch.
* `ES_API_KEY` - clave de API de ElasticSearch, que se puede crear en la página `/indices/index_details/<name>/data` en 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` es una variable de entorno opcional. Cuando está configurada en `true`, omite la verificación del certificado SSL/TLS al conectarse a Elasticsearch.

[Documentación](https://hub.docker.com/r/mcp/elasticsearch)

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

La única credencial necesaria es la cadena de conexión de Postgres.

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

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

La única credencial necesaria es un token de acceso OAuth Bearer, que se puede obtener ejecutando el siguiente código:

```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 obtener el ID de cliente y el secreto de cliente de producción, ve a [https://dashboard.plaid.com/developers/keys](https://dashboard.plaid.com/developers/keys)

[Documentación](https://plaid.com/docs/resources/mcp/)

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

La única credencial necesaria es el token de API, que se puede encontrar en [https://replicate.com/account/api-tokens](https://replicate.com/account/api-tokens)

[Documentación](https://replicate.com/docs/reference/mcp)

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

Deberás proporcionar 2 variables de entorno:

* URL de Grafana
* Token de cuenta de servicio de Grafana: para obtener el token, en la barra lateral ve a Administration > Users and access > Service accounts > Add service account (si aún no tienes ninguna agregada) > 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: El MCP de Pinecone solo admite índices con embeddings integrados. Los índices para vectores que crees con modelos de embeddings externos aún no son compatibles a fecha de 16/7/25.

La única credencial necesaria es la clave de API de Pinecone, que se puede obtener en la página de claves de API del panel de control de Pinecone, como se muestra a continuación:

<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. Primero, configura el servidor MCP. La documentación está disponible [aquí](https://docs.snyk.io/integrations/developer-guardrails-for-agentic-workflows/quickstart-guides-for-mcp/devin-guide). Nota: asegúrate de añadir una variable de entorno al final (no incluida en la guía de documentación).
   <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. Instala la CLI de Snyk en la máquina de Devin. La documentación está disponible [aquí](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
```

Nota: algunas pruebas de Snyk requieren establecer confianza para funcionar; instala Snyk en la máquina después de haber instalado Homebrew. La documentación está disponible [aquí](https://docs.snyk.io/integrations/developer-guardrails-for-agentic-workflows/troubleshooting-for-the-snyk-mcp-server#folder-trust).

**Consejo**:
Si se configura correctamente, la lista completa de análisis de Snyk debería ejecutarse en la primera pasada. Sin embargo, según el framework, algunos análisis requieren que se pase un flag `unmanaged: true` (por ejemplo, C++). Actualmente puedes establecer esto en Knowledge o durante tu sesión con Devin; aquí tienes un ejemplo:

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

**Consejo**: Hemos escrito un [playbook de ejemplo](https://app.devin.ai/settings/playbooks/163db5ecab7e47e6a82c71bf8d338678) para ayudarte a comenzar.

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