WordPress MCP Adapter: kuidas Abilities API-st saavad AI agendi tööriistad

WordPress 6.9 tõi Abilities API, mis annab arendajale standardse viisi kirjeldada „mida see sait või plugin oskab teha“ nii, et see oleks avastatav, tüübistatud (sisend/väljund skeemid) ja käivitatav eri kontekstidest (PHP, JavaScript, REST API). See on oluline ka AI automatiseerimise vaates: kui saidi võimekused on masinloetavalt kirjeldatud, saab neid usaldusväärsemalt kasutada agentides ja töövoogudes.

Sama loogika järgmine samm on Model Context Protocol (MCP) – protokoll, mille abil AI tööriistad saavad „konteksti“ ja teha struktureeritud päringuid väliste süsteemide poole. WordPressi puhul tähendab see, et AI klient võiks saada kontrollitud ligipääsu sinu saidi funktsioonidele ja andmetele (näiteks tellimused, postitused, diagnostika), mitte ainult genereerida teksti.

Selle sillaks on WordPress MCP Adapter: ametlik pakett AI Building Blocks for WordPress algatusest, mis seob Abilities API abil registreeritud võimekused MCP maailmaga. Praktilises mõttes: abilised (abilities) muutuvad AI kliendile MCP tools’ideks (käivitatavad funktsioonid) ja teatud juhtudel ka resources’iteks (loetav kontekst).

Kiirkordus: mis on Abilities API ja miks see loeb?

Abilities API eesmärk on anda WordPressile esimese klassi, eri kontekstides toimiv funktsionaalne API: nii core kui pluginad saavad ühtse mustri järgi kirjeldada oma võimekusi.

Ühe ability defineerid sisuliselt korra ja standardsel kujul:

unikaalne nimi kujul namespace/ability-name
tüübistatud input schema ja output schema
permission_callback, mis kontrollib õiguseid/capabilities
execute_callback, mis teeb töö (andmete toomine, postituse uuendus, diagnostika jne)

Kui ability on registreeritud, on see avastatav ja käivitatav PHP-st, JavaScriptist ning REST API kaudu.

WordPress 6.9 tuleb kaasa kolme vaikimisi core ability’ga, mis sobivad hästi MCP Adapteri testimiseks:

core/get-site-info: tagastab saidi info; vaikimisi kõik väljad, soovi korral filtreeritud alamhulk
core/get-user-info: tagastab sisselogitud kasutaja põhiprofiili andmed (personaliseerimine, audit, access-aware käitumine)
core/get-environment-info: runtime kontekst diagnostikaks ja ühilduvuseks (keskkond, PHP runtime, andmebaasi serveri info, WordPressi versioon)

Mis asi on WordPress MCP Adapter?

WordPress MCP Adapter kohandab Abilities API abil registreeritud abilised MCP primitiivideks (MCP „primitives“). Tulemuseks on see, et AI agent saab:

avastada saidi võimekusi MCP tools’idena
käivitada neid tööriistu (st execute ability)
lugeda WordPressi andmeid MCP resources’itena, kui sa konfigureerid read-only ability sobivaks passiivseks kontekstiks

MCP: tools, resources, prompts lühidalt arendaja keeles

MCP jagab integratsioonipinnad kolmeks:

Tools – käivitatavad funktsioonid, mida AI kutsub tegevuse tegemiseks.
Resources – passiivsed andmeallikad (nt failid, andmebaasiread), mida AI loeb kontekstiks.
Prompts – ette seadistatud mallid/šabloonid kindlate töövoogude juhtimiseks.

MCP Adapteri puhul avaldatakse Abilities enamasti tools’idena, sest need on tegevused (too andmed, uuenda postitus, tee diagnostika). Kui ability on puhtalt read-only ja toimib pigem kontekstina (nt staatiline konfiguratsioon või debug logi), saab seda seadistada ka resource’iks, et AI saaks infot „taustaks“ sisse lugeda ilma eraldi tool call’ita.

MCP Adapteri paigaldamine (pluginana) ja mis sealt kohe kaasa tuleb

Kiireim start on installida MCP Adapter WordPressi pluginana GitHubi releases’ist: https://github.com/WordPress/mcp-adapter/releases

Aktiveerimisel registreeritakse vaikimisi MCP server nimega mcp-adapter-default-server ning kolm adapteri enda ability’t:

mcp-adapter/discover-abilities
mcp-adapter/get-ability-info
mcp-adapter/execute-ability

Need kolm avaldatakse automaatselt ka MCP tool’ideks:

mcp-adapter-discover-abilities
mcp-adapter-get-ability-info
mcp-adapter-execute-ability

Need tööriistad annavad AI agendile kihilise ligipääsu: esmalt avastab (discover), siis küsib detaili (get info) ja lõpuks käivitab (execute) konkreetse ability.

Kuidas teha ability’d vaikimisi MCP serveris kasutatavaks (meta.mcp.public)

Vaikimisi on MCP Adapteri default serveris abilised saadaval ainult siis, kui sa märgid need MCP jaoks avalikuks. Selleks lisa ability registreerimise argumentidesse 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
    ),
),

Core ability’de puhul (need kolm WordPress 6.9 default ability’t) saad kasutada filtrit wp_register_ability_args, et nende registreerimisargumendid jooksvalt täiendada meta.mcp.public lipuga:

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

Kui see on paigas, saad AI klienti kaudu default serveri tööriistadega core ability’sid käivitada.

AI rakenduste ühendamine: STDIO vs HTTP transpordikiht

MCP kliendi ja WordPressi (MCP serveri) vahel kasutatakse MCP transpordikihis kaht varianti:

STDIO – sobib eriti hästi lokaalseks arenduseks; WordPressi poolel käivitatakse server WP-CLI kaudu.
HTTP – sobib avalikult ligipääsetavale WordPressi installile või olukorda, kus STDIO pole mugav; kasutatakse Node.js põhist remote proxy’t.

STDIO: lokaalne arendus WP-CLI kaudu

STDIO ühenduse jaoks on vaja, et sul oleks lokaalselt olemas WP-CLI. Minimaalne konfiguratsioon MCP kliendile näeb välja nii:

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

Olulised detailid:

serveri nimi (wordpress-mcp-server) võib olla ükskõik mis; see on kliendi konfiguratsiooni silt
command on wp (WP-CLI)
--path peab viitama sinu WordPressi installile
mcp-adapter serve käivitab MCP serveri
--server valib MCP serveri (siin default server)
--user määrab, millise WordPressi kasutajana AI klient autentib (näites admin)

HTTP: avalik install või remote proxy Node.js abil

HTTP transpordi jaoks kasutatakse @automattic/mcp-wordpress-remote paketti: https://www.npmjs.com/package/@automattic/mcp-wordpress-remote. Vajad Node.js-i: https://nodejs.org/en

Autentimiseks saad kasutada WordPress application passwords’i (või teha oma OAuth lahenduse). Minimaalne konfiguratsioon:

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

Siin:

npx käivitab Node.js paketi
-y nõustub automaatselt paketi installiga
WP_API_URL peab viitama WordPressi MCP endpointile (/wp-json/mcp/<server>)
WP_API_USERNAME ja WP_API_PASSWORD on kasutaja ja tema application password

Kui ühendad lokaalse installi HTTP remote proxy kaudu ja midagi ei tööta, on abiks mcp-wordpress-remote troubleshooting juhised: https://github.com/Automattic/mcp-wordpress-remote/blob/trunk/Docs/troubleshooting.md. Tüüpilised komistuskivid on mitu Node.js versiooni või lokaalsed SSL sertifikaadid.

Konfiguratsioonid populaarsetes AI klientides (Claude Desktop, Cursor, Claude Code, VS Code)

Claude Desktop

Claude Desktopis lisad MCP serverid Developer vahelehe alt (Claude → Settings → Developer). Sealt „Local MCP servers“ all vali Edit config – see avab claude_desktop_config.json faili, kuhu lisad konfiguratsiooni mcpServers objekti sisse.

{
  "mcpServers": {
  }
}

{
  "mcpServers": {
  }
}

STDIO näide:

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

HTTP näide:

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

Pärast faili salvestamist tuleb Claude Desktop taaskäivitada, sest ta loeb MCP serverite konfiguratsiooni ainult käivitumisel. Kui kõik on korras, näed Developer vaates oma serveri kõrval staatust running.

Claude Desktopis lisatud WordPress MCP server Local MCP servers nimekirjas — *Forrás: developer.wordpress.org*

Cursor

Cursoris mine Cursor → Settings → Cursor Settings ja vali sektsioon Tools and MCP. Sealt Add Custom MCP avab mcp.json faili. Konfiguratsiooniformaat on sama mis Claude Desktopis.

Pärast konfiguratsiooni lisamist salvesta ja naase Tools and MCP vaatesse – seal kuvatakse server ning saad selle oma sessioonides kasutamiseks sisse lülitada.

Claude Code

Claude Code puhul saad MCP serverid lisada kas kodukataloogi .claude.json faili (globaalne) või projekti kausta .mcp.json faili (projekti-põhine). Projekti-põhine variant on mugav, kui eri projektidel on eri MCP serverid. Formaat on sama mis Cursoris ja Claude Desktopis.

VS Code

VS Code puhul käib seadistamine JSON faili kaudu, mis kirjeldab MCP serveri detaile: https://code.visualstudio.com/docs/copilot/customization/mcp-servers. Tavaliselt on failinimi mcp.json ja see asub projekti tööruumi .vscode kataloogis.

Peamine erinevus: VS Code kasutab objekti nimega servers, mitte mcpServers.

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

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

Kui fail on loodud, kuvab VS Code MCP juhtimistööriistariba (start/stop/restart). Kui server käivitub korrektselt, näitab VS Code ka mitu tool’i on AI jaoks saadaval (näites 3).

VS Code mcp.json konfiguratsioon WordPress MCP serveriga ja MCP tööriistariba — *Forrás: developer.wordpress.org*

Kuidas MCP tööriistu päriselt kasutatakse (näide töövoost)

Kui MCP server on AI rakendusega ühendatud, saad kasutada MCP Adapteri poolt avaldatud tööriistu. Näiteks Claude Desktopis võid küsida: „Get the site info from my WordPress site“.

Claude Desktopi päring, mis kasutab WordPress MCP serverit saidi info toomiseks — *Forrás: developer.wordpress.org*

Tüüpiline agenti otsustusloogika on järgmine: ta kutsub mcp-adapter-discover-abilities, et näha millised abilities on saadaval, leiab et core/get-site-info sobib, ja kutsub mcp-adapter-execute-ability, edastades ability nime. Vastuseks tuleb saidi info ning AI klient vormistab selle inimesele loetavaks vastuseks.

Kui default serverist ei piisa: kohandatud MCP server pluginasse (Composeriga)

Default server katab paljud vajadused, kuid pluginapõhiselt võib olla mõistlik teha oma MCP server: saad täpsemalt kontrollida, millised abilities on tööriistadena väljas, milline transport on lubatud ja kuidas vead/telemeetria käituvad.

Selleks paigalda MCP Adapter Composeriga oma plugina kaustast:

composer require wordpress/mcp-adapter

composer require wordpress/mcp-adapter

Seejärel lae Composer autoloader oma plugina põhifailis:

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

Kui on tõenäoline, et saidil mitu pluginat sõltuvad MCP Adapterist või Abilities API-st, soovitatakse versioonikonfliktide vältimiseks kasutada Jetpack Autoloaderit: https://github.com/WordPress/mcp-adapter/blob/trunk/docs/getting-started/installation.md#using-jetpack-autoloader-highly-recommended

Järgmisena initsialiseeri 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();

Kohandatud MCP serveri lood hook’i mcp_adapter_init kaudu. Callback saab McpAdapter instantsi ning server defineeritakse create_server() meetodiga:

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

Parameetrite mõttes tasub tähele panna:

1. parameeter: unikaalne serveri identifikaator (kasutatakse WP-CLI kaudu käivitamisel)
2. ja 3. parameeter: REST API namespace ja route
4. ja 5. parameeter: serveri nimi ja kirjeldus (AI rakendused näitavad neid serverite nimekirjas)
6. parameeter: serveri versioon
10. parameeter: ability nimede massiiv, mida tahad MCP tool’idena välja anda (võib olla mitu)
ülejäänu: transpordid, error handler ja observability handler; vajadusel saad teha ka oma handlerid oma transpordi/logimise/monitooringu jaoks

Näide: „List All URLs“ plugin ja eraldi MCP server

Hea praktiline näide on List All URLs plugin: https://github.com/wptrainingteam/list-all-urls. Eeldus: kui sul MCP Adapter plugin on aktiveeritud, siis selle näite jaoks deaktiveeri see (et näha pluginapõhist serveri seadistust selgemalt).

Klooni repo WordPressi pluginakausta:

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

Lülitu branch’i peale, kus Abilities API on juba integreeritud:

cd list-all-urls
git checkout abilities

cd list-all-urls
git checkout abilities

Kuna plugin kasutab Composerit, paigalda sõltuvused:

composer install

composer install

Lisa MCP Adapter sõltuvus:

composer require wordpress/mcp-adapter

composer require wordpress/mcp-adapter

Seejärel ava list-all-urls.php ja lisa faili lõppu kood, mis initsialiseerib adapteri ning loob kohandatud serveri, mis avaldab ainult list-all-urls/urls ability MCP tool’ina:

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

Oluline nüanss: list-all-urls/urls ability puhul ei pea sa lisama meta.mcp.public lippu, sest sa avaldad selle eksplitsiitselt oma kohandatud MCP serveri kaudu.

Aktiveeri plugin WordPressi administ ja uuenda seejärel oma AI rakenduse MCP konfiguratsiooni, et lisada uus server. Näiteks VS Code puhul võib mcp.json sisaldada korraga nii default serverit kui List All URLs serverit; mõlemad STDIO transpordiga:

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

Ühes AI rakenduses võib olla korraga mitu MCP serverit. See on kasulik, kui tahad vahetada eri WordPressi saitide vahel või kui eri pluginad avaldavad eri abilities komplekte.

Pärast konfiguratsiooni muutmist taaskäivita AI rakendus või käivita server selle UI-st (olenevalt kliendist). Seejärel saad küsida AI-lt näiteks „List all URLs on my WordPress site“ ning ta kutsub MCP Adapteri kaudu tööriista list-all-urls-urls.

Turvalisus ja parimad praktikad

MCP kliendid käituvad WordPressi vaates nagu sisselogitud kasutajad. Seega käsitle neid sama tõsiselt nagu iga muud integratsiooni või admin-taseme automatiseerimist.

Kasuta permission_callback’i läbimõeldult – iga ability peaks kontrollima minimaalset vajalikku capability’t (manage_options, edit_posts jne). Väldi __return_true eriti destruktiivsete tegevuste puhul (nt sisu kustutamine).
Kasuta MCP ligipääsuks eraldi kasutajat – eriti produktsioonis loo spetsiaalne roll/kasutaja piiratud õigustega. Ära ava võimsaid abilities’eid auditimata AI klientidele.
Eelista read-only abilities’eid avalike HTTP endpointide korral – internetti avatud HTTP transpordi puhul hoia fookus diagnostikal, raportitel ja sisu lugemisel.
Kui vaja, tee kohandatud autentimine – vaikimisi kasutatakse application passwords’i, kuid parema turvalisuse jaoks saad rakendada OAuth’i või muud meetodid.
Monitoori ja logi kasutust – kasuta kohandatud error/observability handler’eid, et siduda see oma logimise ja monitooringu stack’iga.

Minimaalne „hello AI“ rada WordPressi arendajale

Kui tahad kiiresti MCP Adapterit proovida, on kõige väiksem toimiv komplekt:

registreeri vähemalt üks ability (või tee core ability’d MCP jaoks avalikuks)
lisa MCP Adapter (pluginana või Composeriga) ja initsialiseeri see
ühenda MCP-toega AI klient (Claude Desktop, Cursor, VS Code või Claude Code) kas STDIO või HTTP transpordiga

Kui sul on juba pluginad, mis kasutavad Abilities API-t, muudab MCP Adapter need sisuliselt AI-valmis API-deks üsna väikese lisatööga. Alusta väikestest, mittedesktruktiivsetest read-only tööriistadest, testi lokaalselt ja laienda alles siis keerukamateks töövoogudeks, kui kontroll ja turvamudel on selge.

Dokumentatsioon ja lähtekohad:

Abilities API: https://developer.wordpress.org/apis/abilities/
MCP Adapter repo: https://github.com/WordPress/mcp-adapter

Märkus WordPress.com vs self-hosted autentimisest (praktikaline vahe)

Praegu on peamine praktiline erinevus connectori-laadsete lahenduste ja self-hosted MCP kasutuse vahel autentimine: WordPress.com kasutab OAuth 2.1 lähenemist (vt: https://wordpress.com/blog/2026/01/22/connect-ai-agents-to-wordpress-oauth-2-1/), samas self-hosted WordPressis ei ole samaväärset „valmis“ OAuth lahendust; seetõttu kasutatakse tihti JWT tokeneid või application passwords’i. Samal ajal on WordPress.com MCP tööriistade poolel loogika samal vundamendil – Abilities API ja MCP Adapter – mis tähendab, et „registreeri ability üks kord“ lähenemine on kontseptuaalselt kooskõlas mõlema maailma vahel.