PromptX: an MCP context server that turns Claude and Cursor into named experts

The problem PromptX targets: prompt reuse across chat clients

Most people who use Claude, Cursor or a similar assistant end up rewriting the same instructions. The product manager persona, the code review checklist, the writing style guide: each one gets pasted into a new conversation, and each conversation forgets it the moment the window closes. PromptX's answer is to move that material out of the conversation and into a server that the client queries over MCP.

The README frames the audience broadly. It advertises a PromptX Client for "all users - one-click launch, zero configuration," with downloads for macOS on Apple Silicon, macOS on Intel, and Windows, and it points to a downloads page for Linux and portable builds. The other audience is developers: the repository is a pnpm and Turbo monorepo with apps/, packages/, docker/, features/ and a Cucumber configuration, and the root package.json describes the project as a "DPML-powered AI prompt framework" with structured prompts, memory systems and execution frameworks. So the same repository serves a consumer desktop app and a CLI-oriented framework, which is worth knowing before you pick a path.

How the MCP injection actually works

The mechanism is narrow and easy to describe. The PromptX client starts an HTTP service on your machine and exposes an MCP endpoint at http://127.0.0.1:5203/mcp. You add that URL to the MCP configuration of an AI application. From then on, the AI application can call into PromptX, which is where roles, tools and memory live.

The README shows the interaction as conversation rather than commands. A user says "Show me what experts are available" and the README says the AI displays 23 available roles; a user says "I need a product manager expert" and the assistant adopts that role. The design claim behind this is stated directly: "Treat AI as a person, not software." Intent recognition is delegated to the model, and PromptX supplies the context it needs to act on that intent.

Two things are visible in the repository that the prose does not explain. The root package.json runs a postinstall step that rebuilds better-sqlite3, which points to local SQLite storage, consistent with the "cognitive memory system" the README lists as a core capability. The monorepo also carries a DPML (Deepractice Prompt Markup Language) keyword set, so role and tool definitions appear to be authored in a structured markup rather than plain text. The README does not document the DPML syntax, the memory schema, or how a role definition is written by hand. That is the biggest gap between what the project claims and what a reader can verify from the documentation alone.

Installing PromptX and getting a first expert reply

There are two install paths. The desktop client is the documented one for people who do not want to touch a terminal: download the .dmg or .exe from the links in the README, open it, and the client runs the MCP server for you. The README states that Windows users need Git for Windows installed before the AgentX feature will work.

Once the client is running, register the MCP endpoint in your AI application. This is the exact configuration block the README gives for Claude, Cursor and other MCP-capable tools:

{
  "mcpServers": {
    "promptx": {
      "type": "streamable-http",
      "url": "http://127.0.0.1:5203/mcp"
    }
  }
}

If you are using Trae, the README gives a shorter form that omits the type field:

{
  "mcpServers": {
    "promptx": {
      "url": "http://127.0.0.1:5203/mcp"
    }
  }
}

After saving the configuration and restarting the AI application, the MCP server should appear as connected. Then ask, in plain language, "Show me what experts are available." According to the README, the assistant should list the 23 roles. Follow with "I need a product manager expert" and the same conversation should shift into that role. If nothing appears, the first thing to check is whether the client is running and port 5203 is listening, because the configuration is useless without the local service behind it.

The second path is the CLI, published as @promptx/cli on npm, which the README badges alongside a Docker image at deepracticexs/promptx. The README does not give CLI install or usage steps, so treat the npm package as something to inspect on its own page rather than something this article can walk you through.

Where PromptX gets in the way

The dependency on a local HTTP service is the main structural limitation. The MCP URL is 127.0.0.1:5203, so anything that cannot reach your loopback interface, such as a hosted agent, a remote CI job or a teammate's machine, will not see PromptX at all. That rules out the shared-team-context scenario the product name suggests, unless you put the service somewhere reachable and accept the security work that follows. The README does not discuss remote deployment.

Documentation depth is the second problem. The README is written for a chat user: three steps, two screenshots of dialogue, a video link. It does not document rollback, versioning of roles, how memory is scoped or cleared, or what DPML looks like. The repository contains docs/ and a paper/ directory, but the README does not point readers to specific files there, so you cannot tell from the front page how much of the framework is specified.

There is also a coherence cost in shipping a desktop client and a framework from one repository. The README's headline capabilities (role creation platform, tool development platform, cognitive memory system) describe a developer product, while the quick start describes a consumer app. A reader who wants the former has to infer the path from the monorepo layout.

Finally, the maintenance signal is mixed. The last push was on 2026-05-17, which is four months before this writing, and the most recent release listed is v2.4.1 from 2026-04-12. The repository is not archived, but a four-month gap between the last push and today means the project should not be described as under active development on the strength of these facts alone. Check the issue tracker and release cadence yourself before committing a team to it.

PromptX compared with hand-written system prompts

The obvious alternative is not another product. It is a folder of markdown files and a habit of pasting the right one into each conversation, plus whatever memory feature your AI client already ships. That approach has real advantages: it is version-controlled with git, reviewable in a pull request, diffable, and it works in any client including ones with no MCP support. Its weakness is exactly what PromptX addresses: nothing switches automatically, and nothing persists across sessions unless the client provides it.

A second alternative is building your own MCP server. The protocol is what makes PromptX useful, and the protocol is public, so a team with a specific role taxonomy can expose it directly and skip the DPML layer. The trade-off is that you then own role storage, memory and tool wiring, which is the work PromptX has already done. The README does not claim PromptX is unique in using MCP, and it should not be read that way; its differentiator is the packaged role set and the conversational switching, not the transport.

The honest comparison point is this: if your roles change weekly and you want to review them as diffs, plain files win. If your roles are stable and you want them to appear inside a chat client without manual pasting, PromptX is doing something a folder cannot.

Licence, upgrades and what MIT means here

The repository is MIT licensed, and the root package.json declares "license": "MIT". That is permissive: you can use, modify and redistribute the code, including in commercial settings, provided the copyright notice and licence text are preserved. This is a description of the licence text, not legal advice; if you are embedding PromptX in a product, have your own counsel read the LICENSE file.

Upgrade cost is harder to judge. The repository uses Changesets, with .changeset/ present and changeset scripts defined in the root package.json, and commitlint plus lefthook are configured. That is a conventional release pipeline, and it suggests versioned, changelogged releases rather than silent pushes to main. The releases listed in the repository follow that pattern: v2.3.0, v2.4.0 and v2.4.1 across March and April 2026.

What the repository does not tell you is whether role definitions or the memory database survive an upgrade. The postinstall step rebuilds better-sqlite3, which is a native module, so a Node.js major-version change on your machine can break the install before PromptX itself is at fault. The README does not document a migration path for stored memory, so back up the data directory before upgrading if you have accumulated anything you care about.

Editorial conclusion

PromptX fits engineers and product people who already live inside an MCP-capable client such as Claude or Cursor and want reusable expert roles and memory without building a prompt framework themselves. Skip it if you need a stable, documented API surface you can program against, or if your workflow lives in a terminal or CI pipeline rather than a chat window. Before adopting, verify three things in your own environment: that the MCP endpoint at http://127.0.0.1:5203/mcp answers after the client starts, that the roles you actually need exist among the 23 shown, and that AgentX works on your platform, since the README states Windows requires Git for Windows.

Frequently asked questions

Official sources

1. Deepractice/PromptX on GitHub
2. License: MIT
3. Project website
4. README
5. Releases