Plugins Claude Code : Comment les outils MCP étendent Claude Code avec des capacités externes

Claude Code ne possède pas de système de plugins traditionnel avec une place de marché et des installations en un clic. Il utilise le Model Context Protocol (MCP), un standard ouvert d’Anthropic pour attacher des outils externes à une session Claude Code. Les serveurs MCP fonctionnent comme des plugins : ils exposent des outils appelables, Claude décide quand les utiliser, et le résultat est réinjecté dans la conversation. Ce guide explique le modèle d’extension ; pour une configuration CLI et JSON prête à l’emploi, consultez le guide de configuration MCP Claude.

Ce que signifient réellement les « plugins Claude Code »

Lorsque les développeurs recherchent « plugins Claude Code », ils veulent généralement l’une des trois choses suivantes : un moyen de donner à Claude Code l’accès à un service externe (GitHub, une base de données, un navigateur web), un moyen d’installer des extensions communautaires, ou une documentation sur le fonctionnement du mécanisme d’extension.

Ces trois demandes mènent à MCP. Anthropic a conçu Claude Code autour du Model Context Protocol plutôt que d’un format de plugin propriétaire. Cela signifie :

• Pas de place de marché séparée : les outils sont distribués en tant que serveurs MCP, et non via un registre spécifique à une plateforme
• Pas de verrouillage au niveau API : tout développeur peut construire un serveur et le partager
• Même surface d’intégration : Claude Code, Claude Desktop et les autres hôtes Claude utilisent tous le même protocole

L’effet pratique est que le catalogue de plugins de Claude Code est l’écosystème MCP — tout serveur construit selon la spécification MCP fonctionne avec Claude Code, et des milliers existent déjà pour les bases de données, les API, les navigateurs, les exécuteurs de code, les systèmes de fichiers, et bien plus.

Il n’existe pas de commande claude plugin install. L’équivalent est claude mcp add.

Comment les serveurs MCP fonctionnent comme plugins

Chaque serveur MCP est un processus qui expose un ensemble d’outils via le protocole MCP. Claude Code lance ou se connecte aux serveurs enregistrés lorsque vous démarrez une session, les interroge pour obtenir leurs listes d’outils, puis utilise ces outils lorsque la conversation le nécessite.

Trois éléments composent l’interface d’un serveur MCP :

Objet	Ce que c’est	Exemple
Outil	Une fonction appelable avec des entrées et sorties définies	run_python, search_docs, create_issue
Ressource	Données en lecture seule que le serveur expose comme contexte	Le contenu d’un fichier, une ligne de base de données, un fixture de test
Prompt	Modèles d’instructions préconstruits fournis avec le serveur	Une checklist de revue de code, un modèle de tâche

Pour la plupart des workflows Claude Code, ce sont les outils qui comptent. Les ressources et les prompts entrent en jeu lorsque vous construisez des pipelines agentiques plus structurés.

La séquence clé du protocole :

1. Claude Code démarre, lit sa configuration et lance les serveurs enregistrés
2. Chaque serveur répond à une requête tools/list avec des noms et des définitions JSON Schema
3. Pendant une session, Claude utilise ces définitions pour décider quand et comment appeler chaque outil
4. Claude Code émet l’appel, le serveur exécute et retourne le résultat, Claude intègre le résultat et continue

Le serveur gère l’exécution. Claude gère le raisonnement sur le moment où l’exécution est nécessaire.

Installer votre premier plugin avec claude mcp add

claude mcp add est la commande qui enregistre un serveur MCP auprès de Claude Code. Exécutez-la une fois ; le serveur est disponible dans chaque session ultérieure.

# Forme de base pour les serveurs stdio
claude mcp add <nom-serveur> -- <commande> [args...]

# Forme de base pour les serveurs HTTP
claude mcp add --transport http <nom-serveur> <url>

Prérequis avant d’exécuter une commande claude mcp add :

• Claude Code installé et dans votre PATH (claude --version doit fonctionner)
• Node.js 18 ou version ultérieure pour les serveurs npm
• Python 3.10 ou version ultérieure pour les serveurs Python

Ajout du plugin navigateur Playwright

Le serveur MCP Playwright donne à Claude un vrai navigateur — il peut naviguer sur des URL, cliquer sur des éléments, extraire du texte et retourner des captures d’écran. C’est l’un des premiers plugins les plus utiles à ajouter car il ne nécessite pas de clé API et démontre immédiatement ce que le protocole peut faire.

claude mcp add playwright -- npx -y @playwright/mcp@latest

Vérifiez qu’il est enregistré :

claude mcp list

Ouvrez ensuite une session :

Utilise playwright pour ouvrir https://example.com et dis-moi le titre de la page et l'en-tête principal

Claude lancera un navigateur, naviguera vers l’URL, lira le DOM et retournera la réponse — sans aucun script requis de votre part.

Ajout d’un plugin de base de données

Le serveur MCP SQLite officiel permet à Claude d’interroger et d’inspecter une base de données SQLite locale directement depuis la conversation :

claude mcp add sqlite -- uvx mcp-server-sqlite --db-path /chemin/vers/votre/base.db

Après cela, vous pouvez demander à Claude d’écrire des requêtes, d’expliquer le schéma ou d’explorer les données directement sans copier-coller les définitions de schéma dans chaque prompt.

Passage de variables d’environnement

La plupart des serveurs adossés à une API ont besoin de clés. Utilisez --env pour les passer lors de l’enregistrement sans les intégrer dans la commande :

claude mcp add linear -- npx -y @linear/mcp-server \
  --env LINEAR_API_KEY=votre_cle_ici

Les valeurs sont stockées dans la configuration de Claude Code et injectées dans le processus du serveur au démarrage.

Portées : locale, projet et utilisateur

Par défaut, claude mcp add enregistre un serveur en portée locale — il est actif uniquement lorsque Claude Code est démarré depuis le répertoire courant. Trois options de portée offrent différents modèles de partage :

Portée	Active dans	Fichier de configuration	Quand l’utiliser
local (par défaut)	Répertoire courant uniquement	~/.claude.json	Serveur de développement personnel pour un seul projet
project	Toute session dans ce dépôt	.mcp.json à la racine du projet	Outil d’équipe — à commiter avec le code
user	Chaque session Claude Code	~/.claude.json sous portée utilisateur	Outils globaux que vous voulez toujours avoir disponibles

Ajoutez --scope project pour commiter la définition du serveur avec votre dépôt :

claude mcp add sqlite --scope project -- uvx mcp-server-sqlite --db-path ./dev.db

Cela crée .mcp.json à la racine du projet avec la définition du serveur. Les membres de l’équipe qui exécutent Claude Code dans le même dépôt obtiennent le même outil disponible automatiquement — aucune configuration par développeur au-delà des prérequis installés.

Pour les outils en portée utilisateur qui ont du sens partout :

claude mcp add playwright --scope user -- npx -y @playwright/mcp@latest

Plugins MCP populaires et ce qu’ils font

L’écosystème MCP a considérablement grandi depuis qu’Anthropic a publié le protocole. Quelques catégories avec une utilisation réelle :

Outils de développement

Serveur	Ce qu’il ajoute
@playwright/mcp	Automatisation de navigateur — naviguer, cliquer, extraire, capturer
@modelcontextprotocol/server-git	Lire les commits, diffs, branches, blâme depuis les dépôts locaux
@modelcontextprotocol/server-filesystem	Accès au système de fichiers limité — lire/écrire des fichiers dans des chemins définis
mcp-server-sqlite	Interroger et inspecter des bases de données SQLite

Services et API

Serveur	Ce qu’il ajoute
@linear/mcp-server	Créer, lire et mettre à jour des tickets Linear
@sentry/mcp-server	Interroger les erreurs et traces Sentry
@modelcontextprotocol/server-github	Dépôts GitHub, tickets, PRs et recherche de code
@notionhq/notion-mcp-server	Lire et écrire des pages et bases de données Notion

IA et exécution de code

Serveur	Ce qu’il ajoute
Serveur MCP Novita Sandbox	Exécution isolée de Python/Node dans des sandbox cloud
@modelcontextprotocol/server-memory	Mémoire clé-valeur persistante entre les sessions

Ces plugins sont installables via claude mcp add avec npx pour les paquets npm ou uvx/pip pour les paquets Python.

Comment Claude achemine les appels d’outils à l’exécution

Claude n’appelle pas les outils de manière aléatoire ou exhaustive. Il raisonne sur quel outil (le cas échéant) est approprié pour chaque étape d’une tâche, en se basant uniquement sur la description de l’outil.

La logique d’acheminement à un niveau élevé :

1. Au début de la session, Claude interroge tous les serveurs enregistrés et construit un catalogue d’outils
2. Pour chaque message utilisateur ou étape de tâche, Claude évalue si une description d’outil correspond à ce qui est nécessaire
3. Si une correspondance semble prometteuse, Claude construit un appel avec les arguments appropriés basés sur le JSON Schema de l’outil
4. Claude Code émet l’appel, attend le résultat et l’intègre avant l’étape suivante

Une conséquence : les descriptions d’outils sont cruciales. Une description vague comme « outil utile » fera que l’outil ne sera jamais appelé. Une description qui dit exactement ce que fait l’outil, quand l’appeler et à quoi ressemblent ses entrées et sorties conduit à une utilisation précise et fiable.

Si vous construisez votre propre serveur MCP et que les outils ne sont pas appelés malgré leur enregistrement, la description est presque toujours le problème — pas l’implémentation.

Claude peut également enchaîner les appels d’outils en un seul tour : lire un fichier pour comprendre le contexte, rechercher une dépendance, exécuter un test, vérifier la sortie et suggérer une correction — chaque étape utilisant un outil différent provenant potentiellement d’un serveur différent.

Exécution de plugins dans un sandbox

Lorsque les plugins exécutent du code — scripts Python, commandes shell, automatisation de navigateur — les exécuter sur votre machine locale comporte des risques. Un outil avec accès au système de fichiers ou capacité de lancement de processus a une large surface d’attaque s’il se comporte mal ou reçoit un prompt malformé.

Novita Agent Sandbox répond à ce problème en fournissant des environnements cloud isolés pour l’exécution des outils. Au lieu d’exécuter votre serveur MCP localement, vous le déployez à l’intérieur d’une instance sandbox. Le sandbox possède son propre système de fichiers, périmètre réseau et limites de ressources. L’exécution des outils se fait à l’intérieur de cette frontière sans toucher à la machine hôte.

Du point de vue de Claude, l’intégration est identique — la liste d’outils est la même et les appels fonctionnent de la même manière. La différence réside uniquement dans l’endroit où l’exécution a lieu.

Caractéristiques clés de Novita Sandbox pour l’exécution d’outils MCP :

• Démarrage rapide : les instances se lancent en moins de ~200ms en moyenne, ce qui maintient une faible latence d’aller-retour des outils
• Facturation à la seconde : vous payez uniquement pour le temps d’exécution actif, pas pour la réservation inactive
• Système de fichiers isolé : chaque instance sandbox dispose d’un espace de travail séparé, empêchant les fuites entre sessions
• Périmètre réseau configurable : contrôlez les services externes auxquels l’outil peut accéder

Pour utiliser le SDK Novita Sandbox dans un gestionnaire d’outils MCP :

pip install novita-sandbox

from novita_sandbox.code_interpreter import Sandbox

def execute_code(code: str, api_key: str) -> dict:
    sandbox = Sandbox.create(
        template="code-interpreter-v1",
        api_key=api_key,
        domain="sandbox.novita.ai",
        timeout=300,
    )
    result = sandbox.run_code(code, language="python")
    sandbox.kill()
    return {
        "output": result.logs,
        "error": result.error,
    }

Le modèle code-interpreter-v1 est livré avec pandas, numpy, matplotlib et d’autres paquets courants préinstallés. Pour une procédure complète, consultez Construire un serveur MCP d’exécution de code à distance avec Novita Sandbox et la bibliothèque mcp-use.

Utilisation de l’API LLM Novita pour le raisonnement lié aux outils

Claude Code gère le raisonnement lié aux outils en utilisant le modèle configuré comme moteur backend. Si vous acheminez Claude Code via un fournisseur alternatif — pour des raisons de coût, de latence ou d’accès aux modèles — la couche de raisonnement pour les appels d’outils passe également par ce fournisseur.

Novita LLM API fournit un point de terminaison compatible Anthropic à l’adresse https://api.novita.ai/anthropic. Configurez-le une fois avec trois variables d’environnement :

export ANTHROPIC_BASE_URL="https://api.novita.ai/anthropic"
export ANTHROPIC_AUTH_TOKEN="votre-cle-api-novita"
export ANTHROPIC_MODEL="qwen/qwen3-coder-480b-a35b-instruct"
export ANTHROPIC_SMALL_FAST_MODEL="deepseek/deepseek-v4-flash"

Avec cette configuration, les appels d’outils MCP de Claude Code continuent de fonctionner exactement comme avant. L’acheminement affecte le modèle qui effectue le raisonnement — pas le mécanisme de répartition des outils, qui reste au niveau de Claude Code.

Choix de modèles pour les sessions avec beaucoup d’outils :

• Qwen3-Coder 480B — bien adapté aux tâches à long horizon où Claude doit lire de nombreux fichiers, planifier une séquence en plusieurs étapes et appeler des outils à chaque étape. Sa gestion des contextes longs maintient l’accessibilité des résultats d’outils précédents tout au long d’une session complexe.
• MiniMax M2.7 — optimisé pour la précision d’utilisation des outils agentiques, spécifiquement conçu pour réduire les invocations incorrectes d’outils et gérer les séquences multi-tours où chaque étape s’appuie sur le résultat précédent.
• DeepSeek V4 Flash — rapide et économique, un bon choix pour ANTHROPIC_SMALL_FAST_MODEL. Claude Code utilise cet emplacement pour la synthèse de session et la compression de contexte, qui ne nécessitent ni l’une ni l’autre un raisonnement approfondi.

Si vous construisez votre propre hôte MCP (plutôt que d’utiliser Claude Code), l’API LLM Novita fournit également un point de terminaison compatible OpenAI à l’adresse https://api.novita.ai/v3/openai pour les modèles prenant en charge l’appel de fonction :

import openai

client = openai.OpenAI(
    base_url="https://api.novita.ai/v3/openai",
    api_key="votre-cle-api-novita",
)

response = client.chat.completions.create(
    model="meta-llama/llama-3.3-70b-instruct",
    messages=[{"role": "user", "content": "Liste les outils disponibles et effectue une vérification rapide"}],
    tools=[
        {
            "type": "function",
            "function": {
                "name": "list_files",
                "description": "Liste les fichiers dans le répertoire de travail actuel.",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "path": {
                            "type": "string",
                            "description": "Chemin du répertoire à lister."
                        }
                    },
                    "required": ["path"]
                }
            }
        }
    ],
    tool_choice="auto",
)

Ceci est particulièrement utile pour les scénarios où vous souhaitez qu’un modèle open-weight agisse comme couche de raisonnement dans un pipeline MCP personnalisé, avec des caractéristiques de coût ou de latence différentes de celles des modèles fermés.

Les modèles open-weight comme alternative

Une option souvent sous-estimée pour les workflows Claude Code intensifs en MCP consiste à remplacer entièrement le modèle Claude par défaut par une alternative open-weight compétente. Des modèles comme Qwen3-Coder, MiniMax M2.7 et DeepSeek V3.1 ont été spécifiquement entraînés pour la précision d’appel d’outils et le raisonnement multi-étapes — dans certains benchmarks, ils égalent ou dépassent les modèles closed-source sur les tâches d’appel de fonction, pour une fraction du coût.

Pour les équipes gérant des sessions agentiques à volume élevé — pipelines CI, revue de code automatisée, refactoring par lots — la différence de coût est importante. Novita AI donne accès à ces modèles via le même point de terminaison compatible Anthropic, donc le changement est une modification de configuration, pas une réécriture de code.

Rédiger des descriptions d’outils qui fonctionnent

Si vous construisez votre propre serveur MCP pour Claude Code, la qualité de vos descriptions d’outils détermine si Claude utilise vos outils efficacement. C’est la chose la plus importante que vous puissiez faire pour un serveur personnalisé.

Une description d’outil qui fonctionne répond à trois questions :

1. Que fait l’outil ? — concret, pas abstrait
2. Quand doit-il être appelé ? — le scénario ou la condition déclencheuse
3. Quelles sont les entrées et sorties ? — assez pour que Claude puisse construire des arguments corrects

Comparez ces deux descriptions pour le même outil search_codebase :

Mauvaise : « Recherche dans la base de code. »

Efficace : « Recherche dans les fichiers source du dépôt actuel un symbole, une chaîne ou un motif regex. Appelez ceci lorsque vous avez besoin de trouver où une fonction est définie, de localiser toutes les utilisations d’une variable ou d’identifier quels fichiers référencent un module particulier. Retourne une liste de chemins de fichiers avec les lignes correspondantes et les numéros de ligne. »

La deuxième description indique à Claude quand appeler l’outil (pas seulement ce qu’il fait), ce qui produit des invocations beaucoup plus précises et opportunes.

Quelques pratiques supplémentaires :

• Marquez clairement les outils mutateurs : si un outil écrit dans une base de données ou déploie du code, dites-le explicitement. Claude sera plus prudent avant de l’appeler sans preuve claire que l’action est intentionnelle.
• Expliquez les formes de retour : si l’outil retourne un objet JSON avec une structure spécifique, décrivez les champs clés. Claude utilise ces informations pour extraire les bonnes données pour l’étape suivante.
• Gardez les portées étroites : un outil nommé « tout_executer » qui accepte des commandes shell arbitraires est plus difficile à raisonner pour Claude qu’un outil « executer_tests » qui exécute la suite de tests du projet. Les outils étroits avec des descriptions précises fonctionnent mieux que les outils larges avec des descriptions vagues.

Dépannage des problèmes courants de plugins

L’outil n’apparaît pas après claude mcp add

Vérifiez que la commande du serveur s’exécute sans erreur dans un terminal frais. Claude Code peut supprimer les stderr des sous-processus. Exécutez claude mcp list — si le serveur affiche un timeout ou une erreur, c’est la commande elle-même qui échoue, pas la configuration.

Outils enregistrés mais jamais appelés

Les descriptions d’outils sont trop vagues. Réécrivez-les pour spécifier quand Claude doit appeler l’outil et ce que signifient les arguments.

npx bloque au premier lancement

Ajoutez le drapeau -y pour accepter automatiquement l’invite d’installation : npx -y @package/mcp-server. Sans cela, npx attend une confirmation utilisateur et Claude Code voit un timeout de connexion.

Serveur inactif dans un nouveau projet

Vous avez enregistré en portée local et démarré Claude Code depuis un répertoire différent. Réajoutez avec --scope user pour un serveur global ou exécutez la commande add depuis la racine du projet correcte.

Les appels d’outils échouent avec des erreurs de validation de schéma

Claude construit les arguments basés sur le JSON Schema de l’outil. Si des champs obligatoires sont absents du schéma ou si les types ne correspondent pas, le serveur rejette l’appel. Revoyez votre définition inputSchema — des schémas incomplets conduisent à des arguments d’appel incomplets.

Commande claude mcp add introuvable

Installez Claude Code : npm install -g @anthropic-ai/claude-code, puis vérifiez avec claude --version.

FAQ

Claude Code a-t-il une place de marché de plugins ?

Pas au sens traditionnel. Claude Code utilise le protocole MCP plutôt qu’une place de marché spécifique à une plateforme. Les serveurs MCP communautaires sont publiés sur npm, PyPI et GitHub. Certains agrégateurs tiennent des listes organisées, mais il n’existe pas de place de marché officielle Claude Code à parcourir.

Quelle est la documentation des plugins Claude Code ?

La documentation officielle d’Anthropic pour l’intégration MCP de Claude Code se trouve sur docs.anthropic.com/claude-code. La spécification MCP elle-même se trouve sur modelcontextprotocol.io. Ce sont les deux sources à consulter pour les détails officiels du protocole et de l’implémentation.

En quoi un serveur MCP est-il différent d’un plugin Claude Code ?

Les termes désignent la même chose dans le contexte de Claude Code. Lorsque les développeurs disent « plugin Claude Code », ils veulent généralement dire un serveur MCP connecté à Claude Code. Le mot « plugin » n’est pas la terminologie officielle d’Anthropic, mais le concept correspond directement : installer une fois, utiliser dans chaque session, étend les capacités de Claude avec de nouveaux outils.

Puis-je utiliser le même serveur MCP dans Claude Desktop et Claude Code ?

Oui. Le serveur est indépendant du protocole — il ne se soucie pas de l’hôte qui se connecte. Pour les serveurs stdio, Claude Code (via claude mcp add) et Claude Desktop (via le fichier de configuration JSON) peuvent lancer la même commande. Pour les serveurs HTTP, tout hôte pouvant atteindre l’URL peut se connecter.

Combien de serveurs MCP puis-je enregistrer ?

Le protocole MCP et Claude Code n’imposent pas de limite stricte. En pratique, avoir de nombreux serveurs avec des centaines d’outils peut ralentir le démarrage de la session (la découverte des outils s’exécute au lancement) et ajouter du bruit à la sélection d’outils par Claude. Gardez l’ensemble actif concentré sur ce dont une session donnée a réellement besoin.

Y a-t-il des risques de sécurité à ajouter des plugins MCP ?

Oui. Les serveurs MCP s’exécutent en tant que processus avec les autorisations nécessaires à leur fonctionnement. Un serveur avec accès au système de fichiers peut lire ou écrire des fichiers ; un serveur avec exécution shell peut exécuter des commandes arbitraires. N’ajoutez que des serveurs en lesquels vous avez confiance. Pour les environnements de production ou partagés, envisagez d’exécuter les serveurs dans des environnements isolés — voir la section sandbox ci-dessus.

Les modèles open-weight prennent-ils en charge l’appel d’outils MCP ?

Oui. Les modèles qui implémentent l’appel de fonction dans le format de l’API de messages Anthropic fonctionnent avec la couche MCP de Claude Code, quel que soit le fournisseur. Qwen3-Coder, MiniMax M2.7 et DeepSeek V3.1 prennent tous en charge l’appel d’outils structuré. La répartition des outils est gérée par Claude Code ; le modèle doit seulement retourner des instructions d’appel d’outils valides dans le format attendu.

---

Articles recommandés

• Commande Claude MCP Add : Comment installer des serveurs MCP dans Claude Code
• Claude MCP : Comment configurer des serveurs MCP dans Claude Code et Claude Desktop
• Construire un serveur MCP d’exécution de code à distance avec Novita Sandbox et la bibliothèque mcp-use