WordPress MCP Adapter: jak napojit Abilities API na AI klienty přes Model Context Protocol

WordPress se poslední měsíce docela rychle posouvá směrem k automatizaci a AI workflow. Klíčovou změnou je Abilities API (představené ve WordPressu 6.9), které dává vývojářům jednotný způsob, jak „zaregistrovat, popsat a spustit“ konkrétní funkcionalitu – typovaně, objevitelné a napříč kontexty (PHP, JavaScript i REST API). Na to teď navazuje WordPress MCP Adapter, který tyto abilities zpřístupní AI klientům přes Model Context Protocol (MCP).

V tomhle článku projdeme kompletní praktickou cestu: instalaci MCP Adapteru, zpřístupnění abilities pro výchozí MCP server, konfiguraci připojení v Claude Desktop, Cursor, Claude Code a VS Code (včetně STDIO a HTTP transportu), použití MCP tools a také vytvoření vlastního MCP serveru přímo v pluginu. Na konci přidám bezpečnostní checklist, protože MCP klient je v praxi „přihlášený uživatel“ ve WordPressu.

Rychlé opakování: proč jsou Abilities základ

Abilities API přináší do WordPressu funkční API první třídy: místo ad‑hoc REST endpointů, custom admin-ajax akcí nebo různých interních helperů můžeš jednu schopnost (ability) definovat jednou a konzistentně ji nabídnout dalším částem systému.

Ability se definuje pomocí několika pevných prvků:

Unikátní název ve formátu namespace/ability-name.
Typované schéma vstupu (input schema) a výstupu (output schema).
permission_callback, který vynucuje oprávnění (capabilities).
execute_callback, který provede samotnou práci.

To, co se spouští v execute_callback, může být prakticky cokoliv: načtení dat, úprava příspěvků, diagnostika, reporty – zkrátka jedna jasně vymezená jednotka práce.

Jakmile je ability zaregistrovaná, je objevitelné a spustitelné z PHP, JavaScriptu i přes REST API.

Výchozí abilities ve WordPressu 6.9

WordPress 6.9 obsahuje tři defaultní core abilities. Nejsou jich desítky, ale na testování MCP Adapteru bohatě stačí:

core/get-site-info: vrací informace o webu nastavené ve WordPressu. Defaultně všechny fieldy, případně jen vybraný subset.
core/get-user-info: vrací základní profilové informace o aktuálně autentizovaném uživateli – pro personalizaci, audit i chování závislé na přístupu.
core/get-environment-info: vrací informace o runtime prostředí pro diagnostiku a kompatibilitu (prostředí, PHP runtime, DB server, verze WordPressu).

Co je WordPress MCP Adapter a k čemu je dobrý

WordPress MCP Adapter je oficiální balíček v iniciativě AI Building Blocks for WordPress. Jeho úkolem je „přeložit“ abilities registrované přes Abilities API do primitiv, která chápe Model Context Protocol (MCP) – a tím zpřístupnit funkce webu AI agentům jako MCP tools a data jako MCP resources.

Praktický dopad je jednoduchý: pokud už dnes v pluginu registruješ abilities, jsi velmi blízko tomu, aby je AI klient uměl objevit a zavolat.

Základní pojmy MCP: tools, resources, prompts

MCP organizuje interakce do tří „primitiv“:

Tools: spustitelné funkce, které AI volá, když má něco udělat (akce).
Resources: pasivní zdroje dat, které si AI jen čte jako kontext (soubory, řádky v DB, exporty apod.).
Prompts: předpřipravené šablony, které vedou konkrétní workflow.

V kontextu MCP Adapteru se abilities typicky mapují na tools, protože reprezentují spustitelnou logiku (načti, spočítej, aktualizuj, diagnostikuj). Adapter je ale flexibilní: pokud je ability čistě read‑only a vrací jen data (např. statická konfigurace, debug log), dá se nakonfigurovat i jako resource, aby si AI mohla data „nasát“ jako background kontext bez aktivního volání.

Instalace MCP Adapteru jako plugin (nejrychlejší start)

Nejrychlejší cesta je stáhnout a nainstalovat MCP Adapter jako plugin přímo z GitHub Releases: https://github.com/WordPress/mcp-adapter/releases. Po aktivaci plugin automaticky zaregistruje výchozí MCP server s názvem mcp-adapter-default-server a přidá tři vlastní abilities:

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

Tyto abilities se zároveň automaticky vystaví jako MCP tools:

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

Dohromady dávají AI agentům „vrstvený“ přístup k abilities: nejdřív objev, co existuje, pak si vyžádej detaily a nakonec konkrétní ability spusť.

Jak zpřístupnit abilities pro výchozí MCP server

Výchozí server MCP Adapteru je záměrně konzervativní: abilities jsou přes něj dostupné jen tehdy, když je při registraci explicitně označíš jako veřejné pro MCP. Dělá se to pomocí flagu meta.mcp.public v argumentech 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
    ),
)

U core abilities (ty tři z WordPressu 6.9) je logicky nechceš přepisovat v core. Místo toho se to řeší filtrem wp_register_ability_args, kde upravíš registrační argumenty a doplníš meta.mcp.public jen pro vybrané ability:

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

Jakmile tohle zapneš, můžeš začít připojovat AI klienty a volat core abilities přes MCP tools výchozího serveru.

Připojení AI aplikací: STDIO vs HTTP transport

MCP podporuje dvě transportní vrstvy: STDIO a HTTP. Volba se typicky odvíjí od toho, kde WordPress běží a jak se k němu chceš připojit.

STDIO: ideální pro lokální vývoj

Pro lokální WordPress prostředí (Studio, Docker, Lando, LocalWP…) je nejpřímočařejší STDIO. MCP Adapter to řeší přes WP-CLI, takže potřebuješ mít WP-CLI nainstalované lokálně.

Minimum konfigurace pro připojení vypadá takhle:

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

Co je důležité:

Název serveru (wordpress-mcp-server) je jen lokální label – může být libovolný.
command je wp (WP-CLI).
--path ukazuje na instalaci WordPressu.
mcp-adapter serve spouští MCP server.
--server vybírá konkrétní MCP server (tady default).
--user určuje, jako který WordPress uživatel se klient autentizuje (typicky admin v devu).

HTTP: pro veřejně dostupné instalace (a když nechceš STDIO)

Pro veřejně dostupné weby, případně když nechceš STDIO, se používá HTTP. Praktická cesta je remote proxy balíček @automattic/mcp-wordpress-remote. Ten vyžaduje mít na stroji Node.js a vyřešenou autentizaci – buď přes WordPress application passwords, nebo vlastní OAuth.

Minimum konfigurace pro HTTP transport:

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

Poznámky ke konfiguraci:

command je npx, který spustí Node.js balíček.
-y automaticky odsouhlasí instalaci balíčku.
WP_API_URL míří na MCP endpoint ve WordPressu.
WP_API_USERNAME a WP_API_PASSWORD jsou přihlašovací údaje (u password jde o application password).

Lokální HTTP a typické potíže

Při lokálním připojení přes remote proxy se občas řeší konflikty více verzí Node.js nebo lokální SSL certifikáty. Balíček má troubleshooting: https://github.com/Automattic/mcp-wordpress-remote/blob/trunk/Docs/troubleshooting.md

Konfigurace pro konkrétní aplikace (Claude Desktop, Cursor, Claude Code, VS Code)

Konfigurační formát je v zásadě stejný, liší se jen místo, kam ho uložíš, a u VS Code i název root objektu.

Claude Desktop

V Claude Desktop přejdi do Developer sekce (Claude → Settings → Developer). V části Local MCP servers klikni na Edit config – otevře se claude_desktop_config.json.

MCP servery se definují do objektu mcpServers:

{
  "mcpServers": {
  }
}

{
  "mcpServers": {
  }
}

Příklad pro STDIO transport:

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

Příklad pro HTTP transport:

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

Po uložení konfigurace je nutné Claude Desktop restartovat – konfigurace MCP serverů se načítá jen při startu. V Developer záložce pak uvidíš server v seznamu Local MCP servers; pokud je u něj status running, můžeš ho používat.

Cursor

V Cursor otevři Settings (Cursor → Settings → Cursor Settings) a sekci Tools and MCP.

Klikni na Add Custom MCP – Cursor otevře konfigurační soubor mcp.json. Formát konfigurace je stejný jako u Claude Desktop. Po uložení se vrať do Tools and MCP a server by se měl objevit v seznamu, kde ho můžeš povolit pro session.

Cursor Tools and MCP s přidaným WordPress MCP serverem — *Forrás: WordPress Developer Blog*

Claude Code

U Claude Code máš dvě možnosti:

Přidat objekt mcpServers do .claude.json v home directory (globálně pro všechny projekty).
Vytvořit .mcp.json přímo v adresáři projektu (konfigurace per‑projekt).

V obou případech použiješ stejný konfigurační formát jako u Cursor nebo Claude Desktop.

VS Code

Ve VS Code je potřeba vytvořit JSON konfiguraci popisující MCP server podle dokumentace: https://code.visualstudio.com/docs/copilot/customization/mcp-servers. Typicky se soubor jmenuje mcp.json a patří do .vscode adresáře v workspace.

Rozdíl proti Claude Desktop/Cursor je, že servery se nedefinují v mcpServers, ale v objektu servers:

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

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

Po vytvoření souboru VS Code zobrazí MCP control toolbar, kde server startuješ/stopuješ/restartuješ. Když se server nastartuje správně, VS Code obvykle ukáže i počet dostupných tools.

Použití MCP tools v praxi

Jakmile je MCP server připojený, můžeš v AI aplikaci začít používat tools, které MCP Adapter vystavuje.

Typický scénář třeba v Claude Desktop: napíšeš požadavek typu „Get the site info from my WordPress site“. Claude si všimne dostupného MCP serveru a zpravidla nejdřív zavolá tool mcp-adapter-discover-abilities, aby zjistil, jaké abilities jsou k dispozici. Pak vybere vhodnou ability (např. core/get-site-info) a provede volání přes mcp-adapter-execute-ability s předaným názvem ability. Výsledkem jsou data o webu, která AI použije k odpovědi.

Vlastní MCP server přímo v pluginu (víc kontroly než default)

Defaultní MCP server pokryje hodně use‑casů, ale někdy chceš mít nad vystavením abilities jako MCP tools větší kontrolu. Typicky: plugin nabízí jen konkrétní sadu tools, nechceš řešit meta.mcp.public, nebo chceš vlastní chování kolem transportu/logování/observability.

V takovém případě MCP Adapter nepřidáváš jako plugin, ale jako Composer závislost v pluginu a vytvoříš si vlastní MCP server.

1) Instalace balíčku přes Composer

V adresáři pluginu spusť:

composer require wordpress/mcp-adapter

composer require wordpress/mcp-adapter

2) Načtení Composer autoloaderu

V hlavním souboru pluginu načti vendor/autoload.php:

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

Pozor na konflikty verzí závislostí

Pokud na webu může být víc pluginů závislých na MCP Adapteru nebo Abilities API, doporučuje se Jetpack Autoloader, aby se předešlo konfliktům verzí: https://github.com/WordPress/mcp-adapter/blob/trunk/docs/getting-started/installation.md#using-jetpack-autoloader-highly-recommended

3) Inicializace MCP Adapteru

Nejdřív ověř, že je třída k dispozici, a pak inicializuj adapter (spolu s default serverem):

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) Vytvoření a registrace vlastního MCP serveru

Vlastní server vytvoříš hookem na akci mcp_adapter_init. Callback dostane instanci McpAdapter a přes create_server() nadefinuješ server včetně toho, jaké abilities se mají vystavit jako tools (a případně resources a prompts):

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

Parametry, které se v praxi řeší nejčastěji:

1. parametr: unikátní identifikátor serveru (použije se třeba při startu přes WP-CLI).
2. + 3. parametr: REST API namespace a route pro MCP server.
4. + 5. parametr: název a popis serveru (uvidíš v AI aplikaci při výpisu serverů).
6. parametr: verze serveru.
10. parametr: pole názvů abilities, které chceš vystavit jako MCP tools (může jich být víc).
Zbytek: transportní metody, error handling a observability handlery – můžeš použít ty z balíčku, nebo napsat vlastní napojení na interní logging/monitoring.

Ukázka: přidání vlastního MCP serveru do pluginu List All URLs

Aby bylo vidět, jak to vypadá na reálném pluginu, vezměme plugin List All URLs: https://github.com/wptrainingteam/list-all-urls. Nejprve je potřeba deaktivovat MCP Adapter plugin, pokud ho máš zapnutý (v téhle ukázce pojedeme čistě composerově z pluginu).

1) Naklonování repozitáře a přepnutí na větev s Abilities

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

2) Instalace závislostí a přidání mcp-adapter

Plugin už používá Composer, takže nejdřív:

composer install

composer install

A pak přidej MCP Adapter:

composer require wordpress/mcp-adapter

composer require wordpress/mcp-adapter

3) Inicializace MCP Adapteru a vytvoření custom serveru v list-all-urls.php

Otevři list-all-urls.php a na konec souboru přidej následující kód:

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

Tady je důležitá praktická drobnost: pro list-all-urls/urls nemusíš nastavovat meta.mcp.public, protože tu ability explicitně vystavuješ přes vlastní MCP server.

Teď plugin aktivuj ve WordPress administraci.

4) Konfigurace AI aplikace pro nový server (příklad pro VS Code)

V AI klientovi jen přidáš další server do konfigurace. Tady je příklad mcp.json pro VS Code se dvěma servery (default + custom z List All URLs), oba přes 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"
      ]
    }
  }
}

V jedné aplikaci můžeš mít nakonfigurovaných více MCP serverů – a přepínat mezi různými weby nebo pluginy, které vystavují různé sady abilities.

Po změně konfigurace nezapomeň aplikaci restartovat, nebo MCP server znovu nastartovat přímo v UI (podle toho, jak se daný klient chová). Pak už můžeš AI zadat třeba „List all URLs on my WordPress site“ a klient zavolá tool list-all-urls-urls přes MCP Adapter.

Bezpečnost a best practices (tohle nepřeskakuj)

MCP klienti se vůči WordPressu chovají jako přihlášení uživatelé. Ber je proto jako součást aplikačního povrchu a drž se těchto pravidel:

Používej permission_callback opravdu pečlivě. Každá ability má kontrolovat minimální potřebnou capability (manage_options, edit_posts atd.).
Vyhni se __return_true u destruktivních operací. Mazání obsahu, změny nastavení a podobně musí mít striktní autorizaci.
Pro MCP přístup používej dedikované uživatele. Zejména v produkci je lepší separátní user/role s omezenými capabilities.
Nevystavuj „silné“ abilities neauditovaným AI klientům. I když je to jen „pomocník“, pořád může dělat věci za uživatele.
Pro veřejné HTTP endpointy preferuj read‑only abilities. Diagnostika, reporting, přístup k obsahu – a nic, co přepisuje data, dokud nemáš vyřešené bezpečnostní procesy.
Když je potřeba, implementuj vlastní autentizaci. Default je postavený na application passwords, ale můžeš jít cestou OAuth nebo jiných metod.
Monitoruj a loguj použití. Přes vlastní error/observability handlery se dá napojit na logging/monitoring stack.

Jak začít experimentovat ještě dnes (minimální „hello AI“ cesta)

Na první funkční pokus vývojáři ve WordPressu stačí:

Zaregistrovat vlastní ability (Abilities API).
Přidat MCP Adapter (pluginem nebo přes Composer) a inicializovat ho.
Připojit MCP‑aware AI klienta (Claude Desktop, Cursor, VS Code, Claude Code) přes STDIO nebo HTTP.
Začít s pár read‑only abilities jako MCP tools a postupně rozšiřovat podle toho, jak roste důvěra a zkušenost.

Pokud už máš pluginy postavené na Abilities API, MCP Adapter z nich udělá AI‑ready API s minimální dodatečnou prací. Pro další studium se hodí dokumentace Abilities API: https://developer.wordpress.org/apis/abilities/ a repozitář MCP Adapteru: https://github.com/WordPress/mcp-adapter.