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

# Model Context Protocol (MCP)

> Intégrez des serveurs MCP à Cascade pour accéder à des outils personnalisés comme GitHub, des bases de données et des API. Configurez les transports stdio, HTTP et SSE avec des contrôles d’administration pour les Teams.

**MCP (Model Context Protocol)** est un protocole qui permet aux LLM d’accéder à des outils et services personnalisés.
Un client MCP (Cascade, dans ce cas) peut envoyer des requêtes à des serveurs MCP pour accéder aux outils qu’ils fournissent.
Cascade s’intègre désormais nativement à MCP, ce qui vous permet d’utiliser votre propre sélection de serveurs MCP dans Cascade.
Consultez la [documentation officielle de MCP](https://modelcontextprotocol.io/) pour en savoir plus.

<Note>Les utilisateurs Enterprise doivent l’activer manuellement dans les Settings</Note>

<div id="adding-a-new-mcp">
  ## Ajouter un nouveau MCP
</div>

De nouveaux MCP peuvent être ajoutés depuis le MCP Marketplace, auquel vous accédez
en cliquant sur l’icône `MCPs` dans le menu en haut à droite du panneau Cascade, ou depuis
la section `Devin Settings` > `Cascade` > `MCP Servers`.

Si vous ne trouvez pas le MCP souhaité, vous pouvez l’ajouter manuellement en modifiant directement le fichier `mcp_config.json`.

Les MCP officiels s’affichent avec une coche bleue, indiquant qu’ils sont créés par l’entreprise à l’origine du service.

Lorsque vous cliquez sur un MCP, cliquez simplement sur `Install` pour rendre le serveur et ses outils accessibles à Cascade.

<div id="one-click-install-via-deeplink">
  ### Installation en un clic via deeplink
</div>

Devin Desktop prend en charge l'installation de MCP en un clic via des deeplinks. Vous pouvez utiliser ces liens pour ouvrir directement la page du
registre MCP dans Devin Desktop, ce qui est utile pour partager des recommandations de serveurs MCP ou intégrer des
boutons d'installation dans la documentation.

Le format du deeplink est :

```
windsurf://windsurf-mcp-registry?serverName=<server-name>
```

* **Avec `serverName`** : ouvre la page du registre MCP pour le serveur spécifié, où l’utilisateur peut le consulter et l’installer.
* **Sans `serverName`** : ouvre la page du MCP Marketplace.

Par exemple, `windsurf://windsurf-mcp-registry?serverName=github-mcp-server` ouvrira la page du registre du serveur MCP GitHub dans Devin Desktop.

<Note>Les deeplinks d’installation en un clic nécessitent que l’accès MCP soit activé pour l’équipe de l’utilisateur. Si l’accès MCP est désactivé par un administrateur, le deeplink n’ouvrira pas la page du registre.</Note>

Devin Desktop prend en charge trois [types de transport](https://modelcontextprotocol.io/docs/concepts/transports) pour les serveurs MCP : `stdio`, `Streamable HTTP` et `SSE`.

Devin Desktop prend également en charge OAuth pour chaque type de transport.

Pour les serveurs `http`, l’URL doit correspondre à celle de l’endpoint et ressembler à `https://<your-server-url>/mcp`.

<Frame>
  <img src="https://mintcdn.com/cognitionai/hxeMffzXgF_RWx-U/desktop/assets/windsurf/cascade/mcp/mcp-plugin-store.png?fit=max&auto=format&n=hxeMffzXgF_RWx-U&q=85&s=cedf7260fa823c72486f1c35faa542f0" width="955" height="774" data-path="desktop/assets/windsurf/cascade/mcp/mcp-plugin-store.png" />
</Frame>

<div id="configuring-mcp-tools">
  ## Configuration des outils MCP
</div>

Chaque MCP donne accès à un certain nombre d’outils. Cascade peut accéder à un maximum de 100 outils au total à un instant donné.

Sur la page Settings de chaque MCP, vous pouvez activer ou désactiver les outils que vous souhaitez utiliser. Pour
ouvrir les Settings d’un MCP, cliquez sur l’icône `MCPs` dans le menu en haut à droite du
panneau Cascade, puis cliquez sur le MCP souhaité.

<Frame>
  <img src="https://mintcdn.com/cognitionai/hxeMffzXgF_RWx-U/desktop/assets/windsurf/cascade/mcp/mcp-manage-plugin-tools.png?fit=max&auto=format&n=hxeMffzXgF_RWx-U&q=85&s=81513e7073b00eb6d9c53017789b08c1" width="893" height="639" data-path="desktop/assets/windsurf/cascade/mcp/mcp-manage-plugin-tools.png" />
</Frame>

<div id="mcp_configjson">
  ## mcp\_config.json
</div>

Le fichier `~/.codeium/windsurf/mcp_config.json` est un fichier JSON qui contient une liste de serveurs auxquels Cascade peut se connecter.

Voici un exemple de configuration qui définit un seul serveur pour GitHub :

```json theme={null}
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_PERSONAL_ACCESS_TOKEN>"
      }
    }
  }
}
```

Veillez à fournir les arguments requis et les variables d’environnement nécessaires aux serveurs que vous souhaitez utiliser.

Consultez le [dépôt de référence officiel des serveurs MCP](https://github.com/modelcontextprotocol/servers) ou [OpenTools](https://opentools.com/) pour voir quelques exemples de serveurs.

<div id="popular-mcp-server-examples">
  ### Exemples de serveurs MCP populaires
</div>

Vous trouverez ci-dessous des exemples de configuration pour certains serveurs MCP couramment utilisés. Vous pouvez les ajouter à votre fichier `mcp_config.json`.

<AccordionGroup>
  <Accordion title="GitHub" description="Gestion des dépôts, opérations sur les fichiers et intégration à l’API GitHub.">
    Le serveur MCP GitHub fournit des outils pour gérer les dépôts, effectuer des opérations sur les fichiers, suivre les problèmes et gérer les pull requests.

    **Avec npx :**

    ```json theme={null}
    {
      "mcpServers": {
        "github": {
          "command": "npx",
          "args": ["-y", "@modelcontextprotocol/server-github"],
          "env": {
            "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_PERSONAL_ACCESS_TOKEN>"
          }
        }
      }
    }
    ```

    **Avec Docker :**

    ```json theme={null}
    {
      "mcpServers": {
        "github": {
          "command": "docker",
          "args": [
            "run", "-i", "--rm",
            "-e", "GITHUB_PERSONAL_ACCESS_TOKEN",
            "ghcr.io/github/github-mcp-server"
          ],
          "env": {
            "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_PERSONAL_ACCESS_TOKEN>"
          }
        }
      }
    }
    ```

    Pour créer un jeton d’accès personnel, accédez à [GitHub Settings > Developer settings > Personal access tokens](https://github.com/settings/tokens).
  </Accordion>

  <Accordion title="Slack" description="Gestion des canaux et messagerie pour les espaces de travail Slack.">
    Le serveur MCP Slack permet de gérer les canaux, la messagerie et les interactions avec l’espace de travail.

    ```json theme={null}
    {
      "mcpServers": {
        "slack": {
          "command": "npx",
          "args": ["-y", "@anthropic/mcp-server-slack"],
          "env": {
            "SLACK_BOT_TOKEN": "<YOUR_SLACK_BOT_TOKEN>",
            "SLACK_TEAM_ID": "<YOUR_SLACK_TEAM_ID>"
          }
        }
      }
    }
    ```

    Pour configurer un jeton de bot Slack :

    1. Créez une application Slack sur [api.slack.com/apps](https://api.slack.com/apps)
    2. Ajoutez les scopes OAuth requis (p. ex. `channels:read`, `chat:write`, `users:read`)
    3. Installez l’application dans votre espace de travail, puis copiez le Bot User OAuth Token
  </Accordion>

  <Accordion title="PostgreSQL" description="Accès en lecture seule à la base de données avec inspection du schéma.">
    Le serveur MCP PostgreSQL fournit un accès en lecture seule aux bases de données PostgreSQL, y compris l’inspection du schéma et l’exécution de requêtes.

    ```json theme={null}
    {
      "mcpServers": {
        "postgres": {
          "command": "npx",
          "args": ["-y", "@modelcontextprotocol/server-postgres"],
          "env": {
            "POSTGRES_CONNECTION_STRING": "postgresql://user:password@localhost:5432/database"
          }
        }
      }
    }
    ```

    <Warning>Le serveur PostgreSQL fournit par défaut un accès en lecture seule pour des raisons de sécurité. Assurez-vous que votre chaîne de connexion utilise des identifiants adaptés avec des autorisations limitées.</Warning>
  </Accordion>

  <Accordion title="Filesystem" description="Opérations sécurisées sur les fichiers avec contrôles d’accès configurables.">
    Le serveur MCP Filesystem fournit un accès sécurisé aux fichiers et répertoires locaux avec des contrôles d’accès configurables.

    ```json theme={null}
    {
      "mcpServers": {
        "filesystem": {
          "command": "npx",
          "args": [
            "-y", "@modelcontextprotocol/server-filesystem",
            "/path/to/allowed/directory"
          ]
        }
      }
    }
    ```

    Vous pouvez spécifier plusieurs répertoires autorisés en ajoutant d’autres arguments de chemin. Seuls les fichiers situés dans ces répertoires seront accessibles.
  </Accordion>

  <Accordion title="Brave Search" description="Recherche sur le Web et en local via l’API Search de Brave.">
    Le serveur MCP Brave Search permet d’effectuer des recherches sur le Web via l’API Search de Brave.

    ```json theme={null}
    {
      "mcpServers": {
        "brave-search": {
          "command": "npx",
          "args": ["-y", "@anthropic/mcp-server-brave-search"],
          "env": {
            "BRAVE_API_KEY": "<YOUR_BRAVE_API_KEY>"
          }
        }
      }
    }
    ```

    Pour obtenir une clé API Brave, inscrivez-vous sur [brave.com/search/api](https://brave.com/search/api/).
  </Accordion>

  <Accordion title="Memory" description="Système de mémoire persistante basé sur un graphe de connaissances.">
    Le serveur MCP Memory fournit un système de mémoire persistante reposant sur un graphe de connaissances, ce qui permet à Cascade de conserver des informations d’une session à l’autre.

    ```json theme={null}
    {
      "mcpServers": {
        "memory": {
          "command": "npx",
          "args": ["-y", "@modelcontextprotocol/server-memory"]
        }
      }
    }
    ```

    Le serveur de mémoire stocke les données localement et les conserve d’une session à l’autre, ce qui le rend utile pour préserver le contexte des projets, des préférences et des informations apprises.
  </Accordion>
</AccordionGroup>

<div id="remote-http-mcps">
  ### MCP HTTP distants
</div>

À noter que pour les MCP HTTP distants, la configuration est légèrement
différente et nécessite un champ `serverUrl` ou `url`.

Voici un exemple de configuration pour un serveur HTTP :

```json theme={null}
{
  "mcpServers": {
    "remote-http-mcp": {
      "serverUrl": "<your-server-url>/mcp",
      "headers": {
        "API_KEY": "value"
      }
    }
  }
}
```

<div id="config-interpolation">
  ### Interpolation de configuration
</div>

Le fichier `~/.codeium/windsurf/mcp_config.json` prend en charge l’interpolation de variables
dans les champs suivants : `command`, `args`, `env`, `serverUrl`, `url` et
`headers`. Cela vous permet d’éviter de coder en dur des secrets directement dans le fichier de configuration.

Deux motifs d’interpolation sont pris en charge :

* **`${env:VAR_NAME}`** — remplacé par la valeur de la variable d’environnement `VAR_NAME`. Si la variable n’est pas définie, il est remplacé par une chaîne vide.
* **`${file:/path/to/file}`** — remplacé par le contenu du fichier au chemin indiqué, après suppression des espaces superflus en début et fin de contenu. Les chemins avec tilde (p. ex. `~/secrets/key.txt`) sont pris en charge. Si le fichier ne peut pas être lu, le motif reste inchangé.

Voici un exemple utilisant une variable d’environnement dans `headers` :

```json theme={null}
{
  "mcpServers": {
    "remote-http-mcp": {
      "serverUrl": "<your-server-url>/mcp",
      "headers": {
        "API_KEY": "Bearer ${env:AUTH_TOKEN}"
      }
    }
  }
}
```

Voici un exemple montrant comment lire une API key à partir d’un fichier :

```json theme={null}
{
  "mcpServers": {
    "my-server": {
      "command": "node",
      "args": ["server.js"],
      "env": {
        "API_KEY": "${file:~/.secrets/api_key.txt}"
      }
    }
  }
}
```

<div id="admin-controls-teams-enterprises">
  ## Contrôles d’administration (Teams et Enterprise)
</div>

Les administrateurs d’une Team peuvent activer ou désactiver l’accès MCP pour leur Team, ainsi qu’autoriser, via une liste d’autorisation, les serveurs MCP approuvés que leur Team peut utiliser :

<div id="mcp-registry">
  ### Registre MCP
</div>

Les Teams Enterprise peuvent configurer des registres MCP personnalisés pour remplacer la marketplace MCP par défaut de Devin Desktop. Les Teams peuvent associer les URL de leurs propres registres pour contrôler quels MCP sont accessibles à leurs utilisateurs.

<Note>Les registres sont l’approche privilégiée pour gérer l’accès aux MCP, même si les listes d’autorisation fonctionnent également.</Note>

<div id="configuring-custom-registries">
  #### Configuration de registres personnalisés
</div>

1. Accédez aux paramètres de votre équipe
2. Recherchez le paramètre **MCP Registry URLs**
3. Ajoutez une ou plusieurs URL de registre

Lorsque plusieurs URL de registre sont configurées, Devin Desktop utilise l’**union** de tous les registres : les utilisateurs voient les MCP de toutes les sources configurées, regroupés en un seul ensemble. Le marketplace MCP de l’équipe récupère alors les données depuis ces registres internes plutôt que depuis le registre Devin Desktop par défaut.

<Note>Les registres personnalisés doivent respecter le [schéma officiel du registre MCP](https://modelcontextprotocol.io/). Cela garantit la compatibilité et des définitions de serveur normalisées.</Note>

<div id="mcp-whitelist">
  ### Liste d’autorisation MCP
</div>

<Card title="MCP Team Settings" horizontal={true} icon="hammer" href="https://windsurf.com/team/settings">
  Paramètres MCP configurables pour votre Team.
</Card>

<Warning>Le lien ci-dessus ne fonctionnera que si vous disposez des droits d’administration pour votre Team.</Warning>

Par défaut, les utilisateurs d’une Team peuvent configurer leurs propres serveurs MCP. Cependant, dès que vous ajoutez ne serait-ce qu’un seul serveur MCP à la liste d’autorisation, **tous les serveurs qui n’y figurent pas seront bloqués** pour votre Team.

<Note>L’ID du serveur dans la liste d’autorisation doit correspondre exactement, en respectant la casse, au nom de clé utilisé dans le `mcp_config.json` de l’utilisateur.</Note>

<div id="how-server-matching-works">
  ### Comment fonctionne la correspondance des serveurs
</div>

Lorsque vous placez un serveur MCP sur la liste d’autorisation, le système utilise la **correspondance par motifs regex** selon les règles suivantes :

* **Correspondance sur l’intégralité de la chaîne** : tous les motifs sont automatiquement ancrés (entourés de `^(?:pattern)$`) afin d’empêcher les correspondances partielles
* **Champ de commande** : doit correspondre exactement ou selon votre motif regex
* **Tableau d’arguments** : chaque argument est comparé individuellement au motif correspondant
* **Longueur du tableau** : le nombre d’arguments doit correspondre exactement entre la liste d’autorisation et la configuration de l’utilisateur
* **Caractères spéciaux** : des caractères comme `$`, `.`, `[`, `]`, `(`, `)` ont une signification particulière en regex et doivent être échappés avec `\` si vous voulez une correspondance littérale

<div id="configuration-options">
  ### Options de configuration
</div>

<AccordionGroup>
  <Accordion title="Option 1 : configuration par défaut du Plugin Store (recommandée)" description="Laissez le champ Server Config (JSON) vide pour autoriser la configuration par défaut du Devin Desktop MCP Plugin Store.">
    **Configuration de la liste d’autorisation Admin :**

    * **ID du serveur :** `github-mcp-server`
    * **Server Config (JSON) :** *(laisser vide)*

    ```json theme={null}
    {}
    ```

    **Configuration utilisateur correspondante (`mcp_config.json`) :**

    ```json theme={null}
    {
      "mcpServers": {
        "github-mcp-server": {
          "command": "docker",
          "args": [
            "run",
            "-i",
            "--rm",
            "-e",
            "GITHUB_PERSONAL_ACCESS_TOKEN",
            "ghcr.io/github/github-mcp-server"
          ],
          "env": {
            "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
          }
        }
      }
    }
    ```

    Cela permet aux utilisateurs d’installer le serveur MCP GitHub avec toute configuration valide, à condition que l’ID du serveur corresponde à l’entrée du Plugin Store.
  </Accordion>

  <Accordion title="Option 2 : configuration avec correspondance exacte" description="Fournissez la configuration exacte que les utilisateurs doivent utiliser. Les utilisateurs doivent respecter cette configuration à l’identique.">
    **Configuration de la liste d’autorisation Admin :**

    * **ID du serveur :** `github-mcp-server`
    * **Server Config (JSON) :**

    ```json theme={null}
    {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "GITHUB_PERSONAL_ACCESS_TOKEN",
        "ghcr.io/github/github-mcp-server"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": ""
      }
    }
    ```

    **Configuration utilisateur correspondante (`mcp_config.json`) :**

    ```json theme={null}
    {
      "mcpServers": {
        "github-mcp-server": {
          "command": "docker",
          "args": [
            "run",
            "-i",
            "--rm",
            "-e",
            "GITHUB_PERSONAL_ACCESS_TOKEN",
            "ghcr.io/github/github-mcp-server"
          ],
          "env": {
            "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
          }
        }
      }
    }
    ```

    Les utilisateurs doivent utiliser cette configuration exacte : tout écart dans la commande ou les arguments sera bloqué. La section `env` peut contenir des valeurs différentes.
  </Accordion>

  <Accordion title="Option 3 : motifs regex flexibles" description="Utilisez des motifs regex pour autoriser des variations dans les configurations utilisateur tout en maintenant les contrôles de sécurité.">
    **Configuration de la liste d’autorisation Admin :**

    * **ID du serveur :** `python-mcp-server`
    * **Server Config (JSON) :**

    ```json theme={null}
    {
      "command": "python3",
      "args": ["/.*\\.py", "--port", "[0-9]+"]
    }
    ```

    **Configuration utilisateur correspondante (`mcp_config.json`) :**

    ```json theme={null}
    {
      "mcpServers": {
        "python-mcp-server": {
          "command": "python3",
          "args": ["/home/user/my_server.py", "--port", "8080"],
          "env": {
            "PYTHONPATH": "/home/user/mcp"
          }
        }
      }
    }
    ```

    Cet exemple offre de la flexibilité aux utilisateurs tout en maintenant la sécurité :

    * La regex `/.*\\.py` correspond à n’importe quel chemin de fichier Python, comme `/home/user/my_server.py`
    * La regex `[0-9]+` correspond à n’importe quel port numérique, comme `8080` ou `3000`
    * Les utilisateurs peuvent personnaliser les chemins de fichier et les ports, tandis que les admins s’assurent que seuls des scripts Python sont exécutés
  </Accordion>
</AccordionGroup>

<div id="common-regex-patterns">
  ### Motifs regex courants
</div>

| Pattern         | Correspond à                            | Exemple                |
| --------------- | --------------------------------------- | ---------------------- |
| `.*`            | N’importe quelle chaîne                 | `/home/user/script.py` |
| `[0-9]+`        | N’importe quel nombre                   | `8080`, `3000`         |
| `[a-zA-Z0-9_]+` | Caractères alphanumériques + underscore | `api_key_123`          |
| `\\$HOME`       | `$HOME` littéral                        | `$HOME` (non étendu)   |
| `\\.py`         | `.py` littéral                          | `script.py`            |
| `\\[cli\\]`     | `[cli]` littéral                        | `mcp[cli]`             |

<div id="notes">
  ## Notes
</div>

<div id="admin-configuration-guidelines">
  ### Consignes de configuration pour les administrateurs
</div>

* **Variables d’environnement** : la section `env` ne fait pas l’objet d’une correspondance par regex et peut être configurée librement par les utilisateurs
* **Outils désactivés** : le tableau `disabledTools` est traité séparément et ne fait pas partie de la correspondance avec la liste d’autorisation
* **Sensibilité à la casse** : toute correspondance est sensible à la casse
* **Gestion des erreurs** : les motifs regex non valides seront consignés dans les journaux et entraîneront un refus d’accès
* **Tests** : testez soigneusement vos motifs regex - des motifs trop restrictifs peuvent bloquer des cas d’usage légitimes

<div id="troubleshooting">
  ### Dépannage
</div>

Si des utilisateurs signalent que leurs serveurs MCP ne fonctionnent pas après leur ajout à la liste d’autorisation :

1. **Vérifier la correspondance exacte** : assurez-vous que le motif de la liste d’autorisation correspond exactement à la configuration de l’utilisateur
2. **Vérifier l’échappement des regex** : les caractères spéciaux peuvent devoir être échappés (p. ex., `\.` pour un point littéral)
3. **Consulter les logs** : les motifs regex non valides sont enregistrés avec un avertissement
4. **Tester les motifs** : utilisez un testeur regex pour vérifier que vos motifs fonctionnent comme prévu

N’oubliez pas : dès que vous ajoutez un serveur à la liste d’autorisation, **tous les autres serveurs sont automatiquement bloqués** pour les membres de votre Team.

<div id="general-information">
  ### Informations générales
</div>

* Comme les appels d’outils MCP peuvent invoquer du code écrit par n’importe quel implémenteur de serveur, nous déclinons toute responsabilité
  en cas d’échec des appels d’outils MCP. En d’autres termes :
* Nous prenons actuellement en charge les [outils](https://modelcontextprotocol.io/docs/concepts/tools), les [ressources](https://modelcontextprotocol.io/docs/concepts/resources) et les [prompts](https://modelcontextprotocol.io/docs/concepts/prompts) d’un serveur MCP.