Serveur MCP WordPress : le guide complet d'installation (MCP Adapter, Claude & agents IA)

L'adaptateur MCP officiel de WordPress transforme les « abilities » (capacités) WordPress approuvées en outils, ressources et prompts que des agents IA compatibles peuvent découvrir et invoquer. Ce guide explique comment installer l'adaptateur, exposer des capacités en toute sécurité, connecter Claude Desktop ou Claude Code, et construire des workflows utiles de lecture, de proposition de brouillons et WooCommerce — sans donner à une IA un accès administrateur illimité.[^1][^2]

> Vous cherchez l'architecture IA WordPress dans son ensemble ? Lisez Claude, Gemini et OpenAI dans WordPress : connecteurs IA, AI Client et MCP expliqués. Ce guide explique l'AI Client, les connecteurs de fournisseurs, le plugin IA canonique, l'Abilities API et le MCP. Cet article-ci se concentre spécifiquement sur le déploiement d'un serveur MCP WordPress.

Qu'est-ce que le MCP WordPress ?

Le Model Context Protocol, ou MCP, est un standard grâce auquel des clients IA peuvent découvrir des outils, ressources et prompts structurés exposés par des systèmes externes. Dans WordPress, l'adaptateur MCP officiel fait le pont entre l'Abilities API et le MCP : une capacité WordPress peut devenir quelque chose qu'un agent autorisé peut inspecter et exécuter.[^3][^2]

Le sens du flux compte :

• AI Client + connecteur de fournisseur : WordPress appelle un modèle IA.
• Adaptateur MCP : un client IA externe appelle des capacités WordPress approuvées.

L'adaptateur MCP n'inclut pas Claude, ChatGPT ou un autre modèle. Il ne donne pas non plus automatiquement à un agent l'accès aux articles, aux réglages ou à WooCommerce. Il fournit la couche serveur et transport à travers laquelle des capacités explicitement exposées peuvent être utilisées.[^4]

Prérequis

Les exigences minimales officielles sont WordPress 6.9 et PHP 7.4, car l'Abilities API est entrée dans le noyau de WordPress en version 6.9. Pour un nouveau déploiement, WordPress 7.1 ou supérieur est recommandé, car la version 7.1 a étendu la découverte des capacités, leur validation et la prise en charge de l'exposition publique.[^5]

Préparez les éléments suivants :

• WordPress 7.1+ avec HTTPS
• PHP 7.4+ ; utilisez si possible une branche PHP actuellement maintenue
• Un accès administrateur pour l'installation
• Un compte WordPress dédié pour le client MCP
• Des mots de passe d'application WordPress pour l'authentification HTTP distante
• WP-CLI pour les configurations STDIO locales et le diagnostic
• Node.js et npx en cas d'utilisation de la configuration officielle de proxy HTTP-vers-STDIO
• Un environnement de pré-production pour le premier déploiement
• Un client MCP compatible tel que Claude Desktop ou Claude Code

Créer un utilisateur dédié

Ne connectez pas un compte administrateur du quotidien, sauf si les capacités prévues nécessitent réellement des privilèges d'administrateur. Créez un compte dédié tel que mcp-reader, mcp-editor ou mcp-commerce-reviewer, attribuez-lui le rôle le plus restreint possible, et créez un mot de passe d'application distinct sous le profil de cet utilisateur.

Les mots de passe d'application sont le mécanisme standard recommandé par WordPress pour l'accès REST externe. Ils peuvent être révoqués indépendamment, sans changer le mot de passe habituel de l'utilisateur.[^6]

Définir d'abord le modèle d'accès

Avant l'installation, décidez de ce que l'agent doit être autorisé à faire :

Cette conception détermine le rôle WordPress, les permission callbacks et les capacités à exposer.

Installer l'adaptateur MCP

L'adaptateur MCP est devenu disponible dans le répertoire des extensions WordPress en tant que plugin canonique en octobre 2026. Il reste expérimental pendant que le projet travaille vers une version stable 1.0.

Depuis l'administration WordPress

1. Ouvrez Extensions → Ajouter une extension. 2. Recherchez MCP Adapter par WordPress.org. 3. Installez et activez l'extension. 4. Vérifiez que les permaliens WordPress et l'API REST fonctionnent.

L'adaptateur n'a volontairement pas d'interface complète de gestion des agents. Son activation enregistre son infrastructure serveur et son endpoint MCP par défaut ; les capacités et les identifiants des clients sont gérés via le code WordPress, les utilisateurs et le client MCP externe.[^7][^4]

Avec WP-CLI

wp plugin install mcp-adapter --activate

Si le paquet du répertoire est temporairement indisponible ou qu'une version de développement spécifique est nécessaire, la documentation du projet fournit également une commande d'installation depuis une release GitHub. Les sites en production devraient privilégier une version épinglée et testée plutôt qu'une branche de développement arbitraire.[^8]

Vérifier l'extension

wp plugin status mcp-adapter

L'identifiant du serveur par défaut est :

mcp-adapter-default-server

Son endpoint distant est :

https://example.com/wp-json/mcp/mcp-adapter-default-server

Le serveur par défaut utilise le MCP Streamable HTTP et nécessite un utilisateur WordPress authentifié disposant au minimum de la capacité read, sauf si les permissions du serveur sont personnalisées.[^9]

Tester la disponibilité REST

Vérifiez d'abord l'index REST général :

curl -i https://example.com/wp-json/

Une requête GET depuis un navigateur vers l'endpoint MCP peut ne produire aucune page de succès exploitable, car la communication MCP utilise des requêtes JSON-RPC authentifiées et une poignée de main d'initialisation. Testez-le avec un véritable client MCP ou une requête authentifiée, plutôt que de supposer qu'une réponse vide dans le navigateur signifie que l'extension est cassée.[^9]

Tester via WP-CLI

WP-CLI utilise le transport STDIO de l'adaptateur et constitue le diagnostic local le plus simple :

echo '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}' | \
wp mcp-adapter serve \
  --server=mcp-adapter-default-server \
  --user=mcp-reader

La commande exécute les vérifications de permissions en tant que l'utilisateur WordPress sélectionné. Remplacez mcp-reader par le nom d'utilisateur dédié ou son identifiant.[^10]

Comment fonctionne le serveur par défaut

Le serveur par défaut ne convertit pas chaque fonction WordPress en un outil d'agent distinct. Il expose trois méta-outils qui découvrent et exécutent les capacités marquées pour une exposition publique MCP :[^11][^9]

1. mcp-adapter-discover-abilities 2. mcp-adapter-get-ability-info 3. mcp-adapter-execute-ability

Cette architecture garde la liste d'outils initiale réduite. L'agent découvre d'abord les capacités éligibles, récupère le schéma de celle dont il a besoin, puis demande son exécution.

Un serveur MCP personnalisé peut à la place exposer des capacités sélectionnées comme des outils, ressources ou prompts autonomes directs. Les serveurs personnalisés sont utiles lorsqu'une intégration de production a besoin d'une surface étroitement contrôlée, de schémas d'outils plus clairs ou de politiques de permission distinctes.[^2][^12]

Exposer des capacités en toute sécurité

Les capacités WordPress sont privées par défaut. Sur l'adaptateur MCP officiel, utilisez meta.public => true ou, plus précisément, meta.mcp.public => true pour rendre une capacité découvrable via le serveur MCP par défaut. Un meta.mcp.public => false explicite exclut du MCP une capacité par ailleurs publique.[^2][^9]

Ceci est distinct de l'exposition REST. show_in_rest => true contrôle l'Abilities REST API, tandis que l'exposition MCP suit les métadonnées publiques MCP. N'exposez pas une capacité à REST simplement parce qu'elle doit être disponible via MCP, sauf si l'intégration nécessite réellement les deux canaux.[^13][^6]

Une capacité de lecture seule sécurisée

Créez une petite extension personnalisée plutôt que d'ajouter du code d'intégration à un thème. Les thèmes changent avec la présentation ; les capacités d'un agent relèvent de la fonctionnalité applicative.

<?php
/**
 * Plugin Name: Busony MCP Abilities
 * Description: Narrow WordPress abilities for approved MCP agents.
 * Version: 1.0.0
 */

add_action( 'wp_abilities_api_init', function () {
    wp_register_ability(
        'busony/get-published-post',
        array(
            'label'       => 'Get a published post',
            'description' => 'Returns a published post by numeric ID.',
            'category'    => 'content',
            'input_schema' => array(
                'type'                 => 'object',
                'additionalProperties' => false,
                'required'             => array( 'post_id' ),
                'properties'           => array(
                    'post_id' => array(
                        'type'    => 'integer',
                        'minimum' => 1,
                    ),
                ),
            ),
            'output_schema' => array(
                'type' => 'object',
                'properties' => array(
                    'id'      => array( 'type' => 'integer' ),
                    'title'   => array( 'type' => 'string' ),
                    'content' => array( 'type' => 'string' ),
                    'url'     => array( 'type' => 'string' ),
                ),
            ),
            'execute_callback' => function ( $input ) {
                $post = get_post( (int) $input['post_id'] );

                if ( ! $post || 'post' !== $post->post_type || 'publish' !== $post->post_status ) {
                    return new WP_Error( 'post_not_available', 'Published post not found.' );
                }

                return array(
                    'id'      => (int) $post->ID,
                    'title'   => get_the_title( $post ),
                    'content' => apply_filters( 'the_content', $post->post_content ),
                    'url'     => get_permalink( $post ),
                );
            },
            'permission_callback' => function ( $input ) {
                return current_user_can( 'read' )
                    && current_user_can( 'read_post', (int) $input['post_id'] );
            },
            'meta' => array(
                'public' => true,
                'mcp'    => array( 'public' => true ),
                'annotations' => array(
                    'readonly'    => true,
                    'destructive' => false,
                    'idempotent'  => true,
                ),
            ),
        )
    );
} );

Les capacités doivent être enregistrées sur wp_abilities_api_init. WordPress valide le schéma d'entrée avant d'appeler le permission callback, et celui-ci doit retourner true, false ou un WP_Error.[^14][^15]

Une capacité de proposition de brouillon

Un modèle d'écriture éditoriale plus sûr crée des brouillons plutôt que de publier directement du contenu :

add_action( 'wp_abilities_api_init', function () {
    wp_register_ability(
        'busony/create-post-draft',
        array(
            'label'       => 'Create a post draft',
            'description' => 'Creates a reviewable post draft. It never publishes.',
            'category'    => 'content',
            'input_schema' => array(
                'type'                 => 'object',
                'additionalProperties' => false,
                'required'             => array( 'title', 'content' ),
                'properties'           => array(
                    'title' => array(
                        'type'      => 'string',
                        'minLength' => 1,
                        'maxLength' => 200,
                    ),
                    'content' => array(
                        'type'      => 'string',
                        'minLength' => 1,
                        'maxLength' => 50000,
                    ),
                ),
            ),
            'output_schema' => array(
                'type' => 'object',
                'properties' => array(
                    'post_id' => array( 'type' => 'integer' ),
                    'status'  => array( 'type' => 'string' ),
                    'edit_url'=> array( 'type' => 'string' ),
                ),
            ),
            'execute_callback' => function ( $input ) {
                $post_id = wp_insert_post(
                    array(
                        'post_type'    => 'post',
                        'post_status'  => 'draft',
                        'post_title'   => sanitize_text_field( $input['title'] ),
                        'post_content' => wp_kses_post( $input['content'] ),
                    ),
                    true
                );

                if ( is_wp_error( $post_id ) ) {
                    return $post_id;
                }

                return array(
                    'post_id' => (int) $post_id,
                    'status'  => 'draft',
                    'edit_url'=> get_edit_post_link( $post_id, 'raw' ),
                );
            },
            'permission_callback' => function () {
                return current_user_can( 'edit_posts' );
            },
            'meta' => array(
                'mcp' => array( 'public' => true ),
                'annotations' => array(
                    'readonly'    => false,
                    'destructive' => false,
                    'idempotent'  => false,
                ),
            ),
        )
    );
} );

Ceci n'expose pas d'outil de publication. Un éditeur humain relit et publie via WordPress. Dans un workflow mature, ajoutez une clé d'idempotence pour éviter les brouillons en double lorsqu'un client relance une requête.

Règles de permission

Une capacité sécurisée doit satisfaire toutes ces conditions :

• La description est précise et sans ambiguïté.
• L'entrée et la sortie utilisent un JSON Schema strict.
• additionalProperties est désactivé, sauf nécessité réelle.
• Les plages numériques et les longueurs de texte sont bornées.
• Le permission callback vérifie l'utilisateur courant et, le cas échéant, l'objet ciblé.
• Le execute callback assainit les entrées et échappe ou filtre les sorties de façon appropriée.
• Les opérations de lecture, d'écriture et destructives sont des capacités séparées.
• Les actions à conséquences nécessitent une confirmation humaine ou un compte à privilèges plus élevés.
• La capacité retourne un WP_Error en cas d'échec, plutôt que de laisser fuiter des traces de pile ou des secrets.

N'exposez jamais du SQL arbitraire, des commandes shell, une exécution PHP non restreinte, l'installation d'extensions, la création d'utilisateurs ou la modification directe des options comme outil générique pour un agent.

Authentifier les clients distants

Le serveur HTTP par défaut exige un utilisateur WordPress authentifié. Pour une configuration distante standard, créez un mot de passe d'application :

1. Connectez-vous avec l'utilisateur MCP dédié. 2. Ouvrez Utilisateurs → Profil. 3. Trouvez la section Mots de passe d'application. 4. Saisissez un libellé tel que Claude MCP — octobre 2026. 5. Générez le mot de passe et copiez-le immédiatement. 6. Stockez-le dans le gestionnaire d'identifiants sécurisé du système d'exploitation ou un autre gestionnaire de secrets.

Le libellé n'est pas le nom d'utilisateur. La configuration MCP doit utiliser le véritable nom de connexion WordPress, ainsi que le mot de passe d'application généré.[^7]

Tester l'authentification avec cURL

curl -i \
  --user 'mcp-reader:xxxx xxxx xxxx xxxx xxxx xxxx' \
  -H 'Content-Type: application/json' \
  -X POST \
  'https://example.com/wp-json/mcp/mcp-adapter-default-server' \
  --data '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "initialize",
    "params": {
      "protocolVersion": "2026-07-28",
      "capabilities": {},
      "clientInfo": {
        "name": "manual-test",
        "version": "1.0.0"
      }
    }
  }'

Les clients MCP Streamable HTTP doivent compléter une poignée de main d'initialisation avant les requêtes ordinaires. En usage normal, Claude ou le proxy gère automatiquement cet échange de protocole.[^9]

Ne placez jamais un mot de passe d'application dans du JavaScript frontend, un dépôt public, une capture d'écran d'article ou un historique de shell partagé.

Connecter Claude Desktop

Il existe deux approches principales : le STDIO local direct via WP-CLI, ou le HTTP distant via un proxy local. Choisissez-en une ; ne combinez pas les réglages de l'ancienne extension Automattic wordpress-mcp, qui utilisait un endpoint et un modèle JWT différents.[^16]

Option A : WordPress local via WP-CLI

Utilisez cette option lorsque Claude Desktop tourne sur la même machine que l'installation WordPress et peut exécuter WP-CLI directement.

Ouvrez le fichier de configuration de Claude Desktop :

• macOS : ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows : %APPDATA%\Claude\claude_desktop_config.json

Ajoutez :

{
  "mcpServers": {
    "wordpress-local": {
      "command": "wp",
      "args": [
        "--path=/absolute/path/to/wordpress",
        "mcp-adapter",
        "serve",
        "--server=mcp-adapter-default-server",
        "--user=mcp-reader"
      ]
    }
  }
}

Utilisez le chemin absolu de WordPress et un nom d'utilisateur dédié existant. Selon le système d'exploitation et la façon dont Claude Desktop lance les sous-processus, le chemin complet vers l'exécutable WP-CLI peut être nécessaire à la place de wp.[^10]

Cette méthode STDIO ne nécessite ni gestion de session HTTP ni mot de passe d'application, car WP-CLI s'exécute localement en tant qu'utilisateur WordPress sélectionné. Elle exige en revanche que Claude Desktop ait un accès local aux processus et au système de fichiers de l'installation.[^9]

Option B : WordPress distant via proxy HTTP

Pour un site distant, la documentation du projet fournit le proxy @automattic/mcp-wordpress-remote. Il s'exécute localement sous Claude Desktop, communique avec Claude via STDIO et traduit les requêtes en appels HTTP authentifiés vers WordPress.[^10]

{
  "mcpServers": {
    "wordpress-production": {
      "command": "npx",
      "args": [
        "-y",
        "@automattic/mcp-wordpress-remote@latest"
      ],
      "env": {
        "WP_API_URL": "https://example.com/wp-json/mcp/mcp-adapter-default-server",
        "WP_API_USERNAME": "mcp-reader",
        "WP_API_PASSWORD": "xxxx xxxx xxxx xxxx xxxx xxxx",
        "LOG_FILE": "/absolute/path/to/logs/wordpress-mcp.log"
      }
    }
  }
}

Lors des premiers tests, le tag latest est pratique. Pour un workflow de production maîtrisé, épinglez une version testée du proxy afin qu'une release amont ne puisse pas modifier le comportement de façon inattendue.

Quittez complètement Claude Desktop et rouvrez-le après avoir enregistré le fichier. Un simple rafraîchissement de page ne suffit pas, car l'application doit relancer le sous-processus MCP.[^7]

Dans une nouvelle conversation, ouvrez le panneau connecteurs/outils et vérifiez que le serveur WordPress est disponible. Commencez par une requête en lecture seule, par exemple :

> Découvre les capacités WordPress publiques qui te sont accessibles. N'exécute aucune action d'écriture.

Puis testez une capacité spécifique :

> Récupère l'article publié 123 via la capacité WordPress approuvée et résume-le. Ne modifie pas WordPress.

Connecteur distant direct

Les clients Claude actuels prennent également en charge des connecteurs MCP distants personnalisés. Dans Claude, ouvrez Personnaliser → Connecteurs, choisissez Ajouter un connecteur personnalisé, saisissez l'URL MCP distante, puis configurez la méthode d'authentification détectée par Claude.[^17]

Cependant, les connecteurs distants de Claude proviennent de l'infrastructure cloud d'Anthropic, et non de l'ordinateur local de l'utilisateur. L'endpoint WordPress doit donc être joignable publiquement depuis les plages réseau requises, et sa méthode d'authentification doit être compatible avec le flux de connecteur de Claude.[^17]

Pour de nombreux déploiements WordPress auto-hébergés, le proxy local documenté associé à un mot de passe d'application constitue le point de départ le plus prévisible. Ne configurez jamais « Aucune connexion » sur un serveur MCP WordPress qui expose des données non publiques du site ou des capacités exécutables.

Connecter Claude Code

Claude Code peut enregistrer une commande STDIO locale ou un serveur MCP HTTP. Le même principe s'applique : utilisez WP-CLI en direct pour une installation WordPress locale, ou lancez le proxy distant WordPress pour un site distant.

STDIO local

Une configuration MCP représentative au niveau du projet :

{
  "mcpServers": {
    "wordpress-local": {
      "command": "wp",
      "args": [
        "--path=/absolute/path/to/wordpress",
        "mcp-adapter",
        "serve",
        "--server=mcp-adapter-default-server",
        "--user=mcp-reader"
      ]
    }
  }
}

Proxy distant

{
  "mcpServers": {
    "wordpress-remote": {
      "command": "npx",
      "args": ["-y", "@automattic/mcp-wordpress-remote@latest"],
      "env": {
        "WP_API_URL": "https://example.com/wp-json/mcp/mcp-adapter-default-server",
        "WP_API_USERNAME": "mcp-reader",
        "WP_API_PASSWORD": "YOUR_APPLICATION_PASSWORD"
      }
    }
  }
}

L'emplacement exact de la configuration et la syntaxe des commandes peuvent évoluer d'une version de Claude Code à l'autre. Vérifiez la documentation MCP actuelle de Claude Code avant tout déploiement, mais conservez le modèle d'endpoint, de nom d'utilisateur et de mot de passe d'application spécifique à WordPress présenté dans la documentation officielle de l'adaptateur.[^10]

Conservez autant que possible la configuration du projet sans secrets. Fournissez le mot de passe d'application via une variable d'environnement ou un gestionnaire de secrets plutôt que de le committer dans un dépôt.

Cas d'usage pratiques

Agent de contenu en lecture seule

Un agent de recherche peut découvrir les capacités de lecture approuvées, récupérer du contenu publié et comparer la couverture du site, sans recevoir l'accès aux brouillons non publiés ni aux réglages.

Permissions recommandées :

• Rôle Abonné dédié ou rôle personnalisé en lecture seule
• Uniquement des capacités portant sur du contenu publié
• Pas d'énumération des utilisateurs
• Pas de capacités sur les extensions, thèmes ou réglages
• Aucun outil d'écriture

Prompt typique :

> Passe en revue les articles publiés disponibles via les outils MCP WordPress. Identifie les affirmations obsolètes, mais ne modifie pas le site. Retourne les corrections proposées avec les identifiants d'articles concernés.

Agent de proposition de brouillons

Un agent éditorial peut récupérer du matériel source approuvé et créer un brouillon pour relecture humaine. La capacité doit coder en dur post_status => draft ; l'agent ne doit pas pouvoir écraser ce statut dans ses arguments.

Permissions recommandées :

• Rôle Contributeur dédié ou rôle personnalisé
• Lecture du contenu approuvé
• Création de brouillons
• Aucune capacité de publication, suppression ou gestion des utilisateurs
• Clé d'idempotence et détection des doublons
• Relecture éditoriale avant publication

Prompt typique :

> Lis l'article 123 et crée une proposition de mise à jour séparée, sous forme de brouillon. Préserve l'article original. Ajoute un journal des modifications en haut, à l'attention de l'éditeur.

Lecteur de stock WooCommerce

L'adaptateur MCP n'expose pas automatiquement WooCommerce. Une extension ou une intégration personnalisée doit enregistrer des capacités WooCommerce étroitement circonscrites.

Une capacité de lecture de stock en lecture seule pourrait accepter un identifiant produit ou un SKU exact, et retourner uniquement :

• L'identifiant produit et le SKU
• Le nom du produit
• Le statut du stock
• L'indicateur de gestion du stock
• La quantité actuelle, lorsque l'utilisateur authentifié est autorisé à la consulter
• La date de dernière modification

Ne commencez pas par une sélection floue de produits suivie de mises à jour autonomes. Exigez un identifiant produit exact et séparez la lecture de l'écriture.

Permission callback à titre d'illustration :

'permission_callback' => function () {
    return current_user_can( 'manage_woocommerce' )
        || current_user_can( 'view_woocommerce_reports' );
},

Choisissez les capacités selon le modèle de rôles du site et la sensibilité des données d'inventaire. Ne retournez jamais les coordonnées client d'une commande, des informations de paiement ou une configuration de boutique sans rapport depuis une capacité de lecture de stock.

Proposition de mise à jour WooCommerce

Un workflow commercial plus sûr est le suivant :

1. L'agent lit le produit via une capacité de lecture. 2. L'agent crée une proposition structurée contenant les anciennes et les nouvelles valeurs. 3. Un humain approuve la proposition. 4. Un service séparé ou une capacité à privilèges plus élevés effectue la mise à jour. 5. L'intégration relit le produit et vérifie le résultat enregistré.

Les mises à jour directes de stock, de prix et de publication nécessitent des permissions, des journaux d'audit, une protection contre l'idempotence et des procédures de rollback plus solides que la création de brouillons de contenu.

Checklist de sécurité

Avant de connecter un client IA, vérifiez chaque point :

• [ ] WordPress, PHP et l'adaptateur MCP sont sur des versions testées et prises en charge.
• [ ] HTTPS est appliqué.
• [ ] Le client utilise un utilisateur WordPress dédié.
• [ ] L'utilisateur dispose du rôle et des capacités minimales requises.
• [ ] Un mot de passe d'application distinct et révocable est utilisé pour chaque client ou environnement.
• [ ] Aucun mot de passe de connexion habituel n'apparaît dans la configuration MCP.
• [ ] Les secrets sont exclus des dépôts, captures d'écran et journaux partagés.
• [ ] Seules les capacités nécessaires ont meta.public ou meta.mcp.public activé.
• [ ] Chaque capacité dispose de schémas d'entrée et de sortie stricts.
• [ ] Chaque capacité dispose d'un permission callback.
• [ ] Des vérifications de capacité au niveau de l'objet protègent les articles, produits ou fiches spécifiques.
• [ ] Les opérations de lecture, d'écriture et destructives sont séparées.
• [ ] Les changements visibles publiquement nécessitent une approbation humaine.
• [ ] Les journaux enregistrent l'utilisateur, la capacité, l'horodatage, les arguments (ou leur hash), le résultat et l'état d'échec.
• [ ] Les données sensibles de prompt ou de client sont expurgées des journaux.
• [ ] Des limites de débit et des contrôles de requêtes en double sont en place.
• [ ] La révocation a été testée en supprimant le mot de passe d'application.
• [ ] Les sauvegardes et procédures de restauration sont opérationnelles.
• [ ] L'intégration a été testée contre l'injection de prompt dans du contenu externe.

Journalisation et observabilité

Le serveur MCP par défaut utilise un gestionnaire de journal d'erreurs pour le diagnostic, et un gestionnaire d'observabilité nul pour les événements de requête. Les développeurs peuvent remplacer le gestionnaire d'observabilité par une implémentation personnalisée via mcp_adapter_default_server_config.[^18]

use WP\MCP\Infrastructure\ErrorHandling\ErrorLogMcpErrorHandler;
use WP\MCP\Infrastructure\Observability\ErrorLogMcpObservabilityHandler;

add_filter( 'mcp_adapter_default_server_config', function ( array $config ): array {
    $config['error_handler'] = ErrorLogMcpErrorHandler::class;
    $config['observability_handler'] = ErrorLogMcpObservabilityHandler::class;
    return $config;
} );

Évitez une journalisation permanente et verbeuse de corps d'articles complets, de fiches clients, d'identifiants ou de conversations avec le modèle. En production, envoyez les événements de sécurité structurés vers un système de journalisation approprié et appliquez des politiques de rétention.

Procédure de révocation

Si un identifiant est exposé ou qu'un client n'est plus approuvé :

1. Révoquez immédiatement son mot de passe d'application. 2. Désactivez l'utilisateur associé en cas de compromission suspectée. 3. Supprimez ou rendez privées les capacités exposées. 4. Examinez les journaux WordPress, du serveur web et d'observabilité MCP. 5. Inspectez les articles, produits, utilisateurs et réglages modifiés pendant la période concernée. 6. Faites tourner les identifiants concernés et restaurez depuis une sauvegarde si nécessaire.

Dépannage

Endpoint introuvable

Symptômes : HTTP 404, rest_no_route, ou un rapport de proxy indiquant que le serveur MCP est injoignable.

Vérifiez :

1. Que l'adaptateur MCP est activé. 2. Que l'URL est exactement :

https://example.com/wp-json/mcp/mcp-adapter-default-server

3. Que l'endpoint /wp-json/ du site est joignable. 4. Que les permaliens WordPress sont activés ; réenregistrez Réglages → Permaliens si nécessaire. 5. Qu'aucune extension de sécurité, proxy inverse, CDN ou hébergeur ne bloque /wp-json/mcp/ ou les requêtes POST authentifiées. 6. Que le sous-répertoire WordPress est bien inclus dans l'URL. 7. Que le client n'utilise pas la route obsolète /wp-json/wp/v2/wpmcp/streamable d'une autre extension.[^16]

Échec de l'authentification

Symptômes : HTTP 401/403, icône d'avertissement dans Claude Desktop, ou « permission refusée ».

Vérifiez :

• Que WP_API_USERNAME est le vrai nom de connexion WordPress, et non le libellé du mot de passe d'application.
• Que WP_API_PASSWORD est bien le mot de passe d'application généré, et non le mot de passe habituel du compte.
• Que HTTPS est actif.
• Que les en-têtes d'autorisation Basic atteignent bien WordPress ; certains proxys les suppriment.
• Que l'utilisateur est actif et dispose au minimum de la capacité requise par le serveur.
• Que le mot de passe d'application n'a pas été révoqué.

Les espaces dans le mot de passe d'application affiché peuvent généralement rester, mais copier des caractères cachés ou des guillemets environnants dans la valeur secrète peut provoquer un échec.[^7]

Connecté, mais aucune capacité utile n'apparaît

Le serveur par défaut s'articule toujours autour de ses trois méta-outils, mais seules les capacités marquées comme publiques pour la découverte MCP seront retournées.[^9]

Vérifiez :

• Que l'extension personnalisée enregistrant les capacités est bien active.
• Que l'enregistrement s'exécute sur wp_abilities_api_init.
• Que meta.public ou meta.mcp.public vaut true.
• Que meta.mcp.public n'est pas explicitement à false.
• Que l'enregistrement de la capacité contient des schémas et callbacks valides.
• Que l'utilisateur authentifié passe le permission callback.

Utilisez WP-CLI pour distinguer un problème côté client d'un problème côté WordPress :

echo '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}' | \
wp mcp-adapter serve \
  --server=mcp-adapter-default-server \
  --user=mcp-reader

Permission refusée pour une capacité

Cela signifie généralement que l'authentification du transport a réussi, mais que le permission callback de la capacité a rejeté l'utilisateur courant ou l'objet ciblé. C'est un comportement de sécurité attendu.

Testez :

• Les capacités du rôle dédié
• L'accès au niveau de l'objet, comme read_post ou edit_post
• Si la capacité attend un identifiant ou un type d'entrée différent
• Si la validation de l'entrée a échoué avant même le permission callback

Ne « résolvez » jamais le problème en remplaçant le permission callback par __return_true sur une capacité d'écriture.

Claude Desktop ne démarre pas le serveur

Vérifiez :

• Que le JSON est valide — pas de commentaires ni de virgules finales.
• Que wp, node et npx figurent bien dans le chemin d'exécution de l'application.
• Utilisez des chemins absolus pour l'exécutable et les journaux si nécessaire.
• Redémarrez complètement Claude Desktop.
• Inspectez les journaux développeur de Claude Desktop et le LOG_FILE du proxy.[^19][^7]

Le proxy distant se ferme immédiatement

Lancez la commande sous-jacente dans un terminal :

npx -y @automattic/mcp-wordpress-remote@latest

Vérifiez ensuite Node.js, le DNS, les certificats TLS, l'endpoint MCP, le nom d'utilisateur et le mot de passe d'application. En présence d'un proxy d'entreprise, confirmez que Node peut bien joindre le site WordPress.

Erreur de session HTTP ou d'initialisation

Le Streamable HTTP nécessite la séquence d'initialisation MCP avant les requêtes d'outils normales. Un tools/list brut envoyé en POST sans initialisation peut échouer selon le client et la version de l'adaptateur. Utilisez un client MCP compatible ou démarrez par la requête initialize.[^9]

Mauvaise configuration de transport

• Utilisez le STDIO WP-CLI direct lorsque le client peut exécuter WP-CLI sur le même hôte ou un environnement local accessible.
• Utilisez le proxy distant lorsqu'un client basé sur STDIO doit joindre WordPress via HTTP.
• N'utilisez un connecteur distant natif que lorsque l'endpoint MCP et le mécanisme d'authentification sont compatibles et joignables publiquement.

Ne pointez jamais une configuration STDIO locale directement vers une URL HTTP sans proxy ni client HTTP natif.

FAQ

L'adaptateur MCP WordPress est-il stable ?

L'extension est publiquement disponible en tant que plugin canonique de WordPress, et la version 0.7.0 a marqué une étape majeure de diffusion. Cependant, WordPress la décrit toujours comme expérimentale, en chemin vers la version 1.0. Utilisez-la de façon sélective en production, épinglez des versions testées et maintenez des procédures de rollback.

Ai-je besoin d'un connecteur de fournisseur IA pour utiliser le MCP ?

Non. Un connecteur de fournisseur permet à WordPress d'appeler OpenAI, Anthropic, Google ou un autre modèle. Avec le MCP, le modèle tourne dans Claude Desktop, Claude Code ou un autre client externe, tandis que WordPress expose des capacités approuvées. N'installez un connecteur de fournisseur que si WordPress lui-même a aussi besoin d'envoyer des requêtes à un modèle.

Pour la distinction complète, voir Claude, Gemini et OpenAI dans WordPress : connecteurs IA, AI Client et MCP expliqués.

Le MCP fonctionne-t-il avec WooCommerce ?

Oui, si des capacités WooCommerce sont fournies par une extension ou du code personnalisé. L'adaptateur MCP ne crée pas automatiquement d'outils pour les produits, le stock, les commandes ou les clients. Commencez par des capacités de lecture seule sur les produits et le stock, puis n'ajoutez des workflows d'écriture approuvés qu'une fois les permissions, la validation, les journaux et le rollback testés.

L'adaptateur expose-t-il toutes les capacités WordPress ?

Non. Les capacités sont privées par défaut. Le serveur par défaut découvre les capacités marquées meta.public => true ou meta.mcp.public => true ; un meta.mcp.public => false explicite exclut une capacité.[^2][^9]

`show_in_rest` équivaut-il à une exposition publique MCP ?

Non. show_in_rest contrôle les endpoints REST de l'Abilities API. L'exposition MCP utilise les métadonnées publiques/MCP de la capacité. Les deux peuvent être activés séparément.[^6][^13]

Claude peut-il publier des articles automatiquement ?

Uniquement si une capacité d'écriture autorise la publication et que l'utilisateur authentifié en a la permission. Une conception initiale plus sûre expose la création de brouillons, mais aucune action de publication.

Un seul serveur MCP WordPress peut-il servir plusieurs agents ?

Oui, mais utilisez des utilisateurs et des identifiants distincts afin que l'accès puisse être attribué et révoqué indépendamment. Pour des niveaux de confiance différents, créez des serveurs MCP personnalisés ou des jeux de capacités distincts plutôt que de donner les mêmes outils à chaque client.

Un compte administrateur WordPress est-il requis ?

Non. Le serveur exige un utilisateur authentifié, et chaque capacité vérifie ses propres permissions. Un rôle dédié à privilèges réduits ou personnalisé est préférable.

Claude Desktop peut-il se connecter sans exposer WordPress publiquement ?

Pour une installation WordPress locale, Claude Desktop peut lancer WP-CLI via STDIO. Les connecteurs distants courtés par le cloud d'Anthropic nécessitent un endpoint MCP joignable publiquement, tandis que les serveurs en sous-processus claude_desktop_config.json locaux peuvent accéder à des ressources locales.[^17][^10]

Le MCP rend-il l'API REST de WordPress inutile ?

Non. Le transport HTTP de l'adaptateur est enregistré via l'infrastructure REST de WordPress, et les capacités peuvent séparément être exposées via l'Abilities REST API. Le MCP ajoute une découverte et une invocation orientées agent ; il ne remplace pas toute intégration REST.[^6][^2]

Construisez un agent WordPress sécurisé avec Busony

Une preuve de concept peut connecter Claude à WordPress en un après-midi. Un agent de production exige davantage : conception des capacités, rôles personnalisés, authentification, contrôles contre l'injection de prompt, garde-fous WooCommerce, workflows d'approbation, observabilité et procédures de récupération.

Busony conçoit et met en œuvre des systèmes d'agents WordPress et WooCommerce maîtrisés, notamment :

• Installation et configuration sécurisée de l'adaptateur MCP
• Capacités personnalisées de lecture, de brouillon, de publication et de commerce
• Connexions à Claude Desktop, Claude Code et aux plateformes d'agents
• Architecture de rôles et de permissions WordPress
• Workflows produits et stock WooCommerce
• Approbation humaine et pistes d'audit
• Contenu multilingue et automatisation de l'export
• Intégration AI Client et connecteurs de fournisseurs
• Revues de sécurité, tests en pré-production et documentation opérationnelle

L'engagement recommandé commence par un audit de capacités MCP : identifier les données et actions dont un agent a besoin, classer leur risque, puis n'exposer que le minimum de capacités nécessaire.

Contactez Busony pour concevoir un serveur MCP WordPress ou un agent WooCommerce maîtrisé pour votre organisation.

> Pour aller plus loin : Claude, Gemini et OpenAI dans WordPress : connecteurs IA, AI Client et MCP expliqués couvre l'ensemble de la pile IA WordPress et explique quand utiliser les connecteurs de fournisseurs, le plugin IA canonique, l'Abilities API ou le MCP.

Références

[^1]: An MCP adapter that bridges the Abilities API to the Model Context Protocol — WordPress/mcp-adapter, GitHub. [^2]: README.md — WordPress/mcp-adapter, GitHub. [^3]: Abilities API – Common APIs Handbook — WordPress Developer Resources. [^4]: mcp-adapter readme.txt — WordPress/mcp-adapter, GitHub. [^5]: Getting started – Common APIs Handbook — WordPress Developer Resources. [^6]: REST API endpoints – Common APIs Handbook — WordPress Developer Resources. [^7]: Settings Menu Doesn't Show up on Hostinger Hosted WP (Issue #148) — WordPress/mcp-adapter, GitHub. [^8]: Getting started guide — WordPress/mcp-adapter, GitHub. [^9]: Default server guide — WordPress/mcp-adapter, GitHub. [^10]: CLI usage guide — WordPress/mcp-adapter, GitHub. [^11]: Architecture overview — WordPress/mcp-adapter, GitHub. [^12]: Transport & permissions guide — WordPress/mcp-adapter, GitHub. [^13]: Basic examples — WordPress/mcp-adapter, GitHub. [^14]: PHP reference – Common APIs Handbook — WordPress Developer Resources. [^15]: Hooks – Common APIs Handbook — WordPress Developer Resources. [^16]: Couldn't reach the MCP server (Issue #161) — WordPress/mcp-adapter, GitHub. [^17]: Get started with custom connectors using remote MCP — Anthropic Help Center. [^18]: Observability guide — WordPress/mcp-adapter, GitHub. [^19]: Getting Started with Local MCP Servers on Claude Desktop — Anthropic Help Center.