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

# Model Context Protocol (MCP)

> Configurez des serveurs MCP pour étendre Cascade avec des outils et des services personnalisés, en utilisant les transports stdio, HTTP ou SSE, avec des contrôles d’administration pour Teams et Enterprise.

**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 utiliser les outils qu’ils exposent.
Cascade s’intègre désormais nativement à MCP, ce qui vous permet d’utiliser votre propre sélection de serveurs MCP avec Cascade.
Consultez la [documentation officielle de MCP](https://modelcontextprotocol.io/) pour en savoir plus.

<Note>Les utilisateurs Enterprise doivent l’activer manuellement dans les paramètres</Note>

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

Vous pouvez ajouter de nouveaux plugins MCP via `Settings` > `Tools` > `Windsurf Settings` > `Add Server`.

Si vous ne trouvez pas le plugin MCP souhaité, vous pouvez l’ajouter manuellement en cliquant sur le bouton `View Raw Config` et en modifiant directement le fichier `mcp_config.json`.

Quand vous sélectionnez un serveur MCP, cliquez simplement sur `+ Add Server` pour exposer le serveur et ses outils à Cascade.

<Frame>
  <img src="https://mintcdn.com/codeium/d8O4q6w3H2CjrirL/assets/plugins/mcp-server-templates.jpg?fit=max&auto=format&n=d8O4q6w3H2CjrirL&q=85&s=06f96424bd8374333d6969006868456e" width="1666" height="1388" data-path="assets/plugins/mcp-server-templates.jpg" />
</Frame>

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

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

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

<Note>Assurez-vous d’appuyer sur le bouton d’actualisation après avoir ajouté un nouveau plugin MCP.</Note>

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

Le fichier `~/.codeium/mcp_config.json` est un fichier JSON qui répertorie les 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": "<VOTRE_TOKEN_D_ACCES_PERSONNEL>"
      }
    }
  }
}
```

Veillez à fournir les arguments requis et les variables d’environnement pour les serveurs que vous souhaitez utiliser.

Consultez le [référentiel officiel des serveurs MCP](https://github.com/modelcontextprotocol/servers) ou [OpenTools](https://opentools.com/) pour des exemples de serveurs.

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

Il est important de noter que, pour les MCP HTTP distants, la configuration diffère légèrement et requiert un champ `serverUrl` ou `url`.

Voici un exemple de configuration pour un serveur HTTP :

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

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

Le fichier `~/.codeium/mcp_config.json` gère l’interpolation des
variables d’environnement pour les champs suivants : `command`, `args`, `env`, `serverUrl`, `url` et
`headers`.

Voici un exemple de configuration qui utilise une variable d’environnement `AUTH_TOKEN`
dans `headers`.

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

<div id="admin-controls-teams-enterprises">
  ## Contrôles d'administration (Teams & Enterprises)
</div>

Les administrateurs d'équipe peuvent activer ou désactiver l'accès MCP pour leur équipe, ainsi que définir une liste de serveurs MCP approuvés que leur équipe est autorisée à utiliser :

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

<Warning>Le lien ci-dessus ne fonctionnera que si vous disposez de privilèges d'administrateur pour votre équipe.</Warning>

Par défaut, les utilisateurs au sein d'une équipe peuvent configurer leurs propres serveurs MCP. Cependant, dès que vous autorisez ne serait-ce qu'un seul serveur MCP, **tous les autres serveurs MCP non autorisés seront bloqués** pour votre équipe.

<div id="how-server-matching-works">
  ### Fonctionnement de la mise en correspondance des serveurs
</div>

Lorsque vous autorisez un serveur MCP, le système utilise une **correspondance par expressions régulières (regex)** selon les règles suivantes :

* **Correspondance sur la chaîne complète** : Tous les motifs sont automatiquement ancrés (encapsulés avec `^(?:pattern)$`) pour éviter les correspondances partielles
* **Champ Command** : Doit correspondre exactement ou selon votre motif regex
* **Tableau d’arguments** : Chaque argument est évalué individuellement par rapport à son motif correspondant
* **Longueur du tableau** : Le nombre d’arguments doit correspondre exactement entre la liste d’autorisation et la configuration utilisateur
* **Caractères spéciaux** : Des caractères comme `$`, `.`, `[`, `]`, `(`, `)` ont une signification particulière en regex et doivent être échappés avec `\` si vous souhaitez une correspondance littérale

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

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

    * **Server ID** : `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 n’importe quelle configuration valide, tant que l’ID du serveur correspond à l’entrée du Plugin Store.
  </Accordion>

  <Accordion title="Option 2 : Correspondance exacte de la configuration" 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 :**

    * **Server ID** : `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 exactement cette configuration : toute divergence dans `command` ou `args` sera bloquée. La section `env` peut contenir des valeurs différentes.
  </Accordion>

  <Accordion title="Option 3 : Modèles regex flexibles" description="Utilisez des expressions régulières (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 :**

    * **Server ID** : `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` fait correspondre tout chemin de fichier Python, comme `/home/user/my_server.py`
    * La regex `[0-9]+` fait correspondre tout port numérique, comme `8080` ou `3000`
    * Les utilisateurs peuvent personnaliser les chemins de fichiers et les ports, tandis que les administrateurs veillent à ce que seuls des scripts Python soient exécutés
  </Accordion>
</AccordionGroup>

<div id="common-regex-patterns">
  ### Modèles regex courants
</div>

| Modèle          | Correspond à                | Exemple                 |
| --------------- | --------------------------- | ----------------------- |
| `.*`            | Toute chaîne                | `/home/user/script.py`  |
| `[0-9]+`        | Tout nombre                 | `8080`, `3000`          |
| `[a-zA-Z0-9_]+` | Alphanumérique + underscore | `api_key_123`           |
| `\\$HOME`       | Littéral `$HOME`            | `$HOME` (non développé) |
| `\\.py`         | Littéral `.py`              | `script.py`             |
| `\\[cli\\]`     | Littéral `[cli]`            | `mcp[cli]`              |

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

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

* **Variables d'environnement** : La section `env` n'est pas évaluée par regex et peut être configurée librement par les utilisateurs
* **Outils désactivés** : Le tableau `disabledTools` est géré séparément et n'entre pas dans la correspondance par liste blanche
* **Sensibilité à la casse** : Toutes les correspondances sont sensibles à la casse
* **Gestion des erreurs** : Les expressions régulières invalides seront journalisées et entraîneront un refus d'accès
* **Tests** : Testez soigneusement vos expressions régulières — des règles trop restrictives peuvent bloquer des cas d'utilisation légitimes

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

Si des utilisateurs signalent que leurs serveurs MCP ne fonctionnent pas après ajout à la liste autorisée :

1. **Vérifier la correspondance exacte** : Assurez-vous que le motif de la liste autorisée correspond exactement à la configuration de l’utilisateur
2. **Vérifier l’échappement des regex** : Les caractères spéciaux peuvent nécessiter un échappement (p. ex. : `\.` pour des points littéraux)
3. **Consulter les logs** : Les motifs regex invalides sont consignés avec des avertissements
4. **Tester les motifs** : Utilisez un testeur de regex pour vérifier que vos motifs fonctionnent comme prévu

Rappel : Une fois que vous autorisez un serveur, **tous les autres serveurs sont automatiquement bloqués** pour les membres de votre équipe.

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

* Étant donné que les appels d’outils MCP peuvent invoquer du code écrit par des implémenteurs de serveurs tiers, nous déclinons toute responsabilité en cas d’échec de ces appels. Pour rappel :
* Nous prenons actuellement en charge les [tools](https://modelcontextprotocol.io/docs/concepts/tools), les [resources](https://modelcontextprotocol.io/docs/concepts/resources) ainsi que les [prompts](https://modelcontextprotocol.io/docs/concepts/prompts) d’un serveur MCP.