WordPress MCP Adapter: kaip „Abilities“ paverčia tavo įskiepio funkcijas AI agentų įrankiais

WordPress jau kurį laiką juda link aiškesnio, „mašinomis skaitomo“ funkcionalumo aprašymo: ne tik REST endpoint’ų ar PHP funkcijų dokumentacijos, bet standartizuoto mechanizmo, kuriuo galima atrasti, patikrinti tipus ir vykdyti konkrečius veiksmus. WordPress 6.9 atsiradusi Abilities API tam yra kertinis akmuo. O dabar šalia jos atsirado dar viena detalė, kuri AI automatizavimą paverčia praktišku kasdieniu įrankiu: WordPress MCP Adapter.

MCP Adapteris į WordPress atneša Model Context Protocol (MCP) – protokolą, kuriuo AI įrankiai gali gauti papildomo konteksto ir, svarbiausia, saugiai kviesti „įrankius“ (tools), skaityti „resursus“ (resources) ir naudoti „prompt’us“ (prompts). Jei tavo įskiepis jau registruoja Abilities, iki AI agentų integracijos lieka vienas žingsnis.

Greitas kontekstas: kas yra Abilities API ir kodėl ji svarbi MCP

Abilities API suteikia WordPress pirmos klasės, „cross-context“ funkcinį API, kuris suvienodina, kaip branduolys (core) ir įskiepiai deklaruoja, ką jie moka daryti. Vieną kartą apibrėži veiksmą (ability) – ir jis tampa atrandamas bei vykdomas iš PHP, JavaScript ir per REST API.

Ability apibrėžimas remiasi keturiais principais:

Unikalus pavadinimas (formatas namespace/ability-name)
Tipizuota įvesties schema (input schema) ir išvesties schema (output schema)
permission_callback, kuris tikrina teises (capabilities)
execute_callback, kuris realiai atlieka veiksmą (pvz., duomenų gavimas, įrašų atnaujinimas, diagnostika ir pan.)

WordPress 6.9 kartu atsineša ir 3 numatytas (core) abilities, kurios labai patogios testams su MCP:

core/get-site-info – grąžina WordPress konfigūruotą svetainės informaciją (pagal nutylėjimą visus laukus, arba pasirinktą jų dalį).
core/get-user-info – grąžina bazinius šiuo metu autentifikuoto vartotojo profilio duomenis (personalizacijai, auditui, „access-aware“ elgsenai).
core/get-environment-info – grąžina pagrindinius vykdymo aplinkos duomenis diagnostikai ir suderinamumui (aplinka, PHP runtime, DB serverio info, WordPress versija).

Kas yra WordPress MCP Adapter ir ką jis realiai daro

WordPress MCP Adapter yra oficialus paketas iniciatyvoje AI Building Blocks for WordPress. Jo paskirtis – paimti Abilities API užregistruotas abilities ir „pritaikyti“ jas MCP architektūros primityvams (primitives), kad AI agentai galėtų:

atrasti ir vykdyti svetainės funkcionalumą kaip MCP tools (įrankius),
skaityti WordPress duomenis kaip MCP resources (resursus).

Praktiškai tai reiškia: jei tavo kode jau yra abilities – tu jau beveik turi AI agentams tinkamą API.

MCP pagrindai: tools, resources ir prompts

MCP sąveiką organizuoja į tris pagrindinius „primitives“:

Tools – vykdomos funkcijos, kurias AI kviečia veiksmams atlikti.
Resources – pasyvūs duomenų šaltiniai (pvz., failai ar DB įrašai), kuriuos AI skaito kontekstui.
Prompts – iš anksto paruošti šablonai, padedantys valdyti konkrečius darbo srautus.

Su MCP Adapteriu abilities dažniausiai tampa tools, nes jos aprašo vykdomą logiką (gauti duomenis, atnaujinti įrašus, paleisti diagnostiką). Bet jei ability yra tik „read-only“ ir tiesiog pateikia konfigūraciją ar log’ą, ją galima sukonfigūruoti ir kaip resource, kad AI ją įsisavintų kaip foninį kontekstą, nekviesdamas aktyvaus veiksmo.

MCP Adapter diegimas kaip įskiepis (greičiausias kelias)

Greitam startui MCP Adapterį patogiausia įsidiegti kaip įskiepį iš GitHub „Releases“ puslapio: https://github.com/WordPress/mcp-adapter/releases. Įdiegus ir aktyvavus, jis automatiškai užregistruoja numatytą MCP serverį mcp-adapter-default-server ir tris abilities:

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

Šios abilities automatiškai išeksponuojamos ir kaip MCP tools:

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

Šie trys tools sudaro sluoksniuotą (layered) prieigą: AI agentas pirmiausia atranda abilities, tada pasižiūri jų informaciją, ir galiausiai vykdo pasirinktą ability.

Kaip įjungti abilities prieigą numatytam MCP serveriui (meta.mcp.public)

Svarbus niuansas: pagal nutylėjimą abilities per numatytą mcp-adapter-default-server pasiekiamos tik tada, kai jas aiškiai pažymi kaip viešas MCP prieigai. Tai daroma ability registracijoje pridedant meta.mcp.public vėliavėlę, kai kvieti 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
    ),
)

Jei nori testuoti su core abilities, jų tiesiogiai nekeisi, bet gali pasinaudoti filtru wp_register_ability_args ir papildyti registracijos argumentus.

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

Po šito jau gali jungti AI klientus prie WordPress per MCP Adapterį ir kviesti core abilities per numatytus MCP tools.

AI programų prijungimas prie WordPress MCP serverio

Transportai: STDIO vs HTTP

MCP ryšiui yra du transporto mechanizmai: STDIO ir HTTP. Kurį rinktis, dažniausiai lemia WordPress instaliacijos vieta.

Lokaliam development’ui paprasčiausia naudoti STDIO. MCP Adapteris tai įgalina per WP-CLI, todėl lokaliai turi būti įdiegtas WP-CLI: https://wp-cli.org/.
Viešai pasiekiamoms instaliacijoms (arba kai nenori STDIO) tinka HTTP per nuotolinį proxy paketą @automattic/mcp-wordpress-remote. Tam reikės Node.js: https://nodejs.org/en ir autentifikacijos per WordPress application passwords arba savo OAuth realizacijos.

STDIO minimalus konfigas (per WP-CLI)

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

Čia:

serverio vardas yra wordpress-mcp-server (gali būti bet koks tavo pasirinktas pavadinimas),
komanda wp – tai WP-CLI,
--path – kelias į WordPress instaliaciją,
mcp-adapter serve – paleidžia MCP Adapter serverį,
--server – nurodo, kurį MCP serverį naudoti (čia numatytą),
--user – WordPress vartotojas, kaip bus autentifikuojamasi (dažnai admin testams).

HTTP minimalus konfigas (per @automattic/mcp-wordpress-remote)

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

Čia:

npx vykdo Node.js paketus,
-y automatiškai sutinka su įdiegimu,
@automattic/mcp-wordpress-remote@latest – naudoja naujausią remote proxy versiją: https://www.npmjs.com/package/@automattic/mcp-wordpress-remote
WP_API_URL turi rodyti į tavo svetainės MCP endpoint’ą (/wp-json/mcp/...),
WP_API_USERNAME – vartotojas,
WP_API_PASSWORD – to vartotojo application password.

Jei HTTP jungiantis lokaliai kyla bėdų

mcp-wordpress-remote turi troubleshooting pastabų, kurios dažniausiai susijusios su keliomis Node.js versijomis arba lokaliais SSL sertifikatais: https://github.com/Automattic/mcp-wordpress-remote/blob/trunk/Docs/troubleshooting.md

Konfigūracija pagal AI klientą (Claude Desktop, Cursor, Claude Code, VS Code)

Toliau – kur konkrečiai susidėti MCP serverio konfigą populiariausiuose įrankiuose.

Claude Desktop

Claude Desktop turi įmontuotą MCP serverių palaikymą. Eik į Developer skiltį (Claude → Settings → Developer), skiltyje Local MCP servers spausk Edit config – atsidarys claude_desktop_config.json, kuriame MCP serveriai aprašomi mcpServers objekte.

{
  "mcpServers": {
  }
}

{
  "mcpServers": {
  }
}

STDIO pavyzdys:

{
  "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 pavyzdys:

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

Išsaugojus failą Claude Desktop būtina perkrauti, nes MCP serverių konfigūraciją jis perskaito tik starto metu. Tada Developer skiltyje turėtum matyti serverį, o šalia jo būseną running.

Cursor

Cursor nustatymuose eik į Cursor → Settings → Cursor Settings ir pasirink Tools and MCP. Spausk Add Custom MCP – tai atidarys mcp.json konfigūraciją. Formatą gali naudoti tokį pat kaip Claude Desktop (mcpServers). Išsaugai, grįžti į Tools and MCP ir įjungi serverį savo sesijoms.

Cursor Tools and MCP panelė su pridėtu WordPress MCP Server įrašu — . — *Forrás: developer.wordpress.org*

Claude Code

Claude Code MCP serverius gali aprašyti dviem būdais:

įdėti mcpServers su serverių konfigais į ~/.claude.json (globaliai visiems projektams),
arba susikurti .mcp.json projekto direktorijoje (skirtingi serveriai skirtingiems projektams).

Abiem atvejais konfigūracijos formatas toks pats kaip Cursor ar Claude Desktop.

VS Code

VS Code pusėje MCP serveriai aprašomi JSON faile (dažniausiai mcp.json), kuris laikomas projekto workspace’e kataloge .vscode. Skirtumas nuo Claude/Cursor: čia serverius rašai ne į mcpServers, o į servers objektą. Visa kita (command/args/env) – tas pats.

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

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

Kai failas sukurtas, VS Code parodo MCP valdymo juostą (start/stop/restart). Sėkmingai paleidus, jis taip pat rodo, kiek tools yra prieinama AI (pvz., 3). Daugiau apie VS Code MCP serverių aprašymą: https://code.visualstudio.com/docs/copilot/customization/mcp-servers

Kaip atrodo MCP tools naudojimas praktikoje

Kai AI aplikacija prijungta prie tavo MCP serverio, gali naudoti MCP Adapterio išeksponuotus tools. Pavyzdžiui, Claude Desktop pokalbyje gali paprašyti: „Get the site info from my WordPress site“.

Tipinis veikimo scenarijus toks:

AI aptinka, kad yra MCP serveris, ir kviečia mcp-adapter-discover-abilities, kad pamatytų, kas prieinama.
Tada nusprendžia, kuri ability atitinka užklausą (pvz., core/get-site-info).
Galiausiai kviečia mcp-adapter-execute-ability, perduodamas ability pavadinimą, ir iš gauto atsakymo suformuoja „žmogišką“ atsakymą.

Kai numatyto serverio neužtenka: nuosavas MCP serveris tavo įskiepiui

Numatytasis MCP serveris dažnai bus pakankamas, bet įskiepiuose kartais norisi daugiau kontrolės: tiksliai nuspręsti, kurios abilities taps tools, kokie transportai naudojami, kaip log’inamos klaidos, kaip integruojamas observability. Tam MCP Adapterį montuoji kaip priklausomybę per Composer ir susikuri nuosavą serverį.

1) Įsidiek MCP Adapter per Composer

Įskiepio kataloge:

composer require wordpress/mcp-adapter

composer require wordpress/mcp-adapter

2) Įkelk Composer autoloader

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

Jei realu, kad keli įskiepiai vienoje svetainėje naudos MCP Adapterį ar Abilities API, rekomenduojama naudoti Jetpack Autoloader, kad išvengtum versijų konfliktų: https://github.com/WordPress/mcp-adapter/blob/trunk/docs/getting-started/installation.md#using-jetpack-autoloader-highly-recommended

3) Inicializuok 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) Susikurk custom MCP serverį per mcp_adapter_init

Užkabinęs mcp_adapter_init gausi McpAdapter instanciją, ir per create_server() aprašysi serverį: identifikatorius, REST namespace/route, pavadinimas/aprašymas, versija, transportas, error/observability handleriai, ir – svarbiausia – abilities, kurias nori išeksponuoti kaip tools (ir papildomai resources/prompts, jei reikia).

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

Parametrai, į kuriuos verta atkreipti dėmesį:

1-as: unikalus serverio identifikatorius (naudojamas paleidžiant per WP-CLI).
2-as ir 3-as: REST API namespace ir route, pagal kuriuos susiformuoja endpoint’ai.
4-as ir 5-as: serverio pavadinimas ir aprašymas, kuriuos matys AI aplikacijos.
6-as: serverio versija.
10-as: abilities sąrašas, kurias eksponuoji kaip MCP tools (gali būti kelios).
Kiti: transportai, klaidų apdorojimas, observability. Gali rašytis ir savo handlerius, jei integruoji su savo log’ais/monitoringu ar alternatyviu transportu.

Praktinis pavyzdys: custom MCP serveris „List All URLs“ įskiepiui

Kad matytum pilną kelią, paimkime „List All URLs“ įskiepį (repo): https://github.com/wptrainingteam/list-all-urls ir pridėkime jam custom MCP serverį.

Išjunk MCP Adapter įskiepį (jei jis aktyvus).
WordPress wp-content/plugins viduje nusiklonuok repo.
Persijunk į branch’ą, kuriame jau yra Abilities API integracija (abilities).
Kadangi įskiepis naudoja Composer, paleisk composer install.
Tada pridėk MCP Adapter priklausomybę per Composer.
Pagrindiniame faile list-all-urls.php apačioje inicializuok MCP Adapterį ir sukurk custom serverį.

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

cd list-all-urls
git checkout abilities

cd list-all-urls
git checkout abilities

composer install

composer install

composer require wordpress/mcp-adapter

composer require wordpress/mcp-adapter

Kodą, kurį reikia pridėti į list-all-urls.php pabaigą:

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

Svarbi detalė: čia nereikia meta.mcp.public ant list-all-urls/urls ability, nes ją tiesiogiai išeksponuoji per custom serverį.

Aktyvuok „List All URLs“ įskiepį WordPress administracijoje. Tada AI aplikacijos MCP konfige pridėk naują serverį. Pavyzdžiui, VS Code mcp.json gali turėti ir numatytą, ir naują serverį – abu per 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"
      ]
    }
  }
}

Vienoje AI aplikacijoje gali laikyti kelis MCP serverius – taip lengvai persijungsi tarp skirtingų WordPress instaliacijų arba skirtingų įskiepių, kurie eksponuoja skirtingas abilities. Po konfigo atnaujinimo nepamiršk: arba perkrauk aplikaciją, arba paleisk MCP serverį per jos UI.

Po to jau gali paprašyti AI: „List all URLs on my WordPress site“ – ir jis kvies list-all-urls-urls tool per MCP Adapterį.

Saugumas ir gerosios praktikos (čia lengviausia prisidaryti bėdų)

MCP klientai WordPress akimis yra prisijungę vartotojai, todėl laikyk juos pilnaverte aplikacijos atakos plokštuma. Praktikoje tai reiškia:

Atsargiai rašyk permission_callback – kiekviena ability turi tikrinti minimaliai reikalingas teises (manage_options, edit_posts ir pan.). Venk __return_true destruktyviems veiksmams (pvz., turinio trynimui).
Naudok dedikuotus vartotojus MCP prieigai – ypač produkcijoje susikurk atskirą rolę/vartotoją su ribotomis capabilities. Neeksponuok galingų abilities neauditintiems AI klientams.
Viešiems HTTP endpoint’ams teik pirmenybę „read-only“ abilities – diagnostika, ataskaitos, turinio skaitymas, o ne rašymas/keitimas.
Jei reikia – įdiek custom autentifikaciją – numatytasis kelias remiasi application passwords, bet gali implementuoti OAuth ar kitus metodus stipresniam saugumui.
Stebėk ir log’ink naudojimą – pasitelk custom error ir observability handlerius, kad integruotum su savo logging/monitoring stack’u.

Nuo ko pradėti šiandien: minimalus „hello AI“ kelias

Minimalus kelias WordPress programuotojui yra labai tiesus: užregistruoji ability, prisijungi MCP Adapter (per įskiepį arba per Composer), inicializuoji jį ir prijungi MCP palaikantį AI klientą. Jei jau turi įskiepių, kurie naudoja Abilities API, MCP Adapteris juos praktiškai paverčia AI-ready API su labai mažu papildomu darbu.

Pradėk mažai: keli nedestruktyvūs, read-only įrankiai, testai lokaliai su Claude Desktop ar Cursor, ir tik tada plėsk į sudėtingesnius workflow. Dokumentacija, kuri dažniausiai atsako į praktinius klausimus: Abilities API – https://developer.wordpress.org/apis/abilities/, MCP Adapter repo – https://github.com/WordPress/mcp-adapter.

Pastaba apie WordPress.com ir autentifikaciją

Įdomus momentas: WordPress.com pusėje MCP įrankiai taip pat remiasi ta pačia Abilities API ir MCP Adapter koncepcija. Esminis skirtumas šiuo metu – autentifikacija: WordPress.com naudoja OAuth 2.1 (plačiau: https://wordpress.com/blog/2026/01/22/connect-ai-agents-to-wordpress-oauth-2-1/), o savarankiškai hostinamuose (self-hosted) WordPress sprendimuose dažniau tenka remtis JWT token’ais arba Application Passwords.