Forem: George Mihailov

9router: route Claude Code, Cursor, or Copilot through whichever free tier you've got

George Mihailov — Sun, 10 May 2026 04:27:39 +0000

I was crawling GitHub trending for AI infra projects when I came across decolua/9router. It's the most thoughtful "stretch your free tiers" project I've seen for AI coding tools — and it does a few things I hadn't seen combined before. Worth a 60-second rundown for anyone burning through Cursor/Claude/Copilot budgets faster than they'd like.

What it actually is

9router runs locally and exposes a single OpenAI-compatible endpoint at http://localhost:20128/v1. Your IDE / coding agent talks to it as if it were OpenAI. Behind the scenes, requests get routed to whichever provider you configured — GitHub Copilot OAuth, a Gemini CLI session, an Ollama instance, Cursor, Codex, Kiro, Qwen, and others.

The interesting parts aren't the routing itself (lots of OpenAI-compatible proxies exist — litellm, OpenRouter, etc.). The interesting parts are:

Combos — a virtual provider made of multiple Providers. Round-robin across three Copilot OAuth sessions and you get effectively "unlimited" throughput without ever tripping a single account's rate limit. Strategy options include round-robin and sticky-round-robin (the latter pins a session to a single conversation).
RTK (Reverse Token Killer) — a filter layer applied before tool output goes back to the LLM. Your agent runs ls, grep, git diff, tree. The output is verbose and most of it is noise. RTK strips it. Configurable compression levels — at 2 it filters tree-like output, at 3 it also compresses git diffs. The filters live in open-sse/rtk/filters/ if you want to add a new one.
Caveman mode — system-prompt compression. Rewrites instructions in terse style ("be concise, no markdown" etc.) to cut output tokens. Configured per-endpoint with three escalating levels.
Antigravity — a MITM proxy specifically for VS Code's Copilot extension. Installs a self-signed cert, intercepts Copilot traffic on port 443, routes through your providers instead of Copilot's backend. Requires sudo and cert trust — properly hairy, but it's there.

Mental model in one diagram

Your IDE / agent
        │
        ▼
   [Endpoint] ─── API key your tool sees
        │
        ▼
[Provider | Combo] ── round-robin / fallback strategy
        │
        ▼
  [Translator] ──── format adapter (Claude / Gemini / Kiro / Ollama / …)
        │
        ▼
[Real upstream API]

Each upstream gets its own Translator that speaks OpenAI ↔ native both ways. Caveman wraps the input prompt; RTK wraps the streaming output before it gets sent back to the agent. The split between input-side compression and output-side compression is the right shape — most "save tokens" tools do one or the other.

Pointing Claude Code at it

docker run -d --name 9router \
  -p 20128:20128 \
  -v ~/.9router:/root/.9router \
  decolua/9router

Open the dashboard at http://localhost:20128, configure your providers, generate an Endpoint key. Then:

export ANTHROPIC_BASE_URL=http://127.0.0.1:20128
export ANTHROPIC_API_KEY=9r_yourkeyhere

Claude Code will route every call through 9router. Same trick works for Cursor, Cline, and anything else that respects ANTHROPIC_BASE_URL / OPENAI_BASE_URL. For VS Code Copilot specifically, you go through the Antigravity MITM mode instead.

Why this is interesting beyond "free tier hack"

Three things stuck out:

The "Combo" abstraction is genuinely useful infrastructure, not just a free-tier dodge. If you're running an agent that fans out work in parallel, having an N-of-M endpoint with proper retry/fallback semantics is the kind of thing you'd otherwise build yourself. 9router has it as a primitive.
RTK lives in the right place. Your agent doesn't need to see the full output of find . -name "*.ts" — it needs the relevant matches. Filtering in the proxy means your agent code doesn't have to know about it; same code works with or without RTK enabled. Putting the filter in user-space is what makes it composable.
The Cloudflare Worker mode lets you deploy 9router edge-side and use it from any laptop/CI without exposing your local box. You configure providers locally, then the Worker fronts the same endpoints with a remote URL. Useful for shared team setups.

Caveats worth being honest about

Stitching together free-tier accounts touches each provider's TOS in different ways. Copilot's terms are the most relevant — read them. 9router is the tooling, not a license to abuse.
Free providers have variable latency and uptime. "Free tier across N accounts" is not a substitute for paid quota in production.
The Antigravity MITM mode is genuinely invasive. It's an option, not the default — and you should know what trusting a self-signed cert at the system level means before you do it.

Worth a look

If your monthly Claude / Cursor / Copilot bill is starting to feel less like a tool and more like a subscription you'd notice if you canceled, 9router is the closest thing I've seen to a real architectural answer rather than a "use this cheaper model" workaround. Repo: github.com/decolua/9router.

I ran into this through Lang Labs — a side project that packs any public git repo into a Claude Code skill you can drop straight into ~/.claude/skills/. Here's 9router as one of those skills if you want a one-page reference plus a downloadable .skill bundle.

Discover MCP Servers Effortlessly with @atonomus/mcp-servers-search 🔍

George Mihailov — Tue, 24 Jun 2025 02:26:42 +0000

Ever found yourself wondering what Model Context Protocol (MCP) servers are available for your Claude Desktop setup? Or maybe you're looking for servers with specific capabilities like database access or blockchain integration? Look no further! The @atonomus/mcp-servers-search package is here to make MCP server discovery a breeze.

What is MCP and Why Should You Care? 🤔

The Model Context Protocol (MCP) is an open protocol that enables seamless integration between AI assistants like Claude and external tools and data sources. Think of MCP servers as bridges that give AI assistants superpowers - from accessing databases to interacting with APIs and beyond.

Introducing @atonomus/mcp-servers-search 🚀

This npm package provides a comprehensive toolset for querying and discovering available MCP servers from the official modelcontextprotocol/servers repository. Whether you're a developer looking to enhance your Claude Desktop experience or building your own MCP-powered applications, this package has got you covered.

Key Features ✨

List Servers: Browse all available MCP servers with filtering by category
Smart Search: Find servers by name, description, or author
Feature Discovery: Search for servers that provide specific capabilities
Random Exploration: Get random server suggestions to discover new tools
Efficient Caching: Minimizes GitHub API calls with smart caching

Getting Started 🏁

Installation

You can install the package globally or use it directly with npx:

# Install globally
npm install -g @atonomus/mcp-servers-search

# Or use directly with npx (no installation needed!)
npx @atonomus/mcp-servers-search

Integrating with Claude Desktop

To use this tool with Claude Desktop, add it to your configuration file:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "servers-search": {
      "command": "npx",
      "args": ["@atonomus/mcp-servers-search"]
    }
  }
}

Available Tools and Real-World Examples 💡

1. List All Servers

Want to see what's available? Use the list_servers tool:

{
  "name": "list_servers",
  "arguments": {
    "category": "official",
    "limit": 10
  }
}

Example Use Case: "Show me all official MCP servers" - Perfect when you want to explore trusted, officially maintained servers.

2. Search by Keywords

Looking for something specific? The search functionality has you covered:

{
  "name": "list_servers",
  "arguments": {
    "search": "database",
    "limit": 5
  }
}

Example Use Case: "Find MCP servers for database operations" - Quickly locate servers that can help with database-related tasks.

3. Discover by Features

Need servers with specific capabilities? Use the feature search:

{
  "name": "search_servers_by_feature",
  "arguments": {
    "feature": "blockchain",
    "limit": 5
  }
}

Example Use Case: "What servers support blockchain integration?" - Find specialized servers for your specific needs.

4. Get Server Details

Want more information about a specific server?

{
  "name": "get_server_details",
  "arguments": {
    "name": "GitHub"
  }
}

Example Use Case: "Tell me more about the GitHub MCP server" - Get detailed information including description, author, and installation instructions.

5. Random Discovery

Feeling adventurous? Discover new servers randomly:

{
  "name": "get_random_servers",
  "arguments": {
    "count": 3,
    "category": "community"
  }
}

Example Use Case: "Show me 3 random community servers to explore" - Great for discovering hidden gems in the MCP ecosystem.

Practical Claude Desktop Workflows 🎯

Once configured, you can ask Claude natural language questions like:

📊 "What MCP servers can help me with data analysis?"
🔗 "Find servers that integrate with external APIs"
🤖 "Show me AI and machine learning related MCP servers"
🎲 "Give me 5 random servers to try out"
🔄 "Refresh the server list to get the latest updates"

Advanced Usage: Programmatic Integration 🛠️

Want to use this in your own projects? Here's how:

import { MCPToolsQueryServer } from '@atonomus/mcp-servers-search';

async function discoverServers() {
  const server = new MCPToolsQueryServer();

  // List all servers
  const allServers = await server.listServers({ category: 'all' });

  // Search for specific features
  const dbServers = await server.searchServersByFeature({ 
    feature: 'database' 
  });

  // Get random suggestions
  const randomPicks = await server.getRandomServers({ 
    count: 5, 
    category: 'community' 
  });

  return { allServers, dbServers, randomPicks };
}

Performance and Caching 🏎️

The package implements intelligent caching to minimize GitHub API calls:

Server list is cached for 1 hour
Use refresh_server_list to force an update when needed
Efficient parsing of the official servers README

Testing and Reliability 🧪

The package includes comprehensive Mocha test coverage for:

Multiple README format parsing (standard, bold, list formats)
Author extraction and category detection
Description cleaning and special character handling
Edge cases and error scenarios

Run tests with:

npm test

Contributing to the Project 🤝

This is an open-source project, and contributions are welcome! Here's how you can help:

Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

Check out the GitHub repository for more details.

Future Possibilities 🔮

The MCP ecosystem is rapidly evolving, and this package will grow with it. Some exciting possibilities:

Server ratings and reviews: Community feedback on server quality
Dependency resolution: Automatically install required dependencies
Server templates: Quick-start configurations for common use cases
Integration testing: Verify server compatibility before installation

Conclusion 🎉

The @atonomus/mcp-servers-search package transforms MCP server discovery from a manual GitHub browsing experience into a powerful, searchable tool. Whether you're using it through Claude Desktop or integrating it into your own projects, it makes the MCP ecosystem more accessible and discoverable.

Give it a try today and unlock the full potential of MCP servers in your AI-powered workflows!

Links:

Happy server hunting! 🕵️‍♂️