Skip to main content
Glama
Performance Engineer MCP

Performance Engineer MCP

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

analyze_website

Full orchestrator — runs all analyzers and returns prioritized recommendations

2

run_lighthouse

Lighthouse audit (scores + CWV lab data) via local Chromium

3

get_core_web_vitals

CrUX real-user field data via PageSpeed Insights API (falls back to Lighthouse)

4

analyze_headers

Compression, caching, CDN detection, security headers

5

analyze_html

Render-blocking resources, meta tags, script loading strategy

6

detect_cms

Fingerprints WordPress, Shopify, Next.js, Nuxt, Astro, Webflow, Wix, Squarespace

7

analyze_images

Oversized images, wrong formats, missing lazy load, LCP candidate

8

analyze_css

Unused CSS via Playwright coverage, render-blocking stylesheets

9

analyze_javascript

Unused JS, third-party scripts (GA4, GTM, Pixel, Hotjar), render-blocking

10

analyze_fonts

Google Fonts preconnect, font-display, WOFF2 format, preload hints

11

wordpress_inspector

Deep WordPress audit — 20+ plugin fingerprints, plugin-level recommendations

12

cloudflare_inspector

Cache status, Brotli, HTTP/3, Early Hints, Polish

13

generate_report

Narrative Markdown report with scores, CWV, and prioritized fixes

14

generate_report_html

Self-contained HTML dashboard — score cards, CWV grid, LCP bar chart, recommendations. Works for any CMS. Rendered as a visual Artifact in Claude.

15

generate_report_docx

Full Word document (.docx) saved to ~/Downloads/ — cover page, exec summary, CWV table, LCP savings table, all recommendations with evidence and fixes

16

generate_wp_rocket_config

WP Rocket settings JSON with Elementor/WooCommerce awareness

17

generate_cloudflare_rules

Cache Rules, Transform Rules, and settings guide

18

compare_performance

Before/after delta from two analyze_website JSON reports

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 build

Optional: 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-started

Connect 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_website

License

MIT

Available Tools

16 tools
analyze_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

    A3.7/5.0

    Scored across 16 tools

    Disambiguation4/5

    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.

    Naming Consistency3/5

    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.

    Tool Count4/5

    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.

    Completeness4/5

    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

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables 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.
      4
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      Core 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.
      4
      14 npm
      MIT