Skip to content
Back to search

mcp-prompts

Model Context Protocol server for managing, storing, and providing prompts and prompt templates for LLM interactions.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/sparesparrow--mcp-prompts/badge.svg)](/listings/sparesparrow--mcp-prompts)

HTML

<a href="/listings/sparesparrow--mcp-prompts"><img src="/api/listings/sparesparrow--mcp-prompts/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

1. Install from GitHub Packages

GitHub Packages asks for a token even for public packages (without one the install fails with `401 Unauthorized`). Create a personal access token with the `read:packages` scope (or, with the GitHub CLI, run `gh auth refresh -h github.com -s read:packages`), then add this to `~/.npmrc`:

@sparesparrow:registry=https://npm.pkg.github.com
//npm.pkg.github.com/:_authToken=YOUR_TOKEN

Keep the token out of any file you commit. Then install:

npm install -g @sparesparrow/mcp-prompts
mcp-prompts   # starts the MCP server on stdio; stop it with Ctrl+C

The package ships the prompts in `data/prompts`, and the server finds them wherever an MCP client starts it from. Three environment variables change what it loads, each layer replacing the one before it for prompts with the same `id`:

| Variable | What it loads | |---|---| | `PROMPTS_DIR` | A directory used *instead of* the bundled prompts. | | `PROMPTS_CATALOG_URL` | A JSON catalog fetched once at start: an array of prompts, or `{ "prompts": [...] }`. It must be `https` (plain `http` only to `localhost`). The server waits at most 5 s and reads at most 1 MB, and it skips entries that are not valid prompts. If the fetch fails, the other prompts stay. | | `PROMPTS_EXTRA_DIRS` | Your own directories, separated by `:` (`;` on Windows), loaded last. |

`get_stats` reports how many prompts came from each source (`bundled`, `catalog`, `user`, and `session` for prompts added with `add_prompt`).

To install from npm instead, skip the `~/.npmrc` lines above and run `npm install -g @sparesparrow/mcp-prompts`. It is the same package, and npm needs no token.

2. Add the server to your MCP client

**Claude Code**, for every project:

claude mcp add -s user mcp-prompts -- mcp-prompts

Or for one project, commit a `.mcp.json` at its root (no paths or tokens in it). Claude Code asks you to approve it the first time:

{
  "mcpServers": {
    "mcp-prompts": {
      "command": "mcp-prompts",
      "args": []
    }
  }
}

Check it with `claude mcp list`. Use one of the two: registering the same name at both scopes gives you two servers.

**Claude Desktop** and other clients take the same command in their config (for Claude Desktop, `claude_desktop_config.json`), with the same `mcpServers` block as above. If the client does not find `mcp-prompts` on its PATH, use the full path from `which mcp-prompts` as the `command`.

Install a profile

By default an install serves every bundled prompt, so every unfiltered `list_prompts` call returns all of them. A **profile** serves only the prompts one kind of work needs:

| Profile | For | Prompts | A `list_prompts` call returns | |---|---|---|---| | `software-dev` | Analysing and reviewing a software project | 13 | 21% of the whole library's | | `embedded-iot` | Firmware, Raspberry Pi, Android and device bridges | 11 | 23% | | `mia-vehicle` | The MIA in-car assistant at run time | 8 | 13% | | `voice-home` | Voice commands and home automation | 13 | 37% | | `learning-loop` | The self-improvement loop | 8 | 11% |

claude mcp add -s user mcp-prompts -- mcp-prompts --profile software-dev
mcp-prompts profiles          # what each profile serves, and which prompts are in none

Several names (`--profile software-dev,embedded-iot`) serve the prompts of any of them. The profiles live in [`data/prompts/profiles.json`](data/prompts/profiles.json); [deploy/README.md](deploy/README.md) says what is in each, how the sizes were measured, how to install one over Docker or HTTP, and how to change or add one.

Choose what gets installed

Beyond the profiles, you can choose yourself (the [install page](https://sparesparrow.github.io/mcp-prompts/) does it with checkboxes and writes the options below for you):

- which **plain prompts** and which **templates** to serve (two separate lists);

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 17 lines
  1. {
  2. "name": "sparesparrow",
  3. "owner": {
  4. "name": "sparesparrow",
  5. "url": "https://github.com/sparesparrow"
  6. },
  7. "description": "Claude Code plugins by sparesparrow.",
  8. "plugins": [
  9. {
  10. "name": "mcp-prompts",
  11. "source": "./plugin",
  12. "description": "A prompt library with templates: find, fill and save prompts, with your own folder, tags, language and catalog.",
  13. "category": "productivity",
  14. "tags": ["prompts", "templates", "mcp"]
  15. }
  16. ]
  17. }
README.md · README · 386 lines
  1. # mcp-prompts
  2. A [Model Context Protocol](https://modelcontextprotocol.io/) server that stores, searches and serves
  3. prompt templates and agent configurations to any MCP client (Claude Desktop, Claude Code, Cursor and
  4. others), plus a script that uses those templates to orchestrate Claude CLI agents over a whole project.
  5. Listed on [Glama](https://glama.ai/mcp/servers/sparesparrow/mcp-prompts),
  6. [MCP Market](https://mcpmarket.com/server/prompts-server) and
  7. [AIBASE](https://mcp.aibase.com/server/1916334459480600578). A Rust reimplementation focused on memory
  8. efficiency and concurrency lives in [mcp-prompts-rs](https://github.com/sparesparrow/mcp-prompts-rs).
  9. **[Configure an install in the browser](https://sparesparrow.github.io/mcp-prompts/):** pick a profile
  10. or your own prompts and templates, choose the MCP capabilities, and copy the matching `claude mcp add`
  11. command, client config, URL or config file. The page reads the library from this branch.
  12. ## What It Does
  13. - **Stores prompts** as JSON files in `data/prompts/`
  14. - **Exposes MCP tools** for querying and managing prompts
  15. - **Provides agent templates** for project orchestration
  16. - **Works with Claude Desktop, Cursor, and other MCP clients**
  17. ## Packages
  18. - **GitHub Packages (preferred):** [`@sparesparrow/mcp-prompts`](https://github.com/sparesparrow/mcp-prompts/pkgs/npm/mcp-prompts), registry `https://npm.pkg.github.com`
  19. - npm: [`@sparesparrow/mcp-prompts`](https://www.npmjs.com/package/@sparesparrow/mcp-prompts), no token needed
  20. Both registries receive the same version from every `v*` tag (first together at 4.0.2); Docker images follow the same tag.
  21. - Docker: `ghcr.io/sparesparrow/mcp-prompts` (Docker Hub: [`sparesparrow/mcp-prompts`](https://hub.docker.com/r/sparesparrow/mcp-prompts))
  22. ## Claude Code plugin
  23. The plugin starts the server for you, asks for your settings once, and adds three skills that do the tool calls:
  24. ```
  25. /plugin install mcp-prompts --marketplace sparesparrow/mcp-prompts
  26. ```
  27. Or in two steps: `/plugin marketplace add sparesparrow/mcp-prompts`, then `/plugin install mcp-prompts@sparesparrow`.
  28. Claude Code then asks for these settings; change them later in `/config`:
  29. | Setting | What it does |
  30. |---|---|
  31. | Package registry | `github` (default) or `npm`. Both serve the same build. `npm` needs no token and is the one that works in cloud sessions. |
  32. | GitHub token | A classic personal access token with `read:packages`, used only with `github`. Claude Code keeps it in secure storage and passes it to npm in `NODE_AUTH_TOKEN`; it is never written to a file. |
  33. | Your prompts folder | Your own prompt JSON files, loaded on top of the bundled ones (`PROMPTS_EXTRA_DIRS`). A prompt with the same `id` replaces the bundled one. |
  34. | Default tags | Comma-separated tags the skills search unless you name others, such as `mia-dev`. |
  35. | Preferred language | `any`, `cs` or `en`: which version to pick when a prompt exists in more than one language. |
  36. | Shared catalog URL | An `https` URL of a JSON catalog, such as one on GitHub Pages (`PROMPTS_CATALOG_URL`). |
  37. The skills:
  38. - `/mcp-prompts:find-prompt` searches by your default tags, a search text and your language.
  39. - `/mcp-prompts:use-prompt <id>` asks for each template variable, fills the template and checks that no `{{` is left.
  40. - `/mcp-prompts:save-prompt` writes a prompt as a JSON file into your folder. Unlike the `add_prompt` tool, which
  41. keeps it in memory only, the file outlasts a restart. Reconnect the server in `/mcp` to load it.
  42. The plugin runs the server with `npx`, pinned to the plugin's version. For that one command it uses its own npm
  43. settings file (`plugin/npmrc/`) instead of your `~/.npmrc`, so a registry mirror or proxy set there is not used.
  44. ## Quick Start
  45. ### 1. Install from GitHub Packages
  46. GitHub Packages asks for a token even for public packages (without one the install fails with `401 Unauthorized`). Create a personal access token with the `read:packages` scope (or, with the GitHub CLI, run `gh auth refresh -h github.com -s read:packages`), then add this to `~/.npmrc`:
  47. ```ini
  48. @sparesparrow:registry=https://npm.pkg.github.com
  49. //npm.pkg.github.com/:_authToken=YOUR_TOKEN
  50. ```
  51. Keep the token out of any file you commit. Then install:
  52. ```bash
  53. npm install -g @sparesparrow/mcp-prompts
  54. mcp-prompts # starts the MCP server on stdio; stop it with Ctrl+C
  55. ```
  56. The package ships the prompts in `data/prompts`, and the server finds them wherever an MCP client starts it from. Three environment variables change what it loads, each layer replacing the one before it for prompts with the same `id`:
  57. | Variable | What it loads |
  58. |---|---|
  59. | `PROMPTS_DIR` | A directory used *instead of* the bundled prompts. |
  60. | `PROMPTS_CATALOG_URL` | A JSON catalog fetched once at start: an array of prompts, or `{ "prompts": [...] }`. It must be `https` (plain `http` only to `localhost`). The server waits at most 5 s and reads at most 1 MB, and it skips entries that are not valid prompts. If the fetch fails, the other prompts stay. |
  61. | `PROMPTS_EXTRA_DIRS` | Your own directories, separated by `:` (`;` on Windows), loaded last. |
  62. `get_stats` reports how many prompts came from each source (`bundled`, `catalog`, `user`, and `session` for prompts added with `add_prompt`).
  63. To install from npm instead, skip the `~/.npmrc` lines above and run `npm install -g @sparesparrow/mcp-prompts`. It is the same package, and npm needs no token.
  64. ### 2. Add the server to your MCP client
  65. **Claude Code**, for every project:
  66. ```bash
  67. claude mcp add -s user mcp-prompts -- mcp-prompts
  68. ```
  69. Or for one project, commit a `.mcp.json` at its root (no paths or tokens in it). Claude Code asks you to approve it the first time:
  70. ```json
  71. {
  72. "mcpServers": {
  73. "mcp-prompts": {
  74. "command": "mcp-prompts",
  75. "args": []
  76. }
  77. }
  78. }
  79. ```
  80. Check it with `claude mcp list`. Use one of the two: registering the same name at both scopes gives you two servers.
  81. **Claude Desktop** and other clients take the same command in their config (for Claude Desktop, `claude_desktop_config.json`), with the same `mcpServers` block as above. If the client does not find `mcp-prompts` on its PATH, use the full path from `which mcp-prompts` as the `command`.
  82. ### Install a profile
  83. By default an install serves every bundled prompt, so every unfiltered `list_prompts` call returns
  84. all of them. A **profile** serves only the prompts one kind of work needs:
  85. | Profile | For | Prompts | A `list_prompts` call returns |
  86. |---|---|---|---|
  87. | `software-dev` | Analysing and reviewing a software project | 13 | 21% of the whole library's |
  88. | `embedded-iot` | Firmware, Raspberry Pi, Android and device bridges | 11 | 23% |
  89. | `mia-vehicle` | The MIA in-car assistant at run time | 8 | 13% |
  90. | `voice-home` | Voice commands and home automation | 13 | 37% |
  91. | `learning-loop` | The self-improvement loop | 8 | 11% |
  92. ```bash
  93. claude mcp add -s user mcp-prompts -- mcp-prompts --profile software-dev
  94. mcp-prompts profiles # what each profile serves, and which prompts are in none
  95. ```
  96. Several names (`--profile software-dev,embedded-iot`) serve the prompts of any of them. The
  97. profiles live in [`data/prompts/profiles.json`](data/prompts/profiles.json);
  98. [deploy/README.md](deploy/README.md) says what is in each, how the sizes were measured, how to
  99. install one over Docker or HTTP, and how to change or add one.
  100. ### Choose what gets installed
  101. Beyond the profiles, you can choose yourself (the [install page](https://sparesparrow.github.io/mcp-prompts/)
  102. does it with checkboxes and writes the options below for you):
  103. - which **plain prompts** and which **templates** to serve (two separate lists);
  104. - which **MCP capabilities** expose them: `tools`, `prompts` (each prompt becomes a slash command, with a template's variables as its arguments) and `resources` (each prompt is readable as `prompts://<id>`, for attaching as context);
  105. - whether the install is **read-only** (no `add_prompt`, `update_prompt` or `delete_prompt`).
  106. The same options go in the install command, the client config file, a dedicated config file or the URL:
  107. | Option | Flag | Environment | Config file | URL (`/mcp?…`) |
  108. |---|---|---|---|---|
  109. | Profiles to serve | `--profile` | `MCP_PROMPTS_PROFILE` | `profile` | `profile` |
  110. | Plain prompts to serve | `--prompts` | `MCP_PROMPTS_PROMPTS` | `prompts` | `prompts` |
  111. | Templates to serve | `--templates` | `MCP_PROMPTS_TEMPLATES` | `templates` | `templates` |
  112. | Leave out of both | `--exclude` | `MCP_PROMPTS_EXCLUDE` | `exclude` | `exclude` |
  113. | Capabilities (default `tools`) | `--expose` | `MCP_PROMPTS_EXPOSE` | `expose` | `expose` |
  114. | Read-only | `--read-only` | `MCP_PROMPTS_READ_ONLY` | `readOnly` | `readOnly` |
  115. | Library instead of the bundled one | `--prompts-dir` | `PROMPTS_DIR` | `promptsDir` | – |
  116. | Your own directories, served in full | `--dir` (repeat) | `MCP_PROMPTS_DIRS` | `dirs` | – |
  117. | Save changes to a directory | `--state-dir` | `MCP_PROMPTS_STATE_DIR` | `stateDir` | – |
  118. | Config file | `--config` | `MCP_PROMPTS_CONFIG` | – | – |
  119. A list is comma-separated, and its entries can be:
  120. - `all` (the default for each list) or `none`;
  121. - a **group**, meaning a directory of the library such as `mia-car` (`cognitive` also covers `cognitive/meta`);
  122. - a prompt **id**;
  123. - `tag:<tag>`.
  124. Flags override environment variables, which override the config file. Paths in a config file are relative to that file. The lists narrow a profile when both are given. Only the library is filtered: prompts in your own `--dir` directories, and prompts added while the server runs, are always served. An own prompt with a library prompt's id replaces it.
  125. See what there is to choose, and what a choice serves:
  126. ```bash
  127. mcp-prompts catalog # groups, with plain/template counts, tags and ids
  128. mcp-prompts catalog --prompts none --templates mia-car --json
  129. ```
  130. Then install it in any of these forms. `mcp-prompts config` with the same options prints all four, ready to paste:
  131. ```bash
  132. # Command
  133. claude mcp add -s user mcp-prompts -- mcp-prompts --prompts none --templates mia-car,openclaw --expose tools,prompts --read-only
  134. ```
  135. The same in a client config (`.mcp.json`, `claude_desktop_config.json`, Cursor and others):
  136. ```json
  137. {
  138. "mcpServers": {
  139. "mcp-prompts": {
  140. "command": "mcp-prompts",
  141. "args": ["--prompts", "none", "--templates", "mia-car,openclaw", "--expose", "tools,prompts", "--read-only"]
  142. }
  143. }
  144. }
  145. ```
  146. ```bash
  147. # Dedicated config file (see examples/mcp-prompts.config.json), referenced from any client
  148. mcp-prompts --config /absolute/path/to/mcp-prompts.json
  149. # Docker: the mcp tag is the stdio server; options go after the image name or in the environment
  150. docker run --rm -i ghcr.io/sparesparrow/mcp-prompts:mcp --prompts none --templates mia-car --expose tools,prompts
  151. docker run --rm -i -e MCP_PROMPTS_PROFILE=mia-vehicle ghcr.io/sparesparrow/mcp-prompts:mcp
  152. # URL, against a server started with mcp-prompts-http (see HTTP Mode)
  153. claude mcp add -s user --transport http mcp-prompts "http://localhost:3003/mcp?prompts=none&templates=mia-car,openclaw&expose=tools,prompts&readOnly=true"
  154. ```
  155. A URL chooses from what that server serves. It can narrow the server's selection and turn read-only on, but it cannot widen the selection, turn read-only off, or name directories. Mistyped options, and a profile the library does not have, stop the server with exit code 2, and a URL with them gets HTTP 400. An entry that matches nothing, or matches only the other list (`--prompts mia-car` when mia-car holds only templates), is logged as a warning.
  156. ### Build from source
  157. To run unreleased changes:
  158. ```bash
  159. pnpm install
  160. pnpm build
  161. node dist/mcp-server-standalone.js # or: pnpm start
  162. ```
  163. and point your client at that file:
  164. ```json
  165. {
  166. "mcpServers": {
  167. "mcp-prompts": {
  168. "command": "node",
  169. "args": ["/absolute/path/to/mcp-prompts/dist/mcp-server-standalone.js"],
  170. "env": { "PROMPTS_DIR": "/absolute/path/to/mcp-prompts/data/prompts" }
  171. }
  172. }
  173. }
  174. ```
  175. ### 3. Use in Claude
  176. Ask Claude:
  177. - "List all prompts tagged with orchestration"
  178. - "Get the claudepy-esp32-android-bridge-workflow prompt"
  179. - "Apply the claudepy-esp32-android-bridge-workflow template with esp32_firmware_path set to ./firmware"
  180. - "Add a prompt for Python FastAPI best practices"
  181. Prompts added or changed through `add_prompt` / `update_prompt` live in memory and are lost when the server restarts, unless the server has a state directory: with `--state-dir ~/.local/share/mcp-prompts` each change is saved there as a JSON file and loaded at the next start. Every MCP client on a machine starts its own server; pointed at the same directory they see each other's changes without a restart. `get_stats` says which applies (`"storage": "file"` or `"memory"`). A prompt that belongs in the bundled library is a JSON file under `data/prompts/` with a stable id, added by pull request.
  182. ## HTTP Mode
  183. The same prompts are also available as a JSON API, for clients that don't speak MCP:
  184. ```bash
  185. pnpm build
  186. PORT=3003 pnpm start:http
  187. # or: mcp-prompts-http, or the default Docker image (port 3003), or: docker compose up -d --wait --build
  188. ```
  189. It listens on `127.0.0.1` unless `HOST` says otherwise.
  190. | Method and path | Does |
  191. |---|---|
  192. | `GET /health`, `/ready`, `/version` | Liveness; readiness and mode (`readOnly`, `auth`, `storage`); package version |
  193. | `GET /v1/prompts?tags=a,b&search=text&category=c&isTemplate=true&limit=20&offset=0` | List prompt summaries, with `total` and `has_more` |
  194. | `POST /v1/prompts` | Add a prompt (same fields as `add_prompt`) |
  195. | `GET` / `PUT` / `DELETE /v1/prompts/:id` | Read, update or delete one prompt |
  196. | `POST /v1/prompts/:id/apply` | Fill a template: `{ "variables": { ... } }` → `{ "result": "...", "missing": [], "unused": [] }` |
  197. | `GET /v1/stats` | Same counts as `get_stats` |
  198. | `GET /mcp/tools`, `POST /mcp/tools/:name` | Call any MCP tool by name: `{ "arguments": { ... } }` |
  199. | `POST /mcp?…` | MCP itself (Streamable HTTP, stateless), for `claude mcp add --transport http`; the query string chooses a profile, prompts, templates and capabilities (see [Install a profile](#install-a-profile)) |
  200. ```bash
  201. curl -s -X POST localhost:3003/v1/prompts/claudepy-esp32-android-bridge-workflow/apply \
  202. -H 'Content-Type: application/json' -d '{"variables":{"esp32_firmware_path":"./firmware"}}'
  203. ```
  204. `mcp-prompts-http` takes the same options as `mcp-prompts` (flags, environment, `--config`); they set what the whole server serves. With `--read-only`, the write routes and tools are left out.
  205. Invalid input answers 400, unknown prompts 404, a taken id 409. Set `CORS_ORIGIN` to allow browser clients.
  206. Changes made over HTTP live in memory, like those made over MCP, unless `--state-dir` is set; the files in `data/prompts` are never rewritten.
  207. Prompts are instructions agents act on, so the server is careful about who may change them:
  208. - `MCP_PROMPTS_AUTH_TOKEN` (or `MCP_PROMPTS_AUTH_TOKEN_FILE`): when set, every request except `/health`, `/ready` and `/version` must send `Authorization: Bearer <token>`.
  209. - Listening beyond loopback (`HOST=0.0.0.0`) with writes enabled and no token is refused at start. Serve read-only, set a token, or set `MCP_PROMPTS_ALLOW_INSECURE=true` behind a proxy that authenticates.
  210. - `MCP_PROMPTS_ALLOWED_HOSTS` and `MCP_PROMPTS_ALLOWED_ORIGINS` list the Host names and browser origins to accept; on loopback only loopback names are.
  211. - The Docker image is read-only unless `MCP_PROMPTS_READ_ONLY=false` is set together with a token.
  212. ## Orchestrating Projects
  213. Use the orchestrate script to analyze entire projects:
  214. ```bash
  215. ./scripts/orchestrate-project.sh ~/projects/mia analyze
  216. ./scripts/orchestrate-project.sh ~/projects/esp32-bpm-detector review
  217. ```
  218. This automatically:
  219. 1. Detects project type
  220. 2. Loads appropriate main agent
  221. 3. Spawns specialized subagents
  222. 4. Runs comprehensive analysis
  223. 5. Returns structured results
  224. ## MCP Tools
  225. | Tool | Description |
  226. |------|-------------|
  227. | `list_prompts` | List prompts, filtered by tags, category, kind or a search term, a page at a time |
  228. | `get_prompt` | Retrieve a prompt by ID |
  229. | `add_prompt` | Add a new prompt or template |
  230. | `update_prompt` | Modify existing prompt |
  231. | `delete_prompt` | Remove prompt |
  232. | `apply_template` | Fill a template prompt's `{{variables}}`, naming any left unfilled |
  233. | `get_stats` | Repository statistics |
  234. ## Prompts Organization
  235. ```
  236. data/prompts/
  237. ├── main-agents/ # 9 project orchestration templates
  238. │ ├── main_agent_python_backend.json
  239. │ ├── main_agent_cpp_backend.json
  240. │ ├── main_agent_android_app.json
  241. │ ├── main_agent_embedded_iot.json
  242. │ ├── main_agent_web_frontend.json
  243. │ └── ... # also web backend, DevOps, multiplatform IoT, generic
  244. │
  245. ├── subagents/ # architecture, security and test analysts
  246. ├── cognitive/ # 7 layers: perception, episodes, semantic, procedures,
  247. │ # evaluation, meta, transfer
  248. ├── embedded/, cross-platform/, home-automation/, mia-car/, voice-intelligence/
  249. │ # domain knowledge
  250. ├── claudepy-workflows/, openclaw/
  251. │ # agent workflow and routing prompts
  252. ├── learned/ # prompts produced by the learning loop
  253. └── profiles.json # the profiles: which of the above each kind of work gets
  254. ```
  255. ## Architecture
  256. Two layers. The full server (`src/mcp/mcp-server.ts`) is hexagonal: the domain in `src/core` (entities,
  257. events, services and the repository and event-bus ports) knows nothing about storage or transport, and
  258. storage adapters plug in behind the ports — file and in-memory in `src/adapters`; the earlier DynamoDB,
  259. S3 and SQS adapters, Lambda handlers and CDK stack are kept in `archive/aws` and `cdk/`. The standalone
  260. server that `pnpm start` and the npm binary run is the small one below: it reads the JSON files in
  261. `PROMPTS_DIR` directly and speaks MCP over stdio.
  262. ```
  263. ┌──────────────────────────────┐
  264. │ MCP Server (stdio) │
  265. │ ├── list_prompts │
  266. │ ├── get_prompt │
  267. │ ├── add_prompt │
  268. │ └── ... │
  269. ├──────────────────────────────┤
  270. │ File Storage │
  271. │ └── data/prompts/*.json │
  272. └──────────────────────────────┘
  273. Orchestration:
  274. orchestrate-project.sh
  275. ↓ loads prompts
  276. ↓ builds agent config
  277. ↓ calls claude CLI
  278. Actual agent execution
  279. ```
  280. ## Development
  281. ```bash
  282. pnpm install # Install dependencies
  283. pnpm build # Build TypeScript
  284. pnpm dev # Watch mode
  285. pnpm test # Run tests
  286. pnpm orchestrate # Test orchestration
  287. pnpm run site # Rebuild the install page (index.html) from site/; see site/README.md
  288. ```
  289. ## Enterprise Deployment
  290. For enterprise features (AWS, multi-tenant, payments), see [archive/aws/README.md](archive/aws/README.md).
  291. Most users don't need this - the local MCP server is sufficient.
  292. ## License
  293. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.