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

Claude Code ne dispose pas d’un 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.

Les trois 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 sous forme de 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 plus encore.

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	Un contenu de 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 envoie 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 toutes les sessions suivantes.

# 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 toute commande claude mcp add :

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

Ajout du plugin navigateur Playwright

Le serveur MCP Playwright donne à Claude un véritable 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 aucune 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 le titre principal

Claude lancera un navigateur, naviguera jusqu’à l’URL, lira le DOM et retournera la réponse — sans aucun script 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 au moment de l’enregistrement sans les intégrer dans la commande :

claude mcp add linear -- npx -y @linear/mcp-server \
  --env LINEAR_API_KEY=votre_clé_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 avec une portée locale — il n’est actif que 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 projet
project	Toute session dans ce dépôt	.mcp.json à la racine du projet	Outil d’équipe — à versionner avec le code
user	Toute session Claude Code	~/.claude.json sous portée utilisateur	Outils globaux toujours disponibles

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

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

Ceci 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à de l’installation des prérequis.

Pour les outils à portée utilisateur qui ont un 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 des 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, issues, 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 Python/Node dans des sandbox cloud
@modelcontextprotocol/server-memory	Mémoire persistante clé-valeur 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 l’outil (le cas échéant) approprié pour chaque étape d’une tâche, en se basant uniquement sur la description de l’outil.

La logique d’acheminement à un haut niveau :

1. Au démarrage 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 envoie 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 le résultat et suggérer une correction — chaque étape utilisant un outil différent provenant potentiellement d’un serveur différent.

Exécuter l’exécution des 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 capable de lancer des 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 dans une instance sandbox. Le sandbox a 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 des outils est la même et les appels fonctionnent de la même manière. La différence réside uniquement dans le lieu d’exécution.

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

• Démarrage rapide : les instances se lancent en moyenne en moins de ~200ms, ce qui maintient une faible latence aller-retour des outils
• Facturation à la seconde : vous ne payez que pour le temps d’exécution actif, pas pour la réservation inactive
• Système de fichiers isolé : chaque instance sandbox a 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 template 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 d’utilisation d’outils

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

Novita LLM API fournit un endpoint 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-clé-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 riches en 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 longs contextes maintient les résultats d’outils antérieurs accessibles tout au long d’une session complexe.
• MiniMax M2.7 — optimisé pour la précision de l’utilisation agentique des outils, 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 pas de raisonnement approfondi.

Si vous construisez votre propre hôte MCP (plutôt que d’utiliser Claude Code), l’API LLM Novita fournit également un endpoint 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-clé-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 courant.",
                "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 des modèles fermés.

Les modèles open-weight comme backbone alternatif

Une option sous-estimée pour les workflows Claude Code fortement axés sur 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 de l’appel d’outils et le raisonnement en plusieurs é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 exécutant des sessions agentiques à volume élevé — pipelines CI, revue de code automatisée, refactoring par lots — la différence de coût compte. Novita AI donne accès à ces modèles via le même endpoint 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 à plus fort impact 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 de déclenchement
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 courant un symbole, une chaîne ou un motif regex. Appelez ceci lorsque vous devez trouver où une fonction est définie, localiser toutes les utilisations d’une variable, ou identifier les fichiers qui 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 bien plus précises et opportunes.

Quelques pratiques supplémentaires :

• Marquez clairement les outils modificateurs : 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 des portées étroites : un outil nommé « executer_tout » 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 la sortie d’erreur du 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.

Les outils sont enregistrés mais jamais appelés

Les descriptions des 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 la confirmation de l’utilisateur et Claude Code voit un timeout de connexion.

Le serveur n’est pas actif dans un nouveau projet

Vous avez enregistré avec une portée local et démarré Claude Code depuis un répertoire différent. Réajoutez-le 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 requis sont absents du schéma ou si les types ne correspondent pas, le serveur rejette l’appel. Révisez votre définition inputSchema — des schémas incomplets mènent à 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 maintiennent 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 protocolaires et d’implémentation faisant autorité.

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 un 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 de 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 comme des processus avec les autorisations dont ils ont besoin pour faire leur travail. 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 qui 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 structuré d’outils. 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

• Règles Claude Code : comment rédiger CLAUDE.md et gérer le contexte de codage agentique
• Documentation CLI Claude Code : configuration, commandes slash et intégration API LLM
• SDK Claude Code : guide Python et TypeScript
• Commande Claude MCP Add : comment installer des serveurs MCP dans Claude Code
• Claude MCP : comment configurer les 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