AEM Edge Delivery Services — MCP Server

A Model Context Protocol server that supercharges AEM EDS development in VS Code, Cursor, and any MCP-compatible IDE. No API keys needed — your IDE's own LLM uses these tools, resources, and prompts to generate EDS-compliant code.

What It Does

Plus 4 resources (coding standards, block guide, cheatsheet, Adobe EDS skills) and 3 prompt templates (new-block, fix-block, design-to-block).

Prompt Parameters

Design → Block workflow

The generate_block_from_design tool and the design-to-block prompt integrate Adobe's official EDS skills (Content-Driven Development, analyze-and-plan, content-modeling, authoring-analysis, building-blocks, UE component model, testing-blocks, code-review).

Provide any combination of:

• Text — natural-language description of what the block should do

• Image(s) — local paths or URLs of design screenshots/mockups (the IDE LLM analyzes them with vision)

• Figma URL — a figma.com/file/... or figma.com/design/... link, optionally with ?node-id=…. The tool emits a local curl recipe to pull node JSON + a 2× PNG export; your Figma token stays on your machine.

The tool returns: the CDD workflow outline, a vision-analysis prompt for the IDE LLM, the Figma-fetch recipe (if applicable), implementation patterns, a baseline scaffold (JS/CSS/README/test.html/sample-content), the UE component-model guidance, a testing matrix, and a self-review checklist.

Related MCP server: Arthur

Quick Start

Cursor

Open Settings → Tools & Integrations → MCP Servers → Add and paste:

{
  "mcpServers": {
    "eds-dev": {
      "command": "npx",
      "args": ["-y", "@anthropic-eds/eds-mcp-server"]
    }
  }
}

Or create .cursor/mcp.json in your project root with the same config.

VS Code

Create .vscode/mcp.json in your project:

{
  "servers": {
    "eds-dev": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@anthropic-eds/eds-mcp-server"]
    }
  }
}

Then use GitHub Copilot Chat in Agent Mode (the @ button) to access the tools.

Local CLI Validator (New)

This project now includes an EDS block validator/linter CLI.

npm run build
npm run validate:blocks -- ./blocks
# or directly
node dist/cli.js ./blocks --strict

Options:

• --json for CI-friendly machine output

• --strict to fail on warnings

• --help for usage details

Claude Code

Add to your ~/.claude/mcp.json:

{
  "mcpServers": {
    "eds-dev": {
      "command": "npx",
      "args": ["-y", "@anthropic-eds/eds-mcp-server"]
    }
  }
}

From Source (Development)

git clone https://github.com/your-org/eds-mcp-server.git
cd eds-mcp-server
npm install
npm run build

# Test with MCP Inspector
npm run inspect
# Opens browser at http://localhost:6274

# Add to IDE pointing to local build:
# "command": "node",
# "args": ["/path/to/eds-mcp-server/dist/index.js"]

Usage Examples

Scaffold a new block

Ask your IDE's AI: "Create a hero block with a background image, heading, and CTA button"

The LLM will call scaffold_block and return all 5 files ready to copy into your project.

Validate existing code

Ask: "Validate my cards block" — paste your JS and CSS. The validate_block tool checks for scoping issues, missing exports, reserved class names, performance problems, and more.

Understand the DOM pipeline

Ask: "How does a 3-row, 2-column table become DOM in EDS?"

The explain_dom tool shows the exact HTML structure your decorate function receives.

Set up a new project

Ask: "Set up a new repoless EDS site with Google Drive and Universal Editor"

The scaffold_project tool returns a complete step-by-step guide.

Get configuration templates

Ask: "I need to set up redirects and custom headers"

The eds_config tool returns ready-to-use spreadsheet formats and configuration examples.

Check performance

Ask: "Is this block going to hurt my Lighthouse score?" — paste the code.

The check_performance tool estimates budget impact and flags render-blocking patterns.

Tool Reference

scaffold_block

scaffold_model

scaffold_project

validate_block

check_performance

explain_dom

lookup_block

search_block_collection

eds_config

eds_scripts_guide

Architecture

eds-mcp-server/
├── src/
│   ├── index.ts              # Server entry point — registers all tools
│   ├── tools/
│   │   ├── scaffold-block.ts   # Generate block files
│   │   ├── scaffold-model.ts   # Generate UE model files
│   │   ├── scaffold-project.ts # New project guide
│   │   ├── validate-block.ts   # Block validation
│   │   ├── explain-dom.ts      # Content → DOM mapping
│   │   ├── eds-config.ts       # Configuration templates
│   │   ├── check-performance.ts # Performance analysis
│   │   ├── lookup-block.ts     # Block pattern search
│   │   ├── search-block-collection.ts # GitHub API block search
│   │   └── eds-scripts.ts      # Scripts customization guide
│   ├── resources/
│   │   └── eds-resources.ts    # Documentation as MCP resources
│   ├── prompts/
│   │   └── eds-prompts.ts      # Prompt templates
│   └── knowledge/
│       ├── eds-conventions.ts  # EDS rules, constraints, templates
│       └── block-templates.ts  # Code generators
├── package.json
├── tsconfig.json
├── LICENSE
├── evaluations.xml
└── README.md

Key design decisions:

• No LLM dependency — the server provides tools and knowledge; your IDE's LLM does the reasoning

• No API keys — pure static analysis, scaffolding, and documentation (except search_block_collection which queries public GitHub API)

• Convention-encoded — EDS rules are hardcoded into validators and generators

• Tool annotations — all tools declare readOnlyHint, destructiveHint, idempotentHint, and openWorldHint

• Stdio transport — works with any MCP client (Cursor, VS Code, Claude Code)

Evaluations

The evaluations.xml file contains 10 LLM-facing integration test Q&A pairs. Each question requires calling one or more MCP tools and verifying the response matches expected behavior. Use these with the MCP Inspector to validate the server end-to-end.

EDS Resources

• AEM Edge Delivery Services docs

• AEM Boilerplate

• Block Collection

• Block Party (community)

• Keeping it 100 (performance)

Contributing

1. Fork the repository

2. Create a feature branch

3. Add tools in src/tools/, knowledge in src/knowledge/

4. Test with npm run inspect

5. Submit a PR

License

MIT