Adobe Extensibility MCP

An MCP (Model Context Protocol) server that gives AI coding assistants — Claude Code, and any other MCP-compatible agent — curated Adobe developer knowledge on demand. Instead of copy-pasting docs or hoping your AI already knows the patterns, point your agent at this server and it will pull the right guidance automatically as you build.

Deployed on Adobe I/O Runtime (serverless, no infrastructure to manage).

What It Does

The server exposes three MCP tools:

When you're building an App Builder action or a Workfront extension, your AI agent calls these tools automatically and gets back precise, copy-paste-ready patterns — the same way a senior developer would hand you the right doc at the right moment.

Related MCP server: Aindreyway MCP Codex Keeper

Available Skills

Using It in Your Project

Add the server to your project's .mcp.json (or your global MCP config). A .mcp.json.example is included in this repo as a starting point — copy it to .mcp.json and add any other servers you need.

Stage (latest changes, may be updated frequently):

{
  "mcpServers": {
    "adobe-extensibility-mcp": {
      "type": "streamable-http",
      "url": "https://27200-adobeextmcp-stage.adobeioruntime.net/api/v1/web/adobe-extensibility-mcp/skills-mcp"
    }
  }
}

Production (stable, recommended for day-to-day development):

{
  "mcpServers": {
    "adobe-extensibility-mcp": {
      "type": "streamable-http",
      "url": "https://27200-adobeextmcp.adobeioruntime.net/api/v1/web/adobe-extensibility-mcp/skills-mcp"
    }
  }
}

That's it. Your agent now has access to all skill domains.

Claude Code

Claude Code will automatically call list_skills and load_skill when you ask it to do something Adobe-related (build an action, wire up a Workfront extension, etc.). To make it lean on the MCP server consistently, add a line to your project's CLAUDE.md:

Use the `adobe-extensibility-mcp` MCP server for all Adobe App Builder and Workfront development patterns.

Then just work normally — ask Claude to build something and it will pull the right skill content before writing code.

How It Works

Your prompt → AI agent → list_skills / load_skill / read_skill_resource
                                  ↓
              Adobe I/O Runtime (serverless action)
                                  ↓
              Skill content returned to agent → code generation

Skills are structured as:

• A SKILL.md file with routing description, core concepts, and a quick-reference table

• references/*.md files with focused, copy-paste-ready patterns (one concern per file)

The agent's routing description tells it when to load each skill — so app-builder-actions fires on backend action work, not on frontend or API tasks.

Running Your Own Instance

Prerequisites

• Adobe I/O CLI: npm install -g @adobe/aio-cli

• An Adobe Developer Console project with App Builder enabled

• Node.js 20+

Setup

git clone https://github.com/your-org/adobe-extensibility-mcp
cd adobe-extensibility-mcp
npm install
aio login
aio app use   # select your org/project/workspace

Deploy

npm run deploy
aio app get-url   # prints your action URL

Update the url in your .mcp.json with the URL from get-url.

Local Development

npm run dev   # starts local dev server via aio app run
npm test      # runs the full test suite

Adding a New Skill

Skills live in actions/skills-mcp/skills/<skill-name>/. To add one:

1. Create SKILL.md with the required frontmatter:

---
name: my-skill
description: >
  When to use this skill. Include trigger phrases so the agent routes correctly.
  Do not use when X, Y, or Z.
metadata:
  author: your-name
  version: "1.0"
---

2. Add references/*.md files — one concern per file, SCREAMING_SNAKE_CASE.md naming, ≤200 lines

3. Regenerate the registry and run tests:

node scripts/generate-registry.js
npm test

4. Deploy:

npm run deploy

Development Workflow

Branching

Making Changes

git checkout stage
git checkout -b my-feature
# make changes
npm test                                      # unit tests must pass
E2E_URL=<your-action-url> npm run test:e2e:report  # run e2e against your deployed env
git add test-results/e2e-report.md
git commit -m "test: update e2e test results"
# open PR targeting stage

CI Checks

PRs → stage

PRs → main (promoting stage to prod)

Deploy Pipeline

PR → stage   →   merge   →   deploy to stage   →   e2e post-deploy verification
PR → main    →   merge   →   deploy to prod    →   e2e post-deploy verification

Test Commands

npm test                                           # unit tests
npm run test:e2e                                   # e2e against stage (default)
E2E_URL=<url> npm run test:e2e                     # e2e against any endpoint
npm run test:e2e:report                            # e2e + generate committed report
npm run test:all:report                            # unit + e2e reports (pre-PR)

Contributing

Sharing is caring — and Adobe's extensibility ecosystem is big enough that no one person has all the patterns.

If you've figured out the right way to do something in App Builder, Workfront, AEM, or any other Adobe product extension surface, consider contributing a skill or improving an existing reference file.

Ways to contribute:

• New skill domain — a new product or extension surface (e.g. AEM Content Fragments, Experience Platform extensions)

• New reference file — a focused pattern doc for an existing skill (e.g. rate limiting, pagination, webhook handling)

• Corrections — if a pattern is outdated or wrong, fix it; bad AI guidance is worse than no guidance

• Better routing descriptions — if the agent is loading the wrong skill for your use case, the description in SKILL.md is why; improve it

To contribute:

1. Fork the repo

2. Add or update skill content following the structure above

3. Run npm test — all tests must pass

4. Open a PR with a short description of what the skill covers and when an agent should use it

No contribution is too small. A single well-written reference file can save hours of debugging for every developer whose AI pulls it.

Related: Agentic Dev Team Framework

This MCP server is designed to work alongside the Cursor Agentic Dev Team framework — a production-grade multi-persona AI workflow for Cursor that brings structure to the full SDLC.

Together they form a complete end-to-end agentic development experience:

How they work together: The agentic dev team framework wires up named personas (Architect, Dev Lead, Security Expert, etc.) that collaborate through structured /plan, /dev, and /epic command pipelines. Each domain specialist persona is configured to pull from this MCP server — so when the App Builder developer persona starts implementing a Runtime action, it automatically loads the app-builder-actions skill with the correct patterns before writing a line of code.

The result: AI agents that follow a real team's workflow and have the right technical knowledge to execute it correctly.

License

MIT