Server data from the Official MCP Registry
Shared memory MCP server for AI coding agents — local by default, team-shared via threadctx.dev.
Shared memory MCP server for AI coding agents — local by default, team-shared via threadctx.dev.
threadctx-mcp is a well-designed MCP server with solid security practices. Authentication is appropriately scoped—local mode requires none (by design), cloud mode requires an API key stored in environment variables rather than version control. The codebase demonstrates careful input validation, proper error handling, and secure credential management. Permissions align well with the server's stated purpose of providing shared memory for coding agents. Minor code quality observations exist but do not materially impact security. Supply chain analysis found 2 known vulnerabilities in dependencies (0 critical, 2 high severity). Package verification found 1 issue.
7 files analyzed · 7 issues found
Security scores are indicators to help you make informed decisions, not guarantees. Always review permissions before connecting any MCP server.
This plugin requests these system permissions. Most are normal for its category.
Set these up before or after installing:
Environment variable: THREADCTX_MODE
Environment variable: THREADCTX_API_KEY
Add this to your MCP configuration file:
{
"mcpServers": {
"io-github-threadctx-dev-threadctx-mcp": {
"env": {
"THREADCTX_MODE": "your-threadctx-mode-here",
"THREADCTX_API_KEY": "your-threadctx-api-key-here"
},
"args": [
"-y",
"threadctx-mcp"
],
"command": "npx"
}
}
}From the project's GitHub README.
Shared memory MCP server for AI coding agents. Works identically with Claude Code and Cursor — same package, same config shape, no per-client integration work.
~/.threadctx/local.json — zero native dependencies, so
npx threadctx-mcp installs instantly on any machine with Node 18+ (no
compiler, no node-gyp step). No network calls except to whichever LLM
provider your agent already uses. Matching is keyword-based, scoped to
the current repo (detected via git remote). Run npx threadctx-mcp list
any time to see exactly what your agents have stored.../cloud/README.md).# Local mode — nothing to configure. Also auto-adds the "check team memory"
# instruction to CLAUDE.md / .cursor/rules/threadctx.mdc on first start.
npx threadctx-mcp
# Optional: write a committable .threadctx.json config, or re-apply the
# project-rules block explicitly.
npx threadctx-mcp init
# Cloud mode — prints the exact MCP config block to paste
npx threadctx-mcp init --mode=cloud --api-key=tctx_xxx
# See what your agents have written to this machine
npx threadctx-mcp list # this repo
npx threadctx-mcp list --all # every repo
init writes a .threadctx.json file (just { "mode": "cloud" }) to the
current directory. It is safe to commit — it never contains your API key.
The key is read from the THREADCTX_API_KEY environment variable at
runtime (set it in your MCP client's env block, as shown below), so
secrets stay out of version control by construction.
threadctx also adds a small, clearly-marked instruction to your project
rules — CLAUDE.md for Claude Code, .cursor/rules/threadctx.mdc for
Cursor — telling the agent to call memory_query before a task and
memory_write after. This happens automatically the first time the
server starts in a project — you don't need to run init for it. Running
init just triggers it explicitly and prints the result; either way it's
idempotent (safe to re-run, never duplicates). Opt out entirely with
THREADCTX_NO_AUTO_RULES=1, or per-init-call with --no-rules.
The same instruction is also sent as part of the MCP initialize handshake
itself (the protocol's instructions field), so it reaches the model even
before any rules file exists, and for clients that don't read project-rules
files at all. The file-based rules are belt-and-suspenders on top of that,
since not every MCP client is guaranteed to surface instructions
prominently.
Add to your Claude Code MCP config (claude mcp add or edit
~/.claude/mcp.json directly):
{
"mcpServers": {
"threadctx": {
"command": "npx",
"args": ["-y", "threadctx-mcp"],
"env": {
"THREADCTX_MODE": "cloud",
"THREADCTX_API_KEY": "tctx_xxx"
}
}
}
}
Add the same block to .cursor/mcp.json in your project root (or via
Cursor Settings → Tools & MCP):
{
"mcpServers": {
"threadctx": {
"command": "npx",
"args": ["-y", "threadctx-mcp"],
"env": {
"THREADCTX_MODE": "cloud",
"THREADCTX_API_KEY": "tctx_xxx"
}
}
}
}
That's it — the same package and config work in both clients because MCP is a portable, open protocol.
| Variable | Required | Description |
|---|---|---|
THREADCTX_MODE | no | local (default) or cloud |
THREADCTX_API_KEY | only in cloud mode | issued via cloud/scripts/create-tenant.ts |
THREADCTX_API_URL | no | defaults to https://threadctx.dev/api/v1; override for self-hosting |
THREADCTX_REPO | no | overrides repo auto-detection from git remote |
THREADCTX_DB_PATH | no | local-mode store path; defaults to ~/.threadctx/local.json |
THREADCTX_NO_AUTO_RULES | no | set to 1 to disable auto-injecting CLAUDE.md / .cursor/rules/threadctx.mdc on server start |
npm install
npm run dev # runs the server via tsx, watches for changes
npm run build # compiles to dist/ for publishing
memory_write(content, tags?) — the agent calls this after resolving a
non-obvious bug, making an architectural decision, or learning
something worth remembering.memory_query(task_description, max_results?) — the agent calls this
before starting risky or repeated work. Results are returned with a
consistent attribution footer (· via threadctx — shared team memory (N hits)) so the same string is recognizable whether you're reading
Claude Code's terminal output or Cursor's agent panel.Tool descriptions are written to bias the model toward calling
memory_query proactively, and — as of 0.3.0 — the server reinforces this
two more ways with zero setup required: the MCP initialize response
carries the same instruction to every connecting client, and CLAUDE.md /
.cursor/rules/threadctx.mdc get it auto-injected on first start. MCP tools
are still fundamentally pull-based (no mechanism can force a tool call), but
these three layers together are the strongest guarantee we can build.
| Command | What it does |
|---|---|
npx threadctx-mcp | Runs the MCP server (this is what Claude Code / Cursor launch). Auto-injects project rules on first start in a project. |
npx threadctx-mcp init [--mode=cloud --api-key=…] [--no-rules] | Writes .threadctx.json and explicitly (re-)applies the project-rules block. |
npx threadctx-mcp list [--all] [--full] [--json] | Shows what's stored in the local on-disk memory. |
Be the first to review this server!
by Modelcontextprotocol · Developer Tools
Web content fetching and conversion for efficient LLM usage
by Modelcontextprotocol · Developer Tools
Read, search, and manipulate Git repositories programmatically
by Toleno · Developer Tools
Toleno Network MCP Server — Manage your Toleno mining account with Claude AI using natural language.