SuperCompress MCP
Query-aware context compression for agents and AI apps: an MCP tool trims long dumps and keeps what matters
- 146 ★ on the repository
- Last commit
- MIT
Extended access
Why this level
- Neural mode sends the text being compressed to the hosted API and logs can contain secrets
- Compression may drop a needed detail and the savings figures come from the authors' own set
Install
- Works in
Manual install
npm i -g supercompress-proxy && npx supercompress setupInstalls the proxy, links an account and adds MCP to detected agents.
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- Neural mode sends the text being compressed to the hosted API and logs can contain secrets
- Compression may drop a needed detail and the savings figures come from the authors' own set
This is third-party code. Review the repository files before installing.
What it does
SuperCompress takes a long context and the current query, splits text into blocks, scores their usefulness for the query and keeps answering lines in their original wording. The query is not compressed and only the surroundings are trimmed. For coding agents the server gives an MCP tool `compress_context` for big dumps, installed with `npm i -g supercompress-proxy` and `npx supercompress setup`. For apps there is the `pip install supercompress` package. There are two paths. Neural v2 on a 400M-parameter cross-encoder runs on the hosted API and gives the best quality, while a fast local compiler processes text in milliseconds. On its own B5 set of 24 coding-agent cases the authors show a mean 64.1 percent context cut while retaining the answering data in all 24 checks, and the model weights are published on Hugging Face under the MIT license. The metric measures evidence retention and not final task completion by a model.
Who it is for. Developers of agents and RAG apps who pay for long logs, tool dumps and chunks and want to cut them to the question.
Good fit when
- The agent got huge test output or logs and the answer depends on a couple of error lines
- RAG chunks and chat history grow and the token bill rises with every request
- IDs, stack traces and exact errors must stay verbatim and not be paraphrased
- You need local preprocessing without a network: the fast compiler runs on the CPU in milliseconds
Not a fit when
- Context must not go to an external service: neural mode runs on the hosted API
- You need a guarantee of model answer quality: the authors' metric measures evidence retention and not task outcome
- The context is short: compression adds latency and will not pay off
Example request
Compress this test output for the question why the auth test failed, keep the error and trace lines verbatim and show how many tokens were savedMCP
- Transport
- stdio
- Authentication
- API key
Limitations
Neural v2 mode runs on the hosted API and needs an account and a key, and the text being compressed goes to the service's server. The figures of 64.1 percent and 96.6 percent at 99 percent or better retention come from the authors' own B5 set of 24 cases and may not repeat on your data. The metric measures evidence retention and not final task completion. The fast local compiler is weaker in quality than neural mode. The `supercompress-proxy` install and the `npx supercompress setup` wizard link an account, detect agents and add MCP to their configs. The license is MIT.
How to disable. Remove the `supercompress` entry from the agent config (`claude mcp remove supercompress`), uninstall the proxy with `npm uninstall -g supercompress-proxy` and revoke the key in the dashboard.
FAQ
How do I connect SuperCompress to an agent?
With `npm i -g supercompress-proxy` and `npx supercompress setup`: the wizard links your account, detects agents and installs MCP.
What does `compress_context` do?
It takes a long context and the current query, keeps blocks that answer it in their original words and returns a smaller prompt with token stats.
How do the neural path and the compiler differ?
Neural v2 on a 400M-parameter cross-encoder gives the best quality but runs on the hosted API. The local compiler is faster, takes milliseconds and runs on the CPU.
What savings are claimed?
A mean of 64.1 percent on the B5 set of 24 cases with 24 passing evidence retention checks and up to 96.6 percent at 99 percent or better retention. These are the authors' results on their own set.
Can I use it in an app with no agent?
Yes, the `pip install supercompress` package compresses context before each model call.
Discussion
No questions or reviews yet.
Related
MCP serversA proxy compresses the tool descriptions of a large MCP server so the model spends context only on the calls it needs.
Local context compression for agents: tool outputs, logs, files and RAG chunks shrink before reaching the LLM. Proxy, CLI, library and MCP
Local proxy between agent and model API: compresses diffs and logs, keeps the request prefix stable for prompt caching.
An MCP server that keeps large tool output out of the agent's context window and stores session memory in SQLite
A Rust program that shrinks the command output an agent reads: drops build and test noise, folds repeated file reads and redacts credentials
Long-term memory for agents: a remote MCP server, plugins for Claude Code, Cursor and Codex, and an API for your own apps
README in short
A headline promising query-aware trimming and benchmark figures. Then a section on why the approach is needed, a comparison with truncation and summarizing, two paths (neural and compiler), two products (an agent plugin and an API), an install table and links to comparisons with Headroom, RTK and LLMLingua.