Passer au contenu principal

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.

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 pour en savoir plus.
Les utilisateurs Enterprise doivent l’activer manuellement dans les Settings

Ajouter un nouveau MCP

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 Windsurf 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. 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.
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.
Devin Desktop prend en charge trois types de transport 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.

Configuration des outils MCP

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

mcp_config.json

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 :
{
  "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 ou OpenTools pour voir quelques exemples de serveurs. Vous trouverez ci-dessous des exemples de configuration pour certains serveurs MCP couramment utilisés. Vous pouvez les ajouter à votre fichier mcp_config.json.
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 :
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_PERSONAL_ACCESS_TOKEN>"
      }
    }
  }
}
Avec Docker :
{
  "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.
Le serveur MCP Slack permet de gérer les canaux, la messagerie et les interactions avec l’espace de travail.
{
  "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
  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
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.
{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "POSTGRES_CONNECTION_STRING": "postgresql://user:password@localhost:5432/database"
      }
    }
  }
}
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.
Le serveur MCP Filesystem fournit un accès sécurisé aux fichiers et répertoires locaux avec des contrôles d’accès configurables.
{
  "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.
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.
{
  "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.

MCP HTTP distants

À 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 :
{
  "mcpServers": {
    "remote-http-mcp": {
      "serverUrl": "<your-server-url>/mcp",
      "headers": {
        "API_KEY": "value"
      }
    }
  }
}

Interpolation de configuration

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 :
{
  "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 :
{
  "mcpServers": {
    "my-server": {
      "command": "node",
      "args": ["server.js"],
      "env": {
        "API_KEY": "${file:~/.secrets/api_key.txt}"
      }
    }
  }
}

Contrôles d’administration (Teams et Enterprise)

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 :

Registre MCP

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

Configuration de registres personnalisés

  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.
Les registres personnalisés doivent respecter le schéma officiel du registre MCP. Cela garantit la compatibilité et des définitions de serveur normalisées.

Liste d’autorisation MCP

MCP Team Settings

Paramètres MCP configurables pour votre Team.
Le lien ci-dessus ne fonctionnera que si vous disposez des droits d’administration pour votre Team.
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.
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.

Comment fonctionne la correspondance des serveurs

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

Options de configuration

Configuration de la liste d’autorisation Admin :
  • ID du serveur : github-mcp-server
  • Server Config (JSON) : (laisser vide)
{}
Configuration utilisateur correspondante (mcp_config.json) :
{
  "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.
Configuration de la liste d’autorisation Admin :
  • ID du serveur : github-mcp-server
  • Server Config (JSON) :
{
  "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) :
{
  "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.
Configuration de la liste d’autorisation Admin :
  • ID du serveur : python-mcp-server
  • Server Config (JSON) :
{
  "command": "python3",
  "args": ["/.*\\.py", "--port", "[0-9]+"]
}
Configuration utilisateur correspondante (mcp_config.json) :
{
  "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

Motifs regex courants

PatternCorrespond àExemple
.*N’importe quelle chaîne/home/user/script.py
[0-9]+N’importe quel nombre8080, 3000
[a-zA-Z0-9_]+Caractères alphanumériques + underscoreapi_key_123
\\$HOME$HOME littéral$HOME (non étendu)
\\.py.py littéralscript.py
\\[cli\\][cli] littéralmcp[cli]

Notes

Consignes de configuration pour les administrateurs

  • 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

Dépannage

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.

Informations générales

  • 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, les ressources et les prompts d’un serveur MCP.