# MCP RTK: cut 90% of MCP server tokens

> Source: <https://dev.to/thomastartrau/mcp-rtk-cut-90-of-mcp-server-tokens-aen>
> Published: 2026-09-11 16:54:06+00:00

I use [Claude Code](https://dev.to/blog/en/claude-code-setup-2026) every day for development. Like many developers, I've connected several MCP servers (GitLab, Grafana, Sentry...) to give Claude direct access to my tools. The problem: every MCP call injects tens of thousands of tokens into the context, and the bill spirals fast.

I built [MCP RTK](https://gitlab.com/ThomasTartrau/mcp-rtk) to fix this. It's an MCP proxy written in Rust that sits between Claude Code and MCP servers, filtering responses before they reach the model. Result: **over 267 million tokens saved** across my 38,000+ commands.

The MCP protocol ([Model Context Protocol](https://modelcontextprotocol.io/)) lets Claude interact with external tools. When Claude calls an MCP tool, the server returns a JSON response. The issue is that these responses often contain:

A single `list_issues` call on GitLab can consume over 180,000 tokens. Claude only needs a fraction to answer the question. The rest is pure waste.

Over a typical work session with 50 to 100 MCP calls, that easily adds up to 500,000 wasted tokens injected into the context.

MCP RTK sits transparently between Claude Code and MCP servers. No workflow change needed: Claude keeps calling the same tools, but responses pass through a filtering pipeline before reaching the context.

The pipeline has 8 steps:

Each step is independently configurable. You can enable or disable each filter, adjust thresholds, and define server-specific rules.

Configuration uses a TOML file. MCP RTK ships with community presets for popular servers:

```
[servers.gitlab]
preset = "gitlab"

[servers.grafana]
preset = "grafana"

[servers.sentry]
preset = "sentry"
```

Each preset defines which fields to keep, which to exclude, and appropriate truncation thresholds for the server. For custom servers, you define rules directly:

```
[servers.my-api]
whitelist = ["id", "name", "status", "created_at"]
max_string_length = 500
max_array_length = 10
```

MCP RTK auto-detects installed MCP servers and offers to configure them.

Across my 38,000+ commands, MCP RTK has saved **267 million tokens** with an average reduction rate of 87%. On Opus 4.6 ($15/M input tokens), that's roughly **$4,000 in savings**:

Useful information is preserved. Claude responds with the same accuracy, but consumes far fewer tokens per session. The `mcp-rtk gain` command lets you track savings in real time:

```
Tokens saved:      267.1M (86.7%)
Efficiency meter: █████████████████████░░░ 86.7%
```

MCP RTK is distributed as a single binary:

```
cargo install mcp-rtk
```

One line change in your Claude Code config - wrap the existing MCP command with `mcp-rtk --`:

```
{
  "mcpServers": {
    "gitlab": {
      "command": "mcp-rtk",
      "args": ["--", "npx", "-y", "@nicepkg/gitlab-mcp"],
      "env": { "GITLAB_PERSONAL_ACCESS_TOKEN": "glpat-..." }
    }
  }
}
```

MCP RTK detects the upstream server from the command and loads the matching preset automatically.

Rust was a deliberate choice. The proxy must process every MCP response with minimal latency to avoid slowing down the workflow. Rust provides:

MCP RTK is published under the MIT license on [GitLab](https://gitlab.com/ThomasTartrau/mcp-rtk) (mirror on [GitHub](https://github.com/ThomasTartrau/mcp-rtk)). Community presets are maintained by users: anyone can contribute their own configurations for new MCP servers.

The project is part of a tooling ecosystem I'm building around Claude Code, alongside [Skill Radar](https://gitlab.com/ThomasTartrau/skill-radar) (detecting repetitive patterns in sessions) and [Claude Deck](https://github.com/ThomasTartrau/claude-deck) (multi-workspace for parallel sessions). To learn how to write your own skills, see the guide on [effective skills](https://dev.to/blog/en/writing-effective-claude-code-skills). The [project page](https://dev.to/projects/mcp-rtk) has installation links and documentation.