A WordPress plugin that extends the WordPress MCP Adapter to expose Elementor data, widgets, and page design tools as MCP (Model Context Protocol) tools. This enables AI agents like Claude, Cursor, and other MCP-compatible clients to create and manipulate Elementor page designs programmatically.

Introducing EMCP Pro! 25% Discount for GitHub Community: MSRGIT

Grab the Deal

Features

• New in v3.3.0: five "intelligence, not just transport" features that let an AI agent understand, undo, and reuse your site, plus a big community contribution:
  • Page Snapshot (get-page-snapshot), one normalized digest of a page (structure, tokens-in-use, responsive overrides, content outline, SEO-lite, + opt-in performance/a11y/SEO audits) so the AI reasons about a page in a single call
  • Change History & Rollback (list-changes / get-change / rollback-change), every AI-made Elementor/filesystem/database change is recorded to one ledger and can be undone, from MCP and a new History admin tab
  • Content Search (search-content / reindex-search), find the site's own pages, templates, widgets, and global styles by natural-language query so the AI reuses existing work instead of rebuilding it
  • Content Mirror (export-content / restore-content / list-content-exports), export page/template content to git-trackable JSON files for external version control
  • Navigation Menus (menu-read / menu-write + [emcp_menu] shortcode), full WordPress nav-menu management over MCP (community-contributed)
  • Multi-site proxy (@msrbuilds/emcp-proxy 1.9.0), drive many WordPress installs from one connection with a site registry and emcp_use_site
• A focused MCP toolset covering the full Elementor page-building workflow, and, since v3.0.0, growing beyond Elementor into general WordPress management across many domains: content, nav menus, settings, plugins & themes, media library, users, performance, filesystem, and database. The 62 per-widget tools are folded into a catalog-backed model, so the active surface stays small, every widget is still reachable via discover → inspect → act. Counts scale with your environment (registered counts; v3.3.0 adds 11 always-on tools over the live-verified 4.1.4 baseline):
  • 128 tools: free Elementor only (104 active by default)
  • 142 tools: free Elementor + Elementor 4.0 atomic elements (118 active)
  • 138 tools: with Elementor Pro (99 active)
  • 152 tools: with Elementor Pro + Elementor 4.0 (113 active; + WooCommerce adds no new tools)
  • +2 ACF tools when Advanced Custom Fields (free or PRO) is active, acf-read and acf-write, two dispatchers exposing 15 ACF operations (8 read, 7 write; the Custom-Post-Type/taxonomy operations need ACF 6.1+). Each dispatcher is a single toggle under Tools → Plugins → ACF (listing the operations it covers); acf-read is on by default, acf-write ships off (v3.2.1)
  • +2 Meta Box tools when Meta Box (free core) is active, metabox-read and metabox-write, two dispatchers exposing 4 Meta Box operations (3 read, 1 write). Each dispatcher is a single toggle under Tools → Plugins → Meta Box (listing the operations it covers); metabox-read is on by default, metabox-write ships off (v3.4.2)
  • +2 WooCommerce tools (Pro) when WooCommerce is active, woo-read and woo-write, two dispatchers over the full wc/v3 surface (~120 operations). Single toggle each under Tools → Plugins → WooCommerce; woo-read on by default, woo-write ships off; refunds/deletes/batch require confirm:true (v3.4.2)
  • 39 of these ship disabled-by-default (SEO & Accessibility, Widget Builder, PHP Snippets, the 9 Plugins & Themes write tools, delete-media, the 2 Users write tools, the 3 Filesystem write tools, and the 3 Database write tools), plus the 7 ACF write operations are off by default within acf-write, so the typical active surface is smaller until you opt in on the Tools tab
• WordPress Content (beyond Elementor): Create and manage posts, pages, and any custom post type, content, status, taxonomy terms, custom fields, and featured images, via MCP, without touching Elementor data. Built on WP core; every post carries an is_elementor flag that steers agents to the Elementor tools for builder pages
• WordPress Settings (beyond Elementor, domain 2): Read and batch-update core WordPress settings (general/reading/writing/discussion/media/permalinks) over MCP. Curated allowlist only, no arbitrary option access; admin_email is read-only; permalink changes auto-flush rewrite rules. manage_options. (v3.0.0)
• Plugins & Themes (beyond Elementor, domain 3): Discover, install (wordpress.org only), update, activate/deactivate, and delete plugins and themes over MCP. Strong guardrails (EMCP Tools + Elementor protected; per-op capability gating; direct-filesystem-only); the 9 mutation tools ship disabled-by-default. manage_options-class capabilities. (v3.0.0)
• Media Library (beyond Elementor, domain 4): Fetch full attachment detail (get-media: every registered size, dimensions, metadata, alt/caption/description), edit metadata (update-media: alt text, title, caption, description, a one-call accessibility/SEO fix), and delete attachments (delete-media: destructive and effectively permanent; disabled-by-default and requires confirm:true). URL uploads continue via sideload-image. (v3.0.0)
• Users (beyond Elementor, domain 5): List and read WordPress users, and safely create/edit non-admin profiles over MCP. Hard guardrails: no delete-user and no role-change tool; create-user assigns only non-admin roles and auto-generates a strong password (emailed to the new user, never returned); update-user edits profile fields only and refuses any user with admin-level capabilities (administrators are off-limits). list-users/get-user are enabled by default; create-user/update-user are disabled-by-default. (v3.0.0)
• ACF / ACF PRO (beyond Elementor): Read and write Advanced Custom Fields values on posts and options pages, discover and author field groups, and register ACF-managed Custom Post Types and taxonomies (ACF 6.1+), enough to stand up a full content structure end-to-end (CPT → taxonomy → field group → posts with values). Full Pro field support: repeaters, flexible content (layout-validated), galleries, groups, and clones round-trip as nested JSON. Only registers when ACF is active; writes resolve field names to keys, ship disabled-by-default, and there is deliberately no delete and no slug/field rename (renames orphan stored content). (v3.2.1)
• Meta Box: Read/write Meta Box custom-field values and discover field groups. Only registers when Meta Box is active; metabox-read is on by default, metabox-write ships disabled-by-default (values only, no delete, and unknown fields are skipped rather than created). (v3.4.2)
• WooCommerce (Pro): Two dispatcher tools (woo-read / woo-write) over the full WooCommerce wc/v3 surface (~120 operations): products (+ variations, categories, tags, attributes, reviews), orders (+ notes, refunds), customers, coupons, reports, settings, payment gateways, shipping, taxes, webhooks, and system status. Runs through WooCommerce's own REST controllers (HPOS-safe, no privilege escalation). Only registers when WooCommerce is active; woo-read is on by default, woo-write ships disabled-by-default, and money/irreversible operations (refunds, deletes, batch) additionally require confirm:true. (v3.4.2)
• Forms, 8 form builders: Two dispatcher tools per plugin (read/write) for Contact Form 7 (free) plus WPForms, Gravity Forms, Fluent Forms, Ninja Forms, Formidable, MetForm, and SureForms (Pro). Read forms, fields, notifications and entries (submissions); manage entries. Each pair registers only when its plugin is active; reads on by default, writes disabled-by-default, and delete-entry requires confirm:true. CF7 has no entries (it stores none); WPForms entry operations require WPForms Pro. Grouped under Tools → Plugins → Forms. (v3.5.0)
• SEO, 7 SEO plugins: Two dispatcher tools per plugin (read/write) for Slim SEO (free) plus Yoast, Rank Math, All in One SEO, SEOPress, The SEO Framework, and SureRank (Pro). Read and write the SEO metadata each plugin stores, title, description, canonical, robots (noindex/nofollow), focus keyword, Open Graph / Twitter, for posts and terms over one unified field vocabulary (the adapter translates to each plugin's own encoding), plus schema-read where supported. Distinct from the Pro SEO & Accessibility toolkit (which audits/generates). Grouped under Tools → Plugins → SEO. (v3.5.0)
• Performance & Security (beyond Elementor, domain 6): Two read-only diagnostics. analyze-performance audits server config, WordPress internals (database size, autoloaded options, post revisions, cron backlog, persistent object cache, OPcache, plugin count), and a target page (defaults to the frontpage; optional url/post_id) for performance bottlenecks. scan-security: the security counterpart, scans across malware heuristics (eval/base64 obfuscation, request-driven execution, command execution, webshells, encoded blobs, executable PHP under uploads), WordPress core-file integrity (against the official wordpress.org checksums), hardening (file editing, debug output, admin username, XML-RPC, version disclosure, HTTPS, security headers), and outdated/abandoned software. Both return a scored report (0-100 + A–F grade) with severity-tagged findings and ranked recommendations; the malware walk is bounded and never returns full file contents (path:line + snippet only). Read-only, self-contained (no external API beyond optional, graceful wordpress.org calls), enabled by default. (v3.0.0)
• Filesystem (beyond Elementor): Read and scan any file inside the WordPress install (read-file, list-directory, search-files, enabled by default). Modify and delete files (write-file, edit-file, delete-file) are disabled-by-default: every path is confined to ABSPATH (no traversal/symlink escape), writes auto-back up the original, wp-config.php/.htaccess are refused, the edit_files capability is enforced (honoring DISALLOW_FILE_EDIT), and all writes are audit-logged. delete-file requires confirm:true. manage_options. (v3.0.0)
• Database (beyond Elementor): Inspect the database with flexible read-only SQL (list-tables, describe-table, query, SELECT/SHOW/DESCRIBE/EXPLAIN only; writes, DDL, stacked statements, MySQL /*! executable comments, and file-access SQL are rejected; results capped; enabled by default). Structured parameterized writes (insert-row, update-rows, delete-rows) are disabled-by-default: uses $wpdb throughout (no raw write-SQL/DDL), forces a non-empty WHERE on update/delete, refuses wp_users/wp_usermeta, captures a before-image snapshot to an audit log, and delete-rows requires confirm:true. manage_options. (v3.0.0)
• Query & Discovery: List widgets, inspect page structures, read element settings, browse templates, view global design tokens
• Page Management: Create pages, update settings, clear content, import/export templates
• Layout Tools: Add flexbox containers, move/remove/duplicate elements, update containers, find elements, batch update, reorder children, get container schema
• Widget Tools: A catalog-backed model: list-widgets (filter by tier/category/search) → get-widget-schema (curated params, batch, or full raw schema) → add-free-widget / add-pro-widget (with Pro) → update-widget. The 62 widgets' curated params live in a built-in catalog (27 free / 30 Pro / 5 WooCommerce), so every widget and parameter stays reachable while the per-turn tool-list cost drops ~10×
• Pro Widget Support: Conditional tools for nav menu, loop grid, loop carousel, media carousel, nested tabs, nested accordion, portfolio, author box, login, code highlight, reviews, off-canvas, progress tracker, search, and more (only register when Elementor Pro is active)
• Atomic Elements (Elementor 4.0+): 13 dedicated tools for Elementor's atomic system: flexbox, div-block, heading, paragraph, button, image, svg, youtube, video, divider, plus universal add-atomic-widget / update-atomic-widget and detect-elementor-version
• Theme Builder: Create theme templates (header/footer/single/archive), set display conditions (Pro)
• Dynamic Tags: List all available dynamic tags, bind dynamic data to element settings (Pro)
• Popup Builder: Create popup templates, configure triggers/conditions/timing (Pro)
• Template Tools: Save pages or elements as reusable templates, apply templates to pages
• Global Settings: Update site-wide color palettes and typography presets
• Brand Kits: One-click coordinated color + typography kits. Apply a curated brand kit and the whole site re-skins (system tokens + Theme Style defaults); back up and restore any time. 10 kits are free to apply; the full 50-kit library and the apply-brand-kit MCP tool are Pro
• AI Widget Builder (Pro): Let an AI agent design custom Elementor widgets from a structured spec, no hand-written PHP. The plugin compiles the spec + an HTML template into a sandboxed Widget_Base class (35 control types, optional per-widget CSS/JS) that appears under a "Custom (EMCP)" category in the editor; a runtime safety net keeps a bad widget from breaking the editor
• Composite Tools: Build a complete page from a declarative JSON structure in a single call
• Stock Images: Search Unsplash, Pexels & Pixabay for stock photos, sideload into Media Library, add to pages
• SVG Icons: Upload SVG icons from URL or raw markup for use with Elementor icon widgets
• Custom Code: Add custom CSS (element/page level), inject JavaScript, create site-wide code snippets for head/body injection
• Low-tools Mode: One-click toggle that filters the active tool list to a curated essentials set, for MCP clients with strict tool caps (Antigravity, Gemini API, etc.). After the v3.0.0 widget consolidation the active count already fits most caps, so this is rarely needed now
• Admin Dashboard: Dedicated top-level EMCP Tools menu with Dashboard / Modules / Tools / Connection / Prompts / Templates / Brand Kits / Skills / Sandbox / History / Changelog tabs. Toggle individual tools on/off, view connection configs for all supported MCP clients, review and roll back AI-made changes on the History tab, and reach the Get Support portal from any tab

Requirements

Installation

1. Install and activate Elementor (version 3.20+).
2. Download the latest release zip from the Releases page.
3. In WordPress, go to Plugins > Add New > Upload Plugin and upload the downloaded zip file.
4. Activate the plugin through the Plugins menu in WordPress. The WordPress MCP Adapter is bundled: no separate install needed (WordPress 6.9+/7.0 already includes the Abilities API).
5. Open the new EMCP Tools top-level menu in the WordPress admin sidebar to configure tools and view connection info.

Connecting to the MCP Server

The MCP server lives at https://your-site.com/wp-json/mcp/emcp-tools-server (WP-CLI: --server=emcp-tools-server). You can connect any MCP client to it with a WordPress Application Password.

Recommended: the in-admin Connection manager

The fastest path is the built-in EMCP Tools → Connection screen. It walks you through it: toggle the server on, generate an Application Password in one click, then pick your AI client: and only the options that fit that client appear, tailored and ready to copy:

• Claude Desktop: a one-click .mcpb bundle. Download it, double-click to install, done, no config files to edit. The bundle is fully self-contained: it ships a single server/index.js (the proxy compiled to CommonJS with your site URL + a fresh Application Password embedded) that runs on Claude Desktop's built-in Node.js: no npx, no separate Node install, no PATH setup. (The .mcpb contains a live credential, delete it after importing.)
• Claude Code / Cursor / VS Code / Antigravity: ready-to-paste JSON (HTTP) or a terminal command, generated with your endpoint and credentials filled in.
• Any client: a copy-paste AI setup prompt that tells the agent how to wire itself up, or the raw manual JSON.

The same screen includes a one-click authentication test (confirms a client can actually connect and flags a host that strips the Authorization header) and a Context page where you write site-wide guidance delivered to every connecting agent as the server's MCP instructions.

Manual configuration

Prefer to wire it up by hand? Create an Application Password at Users → Profile → Application Passwords, base64-encode username:app-password (echo -n "username:app-password" | base64), and point your client at https://your-site.com/wp-json/mcp/emcp-tools-server.

Claude Code

Add as .mcp.json in your project root:

{
    "mcpServers": {
        "emcp-tools": {
            "type": "http",
            "url": "https://your-site.com/wp-json/mcp/emcp-tools-server",
            "headers": {
                "Authorization": "Basic BASE64_ENCODED_CREDENTIALS"
            }
        }
    }
}

Claude Desktop

Add to claude_desktop_config.json (%APPDATA%\Claude\ on Windows, ~/Library/Application Support/Claude/ on macOS):

{
    "mcpServers": {
        "emcp-tools": {
            "type": "http",
            "url": "https://your-site.com/wp-json/mcp/emcp-tools-server",
            "headers": {
                "Authorization": "Basic BASE64_ENCODED_CREDENTIALS"
            }
        }
    }
}

Cursor

Add to .cursor/mcp.json in your project root, or ~/.cursor/mcp.json for global config:

{
    "mcpServers": {
        "emcp-tools": {
            "url": "https://your-site.com/wp-json/mcp/emcp-tools-server",
            "headers": {
                "Authorization": "Basic BASE64_ENCODED_CREDENTIALS"
            }
        }
    }
}

Windsurf

Add to ~/.codeium/windsurf/mcp_config.json:

{
    "mcpServers": {
        "emcp-tools": {
            "serverUrl": "https://your-site.com/wp-json/mcp/emcp-tools-server",
            "headers": {
                "Authorization": "Basic BASE64_ENCODED_CREDENTIALS"
            }
        }
    }
}

Antigravity

Add to ~/.gemini/antigravity/mcp_config.json:

{
    "mcpServers": {
        "emcp-tools": {
            "serverUrl": "https://your-site.com/wp-json/mcp/emcp-tools-server",
            "headers": {
                "Authorization": "Basic BASE64_ENCODED_CREDENTIALS"
            }
        }
    }
}

WP-CLI stdio (local development)

For local development with WP-CLI available, you can use the stdio transport (no HTTP auth needed):

{
    "mcpServers": {
        "emcp-tools": {
            "type": "stdio",
            "command": "wp",
            "args": [
                "mcp-adapter", "serve",
                "--server=emcp-tools-server",
                "--user=admin",
                "--path=/path/to/wordpress"
            ]
        }
    }
}

Node.js proxy (remote sites or protocol compatibility)

For remote WordPress sites, environments without WP-CLI, or when your AI client needs a different MCP protocol version, use the Node.js proxy. Your AI client launches it as a local subprocess, so it must run on the machine with the client, not on the WordPress server. On shared hosting you have no local access to the plugin directory, so use one of the two methods below.

Recommended, npx runner (nothing to install or keep in sync):

{
    "mcpServers": {
        "emcp-tools": {
            "type": "stdio",
            "command": "npx",
            "args": ["-y", "@msrbuilds/emcp-proxy@latest"],
            "env": {
                "WP_URL": "https://your-site.com",
                "WP_USERNAME": "admin",
                "WP_APP_PASSWORD": "xxxx xxxx xxxx xxxx xxxx xxxx",
                "MCP_PROTOCOL_VERSION": "2024-11-05"
            }
        }
    }
}

npx fetches the latest proxy on each launch, so there is no local copy to drift from the plugin version. Requires Node.js 18+ on the client machine.

Alternative, local copy of the proxy file:

Extract bin/mcp-proxy.mjs from the plugin ZIP, save it anywhere on the machine running your AI client, and point args at that local path (e.g. ["C:\\local\\path\\to\\mcp-proxy.mjs"]), not at the copy inside wp-content/plugins/... on the server. Re-extract it after plugin updates to pick up proxy fixes.

Optional environment variables:

Testing with MCP Inspector

npx @modelcontextprotocol/inspector wp mcp-adapter serve \
  --server=emcp-tools-server --user=admin --path=/path/to/wordpress

Available Tools

Query & Discovery (7 tools)

WordPress Content, beyond Elementor (8 tools, v3.0.0)

General WordPress content management over MCP, built on WordPress core, these tools never touch Elementor data. Every returned post carries an is_elementor flag so an agent knows to switch to the Elementor tools for builder pages. Enabled by default; capability-gated. Featured image and custom-field meta are parameters of create/update.

WordPress core's read-only context abilities (core/get-site-info, core/get-user-info, core/get-environment-info) are also surfaced on the EMCP server.

WordPress Settings, beyond Elementor, domain 2 (2 tools, v3.0.0)

Core WordPress settings management over MCP, curated allowlist of general/reading/writing/discussion/media/permalink settings. get-settings doubles as discovery (returns each setting's type, label, enum options, and writable flag). update-settings batch-writes allowlisted keys and reports rejects in skipped[] without aborting the batch; permalink changes auto-flush rewrite rules. Both require manage_options. Safety: curated allowlist only, no arbitrary option access; siteurl/home and users_can_register/default_role are excluded; admin_email is read-only.

WordPress Plugins & Themes, beyond Elementor, domain 3 (13 tools, v3.0.0)

Discover and manage WordPress plugins and themes over MCP, built on WP core upgrader APIs. Installs are wordpress.org-only (by slug; no arbitrary URLs). Guardrails: EMCP Tools and Elementor can never be deactivated or deleted; the active plugin/theme is protected from deletion; install/update/delete require a directly-writable filesystem (clear error instead of an FTP hang). The 4 read/search tools are enabled by default; the 9 mutation tools ship disabled-by-default (admin opts in on the Tools tab).

WordPress Media Library, beyond Elementor, domain 4 (3 tools, v3.0.0)

Manage existing Media Library attachments over MCP, built on WP core attachment functions. get-media and update-media are enabled by default; delete-media ships disabled-by-default and additionally requires an explicit confirm:true (destructive and effectively permanent, WordPress bypasses Trash for media unless MEDIA_TRASH is defined). URL uploads continue to use the existing sideload-image.

WordPress Users, beyond Elementor, domain 5 (4 tools, v3.0.0)

Safe user management over MCP, built on WP core user functions (WP_User_Query, wp_insert_user, wp_update_user). Guardrails: create-user only assigns non-admin roles and auto-generates a strong password (emailed to the new user via wp_send_new_user_notifications, the password is never returned); update-user edits profile fields only (no role or password changes) and refuses any user whose capabilities include manage_options, promote_users, edit_users, delete_users, or manage_network. There is deliberately no delete-user and no role-change tool. list-users/get-user are enabled by default (list_users cap); create-user/update-user ship disabled-by-default (admin opts in on the Tools tab).

ACF (Advanced Custom Fields), beyond Elementor (2 dispatcher tools / 15 operations, v3.2.1)

Read and write ACF field values, discover and author field groups, and register ACF-managed Custom Post Types and taxonomies over MCP, built on the public ACF API (acf_get_field_groups, get_field, update_field, acf_import_field_group, acf_import_post_type, acf_import_taxonomy). To keep the MCP tool-list small, the domain is exposed as 2 dispatcher tools: acf-read and acf-write, each covering the operations of its kind. Call either with no operation to list its operations (the discovery catalog), then again with { operation, arguments }. The dispatchers only register when ACF (free or PRO) is active; Pro-only capabilities (options pages; repeater / flexible content / gallery / clone fields) degrade gracefully on free ACF, and the CPT/taxonomy operations are available only on ACF 6.1+. Writes always resolve field names to field keys first (writing by name silently fails on posts with no stored value), and complex Pro fields round-trip as nested JSON arrays. Deliberately conservative authoring: no delete operations, fields can never be removed, and a field's name/key/type, or a post type / taxonomy slug, can never change (renames orphan stored content). Code-registered field groups (acf-json / PHP) are listed with a local flag and refused by the group editor; the CPT/taxonomy read operations list only the ACF-managed ones. Each dispatcher is a single toggle under Tools → Plugins → ACF (listing the operations it covers): acf-read is enabled by default, acf-write ships disabled-by-default. Every operation keeps its original capability check, enforced per call by the dispatcher.

Field values, field groups & options pages:

Custom Post Types & Taxonomies (ACF 6.1+):

Meta Box, beyond Elementor (2 dispatcher tools, v3.4.2)

Read and write Meta Box custom-field values and discover its field groups over MCP. Only registers when Meta Box is active.

WordPress Performance & Security, beyond Elementor, domain 6 (2 tools, v3.0.0)

Two read-only diagnostics over MCP, both self-contained (the only off-site calls are to wordpress.org, optional and graceful offline). Both return a scored report (0-100 + A–F grade) with severity-tagged findings and ranked recommendations. manage_options; enabled by default.

Filesystem, beyond Elementor (6 tools, v3.0.0)

Read and scan any file inside the WordPress installation, core, plugins, themes, uploads, confined to ABSPATH (no traversal or symlink escape). The 3 read tools are enabled by default; the 3 write/delete tools ship disabled-by-default and require the edit_files capability (honoring DISALLOW_FILE_EDIT). Writes auto-back up the original file; wp-config.php and .htaccess are refused by all write/delete tools; every mutation is audit-logged. manage_options.

Database, beyond Elementor (6 tools, v3.0.0)

Inspect and manage the WordPress database over MCP. The 3 read tools are enabled by default; the 3 write tools ship disabled-by-default and use $wpdb (no raw write-SQL, so no DDL). Writes force a non-empty WHERE clause on update/delete, refuse wp_users/wp_usermeta, snapshot a before-image into an audit log, and delete-rows requires an explicit `confi