In July 2026 we shipped MCP support for Keep My Prompts, and it compresses a whole workflow into one sentence. You no longer open a browser tab, find the right prompt, copy it, and paste it into your AI tool. You type "do this using one of my prompts" and the model connects to your library, reads the titles and your notes, picks the right prompt and applies it. You don't name the prompt. You often don't remember its name anyway, and now you don't have to. The connection is read-only, it runs entirely on your machine, and setting it up takes about two minutes. It is included in the Pro, Ultimate and Team plans from day one. Here is how it works, how to install it in your client, and the design decisions behind it, including the ones that will look like missing features until you see why.
The moment it clicked
The first thing we tried in production was deliberately vague. We had a task open in Claude Code and a matching prompt somewhere in our library, and instead of looking up its name we asked for the task "using one of my prompts", nothing more. The model called the library, got back the list of titles and notes, chose the one we had in mind, fetched its full text and applied it to the task.
That exchange is the entire feature. Everything else in this article is setup instructions and the reasoning behind the design, but the headline is that sentence: your prompt library is now something your AI tools can browse and use on their own, instead of a place you visit.
A terminal exchange in Claude Code: the user asks to rewrite a changelog using one of their prompts without naming it; the model lists the library over MCP, picks the prompt titled Changelog, user-facing based on its notes, and applies it
The first real exchange, reconstructed. The request never names a prompt. The model lists the library, matches the task against titles and notes, and picks. This is not a search feature: there is no keyword index behind it, just the model reading your library's metadata and reasoning about it.
What actually shipped
Keep My Prompts now exposes your library over MCP, the Model Context Protocol, the open standard that Claude Code, Claude Desktop, Cursor, VS Code and most agent-capable AI tools use to talk to external data sources. Concretely, your client gets three tools:
list_prompts: the titles, categories and your notes for every saved prompt, optionally filtered by category. Deliberately not the prompt text: the list stays cheap, and titles plus notes are what the model needs to decide.
get_prompt: the full text and full notes of one prompt, fetched only when the model has chosen.
list_categories: your categories with a count each, for narrowing down a large library.
Want to know how effective your prompts are? Prompt Score analyzes them on 6 criteria.
The connection is strictly read-only. Nothing your model or your client does through MCP can create, edit or delete a prompt. Your library stays yours to change; the tools only read it.
One honest limitation to know before you start: this works with clients that run local MCP servers, which is nearly every desktop tool (Claude Code, Claude Desktop, Cursor, VS Code with Copilot, Windsurf, Zed, Gemini CLI, Codex CLI and more). It does not work with browser-only hosts: claude.ai in a browser tab and ChatGPT on the web only connect to remote MCP servers, and this server is local by design, for reasons we will get to.
Why there is no search tool
The obvious design would have included a search_prompts tool. We built the feature without one, on purpose, and this is the decision that looked most like a missing feature until real use validated it.
Substring search fails on the queries a model actually produces. When you ask for "something for cold emails", no substring of that matches a prompt titled "Outreach opener, agencies". What does work is giving the model the full list of titles and notes and letting it do what models are good at: semantic matching. Your request and your library's metadata land in the same context, and the model connects them.
This moves the quality lever somewhere unusual: your notes field is now a routing signal, not a comment. The note "for cold outreach to agencies, keep it under 120 words" is exactly what lets the model tell that prompt apart from three other email prompts with similar titles. An empty notes field leaves the model guessing from the title alone. If you adopt one habit after reading this, make it writing one sentence of "when to use this" into every prompt's notes.
A diagram showing how the model routes a request to the right prompt: the request on the left, the library's titles and notes in the middle as routing signals, and the chosen prompt on the right, with the note highlighted as the deciding factor
Title says what the prompt is; notes say when to use it. The model reads both and routes. A one-sentence note does more for retrieval quality than any tagging discipline we have tried.
If your library is currently a pile of untitled drafts, the feature will still work, but it will work noticeably better after an hour of cleanup. We wrote about organizing a personal prompt library and migrating out of a spreadsheet before MCP existed; both articles just became setup guides for this feature.
Install it in your client
You need three things: Node.js 20 or newer on your machine, a Keep My Prompts account on a plan with MCP access (Pro, Ultimate or any Team plan), and an API key.
The techniques you're reading about work. Test your prompts now with Prompt Score and see your score in real time.
Step 1: create your key. Go to Settings → MCP in Keep My Prompts and create a key. It is shown exactly once, at creation, and you can revoke it at any time from the same page. Next to the fresh key you get the exact install command for Claude Code, already carrying the current version of the client. Prefer that command over copying from articles, including this one: it is always current.
Step 2: register the server. For Claude Code, the command has this shape:
claude mcp add keepmyprompts -e KMP_API_KEY=kmp_live_... -- npx -y github:simopet/keepmyprompts-mcp#v0.2.0
For Claude Desktop, Cursor, and most other clients, add this to the MCP servers section of the client's configuration file:
The three values are the same everywhere; only the name and location of the config file change per client, so check your client's MCP documentation. Note the #v0.2.0 in both: the install is pinned to a version tag on purpose. Without a tag, your client would silently pick up whatever landed on the repository's default branch since you installed, with no way to roll back.
Step 3: restart the client and ask. "What prompts do I have for code review", "use my follow-up email prompt", or the vague version that started this article. The model picks the right tool on its own.
The client is open source under MIT, and the README covers per-client configuration and troubleshooting for the errors you might actually hit, each of which tells you what it means in plain words.
The security design, and why local beats remote
The part of this feature we spent the most time on is the part you never see, so it is worth stating plainly.
The server runs on your machine and nowhere else. It is a small Node process, spawned by your client over stdio, that makes authenticated HTTPS calls to the Keep My Prompts API with your key. There is no third machine in the path and no persistent connection to keep alive.
Your prompts stay encrypted at rest, and the local server never holds the encryption key. When the model fetches a prompt, the API decrypts it server-side exactly as it does when you open the web app, and sends it over HTTPS. A stolen laptop with your MCP config on it holds an API key you can revoke in one click, not a decryption capability.
Read-only is a security property, not a missing feature. An agent that can read your prompts can pick the wrong one, and the cost is a bad output you notice. An agent that could write to your library could corrupt the one source of truth your whole workflow now depends on, silently. We chose the failure mode you can see.
A diagram of the MCP trust boundary: the client and local server on the user's machine holding only a revocable API key, HTTPS in the middle, and the Keep My Prompts API on the right holding the encryption key and decrypting server-side, with a read-only label on the whole path
The trust boundary. Everything on your machine is revocable; the key that decrypts your prompts never leaves the server. And the whole path is read-only by construction.
Each key is rate-limited and personal, you can hold a handful of active keys (one per machine is the sane pattern, named accordingly), and revoking one kills exactly that machine's access and nothing else. If you run other MCP servers alongside this one, our earlier piece on the MCP attack surface is the checklist we apply to anything we add to our own setup: this server was designed to pass it.
What this replaces, and what it doesn't
It replaces the tab-switch: find prompt, copy, paste, adjust. That loop was the tax on actually using a curated library, and it is gone. It also replaces the "which prompt was it" memory game, because remembering an approximate purpose is now enough.
It does not replace maintaining the library. The model can only route as well as your titles and notes allow, and it cannot know that two near-duplicate prompts exist because you never merged them. Garbage in, garbage routed. If anything, MCP raises the return on the library discipline you already knew you should have.
And if you would rather build this yourself than use ours, that is a real option and we wrote the guide: building your own MCP prompt server covers the from-scratch path. The trade is the one you expect: full control, and you own the maintenance, the auth and the encryption story yourself.
Try it on your own library
MCP access is included in Pro, Ultimate and every Team plan, active from day one, no waitlist. If you are on one of those plans, your key is two clicks away in Settings → MCP, and the whole setup fits in the time your coffee takes to cool.
If your prompts are still scattered across chat histories and text files, this is the feature that makes consolidating them pay off: every prompt you save, title and annotate becomes something every AI tool you use can find and apply on its own. Start your library, save the prompts you actually reuse, write one honest sentence of notes on each, and then ask your AI to use one of them. It will pick right more often than you expect.
