Claude Prompts MCP Server
Claude Prompts is a portable MCP workflow layer for executing and managing reusable prompt workflows across AI clients.
Execute versioned prompt templates with arguments and compose multi-step chains via
prompt_engine.Apply reasoning frameworks such as CAGEERF, ReACT, and 5W1H, plus output styles and validation gates.
Validate outputs with self-checks or shell commands like
verify:"npm test", including retry presets, loops, and retry/skip/abort decisions.Resume, restart, and thread context across chains, including handoffs to client-native subagents.
Create, update, delete, list, inspect, reload, version, compare, and roll back prompts, gates, and frameworks via
resource_manager.Manage frameworks, status, analytics, sessions, and guidance via
system_control.Author YAML resources, hot-reload them, use custom/shared workspaces, and export prompts as native client skills.
Provides a checkpointing system that utilizes git stash to save and restore the state of the working directory, enabling safe rollbacks during automated reasoning and code modification loops.
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., "@Claude Prompts MCP Server analyze @CAGEERF :: 'cite sources'"
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.
The portable workflow layer beside your AI coding harness.
Quick Start · What You Get · Compose Workflows · Run Anywhere · Docs
What your AI client gives you — and what this server adds
Your client already does | This server adds |
Run a prompt | Compose prompts with validation, reasoning guidance, and formatting in one expression |
Single-shot skills | Multi-step workflows that thread context between steps |
Execute subagents | Hand off mid-chain steps to agents with full workflow context |
Client-native skill format | Author once as YAML, export to any client with |
Manual prompt writing | Versioned templates with hot-reload, rollback, and history |
Trust the output | Validate output between steps: self-evaluation and shell commands |
Is this for me?
Use this if you write the same prompts repeatedly, run multi-step workflows, or want to share reusable prompts with a team.
Skip if your client's built-in
/commandsalready handle what you need, or you're looking for a no-code prompt library.Works with Claude Code, Claude Desktop, Cursor, VS Code, OpenCode, Gemini CLI, Codex, and Windsurf. Hook coverage differs by client; the client list shows it.
Quick Start
Claude Code (Recommended)
/plugin marketplace add minipuft/minipuft-plugins # first time only
/plugin install claude-prompts@minipuft
>>tech_evaluation_chain library:'zod' context:'API validation'Codex (Experimental)
Turn on hooks in ~/.codex/config.toml, then install the plugin:
[features]
hooks = truecodex plugin marketplace add https://github.com/minipuft/minipuft-plugins.git
codex plugin add codex-prompts@minipuftRestart Codex, run /hooks to review and trust the plugin hooks, then try the same >>tech_evaluation_chain command. Needs Codex CLI 0.117 or later; not available on Windows (requirements).
Related MCP server: n8n-MCP
Every Client
Hooks are what make >>, -->, and :: work in conversation; "MCP tools only" means the three MCP tools without them. See With Hooks. Config locations and --client presets: Client Capabilities Reference.
npm install -g opencode-prompts && opencode-prompts installFor MCP tools without hooks, use the manual config in the Client Integration Guide.
Steps in Quick Start. Hooks are off by default and need a one-time /hooks trust review.
gemini extensions install https://github.com/minipuft/gemini-promptsFor MCP tools without hooks, use the manual config in the Client Integration Guide.
Option A: GitHub Release (recommended): download claude-prompts-{version}.mcpb from Releases and drag it into Claude Desktop Settings → MCP Servers. The .mcpb bundle is self-contained (~5MB); no npm required.
Option B: NPX (auto-updates): add this to your config file (macOS: ~/Library/Application Support/Claude/claude_desktop_config.json, Windows: %APPDATA%\Claude\claude_desktop_config.json):
{
"mcpServers": {
"claude-prompts": {
"command": "npx",
"args": ["-y", "claude-prompts@latest", "--client", "claude-code"]
}
}
}Restart Claude Desktop and test: >>research_chain topic:'remote team policies'
Cursor and Windsurf (now Devin Desktop) use the same block. Add it to ~/.cursor/mcp.json for Cursor, or to ~/.config/devin/mcp_config.json for Windsurf (Windows: %APPDATA%\devin\mcp_config.json):
{
"mcpServers": {
"claude-prompts": {
"command": "npx",
"args": ["-y", "claude-prompts@latest", "--client=cursor"]
}
}
}VS Code uses a different shape. Add this to .vscode/mcp.json in your project, or to your user profile's mcp.json:
{
"servers": {
"claude-prompts": {
"type": "stdio",
"command": "npx",
"args": ["-y", "claude-prompts@latest", "--client=unknown"]
}
}
}Restart the client after saving. Presets and verification: Client Integration Guide.
What You Get
Four primitives you author, version, and compose. The bundled set ships 52 prompts across 9 categories — a starting library, not the ceiling: your AI writes new prompts and chains through resource_manager as it works, so the set grows around what you actually do. All hot-reloadable, all versioned with rollback.
Primitive | Symbol | What it is | Example |
Prompt template |
| Versioned YAML with named arguments; hot-reload on save |
|
Gate |
| Validation criterion the AI checks its own output against; blocking or advisory; can shell-verify |
|
Framework |
| Reasoning framework that shapes how the AI works through the problem; plug in your own or use built-ins like |
|
Style |
| Output formatting and tone |
|
Prompts, gates, and frameworks are managed through the resource_manager tool. Your AI creates, edits, versions, and rolls them back through MCP, no file editing required. Styles are managed with the bundled cpm CLI. Failed gate checks can retry automatically or pause for your decision (Gates Guide). Build your first primitive: Prompt Authoring Tutorial.
Your own prompts
Your own prompts, gates and frameworks live in a workspace you choose. --init=~/my-prompts scaffolds a starter workspace: three example prompts plus config.jsonc. Edit them (YAML schema), or have your AI author new prompts, gates, and frameworks via resource_manager. Point MCP_RESOURCES_PATH at an existing resources directory (one holding prompts/, gates/ and so on) to use it in place of your workspace's own resources/. Resources that belong to one repository go in .claude-prompts/ at its root (cpm init --project scaffolds it) and load above your workspace over STDIO. See Custom Resources Guide.
The Three Tools
Everything above reaches your client through three MCP tools:
Tool | Purpose |
| Execute prompts with frameworks and validation |
| Create, update, version, and roll back resources |
| Status, analytics, framework switching |
Most users invoke these via >> syntax in conversation; hooks construct the actual calls. For programmatic MCP clients calling tools directly, see MCP Tools Reference.
Compose Workflows
How to write a chain
>>review target:'src/auth/' ^ReACT :: 'cite sources'
--> security_scan :: verify:"npm test"
==> implementationRead top-to-bottom:
>>review target:'src/auth/'runs thereviewprompt against your auth folder.^ReACToverlays the ReACT reasoning framework on this step.:: 'cite sources'adds a gate the AI must satisfy (cite sources, or retry).--> security_scan :: verify:"npm test"chains to step 2, which must passnpm testbefore producing output.==> implementationhands the final step off to a client-native agent (a subagent in Claude Code).
review ships with the server; security_scan and implementation stand in for prompts you write.
Validation runs between steps, not only at the end. For the full operator grammar and examples, see MCP Tools Reference.
Recorded live in Claude Code (Sonnet), sped up, nothing re-ordered or retyped. The side panel shows what each hook and the server's npm test gate did.
Two patterns extend the basic syntax. Chains also support context threading between steps and agent handoffs. See Chains Lifecycle and MCP Tools Reference.
Context7 fetches live library docs mid-chain. The final output is a structured assessment with sources.
Verification Loops
Ground-truth validation via shell commands. The AI keeps iterating until tests pass:
>>implement-feature :: verify:"npm test" loop:trueImplements, runs the test, reads failures, fixes, retries. Spawns a fresh context after repeated failures to avoid context rot.
implement-feature stands for your own prompt: :: verify attaches to any of them.
Preset | Tries | Timeout | Use Case |
| 1 | 30s | Quick check |
| 5 | 5 min | CI validation |
| 10 | 10 min | Large test suites |
For autonomous test-fix cycles with context-rot prevention: Ralph Loops Guide.
Judge Mode
Let the AI pick the right resources for the task:
%judge Help me refactor this authentication moduleAnalyzes available templates, reasoning frameworks, validation rules, and styles, then recommends the best combination. You confirm before it runs. For scoring and overrides see Judge Mode Guide.
Run Anywhere
Author workflows as YAML templates. Export as native skills to your client.
# skills-sync.yaml — choose what to export
registrations:
claude-code:
user:
- prompt:development/review
- prompt:development/validate_worknpm run skills:exportThe review prompt becomes a /review Claude Code skill. validate_work becomes /validate_work. Same source, native experience; no MCP call required at runtime.
Compiles to native skill packages for Claude Code, Cursor, Codex and OpenCode. npm run skills:diff flags when exports drift from source. Configuration, supported clients, and drift detection: Skills Sync Guide.
With Hooks
Without hooks, you're calling the three MCP tools explicitly (the LLM constructs each call). With hooks, the operators work in conversation: >>, -->, ==>, :: feel native rather than mediated, and workflow state survives across LLM turns and context compaction.
What hooks unlock:
Hook | Unlocks |
Auto-routing |
|
Chain continuity across compaction | Multi-step chains preserve state when context compacts mid-execution; the chain doesn't restart from scratch |
Cross-step verdict tracking | Gate pass/fail verdicts thread across all chain steps without the LLM re-deriving them |
Native agent handoffs |
|
Session persistence | Workflow state preserved when context compacts mid-chain |
Hooks ship with the plugin install; the client list shows which clients have them. Detail: hooks/README.md.
How It Works
Command with operators → server parses and injects resources (framework, gates, style) → client executes the rendered prompt and self-evaluates against the gates → router decides: next step on pass, retry on fail, return on done.
Full request lifecycle, pipeline stages, and subsystem diagrams: Architecture Overview.
Documentation
Choose a guide based on what you want to do: learn by building, complete a task, look up syntax, or understand the design.
Quick jumps: Build your first prompt · Chains lifecycle · MCP Tools reference · Architecture overview · Troubleshooting
Contributing
Run it from source, as a Claude Code plugin or for any other MCP client:
git clone https://github.com/minipuft/claude-prompts-mcp.git && cd claude-prompts-mcp
(cd server && npm install && npm run build) # esbuild bundles to server/dist/index.js
claude --plugin-dir . # load it as a Claude Code pluginFor any other MCP client, point its config at server/dist/index.js; transport is --transport=stdio (default) or --transport=streamable-http. Edit hooks or prompts → restart the client. Edit TypeScript → rebuild first.
cd server
npm test # Run test suite
npm run validate:all # Full CI validationThe build produces a self-contained bundle. server/dist/ is gitignored, and CI builds fresh from source.
See CONTRIBUTING.md for workflow details.
License
Available Tools
3 toolsprompt_enginePrompt EngineA
🚀 PROMPT ENGINE [CAGEERF]: Execute prompts with C.A.G.E.E.R.F framework and ground-truth validation.
WHAT IT RETURNS: Prepared prompt + CAGEERF phase instructions (Context→Analysis→Goals→Execution→Evaluation→Refinement). WHAT YOU DO: Execute each phase yourself using the returned structure.
SYNTAX:
prompt_id key:"value" # Run prompt with arguments
step1 --> >>step2 # Chain multiple steps
@CAGEERF >>prompt # Apply CAGEERF framework
:: verify:"npm test" :full # Shell validation (5 attempts, 5min)
:: verify:"cmd" loop:true # Autonomous until pass
PRESETS: :fast (1 try), :full (5 tries), :extended (10 tries) MODIFIERS: %clean (no injection), %lean (gates only), %judge (preview)
Inputs: gates, command, options, chain_id, +4 more.
resource_managerResource ManagerB
🗂️ RESOURCE MANAGER [CAGEERF]: Unified CRUD for prompts, gates, and frameworks.
USAGE: resource_manager(resource_type:"prompt|gate|framework", action:"...", ...) RESOURCE TYPES: prompt (templates), gate (quality criteria), framework (CAGEERF, ReACT, 5W1H, SCAMPER) ACTIONS: create | update | delete | list | inspect | reload | switch (framework only)
Use action:"guide" with resource_type:"prompt" for phase-appropriate recommendations.
Inputs: action (required), resource_type (required), id, name, +37 more.
system_controlSystem ControlD
⚙️ SYSTEM CONTROL [CAGEERF]: System administration. Status shows current CAGEERF phase context.
Inputs: action (required), topic, reason, persist, +7 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 3 tools
The three tools target distinct areas: prompt execution, system administration, and resource management. The only ambiguity is system_control, whose description is vague and could overlap with engine control, but overall the boundaries are clear enough.
All tool names use a consistent snake_case noun_noun format with a role suffix (engine, control, manager). While not a strict verb_noun pattern, the naming style is uniform and predictable across all three tools.
Three tools is at the lower end of appropriate for a focused server, and each tool serves a distinct purpose. The count is reasonable for the narrow domain, though a slightly larger set could add more convenience functions.
The set covers the full lifecycle: creating and managing resources via resource_manager, executing prompts via prompt_engine, and system-level status via system_control. Minor gaps include a dedicated inspection or debugging tool, but the core workflows are complete.
Maintenance
Related MCP Connectors
Manage, version, and publish LLM prompts with blocks, variables, and evaluations.
Your prompt library inside your AI: 1,000+ pro templates, frameworks, vocab & pipelines.
Team prompt library with version control and reviews. Save, search and reuse prompts via MCP.
Self-hosted AI prompt library: prompts, collections, tags, teams, chains. 29 MCP tools for agents.
Related MCP Servers
- AlicenseAqualityBmaintenanceEnables creation, management, and templating of prompts through a simplified SOLID architecture, allowing users to organize prompts by category and fill in templates at runtime.7286 npm120MIT
- AlicenseAqualityAmaintenanceA Model Context Protocol server that provides AI assistants with comprehensive access to n8n node documentation, properties, and operations for effective workflow automation.2847,449 npm23,266MIT
- AlicenseAqualityDmaintenanceProvides structured spec-driven development workflow tools for AI-assisted software development with sequential spec creation (Requirements → Design → Tasks). Features a real-time web dashboard for monitoring project progress and managing development workflows.5637 npm4,307GPL 3.0
- FlicenseNot gradedqualityNot gradedmaintenanceEnables AI-native prompt management for Latitude.so with full CRUD operations, version control, file-based workflows, and direct prompt execution with streaming support.4 npm-