WordPress MCP Adapter: como ligar Abilities a agentes de IA (MCP) no teu site

O WordPress tem vindo a preparar o terreno para automação com IA de forma estruturada – não com “magia” por cima de endpoints soltos, mas com uma camada de capacidades bem definida, tipada e descoberta automaticamente. A peça central dessa estratégia é a Abilities API (chegada no WordPress 6.9) e, mais recentemente, o WordPress MCP Adapter, que transforma essas abilities em primitivas do Model Context Protocol (MCP), para que ferramentas de IA consigam descobrir e executar funcionalidades do teu site com segurança.

A ideia prática é simples: se o teu plugin já regista abilities, estás muito perto de as tornar utilizáveis por um agente de IA como Claude Desktop, Claude Code, Cursor ou VS Code – via MCP. A partir daqui, começa a ser realista construir fluxos como: “gera um relatório de vendas”, “lista URLs do site”, “faz diagnóstico do ambiente”, etc., com o modelo a chamar funções bem definidas em vez de inventar passos.

Recap rápido: porque é que Abilities são a fundação disto tudo?

A Abilities API dá ao WordPress uma API funcional “de primeira classe”, transversal a contextos (PHP, JavaScript e REST API), para padronizar como o core e os plugins expõem aquilo que conseguem fazer. Em vez de cada plugin inventar o seu formato, uma ability fica definida uma vez e pode ser descoberta e executada de forma consistente.

Um nome único (formato namespace/ability-name)
Um schema de input tipado e um schema de output tipado
Um permission_callback que valida permissões/capabilities
Um execute_callback que executa a funcionalidade em si (buscar dados, atualizar posts, correr diagnósticos, etc.)

No WordPress 6.9 existem três abilities de base (core) que servem como ponto de partida para testar integrações:

core/get-site-info: devolve informação do site configurada no WordPress; por defeito devolve todos os campos ou um subconjunto filtrado.
core/get-user-info: devolve detalhes básicos do perfil do utilizador autenticado; útil para personalização, auditoria e comportamento dependente de acesso.
core/get-environment-info: devolve detalhes do contexto de runtime do site (ambiente, PHP runtime, info do servidor de base de dados, versão do WordPress), pensado para diagnóstico/compatibilidade.

O que é o WordPress MCP Adapter?

O WordPress MCP Adapter é um pacote oficial dentro da iniciativa AI Building Blocks for WordPress. O papel dele é adaptar as abilities registadas pela Abilities API para as primitivas do Model Context Protocol (MCP), permitindo que agentes de IA consigam:

Descobrir funcionalidades do site como MCP tools (funções executáveis).
Ler dados do WordPress como MCP resources (fontes de dados passivas).

Na prática: abilities viram tools (na maioria dos casos), porque representam lógica executável. Mas o adaptador é flexível: se uma ability for estritamente read-only e fizer sentido como contexto (por exemplo, configuração estática do site, logs de debug), também pode ser configurada como resource, para o modelo “absorver” sem ter de fazer uma chamada ativa.

MCP em 3 primitivas: tools, resources e prompts

O MCP organiza interações em três blocos principais:

Tools: funções executáveis que o modelo chama para realizar ações.
Resources: dados passivos (ficheiros, linhas de base de dados, etc.) que o modelo lê para ganhar contexto.
Prompts: templates pré-configurados para orientar workflows específicos.

Instalar o MCP Adapter (modo rápido via plugin)

A forma mais direta de começar é instalar o MCP Adapter como plugin, através da página de releases do repositório no GitHub: https://github.com/WordPress/mcp-adapter/releases. Depois de ativo, ele cria um MCP server por defeito com o nome mcp-adapter-default-server e regista três abilities próprias, que também ficam expostas automaticamente como MCP tools.

Abilities registadas pelo plugin

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

Tools MCP expostas automaticamente

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

Estas três tools criam um acesso em camadas: o agente pode descobrir abilities disponíveis, inspecionar detalhes de uma ability e depois executá-la.

Como expor abilities no server por defeito: `meta.mcp.public`

Por defeito, as abilities só ficam acessíveis via o server mcp-adapter-default-server se forem explicitamente marcadas como públicas para MCP. Isso é feito ao registar a ability com wp_register_ability() e adicionar a flag 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
    ),
),

No caso das abilities do core, não vais editá-las diretamente. Em vez disso, podes usar o filtro wp_register_ability_args para alterar os argumentos de registo e adicionar meta.mcp.public às abilities que queres expor.

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

Com isto ativo, já consegues ligar um cliente MCP ao teu site e chamar as abilities do core via as tools do server por defeito.

Ligar aplicações de IA ao teu WordPress via MCP

Transport: STDIO vs HTTP

O MCP define dois mecanismos de transporte principais para comunicar com um server MCP: STDIO e HTTP. A escolha costuma depender de onde está o WordPress e do fluxo de trabalho (local vs público).

Para ambientes locais de desenvolvimento WordPress, o caminho mais simples é STDIO, e o MCP Adapter permite isso via WP-CLI (tens de ter o WP-CLI instalado na tua máquina).

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

wordpress-mcp-server é só um nome lógico para a configuração (pode ser outro).
command: wp indica que o cliente vai arrancar o server via WP-CLI.
Em args: --path aponta para a instalação do WordPress; mcp-adapter serve arranca o server; --server escolhe qual server MCP usar; --user define o utilizador WordPress com que o cliente autentica.

Para instalações publicamente acessíveis (ou se não quiseres STDIO), podes optar por HTTP com um proxy remoto: @automattic/mcp-wordpress-remote. Isto exige Node.js e autenticação – tipicamente com Application Passwords do WordPress (ou OAuth customizado, se precisares de um modelo diferente).

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

command: npx executa packages Node sem instalação global.
-y aceita automaticamente a instalação do package.
WP_API_URL aponta para o endpoint MCP no teu WordPress.
WP_API_USERNAME e WP_API_PASSWORD são as credenciais (com Application Password).

Se estiveres a usar o proxy HTTP para um WordPress local, é comum tropeçar em problemas de múltiplas versões de Node.js ou certificados SSL locais. Há notas de troubleshooting aqui: https://github.com/Automattic/mcp-wordpress-remote/blob/trunk/Docs/troubleshooting.md.

Configuração por aplicação (Claude Desktop, Cursor, Claude Code, VS Code)

Nota sobre os exemplos

Os exemplos abaixo usam um site local em /Users/jonathanbossenger/Studio/wordpress-mcp, acessível em http://localhost:8885/, e o utilizador admin. Substitui pelo caminho/URL e utilizador do teu ambiente.

Claude Desktop

No Claude Desktop, os servers MCP são configurados no separador Developer (Claude → Settings → Developer). Em Local MCP servers, escolhe Edit config para abrir o ficheiro claude_desktop_config.json. As definições ficam dentro do objeto mcpServers.

{
  "mcpServers": {
  }
}

{
  "mcpServers": {
  }
}

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

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

Depois de gravares o ficheiro, tens de reiniciar o Claude Desktop, porque ele só lê as configurações no arranque. Quando estiver tudo certo, vais ver o server listado em Local MCP servers com estado running.

Claude Desktop com um servidor MCP do WordPress listado como running — *Forrás: developer.wordpress.org*

Cursor

No Cursor, vai a Cursor → Settings → Cursor Settings e abre a secção Tools and MCP. Clica em Add Custom MCP para editar o ficheiro mcp.json. O formato é o mesmo do Claude Desktop. Depois de guardares, volta às definições e ativa o server para o usar nas sessões.

Cursor com o WordPress MCP Server adicionado na lista de MCP — *Forrás: developer.wordpress.org*

Claude Code

No Claude Code, podes adicionar servers MCP de duas formas:

Adicionar um objeto mcpServers com as configs no ficheiro .claude.json no teu diretório home (disponível globalmente).
Criar um ficheiro .mcp.json no diretório do projeto (permite configurações por projeto).

Em ambos os casos, o formato das configurações é igual ao do Claude Desktop/Cursor.

VS Code

No VS Code, a ligação a servers MCP é feita com um ficheiro JSON (normalmente mcp.json) dentro de uma pasta .vscode no workspace. A principal diferença é que aqui as definições ficam dentro de um objeto servers (não mcpServers). O resto mantém-se.

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

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

Depois de criares esse ficheiro, o VS Code mostra uma toolbar de controlo MCP para iniciar/parar/reiniciar o server. Quando o arranque corre bem, ele também indica quantas tools estão disponíveis (no exemplo, três). Mais detalhes em: https://code.visualstudio.com/docs/copilot/customization/mcp-servers

VS Code com ficheiro mcp.json e barra de controlo MCP visível — *Forrás: developer.wordpress.org*

Usar as MCP tools (exemplo prático com `core/get-site-info`)

Com o server MCP ligado ao teu cliente (por exemplo, Claude Desktop), já podes pedir algo como: “Get the site info from my WordPress site”. O cliente vai perceber que existe um server MCP e usar a tool mcp-adapter-discover-abilities para descobrir o que está disponível.

A seguir, ao identificar que core/get-site-info resolve o pedido, ele chama mcp-adapter-execute-ability, passando o nome da ability. O resultado volta como dados de info do site e a aplicação responde com base nesse output.

Conversa no Claude Desktop a chamar tools MCP do WordPress e a mostrar site info — *Forrás: developer.wordpress.org*

Criar um MCP server customizado no teu plugin (via Composer)

O server por defeito cobre a maioria dos casos, mas há cenários em que compensa criar um server customizado para o teu plugin – sobretudo quando queres controlar explicitamente que abilities são expostas como tools, sem depender da flag meta.mcp.public.

Aqui o fluxo muda: em vez de instalar o plugin do MCP Adapter, instalas o package via Composer e defines o server no teu código.

1) Instalar a dependência com Composer

composer require wordpress/mcp-adapter

composer require wordpress/mcp-adapter

2) Carregar o autoloader do Composer no ficheiro principal do plugin

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

Quando existe a possibilidade de vários plugins no mesmo site dependerem do MCP Adapter (ou da Abilities API), é recomendado usar o Jetpack Autoloader para evitar conflitos de versões. Referência: https://github.com/WordPress/mcp-adapter/blob/trunk/docs/getting-started/installation.md#using-jetpack-autoloader-highly-recommended

3) Inicializar o 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) Criar e registar um server MCP customizado (`mcp_adapter_init`)

O passo final é fazer hook na action mcp_adapter_init. O callback recebe a instância do adaptador, e tu defines o server com create_server().

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

O que interessa mesmo nos parâmetros

1º parâmetro: identificador único do server (usado ao arrancar via WP-CLI).
2º e 3º parâmetros: namespace e route na REST API para o server MCP.
4º e 5º: nome e descrição visíveis nas apps ao listar servers MCP.
6º: versão do server.
10º: lista de abilities expostas como tools (podes incluir várias).
Restante: métodos de transporte, handlers de erro e observabilidade (podes criar os teus se precisares de integrar com logging/monitorização próprios).

Exemplo completo: adicionar um server MCP custom ao plugin “List All URLs”

Para mostrar isto num caso real, dá para pegar no plugin List All URLs (já com implementação da Abilities API) e criar um server MCP específico só para a ability que lista URLs.

Antes de começares

Desativa o plugin do MCP Adapter, caso o tenhas ativo, antes de testares esta abordagem via Composer no plugin de exemplo.

1) Clonar o repositório para `wp-content/plugins`

cd wp-content/plugins
git clone git@github.com:wptrainingteam/list-all-urls.git

cd wp-content/plugins
git clone git@github.com:wptrainingteam/list-all-urls.git

2) Mudar para a branch com Abilities API

cd list-all-urls
git checkout abilities

cd list-all-urls
git checkout abilities

3) Instalar dependências do plugin e adicionar o mcp-adapter

composer install

composer install

composer require wordpress/mcp-adapter

composer require wordpress/mcp-adapter

4) Alterar `list-all-urls.php` para inicializar o MCP Adapter e criar o server

Abre o ficheiro principal list-all-urls.php e adiciona no fim:

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

Repara num detalhe importante: aqui não precisas de marcar list-all-urls/urls com meta.mcp.public, porque estás a expô-la explicitamente no server customizado.

5) Ativar o plugin e apontar o cliente para o novo server

Ativa o plugin no admin do WordPress e atualiza a configuração do teu cliente MCP para usar o server list-all-urls-mcp-server.

Exemplo de .vscode/mcp.json com dois servers (ambos em STDIO): o default e o do plugin List All URLs.

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

É perfeitamente possível ter vários servers MCP configurados na mesma aplicação. Isso facilita alternar entre sites WordPress diferentes ou entre conjuntos de tools expostas por plugins diferentes.

Depois de atualizares a configuração, reinicia a aplicação (ou inicia o server MCP pela UI, no caso do VS Code). A partir daí, podes pedir algo como “List all URLs on my WordPress site” e o cliente vai chamar a tool list-all-urls-urls.

VS Code a usar MCP tools para obter a lista de URLs via plugin List All URLs — *Forrás: developer.wordpress.org*

Segurança e boas práticas (não saltar esta parte)

Clientes MCP, na prática, comportam-se como utilizadores autenticados no WordPress. Isso significa que passam a fazer parte da tua superfície de aplicação e merecem o mesmo nível de rigor que darias a integrações server-to-server.

Usa permission_callback com cuidado: cada ability deve validar a capability mínima necessária (manage_options, edit_posts, etc.). Evita __return_true em operações destrutivas (por exemplo, apagar conteúdo).
Cria utilizadores dedicados para acesso MCP: especialmente em produção, cria um user/role específico com permissões limitadas. Não exponhas abilities poderosas a clientes de IA não auditados.
Prefere abilities read-only para endpoints MCP públicos: se estiveres a expor HTTP para a internet, foca-te em diagnósticos, reporting e acesso a conteúdo, evitando escrita/mutação.
Implementa autenticação customizada se necessário: o padrão usa application passwords, mas podes implementar OAuth ou outros métodos para um modelo de segurança mais robusto.
Monitoriza e regista utilização: integra handlers de erro e observabilidade com a tua stack de logging/monitorização usando handlers customizados.

Como começar a experimentar hoje (o caminho mínimo)

Um “hello AI” realista para um dev WordPress passa por três passos essenciais:

Registar uma ability (com schemas, permission_callback e execute_callback).
Adicionar o MCP Adapter (via plugin ou Composer) e inicializá-lo.
Ligar um cliente com suporte MCP (Claude Desktop, Cursor, Claude Code ou VS Code) e começar a chamar tools.

Se já tens plugins a usar Abilities, o MCP Adapter transforma isso em APIs prontas para agentes de IA com pouco trabalho extra. A estratégia sensata é começar com abilities pequenas, não destrutivas e read-only; testar localmente via STDIO; e só depois ampliar para workflows mais complexos – sempre com foco em permissões, autenticação e observabilidade.

Documentação útil para aprofundar:

Abilities API: https://developer.wordpress.org/apis/abilities/
WordPress MCP Adapter (repositório): https://github.com/WordPress/mcp-adapter
MCP (introdução): https://modelcontextprotocol.io/docs/getting-started/intro

WordPress MCP Adapter: como ligar Abilities a agentes de IA (MCP) no teu site

Recap rápido: porque é que Abilities são a fundação disto tudo?

O que é o WordPress MCP Adapter?

MCP em 3 primitivas: tools, resources e prompts

Instalar o MCP Adapter (modo rápido via plugin)

Abilities registadas pelo plugin

Tools MCP expostas automaticamente

Como expor abilities no server por defeito: `meta.mcp.public`

Ligar aplicações de IA ao teu WordPress via MCP

Transport: STDIO vs HTTP

Configuração por aplicação (Claude Desktop, Cursor, Claude Code, VS Code)

Nota sobre os exemplos

Claude Desktop

Cursor

Claude Code

VS Code

Usar as MCP tools (exemplo prático com `core/get-site-info`)

Criar um MCP server customizado no teu plugin (via Composer)

1) Instalar a dependência com Composer

2) Carregar o autoloader do Composer no ficheiro principal do plugin

3) Inicializar o MCP Adapter

4) Criar e registar um server MCP customizado (`mcp_adapter_init`)

O que interessa mesmo nos parâmetros

Exemplo completo: adicionar um server MCP custom ao plugin “List All URLs”

Antes de começares

1) Clonar o repositório para `wp-content/plugins`

2) Mudar para a branch com Abilities API

3) Instalar dependências do plugin e adicionar o mcp-adapter

4) Alterar `list-all-urls.php` para inicializar o MCP Adapter e criar o server

5) Ativar o plugin e apontar o cliente para o novo server

Segurança e boas práticas (não saltar esta parte)

Como começar a experimentar hoje (o caminho mínimo)

Referências / Fontes

Inês Silva

Mais de Inês Silva

Junte-se à comunidade HelloWP!

Recap rápido: porque é que Abilities são a fundação disto tudo?

O que é o WordPress MCP Adapter?

MCP em 3 primitivas: tools, resources e prompts

Instalar o MCP Adapter (modo rápido via plugin)

Abilities registadas pelo plugin

Tools MCP expostas automaticamente

Como expor abilities no server por defeito: meta.mcp.public

Ligar aplicações de IA ao teu WordPress via MCP

Transport: STDIO vs HTTP

Configuração por aplicação (Claude Desktop, Cursor, Claude Code, VS Code)

Nota sobre os exemplos

Claude Desktop

Cursor

Claude Code

VS Code

Usar as MCP tools (exemplo prático com core/get-site-info)

Criar um MCP server customizado no teu plugin (via Composer)

1) Instalar a dependência com Composer

2) Carregar o autoloader do Composer no ficheiro principal do plugin

3) Inicializar o MCP Adapter

4) Criar e registar um server MCP customizado (mcp_adapter_init)

O que interessa mesmo nos parâmetros

Exemplo completo: adicionar um server MCP custom ao plugin “List All URLs”

Antes de começares

1) Clonar o repositório para wp-content/plugins

2) Mudar para a branch com Abilities API

3) Instalar dependências do plugin e adicionar o mcp-adapter

4) Alterar list-all-urls.php para inicializar o MCP Adapter e criar o server

5) Ativar o plugin e apontar o cliente para o novo server

Segurança e boas práticas (não saltar esta parte)

Como começar a experimentar hoje (o caminho mínimo)

Referências / Fontes

Inês Silva

Mais de Inês Silva

Junte-se à comunidade HelloWP!

Como expor abilities no server por defeito: `meta.mcp.public`

Usar as MCP tools (exemplo prático com `core/get-site-info`)

4) Criar e registar um server MCP customizado (`mcp_adapter_init`)

1) Clonar o repositório para `wp-content/plugins`

4) Alterar `list-all-urls.php` para inicializar o MCP Adapter e criar o server