Accueil › Claude › MCP

Claude et le MCP : connecter Claude à tous vos outils

Le Model Context Protocol (MCP) est un standard ouvert créé par Anthropic qui permet à Claude de se connecter à vos outils (GitHub, Slack, Notion, bases de données, APIs) via une interface unifiée. Plus de 13 000 serveurs actifs et 97 millions de téléchargements SDK par mois en 2026.

Avant le MCP, chaque intégration entre une IA et un outil externe était un développement sur mesure. Un assistant connecté à Slack, GitHub et Google Drive nécessitait trois intégrations différentes, chacune avec sa propre logique et ses propres problèmes de maintenance. Le MCP transforme ce problème N×M (N outils × M applications) en N+M : chaque outil crée un seul serveur MCP, chaque application IA crée un seul client MCP. C’est souvent comparé à l’USB-C de l’intelligence artificielle.

Comment fonctionne le MCP

Le MCP repose sur une architecture client-serveur simple. Claude (via claude.ai, Claude Desktop ou Claude Code) agit comme client MCP. Les serveurs MCP sont des programmes légers qui encapsulent la logique d’accès à un service externe.

Le flux est direct : vous demandez à Claude « Crée une issue GitHub pour ce bug ». Le client MCP intégré à Claude envoie la requête au serveur MCP GitHub via JSON-RPC. Le serveur exécute l’action sur l’API GitHub et renvoie le résultat. Claude intègre la réponse dans sa conversation.

Chaque serveur MCP expose trois types d’éléments :

Tools (outils) : des actions exécutables. Exemples : create_issue, search_files, send_message. Ce sont les fonctions que Claude peut appeler.

Resources (ressources) : des données lisibles. Exemples : contenu d’un fichier, résultat d’une requête SQL, données d’un CRM. Claude peut les consulter pour enrichir ses réponses.

Prompts (instructions) : des instructions réutilisables stockées côté serveur, que Claude peut charger à la demande pour des tâches spécifiques.

Trois modes de transport sont supportés : stdio (processus local sur votre machine, latence inférieure à 5 ms, le plus simple), SSE (streaming distant) et Streamable HTTP (recommandé pour la production cloud, introduit en mars 2025).

Les connecteurs dans Claude (claude.ai)

Pour les utilisateurs non techniques, Claude intègre un répertoire de plus de 75 connecteurs natifs, directement accessibles depuis l’interface sans configuration technique.

Allez dans Paramètres → Connecteurs. Parcourez le répertoire. Cliquez « Ajouter » sur chaque outil que vous utilisez. Authentifiez-vous via OAuth. Le connecteur est actif.

Les connecteurs les plus utilisés incluent : Google Drive (lecture et édition de documents), Gmail (lecture et envoi d’e-mails), Slack (messages, résumés de fils), Notion (pages et bases de données), HubSpot (contacts et deals), Figma (designs et composants), GitHub (repos, issues, PRs), Salesforce (CRM), Asana (tâches et projets), Box (fichiers), et bien d’autres.

Les connecteurs de base sont disponibles sur le plan gratuit. Le support MCP complet (connecteurs personnalisés, serveurs MCP locaux) est réservé aux plans payants (Pro, Max, Team, Enterprise). L’intégration MCP dans les Artifacts est aussi disponible sur les plans payants.

MCP dans Claude Code (développeurs)

Pour les développeurs, Claude Code offre une intégration MCP native depuis le terminal. Vous pouvez connecter Claude Code à n’importe quel serveur MCP en quelques commandes.

Ajouter un serveur MCP

La commande de base :

# Serveur distant via HTTP
claude mcp add --transport http mon-serveur https://url-du-serveur/mcp

# Serveur local via stdio (le plus courant)
claude mcp add github -e GITHUB_TOKEN=ghp_xxx 
  -- npx -y @modelcontextprotocol/server-github

# Serveur Brave Search
claude mcp add brave-search 
  -e BRAVE_API_KEY=votre_cle 
  -- npx -y @anthropic/mcp-server-brave-search

# Serveur Playwright (contrôle de navigateur)
claude mcp add playwright 
  -- npx -y @anthropic/mcp-server-playwright

Commandes de gestion :

# Lister les serveurs configurés
claude mcp list

# Supprimer un serveur
claude mcp remove nom-du-serveur

# Diagnostiquer depuis une session Claude Code
/mcp

La configuration est stockée dans un fichier JSON (portée projet ou globale). Portée projet : la configuration est dans le dossier du projet et partageable via Git (sans les secrets). Portée globale : la configuration s’applique à toutes vos sessions Claude Code.

Les 3 serveurs essentiels

GitHub (@modelcontextprotocol/server-github) expose 15 outils couvrant issues, pull requests, fichiers et recherche. C’est le serveur le plus installé : 92 % des utilisateurs Claude Code avec MCP l’activent en premier. Nécessite un token fine-grained avec les permissions repo et issues.

Brave Search (@anthropic/mcp-server-brave-search) donne à Claude Code un accès à la recherche web. Le plan gratuit Brave offre 2 000 requêtes par mois, suffisant pour la plupart des usages de développement.

Playwright (@anthropic/mcp-server-playwright) permet à Claude Code de contrôler un navigateur : naviguer, cliquer, capturer des screenshots et extraire du contenu. Idéal pour les tests end-to-end et le scraping.

Ce trio couvre environ 90 % des besoins de développement. Ajoutez des serveurs supplémentaires (PostgreSQL, Sentry, Jira, Figma) selon vos besoins spécifiques.

MCP via l’API Claude

L’API Claude supporte les outils MCP via le paramètre tools de la Messages API. Convertissez les définitions inputSchema d’un serveur MCP vers le format Claude :

from mcp import ClientSession

async def get_claude_tools(mcp_session: ClientSession):
    mcp_tools = await mcp_session.list_tools()
    return [
        {
            "name": tool.name,
            "description": tool.description or "",
            "input_schema": tool.inputSchema,
        }
        for tool in mcp_tools.tools
    ]

# Utilisation avec l'API Claude
claude_tools = await get_claude_tools(mcp_session)
response = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=1024,
    tools=claude_tools,
    messages=[{"role": "user", "content": "Votre requête"}],
)

Le MCP Connector (en beta publique) permet aussi de connecter directement des serveurs MCP distants depuis la Messages API via le paramètre mcp_servers, sans gérer le client MCP vous-même.

MCP dans Claude Desktop

Claude Desktop (macOS et Windows) supporte les serveurs MCP locaux via un fichier de configuration JSON. Le fichier se trouve à :

macOS : ~/Library/Application Support/Claude/settings.json

Linux : ~/.config/Claude/settings.json

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem",
               "/Users/vous/Documents"],
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_votre_token"
      }
    }
  }
}

Après avoir sauvegardé la configuration, redémarrez complètement Claude Desktop. Un indicateur de serveur MCP apparaît dans le coin inférieur droit de la zone de saisie. Cliquez dessus pour voir les outils disponibles. Node.js est requis pour la plupart des serveurs MCP.

L’avantage de l’intégration Desktop : Claude peut interagir avec votre système de fichiers local, créer des documents, organiser des dossiers et rechercher des fichiers, le tout avec votre approbation explicite à chaque action.

Sécurité et bonnes pratiques

Le MCP donne à Claude la capacité d’exécuter des actions et d’accéder à des données. Cette puissance implique des responsabilités de sécurité importantes.

Consentement explicite. Claude demande votre approbation avant chaque action via un outil MCP. Aucune opération n’est exécutée automatiquement sans validation humaine. Vous pouvez accorder des permissions « always allow » pour les outils de confiance, mais commencez par du cas par cas.

Gestion des secrets. Ne versionnez jamais vos tokens ou clés API dans un dépôt Git. Utilisez des variables d’environnement ou un gestionnaire de secrets. Rotation recommandée : tous les 90 jours.

Contrôle des outputs. Les serveurs MCP qui renvoient de gros volumes de données consomment votre fenêtre de contexte. Configurez MAX_MCP_OUTPUT_TOKENS (défaut : 25 000 tokens) pour limiter la consommation. Au-delà de 10 000 tokens, Claude Code affiche un avertissement.

Audit des serveurs. Avant d’installer un serveur MCP communautaire, vérifiez sa source, son mainteneur et ses permissions. Les serveurs officiels Anthropic (@modelcontextprotocol/* et @anthropic/*) sont vérifiés. Les serveurs communautaires doivent être audités avant usage en production.

MCP Tool Search. Quand vous avez beaucoup de serveurs MCP configurés, les définitions d’outils peuvent consommer une part importante de votre contexte. Le MCP Tool Search (activé par défaut dans Claude Code) résout ce problème en chargeant les outils dynamiquement à la demande plutôt que de tous les précharger.

L’écosystème MCP : timeline et adoption

Le MCP a connu une adoption fulgurante depuis son lancement. Voici les étapes clés.

Novembre 2024 : Anthropic lance le MCP comme standard ouvert. Les premiers serveurs (filesystem, GitHub) sont publiés. Le protocole utilise JSON-RPC 2.0 et supporte le transport stdio.

Mars 2025 : lancement de la spécification v2 avec Streamable HTTP et OAuth 2.1. OpenAI adopte officiellement MCP dans son Agents SDK et ChatGPT Desktop.

Mi-2025 : Google DeepMind confirme le support MCP dans Gemini. Microsoft intègre MCP dans Windows, Azure, Foundry et Copilot. L’adoption atteint +340 % sur l’année.

Décembre 2025 : Anthropic donne le MCP à la Linux Foundation via la création de l’AAIF (Agentic AI Foundation), co-fondée avec Block et OpenAI, avec le soutien de Google, Microsoft, AWS et Cloudflare.

Début 2026 : mise à jour majeure de la spécification avec opérations asynchrones, identité des serveurs et registre officiel communautaire. L’écosystème dépasse 13 000 serveurs actifs. Claude intègre plus de 75 connecteurs natifs. Les SDKs totalisent 97 millions de téléchargements mensuels.

Le MCP n’est plus un protocole Anthropic exclusif. C’est un standard de l’industrie soutenu par tous les acteurs majeurs, avec une gouvernance ouverte sous la Linux Foundation.

Cas d’usage concrets du MCP avec Claude

Voici des exemples de workflows réels rendus possibles par les connecteurs MCP.

Développement logiciel de bout en bout

Avec GitHub, Sentry et une base de données connectés via MCP, vous pouvez demander à Claude Code : « Vérifie les issues ouvertes dans JIRA ENG-4521, implémente le correctif, crée les tests, vérifie que Sentry ne remonte plus l’erreur, et ouvre une PR sur GitHub. » Claude Code planifie les étapes, interroge chaque serveur MCP au bon moment, et exécute le workflow complet en autonomie.

Analyse de données cross-sources

Connectez PostgreSQL, Google Sheets et Slack. Demandez : « Trouve les 10 utilisateurs les plus actifs sur la feature X cette semaine (base de données), compare avec les retours qu’ils ont partagés dans le canal #feedback (Slack), et génère un rapport dans Google Sheets avec les insights. » Claude orchestre les trois sources et synthétise les résultats.

Gestion de projet automatisée

Avec Asana ou Jira, Gmail et Google Calendar connectés : « Résume les tâches en retard dans le sprint actuel, envoie un e-mail de relance aux responsables, et bloque un créneau de 30 minutes demain pour une réunion de rattrapage. » Chaque action passe par le serveur MCP correspondant, avec votre validation avant exécution.

Veille et recherche

Avec Brave Search et le filesystem : « Recherche les dernières publications sur le fine-tuning de LLM pour le secteur médical, résume les 5 articles les plus pertinents, et sauvegarde le résumé dans mon dossier Recherche/LLM-Medical. » Le serveur Brave Search fournit les résultats, Claude les analyse, et le serveur filesystem écrit le fichier.

Design et développement frontend

Avec Figma connecté via MCP : « Récupère les derniers designs de la page d’accueil depuis Figma, et mets à jour notre template e-mail standard pour correspondre aux nouvelles maquettes. » Claude lit les composants Figma, comprend les styles et les layouts, et génère le code correspondant.

Créer votre propre serveur MCP

Si votre outil interne n’a pas de serveur MCP existant, vous pouvez en créer un en quelques dizaines de lignes. Voici la structure minimale en TypeScript :

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport }
  from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new McpServer({
  name: "mon-outil-interne",
  version: "1.0.0"
});

// Définir un outil
server.tool(
  "rechercher_client",
  "Recherche un client par nom ou email",
  {
    query: { type: "string", description: "Nom ou email" }
  },
  async ({ query }) => {
    // Votre logique métier ici
    const result = await votreAPI.rechercherClient(query);
    return {
      content: [{
        type: "text",
        text: JSON.stringify(result, null, 2)
      }]
    };
  }
);

// Démarrer le serveur
const transport = new StdioServerTransport();
await server.connect(transport);

Le SDK officiel (@modelcontextprotocol/sdk) est disponible en Python, TypeScript, C# et Java. La documentation complète avec des exemples pour chaque langage est sur modelcontextprotocol.io. Le temps de développement typique pour un serveur MCP simple est de 1 à 2 heures.

Pour une vue d’ensemble du protocole et de son architecture technique, consultez notre page Guide du protocole MCP dans la section Guides.