WordPress MCP Adapter: Abilities als Brücke zu AI Agents (MCP)

WordPress hat mit der Abilities API (seit WordPress 6.9) einen ziemlich wichtigen Grundstein gelegt: Funktionen aus Core und Plugins lassen sich als einheitliche, maschinenlesbare und ausführbare Einheiten registrieren – standardisiert, discoverable, typed und executable. Das ist nicht nur für klassische Integrationen interessant, sondern vor allem für Automatisierung durch moderne KI-Systeme.

Der nächste Baustein ist der WordPress MCP Adapter. Er verbindet Abilities mit dem Model Context Protocol (MCP), also einem Protokoll, über das KI-Clients (z. B. Claude Desktop, Claude Code, Cursor oder VS Code) Tools entdecken und ausführen können – inklusive sicherem Zugriff auf WordPress-Funktionalität und Daten.

In diesem Beitrag bekommst du eine praxisnahe Einführung: Installation, Freigabe von Abilities für den Default-Server, Anbindung gängiger KI-Clients (STDIO/HTTP), Nutzung der MCP-Tools, eigene MCP-Server pro Plugin und ein komplettes Beispiel mit „List All URLs“. Dazu kommen Security-Empfehlungen, die du ernst nehmen solltest – denn MCP-Clients agieren effektiv als eingeloggte WordPress-User.

Kurz-Recap: Warum Abilities die Basis sind

Die Abilities API gibt WordPress eine First-Class, Cross-Context Functional API: Core und Plugins können definieren, was sie können, in einer Form, die konsistent auffindbar und ausführbar ist – unabhängig davon, ob du aus PHP, JavaScript oder via REST API darauf zugreifst.

Eine Ability registrierst du einmalig mit:

einem eindeutigen Namen im Format namespace/ability-name
einem typisierten Input-Schema und Output-Schema
einer permission_callback, die Capabilities durchsetzt
einer execute_callback, die die eigentliche Arbeit erledigt

Was in execute_callback passiert, ist bewusst offen: Daten abfragen, Posts aktualisieren, Diagnosen fahren oder jede andere klar abgrenzbare Aufgabe.

WordPress 6.9 bringt aktuell drei Core-Abilities mit, die sich gut zum Testen eignen:

core/get-site-info: Liefert in WordPress konfigurierte Site-Informationen (standardmäßig alle Felder, optional gefilterte Teilmenge).
core/get-user-info: Liefert grundlegende Profilinformationen des aktuell authentifizierten Users (z. B. für Personalisierung, Auditing, access-aware Verhalten).
core/get-environment-info: Liefert Details zur Runtime-Umgebung für Diagnose/Kompatibilität (Environment, PHP-Runtime, DB-Server-Infos, WordPress-Version).

Was ist der WordPress MCP Adapter?

Der WordPress MCP Adapter ist ein offizielles Package innerhalb der Initiative AI Building Blocks for WordPress. Seine Aufgabe: Abilities, die über die Abilities API registriert sind, in die MCP-„Primitives“ zu überführen, damit AI Agents WordPress-Funktionen als MCP tools ausführen und WordPress-Daten als MCP resources lesen können.

Die praktische Konsequenz ist spannend: Wenn dein Plugin heute schon Abilities registriert, bist du sehr nah daran, diese direkt für einen AI Agent nutzbar zu machen.

MCP-Grundbegriffe: Tools, Resources und Prompts

MCP organisiert Interaktionen über drei zentrale Bausteine:

Tools: ausführbare Funktionen, die die KI aufruft, um Aktionen durchzuführen.
Resources: passive Datenquellen (z. B. Dateien, Datenbankzeilen), die die KI als Kontext lesen kann.
Prompts: vorkonfigurierte Templates, die Workflows anleiten.

Mit dem MCP Adapter werden Abilities typischerweise als Tools exposed, weil sie meist ausführbare Logik darstellen (Daten holen, Inhalte ändern, Diagnostik). Der Adapter ist aber flexibel: Liefert eine Ability nur read-only Daten (z. B. Debug-Log, statische Konfiguration), kann sie auch als Resource konfiguriert werden – dann nimmt die KI die Infos als Hintergrundkontext auf, ohne aktiv „callen“ zu müssen.

Installation: MCP Adapter als Plugin

Der schnellste Einstieg ist die Installation als Plugin über die Releases-Seite des GitHub-Repos: https://github.com/WordPress/mcp-adapter/releases.

Nach Installation und Aktivierung registriert das Plugin automatisch einen Default MCP Server mit dem Namen mcp-adapter-default-server sowie drei zusätzliche Abilities:

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

Diese werden gleichzeitig als MCP Tools verfügbar gemacht:

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

Damit bekommen AI Agents einen „gestuften“ Zugriff auf Abilities: erst discover (welche gibt es?), dann get info (wie sehen Schemas/Parameter aus?), dann execute (ausführen).

Abilities für den Default MCP Server freischalten

Wichtig: Im Default-Setup sind Abilities nur dann über den Default MCP Server nutzbar, wenn sie explizit als öffentlich für MCP markiert werden. Das passiert über ein meta.mcp.public-Flag beim Registrieren via 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
    ),
)

Für Core-Abilities (oder generell Abilities, deren Registrierungsargumente du zur Laufzeit anpassen willst) kannst du den Filter wp_register_ability_args verwenden und dort das Flag ergänzen.

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

Sobald das sitzt, kannst du KI-Clients gegen deinen WordPress-MCP-Server verbinden und die Core-Abilities über die MCP-Tools ausführen lassen.

KI-Clients verbinden: Transport-Layer (STDIO vs. HTTP)

MCP kennt zwei Transport-Mechanismen: STDIO und HTTP. Welche Variante du nutzt, hängt primär davon ab, wo deine WordPress-Installation läuft.

STDIO: ideal für lokale Entwicklungsumgebungen

Für lokale WordPress-Setups ist STDIO meist der direkteste Weg. Der MCP Adapter kann über WP-CLI als MCP-Server laufen – du brauchst WP-CLI also lokal.

Minimal-Konfiguration (Beispielstruktur, wie sie viele Clients erwarten):

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

Bedeutung der Felder:

wordpress-mcp-server: frei wählbarer Name für diese Server-Definition.
command: "wp": WP-CLI als Kommando.
--path=...: Pfad zu deiner WordPress-Installation.
mcp-adapter serve: startet den MCP Adapter Server.
--server=...: welcher MCP Server genutzt werden soll (hier der Default).
--user=...: als welcher WordPress-User authentifiziert wird (z. B. admin).

HTTP: für öffentlich erreichbare Installationen oder ohne STDIO

Wenn deine Installation öffentlich erreichbar ist (oder du STDIO vermeiden willst), kannst du per HTTP anbinden – typischerweise über den Remote-Proxy @automattic/mcp-wordpress-remote. Dafür brauchst du Node.js und eine Authentifizierung, z. B. über Application Passwords oder eine eigene OAuth-Implementierung.

Minimal-Konfiguration für HTTP via npx:

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

Wichtige Details:

command: "npx": startet Node-Pakete ohne globale Installation.
-y: automatische Zustimmung zur Installation.
@automattic/mcp-wordpress-remote@latest: nutzt die neueste Version des Remote-Proxys.
WP_API_URL: MCP-Endpoint deiner Site.
WP_API_USERNAME: User für Auth.
WP_API_PASSWORD: Application Password dieses Users.

Für lokale HTTP-Setups gibt es beim Remote-Proxy eine Troubleshooting-Sektion (häufige Ursachen sind mehrere Node-Versionen oder Probleme mit lokalen SSL-Zertifikaten): https://github.com/Automattic/mcp-wordpress-remote/blob/trunk/Docs/troubleshooting.md

App-spezifische Setups (Claude Desktop, Cursor, Claude Code, VS Code)

Die Konfigurationsformate sind sehr ähnlich – der Unterschied liegt meist nur darin, wo die JSON-Datei liegt und ob das Root-Objekt mcpServers oder servers heißt.

Hinweis zu Beispielwerten

In den folgenden Beispielen wird ein lokales Studio-Setup genutzt: Pfad /Users/jonathanbossenger/Studio/wordpress-mcp, URL http://localhost:8885/, Admin-User admin. Ersetze das durch deine Werte.

Claude Desktop

Claude Desktop hat früh native MCP-Unterstützung bekommen. Du findest die Konfiguration unter Developer (Claude → Settings → Developer). Dort bei Local MCP servers auf Edit config klicken.

Das öffnet die claude_desktop_config.json. MCP-Server werden dort im Objekt mcpServers definiert:

{
  "mcpServers": {
  }
}

{
  "mcpServers": {
  }
}

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

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

Nach dem Speichern musst du Claude Desktop neu starten, da die MCP-Konfiguration nur beim Start eingelesen wird.

Cursor

In Cursor gehst du zu Settings (Cursor → Settings → Cursor Settings) und dort in den Bereich Tools and MCP.

Über Add Custom MCP öffnest du die Datei mcp.json. Das Format ist identisch zu Claude Desktop. Nach dem Speichern taucht der Server in Tools and MCP auf und kann für Coding-Sessions aktiviert werden.

Claude Code

Für Claude Code gibt es zwei gängige Orte:

mcpServers in der .claude.json im Home-Verzeichnis (global für alle Projekte).
Eine .mcp.json im Projektverzeichnis (pro Projekt unterschiedliche MCP-Setups).

Das Konfigurationsformat entspricht dem von Cursor/Claude Desktop.

VS Code

In VS Code richtest du MCP über eine JSON-Datei ein, meist mcp.json in .vscode/ im Workspace. Dokumentation: https://code.visualstudio.com/docs/copilot/customization/mcp-servers

Der zentrale Unterschied: VS Code erwartet ein Root-Objekt namens servers statt mcpServers.

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

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

Nach dem Anlegen zeigt VS Code eine MCP-Control-Toolbar (Start/Stop/Restart). Wenn alles korrekt läuft, siehst du auch, wie viele Tools verfügbar sind (im Default-Setup typischerweise drei).

MCP Tools nutzen: Wie ein AI Client Abilities ausführt

Wenn der MCP-Server in deiner App verbunden ist, kannst du direkt loslegen. Beispiel: In Claude Desktop kannst du sinngemäß fragen: „Get the site info from my WordPress site“.

Claude Desktop: Anfrage an WordPress MCP Server und Ergebnisanzeige — Claude erkennt den MCP-Server, entdeckt Abilities und führt `core/get-site-info` aus. — *Forrás: developer.wordpress.org*

Typischer Ablauf im Hintergrund:

Der Client erkennt einen verfügbaren MCP-Server.
Er ruft mcp-adapter-discover-abilities auf, um verfügbare Abilities zu ermitteln.
Er entscheidet, dass core/get-site-info die Anfrage erfüllt.
Er ruft mcp-adapter-execute-ability auf und übergibt den Ability-Namen.
WordPress liefert die Daten zurück, der Client formuliert daraus die Antwort.

Eigene MCP Server pro Plugin: Mehr Kontrolle als beim Default-Server

Der Default-Server reicht oft aus. Für Plugins kann ein eigener MCP-Server aber sinnvoll sein, wenn du exakt steuern willst, welche Abilities als Tools/Resources/Prompts erscheinen – unabhängig vom meta.mcp.public-Flag.

Technisch setzt das voraus, dass du den MCP Adapter als Dependency via Composer einbindest und dann einen eigenen Server registrierst.

1) Package installieren

Im Plugin-Verzeichnis:

composer require wordpress/mcp-adapter

composer require wordpress/mcp-adapter

2) Composer Autoloader laden

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

Wenn mehrere Plugins auf einer Site vom MCP Adapter oder der Abilities API abhängen, wird empfohlen, den Jetpack Autoloader zu nutzen, um Versionskonflikte zu vermeiden: https://github.com/WordPress/mcp-adapter/blob/trunk/docs/getting-started/installation.md#using-jetpack-autoloader-highly-recommended

3) MCP Adapter initialisieren

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) Custom MCP Server anlegen (mcp_adapter_init)

Über den Action-Hook mcp_adapter_init bekommst du Zugriff auf die Adapter-Instanz und kannst mit create_server() deinen Server definieren:

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

Parameter, die du dir merken solltest:

(1) Server-Identifier: wird beim Start via WP-CLI benötigt.
(2) + (3) REST API namespace + route: bestimmen den Endpoint-Pfad.
(4) + (5) Name + Beschreibung: erscheinen in KI-Apps beim Listing.
(6) Version: Server-Version.
(10) Abilities-Liste: welche Abilities als MCP Tools exposed werden (mehrere möglich).
Transport, Error-Handling und Observability können die Standard-Handler nutzen – oder du baust eigene, wenn du z. B. in ein eigenes Logging/Monitoring integrieren willst.

Beispiel: „List All URLs“ um einen Custom MCP Server erweitern

Ein konkretes Beispiel hilft meist mehr als Theorie: Wir nehmen das Plugin List All URLs und ergänzen einen eigenen MCP Server, der die Ability list-all-urls/urls als Tool anbietet.

Vorbereitung

Wenn du das MCP Adapter Plugin aktiviert hast, deaktiviere es für dieses Beispiel (damit du klar siehst, was das Plugin selbst einbindet).

1) Repository klonen

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) Auf den Branch mit Abilities wechseln

cd list-all-urls
git checkout abilities

cd list-all-urls
git checkout abilities

3) Dependencies installieren

composer install

composer install

4) MCP Adapter als Dependency hinzufügen

composer require wordpress/mcp-adapter

composer require wordpress/mcp-adapter

5) Custom Server im Plugin registrieren

Öffne list-all-urls.php und hänge folgenden Code ans Ende, um den Adapter zu initialisieren und den Custom MCP Server zu erstellen:

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

Wichtig dabei: Du musst hier kein meta.mcp.public setzen, weil du die Ability explizit über deinen Custom Server als Tool exposest.

6) Plugin aktivieren und Client-Konfiguration erweitern

Aktiviere das Plugin im WordPress-Backend. Danach ergänzt du die MCP-Konfiguration in deinem AI-Client so, dass neben dem Default-Server auch dein neuer Server gestartet werden kann.

Beispiel für VS Code: beide Server via STDIO transport in .vscode/mcp.json:

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

Mehrere MCP-Server parallel zu konfigurieren ist ausdrücklich möglich – praktisch, wenn du zwischen Sites oder Plugins mit unterschiedlichen Tool-Sets wechseln willst. Nach Änderungen musst du je nach App neu starten oder den MCP-Server explizit starten/restarten. Dann solltest du den neuen Server sehen und z. B. „List all URLs on my WordPress site“ anfragen können – der Client nutzt dann das Tool list-all-urls-urls.

VS Code: Nutzung von MCP Tools, um List All URLs abzufragen — VS Code ruft das Tool des Custom MCP Servers auf und zeigt die URL-Liste an — *Forrás: developer.wordpress.org*

Security & Best Practices: MCP ist Teil deiner Angriffsfläche

Der kritische Punkt: MCP-Clients agieren effektiv als eingeloggte WordPress-User. Behandle MCP daher wie jeden anderen Integrationskanal, der Aktionen in deinem System ausführen kann.

permission_callback sehr bewusst einsetzen: Jede Ability sollte die minimal nötige Capability prüfen (manage_options, edit_posts, etc.). Vermeide __return_true bei destruktiven Operationen (z. B. Content löschen).
Dedizierte User für MCP verwenden: Gerade in Produktion empfiehlt sich ein eigener User/Rolle mit begrenzten Rechten. Exponiere keine mächtigen Abilities an nicht-auditierte KI-Clients.
Für öffentliche HTTP-Endpunkte read-only bevorzugen: Wenn du MCP über das Internet anbietest, fokussiere auf Diagnose/Reporting/Content-Read-Zugriff statt Schreiboperationen.
Custom Auth bei Bedarf: Standard ist Auth über Application Passwords, möglich sind aber auch OAuth oder andere Verfahren für bessere Security.
Monitoring & Logging aktiv nutzen: Über eigene Error- und Observability-Handler kannst du in deine Logging-/Monitoring-Stacks integrieren.

So startest du heute minimal („Hello AI“ für WordPress)

Für einen minimalen Einstieg brauchst du im Kern nur drei Dinge:

Eine Ability registrieren (mit sauberem Schema, Permission-Check, Execute-Logik).
MCP Adapter einbinden und initialisieren (Plugin oder Composer-Dependency).
Einen MCP-fähigen Client verbinden (Claude Desktop, Cursor, VS Code, Claude Code) und Tools nutzen.

Wenn du bereits Plugins mit der Abilities API betreibst, macht dich der MCP Adapter mit sehr wenig zusätzlicher Arbeit AI-ready: Abilities werden zu strukturierten Tool-Schnittstellen, die AI Agents entdecken und ausführen können.

Ein sinnvoller Einstieg ist, klein anzufangen: wenige, nicht-destruktive, read-only Abilities exponieren, lokal testen (STDIO), und erst dann schrittweise komplexere Workflows ergänzen. Hilfreiche Doku-Startpunkte sind die Abilities API Docs https://developer.wordpress.org/apis/abilities/ und das MCP Adapter Repo https://github.com/WordPress/mcp-adapter.

In Kombination geben dir Abilities und MCP Adapter einen klaren Weg, AI-gestützte Admin-Tools, Automatisierungen und Workflows für Teams und Kund:innen auf WordPress-Basis zu bauen – ohne jedes Mal proprietäre Einzelintegrationen zu stricken.

WordPress MCP Adapter: Abilities als Brücke zu AI Agents (MCP)

Kurz-Recap: Warum Abilities die Basis sind

Was ist der WordPress MCP Adapter?

MCP-Grundbegriffe: Tools, Resources und Prompts

Installation: MCP Adapter als Plugin

Abilities für den Default MCP Server freischalten

KI-Clients verbinden: Transport-Layer (STDIO vs. HTTP)

STDIO: ideal für lokale Entwicklungsumgebungen

HTTP: für öffentlich erreichbare Installationen oder ohne STDIO

App-spezifische Setups (Claude Desktop, Cursor, Claude Code, VS Code)

Hinweis zu Beispielwerten

Claude Desktop

Cursor

Claude Code

VS Code

MCP Tools nutzen: Wie ein AI Client Abilities ausführt

Eigene MCP Server pro Plugin: Mehr Kontrolle als beim Default-Server

1) Package installieren

2) Composer Autoloader laden

3) MCP Adapter initialisieren

4) Custom MCP Server anlegen (mcp_adapter_init)

Beispiel: „List All URLs“ um einen Custom MCP Server erweitern

Vorbereitung

1) Repository klonen

2) Auf den Branch mit Abilities wechseln

3) Dependencies installieren

4) MCP Adapter als Dependency hinzufügen

5) Custom Server im Plugin registrieren

6) Plugin aktivieren und Client-Konfiguration erweitern

Security & Best Practices: MCP ist Teil deiner Angriffsfläche

So startest du heute minimal („Hello AI“ für WordPress)

Referenzen / Quellen

Julia Schneider

Mehr von Julia Schneider

Tritt der HelloWP-Community bei!