Performance Engineer MCP
Detects Astro CMS through fingerprinting and provides platform-specific recommendations.
Analyzes Cloudflare configuration including cache status, Brotli, HTTP/3, Early Hints, and Polish; generates Cloudflare Cache Rules and Transform Rules.
Generates WP Rocket configuration settings optimized for Elementor-based WordPress sites.
Analyzes Google Fonts usage and provides recommendations for preconnect, font-display, WOFF2 format, and preload hints.
Detects Hotjar as a third-party script and provides recommendations for optimizing its impact on performance.
Runs Lighthouse audits via local Chromium to generate performance scores and Core Web Vitals lab data.
Detects Next.js CMS through fingerprinting and provides platform-specific recommendations.
Detects Nuxt CMS through fingerprinting and provides platform-specific recommendations.
Retrieves real-user Core Web Vitals data from the PageSpeed Insights API (CrUX), with fallback to Lighthouse data.
Detects Shopify CMS through fingerprinting and provides platform-specific recommendations.
Detects Squarespace CMS through fingerprinting and provides platform-specific recommendations.
Detects Webflow CMS through fingerprinting and provides platform-specific recommendations.
Detects Wix CMS through fingerprinting and provides platform-specific recommendations.
Detects WooCommerce plugins during WordPress audit and generates WP Rocket configuration with WooCommerce awareness.
Performs deep WordPress audits including fingerprinting of 20+ plugins and generates WP Rocket configuration.
Generates WP Rocket configuration JSON with awareness of Elementor and WooCommerce plugins.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Performance Engineer MCP Run a full performance audit on https://example.com"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Performance Engineer MCP
An MCP server that analyzes websites like a senior performance engineer and produces prioritized Core Web Vitals recommendations.
Connect it to Claude Desktop and ask things like:
"Analyze the performance of https://example.com"
"Give me a visual performance report for https://example.com"
"Give me a pagespeed document report for https://example.com"
"Generate a WP Rocket config for my WordPress site"
"Compare these two performance reports and tell me what improved"
Tools (18)
# | Tool | What it does |
1 |
| Full orchestrator — runs all analyzers and returns prioritized recommendations |
2 |
| Lighthouse audit (scores + CWV lab data) via local Chromium |
3 |
| CrUX real-user field data via PageSpeed Insights API (falls back to Lighthouse) |
4 |
| Compression, caching, CDN detection, security headers |
5 |
| Render-blocking resources, meta tags, script loading strategy |
6 |
| Fingerprints WordPress, Shopify, Next.js, Nuxt, Astro, Webflow, Wix, Squarespace |
7 |
| Oversized images, wrong formats, missing lazy load, LCP candidate |
8 |
| Unused CSS via Playwright coverage, render-blocking stylesheets |
9 |
| Unused JS, third-party scripts (GA4, GTM, Pixel, Hotjar), render-blocking |
10 |
| Google Fonts preconnect, font-display, WOFF2 format, preload hints |
11 |
| Deep WordPress audit — 20+ plugin fingerprints, plugin-level recommendations |
12 |
| Cache status, Brotli, HTTP/3, Early Hints, Polish |
13 |
| Narrative Markdown report with scores, CWV, and prioritized fixes |
14 |
| Self-contained HTML dashboard — score cards, CWV grid, LCP bar chart, recommendations. Works for any CMS. Rendered as a visual Artifact in Claude. |
15 |
| Full Word document (.docx) saved to |
16 |
| WP Rocket settings JSON with Elementor/WooCommerce awareness |
17 |
| Cache Rules, Transform Rules, and settings guide |
18 |
| Before/after delta from two |
Related MCP server: Marketing Master – Landing Page Evaluator
Requirements
Node.js 22+
Claude Desktop
Installation
git clone https://github.com/YOUR_USERNAME/performance-engineer-mcp.git
cd performance-engineer-mcp
npm install # also downloads Playwright Chromium (~300MB)
npm run buildOptional: Google PageSpeed Insights API key
Without a key, get_core_web_vitals returns Lighthouse lab data. With a key it returns real-user CrUX field data (p75 from actual Chrome users).
cp .env.example .env
# Edit .env and add your key — get one free at:
# https://developers.google.com/speed/docs/insights/v5/get-startedConnect to Claude Desktop
Add to your claude_desktop_config.json:
Windows: %APPDATA%\Claude\claude_desktop_config.json
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
{
"mcpServers": {
"performance": {
"command": "node",
"args": ["/absolute/path/to/performance-engineer-mcp/dist/server.js"]
}
}
}Restart Claude Desktop after saving.
Usage examples
analyze_website { "url": "https://example.com" }
run_lighthouse { "url": "https://example.com", "strategy": "mobile" }
get_core_web_vitals { "url": "https://example.com" }
wordpress_inspector { "url": "https://my-wp-site.com" }
generate_report { "url": "https://example.com" }
# Visual HTML dashboard (rendered as an Artifact in Claude)
generate_report_html { "url": "https://example.com" }
# Word document saved to ~/Downloads/
generate_report_docx { "url": "https://example.com" }
generate_wp_rocket_config { "url": "https://my-wp-site.com" }
generate_cloudflare_rules { "url": "https://example.com" }
compare_performance {
"before_report": "<JSON from first analyze_website>",
"after_report": "<JSON from second analyze_website>"
}Development
npm run dev # watch mode
npm test # vitest unit tests
npm run build # compile TypeScript → dist/Architecture
src/
├── server.ts # MCP entry point — registers all 18 tools
├── types.ts # TypeScript interfaces
├── browser.ts # Playwright Chromium singleton
└── tools/
├── lighthouse.ts # run_lighthouse
├── pagespeed.ts # get_core_web_vitals
├── headers.ts # analyze_headers
├── html.ts # analyze_html
├── cms.ts # detect_cms
├── images.ts # analyze_images
├── css.ts # analyze_css
├── javascript.ts # analyze_javascript
├── fonts.ts # analyze_fonts
├── platform.ts # CMS dispatcher
├── wordpress.ts # wordpress_inspector
├── cloudflare.ts # cloudflare_inspector
├── report.ts # generate_report (Markdown)
├── report-html.ts # generate_report_html (visual HTML Artifact)
├── report-docx.ts # generate_report_docx (Word document → Downloads/)
├── wp-rocket.ts # generate_wp_rocket_config
├── cloudflare-rules.ts # generate_cloudflare_rules
├── compare.ts # compare_performance
└── recommendations.ts # generate_recommendations + analyze_websiteLicense
MIT
Available Tools
16 toolsanalyze_cssA
Use Playwright CSS coverage to find unused CSS, render-blocking stylesheets, and large framework bundles (Bootstrap, Tailwind). Reports per-stylesheet usage percentages and critical CSS opportunities.
Inputs: url (required).
analyze_fontsB
Check font loading strategy: Google Fonts preconnect, CSS @import anti-pattern, font-display values, WOFF2 format usage, and preload hints for self-hosted fonts.
Inputs: url (required).
analyze_headersA
Inspect HTTP response headers: compression (Brotli/gzip), caching, CDN detection, security headers, and HTTP/2 support.
Inputs: url (required).
analyze_htmlA
Parse the HTML of a page and check for render-blocking resources, missing meta tags, script loading strategy, and head optimizations.
Inputs: url (required).
analyze_imagesA
Scan all images on a page: detect oversized images, wrong formats (PNG/JPEG instead of AVIF/WebP), missing lazy loading, missing width/height attributes, and the LCP hero candidate that should be preloaded.
Inputs: url (required).
analyze_javascriptA
Use Playwright JS coverage to find unused JavaScript, render-blocking scripts, large bundles, and third-party scripts (GA4, GTM, Facebook Pixel, Hotjar, etc.) with their impact on load time.
Inputs: url (required).
analyze_websiteA
Full performance analysis: runs Lighthouse, PageSpeed Insights, header check, HTML audit, and CMS detection, then returns a prioritized list of Core Web Vitals improvements.
Inputs: url (required).
cloudflare_inspectorB
Detect Cloudflare and audit cache status, Brotli compression, HTTP/3, Early Hints, and Polish image optimization. Generates ready-to-use Cloudflare Cache Rules, Transform Rules, and setting recommendations.
Inputs: url (required).
compare_performanceA
Compare two analyze_website JSON reports (before and after a change) and return a delta report: Lighthouse score changes, Core Web Vitals improvements/regressions, newly introduced issues, and resolved issues. Pass the raw JSON output from two separate analyze_website calls.
Inputs: after_report (required), before_report (required).
detect_cmsA
Fingerprint the CMS and hosting platform of a website (WordPress, Shopify, Next.js, Nuxt, Astro, etc.).
Inputs: url (required).
generate_cloudflare_rulesA
Generate ready-to-implement Cloudflare Cache Rules, Transform Rules, and recommended settings for a domain. Includes CMS-aware cache bypass rules (WordPress admin, WooCommerce cart, Shopify checkout), security header injection, and static asset caching.
Inputs: url (required).
generate_reportA
Run a full performance analysis and return a human-readable Markdown report with Lighthouse scores, Core Web Vitals, platform detection, and prioritized recommendations. Use this when you need a shareable, narrative summary instead of raw JSON.
Inputs: url (required).
generate_wp_rocket_configA
Analyze a WordPress site and generate a recommended WP Rocket settings configuration. Accounts for detected page builders (Elementor, Divi), WooCommerce, cache conflicts, and third-party scripts. Returns a JSON settings object with rationale and warnings.
Inputs: url (required).
get_core_web_vitalsA
Fetch Core Web Vitals from Google PageSpeed Insights API (real-user CrUX field data when API key is set, Lighthouse lab data otherwise). Returns LCP, CLS, INP, FCP, TTFB.
Inputs: url (required), strategy.
run_lighthouseA
Run a Lighthouse audit against a URL for mobile or desktop and return scores, Core Web Vitals lab data, and improvement opportunities.
Inputs: url (required), strategy.
wordpress_inspectorA
Deep WordPress audit: detects 20+ plugins (Elementor, Divi, WooCommerce, WP Rocket, LiteSpeed Cache, NitroPack, Perfmatters, FlyingPress, Yoast, RankMath, and more) and generates plugin-specific recommendations with estimated LCP impact. Only useful on WordPress sites.
Inputs: url (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 16 tools
Most tools have distinct purposes, but there is some overlap: 'analyze_website' already includes Lighthouse and header checks, which are also available as separate tools ('run_lighthouse', 'analyze_headers'). This could cause confusion on which tool to use for a specific analysis.
The naming conventions are mixed: 'analyze_*' for detailed audits, 'generate_*' for config generation, 'detect_cms', 'get_core_web_vitals', 'run_lighthouse', and 'cloudflare_inspector' without a verb prefix. While each is descriptive, the lack of a consistent pattern may reduce predictability.
With 16 tools, it is slightly above the typical 3-15 range, but the number is justified by the comprehensive coverage of web performance auditing. Each tool serves a specific optimization area, so the count is appropriate.
The server covers most major aspects of front-end and CDN performance analysis (CSS, JS, images, fonts, headers, CMS, Cloudflare, Core Web Vitals, Lighthouse). While server-side metrics are missing, that is outside the stated scope.
Maintenance
Related MCP Connectors
Lighthouse scores, Core Web Vitals (LCP, CLS, INP/TBT) and top fixes for any URL, mobile or desktop.
Website performance monitoring: scans, Core Web Vitals, RUM data and alerts.
Google PageSpeed Insights (Lighthouse) scores, Core Web Vitals and top speed fixes for every URL...
Professional SEO auditing: 15 tools, 9 checks, CWV, E-E-A-T, schema, GEO. Free tier.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables AI models to perform Google Lighthouse website performance analysis, including Core Web Vitals, accessibility, SEO audits, and actionable optimization recommendations. Provides comprehensive web performance insights through natural language interactions.4MIT
- AlicenseNot gradedqualityDmaintenanceEnables rapid analysis of landing pages for SEO compliance, conversion structure, color contrast accessibility, and performance metrics with automated optimization suggestions and code snippets.1MIT
- AlicenseAqualityDmaintenanceCore Web Vitals analysis powered by Lighthouse. Four tools: analyze a URL, compare two URLs, check against thresholds, or crawl an entire site. Works with Claude Code, Cursor, Windsurf, and any MCP-compatible AI tool.414 npmMIT
- AlicenseAqualityBmaintenanceEnables AI agents to monitor website performance by scanning sites, retrieving Core Web Vitals, detecting regressions, and receiving AI-powered optimization recommendations.1159 npmMIT