WordPress MCP Adapter : brancher tes Abilities à des agents IA via le Model Context Protocol

Depuis WordPress 6.9, l’Abilities API change la donne : on peut enregistrer des capacités applicatives (des “unités de travail”) de façon standardisée, découvrable, typée et exécutable. Ce n’est pas qu’une nouvelle API sympa pour les devs : c’est aussi un socle très concret pour l’automatisation et les workflows IA sur WordPress.

Dans le monde des agents IA, un mouvement important ces derniers mois est le Model Context Protocol (MCP) : un protocole qui permet à un client IA d’aller chercher du contexte et d’exécuter des actions via des “primitives” communes. Dit autrement : au lieu de bricoler des intégrations ad hoc, tu exposes des fonctions et des ressources d’une manière que les outils IA savent comprendre.

Côté WordPress, il existe désormais un composant officiel pour faire le pont : le WordPress MCP Adapter. Son objectif est simple : prendre les Abilities déjà enregistrées via l’Abilities API et les “adapter” en primitives MCP, afin que des applications IA puissent découvrir et appeler ces fonctionnalités comme des MCP tools (et, dans certains cas, lire des données comme des MCP resources).

Dans cet article, on va voir : (1) le rappel indispensable sur les Abilities, (2) ce que fait exactement l’adapter MCP, (3) comment l’installer et activer l’accès MCP, (4) comment connecter Claude Desktop, Cursor, Claude Code et VS Code, (5) comment créer un serveur MCP personnalisé dans ton plugin, (6) un exemple complet avec “List All URLs”, et (7) les bonnes pratiques sécurité.

Rappel express : Abilities API, la fondation

L’Abilities API apporte à WordPress une API fonctionnelle de premier rang, utilisable “cross-context” (PHP, JavaScript, REST API), avec un format commun pour décrire ce que le core ou les extensions savent faire.

Une Ability se définit une seule fois avec :

Un nom unique (namespace/ability-name).
Un schéma d’entrée et un schéma de sortie typés (input/output schema).
Un permission_callback qui applique des règles d’accès (capabilities).
Un execute_callback qui exécute l’action réelle.

Le code déclenché dans execute_callback peut être très varié : lecture de données, mise à jour de contenus, diagnostics, etc. Une fois enregistrée, l’Ability devient découvrable et exécutable depuis PHP, JavaScript et la REST API.

WordPress 6.9 embarque trois Abilities “core” par défaut, pratiques pour tester rapidement :

core/get-site-info : renvoie les informations de site configurées dans WordPress (par défaut tous les champs, ou un sous-ensemble filtré).
core/get-user-info : renvoie les infos de profil de base de l’utilisateur authentifié courant (personnalisation, audit, comportements sensibles aux droits).
core/get-environment-info : renvoie des infos de contexte runtime utiles au diagnostic (environnement, runtime PHP, infos serveur BDD, version WordPress).

WordPress MCP Adapter : à quoi ça sert concrètement ?

Le WordPress MCP Adapter fait partie d’une initiative plus large : AI Building Blocks for WordPress. Son rôle : convertir les Abilities enregistrées via l’Abilities API en primitives compatibles MCP (au sens de l’architecture MCP) pour que des agents IA puissent :

Découvrir des fonctionnalités du site et les invoquer sous forme de MCP tools (fonctions exécutables).
Lire certaines informations WordPress comme des MCP resources (sources de données passives).

La conséquence pratique est importante : si ton plugin enregistre déjà des Abilities, tu es à un pas de les rendre utilisables par un agent IA.

Petit mémo MCP : tools, resources, prompts

MCP structure l’interaction autour de trois primitives principales :

Tools : fonctions exécutables que le client IA appelle pour agir (lecture/écriture/diagnostic…).
Resources : sources de données “passives” (fichiers, lignes de base, etc.) lues par l’IA pour du contexte.
Prompts : gabarits préconfigurés (templates) pour guider des workflows spécifiques.

Avec l’adapter WordPress, les Abilities sont généralement exposées comme des tools, car elles incarnent une logique exécutable. Mais l’adapter est flexible : si une Ability est strictement en lecture seule et ressemble plutôt à une “source de contexte” (ex. un log de debug ou une configuration statique), elle peut être configurée comme resource pour que l’IA l’ingère sans avoir à “appeler” explicitement une action.

Installer le MCP Adapter (mode plugin)

La voie la plus rapide pour démarrer consiste à installer l’adapter comme plugin, en téléchargeant l’archive depuis la page Releases du dépôt GitHub : https://github.com/WordPress/mcp-adapter/releases.

Une fois activé, le plugin :

Enregistre un serveur MCP par défaut nommé mcp-adapter-default-server.
Ajoute trois Abilities dédiées à l’accès MCP : mcp-adapter/discover-abilities, mcp-adapter/get-ability-info, mcp-adapter/execute-ability.
Expose automatiquement ces Abilities en MCP tools : mcp-adapter-discover-abilities, mcp-adapter-get-ability-info, mcp-adapter-execute-ability.

Ces trois tools fournissent une approche “en couches” pour accéder aux Abilities : un agent peut découvrir ce qui existe, inspecter une Ability (schémas, permissions, etc.), puis exécuter l’Ability.

Rendre une Ability accessible au serveur MCP par défaut

Point clé : le serveur MCP par défaut n’expose pas toutes les Abilities automatiquement. Par défaut, une Ability n’est disponible via ce serveur que si tu la marques explicitement comme “publique” pour MCP, via un flag meta.mcp.public lors de l’enregistrement avec wp_register_ability().

'meta' => array(
    'mcp' => array(
        'public' => true,  // Required for MCP default server access
    ),
),

'meta' => array(
    'mcp' => array(
        'public' => true,  // Required for MCP default server access
    ),
),

Pour les Abilities du core, tu ne vas pas ré-enregistrer : tu peux modifier leurs arguments via le filtre wp_register_ability_args afin d’ajouter ce flag meta.mcp.public.

<?php
/**
 * Plugin Name: Enable core abilities
 * Version: 1.0.0
 *
 * @package enable-core-abilities
 */

add_filter( 'wp_register_ability_args', 'myplugin_enable_core_abilities_mcp_access', 10, 2 );
/**
 * Enable MCP access for core abilities.
 *
 * @param array  $args         Ability registration arguments.
 * @param string $ability_name Ability ID.
 * @return array Modified ability registration arguments.
 */
function myplugin_enable_core_abilities_mcp_access( array $args, string $ability_name ) {
    // Enable MCP access for the three current core abilities.
    $core_abilities = array(
        'core/get-site-info',
        'core/get-user-info',
        'core/get-environment-info',
    );
    if ( in_array( $ability_name, $core_abilities, true ) ) {
        $args['meta']['mcp']['public'] = true;
    }

    return $args;
}

<?php
/**
 * Plugin Name: Enable core abilities
 * Version: 1.0.0
 *
 * @package enable-core-abilities
 */

add_filter( 'wp_register_ability_args', 'myplugin_enable_core_abilities_mcp_access', 10, 2 );
/**
 * Enable MCP access for core abilities.
 *
 * @param array  $args         Ability registration arguments.
 * @param string $ability_name Ability ID.
 * @return array Modified ability registration arguments.
 */
function myplugin_enable_core_abilities_mcp_access( array $args, string $ability_name ) {
    // Enable MCP access for the three current core abilities.
    $core_abilities = array(
        'core/get-site-info',
        'core/get-user-info',
        'core/get-environment-info',
    );
    if ( in_array( $ability_name, $core_abilities, true ) ) {
        $args['meta']['mcp']['public'] = true;
    }

    return $args;
}

Avec ça en place, tu peux connecter un client IA à ton site et appeler ces Abilities core via les tools du serveur par défaut.

Connecter des applications IA à ton site WordPress MCP

Les deux transports MCP : STDIO et HTTP

Pour parler à un site WordPress exposé en serveur MCP, MCP prévoit deux mécanismes de transport : STDIO et HTTP. Le bon choix dépend surtout d’où tourne ton site.

Pour un environnement local de dev WordPress, le plus simple est généralement STDIO. Le MCP Adapter le supporte via WP-CLI (donc WP-CLI doit être installé localement). La configuration minimale ressemble à ça :

{
  "wordpress-mcp-server": {
    "command": "wp",
    "args": [
      "--path=/path/to/your/wordpress/installation",
      "mcp-adapter",
      "serve",
      "--server=mcp-adapter-default-server",
      "--user={admin_user}"
    ]
  }
}

{
  "wordpress-mcp-server": {
    "command": "wp",
    "args": [
      "--path=/path/to/your/wordpress/installation",
      "mcp-adapter",
      "serve",
      "--server=mcp-adapter-default-server",
      "--user={admin_user}"
    ]
  }
}

À noter :

wordpress-mcp-server est un identifiant libre (tu peux le nommer comme tu veux).
La commande est wp (WP-CLI).
Dans args : --path pointe vers l’installation WordPress, mcp-adapter serve démarre le serveur, --server choisit quel serveur MCP utiliser (ici le serveur par défaut), --user définit l’utilisateur WordPress utilisé pour s’authentifier (ex. admin).

Pour un WordPress publiquement accessible, ou si tu ne veux pas passer par STDIO, tu peux utiliser HTTP via un proxy distant : @automattic/mcp-wordpress-remote (https://www.npmjs.com/package/@automattic/mcp-wordpress-remote). Dans ce cas, il te faut Node.js : https://nodejs.org/en et une authentification basée sur les Application Passwords WordPress (ou une implémentation OAuth custom).

Configuration minimale en HTTP :

{
  "wordpress-mcp-server": {
    "command": "npx",
    "args": ["-y", "@automattic/mcp-wordpress-remote@latest"],
    "env": {
      "WP_API_URL": "https://yoursite.example/wp-json/mcp/mcp-adapter-default-server",
      "WP_API_USERNAME": "{admin_user}",
      "WP_API_PASSWORD": "{application-password}"
    }
  }
}

{
  "wordpress-mcp-server": {
    "command": "npx",
    "args": ["-y", "@automattic/mcp-wordpress-remote@latest"],
    "env": {
      "WP_API_URL": "https://yoursite.example/wp-json/mcp/mcp-adapter-default-server",
      "WP_API_USERNAME": "{admin_user}",
      "WP_API_PASSWORD": "{application-password}"
    }
  }
}

Détails importants :

La commande npx exécute des paquets Node.js.
-y accepte automatiquement l’installation du paquet.
WP_API_URL doit pointer vers l’endpoint MCP du site (namespace du serveur inclus).
WP_API_USERNAME et WP_API_PASSWORD servent à l’authentification (mot de passe d’application).
Le proxy mcp-wordpress-remote propose aussi des pistes de diagnostic pour les connexions HTTP en local, notamment si tu as plusieurs versions de Node.js ou des soucis de certificats SSL : https://github.com/Automattic/mcp-wordpress-remote/blob/trunk/Docs/troubleshooting.md.

Configurations spécifiques : Claude Desktop, Cursor, Claude Code, VS Code

Valeurs d’exemple

Les exemples ci-dessous utilisent un site Studio “WordPress MCP” dans /Users/jonathanbossenger/Studio/wordpress-mcp, accessible via http://localhost:8885/, et un user admin admin. Remplace avec ton chemin et ton utilisateur.

Claude Desktop

Claude Desktop (Anthropic) a supporté MCP très tôt. Pour ajouter un serveur MCP : va dans l’onglet Developer (Claude → Settings → Developer), puis sous “Local MCP servers” clique Edit config. Cela ouvre l’emplacement du fichier claude_desktop_config.json.

Les serveurs se déclarent dans un objet mcpServers :

{
  "mcpServers": {
  }
}

{
  "mcpServers": {
  }
}

Exemple en transport STDIO :

{
  "mcpServers": {
    "wordpress-mcp-server": {
      "command": "wp",
      "args": [
        "--path=/Users/jonathanbossenger/Studio/wordpress-mcp",
        "mcp-adapter",
        "serve",
        "--server=mcp-adapter-default-server",
        "--user=admin"
      ]
    }
  }
}

{
  "mcpServers": {
    "wordpress-mcp-server": {
      "command": "wp",
      "args": [
        "--path=/Users/jonathanbossenger/Studio/wordpress-mcp",
        "mcp-adapter",
        "serve",
        "--server=mcp-adapter-default-server",
        "--user=admin"
      ]
    }
  }
}

Exemple en transport HTTP :

{
  "mcpServers": {
    "wordpress-mcp-server": {
      "command": "npx",
      "args": ["-y", "@automattic/mcp-wordpress-remote@latest"],
      "env": {
        "WP_API_URL": "http://localhost:8885/wp-json/mcp/mcp-adapter-default-server",
        "WP_API_USERNAME": "admin",
        "WP_API_PASSWORD": "2SEB qW5j D7CW fpsh pbmN RGva"
      }
    }
  }
}

{
  "mcpServers": {
    "wordpress-mcp-server": {
      "command": "npx",
      "args": ["-y", "@automattic/mcp-wordpress-remote@latest"],
      "env": {
        "WP_API_URL": "http://localhost:8885/wp-json/mcp/mcp-adapter-default-server",
        "WP_API_USERNAME": "admin",
        "WP_API_PASSWORD": "2SEB qW5j D7CW fpsh pbmN RGva"
      }
    }
  }
}

Après sauvegarde, il faut redémarrer Claude Desktop (il ne recharge la conf MCP qu’au démarrage). Ensuite tu dois voir le serveur dans Developer → Local MCP servers, idéalement avec le statut running.

Cursor

Dans Cursor : va dans Cursor → Settings → Cursor Settings, puis ouvre la section Tools and MCP.

Clique sur Add Custom MCP : Cursor ouvre alors le fichier mcp.json. La structure de configuration est la même que pour Claude Desktop. Après sauvegarde, reviens dans Tools and MCP : le serveur doit apparaître et tu peux l’activer pour tes sessions.

Claude Code

Pour Claude Code, tu as deux options :

Déclarer mcpServers dans ~/.claude.json (disponible globalement).
Créer un fichier .mcp.json à la racine de ton projet (config spécifique à un projet).

Dans les deux cas, tu utilises le même format que Cursor/Claude Desktop (objet mcpServers).

VS Code

VS Code se configure via un fichier JSON décrivant les serveurs MCP (doc VS Code : https://code.visualstudio.com/docs/copilot/customization/mcp-servers). En pratique, tu crées souvent un mcp.json dans un dossier .vscode au sein du workspace.

Différence notable : VS Code attend un objet servers (et non mcpServers). Le reste (command/args/env) est identique.

{
  "servers": {
    // MCP server definitions go here
  }
}

{
  "servers": {
    // MCP server definitions go here
  }
}

Une fois en place, VS Code affiche une barre de contrôle MCP pour démarrer/arrêter/redémarrer le serveur. Quand tout est OK, VS Code indique aussi le nombre de tools disponibles (dans l’exemple présenté : 3 tools).

VS Code affichant la configuration mcp.json et les contrôles MCP — VS Code lit `.vscode/mcp.json`, pilote le serveur MCP, et affiche le nombre de tools disponibles. — *Forrás: WordPress Developer Blog*

Utiliser les MCP tools exposés par WordPress

Une fois ton serveur MCP connecté, tu peux commencer à exploiter les tools exposés par l’adapter. Exemple simple dans Claude Desktop : demander “Get the site info from my WordPress site”.

Requête dans Claude Desktop utilisant le serveur MCP WordPress et renvoyant les infos du site — Claude identifie le serveur MCP, découvre les Abilities, puis exécute celle qui correspond à la demande. — *Forrás: WordPress Developer Blog*

Dans ce scénario, le client IA :

Détecte qu’un serveur MCP est disponible.
Appelle mcp-adapter-discover-abilities pour lister les Abilities accessibles.
Déduit que core/get-site-info correspond à la demande.
Appelle mcp-adapter-execute-ability en lui passant core/get-site-info.
Récupère les données et formule une réponse avec les infos du site.

Aller plus loin : créer un serveur MCP personnalisé dans ton plugin

Le serveur par défaut couvre déjà beaucoup de cas, mais tu peux vouloir un serveur MCP spécifique à ton plugin. L’intérêt : contrôler finement quelles Abilities deviennent des tools (et comment), sans dépendre du flag meta.mcp.public.

Pour faire ça, il faut installer le package via Composer, puis créer/enregistrer ton serveur MCP.

1) Installer le package via Composer

Depuis le dossier de ton plugin :

composer require wordpress/mcp-adapter

composer require wordpress/mcp-adapter

2) Charger l’autoloader Composer

Dans le fichier principal du plugin :

if ( file_exists( __DIR__ . '/vendor/autoload.php' ) ) {
    require_once __DIR__ . '/vendor/autoload.php';
}

if ( file_exists( __DIR__ . '/vendor/autoload.php' ) ) {
    require_once __DIR__ . '/vendor/autoload.php';
}

Si plusieurs plugins risquent de dépendre de l’Abilities API ou du MCP Adapter sur le même site, il est recommandé d’utiliser Jetpack Autoloader pour éviter les conflits de versions (doc du dépôt) : https://github.com/WordPress/mcp-adapter/blob/trunk/docs/getting-started/installation.md#using-jetpack-autoloader-highly-recommended.

3) Initialiser le MCP Adapter

if ( ! class_exists( WPMCPCoreMcpAdapter::class ) ) {
    // check if the MCP Adapter class is available, if not show some sort of error or admin notice
    return;
}

// Initialize MCP Adapter and its default server.
WPMCPCoreMcpAdapter::instance();

if ( ! class_exists( WPMCPCoreMcpAdapter::class ) ) {
    // check if the MCP Adapter class is available, if not show some sort of error or admin notice
    return;
}

// Initialize MCP Adapter and its default server.
WPMCPCoreMcpAdapter::instance();

4) Déclarer un serveur MCP custom avec mcp_adapter_init

Tu peux maintenant créer un serveur sur le hook mcp_adapter_init. Le callback reçoit l’instance McpAdapter, et tu appelles create_server() avec la configuration souhaitée.

add_action( 'mcp_adapter_init', 'myplugin_create_custom_mcp_server' );
function myplugin_create_custom_mcp_server( $adapter ) {
    $adapter = WPMCPCoreMcpAdapter::instance();
    $adapter->create_server(
        'custom-mcp-server', // Unique server identifier.
        'custom-mcp-server', // REST API namespace.
        'mcp',               // REST API route.
        'Custom MCP Server', // Server name.
        'Custom MCP Server', // Server description.
        'v1.0.0',            // Server version.
        array(               // Transport methods.
            WPMCPTransportHttpTransport::class,  // Recommended: MCP 2025-06-18 compliant.
        ),
        WPMCPInfrastructureErrorHandlingErrorLogMcpErrorHandler::class, // Error handler.
        WPMCPInfrastructureObservabilityNullMcpObservabilityHandler::class, // Observability handler.
        array( 'namespace/ability-name' ), // Abilities to expose as tools
        array(),                           // Resources (optional).
        array(),                           // Prompts (optional).
    );
}

add_action( 'mcp_adapter_init', 'myplugin_create_custom_mcp_server' );
function myplugin_create_custom_mcp_server( $adapter ) {
    $adapter = WPMCPCoreMcpAdapter::instance();
    $adapter->create_server(
        'custom-mcp-server', // Unique server identifier.
        'custom-mcp-server', // REST API namespace.
        'mcp',               // REST API route.
        'Custom MCP Server', // Server name.
        'Custom MCP Server', // Server description.
        'v1.0.0',            // Server version.
        array(               // Transport methods.
            WPMCPTransportHttpTransport::class,  // Recommended: MCP 2025-06-18 compliant.
        ),
        WPMCPInfrastructureErrorHandlingErrorLogMcpErrorHandler::class, // Error handler.
        WPMCPInfrastructureObservabilityNullMcpObservabilityHandler::class, // Observability handler.
        array( 'namespace/ability-name' ), // Abilities to expose as tools
        array(),                           // Resources (optional).
        array(),                           // Prompts (optional).
    );
}

Paramètres à bien comprendre :

(1) Identifiant unique du serveur : utilisé notamment quand tu démarres le serveur via WP-CLI.
(2) et (3) Namespace et route REST API de ton serveur MCP.
(4) et (5) Nom et description affichés côté applications IA.
(6) Version du serveur.
(10) Liste des Abilities à exposer en tant que tools (tu peux en mettre plusieurs).
Les autres paramètres couvrent la méthode de transport, la gestion d’erreurs, et l’observabilité. Tu peux utiliser ceux fournis, ou implémenter tes propres handlers pour intégrer ton transport/logging/monitoring.

Exemple complet : ajouter un serveur MCP au plugin “List All URLs”

Pour un exemple réaliste de serveur MCP custom, on peut partir du plugin “List All URLs” : https://github.com/wptrainingteam/list-all-urls.

Important

Avant de tester ce scénario, désactive le plugin MCP Adapter si tu l’avais activé, afin de bien valider l’exécution via la dépendance Composer dans le plugin d’exemple.

1) Cloner le plugin dans wp-content/plugins

cd wp-content/plugins
git clone git@github.com:wptrainingteam/list-all-urls.git

cd wp-content/plugins
git clone git@github.com:wptrainingteam/list-all-urls.git

2) Basculer sur la branche qui intègre l’Abilities API

cd list-all-urls
git checkout abilities

cd list-all-urls
git checkout abilities

3) Installer les dépendances Composer du plugin

composer install

composer install

4) Ajouter wordpress/mcp-adapter

composer require wordpress/mcp-adapter

composer require wordpress/mcp-adapter

5) Modifier list-all-urls.php : init + serveur custom

Dans list-all-urls.php, ajoute en bas du fichier :

if ( ! class_exists( WPMCPCoreMcpAdapter::class ) ) {
    return;
}

// Initialize MCP Adapter and its default server.
WPMCPCoreMcpAdapter::instance();

add_action( 'mcp_adapter_init', 'list_all_urls_create_custom_mcp_server' );
/**
 * Create a custom MCP server for the List All URLs plugin.
 *
 * @param object $adapter WPMCPCoreMcpAdapter The MCP Adapter instance.
 * @return void
 */
function list_all_urls_create_custom_mcp_server( $adapter ) {
    $adapter = WPMCPCoreMcpAdapter::instance();
    $adapter->create_server(
        'list-all-urls-mcp-server',
        'list-all-urls-mcp-server',
        'mcp',
        'List All URLS MCP Server',
        'Custom MCP Server for the List All URLs plugin. Currently exposes only the list-all-urls/urls ability as an MCP Tool.',
        'v1.0.0',
        array(
            WPMCPTransportHttpTransport::class,
        ),
        WPMCPInfrastructureErrorHandlingErrorLogMcpErrorHandler::class,
        WPMCPInfrastructureObservabilityNullMcpObservabilityHandler::class,
        array( 'list-all-urls/urls' ),
    );
}

if ( ! class_exists( WPMCPCoreMcpAdapter::class ) ) {
    return;
}

// Initialize MCP Adapter and its default server.
WPMCPCoreMcpAdapter::instance();

add_action( 'mcp_adapter_init', 'list_all_urls_create_custom_mcp_server' );
/**
 * Create a custom MCP server for the List All URLs plugin.
 *
 * @param object $adapter WPMCPCoreMcpAdapter The MCP Adapter instance.
 * @return void
 */
function list_all_urls_create_custom_mcp_server( $adapter ) {
    $adapter = WPMCPCoreMcpAdapter::instance();
    $adapter->create_server(
        'list-all-urls-mcp-server',
        'list-all-urls-mcp-server',
        'mcp',
        'List All URLS MCP Server',
        'Custom MCP Server for the List All URLs plugin. Currently exposes only the list-all-urls/urls ability as an MCP Tool.',
        'v1.0.0',
        array(
            WPMCPTransportHttpTransport::class,
        ),
        WPMCPInfrastructureErrorHandlingErrorLogMcpErrorHandler::class,
        WPMCPInfrastructureObservabilityNullMcpObservabilityHandler::class,
        array( 'list-all-urls/urls' ),
    );
}

Détail intéressant : ici, tu n’as pas besoin d’ajouter meta.mcp.public sur l’Ability list-all-urls/urls, parce que tu l’exposes explicitement via ton serveur MCP custom.

6) Activer le plugin et configurer ton client IA sur le nouveau serveur

Active le plugin “List All URLs” dans l’admin WordPress. Ensuite, mets à jour la configuration MCP de ton application IA pour utiliser le nouveau serveur.

Exemple de configuration VS Code qui déclare à la fois le serveur par défaut et celui du plugin “List All URLs”, en STDIO :

{
  "servers": {
    "wordpress-mcp-server": {
      "command": "wp",
      "args": [
        "--path=/Users/jonathanbossenger/Studio/wordpress-mcp",
        "mcp-adapter",
        "serve",
        "--server=mcp-adapter-default-server",
        "--user=admin"
      ]
    },
    "list-all-urls-mcp-server": {
      "command": "wp",
      "args": [
        "--path=/Users/jonathanbossenger/Studio/wordpress-mcp",
        "mcp-adapter",
        "serve",
        "--server=list-all-urls-mcp-server",
        "--user=admin"
      ]
    }
  }
}

{
  "servers": {
    "wordpress-mcp-server": {
      "command": "wp",
      "args": [
        "--path=/Users/jonathanbossenger/Studio/wordpress-mcp",
        "mcp-adapter",
        "serve",
        "--server=mcp-adapter-default-server",
        "--user=admin"
      ]
    },
    "list-all-urls-mcp-server": {
      "command": "wp",
      "args": [
        "--path=/Users/jonathanbossenger/Studio/wordpress-mcp",
        "mcp-adapter",
        "serve",
        "--server=list-all-urls-mcp-server",
        "--user=admin"
      ]
    }
  }
}

Le fait d’avoir plusieurs serveurs MCP dans la même application est un gros plus : tu peux basculer entre plusieurs sites WordPress, ou isoler des groupes d’Abilities par plugin/usage.

Après mise à jour de la config : redémarre l’application (ou démarre explicitement le serveur MCP dans l’UI quand l’app le permet). Tu devrais voir le nouveau serveur et pouvoir demander à l’IA “List all URLs on my WordPress site” : elle appellera alors le tool list-all-urls-urls via l’adapter.

Sécurité : les règles à appliquer avant d’ouvrir la porte aux agents

Un point à garder en tête : un client MCP agit comme un utilisateur WordPress connecté. Il faut donc considérer l’intégration MCP comme une extension de ta surface applicative.

Soigne le permission_callback : chaque Ability doit vérifier la capability minimale requise (manage_options, edit_posts, etc.). Évite __return_true sur les opérations destructrices (suppression de contenu, modifications sensibles…).
Utilise des comptes dédiés pour l’accès MCP : en production, crée un user/role spécifique avec des droits limités. N’expose pas des Abilities puissantes à des clients IA non auditables.
Privilégie le read-only pour les endpoints MCP publics : si tu exposes du HTTP sur Internet, reste d’abord sur du diagnostic, du reporting et de l’accès contenu en lecture.
Authentification sur mesure si nécessaire : le mode par défaut passe par les application passwords, mais tu peux implémenter OAuth ou un autre schéma pour durcir la sécurité.
Surveille et journalise l’usage : exploite des handlers d’erreur et d’observabilité personnalisés pour brancher ton stack de logs/monitoring.

Démarrer aujourd’hui : le chemin “hello IA” minimal

Pour expérimenter sans se perdre : le minimum côté dev WordPress consiste à (1) enregistrer une Ability, (2) ajouter/initialiser le MCP Adapter, (3) connecter un client IA compatible MCP.

Si tu as déjà des plugins basés sur l’Abilities API, l’adapter transforme ces Abilities en API prêtes pour des agents IA avec très peu d’effort additionnel. La stratégie la plus saine : commencer petit, exposer d’abord quelques Abilities non destructrices et en lecture seule, tester en local (Claude Desktop, Cursor), puis élargir progressivement vers des workflows plus ambitieux.

Pour aller plus loin : documentation Abilities API https://developer.wordpress.org/apis/abilities/ et dépôt du MCP Adapter https://github.com/WordPress/mcp-adapter.

WordPress MCP Adapter : brancher tes Abilities à des agents IA via le Model Context Protocol

Rappel express : Abilities API, la fondation

WordPress MCP Adapter : à quoi ça sert concrètement ?

Petit mémo MCP : tools, resources, prompts

Installer le MCP Adapter (mode plugin)

Rendre une Ability accessible au serveur MCP par défaut

Connecter des applications IA à ton site WordPress MCP

Les deux transports MCP : STDIO et HTTP

Configurations spécifiques : Claude Desktop, Cursor, Claude Code, VS Code

Valeurs d’exemple

Claude Desktop

Cursor

Claude Code

VS Code

Utiliser les MCP tools exposés par WordPress

Aller plus loin : créer un serveur MCP personnalisé dans ton plugin

1) Installer le package via Composer

2) Charger l’autoloader Composer

3) Initialiser le MCP Adapter

4) Déclarer un serveur MCP custom avec mcp_adapter_init

Exemple complet : ajouter un serveur MCP au plugin “List All URLs”

Important

1) Cloner le plugin dans wp-content/plugins

2) Basculer sur la branche qui intègre l’Abilities API

3) Installer les dépendances Composer du plugin

4) Ajouter wordpress/mcp-adapter

5) Modifier list-all-urls.php : init + serveur custom

6) Activer le plugin et configurer ton client IA sur le nouveau serveur

Sécurité : les règles à appliquer avant d’ouvrir la porte aux agents

Démarrer aujourd’hui : le chemin “hello IA” minimal

Références / Sources

Camille Dubois

Plus d’articles de Camille Dubois

Rejoignez la communauté HelloWP !