Context Mode
Context Mode is a local MCP server that keeps large tool output out of an agent’s context by running, indexing, searching, and managing data in a local SQLite-backed knowledge base.
Run JavaScript, TypeScript, Python, shell, and other code in a sandbox and return only printed summaries with
ctx_execute.Analyze a file in a sandbox through
FILE_CONTENTwithout loading its raw bytes into context usingctx_execute_file.Index documentation, API references, files, directories, or URLs into a searchable knowledge base.
Search indexed content and auto-captured session memory with ranked snippets, source filters, code/prose filters, and timeline sorting.
Fetch and index one or many URLs with caching, TTL controls, and parallel fetches.
Run batches of shell commands, auto-index their output, and retrieve matching sections in one round trip.
View session context-consumption and savings statistics with
ctx_stats.Diagnose installation issues with
ctx_doctor.Upgrade the plugin via
ctx_upgrade.Permanently delete indexed data by session or project with
ctx_purge.Open a hosted Insight analytics dashboard with
ctx_insight.
Enables high-performance execution of JavaScript and TypeScript in a sandboxed environment to process and summarize large outputs.
Allows listing containers and monitoring resource usage through sandboxed command execution with credential passthrough.
Analyzes repository history and logs to provide summaries of commits and file changes without loading the entire log into context.
Interfaces with the GitHub CLI to fetch and summarize issues, pull requests, and repository metadata.
Interacts with Kubernetes clusters to show running pods and resource metrics via sandboxed kubectl commands.
Executes JavaScript code in a sandboxed environment to summarize files and raw data inputs.
Analyzes project dependencies and package files to identify large modules and project configuration.
Runs Perl scripts in an isolated sandbox to filter and summarize large text outputs.
Executes PHP code in a sandboxed environment to process data and return concise summaries.
Performs data analysis and file processing using sandboxed Python scripts to generate summaries of large datasets.
Fetches, indexes, and searches React documentation to provide specific code examples and technical patterns.
Runs Ruby code in a sandbox to process complex data and generate summarized results.
Provides sandboxed Rust execution for high-performance processing and summarization of large data sources.
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., "@Context Mode Analyze the last 500 lines of app.log for any database errors"
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.
Context Mode
A free, local plugin for 11 coding agents. It keeps tool output out of your agent's context window and keeps all usage data on your machine. The plugin is free forever.
34K GitHub stars · 866K npm downloads (read 2026-11-19, stats.json) · on the Hacker News front page and GitHub Trending: charts and sources
The Context Mode plugin is free and local, with its source open on GitHub. Context Mode Gateway is a separate hosted service with its own account and subscription. It takes the same idea from tool output to the whole conversation: Gateway Recall keeps long sessions searchable, and Gateway Memory shares what your agents learn across sessions and tools. See how the Gateway works
Contents: Why · Adoption · Install · Try it · Use cases · Benchmarks · How it works · Tools · Security and privacy · Context Mode Gateway · License · Community
Why
A coding agent reads files, runs commands and fetches pages, and every result goes into its context window. The Context Mode plugin runs that work in a local sandbox, keeps the full output in a SQLite index on your machine, and gives the agent the part it asks for.
The plugin is free forever. Use it at home and at work, free of charge, under a source-available license.
Runs on your machine. The hooks, the sandbox and search run as local processes next to your agent.
The plugin keeps your data on your machine. Every index lives in
~/.context-mode: onecontext.dbper project.Zero telemetry. The plugin keeps all usage data on your machine. Security and privacy lists each network call it makes.
Works offline after install. Sandbox runs, file indexing and search use local SQLite and your own runtimes.
Code Mode. The agent writes a short script instead of reading the data, and only what the script prints reaches the context: see How it works, step 5.
Small replies. On the 36 bench rows with 10 KB or more of raw output, the plugin's median reply is 99.4% smaller than the raw output.
Related MCP server: fittok
Adoption: stars and npm downloads
Open the interactive chart and point at a bar to read its value. Tabs there show days, weeks, months and years. Stars come from the GitHub GraphQL API (starredAt); npm downloads come from api.npmjs.org/downloads/range. The total up to 2026-10-29 is 683K npm downloads (stats.json keeps a daily copy). A daily job redraws both charts.
Hacker News. "MCP server that reduces Claude Code context consumption by 98%" reached the front page with 570+ points and 107 comments on 2026-02-28 (thread).
GitHub Trending. A bot that watches GitHub Trending logged the repo there on 14 days from 2026-04-24 to 2026-10-17 (uibm/trending-watcher).
Starred by engineers at these companies: each name is the company field of 2 or more stargazer profiles, read with the GitHub GraphQL API on 2026-11-01 (data).
Install
Pick your agent: Claude Code · Codex · Gemini CLI · Qwen Code · Pi · OMP · OpenCode · Copilot CLI · Kiro · VS Code · ZCode
Open its block and copy its own install command. Each block also holds the update, check and remove steps, and the Install guide walks through them.
The plugin needs Node 24.15.0 or later, from the engines field in package.json. On Windows, add Git for Windows: the shell tools run in Git Bash, and doctor checks for it.
contextmode installs as the npm package and command context-mode.
Claude Code, Codex, Gemini CLI and Qwen Code install from GitHub, and each of their commands names the release branch.
claude plugin marketplace add mksglu/context-mode
claude plugin install context-mode@context-mode# update
claude plugin update context-mode@context-mode
# check
claude plugin list
# remove
claude plugin marketplace remove context-modeHooks ✓ (package) · MCP ✓ · Skills ✓
codex plugin marketplace add mksglu/context-mode
codex plugin add context-mode@context-mode
# one-time step: trust the plugin hooks
npm i -g context-mode
context-mode setup --agents codex# update
codex plugin marketplace upgrade context-mode
# check
codex mcp list
# remove
codex plugin remove context-mode@context-modeHooks ✓ (hook file) · MCP ✓ · Skills ✓
gemini extensions install https://github.com/mksglu/context-mode# update
gemini extensions update context-mode
# check
GEMINI_CLI_TRUST_WORKSPACE=true gemini mcp list
# remove
gemini extensions uninstall context-modeHooks ✓ (package) · MCP ✓ · Skills ✓
qwen extensions install https://github.com/mksglu/context-mode:context-mode# update
qwen extensions update context-mode
# check
qwen extensions list
# remove
qwen extensions uninstall context-modeHooks ✓ (package) · MCP ✓ · Skills ✓
pi install npm:context-mode# update
pi update --extensions
# check
pi list
# remove
pi remove npm:context-modeHooks ✓ (the plugin's own event handlers) · MCP ✓ (ctx tools built into the plugin) · Skills ✓
omp plugin install context-mode# update
omp plugin upgrade context-mode
# check
omp plugin list
# remove
omp plugin uninstall context-modeHooks ✓ (the plugin's own event handlers) · MCP ✓ (ctx tools built into the plugin) · Skills ✓
opencode plugin add context-mode# update
opencode plugin update
# check
opencode mcp list --pure # OpenCode 1.19
opencode mcp list --standalone # OpenCode 2
# remove
opencode plugin remove context-modeHooks ✓ (the plugin's own event handlers) · MCP ✓ · Skills ✓
npm i -g context-mode
context-mode setup --agents copilot-cli# update
context-mode upgrade
# check
context-mode doctor --agents copilot-cli
copilot mcp list
# remove
context-mode setup --remove --agents copilot-cliHooks ✓ (hook file) · MCP ✓ · Skills ✓
npm i -g context-mode
context-mode setup --agents kiro# update
context-mode upgrade
# check
context-mode doctor --agents kiro
# remove
context-mode setup --remove --agents kiroHooks ✓ (hook file) · MCP ✓ · Skills ✓
npm i -g context-mode
context-mode setup --agents vscode# update
context-mode upgrade
# check
context-mode doctor --agents vscode
# remove
context-mode setup --remove --agents vscodeHooks ✓ (hook file) · MCP ✓ · Skills ✓
zcode plugins marketplace add mksglu/context-mode
zcode plugins install context-mode@context-mode# update
zcode plugins update context-mode@context-mode
# check
zcode plugins list
# remove
zcode plugins uninstall context-mode@context-modeHooks ✓ (hook file) · MCP ✓ · Skills ✓
The npm route works for every agent:
npm i -g context-mode
context-mode setupSetup is also the repair. It shows a plan, saves your earlier config, then applies the plan; when a step ends early, it restores the saved config. To uninstall:
context-mode setup --remove
npm rm -g context-modeRestart the agent, then run /ctx-doctor in it. Each check prints PASS or a fix command, and the Doctor guide explains each check.
Every agent gets hooks, the MCP server and the plugin skills; the last line of each block above says how. Hooks reach each agent in one of three ways: in the plugin package (Claude Code, Gemini CLI, Qwen Code), in a hook file (Codex, Copilot CLI, Kiro, VS Code, ZCode), or in a plugin inside the agent (OpenCode, Pi, OMP). The Agents guide shows what each agent runs. We ran the real binary of each agent with the plugin hook: Claude Code, Codex, Gemini CLI, Qwen Code, Pi, OpenCode, Copilot CLI and ZCode. Each run used a clean temp home and a local test model, on 2.0.0-next.15. OMP 18.20.0 ran the same way with ADR-0026, and CI installs the real OMP on Linux, macOS and Windows. For VS Code and Kiro, the check covers the hook setup: VS Code runs the hook command with the documented payload, and kiro-cli 2.35.2 loads all 6 hook entries. CI runs setup, doctor, a hook and an MCP handshake for all 11 agents from the packed package on Linux, macOS and Windows. Record: HOOKS-FIRE.md. Each agent uses its own install command, and ADR-0023 says why.
Your first task with the plugin, step by step: First session. Or paste a prompt from Try it right now.
Try it
Paste one of these prompts into your agent after the install. Each one ran once, live, in Claude Code 2.1.312, and its answer matched the source data (evidence and rerun steps). The headline numbers in Benchmarks use the median of 5 runs. Other agents do the same job with the same tools: ctx_execute, ctx_index and ctx_search.
After a prompt, run the stats skill and read the report yourself (See the saving).
On https://react.dev/reference/react/useEffect, show me the example that connects to a chat server and cleans up, and list the rules for the dependency array.The hook sends WebFetch to the sandbox, and the agent searches the page for the example and the rules. 601,984 B raw, 20,860 B reached the context, 96.5% saved (2026-11-02, 2.0.0-next.26, claude-haiku-5-5).
Fetch https://jsonplaceholder.typicode.com/photos. Which photo has the longest title (give its id and title), and how many photos have a title that contains the word "est"?The agent runs code over 5,000 JSON records in the sandbox and gets back two answers. 1,039,898 B raw, 393 B reached the context, 99.96% saved (2026-11-02, 2.0.0-next.26, claude-haiku-5-5). The answer is two short facts, so this is the best case of the four.
Here is a Linux syslog sample: https://raw.githubusercontent.com/logpai/loghub/master/Linux/Linux_2k.log. How many authentication failures does it contain, and which 3 remote hosts caused the most?The agent counts failures in a 1,999-line syslog in the sandbox. 216,485 B raw, 566 B reached the context, 99.7% saved (2026-11-02, 2.0.0-next.26, claude-haiku-5-5).
What are the top 10 stories on the Hacker News front page right now? Give title, points and domain for each.The hook sends WebFetch to the sandbox, and the agent reads ten stories from the page. 35,087 B raw, 1,501 B reached the context, 95.7% saved (2026-11-02, 2.0.0-next.26, claude-haiku-5-5). The front page changes, so the raw size changes with each run.
See the saving
Run the stats skill right after a prompt. Each agent uses its own command; the skill calls ctx_stats and shows its report unchanged.
Agent | Command |
Claude Code |
|
Codex |
|
Copilot CLI |
|
Gemini CLI |
|
Kiro |
|
OMP |
|
OpenCode |
|
Pi |
|
Qwen Code |
|
VS Code (Copilot) |
|
ZCode |
|
The first lines of a real report, after the JSON prompt above ran as one ctx_execute call:
context-mode stats
────────────────────────────────────────────────────────────────────────────────
This session · 1 call · <1m active
1015.5 KB became 3.7 KB: 1011.8 KB kept out (99.6%)
Without context-mode |████████████████████████████████████████| 1015.5 KB
With context-mode |█░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░| 3.7 KB
about 259K tokens kept out, 1.3 times a 200K windowCaptured 2026-11-03 with 2.0.0-next.35: release-out/server.mjs over MCP in a temp HOME.
Next, the same numbers for 20 real tools, in Use cases.
Use cases
Real tool output from public projects, run through Context Mode. Bench of 2026-11-01 on 2.0.0-next.23 (commit 16a4bcc5), median of 5 runs.
What you do | Tool | Raw | Reaches the context | Saved |
Chrome DevTools MCP | 136,514 B | 463 B | 99.7% | |
GitHub CLI | 182,943 B | 850 B | 99.5% | |
GitHub CLI | 195,471 B | 776 B | 99.6% | |
Context7 | 6,917 B | 473 B | 93.2% | |
Vitest | 62,909 B | 429 B | 99.3% | |
Biome | 288,523 B | 577 B | 99.8% | |
pnpm | 14,988 B | 199 B | 98.7% | |
npm | 37,761 B | 435 B | 98.8% | |
Docker | 60,374 B | 587 B | 99.0% | |
Terraform | 34,081 B | 166 B | 99.5% | |
git | 164,385 B | 268 B | 99.8% | |
Read, sent to | 91,362 B | 375 B | 99.6% | |
WebFetch, sent to | 271,731 B | 439 B | 99.8% | |
curl in Bash, replaced after it runs | 219,175 B | 291 B | 99.9% | |
Bash, output replaced after it runs | 191,120 B | 204 B | 99.9% | |
Host tool output over the cap, indexed whole | 191,120 B | 2,842 B | 98.5% | |
Host tool output over the cap, indexed whole | 219,175 B | 4,060 B | 98.1% | |
Read, sent to | 46,216 B | 371 B | 99.2% | |
Read, sent to | 61,576 B | 374 B | 99.4% | |
All hooks and tools | 281,261 B | 3,266 B | 98.8% |
Source: bench/results/2026-11-01-darwin-arm64.json, one row per line; SOURCE.md names where each input comes from. Click a task to open its case: the command, the input file with its sha256, and the run command, so you can run the same row on your machine.
The agent gets the part it asks for. The full output stays in the local index, and ctx_search reads it back.
Rows with a command run in the sandbox; the agent then finds the rest with search.
The Context7 row has 6,917 B of raw output, under the 10 KB line of the headline rule, so the headline leaves it out.
Next, how the bench counts these bytes, in Benchmarks.
Benchmarks
Rule for every headline number in this README: rows with 10 KB or more of raw output, median of 5 runs per row, measured with ctx_bytes against raw_bytes; a category is the median of its rows; 1 KB = 1,024 B.
All 36 such rows, the six categories below: the plugin keeps a median of 99.4% of output bytes out of the context. Bench on 2.0.0-next.23 (commit 16a4bcc5 and the local edits that the file records), macOS arm64, 2026-11-01.
Category | What runs | Rows | Median saved |
a. Sandbox |
| 19 | 99.5% |
b. Retrieval |
| 3 | 77.2% |
c. Batch |
| 2 | 93.1% |
d. Externalize | Host tool output over the cap, indexed whole | 4 | 98.3% |
f. Hook redirect | A big Read, curl or WebFetch sent to the sandbox | 7 | 99.8% |
g. Session total | One full scripted session | 1 | 98.8% |
Search replies (category b) carry the matching text, so they save 77.2%. Category e (long sessions) is in Longer sessions. The full file lists every row, small ones too: 2026-11-01-darwin-arm64.md.
Reproduce with cd bench && node run.mjs. It needs plain Node and runs offline; bench/README.md lists each scenario and its options.
Method, data files and rerun steps: Benchmarks guide.
Longer sessions
Say you debug a slow test all afternoon. The agent reads files, runs the suite and fetches docs, and each result goes into the context window. When the window is full, the host compacts it, and from then on the agent sees a short summary plus your next message.
Context Mode keeps the full output of each large tool call in context.db on your machine and gives the agent a small reply. At compaction, a snapshot of at most 2,048 B keeps the session state. After the compaction, the agent calls ctx_resume to read that snapshot back and ctx_search to find any earlier output by keyword.
In the bench, a scripted session of 40 tool outputs and one compaction made a 442,893 B transcript, and the ctx_resume block that brought the agent back was 2,019 B (row e-long-session in the bench file; open the case).
In the same bench, one large log of 666,796 B put 3,380 B into the context, and the full log stayed in the index for ctx_search (row d-synth-1m; open the case).
How the snapshot picks what to keep: the Long sessions guide and ADR-0009.
Speed
Median of 5 runs, bench of 2026-11-01.
Measure | Result |
Hook time over a bare | 7.5 ms to 12.3 ms |
| 1.62 ms median, 6.70 ms max |
| 150 ms per MB |
Source: rows g-hook-kiro to g-hook-claude-code, g-search-latency and g-index-per-mb of the bench file, with every agent and query. The overhead cases show how each one runs.
Next, what happens inside one tool call, in How it works.
How it works
One tool call, in time order, from the install to a hook error.
Install. Each agent's own install command adds the MCP server, the hooks and the skills
ctx-doctor,ctx-statsandctx-upgradeto that agent's config folder, for example~/.codex/skills/<name>/SKILL.md.context-mode setupwrites or repairs any part the native command leaves out (ADR-0023).Session start. The
SessionStarthook opens the project database. When the session ran before, the agent gets one line that tells it to callctx_resume(dispatch.ts).PreToolUse checks. Before a tool runs, the
PreToolUsehook checks the call in a fixed order: the user's deny list, WebFetch, curl and wget, inline HTTP and build commands, then a full-file Read overOUTPUT_CAP(16,384 B) and one-file shell dumps such ascatortail. A Read with a line range runs as usual (decide.ts).The exact call. When a check matches, the hook stops the call and its reply names the exact
ctx_*call to use, for examplectx_executewith{"language":"shell","code":"<the command>","intent":"<what you need>"}. For WebFetch the reply namesctx_index, thenctx_search(read-deny.ts).The sandbox. This is the Code Mode step: the agent's script runs here, and only what it prints comes back.
ctx_executewrites the script to a temp folder and spawns the runtime from an argument list in the project folder. The timeout isEXEC_TIMEOUT_MS(600,000 ms, default and maximum); on timeout it stops the whole process group (taskkill /F /Ton Windows). The child gets your environment minus preload variables such asNODE_OPTIONS, and the agent gets what the script prints, at mostOUTPUT_CAP(execute.ts). Code Mode. The agent sends a short script as a tool parameter, the script reads the data in the sandbox, and only what it prints goes into the context. Two real calls, in the form the Claude Code terminal shows them:ctx_executeon 5,000 JSON records, from the Claude Code 2.1.312 stream of the Try-it run with Context Mode 2.0.0-next.26 (04-api-json.json). The data is 1,039,898 B; the agent gets 254 B.⏺ context-mode - ctx_execute (MCP)(language: "javascript", c…jsonplaceholder.typicode.com/photos\"); if (!res.ok) throw new Error(\"HTTP \" + res.status); const photos = await res.json(); let longest = null; for (const p of photos) { if (!longest || p.title.length > longest.title.length) longest = p; } const withEst = photos.filter(p => p.title.includes(\"est\")).length; const ties = photos.filter(p => p.title.length === longest.title.length).map(p => p.id); console.log(JSON.stringify({ total: photos.length, longest…nd count of titles containing \"est\"") ⎿ exit 0 · 239 B { "total": 5000, "longest": { "id": 653, "title": "temporibus commodi et fugit doloremque re…rit exercitationem necessitatibus aut", "length": 86 }, "longestTieIds": [ 653 ], "titlesContainingEst": 892 }ctx_batchon an install log and a long git log, one live MCP call torelease-out/server.mjsof Context Mode 2.0.0-next.36 on 2026-11-03 (2026-11-03-ctx-batch.json). The commands print 228,881 B; the agent gets 8,667 B, the parts that match its two queries, and the full output stays in the index.⏺ context-mode - ctx_batch (MCP)(commands: ["cat npm-install… queries: ["cache miss","feat commit"]) ⎿ ## cache miss js.org/@esbuild%2fwin32-x64 282ms (cache miss) npm http fetch GET 200 https://registry.npmjs.org/@esbuild%2flinux-s390x 79ms (cache miss) npm http fetch GET 200 https://registry.npmjs.org/@esbuild%2fopenbsd-x64 101ms (cache miss) npm http fetch GET 200 https://registry.npmjs.org/@esbuild%2fwin32-arm64 99ms (cache miss) npm http fetch GET 200 https://registry.npmjs.org/@esbuild%2fdarwin-arm64 99ms (cache miss) … +95 lines (ctrl+o to expand)Indexing. The full output goes into the index in chunks of at most
MAX_CHUNK_BYTES(4,096 B). A Markdown chunk stays inside one heading section, and a code block that fits stays whole. Each chunk goes into two SQLite FTS5 tables: a Porter-stemmed table for words and a trigram table for paths, names and parts of words (fts.ts).ctx_indexon a copy of this repo'sdocs/how-it-works.md, one live MCP call torelease-out/server.mjsof Context Mode 2.0.0-next.36 on 2026-11-03 (calls.json). The file is 11,577 B; the agent gets 64 B.⏺ context-mode - ctx_index (MCP)(path: "how-it-works.md") ⎿ Indexed 1 source(s), 17 chunk(s) from s1. Label: how-it-works.mdSearch.
ctx_searchranks each table with BM25 and joins the two lists with Reciprocal Rank Fusion: a hit scores 1/(RRF_K+ rank), withRRF_K= 60. Before it returns an empty list, it tries a spelling fix from the indexed words. Search covers this session, this worktree (the default) or the whole project, and each snippet is at mostSNIPPET_MAX_BYTES(800 B) (search.ts).ctx_searchon that index, in the same run, in a project that also holds anAGENTS.md. One search reads the index and every agent's memory files. The agent gets 1,268 B: one content hit and one memory hit, each with its source and heading. For memory shared across machines, agents and sessions, see Context Mode Gateway Memory.⏺ context-mode - ctx_search (MCP)(queries: ["compaction state block"]) ⎿ Query "compaction state block": how-it-works.md #14: ### Session continuity The hooks log each prompt, edit, command, tool error, i…e same rows always give the same bytes. memory AGENTS.md #0: # Agent rules … +10 lines (ctrl+o to expand)Run, then replace. On hosts that run the tool first, the
PostToolUsehook checks the result. Output overREPLACE_TRIGGER_BYTES(4,096 B) goes into the index whole, and the agent gets the best-matching chunks and onectx_searchline for the rest (dispatch.ts).Journal and compaction. The hooks log each prompt, edit, command, tool error and decision in a journal. After a compaction the agent gets a state block of at most
STATE_BUDGET(2,048 B), and each long line becomes actx_resume(seq)pointer to the full row; onectx_resumereply is at mostRESUME_CAP(2,048 B). On the next prompt, a prompt-match block brings back the journal rows that match it by BM25 (ADR-0009).ctx_resumewith empty parameters returns the state block, in the same run: 209 B.⏺ context-mode - ctx_resume (MCP)() ⎿ <context_mode_state session="mcp:85e67fa2-28ef-45eb-9d5b-a967129b74c0" upto="2"> indexed how-it-works.md source s1: how-it-works.md (11536 B) more: ctx_search(queries:[], scope:"session") </context_mode_state>The database. Each project has one
context.dbunder~/.context-mode, in Node's built-innode:sqlite. The database runs in WAL mode and runs a PASSIVE checkpoint on close. A new database gets built under a temp name and moves into place in one atomic step, and the busy timeout isDB_TIMEOUT_MS(5,000 ms) (db.ts).A hook error. A hook always ends with exit 0. On any error it gives the host's allow reply and writes one log line to
~/.context-mode/hook-errors.log, so your agent keeps working. A spawned hook hasHOOK_TIMEOUT_MS(5,000 ms) (fallback.ts).
Every number with its reason: How it works. The rules the hook follows: ADR-0008. Next, the Tools the agent calls.
Tools
Tool | What it does |
| Runs code or a shell command in a sandbox; returns what it prints |
| Runs many commands, indexes the output, and searches it in one call |
| Indexes a file, a text or a URL into the project database |
| Searches the local index; returns the matching parts |
| Returns the plugin's local state block (at most 2,048 B), or one full row by |
| Shows how much output stayed out of context |
| Checks the install; each check prints PASS or a fix command |
| Installs, upgrades or uninstalls; replaces old contextmode entries |
| Deletes indexed data by session, source or project |
Three more real calls, from the same live run of Context Mode 2.0.0-next.36 on 2026-11-03 (calls.json).
ctx_stats: the agent gets 3,097 B, the first line is the summary.
⏺ context-mode - ctx_stats (MCP)()
⎿ ctx_stats: 82.5% kept out all-time, 82.5% this session.
… +59 lines (ctrl+o to expand)ctx_doctor after context-mode setup --agents claude-code: 862 B, one row per check.
⏺ context-mode - ctx_doctor (MCP)()
⎿ Environment: context-mode 2.0.0-next.36 (8facf27), agent claude-code 0 (client r20-live)
Environment: darwin-arm64, Node v26.8.1, shell /bin/zsh
| Check | Status | Detail | Fix |
|---|---|---|---|
| D1 version | PASS | 2.0.0-next.36 (8facf27): ahead of next on npm (2.0.0-next.34) | |
| D2 node | PASS | ok | |
… +11 lines (ctrl+o to expand)ctx_purge deletes one source: 66 B.
⏺ context-mode - ctx_purge (MCP)(source: "how-it-works.md")
⎿ ctx_purge: deleted 18 rows (scope: source). This cannot be undone.Full reference: Tools.
Commands in the agent: /ctx-stats shows the ctx_stats result, /ctx-doctor runs ctx_doctor (send its report with a defect report), and /ctx-upgrade runs ctx_upgrade, then ctx_doctor.
Security and privacy
The plugin keeps all its data on your machine, one database per project in
~/.context-mode, andctx_purgedeletes it by session, source or project. Read the Security guide.The plugin has zero telemetry: usage data, events and crash reports stay on your machine. It uses the network for four calls, each one started by you or your agent:
Call | When | File |
Fetch of a URL, for | Your agent asks for a page. The fetch blocks private and link-local addresses, checks each address the host name points to, connects to the address it checked, and checks again at each redirect. | |
One read of the npm dist-tags, with | You run | |
| You run | |
Your agent's own install command, npm or git | You install or update | Your agent |
The guard test D-PRIVACY-NET-1 in tests/0008-enforcement.test.mjs scans the source for HTTP clients, sockets, DNS lookups, git network calls and gh or npm spawns. It flags each new call site, so this table stays true.
Doctor and the debug report remove secrets by their structure before they print.
Code from ctx_execute runs on your host as your user, with your files, your network and your environment except the preload variables, so keep your agent's own permission prompts on. Here "sandbox" means the output stays in the sandbox and out of the context.
What the plugin stores, where, and how to delete it: Privacy.
Context Mode Gateway
The plugin works on tool output, on your machine, and it is complete on its own. Context Mode Gateway is a separate hosted service with its own account and subscription. It works on every request, across all your agents. Its 11 features, the full list: Context Saving, Recall, Memory, Skills, Search, Session resume, Active Context, Instructions, Protect, Prompt caching, Live and Analytics.
Add the Gateway when you want savings on every request, memory across sessions and agents, or cost reports for a team. For one project on one machine, the plugin covers the job. The two work together: Gateway guide.
Gateway Recall, Search and Session resume run on the Gateway server, across sessions and agents. The plugin's ctx_search and ctx_resume read the local context.db of one project.
With the Gateway on, your requests pass through its server; the plugin keeps its own data on your machine.
Product | Runs | Scope | Billing |
Context Mode plugin | On your machine | One project, local | Free |
Context Mode Gateway | Hosted service | All sessions and agents | Subscription, separate from the plugin |
Set up the Gateway with one command:
npx @context-mode/clinpx @context-mode/cli signs you in to your Gateway account, which has its own subscription, and writes one config change per agent.
Apps: Claude Code, Claude Desktop, Codex, Codex Desktop, T3 Code, OpenCode and Pi. The Gateway CLI needs Node 20.12 or later, from its npm engines field.
Live. One session as it runs: money saved this session, bytes kept out per request, history kept and sent, and a feed of each request with its cost and saving. Click the image for the full video.
Docs: How saving works
Numbers in these screens come from the author's own account over 30 days (Oct 3 - Nov 1, 2026), so read them as one account's usage. Click an image for the full size.
Three prompts to try with the Gateway on. The line under each one names the feature it shows.
Move this project from Jest to Vitest. Convert every test file, fix the config, run the suite after each batch, and tell me what is left.Memory keeps the plan and the file list across a long job.
Pick up where we stopped yesterday on the Jest to Vitest move. What is done, what is left, and which test was failing?Recall brings back yesterday's work in a fresh session.
Which date library did we choose on Tuesday, and why did we reject the other two?Search finds the answer in past sessions.
Source: contextmode.ai/docs:
Feature | What it does | What you get | Details |
Context Saving | Folds old tool output, runs data work as code (Code Mode), trims tool schemas, places cache marks | A tool output over 2,048 B becomes a short pointer, with the full copy archived | Saves the most on sessions with many tool calls |
Recall | The model sees recent work and an index of older work; the agent searches the archive for the rest | Gateway, Claude Code, Opus 5.5, 200K window, 2026-10-04: mean cost per session $4.8627 to $3.0353 (-37.6% in dollars, | Cost measured in Claude Code on Claude Opus 5.5 |
Memory | Each fact keeps two times: when it was true and when the Gateway learned it | Claude Code and Codex on one account share one store, tested end to end | The memory block goes into the first request of a new session |
Skills | A skill catalog on the Gateway for your account; it loads the skill that matches your message | The matching skill loads on the message that needs it | Import skills from GitHub; a loaded skill joins the prompt in full |
Search | Searches the prompts, commands and tool output that passed through, in the console and as an agent tool | Find any past prompt, command or tool output, from the console or your agent | The console searches the first 4,000 characters of each tool result |
Session resume | One command rebuilds a conversation as a native Claude Code or Codex session | Continue a conversation in Claude Code or Codex | Restores the text, tool names and a summary; the command is valid for 15 minutes |
Active Context | Sets how much a thread carries before its oldest parts move to the archive: 200K, 500K or 1M tokens | Pick the window size per thread | An image older than the kept part becomes a short text note |
Instructions | One text of at most 4,096 characters that tells every agent how to answer you | Read from the provider cache after the first request | Sets how the agent writes to you |
Protect | A tool-call firewall: checks shell commands, file reads and writes, web fetches and tool-server calls by what they do | Each call checked before it runs | Reads the call itself, so keep your agent's sandbox on for script files and paths built at run time; opt-in |
Prompt caching | Keeps requests cache-friendly: cache marks on the fixed part of the prompt and a cache for fetched pages | Inside the measured costs above | Uses up to 4 cache marks, the provider's maximum |
Live and Analytics | Shows each request and what the Gateway saved, as it happens and over time | See each request and its saving, live and over time | Covers every request that passes through the Gateway |
Gateway only: its cost against Claude Code alone, Claude Opus 5.5, mean dollars per session at list price. The plugin numbers are in Benchmarks.
Six short tasks (2026-09-29): 24.5% fewer dollars pooled over 176 sessions (21% to 29% per task). v3-opus55-short.json
Long Claude Code session, 200K window (2026-10-03/04): mean cost per session $4.8627 to $3.0353 (-37.6% in dollars, mean of 3 pairs). ab.json
We fixed the rules before each run: contextmode.ai/docs/benchmarks.
The Gateway routes to Anthropic and OpenAI. The Gateway sends your requests to its server on the way to the model. It keeps a searchable record of your sessions for Recall and Search, and masks secrets and e-mail addresses when it reads archived output back. Its privacy page is at contextmode.ai/privacy. Keep your agent's own sandbox on next to Protect.
License
Elastic License 2.0 (ELv2, the LICENSE file), a source-available license. You may use, copy, change and share the code, and use it at work, free of charge.
The license keeps three uses for the licensor:
Offering the software to others as a hosted or managed service that gives them a large part of its features.
Moving, changing, turning off or getting around the license key functions, or removing or hiding what the license key protects.
Changing, removing or hiding the licensor's license, copyright or other notices.
We chose ELv2 so the source stays open to all and the hosted service stays with the project.
Community
Report a defect on Discord with the full /ctx-doctor report, and send ideas there too. The maintainer writes every change; CONTRIBUTING.md shows how an agent files an issue.
Videos. Better Stack on Context Mode. Make your own video and share it on Discord; we add videos over 10K views here.
Available Tools
11 toolsctx_batch_executeBatch Execute & SearchADestructive
Run multiple commands in ONE call. Every command's output is auto-indexed into the knowledge base; if you also pass queries, the matching sections come back in the same round trip so a follow-up search call is not needed.
Concurrency parallelizes the FETCH phase (run-the-commands). The DERIVATION phase — turning raw output into an answer — still belongs in code: add a processing command that consumes the indexed output and prints only the answer, so the raw bytes never enter your conversation (Think-in-Code, same principle as the sandbox tool).
WHEN:
You have 3+ related commands you would otherwise run sequentially (multi-issue lookups, git log + git diff + git blame, multi-file reads, multi-region cloud queries)
You want to gather AND query in one round trip — pass
queriesso the matching sections come back inlineYou want to parallelize I/O-bound work — pass
concurrency2-8 (network calls, gh CLI, cloud APIs, multi-repo git reads)The combined output is large enough that piping it through ctx_search later would itself be expensive — let auto-index + inline queries do both in one shot
WHEN NOT:
Single command with no follow-up query — run it in the sandbox tool directly
CPU-bound or stateful commands — keep concurrency at 1 (npm test, build, lint, port-binding servers, lock-file holders, anything that races on the same resource)
RETURNS:
Auto-indexed section list per command label, plus top matches per query (when queries is passed). Raw output is NOT echoed in full — only the matched windows. Concurrency>1 switches each command to its own per-command timeout (no shared budget); concurrency=1 preserves the legacy shared-budget cascading-skip-on-timeout path. Use 4-8 for I/O-bound batches; keep at 1 for CPU work or shared-state commands; lower the value when target hosts enforce per-IP rate limits.
EXAMPLE: ctx_batch_execute( commands: [ {label: "issue 1", command: "gh issue view 1"}, {label: "issue 2", command: "gh issue view 2"}, {label: "summarize", command: "echo done"} ], queries: ["root cause", "proposed fix"], concurrency: 2 )
Inputs: queries (required), commands (required), cwd, timeout, +2 more.
ctx_doctorRun DiagnosticsARead-onlyIdempotent
Diagnose context-mode installation. Runs all checks server-side and returns a plain-text status report with [OK]/[FAIL]/[WARN] prefixes (renderer-safe across MCP clients). No CLI execution needed.
Inputs: no named parameters.
ctx_executeRun code in a sandbox (executes the supplied code)ADestructive
Run code in a sandboxed subprocess. Languages: javascript, shell, typescript, python, perl.
Think-in-Code — the core philosophy: the bytes your code processes never enter your conversation memory; only what you console.log() does. Reading a 700 KB log directly means 700 KB of your remaining reasoning capacity gets spent on raw bytes. Running code over that same log in this sandbox and printing a 3 KB summary leaves you with 697 KB of capacity for the actual work.
Concrete shape — analyze 47 source files without reading any of them:
ctx_execute(language: "javascript", code: const fs = require('fs'); const files = fs.readdirSync('src').filter(f => f.endsWith('.ts')); files.forEach(f => { const lines = fs.readFileSync('src/'+f,'utf8').split('\\n').length; console.log(f + ': ' + lines + ' lines'); }); )
// 47 files analyzed, 15,314 LoC summarized — output ~3.6 KB instead of 47 Read() calls = ~700 KB.
WHEN:
You intend to derive an answer FROM data (filter, count, aggregate, parse, compare, transform) — do the derivation in code and print only the answer
Output shape or size cannot be predicted before execution (recursive finds, repo-wide greps, list endpoints, query results, log scans)
You would otherwise read raw output and then mentally compute — that compute belongs here, in code, where its inputs stay out of your conversation
You need to keep a long-running process alive (dev server, watcher, daemon) — pass
background: trueto detach on timeout instead of killing the processThe output may legitimately be large but you only want recall-by-topic later — pass an
intentstring; outputs over ~5KB are auto-indexed into the knowledge base and only the section titles + previews come back, retrievable via ctx_search
WHEN NOT:
Single observational command whose entire short output you intend to consume verbatim (whoami, pwd, git status on a clean tree) — Bash is simpler
File mutations (Edit/Write) or navigation (cd/ls) — Bash is the right surface
You already know the output is one short fixed line and you want to read it as-is
RETURNS:
Only what your code prints. Wrap risky calls in try/catch — uncaught errors go to stderr and may leak more than intended. When intent is set and output exceeds the auto-index threshold, the response carries searchable section titles + previews instead of the raw stdout; use ctx_search(queries: [...]) to drill into specific sections.
EXAMPLE: ctx_execute(language: "javascript", code: "const out = require('child_process').execSync('npm test', {encoding:'utf8', stdio:['ignore','pipe','pipe']}); console.log(out.split('\n').filter(l => /(FAIL|✗|×|Error:|Tests +.*(failed|passed))/i.test(l)).slice(0, 60).join('\n'))")
EXAMPLE: ctx_execute(language: "javascript", code: "const out = require('child_process').execSync('gh issue list --json number,title --limit 100', {encoding:'utf8'}); const hooks = JSON.parse(out).filter(i => /hook|routing/i.test(i.title)); console.log(${hooks.length} hook-related issues)")
Inputs: code (required), language (required), cwd, intent, +2 more.
ctx_execute_fileRun code over a file (executes code, reads the given path)ADestructive
Read a file into a sandboxed FILE_CONTENT variable and run code over it. Only what you console.log() enters your conversation — the file bytes stay in the sandbox.
Think-in-Code applied to file-level analysis: Reading the whole file means every byte enters your conversation memory and costs reasoning capacity for the rest of the session. Running code over it here lets you keep the raw bytes out and only the derived answer in. Same principle as ctx_execute, scoped to one named file via the FILE_CONTENT variable.
WHEN:
You want to KNOW SOMETHING ABOUT a file (line count, matches of a pattern, parsed structure, statistical aggregate) without needing to SEE all of it
The file is structured (CSV, JSON, log, code) and a code-level derivation is cheaper than reading verbatim
The file is large enough that reading the full content would burn meaningful conversation memory you need for the actual work
The derivation may itself produce a large output you want recall-by-topic on later — pass an
intentstring; outputs over ~5KB are auto-indexed and only matching sections come back, retrievable via ctx_search
WHEN NOT:
You intend to EDIT the file — use Read so the subsequent Edit can match the exact text
You only need one specific line and you know its offset — Read with offset/limit is the simplest path
The file is small AND you will consume all of it for understanding/editing — Read directly
RETURNS:
Only what your code prints. The FILE_CONTENT variable holds the raw bytes inside the sandbox; nothing else leaves. When intent is set and output exceeds the auto-index threshold, the response carries searchable section titles + previews instead of the raw stdout.
EXAMPLE: ctx_execute_file(path: "huge.log", language: "javascript", code: "const errs = FILE_CONTENT.split('\n').filter(l => /ERROR|FATAL/.test(l)); console.log(${errs.length} error lines); console.log(errs.slice(-5).join('\n'))")
EXAMPLE: ctx_execute_file(path: "data.csv", language: "javascript", code: "const rows = FILE_CONTENT.split('\n'); console.log(rows: ${rows.length - 1}, header: ${rows[0]})")
Inputs: code (required), path (required), language (required), intent, +1 more.
ctx_fetch_and_indexFetch & Index URL(s)A
Fetches URL content, converts HTML to markdown (JSON is chunked by key paths, plain text indexed directly), persists it in a searchable knowledge base, and returns a small preview window per source. The raw page bytes never enter your conversation — they live in storage and you retrieve any section on-demand via ctx_search.
Caching: every fetch is cached on disk and reused for repeat calls within the TTL window. The default TTL is 24 hours; override per-call with the ttl parameter (milliseconds, ttl: 0 bypasses cache like force: true). Stored content older than 14 days is cleaned up on startup.
WHEN:
You need web content (docs, changelogs, API references, spec pages) and the raw page bytes should NOT enter your conversation
Multi-URL research (library evaluation, migration scans, doc comparisons): pass the
requestsarray and aconcurrencyvalue 2-8 for parallel I/OYou want repeat lookups against the same URL to be cheap (TTL cache hits return only a hint, no re-fetch)
You want a long-lived cache window (override
ttlupward for stable specs) or a guaranteed-fresh fetch (ttl: 0orforce: true)
WHEN NOT:
You already have the content locally — store it via the inline index tool
The page is SPA-rendered (JavaScript-required to materialize content) — this is a plain HTTP fetch, no headless browser
RETURNS: Per-source preview windows extracted around indexable headings plus indexing metadata (chunk counts, source labels, cache state). Raw content is NOT echoed back — retrieve any section on-demand via ctx_search(source: ""). Concurrency parallelizes the fetch phase up to your chosen value (capped by the host's logical CPU count); the FTS5 write phase always runs serially because SQLite is a single-writer store. Net latency = max(fetch latency across the pool) + sum(per-source index write time). Cache hits skip both phases and return a small freshness hint instead of re-fetching. Use 4-8 for stable I/O-bound batches; lower the value when the target host enforces a per-IP rate limit you cannot raise.
EXAMPLE: ctx_fetch_and_index( requests: [{url: "https://react.dev/...", source: "react"}, {url: "https://vuejs.org/...", source: "vue"}], concurrency: 5 )
Inputs: ttl, url, force, source, +2 more.
ctx_indexIndex ContentA
Store content in a searchable knowledge base (BM25 over FTS5). Splits markdown by headings, keeps code blocks intact, and persists the raw chunks. The full content stays in storage — retrieve any section on-demand via ctx_search; nothing is summarized or truncated.
WHEN:
Documentation from Context7, Skills, or MCP tools (API docs, framework guides, code examples)
API references (endpoint details, parameter specs, response schemas)
MCP tools/list output (exact tool signatures and descriptions)
Skill prompts and instructions that are too large to keep verbatim in conversation
README files, migration guides, changelog entries
Any content with code examples you may need to reference precisely later
WHEN NOT:
Log files, test output, CSV, or build output — use ctx_execute_file, which processes in-sandbox without persisting bytes
Single-use ephemeral content you will not query later — keep it inline if it fits, or ctx_execute_file it
RETURNS:
Indexing metadata: chunk counts (total, code-bearing), source label, and the exact ctx_search call shape to query the indexed content. Raw content is NOT echoed back — it lives in storage, retrievable via ctx_search(source: ""). When path is provided, a content hash is stored so ctx_search results auto-flag staleness on future calls.
EXAMPLE: ctx_index(content: "# React useEffect\n\nThe Effect Hook lets you ...", source: "react-useeffect-docs") EXAMPLE: ctx_index(path: "/path/to/large-spec.md", source: "openapi-v2-spec")
Inputs: path, source, content, exclude, +6 more.
ctx_insightOpen Insight DashboardAIdempotent
Opens the context-mode Insight dashboard (https://context-mode.com/insight) in your default browser — a dashboard launcher for the hosted analytics layer, not a Q&A engine. Insight surfaces per-engineer productive rate, retry waste, blocker detection, and role-narrowed views for CTO, EM, IC, CISO, FinOps, and DevOps. For natural-language queries over your indexed content, use ctx_search.
Inputs: no named parameters.
ctx_purgePurge Knowledge BaseADestructiveIdempotent
DESTRUCTIVE: permanently delete indexed content. Cannot be undone. Requires confirm:true and exactly one scope.
WHEN:
User explicitly asks to clear a specific session ('purge this session', 'wipe this conversation')
User explicitly asks to reset the whole project ('reset everything', 'wipe the knowledge base')
WHEN NOT:
User says 'reset', 'clear', or 'wipe' without naming a scope -> ask which scope before calling
User wants to free memory or improve performance -> recommend ctx_stats first, do not purge
SCOPES (pass exactly one):
Per-session: ctx_purge(confirm: true, sessionId: "") deletes that session's events (auto-captured decisions, errors, plans, user prompts, rejected approaches, etc.) and per-session FTS5 chunks; sibling sessions and stats file are preserved.
Per-project: ctx_purge(confirm: true, scope: "project") wipes FTS5 knowledge base, every session DB row, events markdown, and resets the stats file. Use ctx_stats first to preview category counts before purging.
CONTRACT:
confirm:true is required; confirm:false returns 'purge cancelled'.
sessionId and scope:'project' together return 'ambiguous - pick one'.
scope:'session' without sessionId throws (sessionId required).
Bare {confirm:true} is deprecated: maps to scope:'project' with a stderr warning; will hard-error in a future major.
RETURNS: A summary of removed rows + the resolved scope.
EXAMPLE: ctx_purge(confirm: true, sessionId: "7c8a-1234-5678-9abc-def012345678") EXAMPLE: ctx_purge(confirm: true, scope: "project")
Inputs: confirm (required), scope, sessionId.
ctx_searchSearch Indexed ContentARead-onlyIdempotent
Search a unified knowledge base with a multi-strategy ranking pipeline. Two parallel matchers run on every query: a Porter-stemming matcher ("caching" finds "cached", "caches", "cach") and a trigram-substring matcher ("useEff" finds "useEffect"). Their ranked lists are merged via Reciprocal Rank Fusion, so a document that ranks well in both surfaces above one that wins only on a single strategy. Multi-term queries get an additional proximity-rerank pass that boosts passages where the query terms appear close together. Typos are corrected via Levenshtein distance and re-searched. Result snippets are window-extracted around the matched terms, not blindly truncated.
The knowledge base is unified: queries reach indexed content you stored (ctx_index, ctx_fetch_and_index, ctx_batch_execute output) AND auto-captured session memory written by hooks (decisions, errors, blockers, plans, user prompts, rejected approaches, tool failures, compaction guides — 26 event categories). File-backed sources carry a content hash and auto-flag staleness when the source file changes.
WHEN:
You want to recall something that exists in storage (recently indexed content, prior session events, auto-memory) instead of re-reading raw sources
You have multiple related questions about the same body of knowledge — batch every question into one call (the ranking pipeline runs per-query but the round-trip cost is paid once)
You want to scope the query to one labelled source (pass
source— partial match is fine)You want a chronological view across current session + prior sessions + persistent auto-memory (pass
sort: "timeline"— the defaultrelevancemode only ranks within the current session)You want to filter ranked results by content shape (pass
contentType: "code"to surface implementation snippets orcontentType: "prose"to surface explanations)
WHEN NOT:
The data you want to query has never been stored in the knowledge base AND no session memory has accumulated around it — capture first (run a gather-and-index call), then come back here to query
You have one ad-hoc question against data that is not in the knowledge base — answer it inline by running code in the sandbox tool; one round-trip instead of capture-then-query
RETURNS:
Per-query ranked sections with window-extracted snippets. Use 2-4 specific technical terms per query. Common session-memory source labels: decision (user corrections / preferences), error and error-resolution (past failures + their fixes), blocker, plan, user-prompt, rejected-approach, compaction (post-compact session guide). See ctx_stats for live category counts. Each response carries a throttle counter (call #N/M in the rolling time window); results taper toward the soft cap and calls block after the hard cap. Tune via CONTEXT_MODE_SEARCH_WINDOW_MS, CONTEXT_MODE_SEARCH_MAX_RESULTS_AFTER, CONTEXT_MODE_SEARCH_BLOCK_AFTER.
EXAMPLE: ctx_search(queries: ["root cause", "proposed fix", "test coverage"], source: "issue-#683") EXAMPLE: ctx_search(queries: ["what did we decide about caching"], source: "decision", sort: "timeline") EXAMPLE: ctx_search(queries: ["useEffect cleanup pattern"], source: "react-docs", contentType: "code", limit: 5) EXAMPLE: ctx_search(queries: ["last user prompt", "active skills", "open blockers"], sort: "timeline")
Inputs: sort, limit, source, queries, +1 more.
ctx_statsSession StatisticsARead-onlyIdempotent
Returns context consumption statistics for the current session. Shows total bytes returned to context, breakdown by tool, call counts, estimated token usage, and context savings ratio.
Inputs: no named parameters.
ctx_upgradeUpgrade PluginAIdempotent
Upgrade context-mode to the latest version. Returns a shell command to execute. You MUST run the returned command using your shell tool (Bash, shell_execute, run_in_terminal, etc.) and display the output as a checklist. Tell the user to restart their session after upgrade.
Inputs: no named parameters.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 11 tools
ctx_execute, ctx_execute_file, and ctx_batch_execute share an execution surface, but each has a clearly scoped role (single code block vs file-scoped processing vs batched commands with auto-indexing) reinforced by detailed WHEN/WHEN NOT guidance. ctx_index and ctx_fetch_and_index are similarly distinct (inline content vs URL fetching). No two tools are truly interchangeable.
Every tool uses the ctx_ prefix with lowercase snake_case, and most follow a verb pattern (ctx_execute, ctx_index, ctx_search, ctx_purge, ctx_upgrade) or a noun for informational tools (ctx_stats, ctx_doctor, ctx_insight). Fetch-and-index and batch-execute combine verbs in a predictable, readable way.
11 tools cover the server's scope — sandboxed execution, knowledge-base indexing/retrieval, maintenance (doctor, upgrade), statistics, and destructive cleanup — without redundancy. Each tool has a distinct purpose, and the count is within the ideal range for a feature-rich but focused MCP server.
The main lifecycle is covered: capture (ctx_execute/ctx_execute_file/ctx_batch_execute/ctx_fetch_and_index), store (ctx_index), retrieve (ctx_search), and destroy (ctx_purge). Minor gaps remain: there is no per-source or per-chunk deletion/update tool, and no explicit way to list all indexed sources beyond stats counts.
Maintenance
Related MCP Connectors
Shared memory MCP server for Claude Code, Codex, Gemini CLI and Cursor. Cited, editable.
An MCP server that gives your AI access to the source code and docs of all public github repos
Augments MCP Server - A comprehensive framework documentation provider for Claude Code
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Related MCP Servers
- AlicenseAqualityCmaintenanceLocal-first MCP server that gives any AI coding agent per-project memory, workflow intelligence, and always-on, lossless token & context optimization.3731 npm6MIT
- AlicenseCqualityCmaintenanceAn MCP server that filters and compresses context by 80-90% before sending to an LLM, using code knowledge graphs and compression.2069 PyPI3MIT
- AlicenseAqualityDmaintenanceAn MCP server that provides a persistent sandbox for AI coding agents to explore codebases server-side, returning only compact summaries to reduce context consumption.39MIT
- AlicenseAqualityCmaintenanceProvides reversible context compression for AI agents, reducing token usage while preserving the ability to retrieve original content, and serves as an MCP server for integration with tools like GitHub Copilot and Claude Code.31Apache 2.0