Introduction : pourquoi MCP ?

Qu’est-ce que le Model Context Protocol ?
Comment fonctionne MCP avec Claude ?
Claude Desktop vs Claude Code
Configuration d’un serveur MCP
Configuration avec claude mcp add
Configuration manuelle avec .mcp.json
Exemple concret : connecter un serveur MCP
Vérifier la connexion avec /mcp
Gestion des scopes : local, projet et utilisateur
Variables d’environnement et secrets
Sécurité : risques liés aux MCP
Bonnes pratiques
Conclusion

La documentation actuelle de Claude Code recommande notamment les commandes claude mcp add, claude mcp list, claude mcp get et /mcp pour gérer et vérifier les serveurs MCP. Les serveurs peuvent notamment utiliser les transports HTTP ou stdio. (Claude)

Je te propose comme titre :

Configurer MCP avec Claude Code : connecter Claude à vos outils et données

Introduction

Les assistants IA comme Claude sont particulièrement puissants lorsqu'ils peuvent comprendre le code d'un projet. Mais leurs capacités deviennent encore plus intéressantes lorsqu'ils peuvent également interagir avec les outils utilisés quotidiennement par les développeurs : bases de données, GitHub, systèmes de monitoring, APIs, gestionnaires de tâches ou encore services internes.

C'est précisément le rôle du Model Context Protocol (MCP).

MCP permet à Claude de communiquer avec des outils et des sources de données externes à travers un protocole standardisé. Au lieu de copier manuellement des informations dans une conversation, Claude peut utiliser directement les outils auxquels il a été autorisé à accéder.

Dans cet article, nous allons voir comment configurer MCP avec Claude Code, comment ajouter un serveur MCP, comment vérifier son fonctionnement et quelles précautions prendre concernant la sécurité.

1. Qu'est-ce que MCP ?

MCP, ou Model Context Protocol, est un protocole ouvert permettant à une application d'IA de communiquer avec des outils et des sources de données externes.

On peut le représenter simplement ainsi :

                    ┌─────────────────┐
                    │    Claude Code  │
                    │        IA       │
                    └────────┬────────┘
                             │
                            MCP
                             │
              ┌──────────────┼──────────────┐
              │              │              │
              ▼              ▼              ▼
         ┌─────────┐   ┌───────────┐   ┌──────────┐
         │ GitHub  │   │ PostgreSQL│   │   API    │
         └─────────┘   └───────────┘   └──────────┘

Le serveur MCP joue donc le rôle d'intermédiaire entre Claude et le système externe.

Par exemple, sans MCP, on pourrait demander à Claude :

« Voici les erreurs présentes dans mon système de monitoring. Analyse-les. »

Il faudrait généralement copier les erreurs dans la conversation.

Avec MCP, Claude peut potentiellement interroger directement le système concerné et récupérer les informations nécessaires.

2. Pourquoi utiliser MCP avec Claude Code ?

Pour un développeur, MCP peut être particulièrement intéressant lorsqu'un projet dépend de plusieurs services.

Par exemple :

GitHub pour le code source ;
PostgreSQL pour les données ;
Sentry pour les erreurs ;
Linear ou Jira pour les tâches ;
Slack pour les communications ;
une API interne ;
un système de monitoring ;
des outils métier développés en interne.

Claude Code peut alors utiliser les outils exposés par ces serveurs MCP.

L'intérêt principal est de réduire les opérations manuelles et de donner à Claude un accès contrôlé à des informations dont il a besoin pour effectuer certaines tâches.

3. Claude Desktop ou Claude Code ?

Il est important de distinguer les deux.

Claude Desktop

Claude Desktop peut utiliser des serveurs MCP locaux. Anthropic propose également les Desktop Extensions, qui permettent d'installer plus facilement certains serveurs MCP locaux depuis l'interface de Claude Desktop. (Claude Centre d'Aide)

Claude Code

Claude Code est particulièrement intéressant pour les développeurs puisqu'il permet de configurer les serveurs MCP directement depuis le terminal.

Par exemple :

claude mcp add

On peut ensuite gérer les serveurs avec :

claude mcp list
claude mcp get <nom>
claude mcp remove <nom>

Et vérifier les connexions depuis Claude Code avec :

/mcp

(Claude)

4. Ajouter un serveur MCP avec Claude Code

La méthode la plus simple consiste à utiliser la commande claude mcp add.

Pour un serveur MCP HTTP :

claude mcp add --transport http mon-serveur https://example.com/mcp

Pour un serveur utilisant stdio, on peut par exemple utiliser :

claude mcp add --transport stdio mon-serveur -- npx mon-mcp-server

Le -- permet de séparer les options de Claude Code de la commande qui sera réellement exécutée pour démarrer le serveur MCP. (Claude)

5. Ajouter un serveur MCP avec une configuration JSON

Il est également possible d'ajouter directement une configuration JSON.

Par exemple :

claude mcp add-json weather-api \
'{
  "type": "http",
  "url": "https://api.example.com/mcp"
}'

Pour un serveur local utilisant stdio :

claude mcp add-json local-server \
'{
  "type": "stdio",
  "command": "npx",
  "args": [
    "-y",
    "mon-mcp-server"
  ]
}'

Cette approche est particulièrement pratique lorsqu'un fournisseur MCP fournit déjà une configuration JSON.

6. Utiliser `.mcp.json` dans un projet

Claude Code permet également de définir des serveurs MCP au niveau du projet.

On peut créer un fichier :

.mcp.json

à la racine du projet.

Exemple :

{
  "mcpServers": {
    "mon-server": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "mon-mcp-server"
      ]
    }
  }
}

Cette approche est particulièrement intéressante pour les équipes.

Le fichier peut être versionné avec le projet afin que les membres de l'équipe disposent d'une configuration MCP commune.

Claude Code demande toutefois une validation avant d'utiliser les serveurs provenant d'un .mcp.json de projet, ce qui constitue une mesure de sécurité importante. (Claude)

7. Les différents scopes

Claude Code permet de gérer les serveurs MCP selon différents niveaux de portée.

Scope local

Le serveur est disponible pour l'utilisateur et peut être utilisé dans différents projets.

La configuration est notamment stockée dans :

~/.claude.json

Scope projet

La configuration est stockée dans :

.mcp.json

à la racine du projet.

C'est généralement le choix le plus intéressant lorsqu'une équipe doit partager la même configuration MCP.

Scope utilisateur

Un serveur peut également être configuré pour être accessible sur différents projets de la machine.

Exemple :

claude mcp add --transport http \
  --scope user \
  mon-server \
  https://example.com/mcp

Les différences entre ces scopes sont importantes lorsqu'on travaille sur plusieurs projets ou avec une équipe. (Claude)

8. Utiliser des variables d'environnement

Il est déconseillé de placer directement des secrets dans le fichier .mcp.json.

Par exemple, évitez :

{
  "env": {
    "API_KEY": "ma-cle-secrete"
  }
}

Préférez une variable d'environnement :

{
  "mcpServers": {
    "mon-api": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "mon-mcp-server"
      ],
      "env": {
        "API_KEY": "${API_KEY}"
      }
    }
  }
}

Puis définissez la variable dans votre environnement :

export API_KEY="..."

Cela permet d'éviter de publier accidentellement une clé API dans Git.

9. Vérifier que le serveur MCP fonctionne

Après avoir configuré un serveur, il faut vérifier son état.

Dans Claude Code :

/mcp

Cette commande affiche notamment les serveurs MCP configurés ainsi que les outils exposés par ceux-ci.

Depuis le terminal, on peut également utiliser :

claude mcp list

Puis obtenir les détails d'un serveur :

claude mcp get mon-server

Cela permet de diagnostiquer rapidement une configuration incorrecte. (Claude)

10. Exemple concret

Imaginons que nous souhaitons connecter Claude à une API interne exposant un serveur MCP.

Notre serveur est disponible à :

https://mcp.monentreprise.com/mcp

Nous pouvons l'ajouter avec :

claude mcp add \
  --transport http \
  entreprise \
  https://mcp.monentreprise.com/mcp

Puis :

claude mcp list

Et dans Claude Code :

/mcp

Une fois connecté, Claude peut utiliser les outils exposés par ce serveur selon les permissions accordées.

On peut alors lui demander par exemple :

Analyse les incidents ouverts cette semaine et identifie ceux qui semblent liés à la dernière version de l'API.

La différence est importante : Claude ne reçoit plus uniquement des informations copiées manuellement dans le prompt. Il peut utiliser les outils MCP disponibles pour récupérer les informations nécessaires.

11. MCP et authentification

Les serveurs MCP distants peuvent nécessiter une authentification.

Claude Code prend notamment en charge l'authentification OAuth pour les serveurs HTTP.

Dans ce cas, on peut configurer le serveur puis lancer :

/mcp

et suivre le processus d'authentification.

Les informations d'authentification peuvent être conservées de manière sécurisée par Claude Code plutôt que d'être placées directement dans la configuration du projet. (Claude)

12. La sécurité doit rester une priorité

MCP donne à Claude accès à des outils externes.

Il faut donc considérer un serveur MCP comme une extension de la surface d'accès de votre agent IA.

Avant d'installer un serveur, vérifiez :

son origine ;
son code source lorsque celui-ci est disponible ;
les permissions demandées ;
les données auxquelles il peut accéder ;
les actions qu'il peut exécuter ;
la manière dont les secrets sont stockés ;
les dépendances utilisées.

Il faut également être particulièrement attentif aux serveurs qui récupèrent du contenu externe, car ce contenu peut introduire des risques d'injection de prompt. Anthropic recommande explicitement de ne connecter que des serveurs auxquels vous faites confiance. (Claude)

13. MCP ne signifie pas « donner tous les accès à Claude »

C'est probablement l'un des points les plus importants.

Si Claude possède un outil permettant :

DELETE FROM users;

il ne faut pas considérer que Claude devrait automatiquement pouvoir l'utiliser.

L'approche recommandée consiste à appliquer le principe du moindre privilège.

Par exemple :

Claude
   │
   ▼
MCP Server
   │
   ├── READ users
   ├── READ orders
   └── READ logs

plutôt que :

Claude
   │
   ▼
MCP Server
   │
   └── accès administrateur complet

Un serveur MCP doit exposer uniquement les capacités réellement nécessaires au cas d'utilisation.

14. Quelques bonnes pratiques

1. Ne jamais versionner les secrets

Utilisez des variables d'environnement ou un gestionnaire de secrets.

2. Limiter les permissions

Un serveur MCP dédié à la consultation d'une base de données n'a pas nécessairement besoin des permissions INSERT, UPDATE ou DELETE.

3. Utiliser `.mcp.json` pour les configurations d'équipe

Cela permet de partager une configuration cohérente entre les développeurs.

4. Vérifier les serveurs MCP tiers

Un serveur MCP est du code qui s'exécute ou communique avec votre environnement. Il doit donc être traité comme n'importe quelle dépendance externe.

5. Séparer développement et production

Évitez de donner à un agent IA un accès direct à une base de production lorsque cela n'est pas nécessaire.

6. Journaliser les opérations sensibles

Pour les outils qui peuvent modifier des données, la traçabilité est importante.

Conclusion

MCP transforme Claude d'un simple assistant capable de générer ou analyser du texte et du code en un agent capable d'interagir avec un écosystème d'outils.

Pour un développeur, cela ouvre des possibilités importantes :

Claude Code
     │
     ├── GitHub
     ├── PostgreSQL
     ├── Sentry
     ├── Slack
     ├── Jira
     ├── APIs internes
     └── Outils personnalisés

La configuration de base reste relativement simple :

claude mcp add --transport http mon-server https://example.com/mcp

Puis :

claude mcp list

et :

/mcp

Mais la véritable difficulté n'est pas uniquement technique.

La question essentielle est de déterminer quels outils Claude doit pouvoir utiliser, avec quelles permissions et dans quel environnement.

MCP doit donc être considéré non seulement comme une technologie d'intégration, mais également comme une composante de l'architecture et de la sécurité de vos applications IA.