How do I use MCP File Compaction?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@MCP File Compaction read_file src/lib.rs" 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.

MCP File Compaction

An MCP server that reduces Claude context window costs by automatically summarizing files to their public interfaces.

The Problem

When Claude works on large tasks across multiple files, the context window grows continuously. Each API request costs based on the full size of the context, not just new tokens. This leads to quadratic cost growth:

Implement ptr.rs (2KB) → Context: 2KB
Implement raw_page.rs using ptr.rs (3KB) → Context: 5KB
Implement paged_pool.rs using both (4KB) → Context: 9KB

After finishing a file, Claude doesn't need the full implementation—just the public interface (structs, functions, traits).

The Solution

This MCP server:

Tracks the "active" file — the one you're currently editing (full contents)
Auto-summarizes inactive files — when you switch files, the previous one is summarized to just its public API
Uses AST parsing — deterministic, fast, no LLM calls for summarization
Handles unsupported languages gracefully — returns full contents without tracking

Installation

From GitHub (recommended)

npx github:YOUR_USERNAME/mcp-file-compaction

Local development

git clone https://github.com/YOUR_USERNAME/mcp-file-compaction.git cd mcp-file-compaction npm install npm run build

Configuration

Add to your Claude Code MCP settings:

{ "mcpServers": { "file-compaction": { "command": "npx", "args": ["github:YOUR_USERNAME/mcp-file-compaction"] } } }

Or for local development:

{ "mcpServers": { "file-compaction": { "command": "node", "args": ["/path/to/mcp-file-compaction/dist/index.js"] } } }

Add to your CLAUDE.md:

## File Operations Use the file-compaction MCP server for file operations: - `read_file` instead of `Read` when you need full file contents - `peek_file` when you only need to check interfaces - `edit_file` instead of `Edit` for modifications - `write_file` instead of `Write` for new files - `file_status` to see tracked files and context savings This reduces context window size by keeping only summaries of inactive files.

Tools

read_file

Read a file and mark it as the active file. When you switch to a different file, the previous file is automatically summarized.

{ "path": "src/lib.rs" }

peek_file

Get a summary of a file's public interface without changing the active file. Useful for checking APIs.

{ "path": "src/ptr.rs" }

edit_file

Edit a file by replacing a specific string. The file becomes (or remains) the active file.

{ "path": "src/lib.rs", "old_string": "fn old_name(", "new_string": "fn new_name(" }

write_file

Write content to a file, creating it if needed. The file becomes the active file.

{ "path": "src/new_module.rs", "content": "//! New module\n\npub fn hello() {}\n" }

file_status

Show all tracked files with size comparison and savings.

Context Status ============== Active: src/paged_pool.rs (full, 4.2 KB) Cached Summaries: src/ptr.rs 312 B (was 2.1 KB, saved 1.8 KB) src/raw_page.rs 428 B (was 3.4 KB, saved 3.0 KB) Total Context: 5.2 KB Without Compaction: 11.5 KB Savings: 6.3 KB (55%)

forget_file

Remove a file from tracking entirely.

{ "path": "src/old_file.rs" }

Supported Languages

Currently supported for summarization:

Rust (.rs) — extracts public structs, enums, traits, functions, type aliases, constants, and re-exports

Unsupported file types are read/edited normally without tracking—they won't interfere with compaction.

How Summaries Work

For a Rust file like:

//! Type-safe pointer wrappers. use std::marker::PhantomData; #[derive(Debug, Clone)] pub struct Ptr<T> { raw: *mut T, _marker: PhantomData<T>, } impl<T> Ptr<T> { pub fn new(raw: *mut T) -> Self { Self { raw, _marker: PhantomData } } pub fn is_null(&self) -> bool { self.raw.is_null() } // Private helper fn internal_check(&self) -> bool { !self.raw.is_null() } }

The summary becomes:

// Purpose: Type-safe pointer wrappers. #[derive(Debug, Clone)] pub struct Ptr<T> { ... } impl<T> Ptr<T> { pub fn new(raw: *mut T) -> Self; pub fn is_null(&self) -> bool; }

Private items, implementation details, and doc comments are condensed—only the public interface remains.

License

MIT

MCP File Compaction

MCP File Compaction

The Problem

The Solution

Installation

From GitHub (recommended)

Local development

Configuration

Tools

read_file

peek_file

edit_file

write_file

file_status

forget_file

Supported Languages

How Summaries Work

License

Resources

New MCP Servers

Latest Blog Posts

MCP directory API