Passer au contenu principal
Claude Code peut se connecter à des centaines d’outils externes et de sources de données via le Model Context Protocol (MCP), une norme ouverte pour les intégrations IA-outils. Les serveurs MCP donnent à Claude Code accès à vos outils, bases de données et API.

​
Ce que vous pouvez faire avec MCP

Avec les serveurs MCP connectés, vous pouvez demander à Claude Code de :
  • Implémenter des fonctionnalités à partir de suivi de problèmes : « Ajouter la fonctionnalité décrite dans le problème JIRA ENG-4521 et créer une PR sur GitHub. »
  • Analyser les données de surveillance : « Vérifier Sentry et Statsig pour vérifier l’utilisation de la fonctionnalité décrite dans ENG-4521. »
  • Interroger les bases de données : « Trouver les e-mails de 10 utilisateurs aléatoires qui ont utilisé la fonctionnalité ENG-4521, en fonction de notre base de données Postgres. »
  • Intégrer les conceptions : « Mettre à jour notre modèle d’e-mail standard en fonction des nouvelles conceptions Figma qui ont été publiées sur Slack »
  • Automatiser les flux de travail : « Créer des brouillons Gmail invitant ces 10 utilisateurs à une session de rétroaction sur la nouvelle fonctionnalité. »

​
Serveurs MCP populaires

Voici quelques serveurs MCP couramment utilisés que vous pouvez connecter à Claude Code :
Utilisez les serveurs MCP tiers à vos propres risques - Anthropic n’a pas vérifié l’exactitude ou la sécurité de tous ces serveurs. Assurez-vous que vous faites confiance aux serveurs MCP que vous installez. Soyez particulièrement prudent lors de l’utilisation de serveurs MCP qui pourraient récupérer du contenu non approuvé, car ceux-ci peuvent vous exposer à un risque d’injection de prompt.
Besoin d’une intégration spécifique ? Trouvez des centaines d’autres serveurs MCP sur GitHub, ou créez le vôtre en utilisant le SDK MCP.

​
Installation des serveurs MCP

Les serveurs MCP peuvent être configurés de trois façons différentes selon vos besoins :

​
Option 1 : Ajouter un serveur HTTP distant

Les serveurs HTTP sont l’option recommandée pour se connecter aux serveurs MCP distants. C’est le transport le plus largement supporté pour les services basés sur le cloud. 
# Syntaxe de base
claude mcp add --transport http <name> <url>

# Exemple réel : Se connecter à Notion
claude mcp add --transport http notion https://mcp.notion.com/mcp

# Exemple avec jeton Bearer
claude mcp add --transport http secure-api https://api.example.com/mcp \
  --header "Authorization: Bearer your-token"

​
Option 2 : Ajouter un serveur SSE distant

Le transport SSE (Server-Sent Events) est déprécié. Utilisez plutôt les serveurs HTTP, le cas échéant.
# Syntaxe de base
claude mcp add --transport sse <name> <url>

# Exemple réel : Se connecter à Asana
claude mcp add --transport sse asana https://mcp.asana.com/sse

# Exemple avec en-tête d'authentification
claude mcp add --transport sse private-api https://api.company.com/sse \
  --header "X-API-Key: your-key-here"

​
Option 3 : Ajouter un serveur stdio local

Les serveurs Stdio s’exécutent en tant que processus locaux sur votre machine. Ils sont idéaux pour les outils qui ont besoin d’un accès direct au système ou de scripts personnalisés. 
# Syntaxe de base
claude mcp add --transport stdio <name> <command> [args...]

# Exemple réel : Ajouter un serveur Airtable
claude mcp add --transport stdio airtable --env AIRTABLE_API_KEY=YOUR_KEY \
  -- npx -y airtable-mcp-server
Comprendre le paramètre ”—”: Le -- (double tiret) sépare les propres drapeaux CLI de Claude de la commande et des arguments qui sont transmis au serveur MCP. Tout ce qui précède -- sont des options pour Claude (comme --env, --scope), et tout ce qui suit -- est la commande réelle pour exécuter le serveur MCP.Par exemple :
  • claude mcp add --transport stdio myserver -- npx server → exécute npx server
  • claude mcp add --transport stdio myserver --env KEY=value -- python server.py --port 8080 → exécute python server.py --port 8080 avec KEY=value dans l’environnement
Cela évite les conflits entre les drapeaux de Claude et les drapeaux du serveur.

​
Gestion de vos serveurs

Une fois configurés, vous pouvez gérer vos serveurs MCP avec ces commandes : 
# Lister tous les serveurs configurés
claude mcp list

# Obtenir les détails d'un serveur spécifique
claude mcp get github

# Supprimer un serveur
claude mcp remove github

# (dans Claude Code) Vérifier l'état du serveur
/mcp
Conseils :
  • Utilisez le drapeau --scope pour spécifier où la configuration est stockée :
    • local (par défaut) : Disponible uniquement pour vous dans le projet actuel (appelé project dans les versions antérieures)
    • project : Partagé avec tous les membres du projet via le fichier .mcp.json
    • user : Disponible pour vous dans tous les projets (appelé global dans les versions antérieures)
  • Définissez les variables d’environnement avec les drapeaux --env (par exemple, --env KEY=value)
  • Configurez le délai d’expiration du démarrage du serveur MCP à l’aide de la variable d’environnement MCP_TIMEOUT (par exemple, MCP_TIMEOUT=10000 claude définit un délai d’expiration de 10 secondes)
  • Claude Code affichera un avertissement lorsque la sortie de l’outil MCP dépasse 10 000 jetons. Pour augmenter cette limite, définissez la variable d’environnement MAX_MCP_OUTPUT_TOKENS (par exemple, MAX_MCP_OUTPUT_TOKENS=50000)
  • Utilisez /mcp pour vous authentifier auprès des serveurs distants qui nécessitent une authentification OAuth 2.0
Utilisateurs Windows : Sur Windows natif (pas WSL), les serveurs MCP locaux qui utilisent npx nécessitent le wrapper cmd /c pour assurer une exécution correcte.
# Cela crée command="cmd" que Windows peut exécuter
claude mcp add --transport stdio my-server -- cmd /c npx -y @some/package
Sans le wrapper cmd /c, vous rencontrerez des erreurs « Connection closed » car Windows ne peut pas exécuter directement npx. (Voir la note ci-dessus pour une explication du paramètre --.)

​
Serveurs MCP fournis par les plugins

Les plugins peuvent regrouper les serveurs MCP, fournissant automatiquement des outils et des intégrations lorsque le plugin est activé. Les serveurs MCP des plugins fonctionnent de manière identique aux serveurs configurés par l’utilisateur. Comment fonctionnent les serveurs MCP des plugins :
  • Les plugins définissent les serveurs MCP dans .mcp.json à la racine du plugin ou en ligne dans plugin.json
  • Lorsqu’un plugin est activé, ses serveurs MCP démarrent automatiquement
  • Les outils MCP des plugins apparaissent aux côtés des outils MCP configurés manuellement
  • Les serveurs des plugins sont gérés via l’installation du plugin (pas les commandes /mcp)
Exemple de configuration MCP du plugin : Dans .mcp.json à la racine du plugin : 
{
  "database-tools": {
    "command": "${CLAUDE_PLUGIN_ROOT}/servers/db-server",
    "args": ["--config", "${CLAUDE_PLUGIN_ROOT}/config.json"],
    "env": {
      "DB_URL": "${DB_URL}"
    }
  }
}
Ou en ligne dans plugin.json : 
{
  "name": "my-plugin",
  "mcpServers": {
    "plugin-api": {
      "command": "${CLAUDE_PLUGIN_ROOT}/servers/api-server",
      "args": ["--port", "8080"]
    }
  }
}
Fonctionnalités MCP du plugin :
  • Cycle de vie automatique : Les serveurs démarrent lorsque le plugin s’active, mais vous devez redémarrer Claude Code pour appliquer les modifications du serveur MCP (activation ou désactivation)
  • Variables d’environnement : Utilisez ${CLAUDE_PLUGIN_ROOT} pour les chemins relatifs au plugin
  • Accès aux variables d’environnement utilisateur : Accès aux mêmes variables d’environnement que les serveurs configurés manuellement
  • Types de transport multiples : Support des transports stdio, SSE et HTTP (le support du transport peut varier selon le serveur)
Affichage des serveurs MCP des plugins : 
# Dans Claude Code, voir tous les serveurs MCP, y compris ceux des plugins
/mcp
Les serveurs des plugins apparaissent dans la liste avec des indicateurs montrant qu’ils proviennent des plugins. Avantages des serveurs MCP des plugins :
  • Distribution groupée : Outils et serveurs emballés ensemble
  • Configuration automatique : Aucune configuration MCP manuelle nécessaire
  • Cohérence d’équipe : Tout le monde obtient les mêmes outils lorsque le plugin est installé
Consultez la référence des composants du plugin pour plus de détails sur le regroupement des serveurs MCP avec les plugins.

​
Portées d’installation MCP

Les serveurs MCP peuvent être configurés à trois niveaux de portée différents, chacun servant des objectifs distincts pour gérer l’accessibilité et le partage des serveurs. Comprendre ces portées vous aide à déterminer la meilleure façon de configurer les serveurs pour vos besoins spécifiques.

​
Portée locale

Les serveurs à portée locale représentent le niveau de configuration par défaut et sont stockés dans vos paramètres utilisateur spécifiques au projet. Ces serveurs restent privés pour vous et ne sont accessibles que lorsque vous travaillez dans le répertoire du projet actuel. Cette portée est idéale pour les serveurs de développement personnels, les configurations expérimentales ou les serveurs contenant des identifiants sensibles qui ne doivent pas être partagés. 
# Ajouter un serveur à portée locale (par défaut)
claude mcp add --transport http stripe https://mcp.stripe.com

# Spécifier explicitement la portée locale
claude mcp add --transport http stripe --scope local https://mcp.stripe.com

​
Portée du projet

Les serveurs à portée de projet permettent la collaboration d’équipe en stockant les configurations dans un fichier .mcp.json à la racine de votre projet. Ce fichier est conçu pour être archivé dans le contrôle de version, garantissant que tous les membres de l’équipe ont accès aux mêmes outils et services MCP. Lorsque vous ajoutez un serveur à portée de projet, Claude Code crée ou met à jour automatiquement ce fichier avec la structure de configuration appropriée. 
# Ajouter un serveur à portée de projet
claude mcp add --transport http paypal --scope project https://mcp.paypal.com/mcp
Le fichier .mcp.json résultant suit un format standardisé : 
{
  "mcpServers": {
    "shared-server": {
      "command": "/path/to/server",
      "args": [],
      "env": {}
    }
  }
}
Pour des raisons de sécurité, Claude Code demande l’approbation avant d’utiliser les serveurs à portée de projet à partir des fichiers .mcp.json. Si vous devez réinitialiser ces choix d’approbation, utilisez la commande claude mcp reset-project-choices.

​
Portée utilisateur

Les serveurs à portée utilisateur offrent une accessibilité inter-projets, les rendant disponibles dans tous les projets de votre machine tout en restant privés pour votre compte utilisateur. Cette portée fonctionne bien pour les serveurs utilitaires personnels, les outils de développement ou les services que vous utilisez fréquemment dans différents projets. 
# Ajouter un serveur utilisateur
claude mcp add --transport http hubspot --scope user https://mcp.hubspot.com/anthropic

​
Choisir la bonne portée

Sélectionnez votre portée en fonction de :
  • Portée locale : Serveurs personnels, configurations expérimentales ou identifiants sensibles spécifiques à un projet
  • Portée du projet : Serveurs partagés par l’équipe, outils spécifiques au projet ou services requis pour la collaboration
  • Portée utilisateur : Utilitaires personnels nécessaires dans plusieurs projets, outils de développement ou services fréquemment utilisés

​
Hiérarchie et priorité des portées

Les configurations des serveurs MCP suivent une hiérarchie de priorité claire. Lorsque des serveurs portant le même nom existent à plusieurs portées, le système résout les conflits en donnant la priorité aux serveurs à portée locale en premier, suivis des serveurs à portée de projet, et enfin des serveurs à portée utilisateur. Cette conception garantit que les configurations personnelles peuvent remplacer les configurations partagées si nécessaire.

​
Expansion des variables d’environnement dans .mcp.json

Claude Code prend en charge l’expansion des variables d’environnement dans les fichiers .mcp.json, permettant aux équipes de partager des configurations tout en maintenant la flexibilité pour les chemins spécifiques à la machine et les valeurs sensibles comme les clés API. Syntaxe supportée :
  • ${VAR} - Se développe à la valeur de la variable d’environnement VAR
  • ${VAR:-default} - Se développe à VAR s’il est défini, sinon utilise default
Emplacements d’expansion : Les variables d’environnement peuvent être développées dans :
  • command - Le chemin de l’exécutable du serveur
  • args - Arguments de la ligne de commande
  • env - Variables d’environnement transmises au serveur
  • url - Pour les types de serveur HTTP
  • headers - Pour l’authentification du serveur HTTP
Exemple avec expansion de variable : 
{
  "mcpServers": {
    "api-server": {
      "type": "http",
      "url": "${API_BASE_URL:-https://api.example.com}/mcp",
      "headers": {
        "Authorization": "Bearer ${API_KEY}"
      }
    }
  }
}
Si une variable d’environnement requise n’est pas définie et n’a pas de valeur par défaut, Claude Code ne pourra pas analyser la configuration.

​
Exemples pratiques

​
Exemple : Surveiller les erreurs avec Sentry

# 1. Ajouter le serveur MCP Sentry
claude mcp add --transport http sentry https://mcp.sentry.dev/mcp

# 2. Utiliser /mcp pour vous authentifier auprès de votre compte Sentry
> /mcp

# 3. Déboguer les problèmes de production
> "Quelles sont les erreurs les plus courantes au cours des dernières 24 heures ?"
> "Afficher la trace de pile pour l'erreur ID abc123"
> "Quel déploiement a introduit ces nouvelles erreurs ?"

​
Exemple : Se connecter à GitHub pour les révisions de code

# 1. Ajouter le serveur MCP GitHub
claude mcp add --transport http github https://api.githubcopilot.com/mcp/

# 2. Dans Claude Code, s'authentifier si nécessaire
> /mcp
# Sélectionner « Authenticate » pour GitHub

# 3. Maintenant, vous pouvez demander à Claude de travailler avec GitHub
> "Examiner la PR #456 et suggérer des améliorations"
> "Créer un nouveau problème pour le bug que nous venons de trouver"
> "Afficher toutes les PR ouvertes qui m'ont été assignées"

​
Exemple : Interroger votre base de données PostgreSQL

# 1. Ajouter le serveur de base de données avec votre chaîne de connexion
claude mcp add --transport stdio db -- npx -y @bytebase/dbhub \
  --dsn "postgresql://readonly:[email protected]:5432/analytics"

# 2. Interroger votre base de données naturellement
> "Quel est notre revenu total ce mois-ci ?"
> "Afficher le schéma de la table des commandes"
> "Trouver les clients qui n'ont pas effectué d'achat depuis 90 jours"

​
S’authentifier auprès des serveurs MCP distants

De nombreux serveurs MCP basés sur le cloud nécessitent une authentification. Claude Code prend en charge OAuth 2.0 pour les connexions sécurisées.
1

Ajouter le serveur qui nécessite une authentification

Par exemple :
claude mcp add --transport http sentry https://mcp.sentry.dev/mcp
2

Utiliser la commande /mcp dans Claude Code

Dans Claude Code, utilisez la commande :
> /mcp
Puis suivez les étapes dans votre navigateur pour vous connecter.
Conseils :
  • Les jetons d’authentification sont stockés de manière sécurisée et actualisés automatiquement
  • Utilisez « Clear authentication » dans le menu /mcp pour révoquer l’accès
  • Si votre navigateur ne s’ouvre pas automatiquement, copiez l’URL fournie
  • L’authentification OAuth fonctionne avec les serveurs HTTP

​
Ajouter des serveurs MCP à partir de la configuration JSON

Si vous avez une configuration JSON pour un serveur MCP, vous pouvez l’ajouter directement :
1

Ajouter un serveur MCP à partir de JSON

# Syntaxe de base
claude mcp add-json <name> '<json>'

# Exemple : Ajouter un serveur HTTP avec configuration JSON
claude mcp add-json weather-api '{"type":"http","url":"https://api.weather.com/mcp","headers":{"Authorization":"Bearer token"}}'

# Exemple : Ajouter un serveur stdio avec configuration JSON
claude mcp add-json local-weather '{"type":"stdio","command":"/path/to/weather-cli","args":["--api-key","abc123"],"env":{"CACHE_DIR":"/tmp"}}'
2

Vérifier que le serveur a été ajouté

claude mcp get weather-api
Conseils :
  • Assurez-vous que le JSON est correctement échappé dans votre shell
  • Le JSON doit être conforme au schéma de configuration du serveur MCP
  • Vous pouvez utiliser --scope user pour ajouter le serveur à votre configuration utilisateur au lieu de celle spécifique au projet

​
Importer les serveurs MCP à partir de Claude Desktop

Si vous avez déjà configuré les serveurs MCP dans Claude Desktop, vous pouvez les importer :
1

Importer les serveurs à partir de Claude Desktop

# Syntaxe de base 
claude mcp add-from-claude-desktop
2

Sélectionner les serveurs à importer

Après avoir exécuté la commande, vous verrez une boîte de dialogue interactive qui vous permet de sélectionner les serveurs que vous souhaitez importer.
3

Vérifier que les serveurs ont été importés

claude mcp list
Conseils :
  • Cette fonctionnalité ne fonctionne que sur macOS et Windows Subsystem for Linux (WSL)
  • Elle lit le fichier de configuration de Claude Desktop à partir de son emplacement standard sur ces plates-formes
  • Utilisez le drapeau --scope user pour ajouter les serveurs à votre configuration utilisateur
  • Les serveurs importés auront les mêmes noms que dans Claude Desktop
  • Si des serveurs portant les mêmes noms existent déjà, ils recevront un suffixe numérique (par exemple, server_1)

​
Utiliser Claude Code comme serveur MCP

Vous pouvez utiliser Claude Code lui-même comme serveur MCP auquel d’autres applications peuvent se connecter : 
# Démarrer Claude en tant que serveur MCP stdio
claude mcp serve
Vous pouvez l’utiliser dans Claude Desktop en ajoutant cette configuration à claude_desktop_config.json : 
{
  "mcpServers": {
    "claude-code": {
      "type": "stdio",
      "command": "claude",
      "args": ["mcp", "serve"],
      "env": {}
    }
  }
}
Configuration du chemin de l’exécutable : Le champ command doit faire référence à l’exécutable Claude Code. Si la commande claude ne se trouve pas dans le PATH de votre système, vous devrez spécifier le chemin complet de l’exécutable.Pour trouver le chemin complet :
which claude
Puis utilisez le chemin complet dans votre configuration :
{
  "mcpServers": {
    "claude-code": {
      "type": "stdio",
      "command": "/full/path/to/claude",
      "args": ["mcp", "serve"],
      "env": {}
    }
  }
}
Sans le chemin d’exécutable correct, vous rencontrerez des erreurs comme spawn claude ENOENT.
Conseils :
  • Le serveur fournit l’accès aux outils de Claude comme View, Edit, LS, etc.
  • Dans Claude Desktop, essayez de demander à Claude de lire les fichiers dans un répertoire, de faire des modifications, etc.
  • Notez que ce serveur MCP expose simplement les outils de Claude Code à votre client MCP, donc votre propre client est responsable de l’implémentation de la confirmation de l’utilisateur pour les appels d’outils individuels.

​
Limites de sortie MCP et avertissements

Lorsque les outils MCP produisent de grandes sorties, Claude Code aide à gérer l’utilisation des jetons pour éviter de surcharger votre contexte de conversation :
  • Seuil d’avertissement de sortie : Claude Code affiche un avertissement lorsque la sortie de tout outil MCP dépasse 10 000 jetons
  • Limite configurable : Vous pouvez ajuster le nombre maximum de jetons de sortie MCP autorisés à l’aide de la variable d’environnement MAX_MCP_OUTPUT_TOKENS
  • Limite par défaut : La limite maximale par défaut est de 25 000 jetons
Pour augmenter la limite pour les outils qui produisent de grandes sorties : 
# Définir une limite plus élevée pour les sorties des outils MCP
export MAX_MCP_OUTPUT_TOKENS=50000
claude
Ceci est particulièrement utile lorsque vous travaillez avec des serveurs MCP qui :
  • Interrogent de grands ensembles de données ou des bases de données
  • Génèrent des rapports ou des documentations détaillés
  • Traitent des fichiers journaux ou des informations de débogage étendus
Si vous rencontrez fréquemment des avertissements de sortie avec des serveurs MCP spécifiques, envisagez d’augmenter la limite ou de configurer le serveur pour paginer ou filtrer ses réponses.

​
Utiliser les ressources MCP

Les serveurs MCP peuvent exposer des ressources que vous pouvez référencer en utilisant des mentions @, similaire à la façon dont vous référencez les fichiers.

​
Référencer les ressources MCP

1

Lister les ressources disponibles

Tapez @ dans votre invite pour voir les ressources disponibles de tous les serveurs MCP connectés. Les ressources apparaissent aux côtés des fichiers dans le menu de saisie semi-automatique.
2

Référencer une ressource spécifique

Utilisez le format @server:protocol://resource/path pour référencer une ressource :
> Pouvez-vous analyser @github:issue://123 et suggérer un correctif ?

> Veuillez examiner la documentation de l'API à @docs:file://api/authentication
3

Références de ressources multiples

Vous pouvez référencer plusieurs ressources dans une seule invite :
> Comparer @postgres:schema://users avec @docs:file://database/user-model
Conseils :
  • Les ressources sont automatiquement récupérées et incluses en tant que pièces jointes lorsqu’elles sont référencées
  • Les chemins des ressources sont recherchables par correspondance floue dans la saisie semi-automatique de mention @
  • Claude Code fournit automatiquement des outils pour lister et lire les ressources MCP lorsque les serveurs les supportent
  • Les ressources peuvent contenir n’importe quel type de contenu fourni par le serveur MCP (texte, JSON, données structurées, etc.)

​
Utiliser les invites MCP comme commandes slash

Les serveurs MCP peuvent exposer des invites qui deviennent disponibles en tant que commandes slash dans Claude Code.

​
Exécuter les invites MCP

1

Découvrir les invites disponibles

Tapez / pour voir toutes les commandes disponibles, y compris celles des serveurs MCP. Les invites MCP apparaissent avec le format /mcp__servername__promptname.
2

Exécuter une invite sans arguments

> /mcp__github__list_prs
3

Exécuter une invite avec des arguments

De nombreuses invites acceptent des arguments. Passez-les séparés par des espaces après la commande :
> /mcp__github__pr_review 456

> /mcp__jira__create_issue "Bug in login flow" high
Conseils :
  • Les invites MCP sont découvertes dynamiquement à partir des serveurs connectés
  • Les arguments sont analysés en fonction des paramètres définis de l’invite
  • Les résultats de l’invite sont injectés directement dans la conversation
  • Les noms des serveurs et des invites sont normalisés (les espaces deviennent des traits de soulignement)

​
Configuration MCP d’entreprise

Pour les organisations qui ont besoin d’un contrôle centralisé sur les serveurs MCP, Claude Code prend en charge les configurations MCP gérées par l’entreprise. Cela permet aux administrateurs informatiques de :
  • Contrôler les serveurs MCP auxquels les employés peuvent accéder : Déployer un ensemble standardisé de serveurs MCP approuvés dans toute l’organisation
  • Empêcher les serveurs MCP non autorisés : Optionnellement, restreindre les utilisateurs d’ajouter leurs propres serveurs MCP
  • Désactiver complètement MCP : Supprimer complètement la fonctionnalité MCP si nécessaire

​
Configuration de la configuration MCP d’entreprise

Les administrateurs système peuvent déployer un fichier de configuration MCP d’entreprise aux côtés du fichier de paramètres gérés :
  • macOS : /Library/Application Support/ClaudeCode/managed-mcp.json
  • Windows : C:\ProgramData\ClaudeCode\managed-mcp.json
  • Linux : /etc/claude-code/managed-mcp.json
Le fichier managed-mcp.json utilise le même format qu’un fichier .mcp.json standard : 
{
  "mcpServers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"
    },
    "sentry": {
      "type": "http",
      "url": "https://mcp.sentry.dev/mcp"
    },
    "company-internal": {
      "type": "stdio",
      "command": "/usr/local/bin/company-mcp-server",
      "args": ["--config", "/etc/company/mcp-config.json"],
      "env": {
        "COMPANY_API_URL": "https://internal.company.com"
      }
    }
  }
}

​
Restriction des serveurs MCP avec des listes blanches et des listes noires

En plus de fournir des serveurs gérés par l’entreprise, les administrateurs peuvent contrôler les serveurs MCP que les utilisateurs sont autorisés à configurer en utilisant allowedMcpServers et deniedMcpServers dans le fichier managed-settings.json :
  • macOS : /Library/Application Support/ClaudeCode/managed-settings.json
  • Windows : C:\ProgramData\ClaudeCode\managed-settings.json
  • Linux : /etc/claude-code/managed-settings.json
{
  "allowedMcpServers": [
    { "serverName": "github" },
    { "serverName": "sentry" },
    { "serverName": "company-internal" }
  ],
  "deniedMcpServers": [
    { "serverName": "filesystem" }
  ]
}
Comportement de la liste blanche (allowedMcpServers) :
  • undefined (par défaut) : Aucune restriction - les utilisateurs peuvent configurer n’importe quel serveur MCP
  • Tableau vide [] : Verrouillage complet - les utilisateurs ne peuvent configurer aucun serveur MCP
  • Liste de noms de serveurs : Les utilisateurs ne peuvent configurer que les serveurs spécifiés
Comportement de la liste noire (deniedMcpServers) :
  • undefined (par défaut) : Aucun serveur n’est bloqué
  • Tableau vide [] : Aucun serveur n’est bloqué
  • Liste de noms de serveurs : Les serveurs spécifiés sont explicitement bloqués dans toutes les portées
Notes importantes :
  • Ces restrictions s’appliquent à toutes les portées : utilisateur, projet, local, et même les serveurs d’entreprise à partir de managed-mcp.json
  • La liste noire a une priorité absolue : Si un serveur apparaît dans les deux listes, il sera bloqué
Priorité de la configuration d’entreprise : La configuration MCP d’entreprise a la priorité la plus élevée et ne peut pas être remplacée par les configurations utilisateur, locale ou de projet.