Claude Prompts MCP Server
It is an MCP server that adds a portable workflow layer to AI coding clients: reusable prompts, validation gates, reasoning frameworks, multi-step chains, and client-native skill export.
Execute versioned prompt templates with named arguments (
>>prompt key:"value")Compose multi-step chains with context threading, retries, and agent handoffs (
-->,==>)Enforce validation gates between steps, including shell-command verification loops (
:: verify:"npm test" loop:true)Apply reasoning frameworks like CAGEERF, ReACT, 5W1H, SCAMPER (
@framework)Manage prompts, gates, and frameworks via
resource_manager: create, update, delete, version, rollback, inspect, reloadUse
system_controlfor status, analytics, framework switching, and gate/framework configurationExport YAML-authored prompts as native skills for Claude Code, Cursor, OpenCode, and more (
skills:export)Run in MCP-only clients or with enhanced hooks (Claude Code, OpenCode, Gemini CLI, experimental Codex)
Use Judge Mode (
%judge) to get AI-recommended resource combinations before runningHot-reload resources and preserve chain state across context compaction
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 Serveranalyze @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, OpenCode, Gemini CLI, Codex, Windsurf, and Zed. Plugin installers add hooks (chain tracking, gate enforcement, state preservation) for Claude Code, OpenCode, Gemini CLI, and Codex (experimental); other clients run MCP-only.
Quick Start
Claude Code (Recommended)
# Add marketplace (first time only)
/plugin marketplace add minipuft/minipuft-plugins
# Install
/plugin install claude-prompts@minipuft
# Try it
>>tech_evaluation_chain library:'zod' context:'API validation'Load plugin from local source for development:
git clone https://github.com/minipuft/claude-prompts-mcp ~/Applications/claude-prompts-mcp
cd ~/Applications/claude-prompts-mcp/server && npm install && npm run build
claude --plugin-dir ~/Applications/claude-prompts-mcpEdit hooks/prompts → restart Claude Code. Edit TypeScript → rebuild first.
Codex (Experimental)
Codex hooks require Codex CLI 0.117 or later and are unavailable on Windows. See the codex-prompts requirements for Python and Node.js prerequisites.
Enable hooks in ~/.codex/config.toml:
[features]
hooks = trueThen install the plugin:
codex plugin marketplace add https://github.com/minipuft/minipuft-plugins.git
codex plugin add codex-prompts@minipuftRestart Codex, run /hooks to review the plugin hooks, then try >>tech_evaluation_chain library:'zod' context:'API validation'.
Related MCP server: n8n-MCP
More Client Setups
Claude Desktop
Option A: GitHub Release (recommended)
Download
claude-prompts-{version}.mcpbfrom ReleasesDrag into Claude Desktop Settings → MCP Servers
Done
The .mcpb bundle is self-contained (~5MB); no npm required.
Option B: NPX (auto-updates)
Add to your config file:
macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%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'
Client setup: VS Code, Cursor, and other MCP-only clients use the manual configuration guide below.
Plugin installers (recommended where available; adds hooks):
# OpenCode (full hooks)
npm install -g opencode-prompts && opencode-prompts install
# Gemini CLI (partial hooks)
gemini extensions install https://github.com/minipuft/gemini-promptsManual config for VS Code, Cursor, OpenCode (no hooks), Gemini CLI (no hooks), Codex (no plugin hooks), Windsurf, and Zed: see Client Integration Guide for per-client config locations, JSON examples, and --client preset matrix. Client Capabilities Reference covers profile mapping and limits.
From source (developers):
git clone https://github.com/minipuft/claude-prompts-mcp.git
cd claude-prompts-mcp/server && npm install && npm run build && npm testPoint your MCP config to server/dist/index.js. Transport: --transport=stdio (default) or --transport=streamable-http.
Custom resources: --init=~/my-prompts scaffolds a starter workspace: three example prompts plus config.json. Edit them (YAML schema), or have your AI author new prompts, gates, and frameworks via resource_manager. Point MCP_RESOURCES_PATH at an existing workspace if you already have one in the right shape. See Custom Resources Guide.
What You Get
Four primitives you author, version, and compose. The bundled set ships 51 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.
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.
A gate catches a missing field, the model corrects itself, and the chain passes. Recorded on haiku, the cheapest model.
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.
There are two source-of-truth scopes. MCP prompt YAML underserver/resources/ is canonical
for skills compiled by this repository. Shared user-authored operational skills, rules, and
global instructions are canonical in ~/.claude; Codex and OpenCode installations are
one-way downstream consumers and must not be edited independently. Codex uses per-skill
symlinks; Codex and OpenCode share a generated global AGENTS.md containing the global
CLAUDE.md plus compact rule dispatch. OpenCode natively discovers ~/.claude/skills and loads
that generated file through its instructions configuration. ~/.codex/rules/ remains
reserved for Codex command-execution policy.
Repository guidance follows the same ownership rule. CLAUDE.md plus .claude/rules/*.md are
canonical; the tracked AGENTS.md is a generated compact projection for clients that prefer that
filename. It carries selected project-wide handbook sections plus conditional dispatch entries for
every Claude rule rather than copying all rule bodies into always-loaded context. The renderer
enforces Codex's documented default 32 KiB project-guidance budget. A pre-commit hook regenerates
it from staged source bytes, and CI rejects drift:
npm run guidance:sync # regenerate AGENTS.md
npm run guidance:check # verify the committed projection# 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 Claude Code skills, Cursor rules, OpenCode commands, and more. 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. Full support on Claude Code (this repo) and OpenCode; partial on Gemini CLI; experimental on Codex, where Codex hooks are off by default and each install requires a one-time /hooks trust review. Other clients get the three MCP tools but no hook-driven behaviors. 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
cd server
npm install
npm run build # esbuild bundles to dist/index.js
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)
| Name | Required | Description | Default |
|---|---|---|---|
| gates | No | Unified gate specification - Accepts gate IDs (strings), custom checks ({name, description}), or full gate definitions. Supports mixed types in single array for maximum flexibility. Canonical parameter for all gate specification (v3.0.0+). | |
| command | No | Prompt ID to expand. Resulting prompt will include CAGEERF phase guidance for you to apply. | |
| options | No | Additional execution options (key-value pairs) passed through to execution. | |
| chain_id | No | Resume token (e.g., `chain-demo#2`). RESUME: chain_id + user_response only. Omit command. | |
| gate_action | No | User choice after gate retry limit exhaustion. "retry" resets attempt count, "skip" bypasses the gate, "abort" stops execution. | |
| gate_verdict | No | Gate review result when resuming. PREFERRED (structured, cannot be malformed): {overall:"PASS"|"FAIL", rationale:"...", per_gate:[{index:1, passed:true, rationale:"..."}]}. Also accepts the legacy string "GATE_REVIEW: PASS - rationale". Rationales are single-line. Keep user_response for actual step output. | |
| force_restart | No | Create a new chain execution (increments chain ID). Use `command`. | |
| user_response | No | Your Step output to capture before advancing. Supply the same text you would reply with during manual execution. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Despite no annotations, the description discloses key behavior: it returns instructions rather than executing phases itself ("WHAT YOU DO: Execute each phase yourself"). It also details retry limits, presets, modifiers, and shell validation behavior, which go beyond the structured schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is moderately long but well-organized into sections (WHAT IT RETURNS, WHAT YOU DO, SYNTAX, PRESETS, MODIFIERS). Each section contributes practical usage information with minimal waste, though it could be tightened.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (8 params, nested objects, no output schema), the description covers the overall workflow, syntax, chaining, validation, presets, and modifiers. It does not explicitly explain the resume parameters (chain_id, gate_verdict, user_response) but the schema descriptions cover those, so the description adds sufficient context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds high-level syntax context (e.g., >>prompt_id, :: verify) but does not map those directly to the named parameters or add per-parameter meaning beyond the schema's own descriptions. It introduces concepts like verify and presets that don't correspond clearly to schema fields.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's verb and resource: "Execute prompts with C.A.G.E.E.R.F framework and ground-truth validation." It defines what it returns (prepared prompt + phase instructions) and what the agent should do, making it distinct from sibling tools like system_control and resource_manager.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context on when to use the tool (for executing prompts with CAGEERF and validation) and how to invoke it via syntax examples. It does not explicitly name alternatives or exclusions, but the purpose is specific enough that selection is unambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| id | No | ||
| name | No | ||
| gates | No | ||
| limit | No | ||
| tools | No | ||
| action | Yes | ||
| detail | No | ||
| filter | No | ||
| format | No | ||
| phases | No | ||
| reason | No | ||
| confirm | No | ||
| enabled | No | ||
| persist | No | ||
| version | No | ||
| category | No | ||
| guidance | No | ||
| arguments | No | ||
| framework | No | ||
| gate_type | No | ||
| activation | No | ||
| to_version | No | ||
| chain_steps | No | ||
| description | No | ||
| enabled_only | No | ||
| from_version | No | ||
| retry_config | No | ||
| search_query | No | ||
| skip_version | No | ||
| pass_criteria | No | ||
| resource_type | Yes | ||
| execution_hint | No | ||
| system_message | No | ||
| chain_step_data | No | ||
| chain_step_index | No | ||
| chain_step_order | No | ||
| tool_descriptions | No | ||
| gate_configuration | No | ||
| chain_step_operation | No | ||
| user_message_template | No | ||
| system_prompt_guidance | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the full burden of disclosing behavioral traits. It mentions CRUD and a few action constraints (e.g., switch is framework-only), but does not describe side effects such as destructive deletes, persistence, versioning, or consequences of reload/rollback/clear. Many actions from the schema are absent, so the agent remains unaware of their behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is exceptionally concise and well-structured, with a clear title, usage line, resource types, actions, and a single special-case instruction. Each line adds necessary information without filler, and the layout makes it easy to scan.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (41 parameters, 14 actions, 4 resource types), the description is far from complete. It omits the 'checkpoint' resource type and advanced actions such as analyze_type, analyze_gates, history, rollback, compare, and clear. No output schema exists, so the description should cover more of the tool's capabilities.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 41 parameters with zero description coverage, so the tool description must compensate. It does clarify resource_type by defining prompt, gate, and framework, and it explains some action constraints, but the overwhelming majority of parameters (id, name, gates, limit, version, etc.) remain undocumented. The description only partially addresses the required parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description immediately establishes a specific purpose: 'Unified CRUD for prompts, gates, and frameworks.' It names concrete resource types and lists actions, making it clear this is a management tool for these entities. The title and usage string further reinforce the verb-resource relationship.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a usage template and enumerates resource types and actions, giving clear context for how to invoke the tool. However, it does not explicitly state when to choose resource_manager over sibling tools like prompt_engine or system_control, nor does it mention when not to use it. The special case for action:'guide' is a helpful guideline but limited.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
system_controlSystem ControlD
⚙️ SYSTEM CONTROL [CAGEERF]: System administration. Status shows current CAGEERF phase context.
| Name | Required | Description | Default |
|---|---|---|---|
| topic | No | Guide topic when requesting guidance. | |
| action | Yes | Use 'guide' with topic:'framework' for phase-specific operation guidance. | |
| reason | No | Audit-friendly explanation for switches, config changes, or restarts. | |
| persist | No | When true, gate/framework enable/disable changes are also written to config.json. | |
| framework | No | Framework identifier when switching. Use framework:list to see available options. | |
| operation | No | Sub-command for the selected action (e.g. framework: switch|list|enable|disable, analytics: view|reset|history). | |
| session_id | No | Target session ID or chain ID for session operations. | |
| search_query | No | Filter gates by keyword (matches ID, name, or description). Use with gates:list action. | |
| show_details | No | Request an expanded response for list/status style commands. | |
| include_history | No | Include historical entries (where supported). | |
| include_metrics | No | Include detailed metrics output (where supported). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for behavioral disclosure. It only offers a minor note about status showing CAGEERF phase context, without disclosing any actions, side effects, or persistence behaviors inherent to system administration.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely brief, but the brevity results in under-specification rather than effective conciseness. The single vague sentence adds little value beyond the tool's name and does not earn its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 11 parameters, no annotations, and no output schema, the description must provide substantial context but only gives a vague one-liner. It fails to explain the tool's operations, supported actions, or expected behavior, making it inadequate for safe invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides descriptions for all 11 parameters, achieving 100% coverage. The tool description adds no additional parameter semantics, so the baseline score of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'System administration' and 'Status shows current CAGEERF phase context,' which is vague and largely restates the tool's name. It fails to specify any concrete verb or resource and does not differentiate from sibling tools like prompt_engine or resource_manager.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. There is no mention of use cases, prerequisites, or exclusions, leaving the agent without criteria for selecting this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
v0.1.0- First observed
prompt_engine - First observed
resource_manager - First observed
system_control
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
- PromptOTOAuthcom.promptot
Manage, version, and publish LLM prompts with blocks, variables, and evaluations.
Your prompt library inside your AI: 1,000+ pro templates, frameworks, vocab & pipelines.
Self-hosted AI prompt library: prompts, collections, tags, teams, chains. 29 MCP tools for agents.
Hosted runtime for persistent agent teams, durable workflows, memory, schedules, and goals.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables creation, management, and templating of prompts through a simplified SOLID architecture, allowing users to organize prompts by category and fill in templates at runtime.13 npm118MIT
- AlicenseAqualityAmaintenanceA Model Context Protocol server that provides AI assistants with comprehensive access to n8n node documentation, properties, and operations for effective workflow automation.2877,070 npm22,906MIT
- AlicenseAqualityCmaintenanceProvides 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.5376 npm4,293GPL 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-