Guide Claude MCP Servers : Connectez n'importe quel outil à l'IA
TL;DR : Model Context Protocol (MCP) est une norme ouverte qui permet à Claude de se connecter à des outils externes, des bases de données, des API et des services. Ce guide explique ce qu'est MCP, comment installer et configurer les serveurs MCP populaires, comment créer les vôtres, et des workflows pratiques qui combinent plusieurs outils MCP en puissants pipelines assistés par l'IA.
Qu'est-ce que MCP et pourquoi est-ce important ?
Model Context Protocol (MCP) est une norme ouverte développée par Anthropic qui crée une interface universelle entre des modèles d'IA comme Claude et des outils externes, des sources de données et des services. Avant MCP, l'intégration de l'IA avec des systèmes externes nécessitait des intégrations personnalisées et uniques pour chaque combinaison de modèle d'IA et d'outil. MCP standardise cela : tout outil compatible MCP fonctionne avec n'importe quel modèle d'IA compatible MCP.
L'impact pratique est énorme. Sans MCP, Claude est limité aux informations que vous collez dans la conversation. Avec MCP, Claude peut interroger votre base de données en production, parcourir le web, lire votre système de fichiers, appeler des API externes, gérer des dépôts GitHub, contrôler un navigateur, accéder aux canaux Slack, et bien plus — tout cela pendant une conversation ou une session de codage normale.
Pensez aux serveurs MCP comme des plugins pour Claude. Tout comme les extensions de navigateur ajoutent des capacités à un navigateur web, les serveurs MCP ajoutent des capacités à Claude. La différence est que MCP est standardisé : une fois qu'un serveur est construit en respectant la spécification MCP, il fonctionne avec n'importe quel client compatible MCP — Claude Code, Claude Desktop, ou n'importe quelle application tierce qui implémente le protocole.
Depuis le milieu de 2026, des centaines de serveurs MCP communautaires et officiels sont disponibles, couvrant les bases de données (PostgreSQL, MySQL, MongoDB, SQLite), le contrôle de version (GitHub, GitLab, Bitbucket), la communication (Slack, Discord, email), les services cloud (AWS, GCP, Azure), les outils de productivité (Notion, Linear, Jira), les navigateurs, les systèmes de fichiers, et bien plus. L'écosystème se développe rapidement.
Architecture MCP expliquée
MCP définit trois composants principaux : les hôtes, les clients et les serveurs. Un hôte est l'application que vous utilisez pour parler à Claude — Claude Desktop ou Claude Code. Un client est le composant au sein de l'hôte qui gère la communication du protocole MCP. Un serveur est un processus externe qui expose des outils, des ressources et des invites via le protocole MCP.
Les serveurs MCP exposent trois types de capacités : les outils sont des fonctions que Claude peut appeler pour effectuer des actions (interroger une base de données, envoyer un email, faire une demande API). Les ressources sont des sources de données que Claude peut lire (contenu de fichiers, enregistrements de base de données, réponses API). Les invites sont des modèles d'invite réutilisables que le serveur fournit pour les workflows courants.
Lorsque Claude décide d'utiliser un outil MCP, le flux est : Claude identifie l'outil pertinent à partir de sa description → formule les paramètres d'entrée → le client appelle le serveur → le serveur exécute l'action et retourne le résultat → Claude incorpore le résultat dans sa réponse. L'ensemble du flux se produit de manière transparente — de votre point de vue, vous avez posé une question et Claude l'a répondue avec des informations en temps réel.
Installation de votre premier serveur MCP
La configuration du serveur MCP se trouve dans votre fichier de paramètres Claude. Pour Claude Code : ~/.claude/settings.json. Pour Claude Desktop : le menu des paramètres de l'application. La structure de configuration est identique pour les deux.
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"/Users/yourname/projects",
"/Users/yourname/documents"
]
}
}
}Cela installe le serveur MCP filesystem officiel, donnant à Claude un accès en lecture et écriture aux répertoires spécifiés. Après avoir enregistré cette configuration et redémarré Claude Code, vous pouvez demander à Claude de « lire le README dans mon dossier projects » et il le fera directement. Pour les serveurs nécessitant une authentification, transmettez les credentials via des variables d'environnement :
{
"mcpServers": {
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {"GITHUB_TOKEN": "ghp_your_token_here"}
}
}
}Les 10 serveurs MCP les plus utiles
Avec des centaines de serveurs MCP disponibles, ces dix offrent les capacités les plus largement applicables pour les développeurs et les utilisateurs avancés.
1. Filesystem (@modelcontextprotocol/server-filesystem)
La fondation de la plupart des workflows Claude Code. Donne à Claude un accès direct au système de fichiers dans les répertoires spécifiés. Supporte la lecture, l'écriture, le déplacement, la recherche et la traversée de répertoires. Essentiel pour tout workflow impliquant des fichiers locaux.
2. GitHub (@modelcontextprotocol/server-github)
Intégration complète de GitHub : lire et écrire des fichiers, gérer les problèmes et les demandes de fusion, examiner le code, vérifier l'état de CI, rechercher des dépôts et accéder à l'historique git. Transforme Claude en un assistant complet de workflow GitHub qui n'a jamais besoin de quitter le terminal.
3. PostgreSQL (@modelcontextprotocol/server-postgres)
Capacité directe de requête de base de données. Claude peut explorer votre schéma, écrire et exécuter des requêtes, analyser les distributions de données, identifier les problèmes de performance et générer des migrations. Un mode lecture seule est disponible pour les bases de données en production afin d'éviter les modifications accidentelles.
4. Playwright (automatisation du navigateur)
Contrôle complet du navigateur : naviguer vers des URLs, cliquer sur des éléments, remplir des formulaires, prendre des captures d'écran, extraire du contenu et interagir avec des applications web. Permet à Claude de tester les interfaces utilisateur web, d'extraire des données et d'automatiser les workflows basés sur le navigateur entièrement sans intervention.
5. Slack
Lire l'historique des canaux, rechercher des messages, publier sur des canaux, gérer les fils de discussion et rechercher des informations sur les utilisateurs. Claude devient un assistant conscient de Slack qui peut référencer les discussions récentes, rédiger des annonces et aider à gérer les communications d'équipe en contexte.
6. Memory (@modelcontextprotocol/server-memory)
Graphe de connaissances persistant qui survit à travers les conversations. Claude peut stocker et récupérer des faits, des relations et du contexte qui seraient autrement perdus lorsqu'une session se termine. Essentiel pour les projets à long terme où la continuité compte.
7. Fetch (accès web)
Récupère les URLs web et retourne leur contenu en texte. Donne à Claude accès aux informations actuelles du web, à la documentation et à n'importe quelle URL accessible au public. Plus simple que le serveur de navigateur Playwright pour les cas d'usage d'extraction de contenu où l'interaction n'est pas nécessaire.
8. SQLite
Pour les projets utilisant des bases de données SQLite (applications locales, scripts, petits services). Les mêmes capacités que le serveur PostgreSQL mais pour les fichiers SQLite. Particulièrement utile pour le développement d'applications mobiles, d'applications de bureau et les workflows de base de données intégrée.
9. AWS
Accédez aux compartiments S3, interrogez DynamoDB, vérifiez les métriques CloudWatch, gérez les fonctions Lambda et interagissez avec d'autres services AWS. Permet une assistance IA consciente du cloud qui comprend l'état réel de votre infrastructure plutôt que de travailler à partir de descriptions.
10. Linear
Intégration de la gestion de projet : lire et créer des problèmes, mettre à jour le statut, gérer les sprints et suivre le travail d'ingénierie. Claude devient un assistant de planification qui comprend votre backlog réel et peut aider à prioriser le travail avec un contexte complet.
Modèles de configuration avancée
Gestion des variables d'environnement
Pour les déploiements en production, ne codez jamais en dur les credentials dans settings.json. Référencez les variables d'environnement en utilisant l'expansion de variables du shell :
{
"mcpServers": {
"postgres": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-postgres"],
"env": {"DATABASE_URL": "${DATABASE_URL}"}
}
}
}Instances multiples du serveur
Exécutez plusieurs instances du même type de serveur avec des configurations différentes — utile pour accéder aux bases de données en production et de préproduction simultanément :
{
"mcpServers": {
"db-production": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-postgres"],
"env": {"DATABASE_URL": "postgresql://prod-host/myapp"}
},
"db-staging": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-postgres"],
"env": {"DATABASE_URL": "postgresql://staging-host/myapp"}
}
}
}Configuration MCP spécifique au projet
Placez un .claude/settings.json dans un répertoire de projet pour configurer les serveurs MCP qui ne s'activent que lorsque vous travaillez dans ce projet. C'est plus propre que de configurer tous les serveurs possibles mondialement et garantit que Claude n'a accès qu'aux outils pertinents pour chaque contexte de projet spécifique.
Créer un serveur MCP personnalisé
Si aucun serveur MCP existant ne couvre votre cas d'usage, en construire un est simple. Le SDK MCP gère tous les détails du protocole — vous implementez simplement la logique des outils.
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
const server = new Server(
{ name: 'my-custom-server', version: '1.0.0' },
{ capabilities: { tools: {} } }
);
server.setRequestHandler(ListToolsRequestSchema, async () => ({
tools: [{
name: 'get_stock_price',
description: 'Get the current stock price for a ticker symbol. Use when user asks about stock prices or market data.',
inputSchema: {
type: 'object',
properties: {
ticker: { type: 'string', description: 'Stock ticker symbol e.g. AAPL, TSLA' }
},
required: ['ticker']
}
}]
}));
server.setRequestHandler(CallToolRequestSchema, async (request) => {
if (request.params.name === 'get_stock_price') {
const { ticker } = request.params.arguments;
const price = await fetchStockPrice(ticker); // your real API call
return {
content: [{ type: 'text', text: JSON.stringify({ ticker, price, timestamp: new Date().toISOString() }) }]
};
}
throw new Error('Unknown tool');
});
const transport = new StdioServerTransport();
await server.connect(transport);Principes clés pour une conception efficace du serveur MCP : écrivez des descriptions d'outils détaillées — Claude les utilise pour décider s'il faut appeler l'outil ; retournez du JSON structuré pour les données complexes ; implémentez une gestion d'erreur appropriée avec des messages d'erreur significatifs ; gardez les outils concentrés sur des responsabilités uniques ; et documentez clairement les variables d'environnement requises.
Workflows MCP dans le monde réel
Le vrai pouvoir de MCP émerge lorsque vous combinez plusieurs serveurs en workflows intégrés qui seraient impossibles avec Claude seul.
Pipeline d'examen de code automatisé
Avec les MCPs GitHub + filesystem + PostgreSQL configurés : « Examinez les demandes de fusion ouvertes dans mon dépôt, vérifiez la couverture de test pour chaque fichier modifié, interrogez la base de données des bugs pour les problèmes connus dans les modules affectés et produisez un rapport d'examen par ordre de priorité. » Claude exécute ceci sur trois systèmes différents simultanément, produisant un examen qui prendrait des heures à un analyste humain pour assembler.
Workflow d'analyse de données
Avec les MCPs PostgreSQL + filesystem : « Interrogez la base de données des ventes pour les données du mois dernier, analysez les tendances par région et catégorie de produit, écrivez un script d'analyse Python dans mes fichiers locaux et produisez un rapport de synthèse avec des recommandations. » Claude écrit et exécute l'ensemble du pipeline d'analyse des données au résultat final.
Réponse aux incidents DevOps
Avec les MCPs AWS + Slack + GitHub : « Vérifiez CloudWatch pour les alertes qui se sont déclenché la dernière heure, trouvez les commits git déployés dans les 24 dernières heures qui ont touché les services affectés et publiez une analyse préliminaire des causes racines sur le canal Slack #incidents. » Ce workflow prend 30 secondes au lieu de 30 minutes d'investigation manuelle.
Considérations de sécurité
Les serveurs MCP étendent les capacités de Claude et le rayon de dégâts potentiel. Les déploiements MCP en production doivent mettre en œuvre ces pratiques de sécurité.
Utilisez des connexions de base de données en lecture seule pour les bases de données en production. Un utilisateur de base de données SELECT uniquement empêche Claude de modifier accidentellement les données en production. Réservez l'accès en lecture-écriture aux environnements de développement et de préproduction où les erreurs sont récupérables.
Implémentez des restrictions de répertoire dans les serveurs filesystem. Accordez l'accès uniquement aux répertoires spécifiques pertinents pour chaque workflow — pas à l'ensemble de votre répertoire personnel. Cela limite l'exposition si une attaque par injection de prompt tente d'exfiltrer des fichiers sensibles.
Configurez la limitation de débit sur les serveurs connectés à l'API pour éviter les appels API qui ne s'arrêtent pas dans les workflows autonomes. Une boucle coincée dans un agent autonome pourrait déclencher des milliers d'appels API sans limitation de débit en place.
Activez l'audit logging pour tous les appels d'outils MCP en production. Utilisez les hooks Claude Code ou la journalisation côté serveur pour enregistrer chaque invocation d'outil avec ses entrées et sorties. C'est inestimable pour déboguer un comportement inattendu et à des fins de conformité.
Ne connectez jamais les serveurs MCP avec des credentials administratifs dans les workflows automatisés. Utilisez le principe du moindre privilège : accordez uniquement les permissions spécifiques nécessaires pour les outils définis, pas un accès administratif plus large au système sous-jacent.
Questions fréquemment posées
MCP fonctionne-t-il avec Claude.ai dans le navigateur ?
MCP est supporté dans Claude Desktop et Claude Code. Claude.ai basé sur navigateur ne supporte pas MCP à partir du milieu de 2026. Pour les workflows alimentés par MCP, utilisez Claude Desktop ou Claude Code avec un abonnement Claude Max (disponible gratuitement via FreeClaude).
Comment Claude décide-t-il quel outil MCP utiliser ?
Claude lit le nom et la description de chaque outil disponible et utilise son jugement pour déterminer quels outils sont pertinents. C'est pourquoi les descriptions d'outils sont critiques — une description vague conduit à une sélection d'outil incorrecte. Écrivez des descriptions qui énoncent clairement ce que fait l'outil, quelles données il retourne et quand il doit être utilisé.
Les serveurs MCP peuvent-ils communiquer les uns avec les autres ?
Les serveurs MCP ne communiquent pas directement — toute coordination se fait via Claude. Claude peut appeler plusieurs serveurs en séquence, en utilisant la sortie de l'un comme entrée de l'autre. Cette chaînage séquentiel est comment les workflows multi-systèmes complexes sont réalisés.
Quel est l'impact de performance des appels d'outils MCP ?
Chaque appel d'outil ajoute de la latence : le temps pour Claude de décider d'appeler l'outil, le temps d'exécution de l'outil et le temps d'incorporation du résultat. Les appels locaux simples (lectures filesystem) ajoutent des millisecondes. Les appels API distants ajoutent le temps de voyage réseau. Concevez les workflows pour regroup