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

> Intégrez des serveurs MCP avec 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 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, en l’occurrence) peut envoyer des requêtes à des serveurs MCP pour utiliser les 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 avec Cascade.
Consultez la [documentation officielle 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">
  ## Ajouter un nouveau MCP
</div>

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

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

Les MCP officiels apparaissent avec une coche bleue, indiquant qu’ils sont fournis par le service d’origine.

Quand vous cliquez sur un MCP, il suffit de cliquer sur `Install` pour rendre le serveur et ses outils accessibles à Cascade.

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

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

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

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

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

Chaque MCP dispose d’un certain nombre d’outils auxquels il peut accéder. Cascade est limitée à 100 outils au total accessibles à un instant donné.

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

<Frame>
  <img src="https://mintcdn.com/codeium/Rm_zdSOuabDsfa9L/assets/windsurf/cascade/mcp/mcp-manage-plugin-tools.png?fit=max&auto=format&n=Rm_zdSOuabDsfa9L&q=85&s=167fd87ffb6cf42228f6e62ff8cb6596" width="893" height="639" data-path="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 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 [dépôt de référence officiel des serveurs MCP](https://github.com/modelcontextprotocol/servers) ou [OpenTools](https://opentools.com/) pour des 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 de dépôts, opérations sur les fichiers et intégration à l’API GitHub.">
    Le serveur MCP GitHub fournit des outils pour la gestion de dépôts, les opérations sur les fichiers, le suivi des issues et la gestion des 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, rendez-vous sur [GitHub Settings > Developer settings > Personal access tokens](https://github.com/settings/tokens).
  </Accordion>

  <Accordion title="Slack" description="Gestion de canaux et messagerie pour les workspaces Slack.">
    Le serveur MCP Slack permet la gestion des canaux, la messagerie et les interactions avec le workspace.

    ```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 Slack App sur [api.slack.com/apps](https://api.slack.com/apps)
    2. Ajoutez les scopes OAuth nécessaires (par exemple : `channels:read`, `chat:write`, `users:read`)
    3. Installez l’app sur votre workspace et 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>Par défaut, le serveur PostgreSQL fournit un accès en lecture seule pour des raisons de sécurité. Assurez-vous que votre chaîne de connexion utilise des identifiants appropriés avec des permissions limitées.</Warning>
  </Accordion>

  <Accordion title="Filesystem" description="Opérations sur les fichiers sécurisées 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 des arguments de chemin supplémentaires. Seuls les fichiers situés dans ces répertoires seront accessibles.
  </Accordion>

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

    ```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 utilisant un graphe de connaissances, permettant à Cascade de se souvenir d’informations entre les sessions.

    ```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 entre les sessions, ce qui le rend utile pour maintenir le contexte des projets, des préférences et des informations apprises.
  </Accordion>
</AccordionGroup>

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

Il convient de noter que, pour les MCP HTTP distants, la configuration diffère légèrement
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": "<votre-url-de-serveur>/mcp",
      "headers": {
        "API_KEY": "value"
      }
    }
  }
}
```

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

Le fichier `~/.codeium/windsurf/mcp_config.json` gère l’interpolation des
variables d’environnement dans 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 qu'ajouter à la liste blanche des serveurs MCP approuvés pour que leur équipe puisse les 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 membres d'une équipe peuvent configurer leurs propres serveurs MCP. Cependant, dès que vous ajoutez ne serait-ce qu'un seul serveur MCP à la liste blanche, **tous les serveurs non autorisés seront bloqués** pour votre équipe.

<Note>L'ID de serveur dans la liste blanche 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">
  ### Fonctionnement de la correspondance de serveurs
</div>

Lorsque vous ajoutez un serveur MCP à la liste d’autorisation (whitelist), 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 comparé individuellement à 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 : Plugin Store par défaut (recommandé)" description="Laissez le champ Server Config (JSON) vide pour utiliser la configuration par défaut fournie par le 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 toute configuration valide, tant que le Server ID 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 appliquer. Les utilisateurs doivent s’y conformer strictement.">
    **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 différence dans `command` ou `args` sera bloquée. La section `env` peut contenir des valeurs différentes.
  </Accordion>

  <Accordion title="Option 3 : Modèles d’expressions régulières flexibles" description="Utilisez des expressions régulières pour autoriser des variations dans les configurations utilisateur tout en conservant des 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` correspond à n’importe quel chemin vers un 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 fichiers et les ports, tandis que les administrateurs s’assurent que seuls des scripts Python sont exécutés
  </Accordion>
</AccordionGroup>

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

| Motif           | Correspond à                | Exemple                 |
| --------------- | --------------------------- | ----------------------- |
| `.*`            | N’importe quelle chaîne     | `/home/user/script.py`  |
| `[0-9]+`        | N’importe quel 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 administrateur
</div>

* **Variables d'environnement** : La section `env` n'est pas soumise à une correspondance 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 ne fait pas partie de la correspondance par liste d’autorisation
* **Sensibilité à la casse** : Toutes les correspondances sont sensibles à la casse
* **Gestion des erreurs** : Les expressions régulières invalides seront consignées et entraîneront un refus d'accès
* **Tests** : Testez soigneusement vos expressions régulières — 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 expressions régulières** : Certains caractères spéciaux doivent être échappés (p. ex., `\.` pour un point littéral)
3. **Consulter les logs** : Les motifs d’expressions régulières invalides sont consignés avec des avertissements
4. **Tester les motifs** : Utilisez un testeur d’expressions régulières pour vérifier que vos motifs fonctionnent comme prévu

À retenir : Une fois qu’un serveur est ajouté à la liste d’autorisation, **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 exécuter du code écrit par n’importe quel implémenteur de serveur, nous déclinons toute responsabilité en cas d’échec de ces appels. Pour le rappeler :
* Nous prenons actuellement en charge les [tools](https://modelcontextprotocol.io/docs/concepts/tools), les [resources](https://modelcontextprotocol.io/docs/concepts/resources) et les [prompts](https://modelcontextprotocol.io/docs/concepts/prompts) d’un serveur MCP.