DPS-Superskills-MCP
The DPS-Superskills-MCP server exposes the DPS SuperSkills v5.2.1 framework as MCP tools, giving AI agents structured access to 31 software engineering skills, workflows, and knowledge management across 16 tools and 31 read-only resources.
Skill Tools
skill_list— Discover all 31 skills with descriptions and registers (DISCIPLINE, TECHNIQUE, KNOWLEDGE LAYER, REFERENCE); filter by register categoryskill_read— Retrieve full SKILL.md content for any skill, with optional compressed nano versionskill_run— Invoke a skill with your task context to receive a structured workflow: ANNOUNCE, GOAL, CONSTRAINTS, CHECKLIST, OUTPUT TEMPLATE, active GOTCHAS, and NANO REFERENCEDispatch templates — Generate role-specific prompt templates (implementer, reviewer, specialist) for spawning focused subagents
Knowledge Base Persist, update, query, and monitor cross-session knowledge entries (gotchas, decisions, patterns, bug-patterns, domain terms) with health reporting on entry counts, stale items, and coverage gaps.
Code Retrieval Perform semantic code searches within your repository, build/refresh a local code index, and check index status.
DPS Spec Tools
Initialize or validate the four core DPS living-spec files (README, CONTRACTS, BLUEPRINT, ADR) in your workspace. Validation via Python script is disabled under MCP_SAFE_MODE=true.
System Tools
super_mcp_ping— Health check confirming server and middleware statussuper_mcp_pattern_debt— View the pattern-debt registry (implementation gates, runtime guards), with optional filtering
MCP Resources 31 read-only skill resources available for auto-injection by compatible MCP clients, with DISCIPLINE skills prioritized.
Skill Categories
DISCIPLINE (Iron Laws):
complexity-gate,tdd-verified,verification-before-completion,context-reanchor,epistemic-health-check,privacy-secrets-gateTECHNIQUE:
brainstorming,systematic-debugging,specialist-review,session-handoff,dispatching-parallel-agents, and moreKNOWLEDGE LAYER:
domain-alignment,knowledge-compound,audit-distill,adr-commitREFERENCE:
kb-query,skill-init,using-super-skills,framework-doctor,writing-super-skills
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., "@DPS-Superskills-MCP list all skills"
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.
DPS SuperSkills MCP Server
DPS SuperSkills v5.2.1 deployed as an MCP server — exposes 16 MCP tools plus 31 read-only skill resources for any MCP-compatible client (Claude Desktop, Cursor, VS Code, Windsurf, Antigravity, or any IDE/chatbot supporting MCP).
Package:
dps-superskills-mcpDefault transport:stdioSkills content:docs/DPS-superskills-v5.2.1/(31 skills, 31 nano references) Runtime entrypoint:dist/index.jsBase layer: SUPER-MCP Framework (TypeScript / ESM)
DPS SuperSkills — MCP Tools & Resources
This server exposes both MCP Tools (for on-demand invocation) and MCP Resources (for context auto-injection) to give any AI agent structured access to the full DPS SuperSkills v5.2.1 framework.
MCP Resources
All 31 skills are exposed as read-only MCP Resources at skill://<name> (for example, skill://using-super-skills or skill://complexity-gate). Resource annotations prioritize DISCIPLINE skills so clients that support resource ranking can inject the Iron Laws first.
Compatible MCP clients can discover the skill://{skill_name} template, call resources/list, and read individual skills with resources/read. When resources are enabled, the server advertises standard MCP resources capability during initialize.
Note: Resources inherit the SUPER-MCP governance pipeline scaled by endpoint: resources/read enforces rate-limiting, quota, and Output Firewall (like Tools); resources/list enforces rate-limiting and quota; resources/templates/list is lightweight discovery. Enabled by default; can be disabled via MCP_ENABLE_SKILL_RESOURCES=false.
MCP Tools
Skills (skills.tool.js — 5 tools)
MCP Tool | Purpose |
| List all 31 skills with descriptions, register (DISCIPLINE / TECHNIQUE / KNOWLEDGE LAYER / REFERENCE), and curated |
| Return the full SKILL.md content for a specific skill. Optionally include nano (compressed) version. |
| Invoke a skill with caller context. Returns the structured workflow (ANNOUNCE, GOAL, CONSTRAINTS, CHECKLIST, OUTPUT TEMPLATE, active GOTCHAS, NANO REFERENCE) scaled by |
| Generate a role-specific prompt template (implementer / reviewer / specialist) for spawning a focused subagent, pre-loaded with tier-appropriate skills and nano references. C0 tasks return a simplified "implement directly" prompt. |
| Search skills by keyword across names, descriptions, and registers. Use when unsure which skill applies — faster than reading |
Knowledge base (knowledge.tool.js — 4 tools, persistent cross-session memory)
MCP Tool | Purpose |
| Record a single knowledge entry ( |
| Update an existing KB entry in-place by slug. Use when a gotcha or decision is no longer accurate and needs replacing. |
| Search the KB. Default returns a compact |
| Report entry counts per category, flag stale entries (>90 days), and surface coverage gaps. |
Code retrieval (code_index.tool.js — 3 tools, local data-plane over the user's repo)
MCP Tool | Purpose |
| Semantic-ish local code search (native zero-dependency BM25 + symbol/path/proximity rerank). Use instead of grep+read to locate where something is implemented — returns the most relevant chunks as |
| Build / incrementally refresh the local index. Only changed files (size+mtime) are re-read; a no-op refresh short-circuits in ~25ms. |
| Report whether the index exists, its manifest, and how stale it is (added/modified/removed files). |
DPS living-spec (dps.tool.js — 2 tools)
MCP Tool | Purpose |
| Initialize/inject the 4 DPS living-spec files (README/CONTRACTS/BLUEPRINT/ADR) into |
| Validate the DPS spec via |
System (system.tool.js — 2 tools)
MCP Tool | Purpose |
| Health check — confirm the server is alive and responding. |
| View the active pattern-debt registry. |
31 Skills Available
DISCIPLINE (Iron Laws — non-negotiable):
complexity-gate · tdd-verified · verification-before-completion · context-reanchor · epistemic-health-check · privacy-secrets-gate
TECHNIQUE (Goal + constraints — adapt approach):
brainstorming · dps-init · audit-design · dps-promote · writing-plans · task-risk-score
systematic-debugging · pattern-globalize · specialist-review · release-readiness
subagent-driven-development · executing-plans · dispatching-parallel-agents
receiving-code-review · using-git-worktrees · session-handoff
KNOWLEDGE LAYER (Cross-cycle compounding):
domain-alignment · knowledge-compound · audit-distill · adr-commit
REFERENCE (Lookup only):
kb-query · skill-init · writing-super-skills · framework-doctor · using-super-skills
Related MCP server: skillsmcp
Client Configuration
To automatically generate the correct configuration with absolute paths for your environment, run:
./install.shManual Configuration (Claude Desktop / Claude Code / Cursor / Antigravity / Codex)
Replace <absolute-path-to> with your actual full path, or run ./install.sh to get it pre-filled.
MCP_SAFE_MODE=falseis required fordps_check(it spawnspython3—process.spawnis blocked in safe mode). Everything else runs under safe mode:kb_write/kb_updateuse the localkb.writecapability, andcode_search/code_index/dps_initonly write into the workspace (fs.write.workspace). Usefalsewhen you want the full tool set includingdps_check; usetruefor the smallest local permission profile when you do not need DPS linting.
MCP_WORKSPACE_ROOT— the code retrieval + DPS tools operate on the user's project. Understdiothey default to the server's working directory (process.cwd()); if your IDE does not launch the server with the project as cwd, setMCP_WORKSPACE_ROOTto the absolute project path. Underhttp(remote/control-plane) the indexer disables itself.
{
"mcpServers": {
"dps-superskills": {
"command": "node",
"args": ["<absolute-path-to>/DPS-Superskills/dist/index.js"],
"env": {
"TRANSPORT_DRIVER": "stdio",
"STORAGE_DRIVER": "fs",
"MCP_SAFE_MODE": "false",
"MCP_PLUGIN_ALLOWLIST": "system.tool.js,skills.tool.js,knowledge.tool.js,code_index.tool.js,dps.tool.js",
"MCP_PLUGIN_ISOLATION_MODE": "policy",
"MCP_ENABLE_SKILL_RESOURCES": "true",
"MCP_PROJECT_ID": "dps-superskills",
"MCP_TENANT_ID": "tenant_local"
}
}
}
}VS Code / Windsurf (stdio)
{
"mcp": {
"servers": {
"dps-superskills": {
"command": "node",
"args": ["<absolute-path-to>/DPS-Superskills/dist/index.js"],
"env": {
"TRANSPORT_DRIVER": "stdio",
"STORAGE_DRIVER": "fs",
"MCP_SAFE_MODE": "false",
"MCP_PLUGIN_ALLOWLIST": "system.tool.js,skills.tool.js,knowledge.tool.js,code_index.tool.js,dps.tool.js",
"MCP_PLUGIN_ISOLATION_MODE": "policy",
"MCP_ENABLE_SKILL_RESOURCES": "true",
"MCP_PROJECT_ID": "dps-superskills",
"MCP_TENANT_ID": "tenant_local"
}
}
}
}
}Cursor (~/.cursor/mcp.json or .cursor/mcp.json)
{
"dps-superskills": {
"command": "node",
"args": ["<absolute-path-to>/DPS-Superskills/dist/index.js"],
"env": {
"TRANSPORT_DRIVER": "stdio",
"STORAGE_DRIVER": "fs",
"MCP_SAFE_MODE": "false",
"MCP_PLUGIN_ALLOWLIST": "system.tool.js,skills.tool.js,knowledge.tool.js,code_index.tool.js,dps.tool.js",
"MCP_PLUGIN_ISOLATION_MODE": "policy",
"MCP_ENABLE_SKILL_RESOURCES": "true",
"MCP_PROJECT_ID": "dps-superskills",
"MCP_TENANT_ID": "tenant_local"
}
}
}Quick Start
# Option A — auto build + print IDE configs with your absolute paths:
./install.sh
# Option B — manual:
pnpm install --frozen-lockfile
pnpm build
# Then copy a config block from docs/MCP-CONNECT.md into your IDEProject Structure
.
├── docs/DPS-superskills-v5.2.1/ <- 31 skills content (SKILL.md + nano.md)
│ ├── <skill-name>/SKILL.md
│ ├── <skill-name>/<skill-name>.nano.md
│ ├── shared/ <- gotcha-schema, claim-grammar, etc.
│ ├── bootstrap-templates/
│ ├── quickstarts/
│ ├── tools/
│ └── README.md
├── docs/MCP-CONNECT.md <- IDE connection guide (all configs)
├── install.sh <- build + print IDE configs with abs paths
└── src/
├── index.ts
├── skills/ <- DPS SuperSkills MCP bridge layer
│ ├── skill_loader.ts <- SKILL.md / nano.md parser + cache
│ ├── skill_registry.ts <- 31-skill static registry
│ └── skill_executor.ts <- structured workflow formatter
├── plugins/
│ ├── skills.tool.ts <- skill_list, skill_read, skill_run, skill_dispatch, skill_search
│ ├── knowledge.tool.ts <- kb_write, kb_update, kb_query, kb_health
│ ├── code_index.tool.ts <- code_search, code_index, code_index_status
│ ├── dps.tool.ts <- dps_init, dps_check
│ └── system.tool.ts <- super_mcp_ping, super_mcp_pattern_debt
├── core/indexer/ <- zero-dep BM25 code retrieval (walker, chunker, bm25, store)
├── core/dps/ <- DPS spec scaffold + dps.py wrapper (init.ts)
└── ... <- Layer 0 (SUPER-MCP runtime)At runtime, the code-retrieval + DPS tools materialize a folder inside the user's own project (never this repo):
<user-project>/.dps/
├── spec/ <- DPS living-spec: README/CONTRACTS/BLUEPRINT/ADR.md (tracked)
├── agent/ <- generated projection sidecars (tracked)
├── index/ <- local code index cache (gitignored)
└── DPS_INDEX.yml, DPS_LOCK.ymlBy default the server reads skills from <project_root>/docs/DPS-superskills-v5.2.1. Override with:
MCP_SKILLS_PATH=/custom/path/to/skillsThe persistent knowledge base defaults to <project_root>/docs/superskills. Override it when you want project-local or test-isolated KB files:
MCP_KB_PATH=/abs/path/to/docs/superskillsCode-retrieval / DPS tools:
# Project root the indexer + DPS tools operate on (defaults to cwd under stdio).
MCP_WORKSPACE_ROOT=/abs/path/to/your/project
# Set false to stop code_search from auto-building the index on first use.
MCP_INDEX_AUTO=trueLayer 0: SUPER-MCP Runtime
This MCP server is built on top of the hardened SUPER-MCP Boilerplate (Layer 0).
While the primary focus of this project is the DPS SuperSkills implementation, the underlying architecture provides:
Dual transports: Native support for both
stdioandhttp.Durable Storage: Extensible storage (fs, Redis) for task and state persistence.
Output Firewall: Redaction of sensitive data before returning to the LLM.
Security Primitives: Capability-based safety policies (
MCP_SAFE_MODE), plugin allowlisting, and native tasks support.
(Note: Advanced configuration options for Redis, KMS encryption, OAuth, and HTTP deployments inherited from SUPER-MCP are supported but omitted from this README for brevity, as the standard local stdio usage is recommended for IDEs and Chatbots).
Available Tools
5 toolsskill_listARead-onlyIdempotent
List all available DPS SuperSkills v5.2.1 skills with their descriptions and register (DISCIPLINE / TECHNIQUE / KNOWLEDGE LAYER / REFERENCE). Use this first to discover which skill to invoke.
Inputs: register.
skill_readARead-onlyIdempotent
Return the full SKILL.md content for a specific DPS SuperSkill. Use when you need the raw, complete skill definition including all examples and pressure tests. For a structured executable workflow, use skill_run instead.
Inputs: skill_name (required), include_nano.
skill_runARead-onlyIdempotent
Invoke a DPS SuperSkill v5.2.1 with your task context. Returns a structured workflow response: ANNOUNCE statement, GOAL, CONSTRAINTS, CHECKLIST (ready to execute), OUTPUT TEMPLATE (pre-labeled), active GOTCHAS with do-instead guidance, and NANO REFERENCE.
Tip: Run skill_list first if unsure which skill to use. Run complexity-gate before other skills for software tasks.
Inputs: skill_name (required), task_description, context, error_message, +2 more.
super_mcp_pattern_debtARead-onlyIdempotent
Read-only report of documented pattern-debt items, implementation gates, and runtime guards.
Inputs: debt_id, include_implemented.
super_mcp_pingARead-onlyIdempotent
Ping server để kiểm tra trạng thái và pipeline middlewares.
Inputs: message.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 5 tools
Each tool has a clearly distinct purpose: listing skills, reading full definitions, running skills with workflow, checking pattern debt, and pinging server status. No overlap in functionality.
All tool names follow snake_case with a consistent prefix per group: 'skill_' for core skill operations and 'super_mcp_' for server utilities. The pattern is predictable and uniform.
With 5 tools, the server is well-scoped for its purpose of managing and invoking DPS SuperSkills. Each tool covers an essential operation without bloat or deficiency.
The tool surface covers the full lifecycle expected for a skills server: discovery (list), full definition retrieval (read), execution (run), plus supporting utilities for debt management and health check. No obvious gaps.
Maintenance
Related MCP Connectors
Governed AI agent skills — one library, distributed to devs and exposed to remote agents over MCP.
Patterns for designing and reviewing AI skills, agents, and multi-agent workflows. Find guidance on context economy, delegation, verification, and tool design; inspect claims, worked examples, maturity labels, and source references. Five read-only tools let agents discover relevant patterns, compare concise cards, read specific sections, and explore relationships. Hosted Streamable HTTP at https://agentic-atlas.dev/mcp/ — no installation, account, or API key required. Browse the atlas at https://agentic-atlas.dev/.
214 tools for AI agents over one MCP endpoint: image, video, audio, 3D, data, storage, mail, GPUs.
Governed app access for AI agents: 1,000+ apps & 12,000+ tools via Code Mode MCP.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceA TypeScript ESM MCP server exposing 20 public instruction tools and 7 utility tools, backed by 102 internal skills across 18 domain families — from requirements discovery and code quality through governance, resilience, and physics-inspired analysis.478 npm6MIT
- AlicenseAqualityDmaintenanceExposes Agent Skills to AI agents as MCP tools, enabling discovery and activation of skill instructions for coding agents.327MIT
- AlicenseAqualityDmaintenanceProvides 634+ curated production-ready AI skills for any MCP-compatible client, covering areas like security, frontend, backend, infrastructure, AI/ML, and architecture. Enables AI agents to access best practices, patterns, and solutions across multiple domains.67 npm1MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI agents to discover and execute over 1,000 developer skills and tools via MCP and WebMCP, with progressive disclosure for efficient token usage.MIT