WordPress MCP Adapter: zo maak je Abilities direct bruikbaar voor AI-agents
WordPress beweegt stap voor stap richting automatisering met Generative AI, maar dan wel op een manier die past bij het ecosysteem: gestandaardiseerd, uitbreidbaar en met duidelijke permissies. De grote enablers daarin zijn de Abilities API (WordPress 6.9) en de WordPress MCP Adapter, die die abilities beschikbaar maakt via het Model Context Protocol (MCP).
Het praktische resultaat: als je plugin(s) al abilities registreren, ben je nog maar één stap verwijderd van AI-agents die ze kunnen discoveren en executen vanuit tools als Claude Desktop, Claude Code, Cursor en VS Code.
Snelle opfrisser: Abilities als fundament
De Abilities API geeft WordPress een first-class, cross-context functional API: één uniforme manier waarop core en plugins kunnen beschrijven wat ze kunnen doen. Het doel is dat functionaliteit gestandaardiseerd, discoverable, typed en executable wordt-en dat vanuit meerdere contexten.
Een ability definieer je één keer met:
- Een unieke naam (
namespace/ability-name). - Een getypeerde input schema en output schema.
- Een permission_callback die capabilities afdwingt.
- Een execute_callback die de daadwerkelijke actie uitvoert.
Wat je in execute_callback doet kan van alles zijn: data ophalen, posts updaten, diagnostiek draaien, of een andere afgebakende unit of work.
Na registratie is een ability vindbaar en uitvoerbaar vanuit PHP, JavaScript en de REST API.
WordPress 6.9 levert (op dit moment) drie core-abilities mee, handig als testset:
core/get-site-info: geeft site-informatie terug die in WordPress is geconfigureerd. Standaard alle velden, of optioneel een gefilterde subset.core/get-user-info: geeft basisprofielinformatie terug van de huidige geauthenticeerde gebruiker (personalisatie, auditing, access-aware gedrag).core/get-environment-info: geeft runtime-context terug voor diagnose en compatibiliteit (environment, PHP runtime, database server info, WordPress-versie).
Wat is de WordPress MCP Adapter?
De WordPress MCP Adapter is een officieel pakket binnen het initiatief AI Building Blocks for WordPress. De adapter vertaalt abilities die je registreert via de Abilities API naar de primitives van MCP, zodat AI-agents:
- sitefunctionaliteit kunnen ontdekken en uitvoeren als MCP tools;
- WordPress-data kunnen lezen als MCP resources.
Kort gezegd: abilities zijn de building blocks; MCP is de manier waarop AI-clients context en uitvoerbare acties gestandaardiseerd kunnen benaderen.
MCP in 3 primitives: tools, resources en prompts
MCP organiseert interacties in drie hoofdprimitives:
- Tools: uitvoerbare functies die een AI kan aanroepen om acties te doen.
- Resources: passieve databronnen die een AI kan lezen voor context (denk aan files of database-rijen).
- Prompts: vooraf ingestelde templates die een workflow sturen.
In de praktijk zal je abilities meestal als tools exposen omdat ze uitvoerbare logica vertegenwoordigen (data ophalen, posts updaten, diagnostiek). Maar de adapter is flexibel: als een ability puur read-only context levert (bijv. een debuglog of statische configuratie), kun je die ook als resource inrichten zodat de AI het kan inlezen zonder een actieve tool-call.
Installatie: MCP Adapter als plugin
De snelste start is de MCP Adapter downloaden en installeren als plugin via de GitHub releases: https://github.com/WordPress/mcp-adapter/releases.
Na activatie registreert de plugin een default MCP server met de naam mcp-adapter-default-server, plus drie custom abilities:
mcp-adapter/discover-abilitiesmcp-adapter/get-ability-infomcp-adapter/execute-ability
Die abilities worden automatisch als MCP tools beschikbaar gemaakt onder deze toolnamen:
mcp-adapter-discover-abilitiesmcp-adapter-get-ability-infomcp-adapter-execute-ability
Samen vormen ze een gelaagde toegang: een agent kan eerst discoveren welke abilities bestaan, dan info ophalen over zo’n ability, en vervolgens de juiste ability executen.
Abilities beschikbaar maken op de default server
Belangrijk detail: abilities zijn op de default MCP server niet automatisch zichtbaar. Standaard zijn ze alleen via de MCP Adapter default server beschikbaar als je ze expliciet als “public voor MCP” markeert.
Dat doe je door bij wp_register_ability() een meta.mcp.public vlag toe te voegen:
'meta' => array(
'mcp' => array(
'public' => true, // Required for MCP default server access
),
),
Voor core-abilities (die je natuurlijk niet zelf registreert) kun je via de wp_register_ability_args filter de registratie-args aanpassen en alsnog meta.mcp.public toevoegen. Bijvoorbeeld om de drie huidige core-abilities MCP-toegang te geven:
<?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;
}
Met deze plugin actief kun je AI-clients verbinden met je WordPress-installatie en de core-abilities via de default server laten aanroepen.
AI-apps verbinden: STDIO of HTTP
MCP kent twee transport-mechanismen: STDIO en HTTP. Welke je gebruikt hangt vooral af van waar je WordPress draait.
Transport 1: STDIO (lokaal) via WP-CLI
Voor lokale WordPress development-omgevingen is STDIO vaak het meest rechttoe-rechtaan. De MCP Adapter ondersteunt dit via WP-CLI, dus WP-CLI moet lokaal geïnstalleerd zijn.
Minimale configuratie (conceptueel) om te verbinden met je MCP-enabled WordPress site via STDIO:
{
"wordpress-mcp-server": {
"command": "wp",
"args": [
"--path=/path/to/your/wordpress/installation",
"mcp-adapter",
"serve",
"--server=mcp-adapter-default-server",
"--user={admin_user}"
]
}
}
- De servernaam (
wordpress-mcp-server) is vrij te kiezen. commandiswp(WP-CLI).--pathwijst naar je WordPress-installatie.mcp-adapter servestart de server.--serverkiest welke MCP server je draait (hier: default).--userbepaalt als welke WordPress-user de MCP client zich authenticeert.
Transport 2: HTTP (publiek of zonder STDIO) via remote proxy
Voor publiek toegankelijke WordPress-installaties, of als je liever niet met STDIO werkt, kun je HTTP gebruiken via de remote proxy @automattic/mcp-wordpress-remote. Hiervoor heb je Node.js nodig en authenticatie via WordPress application passwords of een eigen OAuth-implementatie.
Minimale configuratie voor 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}"
}
}
}
commandisnpxom een Node package uit te voeren.-yaccepteert installatie zonder prompt.@automattic/mcp-wordpress-remote@latestdraait de nieuwste versie van de proxy.WP_API_URLwijst naar het MCP endpoint op je WordPress site (/wp-json/mcp/...).WP_API_USERNAMEis de WordPress-user.WP_API_PASSWORDis het application password van die user.
Voor lokale installaties die je toch via de HTTP remote proxy wilt benaderen, staan er troubleshooting-tips in de docs van het package: https://github.com/Automattic/mcp-wordpress-remote/blob/trunk/Docs/troubleshooting.md. Issues zitten daar vaak in meerdere Node-versies naast elkaar of problemen met lokale SSL-certificaten.
Configuratie per app: Claude Desktop, Cursor, Claude Code en VS Code
Configuratieformat
Claude Desktop en Cursor gebruiken een mcpServers object. VS Code gebruikt een servers object. De rest van de serverdefinitie (command/args/env) blijft hetzelfde.
Claude Desktop
Claude Desktop heeft ingebouwde MCP-support. Je voegt MCP servers toe via de Developer-instellingen: Claude → Settings → Developer. Onder “Local MCP servers” kies je Edit config; dat opent de locatie van claude_desktop_config.json.
In Claude Desktop zet je serverdefinities onder mcpServers:
{
"mcpServers": {
}
}
Voorbeeld (STDIO):
{
"mcpServers": {
"wordpress-mcp-server": {
"command": "wp",
"args": [
"--path=/Users/jonathanbossenger/Studio/wordpress-mcp",
"mcp-adapter",
"serve",
"--server=mcp-adapter-default-server",
"--user=admin"
]
}
}
}
Voorbeeld (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"
}
}
}
}
Na opslaan moet je Claude Desktop herstarten; de app leest MCP serverconfiguratie alleen bij startup. Als alles klopt, zie je in de Developer-tab de server met status running.
Cursor
In Cursor vind je MCP onder Cursor → Settings → Cursor Settings → Tools and MCP. Klik op Add Custom MCP; dat opent mcp.json.
De configuratie is hetzelfde format als Claude Desktop. Na opslaan verschijnt de server in Tools and MCP en kun je ‘m activeren voor je coding sessions.
Claude Code
Claude Code kun je op twee manieren configureren:
- Globaal:
mcpServerstoevoegen aan.claude.jsonin je home directory. - Per project: een
.mcp.jsonin je projectdirectory.
Per project is handig als je verschillende MCP servers per codebase wilt gebruiken; globaal is handig als je één set servers overal beschikbaar wilt hebben. Het configuratieformat is hetzelfde als bij Cursor/Claude Desktop.
VS Code
VS Code configureer je via een JSON-bestand (meestal mcp.json) in .vscode/ binnen je workspace. De serverdefinities staan in een servers object (niet mcpServers). Verder blijft alles gelijk. Documentatie: https://code.visualstudio.com/docs/copilot/customization/mcp-servers.
{
"servers": {
// MCP server definitions go here
}
}
Als VS Code de server correct start, zie je een MCP-control toolbar waarmee je kunt starten/stoppen/restarten. VS Code laat ook zien hoeveel tools beschikbaar zijn (bij de default server: drie).
MCP tools gebruiken: wat gebeurt er precies?
Zodra je MCP server gekoppeld is aan je AI-app, kun je de tools gebruiken die de MCP Adapter exposeert. Een simpele test in Claude Desktop is: “Get the site info from my WordPress site.”
Onder de motorkap verloopt dat gelaagd:
- De client ziet dat er een MCP server beschikbaar is.
- De agent roept
mcp-adapter-discover-abilitiesaan om te ontdekken welke abilities bestaan. - Vervolgens kiest de agent de juiste ability (bijv.
core/get-site-info). - Daarna roept de agent
mcp-adapter-execute-abilityaan en geeft de ability-naam mee. - De tool-call levert de data terug, en de AI-app presenteert dat als antwoord.
Custom MCP servers maken voor je plugin (Composer)
De default server is genoeg voor veel gevallen, maar soms wil je als plugin-auteur meer controle: exact bepalen welke abilities je exposeert, eigen servernaam/description, eigen handlers voor logging/observability, en vooral: abilities beschikbaar maken zonder meta.mcp.public op de default server.
Daarvoor installeer je de MCP Adapter als dependency via Composer:
composer require wordpress/mcp-adapter
Laad vervolgens Composer’s autoloader in je hoofdpluginbestand:
if ( file_exists( __DIR__ . '/vendor/autoload.php' ) ) {
require_once __DIR__ . '/vendor/autoload.php';
}
Als meerdere plugins op één site afhankelijk kunnen zijn van de MCP Adapter of de Abilities API, wordt aangeraden om Jetpack Autoloader te gebruiken om versieconflicten te vermijden: https://github.com/WordPress/mcp-adapter/blob/trunk/docs/getting-started/installation.md#using-jetpack-autoloader-highly-recommended.
Initialiseer daarna de MCP Adapter (inclusief de default server):
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();
Een custom MCP server maak je via de mcp_adapter_init action. In de callback gebruik je create_server() om de server te definiëren:
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).
);
}
Parameters die je in de praktijk het vaakst nodig hebt:
- Parameter 1: unieke server identifier (ook gebruikt bij WP-CLI om de server te starten).
- Parameter 2 + 3: REST API namespace en route.
- Parameter 4 + 5: servernaam en beschrijving (zichtbaar in AI-apps).
- Parameter 6: serverversie.
- Parameter 10: array met ability-namen die je als tools exposeert (meerdere kan).
- Overige parameters: transport, error handling, observability. Je kunt eigen handlers bouwen als je wilt integreren met je eigen transport/logging/monitoring.
Voorbeeld: custom MCP server toevoegen aan “List All URLs”
Een concreet voorbeeld is de plugin “List All URLs”: https://github.com/wptrainingteam/list-all-urls. Het idee: de plugin exposeert een ability list-all-urls/urls, en via een custom MCP server maak je die direct beschikbaar als tool-zonder meta.mcp.public op de default server.
Voor je begint: deactiveer de MCP Adapter plugin als je die als losse plugin hebt draaien.
Clone daarna de repo in je plugins-directory:
cd wp-content/plugins
git clone git@github.com:wptrainingteam/list-all-urls.git
Schakel naar de branch met de Abilities API implementatie:
cd list-all-urls
git checkout abilities
Installeer dependencies (de plugin gebruikt Composer):
composer install
Voeg vervolgens de MCP Adapter dependency toe:
composer require wordpress/mcp-adapter
Open nu list-all-urls.php en voeg onderaan deze code toe om de adapter te initialiseren en een custom server te registreren:
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' ),
);
}
Let op: je hoeft nu géén meta.mcp.public aan te zetten voor list-all-urls/urls, omdat je deze ability expliciet exposeert via je custom server.
Activeer daarna de plugin via wp-admin. Vervolgens update je de MCP serverconfiguratie in je AI-app om ook deze nieuwe server te starten.
Voorbeeld voor VS Code met twee servers (beide STDIO): de default server én de custom List All URLs server:
{
"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"
]
}
}
}
Meerdere MCP servers naast elkaar configureren is dus prima. Handig als je wilt wisselen tussen sites, of tussen plugin-specifieke sets aan tools.
Na het updaten: herstart je app of start de MCP server(s) opnieuw in de UI. Daarna kun je bijvoorbeeld vragen: “List all URLs on my WordPress site”, waarna de client de list-all-urls-urls tool via de adapter zal gebruiken.
Security en best practices
MCP clients gedragen zich als ingelogde WordPress-users. Zie ze dus als onderdeel van je aanvalsoppervlak en hanteer strikte richtlijnen:
- Gebruik
permission_callbackzorgvuldig: check per ability de minimale capability (manage_options,edit_posts, enz.). Vermijd__return_truebij destructieve acties zoals content verwijderen. - Gebruik dedicated users voor MCP access: zeker in productie een aparte rol/user met beperkte rechten. Expose geen krachtige abilities aan niet-geaudite AI-clients.
- Kies voor read-only abilities bij publieke HTTP endpoints: denk aan diagnostics, reporting en content read access.
- Implementeer custom authentication als dat nodig is: standaard werkt het met application passwords, maar OAuth of alternatieven kunnen beter passen bij je securitymodel.
- Monitor en log usage: gebruik custom error- en observability-handlers om te koppelen met je logging/monitoring stack.
Snel starten: minimale “hello AI”-route
Als je vandaag wilt experimenteren, is de minimale route verrassend kort:
- Registreer een ability (liefst read-only om te beginnen).
- Require en initialiseer de MCP Adapter (plugin of Composer).
- Verbind een MCP-aware AI-client (Claude Desktop, Cursor, Claude Code, VS Code).
Heb je al plugins die de Abilities API gebruiken, dan maakt de MCP Adapter daar met weinig extra werk AI-ready API’s van. Begin klein, expose een paar niet-destructieve abilities als tools, test lokaal, en breid pas daarna uit naar complexere workflows.
Documentatie die je er direct naast wilt houden: Abilities API: https://developer.wordpress.org/apis/abilities/ en MCP Adapter: https://github.com/WordPress/mcp-adapter.
Praktische nuance: WordPress.com, OAuth 2.1 en self-hosted auth
In discussies rondom MCP komt vaak de vraag op of dit kan convergeren tussen WordPress.com en self-hosted. Wat hierbij relevant is: de MCP tools op WordPress.com draaien op dezelfde fundamenten (Abilities API + MCP Adapter). Het grote verschil zit vooral in authenticatie: WordPress.com gebruikt OAuth 2.1 (zie: https://wordpress.com/blog/2026/01/22/connect-ai-agents-to-wordpress-oauth-2-1/), terwijl je op self-hosted momenteel vaak uitkomt op JWT tokens of application passwords.
Referenties / Bronnen
- From Abilities to AI Agents: Introducing the WordPress MCP Adapter
- Abilities API in WordPress 6.9
- Introducing the WordPress Abilities API
- Model Context Protocol (MCP) Intro
- MCP Adapter
- AI Building Blocks for WordPress
- @automattic/mcp-wordpress-remote
- mcp-wordpress-remote troubleshooting
- Application Passwords Integration Guide
- VS Code MCP servers documentation
- WordPress MCP Adapter repository
- List All URLs plugin
- Connect AI agents to WordPress with OAuth 2.1
Sophie de Vries
Hoofdredacteur van het Nederlandse team, evangelist voor toegankelijkheid en webstandaarden. Ik geloof in het open web en inclusief design. WCAG-expert.
Alle berichtenMeer van Sophie de Vries
European Accessibility Act (EAA) is live: zo maak je je WordPress-site nu toegankelijk
WP Media Cleanup (van Duplicator): ongebruikte WordPress-afbeeldingen opsporen, veilig verwijderen en via WP-CLI automatiseren
WooCommerce 10.5 komt eraan: dit verandert er voor developers (performance, API, checkout en belasting)