Skip to main content
Glama
zacdreyer

BeTheme MCP Server

by zacdreyer
OverviewSchemaSourceRelated ServersScoreDiscussionsAdmin
JavaScript
Hybrid

BeTheme MCP Server

A secure, agent-friendly MCP server that turns one or more BeTheme-powered WordPress sites into a backend-equivalent environment for an AI agent.

┌──────────────────────────────────────────────────────────────┐
│  BeTheme MCP Server                                          │
│  Agent-driven WordPress + BeTheme administration             │
│  Pages • Templates • Plugins • WooCommerce • BeBuilder       │
└──────────────────────────────────────────────────────────────┘

What this project does

This project lets an AI agent manage BeTheme-powered WordPress sites without logging into wp-admin. It exposes MCP tools for:

  • creating, editing, publishing, and deleting pages

  • reading and writing BeBuilder payloads (mfn-page-items)

  • creating and updating BeTheme templates (headers, footers, archives, popups, etc.)

  • listing, activating, deactivating, and installing plugins

  • returning site context and capabilities so the agent knows what it can do

The design is built for agencies: one local MCP server can connect to many client sites, each with its own URL and API key.

Related MCP server: WordPress MCP Server

Architecture — what runs where

The project has two parts. Almost all business logic lives in the WordPress plugin. The local Node process is only a thin protocol adapter between the MCP client and the REST bridge.

flowchart LR
    A[MCP client e.g. Claude Desktop] -->|stdio| B[Local Node MCP server]
    B -->|HTTPS + HMAC signed| C[WordPress REST API]
    C --> D[BeTheme MCP Bridge plugin]
    D --> E[WordPress + BeTheme]

Part 1 — WordPress bridge plugin (plugin/betheme-mcp-bridge.php)

This runs on the web server inside WordPress. It:

  • registers REST routes under /wp-json/betheme-mcp/v1/

  • authenticates every request with an API key + HMAC-SHA256 request signature

  • enforces WordPress capability checks (edit_pages, edit_theme_options, activate_plugins, etc.)

  • sanitizes input, allow-lists BeTheme meta keys, and stores builder payloads in BeTheme's native format

  • audits every action through the betheme_mcp_audit hook

  • applies per-key rate limiting

Part 2 — Local MCP server (src/server.js)

This is a small Node.js process that runs on the machine where the AI agent runs. It:

  • speaks the MCP protocol over stdin/stdout

  • validates tool arguments against the declared JSON schema

  • routes each tool call to the correct WordPress bridge endpoint

  • supports multiple sites through a site argument or per-site configuration

Why does the MCP server run locally?

MCP clients today (Claude Desktop, etc.) usually launch an MCP server as a local child process over stdio. That local process can then talk to remote APIs. We keep the local part as thin as possible: it has no WordPress business logic, no database access, and no plugin installation logic. If your MCP client supports SSE, you can also host the Node server on your own infrastructure and point the client at it.

Installation — single site

1. WordPress requirements

  • WordPress 6.4+ with the BeTheme theme active

  • PHP 8.2+

  • HTTPS recommended in production

2. Install the bridge plugin

  1. Copy plugin/betheme-mcp-bridge.php into your WordPress site's wp-content/plugins/ directory.

  2. In wp-admin, go to Plugins and activate BeTheme MCP Bridge.

  3. Open wp-config.php and add a secure API key:

    define('BETHEME_MCP_API_KEY', 'replace-with-a-long-random-key');

  4. Optional but recommended policy flags:

    define('BETHEME_MCP_AUDIT_LOG', true);
define('BETHEME_MCP_ALLOW_PLUGIN_INSTALL', false);

  5. Verify the bridge is reachable:

    curl -H "X-API-Key: replace-with-a-long-random-key" \
     https://your-site.test/wp-json/betheme-mcp/v1/health

    You should get {"ok":true,"site":"..."}.

3. Install and run the local MCP server

  1. Clone this repository on the machine where your AI agent runs:

    git clone <repo-url> betheme-mcp
cd betheme-mcp
npm install

  2. Create the environment file:

    cp .env.example .env

  3. Edit .env:

    BETHEME_MCP_API_KEY=replace-with-a-long-random-key
BETHEME_MCP_BASE_URL=https://your-site.test
BETHEME_MCP_TIMEOUT_MS=10000

  4. Start the server:

    npm start

  5. Verify with the demo harness:

    npm run demo

4. Connect your MCP client

Pick the client you use and add the server configuration. In every case the local Node process is the same; only the client's config file or settings change.

Claude Desktop

Edit claude_desktop_config.json:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

  • Windows: %APPDATA%\Claude\claude_desktop_config.json

  • Linux: ~/.config/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "betheme": {
      "command": "node",
      "args": ["/absolute/path/to/betheme-mcp/src/server.js"]
    }
  }
}

ChatGPT Desktop

OpenAI's ChatGPT Desktop does not currently support local MCP servers. If support is added, the configuration file is expected to use the same mcpServers format as Claude Desktop. Use the same JSON structure and check OpenAI's documentation for the exact file location.

Copilot via VS Code

VS Code's Copilot Chat can use MCP servers configured in your user settings. Open Settings (JSON) (Cmd/Ctrl + Shift + P → Preferences: Open User Settings (JSON)) and add:

{
  "chat.mcp.servers": {
    "betheme": {
      "command": "node",
      "args": ["/absolute/path/to/betheme-mcp/src/server.js"]
    }
  }
}

The exact setting name may vary across VS Code versions (chat.mcp.servers, chat.mcp.serverDefinitions, or github.copilot.chat.mcpServers). If one setting is not recognized, try the next or check the latest VS Code MCP documentation.

GitHub Copilot Desktop

There is currently no standalone "GitHub Copilot Desktop" application that exposes local MCP server configuration. Use Copilot via VS Code above, or use Copilot in any editor that supports MCP server settings.

After saving the configuration, restart the client. The agent can now call tools such as list_pages, create_page, save_page_builder_payload, and list_plugins.

Installation — multi-site (agency setup)

Agencies can manage many client sites from one local MCP server. There are two ways to configure multiple sites.

Option A: sites.json file (recommended)

  1. Copy the example file:

    cp sites.json.example sites.json

  2. Edit sites.json:

    [
  {
    "name": "client-a",
    "baseUrl": "https://client-a.test",
    "apiKey": "key-for-client-a",
    "timeoutMs": 10000
  },
  {
    "name": "client-b",
    "baseUrl": "https://client-b.test",
    "apiKey": "key-for-client-b",
    "timeoutMs": 10000
  }
]

  3. Restart npm start.

Option B: environment variable

In .env, set a single JSON array:

BETHEME_MCP_SITES=[{"name":"client-a","baseUrl":"https://client-a.test","apiKey":"key-for-client-a"},{"name":"client-b","baseUrl":"https://client-b.test","apiKey":"key-for-client-b"}]

BETHEME_MCP_SITES overrides sites.json. The single-site variables are ignored when multi-site configuration is present.

Using multiple sites in conversation

The agent can list configured sites with list_sites. For any other tool, pass the site argument:

  • list_pages → lists pages from the first/default site

  • list_pages with {"site":"client-a"} → lists pages from client-a

  • create_page with {"title":"Home","site":"client-b"} → creates a page on client-b

If site is omitted, the first site in the configuration is used.

Multiple sites from the agent's point of view

You can tell the agent:

"List the sites you can access, then create a homepage on client-a and a contact page on client-b."

The agent will call list_sites, pick the correct aliases, and route each action to the right WordPress installation.

How authentication works

Every request from the local MCP server to WordPress is authenticated in two ways:

  1. API key — sent in the X-API-Key header and compared against BETHEME_MCP_API_KEY in wp-config.php.

  2. HMAC request signature — the local server signs the request with HMAC-SHA256(method|timestamp|body) and sends it in X-Request-Signature. The bridge rejects requests outside a 5-minute replay window or with an invalid signature.

Keep the API key secret. Use HTTPS in production so the key and signatures are protected in transit.

Capability model

The bridge checks WordPress capabilities on every route:

Operation

Capability required

Read pages

edit_pages

Create pages

publish_pages

Update pages

edit_pages (or edit_others_pages for other authors)

Delete pages

delete_pages (or delete_others_pages)

Templates

edit_theme_options

List/activate/deactivate plugins

activate_plugins

Install plugins

install_plugins AND BETHEME_MCP_ALLOW_PLUGIN_INSTALL must be true

The authenticate tool returns the bridge-level capabilities the current context supports.

Security model

  • Authentication: API key + HMAC-SHA256 request signing with timestamp replay window.

  • Authorization: per-route WordPress capability checks.

  • Input validation: JSON Schema validation on the MCP side; sanitization and allow-lists on the PHP side.

  • Meta allow-listing: only known BeTheme page/template meta keys are accepted.

  • Payload hardening: builder payloads are stored in BeTheme's native format and capped at 1 MB.

  • Rate limiting: per-API-key token bucket using WordPress transients.

  • Audit logging: every administrative action is logged via betheme_mcp_audit and optionally to the PHP error log.

Development and testing

Run the local test and lint suite:

npm test
npm run lint
php -l plugin/betheme-mcp-bridge.php

All three should pass before any release.

Documentation

Release and versioning

Releases are published through GitHub Actions when a v* tag is pushed. Version numbers align with the BeTheme version they target, plus an alpha suffix. The current alpha is 28.5.4-alpha.003.

Alpha release notice

This project is currently an alpha release and is still under quality assurance. It is intended for evaluation, integration testing, and controlled internal use, not for production deployment until QA is complete.

Available Tools

21 tools
activate_pluginC

Activate an installed plugin.

ParametersJSON Schema
NameRequiredDescriptionDefault
siteNoOptional site alias when managing multiple sites.
slugYes

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided; the description does not disclose behavioral details such as permissions required, side effects, or what activation entails beyond the verb. For a mutation tool, this is insufficient.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise at 5 words and front-loaded, but the brevity sacrifices necessary detail. It could be more informative without much more length.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema and no annotations, the description should cover prerequisites and effects. It does not, leaving the agent underinformed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 50% (only 'site' has description). The description does not add any meaning beyond the schema; parameters remain underdocumented.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Activate an installed plugin' is a specific verb+resource pair. It clearly distinguishes from siblings like install_plugin and deactivate_plugin.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool vs alternatives, or any prerequisites (e.g., plugin must be installed). The description lacks usage context entirely.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

authenticateA

Verify bridge credentials and return site capabilities.

ParametersJSON Schema
NameRequiredDescriptionDefault
siteNoOptional site alias when managing multiple sites.

TDQS

A3.6/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the burden. It states the tool verifies credentials and returns capabilities, suggesting a non-destructive operation, but does not disclose side effects, permissions needed, or error handling.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Very concise single sentence that is front-loaded with key information. No unnecessary words, but could potentially include more context without harming conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the simplicity (no required params, no output schema), the description is fairly complete. However, it lacks details about the format of returned capabilities or authentication requirements, which could be helpful.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with one optional parameter 'site' already described. The tool description adds no additional semantic value beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: verifying bridge credentials and returning site capabilities. The verb 'verify' and 'return' specify actions, and the resources are distinct from sibling tools like list_sites or get_capabilities.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use this tool versus alternatives. While the purpose implies it is for authentication, there is no mention of when not to use it or prerequisites.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

create_pageC

Create a new page in WordPress.

ParametersJSON Schema
NameRequiredDescriptionDefault
metaNo
siteNoOptional site alias when managing multiple sites.
slugNo
titleYes
contentNo
builder_payloadNo

TDQS

C2.4/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description solely must disclose behavioral traits. It only states 'create a new page', which implies mutation but does not specify whether the page is created as a draft or published, authentication needs, rate limits, or behavior on duplicate titles.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence, which is concise but lacks necessary detail. It is not verbose, but the brevity comes at the cost of completeness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness1/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool complexity (6 parameters, nested objects, no output schema), the description is severely incomplete. It does not explain return values, side effects, or how to use complex parameters like 'meta' and 'builder_payload'.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is only 17% (only 'site' has a description). The description adds no meaning for the 6 parameters, including the required 'title', optional 'slug', 'content', 'meta' object, and 'builder_payload'. With low coverage, the description fails to compensate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool creates a new page in WordPress, with a specific verb and resource. It distinguishes from sibling tools like update_page or delete_page, though it does not explicitly differentiate from publish_page regarding draft vs published state.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives like publish_page or create_template. Missing context about prerequisites, typical use cases, or when not to use it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

create_templateC

Create a new BeTheme template.

ParametersJSON Schema
NameRequiredDescriptionDefault
metaNo
siteNoOptional site alias when managing multiple sites.
typeYes
titleYes
contentNo
builder_payloadNo

TDQS

C2.3/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations exist, so the description carries full burden. It only implies a write operation ('Create') without disclosing effects, required permissions, error states, or validation behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness2/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The single sentence is concise but at the expense of necessary details. It is under-specified and does not merit a higher score for conciseness alone.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness1/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With 6 parameters (including nested objects), no output schema, and many siblings, the description is grossly inadequate. An agent cannot understand valid values, required fields, or expected outcomes.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is only 17% (only 'site' has a description). The description adds no meaning for parameters like type, content, meta, or builder_payload, leaving their semantics entirely unspecified.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Create' and resource 'BeTheme template', making the tool's purpose obvious. However, it does not differentiate from siblings like update_template or list_templates.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this tool versus alternatives (e.g., when to create vs update a template). No context or prerequisites are provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

deactivate_pluginC

Deactivate an installed plugin.

ParametersJSON Schema
NameRequiredDescriptionDefault
siteNoOptional site alias when managing multiple sites.
slugYes

TDQS

C2.6/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description must disclose behavior. It only says 'Deactivate an installed plugin' without mentioning side effects, required permissions, or what happens to plugin settings or data.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is only one sentence, which is concise, but it omits critical information, making it under-specified rather than efficiently informative.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema, incomplete parameter descriptions, and multiple sibling tools, the description lacks completeness. It does not explain return values, prerequisites, or how this tool fits into the broader workflow.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 50% (only site described). Description adds no parameter details; slug is not explained, and site usage is not clarified beyond the schema. Does not compensate for missing schema descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's action (deactivate) and resource (plugin). It distinguishes from siblings like activate_plugin and install_plugin, but lacks nuance about scope or prerequisites.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use deactivate_plugin versus other plugin operations. No mention of prerequisites like the plugin being active, or consequences of deactivation.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

delete_pageC

Delete a WordPress page.

ParametersJSON Schema
NameRequiredDescriptionDefault
idYes
siteNoOptional site alias when managing multiple sites.

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided; description simply states 'Delete a WordPress page' without disclosing side effects, irreversibility, or permission requirements.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence, no unnecessary words. Front-loaded purpose, but minimal detail.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given simple tool with no annotations or output schema, description should provide more context on effects (permanent deletion) and prerequisites, but remains bare.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 50%; the description does not add meaning to parameters beyond the schema. No explanation of 'id' (e.g., page ID) or 'site' beyond schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description states 'Delete a WordPress page' with a clear verb-resource pair. It distinguishes from sibling tools like get_page, create_page.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool vs alternatives, no mention of prerequisites or irreversibility.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_capabilitiesC

Return the capabilities exposed by the bridge and the current authentication context.

ParametersJSON Schema
NameRequiredDescriptionDefault
siteNoOptional site alias when managing multiple sites.

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It implies a read operation but does not state side effects, authentication requirements, rate limits, or how the context is determined. The description is too brief to fully inform an agent about behavioral aspects.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

A single sentence that is direct and front-loaded with the key action and object. Every word earns its place; no verbosity or redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema is provided, and the description does not explain the structure or content of the returned 'capabilities' or 'authentication context'. Given the tool's simplicity (1 optional param), the description should at least hint at the response format to be fully actionable.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with a clear description for the 'site' parameter. The tool description does not add extra meaning beyond the schema, but the baseline is 3 as the schema already explains the parameter.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The verb 'Return' and resource 'capabilities' and 'authentication context' clearly indicate the tool's purpose. It distinguishes from siblings like list_sites or health_check by focusing on capabilities and auth context rather than site listing or system health.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives (e.g., health_check, get_site_context). The description does not provide context about typical use cases or when not to use it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_pageC

Retrieve a specific WordPress page.

ParametersJSON Schema
NameRequiredDescriptionDefault
idYes
siteNoOptional site alias when managing multiple sites.

TDQS

C2.2/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, description should disclose behavioral traits like permissions, side effects, or error handling. Only states 'retrieve', missing essential transparency for a read operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

One sentence, concise but sacrificies needed detail. Front-loaded but insufficiently informative given sibling tool complexity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema, partial parameter descriptions, and no mention of return values, error conditions, or pagination. Incomplete for a simple retrieval tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Description adds no meaning beyond input schema. Schema coverage is 50% with only 'site' described; 'id' lacks description, and description does not clarify parameter usage or format.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose3/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states 'Retrieve a specific WordPress page' with verb and resource, but does not differentiate from sibling tools like get_page_builder_payload or list_pages, making it ambiguous in context.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives (e.g., list_pages for multiple pages, get_page_builder_payload for builder data). Implies usage but lacks exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_page_builder_payloadC

Retrieve the stored BeBuilder payload for a page.

ParametersJSON Schema
NameRequiredDescriptionDefault
idYes
siteNoOptional site alias when managing multiple sites.

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are present, so the description carries full burden. It labels the operation as 'retrieve' (read-only) but does not disclose any behavioral traits such as failure modes (if page has no payload), authorization requirements, or data format. The description adds minimal transparency beyond the verb.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is very concise (one sentence, 8 words) and front-loaded. However, it may be too brief to be fully informative. It earns its place but could add a bit more context without losing conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the lack of an output schema, the description should at least indicate that the payload is JSON or what fields it contains. The tool has 2 simple parameters, but the description fails to explain the nature of the payload (e.g., BeBuilder format) or any behavioral constraints, leaving the agent underinformed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 50%: only the 'site' parameter has a description; 'id' has none. The description does not clarify that 'id' is the page ID or the payload ID. No parameter semantics are added in the description beyond what the schema already provides for 'site'.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Retrieve' and the resource 'stored BeBuilder payload for a page', which is specific and distinguishes it from siblings like 'save_page_builder_payload' (write) and 'get_page' (different resource).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives. There are no prerequisites (e.g., page must exist, payload must be saved) or comparisons to similar tools like 'get_page' or 'save_page_builder_payload'. Usage is only implied.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_site_contextB

Return a safe summary of the WordPress site and theme context for an agent.

ParametersJSON Schema
NameRequiredDescriptionDefault
siteNoOptional site alias when managing multiple sites.

TDQS

B3.2/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description says 'safe summary,' implying non-destructive and read-only behavior, but does not detail what 'safe' entails (e.g., no sensitive data). Without annotations, the description carries full burden; it provides a hint but not enough transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence, no unnecessary words. Extremely concise and front-loaded with the key purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema and no annotations, the description is too sparse. It does not specify what fields are in the summary, making it less useful for an agent to plan further actions.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Parameter 'site' is described in the schema with full coverage (100%). The description adds no extra meaning beyond the schema, so a baseline of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool returns a summary of site and theme context. The verb 'Return' and resource 'summary' are specific. It distinguishes from siblings like 'list_sites' which lists sites, while this tool returns a summary.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool vs alternatives. For example, it doesn't mention when to use this over 'list_sites' or 'get_capabilities'. The description lacks usage context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_templateB

Retrieve a specific BeTheme template.

ParametersJSON Schema
NameRequiredDescriptionDefault
idYes
siteNoOptional site alias when managing multiple sites.

TDQS

B3.1/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are present, so the description must carry the full burden. It only states 'retrieve', implying a read-only operation, but fails to disclose authentication requirements, response details, or any side effects. The lack of transparency is significant.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise sentence with no wasted words. However, it may be too terse given the tool's context and the need for more behavioral detail.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple retrieval tool with no output schema, the description is minimally complete. However, it could be more helpful by mentioning what is returned or that it requires an existing template ID.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 50% (only 'site' has a description). The description adds no parameter information beyond what the schema provides, failing to compensate for the gap. The 'id' parameter, which is required, remains undocumented in both schema and description.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Retrieve') and the resource ('a specific BeTheme template'), distinguishing it from sibling tools like list_templates, create_template, and update_template.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives (e.g., list_templates for all templates, update_template for modifications). The agent is left to infer usage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

health_checkA

Verify that the MCP bridge and WordPress site are reachable.

ParametersJSON Schema
NameRequiredDescriptionDefault
siteNoOptional site alias when managing multiple sites.

TDQS

A3.6/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It only says 'verify reachability' without disclosing what the tool returns (e.g., boolean, status codes, error messages), whether it requires authentication, or if it has any side effects. For a simple read operation, more context on expected output would be helpful.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no unnecessary words. Every part contributes to defining the tool's purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is simple with one optional parameter and no output schema. The description explains the purpose and parameter context sufficiently. An output schema would help, but given the tool's low complexity, the description is nearly complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% for the single optional parameter 'site', described as 'Optional site alias when managing multiple sites.' The description adds no additional meaning beyond the schema, so baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Verify that the MCP bridge and WordPress site are reachable' uses a specific verb 'verify' and identifies the resources (MCP bridge and WordPress site). It clearly distinguishes from sibling tools like list_sites or update_template, which cover different operations.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for checking connectivity but does not explicitly state when to use it versus alternatives, nor does it mention exclusions or prerequisites. There is no guidance like 'use this before other operations' or 'do not use for authentication checks'.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

install_pluginC

Install and activate a plugin from the WordPress ecosystem.

ParametersJSON Schema
NameRequiredDescriptionDefault
siteNoOptional site alias when managing multiple sites.
slugYes

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It only says 'install and activate' without disclosing side effects (e.g., permission requirements, whether it overwrites existing installations, or what happens on failure).

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

One sentence clearly stating the action. No unnecessary words, but could be expanded slightly for clarity without losing conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema, no annotations. The description lacks behavioral context such as what happens if the plugin is already installed, if it requires authentication, or what the return value contains. Incomplete for a tool that modifies system state.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema has 2 parameters: 'site' (described in schema) and 'slug' (no description in schema, 50% coverage). The description adds no extra meaning beyond the schema for either parameter. The slug parameter is left entirely to inference from the tool name.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action: 'Install and activate a plugin from the WordPress ecosystem.' It specifies the verb (install and activate) and resource (plugin), and distinguishes from siblings like 'activate_plugin' which only activates a presumably already installed plugin.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this tool versus alternatives (e.g., activate_plugin for already installed plugins, or when prerequisites like authentication are needed). The description only states the function without context-specific conditions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_pagesB

List pages available in WordPress.

ParametersJSON Schema
NameRequiredDescriptionDefault
siteNoOptional site alias when managing multiple sites.
statusNo

TDQS

B3.1/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description should disclose behavioral traits like authentication requirements, pagination, or whether it lists all pages. It only states 'list pages' without any additional behavioral context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence with no superfluous content; direct and to the point.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given two parameters and no output schema, the description is too minimal. It does not explain the return format, whether the list is paginated, or any constraints like site filtering.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 50% (site has a description, status does not). The description adds no parameter meaning beyond the schema, leaving the 'status' parameter undocumented.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action (list) and resource (pages), distinguishing it from sibling tools like get_page, create_page, and delete_page.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives such as get_page or list_templates, nor any context about prerequisites or scenarios to prefer this tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_pluginsB

List installed or available plugins.

ParametersJSON Schema
NameRequiredDescriptionDefault
siteNoOptional site alias when managing multiple sites.

TDQS

B3.1/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must disclose behavioral traits. It does not mention side effects (none expected), required permissions, behavior without the optional site parameter, or any limits. The description is too terse to inform about behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise at 5 words, front-loaded with the verb. It earns its place by being direct, but could include a bit more context without becoming verbose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the simple nature of the tool and no output schema, the description should still clarify what 'available' means, whether listing requires prior authentication, and the impact of the optional site parameter. It lacks these details, making it incomplete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The single parameter 'site' is fully documented in the input schema (100% coverage). The description adds no further meaning beyond the schema, resulting in baseline score.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'List' and the resource 'plugins', specifying scope as 'installed or available'. It distinguishes the tool from sibling tools like install_plugin, activate_plugin, etc., which perform actions rather than listing.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives, when not to use it, or preconditions. Agents receive no context for decision-making beyond the basic purpose.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_sitesA

List the WordPress sites configured for this MCP server.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

A3.7/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, and the description only states 'list', implying a read operation. It does not disclose behavioral traits such as authentication requirements, rate limits, or whether results are paginated. Since annotations are absent, the description bears full responsibility but fails to provide sufficient behavioral context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence, concise and front-loaded. It conveys the core functionality without any extraneous information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is simple with no parameters and no output schema. The description covers the purpose but lacks details about the output format or any additional context (e.g., whether sites are listed alphabetically). For a straightforward list tool, this may be sufficient, but it could be more complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so the input schema provides complete information. The description adds no parameter details, but none are needed. With 100% schema coverage, baseline is 3; given no parameters, a score of 4 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states verb 'list' and resource 'WordPress sites configured for this MCP server'. Sibling tools are all specific actions (plugins, pages, templates), so this tool's purpose is distinct and unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit usage guidance provided. While the description implies it should be used to see available sites, there is no mention of when to use this vs alternatives or any prerequisites. However, given its straightforward nature, a lack of guidance is acceptable but not ideal.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_templatesC

List available BeTheme templates.

ParametersJSON Schema
NameRequiredDescriptionDefault
siteNoOptional site alias when managing multiple sites.

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden for behavioral traits. It does not disclose whether results are paginated, the scope of 'available', return format, or any authorization requirements. The description is too sparse to inform safe and effective usage.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, concise sentence. It is front-loaded with the essential action and resource, avoiding unnecessary words. It could be slightly more informative without becoming verbose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is a simple list operation, but the description omits crucial context such as whether results are filtered by the optional 'site' parameter, what properties are returned (IDs, names, etc.), and how it interacts with sibling template tools. The lack of output schema makes the description inadequate for an agent to fully understand the tool's behavior.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% and the parameter 'site' is described inline. The tool description adds no additional semantics beyond the schema, but since baseline is 3 for high coverage, no deduction is made.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'List available BeTheme templates' clearly states the action (list) and the resource (templates in BeTheme). It is specific but does not differentiate from sibling tools like 'get_template' or 'create_template', nor does it mention the optional 'site' parameter for filtering.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives such as 'get_template' (single template) or 'update_template'. The description fails to indicate context or exclude inappropriate use cases.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

publish_pageC

Publish a draft page.

ParametersJSON Schema
NameRequiredDescriptionDefault
idYes
siteNoOptional site alias when managing multiple sites.

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must disclose behavioral traits. It fails to mention what happens after publishing (e.g., status change, visibility), authentication needs, or side effects.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is very concise (5 words) but lacks necessary structure and detail. Every word earns its place, but more content is needed.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the presence of 2 parameters, no output schema, and no annotations, the description is incomplete. It does not explain return values, error conditions, or prerequisites like authentication.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 50% (site param described). The tool description adds no meaning beyond the schema; it doesn't explain the 'id' parameter or how 'site' is used.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Publish a draft page' clearly states the action (publish) and the resource (a draft page). It distinguishes the tool from siblings like list_pages, create_page, etc., which do not involve publishing.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool, such as prerequisites (page must be draft) or alternatives. No exclusions or context are given.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

save_page_builder_payloadC

Persist a BeBuilder payload for a page.

ParametersJSON Schema
NameRequiredDescriptionDefault
idYes
siteNoOptional site alias when managing multiple sites.
builder_payloadYes

TDQS

C2.4/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It fails to disclose behavioral traits such as idempotency, overwrite behavior, authentication requirements, rate limits, or side effects. The word 'persist' implies mutation, but no specifics.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise with a single sentence, but it sacrifices informativeness. It is not front-loaded with key details and fails to earn its place by omitting crucial information for tool usage.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the lack of annotations and output schema, the description is insufficiently complete. It does not address the return value, preconditions, or error scenarios, leaving many gaps for a tool with 3 parameters and mutation behavior.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With only 33% schema description coverage, the description adds no value beyond the schema. It does not explain the 'builder_payload' parameter (structure, format) or the 'id' parameter usage. The 'site' parameter has a description in schema, but the description repeats nothing and provides no additional context.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states 'Persist a BeBuilder payload for a page,' which clearly identifies the action (persist) and the resource (BeBuilder payload for a page). It differentiates from the sibling 'get_page_builder_payload' but does not specify whether 'persist' means create or update, introducing slight ambiguity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives, no prerequisites, and no conditions for when not to use it. A single sentence without any contextual usage hints.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

update_pageC

Update an existing WordPress page.

ParametersJSON Schema
NameRequiredDescriptionDefault
idYes
metaNo
siteNoOptional site alias when managing multiple sites.
titleNo
contentNo
builder_payloadNo

TDQS

C2.5/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations exist, so the description must disclose behavioral traits. It only says 'Update' without explaining whether it patches or replaces, what permissions are required, or any side effects. This lacks critical transparency for a mutation tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is very short and to the point, but it achieves conciseness at the expense of completeness. It could be slightly more detailed without losing brevity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness1/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity (6 parameters, nested objects, no output schema), the description is grossly incomplete. It does not explain return values, behavior, or constraints, making it insufficient for correct tool selection and invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With only 17% schema description coverage (just the site parameter), the description adds no additional meaning to the parameters. It fails to explain the purpose of id, meta, title, content, or builder_payload, leaving the agent to infer from names alone.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Update an existing WordPress page' is clear and uses a specific verb and resource. It distinguishes from sibling tools like create_page, delete_page, and publish_page, but lacks specificity about what fields can be updated.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives such as create_page or publish_page. The description does not mention prerequisites, contexts, or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

update_templateC

Update an existing BeTheme template.

ParametersJSON Schema
NameRequiredDescriptionDefault
idYes
metaNo
siteNoOptional site alias when managing multiple sites.
typeNo
titleNo
contentNo
builder_payloadNo

TDQS

C2.6/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Description lacks disclosure of behavioral traits like partial vs full update, error scenarios, or effects on related data. No annotations compensate.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence, no unnecessary words. Could expand slightly without losing brevity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness1/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema, no error info, 7 parameters with limited description. Incomplete for effective invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Only 1 of 7 parameters ('site') has inline description. The tool description adds no parameter context, leaving agents to infer from schema alone.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states verb 'Update' and resource 'existing BeTheme template', distinguishing it from create/list/get. Could benefit from summarizing updatable fields.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool vs alternatives, prerequisites, or typical use cases.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

  1. 21 tool updatesv0.1.2
    • Addedactivate_plugin
    • Addedauthenticate
    • Addedcreate_page
    • Changedcreate_template1 field changed
      • addedInput schema / properties / site
        Added value: +{
+  "description": "Optional site alias when managing multiple sites.",
+  "type": "string"
+}
    • Addeddeactivate_plugin
    • Addeddelete_page
    • Addedget_capabilities
    • Addedget_page
    • Changedget_page_builder_payload1 field changed
      • addedInput schema / properties / site
        Added value: +{
+  "description": "Optional site alias when managing multiple sites.",
+  "type": "string"
+}
    • Addedget_site_context
    • Changedget_template1 field changed
      • addedInput schema / properties / site
        Added value: +{
+  "description": "Optional site alias when managing multiple sites.",
+  "type": "string"
+}
    • Changedhealth_check1 field changed
      • addedInput schema / properties / site
        Added value: +{
+  "description": "Optional site alias when managing multiple sites.",
+  "type": "string"
+}
    • Addedinstall_plugin
    • Addedlist_pages
    • Changedlist_plugins1 field changed
      • addedInput schema / properties / site
        Added value: +{
+  "description": "Optional site alias when managing multiple sites.",
+  "type": "string"
+}
    • Addedlist_sites
    • Changedlist_templates1 field changed
      • addedInput schema / properties / site
        Added value: +{
+  "description": "Optional site alias when managing multiple sites.",
+  "type": "string"
+}
    • Changedpublish_page1 field changed
      • addedInput schema / properties / site
        Added value: +{
+  "description": "Optional site alias when managing multiple sites.",
+  "type": "string"
+}
    • Changedsave_page_builder_payload1 field changed
      • addedInput schema / properties / site
        Added value: +{
+  "description": "Optional site alias when managing multiple sites.",
+  "type": "string"
+}
    • Changedupdate_page1 field changed
      • addedInput schema / properties / site
        Added value: +{
+  "description": "Optional site alias when managing multiple sites.",
+  "type": "string"
+}
    • Changedupdate_template1 field changed
      • addedInput schema / properties / site
        Added value: +{
+  "description": "Optional site alias when managing multiple sites.",
+  "type": "string"
+}
  2. 9 tool updatesv0.1.1
    • Addedcreate_template
    • Addedget_template
    • Addedhealth_check
    • Addedlist_plugins
    • Addedlist_templates
    • Addedpublish_page
    • Addedsave_page_builder_payload
    • Addedupdate_page
    • Addedupdate_template
  3. 1 tool updatev0.1.0
    • First observedget_page_builder_payload
Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3.2/5.0
Disambiguation5/5

Each tool targets a distinct function: health check, page operations (update, publish, payload get/save), template CRUD (list, get, create, update), and plugin listing. No overlapping purposes.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern in snake_case (e.g., update_page, list_templates). The health_check name is a slight deviation but standard for its purpose.

Tool Count5/5

With 10 tools, the server covers its declared scope of managing BeTheme pages, templates, and plugins without being excessive or insufficient.

Completeness3/5

Missing some lifecycle operations: no create_page, no delete tools for pages or templates, and plugins only support listing. Core workflows are covered but notable gaps exist.

Maintenance

ActivitySlowing
ResponsivenessNo issues

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/zacdreyer/wp-betheme-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server