Dal’Abilities API agli AI agent: come usare il WordPress MCP Adapter (con esempi reali)

Con WordPress 6.9 è arrivata l’Abilities API, un modo coerente e “machine-friendly” per dichiarare cosa sa fare un sito (core o plugin) tramite funzioni standardizzate, scopribili, tipizzate ed eseguibili. Il passo successivo, per chi sta lavorando su automazioni e agent, è naturale: esporre quelle Abilities a strumenti di AI in modo sicuro e controllabile.

Qui entra in gioco il WordPress MCP Adapter, un pacchetto ufficiale dell’iniziativa AI Building Blocks for WordPress che implementa il Model Context Protocol (MCP) nel perimetro di un sito WordPress. Tradotto in pratica: un client compatibile MCP (Claude Desktop, Claude Code, Cursor, VS Code) può scoprire e chiamare le Abilities del tuo sito come se fossero MCP tools, e in alcuni casi leggere dati come MCP resources.

In questa guida trovi: installazione del MCP Adapter, come rendere disponibili le Abilities al server di default, come collegare i principali client AI con trasporti STDIO/HTTP, come usare i tool, come creare server MCP custom per un plugin, un esempio completo con “List All URLs”, e una checklist di sicurezza.

Ripasso veloce: perché Abilities è la base giusta

L’Abilities API dà a WordPress una API funzionale “di prima classe” e cross-context: la stessa Ability è scopribile ed eseguibile da PHP, JavaScript e REST API, con input/output definiti e permessi espliciti.

Una Ability la registri una volta con:

Un nome univoco nel formato namespace/ability-name
Uno schema tipizzato per input e output (input schema e output schema)
Una permission_callback per applicare capability e vincoli
Una execute_callback che esegue davvero l’azione (fetch dati, update post, diagnostica, ecc.)

WordPress 6.9 include già 3 Abilities di core, utili anche solo per fare prove con MCP:

core/get-site-info: ritorna le informazioni del sito configurate in WordPress (tutti i campi o un sottoinsieme).
core/get-user-info: ritorna dettagli base del profilo dell’utente autenticato corrente, utile per personalizzazione/audit/comportamenti “access-aware”.
core/get-environment-info: ritorna dettagli del contesto runtime (ambiente, runtime PHP, info DB server, versione WordPress) per diagnostica e compatibilità.

Cos’è il WordPress MCP Adapter

Il WordPress MCP Adapter fa da “ponte” tra Abilities e MCP: adatta le Abilities (registrate tramite Abilities API) nelle primitive supportate dal Model Context Protocol così che un agent possa:

Scoprire ed eseguire funzionalità del sito come MCP tools
Leggere dati WordPress come MCP resources quando ha senso esporli in modo passivo

In altre parole: se il tuo plugin registra già Abilities, sei molto vicino a renderle utilizzabili da un agent AI, senza inventarti una nuova API proprietaria.

Primer MCP: tools, resources, prompts

MCP organizza l’interazione in tre primitive:

Tools: funzioni eseguibili chiamate dall’AI per compiere azioni.
Resources: fonti dati passive (file, righe DB, ecc.) che l’AI legge come contesto.
Prompts: template preconfigurati per guidare workflow specifici.

Con il MCP Adapter, la scelta più comune è esporre le Abilities come tools, perché spesso incarnano logica eseguibile (lettura dati, update contenuti, diagnostica). Però l’adapter è flessibile: una Ability puramente read-only che fornisce dati “statici” (ad esempio un log di debug o una configurazione del sito) può essere configurata come resource, così l’AI la usa come contesto senza “invocarla” come azione.

Installare il MCP Adapter (via plugin)

Il percorso più rapido per iniziare è installarlo come plugin scaricandolo dalla pagina delle release su GitHub: https://github.com/WordPress/mcp-adapter/releases.

Una volta installato e attivato, il plugin registra:

Un server MCP di default chiamato mcp-adapter-default-server
Tre Abilities custom dell’adapter: mcp-adapter/discover-abilities, mcp-adapter/get-ability-info, mcp-adapter/execute-ability
Le stesse esposte automaticamente come MCP tools: mcp-adapter-discover-abilities, mcp-adapter-get-ability-info, mcp-adapter-execute-ability

Questi tre tool permettono un accesso “a strati” alle Abilities: prima l’agent scopre cosa è disponibile, poi legge i dettagli di una Ability, infine la esegue.

Rendere disponibili le Abilities al server di default

Per impostazione predefinita, una Ability è disponibile via server di default del MCP Adapter solo se la marchi esplicitamente come pubblica per l’accesso MCP. Il flag da aggiungere durante la registrazione con wp_register_ability() è meta.mcp.public.

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

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

Per le Abilities di core (che ovviamente non registri tu), puoi intervenire con il filtro wp_register_ability_args e “arricchire” gli argomenti di registrazione aggiungendo quel flag.

<?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;
}

A questo punto puoi collegare un client AI al tuo WordPress “MCP-enabled” e chiamare quelle Abilities passando dal server di default e dai tool dell’adapter.

Collegare applicazioni AI: STDIO vs HTTP

Metodi di trasporto

Per parlare con un sito WordPress esposto come server MCP esistono due meccanismi di trasporto (transport layer): STDIO e HTTP. La scelta dipende quasi sempre da dove gira il sito.

STDIO: ideale in locale, soprattutto in ambienti di sviluppo. Nel caso del MCP Adapter, passa da WP-CLI (quindi WP-CLI deve essere installato localmente).
HTTP: tipico per installazioni raggiungibili pubblicamente, o quando non vuoi/puoi usare STDIO. In questo caso puoi usare un proxy remoto basato su Node.js: @automattic/mcp-wordpress-remote.

Configurazione minima per STDIO (WP-CLI)

Per un ambiente WordPress locale, la configurazione minima in stile MCP è questa:

{
  "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}"
    ]
  }
}

Dettagli importanti:

wordpress-mcp-server è un nome a tua scelta (identificatore del server nella configurazione del client).
command è wp (il binario di WP-CLI).
In args: --path punta alla directory di installazione WordPress; mcp-adapter serve avvia il server; --server sceglie quale server MCP usare (qui il default); --user definisce l’utente WordPress con cui autenticare le chiamate (es. admin).

Configurazione minima per HTTP (proxy Node.js)

Per un’installazione pubblica (o semplicemente per evitare STDIO), puoi impostare HTTP usando il proxy @automattic/mcp-wordpress-remote (serve Node.js). L’autenticazione può avvenire con application passwords WordPress, oppure con una implementazione OAuth custom.

{
  "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}"
    }
  }
}

Note pratiche:

command è npx (esegue pacchetti Node).
In args, -y accetta automaticamente l’installazione e @automattic/mcp-wordpress-remote@latest usa l’ultima versione del proxy.
In env, WP_API_URL punta all’endpoint MCP del sito, mentre username e application password definiscono l’identità WordPress con cui il client agirà.

Se stai usando HTTP proxy verso un WordPress locale, il progetto mcp-wordpress-remote include anche una pagina di troubleshooting: https://github.com/Automattic/mcp-wordpress-remote/blob/trunk/Docs/troubleshooting.md. I problemi più frequenti in questi casi sono legati a più versioni di Node installate o a certificati SSL locali.

Dove si configura l’MCP server nei client più usati

Qui sotto trovi i punti esatti dell’interfaccia dove inserire la configurazione MCP in Claude Desktop, Cursor, Claude Code e VS Code. Il formato della configurazione è sostanzialmente lo stesso: cambiano soprattutto nome del file e (nel caso di VS Code) la chiave root (servers invece di mcpServers).

Claude Desktop

In Claude Desktop vai nella sezione Developer (Claude → Settings → Developer). Sotto “Local MCP servers” clicca Edit config: si aprirà il file claude_desktop_config.json.

I server MCP si definiscono dentro l’oggetto mcpServers:

{
  "mcpServers": {
  }
}

{
  "mcpServers": {
  }
}

Ecco un esempio completo con trasporto 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"
      ]
    }
  }
}

E lo stesso con trasporto 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"
      }
    }
  }
}

Dopo aver salvato il file, riavvia Claude Desktop: legge la configurazione dei server MCP solo all’avvio. Quando tutto è ok, nella tab Developer vedrai il server con stato running e potrai usarlo nelle conversazioni.

Claude Desktop con WordPress MCP server aggiunto tra i Local MCP servers — . — *Forrás: developer.wordpress.org*

Cursor

In Cursor vai in Settings (Cursor → Settings → Cursor Settings) e apri la sezione Tools and MCP.

Clicca Add Custom MCP: Cursor aprirà il file mcp.json. Il formato della configurazione è lo stesso di Claude Desktop. Dopo il salvataggio, torna in Tools and MCP: vedrai il server in lista e potrai abilitarlo per le sessioni di coding.

Claude Code

Con Claude Code puoi aggiungere i server MCP in due modi:

Inserendo un oggetto mcpServers con le configurazioni dentro il file .claude.json nella tua home directory (config globale).
Creando un file .mcp.json nella directory del progetto (config per-progetto, utile se vuoi server diversi a seconda del repository).

In entrambi i casi, puoi usare lo stesso formato visto per Cursor/Claude Desktop.

VS Code

In VS Code la configurazione dei server MCP avviene tramite un file JSON tipicamente chiamato mcp.json, da mettere in .vscode dentro il workspace. Il dettaglio che cambia è che i server stanno dentro l’oggetto servers (non mcpServers).

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

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

Una volta presente il file, VS Code mostra una toolbar di controllo MCP per avviare/fermare/riavviare il server. Quando parte correttamente, ti mostra anche quanti tool sono disponibili (nel caso base dell’adapter: tre).

Usare i MCP tools: esempio end-to-end

Una volta connesso il server MCP nel client che preferisci, puoi iniziare a usare i tool esposti dal MCP Adapter. Un esempio semplice in Claude Desktop: chiedi qualcosa come “Recupera le informazioni del sito dal mio WordPress”.

Il flusso tipico è:

Il client identifica che esiste un MCP server collegato.
Chiama mcp-adapter-discover-abilities per capire quali Abilities sono disponibili.
Seleziona l’Ability corretta (es. core/get-site-info).
Chiama mcp-adapter-execute-ability passando il nome dell’Ability.
Riceve i dati e li presenta come risposta (site info).

Quando ha senso creare un MCP server custom per un plugin

Il server di default dell’adapter copre molti casi, ma un server MCP custom nel tuo plugin ti dà più controllo su come e cosa esporre. Per farlo, l’approccio consigliato è installare il pacchetto via Composer e registrare il server nel lifecycle del plugin.

1) Installare via Composer

Dalla directory del plugin:

composer require wordpress/mcp-adapter

composer require wordpress/mcp-adapter

2) Caricare l’autoloader di Composer

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';
}

Se è realistico che più plugin nello stesso sito dipendano da MCP Adapter o Abilities API, la documentazione ufficiale raccomanda di usare Jetpack Autoloader per evitare conflitti di versione: https://github.com/WordPress/mcp-adapter/blob/trunk/docs/getting-started/installation.md#using-jetpack-autoloader-highly-recommended.

3) Inizializzare l’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) Registrare un server custom con mcp_adapter_init

Agganciati all’action mcp_adapter_init. La callback riceve l’istanza dell’adapter; poi chiami create_server() con configurazione, trasporti, handler e lista di Abilities esposte.

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).
    );
}

Parametri da non confondere:

1° parametro: identificatore univoco del server (serve anche quando lo avvii via WP-CLI).
2° e 3° parametro: namespace e route REST API del server MCP.
4° e 5° parametro: nome e descrizione mostrati nei client AI quando elencano i server disponibili.
6° parametro: versione del server.
10° parametro: array dei nomi delle Abilities che vuoi esporre come MCP tools (anche più di una).
Gli altri parametri controllano trasporti, error handling e observability. In esempio: HTTP transport, error log e handler di osservabilità “null”, ma puoi implementare handler custom per integrare transport/logging/monitoring proprietari.

Esempio completo: aggiungere un server MCP custom a “List All URLs”

Per vedere un caso concreto, prendiamo il plugin List All URLs: https://github.com/wptrainingteam/list-all-urls. L’obiettivo è esporre la sua Ability list-all-urls/urls come MCP tool tramite un server custom del plugin.

Prima di iniziare

Se hai attivo il plugin “MCP Adapter” installato come plugin WordPress, disattivalo prima di procedere con l’esempio: qui usiamo l’adapter come dipendenza del plugin via Composer.

1) Clonare il repository nella directory 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) Passare al branch con Abilities API

cd list-all-urls
git checkout abilities

cd list-all-urls
git checkout abilities

3) Installare le dipendenze

Il plugin usa già Composer, quindi:

composer install

composer install

4) Aggiungere la dipendenza wordpress/mcp-adapter

composer require wordpress/mcp-adapter

composer require wordpress/mcp-adapter

5) Modificare list-all-urls.php: init adapter + create_server()

Apri list-all-urls.php e aggiungi in fondo questo codice per inizializzare l’adapter e registrare un server MCP custom che espone solo list-all-urls/urls come tool.

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' ),
    );
}

Dettaglio utile: qui non serve impostare meta.mcp.public sull’Ability list-all-urls/urls, perché la stai esponendo esplicitamente tramite server custom.

6) Attivare il plugin e aggiornare la configurazione nel client AI

Dopo aver attivato “List All URLs” da wp-admin, aggiorna la configurazione del tuo client AI per usare anche il nuovo server. Ecco un esempio di mcp.json per VS Code che include sia il server di default sia quello custom, entrambi in 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"
      ]
    }
  }
}

È perfettamente possibile configurare più server MCP nello stesso client: utile per passare tra siti diversi o tra set di Abilities esposte da plugin differenti. Dopo l’aggiornamento ricordati di riavviare l’app o (dove supportato) avviare il server MCP dal controllo integrato.

A questo punto puoi chiedere all’AI qualcosa come “Elenca tutti gli URL del mio sito WordPress” e il client chiamerà il tool list-all-urls-urls tramite MCP Adapter.

Sicurezza e best practice (da applicare sempre)

Un punto da tenere sempre presente: i client MCP agiscono come utenti WordPress autenticati. Quindi vanno trattati come parte della tua superficie applicativa.

Usa permission_callback con attenzione: ogni Ability deve verificare la capability minima necessaria (manage_options, edit_posts, ecc.).
Evita __return_true per operazioni distruttive (ad esempio cancellazioni o modifiche irreversibili).
Usa utenti dedicati per accesso MCP: soprattutto in produzione, crea un utente/ruolo specifico con capability limitate.
Non esporre Abilities potenti a client AI non verificati/auditati.
Preferisci Abilities read-only per endpoint MCP pubblici: se esponi HTTP su internet, concentrati su diagnostica, reportistica e accesso contenuti in sola lettura.
Implementa autenticazione custom se serve: di default puoi usare application passwords, ma puoi adottare OAuth o altri metodi per alzare il livello di sicurezza.
Monitora e fai logging dell’uso: valuta handler custom di error/observability per integrare logging e monitoring nel tuo stack.

Come iniziare a sperimentare subito (per davvero)

Il percorso minimo “hello AI” per uno sviluppatore WordPress è lineare:

Registra una Ability (anche banale e read-only).
Aggiungi MCP Adapter (plugin o Composer) e inizializzalo.
Collega un client compatibile MCP (Claude Desktop, Cursor, VS Code, Claude Code) via STDIO o HTTP.
Prova a far chiamare il tool dall’AI e controlla permessi/risposte/log.

Se hai già plugin basati su Abilities API, il MCP Adapter può trasformarli rapidamente in API pronte per agent AI, con uno sforzo aggiuntivo minimo. Il consiglio operativo è partire piccolo: poche Abilities non distruttive, test in locale, e poi espansione graduale a workflow più complessi.

Documentazione utile: Abilities API https://developer.wordpress.org/apis/abilities/ e repository MCP Adapter https://github.com/WordPress/mcp-adapter.

Dal’Abilities API agli AI agent: come usare il WordPress MCP Adapter (con esempi reali)

Ripasso veloce: perché Abilities è la base giusta

Cos’è il WordPress MCP Adapter

Primer MCP: tools, resources, prompts

Installare il MCP Adapter (via plugin)

Rendere disponibili le Abilities al server di default

Collegare applicazioni AI: STDIO vs HTTP

Metodi di trasporto

Configurazione minima per STDIO (WP-CLI)

Configurazione minima per HTTP (proxy Node.js)

Dove si configura l’MCP server nei client più usati

Claude Desktop

Cursor

Claude Code

VS Code

Usare i MCP tools: esempio end-to-end

Quando ha senso creare un MCP server custom per un plugin

1) Installare via Composer

2) Caricare l’autoloader di Composer

3) Inizializzare l’MCP Adapter

4) Registrare un server custom con mcp_adapter_init

Esempio completo: aggiungere un server MCP custom a “List All URLs”

Prima di iniziare

1) Clonare il repository nella directory plugins

2) Passare al branch con Abilities API

3) Installare le dipendenze

4) Aggiungere la dipendenza wordpress/mcp-adapter

5) Modificare list-all-urls.php: init adapter + create_server()

6) Attivare il plugin e aggiornare la configurazione nel client AI

Sicurezza e best practice (da applicare sempre)

Come iniziare a sperimentare subito (per davvero)

Riferimenti / Fonti

Francesca Rossi

Altro da Francesca Rossi

Unisciti alla community di HelloWP!