> ## 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 MCP (Model Context Protocol)

MCP est un protocole ouvert qui permet à Devin d'exploiter des centaines d'outils et de sources de données externes. Devin prend en charge 3 méthodes de transport (stdio, SSE et HTTP).

<div id="why-use-mcp">
  ## Pourquoi utiliser MCP ?
</div>

Avec MCP, Devin peut vous aider à :

* analyser les logs Sentry, Datadog et Vercel
* [utiliser Devin comme data analyst](https://devin.ai/ai-data-analyst-1) dans Slack avec des MCP de base de données
* examiner en détail les problèmes SonarQube, CircleCI et Jam
* créer en masse des tickets Linear, des documents Notion, des Google Docs (via Zapier) et plus encore
* récupérer du contexte et interagir avec Airtable, Stripe et Hubspot
* et bien plus encore !

<div id="get-started-with-mcps">
  ## Prise en main des MCP
</div>

Accédez à [Settings > Connexions > serveurs MCP](https://app.devin.ai/settings/connections?tab=mcps) pour parcourir et activer les MCP.

<CardGroup cols={2}>
  <Card title="Utilisez Devin pour l’analyse de données dans Slack en le connectant à des MCP de bases de données" icon="chart-simple" href="https://devin.ai/ai-data-analyst-1/">
    Découvrez notre guide étape par étape !
  </Card>

  <Card title="Découvrir les cas d'usage MCP" icon="grid-2" href="/fr/use-cases/gallery/index">
    Explorez des exemples pratiques de Devin avec des MCP comme Datadog, Sentry, Linear, Figma et plus encore.
  </Card>
</CardGroup>

<div id="configuration-tips">
  ## Conseils de configuration
</div>

<Note>
  Pour les MCP utilisant l'authentification OAuth, Devin vous demandera de vous rendre sur une URL pour lier votre compte. **Nous vous recommandons vivement d'utiliser un compte de service**, et non votre compte personnel, car l'accès sera partagé au sein de votre organisation.
</Note>

<Note>
  Vous ne voyez pas le MCP que vous recherchez ? Les administrateurs de l'organisation peuvent ajouter n'importe quel serveur MCP à l'aide du bouton **Ajouter un MCP personnalisé**. Si vous n'avez pas les autorisations d'administrateur, utilisez **Suggérer une intégration MCP** pour en faire la demande.

  Vous rencontrez des difficultés ? Contactez-nous via notre [page d'assistance](https://app.devin.ai/settings/support) ou à l'adresse [support@cognition.ai](mailto:support@cognition.ai).
</Note>

<div id="setting-up-a-custom-mcp-server">
  ## Configuration d'un serveur MCP personnalisé
</div>

Si le MCP dont vous avez besoin n'est pas disponible sur la marketplace, les administrateurs de l'organisation peuvent ajouter n'importe quel serveur MCP à l'aide du bouton **Ajouter un MCP personnalisé**. Devin prend en charge trois types de transport pour les serveurs personnalisés :

<Note>
  L'ajout de serveurs MCP personnalisés nécessite l'autorisation **Gérer les serveurs MCP**. Si vous ne voyez pas le bouton **Ajouter un MCP personnalisé**, contactez l'administrateur de votre organisation ou utilisez l'option **Suggérer une intégration MCP** pour demander un nouveau serveur.
</Note>

| Transport | Idéal pour                                                                        | Champs requis                                  |
| --------- | --------------------------------------------------------------------------------- | ---------------------------------------------- |
| **STDIO** | Serveurs locaux accessibles en ligne de commande (par ex. : `npx`, `uvx`, Docker) | Commande, arguments, variables d'environnement |
| **SSE**   | Serveurs distants utilisant Server-Sent Events                                    | URL du serveur, en-têtes                       |
| **HTTP**  | Serveurs distants utilisant Streamable HTTP                                       | URL du serveur, en-têtes                       |

<div id="step-by-step-adding-a-custom-mcp-server">
  ### Étapes pour ajouter un serveur MCP personnalisé
</div>

1. Accédez à [Settings > Connections > serveurs MCP](https://app.devin.ai/settings/connections?tab=mcps).
2. Cliquez sur **Ajouter un MCP personnalisé** en haut de la page.
3. Renseignez les détails du serveur :
   * **Server Name** : un nom descriptif pour le serveur (par exemple « Internal API Gateway »).
   * **Icon** (optionnel) : un emoji ou une URL à utiliser comme icône du serveur.
   * **Short Description** : un bref résumé de ce que fait le serveur.
4. Sélectionnez le **type de transport** (STDIO, SSE ou HTTP).
5. Renseignez les champs de configuration spécifiques au transport (voir [Format de configuration](#configuration-format) ci-dessous).
6. Cliquez sur **Save** pour créer le serveur.
7. Cliquez sur **Test listing tools** pour vérifier la connexion. Devin lancera un environnement de test isolé, se connectera à votre serveur et tentera de découvrir les outils disponibles.

<Note>
  Le bouton **Test listing tools** est désactivé tant que vous n’avez pas enregistré votre configuration. Si la validation échoue, vérifiez le message d’erreur affiché : il indiquera si le problème concerne la connectivité, l’authentification ou un dépassement de délai.
</Note>

<div id="configuration-format">
  ### Format de configuration
</div>

<Note>
  Les exemples ci-dessous montrent des représentations JSON des champs de configuration de chaque transport. En pratique, vous les complétez via le formulaire en ligne — vous n'avez pas besoin d'écrire ou de coller du JSON. Le format JSON est présenté ici pour plus de clarté et comme référence pour les configurations programmatiques ou via l'API.
</Note>

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

Utilisez STDIO pour les serveurs qui s’exécutent en tant que processus locaux. Vous fournissez la commande pour lancer le serveur, ainsi que les arguments et les variables d’environnement.

**Champs :**

* **Commande** (obligatoire) : l’exécutable à lancer (par exemple, `npx`, `uvx`, `docker`).
* **Arguments** : les arguments de ligne de commande transmis au serveur.
* **Variables d’environnement** : paires clé-valeur définies dans l’environnement de processus du serveur. Utilisez-les pour transmettre des clés d’API, des jetons ou des valeurs de configuration.

**Exemple — un serveur STDIO personnalisé utilisant `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"
  }
}
```

**Exemple — un serveur STDIO personnalisé utilisant 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">
  #### Transports SSE et HTTP
</div>

Utilisez SSE ou HTTP pour les serveurs distants accessibles via le réseau. HTTP (Streamable HTTP) est recommandé pour les nouvelles intégrations ; SSE est pris en charge pour les serveurs existants.

**Champs :**

* **Server URL** (obligatoire) : l’URL du point de terminaison (endpoint) du serveur MCP.
* **Authentication method** : choisissez entre `None`, `Auth Header` ou `OAuth`.
  * Pour **Auth Header** : indiquez la clé d’en-tête (par défaut `Authorization`) et la valeur de l’en-tête (par exemple, `Bearer your-token`).
  * Pour **OAuth** : Devin vous demandera de compléter un flux OAuth lors de votre première session.

**Exemple — un serveur HTTP distant avec authentification par jeton Bearer :**

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

**Exemple — un serveur SSE distant sans authentification :**

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

<Tip>
  Lorsque vous choisissez entre SSE et HTTP, privilégiez **HTTP** (HTTP diffusé en continu). SSE est un protocole historique, progressivement abandonné dans l'écosystème MCP.
</Tip>

<div id="common-patterns">
  ## Schémas courants
</div>

<div id="connecting-to-an-internal-api">
  ### Connexion à une API interne
</div>

Exposez votre API interne sous la forme d’un serveur MCP afin que Devin puisse l’interroger directement. Utilisez le transport STDIO avec un adaptateur qui traduit les appels d’outils MCP en requêtes 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"
  }
}
```

Sinon, si votre API interne est accessible via le réseau, utilisez le transport 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">
  ### Connexion à une base de données
</div>

Utilisez un serveur MCP de base de données pour accorder à Devin un accès en lecture ou en écriture à vos données. De nombreux serveurs communautaires existent pour les bases de données les plus courantes.

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

<Note>
  Pour les bases de données de production, utilisez une chaîne de connexion **en lecture seule** ou un utilisateur de base de données avec des droits restreints. Devin exécute des requêtes en fonction des instructions de l’utilisateur, il est donc important de limiter correctement les accès.
</Note>

<div id="connecting-to-a-custom-tool-or-script">
  ### Connexion à un outil ou script personnalisé
</div>

Encapsulez n'importe quel outil ou script en ligne de commande en tant que serveur MCP. Par exemple, un serveur Python utilisant `uvx` :

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

Ou un serveur Docker pour une exécution isolée :

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

<div id="using-environment-variables-for-secrets">
  ### Utilisation des variables d'environnement pour les secrets
</div>

Transmettez les valeurs sensibles via des variables d'environnement plutôt que de les coder en dur dans les arguments. La fonctionnalité [Secrets](/fr/product-guides/secrets) de Devin peut gérer ces valeurs : stockez vos clés API ou jetons en tant que secrets, puis utilisez-les dans la configuration de votre serveur MCP.

<div id="troubleshooting-custom-mcp-servers">
  ## Dépannage des serveurs MCP personnalisés
</div>

<div id="test-listing-tools-fails">
  ### Échec de "Test listing tools"
</div>

| Symptom                                                 | Cause probable                                                          | Correctif                                                                                                                                                       |
| ------------------------------------------------------- | ----------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| "Verify server URL and network connectivity"            | L’URL du serveur est injoignable                                        | Vérifiez que l’URL est correcte et accessible depuis Internet (ou depuis le réseau de Devin si vous utilisez un VPN)                                            |
| "Check authentication credentials and permissions"      | Informations d’authentification invalides ou manquantes                 | Vérifiez votre API key, votre jeton ou votre configuration OAuth                                                                                                |
| "Server took too long to respond - check server status" | Le serveur n’a pas répondu avant l’expiration du délai                  | Assurez-vous que le serveur est en cours d’exécution et réactif ; vérifiez l’absence de règles de pare-feu bloquant la connexion                                |
| "MCP server validation failed" (générique)              | Commande introuvable, dépendances manquantes ou arrêt brutal du serveur | Pour les serveurs STDIO, vérifiez que la commande existe et s’exécute localement ; assurez-vous que toutes les variables d’environnement requises sont définies |

<div id="server-connects-but-tools-arent-available">
  ### Le serveur se connecte mais les outils ne sont pas disponibles
</div>

* Vérifiez que le serveur implémente correctement la méthode `tools/list` du protocole MCP.
* Pour les serveurs STDIO, assurez-vous que le processus écrit des messages JSON-RPC valides sur stdout et lit depuis stdin — tout journal ou sortie de débogage envoyés sur stdout fera échouer le protocole.
* Vérifiez que les variables d'environnement sont correctement définies. Des valeurs manquantes (par exemple, une API key vide) peuvent permettre au serveur de démarrer mais l'empêcher d'enregistrer les outils.

<div id="oauth-authentication-issues">
  ### Problèmes d’authentification OAuth
</div>

* Lorsqu’il vous est demandé de vous authentifier, terminez le flux d’authentification OAuth dans la fenêtre de navigateur qui s’ouvre. Devin attendra le callback.
* Si l’authentification échoue, vérifiez que l’URI de redirection OAuth est correctement configurée côté fournisseur.
* Seuls les utilisateurs disposant de l’autorisation **Gérer les serveurs MCP** peuvent authentifier les serveurs MCP basés sur OAuth. Si vous voyez une erreur d’autorisation, contactez l’administrateur de votre organisation.

<Note>
  Pour les MCP basés sur OAuth, **utilisez un compte de service** plutôt que votre compte personnel. L’accès est partagé au sein de votre organisation et les sessions de tous les membres utiliseront la même connexion authentifiée.
</Note>

<div id="general-debugging-tips">
  ### Conseils généraux de débogage
</div>

* **Testez d'abord le serveur en local.** Avant d'ajouter un serveur personnalisé à Devin, vérifiez qu'il fonctionne en exécutant la commande ou en accédant à l'URL depuis votre propre machine.
* **Consultez les journaux de session de Devin.** Si un serveur échoue pendant une session, Devin consigne l'erreur. Recherchez les messages liés au MCP dans la sortie de la session.
* **Simplifiez et itérez.** Commencez avec la configuration minimale (par exemple, sans authentification, paramètres par défaut) et ajoutez de la complexité une fois que la connexion de base fonctionne.
* **Vérifiez les variables d'environnement.** Un problème courant est l'absence ou le nommage incorrect de variables d'environnement. Vérifiez soigneusement que chaque variable requise est définie dans la configuration.

<Tip>
  Si vous créez votre propre serveur MCP, la [spécification Model Context Protocol](https://modelcontextprotocol.io/introduction) fournit une documentation détaillée sur le protocole, les types de transport et les définitions d'outils.
</Tip>

***

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

Vous trouverez ci-dessous les détails de configuration de certains MCP disponibles sur le Marketplace.

<div id="vercel-atlassian-notion-sentry-neon-asana-jam-and-many-more">
  ### Vercel, Atlassian, Notion, Sentry, Neon, Asana, Jam et bien d'autres
</div>

De nombreux MCP dans notre marketplace peuvent être activés sans configuration, en un clic !

Cliquez simplement sur « Enable ». Il vous sera demandé de connecter un compte de service pendant votre session Devin ou lorsque vous cliquerez sur « Test listing tools ».

Les MCP disponibles comprennent :

* 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
* Et bien d'autres ci-dessous !

<Note>
  **Linear** : Si vous avez l'[intégration Linear](/fr/integrations/linear) connectée, Devin dispose déjà d'outils Linear natifs et vous n'avez pas besoin de configurer séparément le MCP Linear.
</Note>

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

Il s’agit du serveur MCP distant officiel de Datadog. Lorsque vous l’activez depuis le marketplace, vous serez invité à vous authentifier avec votre compte Datadog via OAuth.

Vous devrez également sélectionner votre site/région Datadog (par ex. US1, US3, US5, EU, AP1, AP2, US1-FED) lors de l’activation du MCP.

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

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

Il s'agit du serveur MCP distant officiel de Slack. Lorsque vous l'activez depuis la marketplace, vous serez invité à vous authentifier avec votre compte Slack via OAuth.

Notez qu'il utilise OAuth au niveau utilisateur : s'il est connecté avec un accès à l'échelle de l'organisation, tous les membres de l'organisation partagent la même identité utilisateur. Nous vous recommandons donc d'utiliser un accès personnel.

[Documentation](https://docs.slack.dev/ai/slack-mcp-server)

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

Vous devrez fournir un token d'accès personnel, que vous pouvez générer ou récupérer à l'adresse [https://supabase.com/dashboard/account/tokens](https://supabase.com/dashboard/account/tokens)

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

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

Il s'agit du serveur MCP distant officiel de Figma. Lorsque vous activez le MCP depuis le marketplace, vous serez invité à vous authentifier avec votre compte Figma via OAuth.

Lorsque vous utilisez ce MCP, veillez à envoyer à Devin un lien vers votre fichier Figma.

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

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

Vous devez fournir un en-tête d’autorisation au format `Bearer <TOKEN>`, dans lequel `<TOKEN>` correspond à votre clé d’API Stripe. Plus d’informations sur : [https://docs.stripe.com/mcp#bearer-token](https://docs.stripe.com/mcp#bearer-token)

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

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

Vous devez fournir un en-tête d’autorisation au format `Bearer <TOKEN>`.

Vous devez extraire votre jeton Bearer à partir de l’URL de serveur indiquée sur [https://mcp.zapier.com/mcp/servers](https://mcp.zapier.com/mcp/servers) > Connect

Votre URL de serveur aura la forme suivante : [https://mcp.zapier.com/api/mcp/s/\*\*\*\*\*/mcp](https://mcp.zapier.com/api/mcp/s/*****/mcp)

Extrayez la partie indiquée par des astérisques (\*\*\*\*\*) et utilisez-la dans l’en-tête d’autorisation que vous fournissez : `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>

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

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

Vous devrez fournir une clé API Airtable. Vous pouvez trouver vos clés API à l’adresse suivante : [https://airtable.com/create/tokens](https://airtable.com/create/tokens)

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

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

Identifiants requis :

* Nom d’utilisateur Docker Hub : vous pouvez l’obtenir depuis My Hub
* Jeton d’accès personnel : accédez à Account settings > Personal access tokens et créez un jeton
  <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>

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

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

Pour obtenir les identifiants requis :

* SonarQube token : allez dans My Account > Security et générez votre jeton d’API
* SonarQube org : il s’agit de votre nom d’utilisateur, comme illustré dans l’image ci-dessous
  <Frame>
    <img src="https://mintcdn.com/cognitionai-enterprise/A1NrXl_1--Cgx5nh/images/sonarqubemcp.png?fit=max&auto=format&n=A1NrXl_1--Cgx5nh&q=85&s=e5054e50938f9c50e35ecb01b5336ffd" alt="Devin" width="1836" height="652" data-path="images/sonarqubemcp.png" />
  </Frame>
* SonarQube URL :
  * Pour une instance auto-hébergée : l’URL est de la forme [http://localhost:9000](http://localhost:9000/) OU [https://sonarqube.mycompany.com](https://sonarqube.mycompany.com/)
  * Pour SonarCloud : utilisez [https://sonarcloud.io](https://sonarcloud.io/)

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

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

Vous devrez fournir un jeton d’accès personnel, que vous pouvez afficher et créer à l’adresse [https://app.netlify.com/user/applications#personal-access-tokens](https://app.netlify.com/user/applications#personal-access-tokens). Assurez-vous de copier le PAT dès qu’il est créé. Vous ne pourrez plus l’afficher par la suite !

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

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

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

Vous pouvez obtenir un jeton d'accès Pulumi depuis la section « Access tokens » dans la barre latérale du tableau de bord 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>

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

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

Vous devrez fournir une clé API, que vous pouvez générer sur [https://platform.parallel.ai/](https://platform.parallel.ai/)

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

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

Vous devrez fournir une clé API, que vous pouvez récupérer sur [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>

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

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

Vous devrez fournir 2 variables d'environnement :

* `CIRCLECI_TOKEN` - Jeton d'API CircleCI, qui peut être créé à l'adresse [https://app.circleci.com/settings/user/tokens](https://app.circleci.com/settings/user/tokens). Assurez-vous de copier le jeton d'API dès sa création. Vous ne pourrez plus l'afficher par la suite !

<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` \[Optionnel] - Variable facultative, requise uniquement pour les clients on-premises. La valeur par défaut est `"https://circleci.com"`

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

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

Vous devez fournir un jeton d'accès personnel Cortex pour activer ce MCP :

1. Connectez-vous à votre instance Cortex.
2. Dans le menu de gauche, accédez à *Settings → My access tokens*.
3. Cliquez sur *Create new token*.
4. Saisissez un nom et une description pour le jeton.
5. Cliquez sur *Create token* et copiez le jeton.

Lorsque vous utilisez ce MCP, assurez-vous que Devin est configuré avec l’URL correcte de l’API Cortex (par défaut `https://api.getcortexapp.com`).

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

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

Vous devrez fournir un en-tête d’autorisation suivant le format `Bearer <TOKEN>`, où `<TOKEN>` est votre jeton d’accès Square. Plus d’informations sur : [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)

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

Vous devez fournir un jeton d’accès comme variable d’environnement. Pour obtenir votre jeton d’accès :

1. Créez une application privée dans HubSpot :
2. Accédez à Settings > Integrations > Private Apps
3. Cliquez sur « Create private app »
4. Nommez votre application et définissez les autorisations requises
5. Cliquez sur « Create app »
6. Copiez le jeton d’accès généré depuis l’onglet « Auth »

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

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

Identifiants requis :

* Hôte Redis
* Port Redis
* Nom d’utilisateur Redis
* Mot de passe Redis

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

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

Vous devrez (1) fournir une clé d’API et (2) activer individuellement les API auxquelles vous souhaitez que Devin ait accès.

Pour obtenir votre clé d’API, accédez à [https://console.cloud.google.com/apis/credentials](https://console.cloud.google.com/apis/credentials) puis ouvrez le menu latéral > APIs and services > Credentials.

Pour activer une API, recherchez-la puis cliquez sur « Enable ».

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

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

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

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

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

Aucune variable d'environnement n'est requise pour cela ! Il suffit d'activer l'intégration.

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

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

Vous devez fournir une clé d’API (`FIRECRAWL_API_KEY`), que vous pouvez consulter et créer à l’adresse [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)

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

Vous devez fournir deux variables d’environnement :

* `ES_URL` - URL ou endpoint ElasticSearch, que vous trouverez sur la page `/overview` dans Elasticsearch.
* `ES_API_KEY` - clé d’API ElasticSearch, que vous pouvez créer sur la page `/indices/index_details/<name>/data` dans 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` est une variable d’environnement facultative. Lorsqu’elle est définie sur `true`, la vérification du certificat SSL/TLS est ignorée lors de la connexion à Elasticsearch.

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

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

Le seul identifiant requis est la chaîne de connexion Postgres.

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

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

Le seul identifiant requis est un jeton d’accès OAuth Bearer, que vous pouvez obtenir en exécutant le code suivant :

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

Pour obtenir l'ID client et le secret client de production, rendez-vous sur [https://dashboard.plaid.com/developers/keys](https://dashboard.plaid.com/developers/keys)

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

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

La seule information d’authentification requise est le jeton API, que vous pouvez trouver à l’adresse [https://replicate.com/account/api-tokens](https://replicate.com/account/api-tokens)

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

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

Vous devrez fournir deux variables d'environnement :

* URL de Grafana
* Jeton de compte de service Grafana : pour obtenir ce jeton, dans la barre latérale, accédez à Administration > Users and access > Service accounts > Add service account (si vous n'en avez pas déjà un) > 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>

REMARQUE : le MCP Pinecone ne prend en charge que les index avec `embeddings` intégrés. Les index pour les vecteurs que vous créez avec des modèles d’`embeddings` externes ne sont pas encore pris en charge au 16/07/25.

La seule donnée d’authentification requise est la clé API Pinecone, qui peut être obtenue via la page des clés API dans le tableau de bord Pinecone, comme illustré ci-dessous :

<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. Commencez par configurer le serveur MCP. La documentation est disponible [ici](https://docs.snyk.io/integrations/developer-guardrails-for-agentic-workflows/quickstart-guides-for-mcp/devin-guide). Remarque : assurez-vous d'ajouter une variable d'environnement à la fin (elle ne figure pas dans le guide de documentation).
   <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. Installez le CLI Snyk sur la machine de Devin. La documentation est disponible [ici](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
```

Remarque : certains tests Snyk nécessitent une approbation pour pouvoir s’exécuter — installez-les sur la machine après l’installation de Homebrew. La documentation est disponible [ici](https://docs.snyk.io/integrations/developer-guardrails-for-agentic-workflows/troubleshooting-for-the-snyk-mcp-server#folder-trust).

**Conseil** :
Si la configuration est correcte, la liste complète des analyses Snyk doit s’exécuter dès le premier passage. Toutefois, selon le framework, certaines analyses nécessitent qu’un paramètre `unmanaged: true` (par ex. C++) soit transmis. Vous pouvez actuellement le définir dans Knowledge ou pendant votre session Devin — voici un exemple :

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

**Conseil** : Nous avons rédigé un [playbook d’exemple](https://app.devin.ai/settings/playbooks/163db5ecab7e47e6a82c71bf8d338678) pour vous aider à démarrer.

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