slm-mcp-hub 0.1.5

The world's first MCP gateway that learns — intelligent federation, caching, cost tracking, and coordination for Model Context Protocol servers.

SLM MCP Hub

The World's First MCP Gateway That Learns

One hub process. Every MCP server. Every AI client. Shared across sessions.
Federated tool discovery with memory, learning, and cost intelligence.

---

The Problem

Every AI coding session spawns its own MCP server processes. Five Claude Code sessions with 36 MCPs means 180 OS processes eating ~9GB RAM. Each session loads ~150K tokens of tool definitions into the context window. On a 200K-context model, 75% is gone before you type anything.

And every session starts from zero. No shared cache. No cost tracking. No learning. No coordination between sessions.

The Solution

SLM MCP Hub runs all your MCPs in one shared process. Every AI client connects to one HTTP endpoint. The hub federates, caches, tracks costs, and — with SuperLocalMemory — learns from every tool call.

Metric	Without Hub	With Hub
Processes (5 sessions, 36 MCPs)	180	37 (79% reduction)
RAM usage	~9 GB	~1.9 GB
Session startup	~30s (spawn 36 processes)	Instant (HTTP connect)
Tool definitions in context	400+ tools (~150K tokens)	3 meta-tools (~1K tokens)
Config management	Per-IDE, per-session	One hub config
Learning across sessions	None	Automatic (with SLM plugin)

---

How It Works

Federated Mode — 3 Tools Instead of 400+

Instead of loading 400+ tool definitions into every session, Claude gets 3 meta-tools:

Meta-Tool	What It Does
hub__search_tools	Search all tools by name or description. Returns full input schemas.
hub__call_tool	Call any tool on any MCP server. Routes automatically.
hub__list_servers	List all connected servers and their tool counts.

You:     "Search GitHub for qualixar repos"
Claude:  hub__search_tools(query="github search")
Hub:     Found: github__search_repositories, github__search_code, ...

Claude:  hub__call_tool(tool="github__search_repositories", arguments={"query": "qualixar"})
Hub:     Routes to GitHub MCP → returns real results

3 tool definitions instead of 400+. That's 150K tokens saved per session.

---

Quick Start

# Install
pip install slm-mcp-hub

# Initialize and import your MCPs
slm-hub config init
slm-hub setup import ~/.claude.json

# Start the hub
slm-hub start

Connect Claude Code

Add to ~/.claude.json:

{
  "mcpServers": {
    "hub": {
      "type": "http",
      "url": "http://127.0.0.1:52414/mcp"
    }
  }
}

Restart Claude Code. All tools available through hub__search_tools and hub__call_tool.

---

SLM Plugin — The Gateway That Learns

When SuperLocalMemory is running, the hub automatically connects to it and learns from every tool call. No configuration needed.

SLM MCP Hub v0.1.0 running on http://127.0.0.1:52414/mcp
  MCP servers: 37/37 connected
  Tools: 345
  Plugins: 2 (slm, mesh)         ← Auto-discovered
  SLM: connected (mode=b, 4461 facts)

What the SLM Plugin Does

Hook	What Happens	SLM Endpoint
Session start	Recalls relevant context from past sessions	POST /api/v3/recall/trace
Every tool call	Logs to SLM's learning pipeline — tool name, duration, success/failure	POST /api/v3/tool-event
Session end	Persists session summary for future recall	POST /api/v3/tool-event (session_end type)
Warm-up prediction	Predicts which MCPs you'll need based on recent history	Local ring buffer

How It Works Under the Hood

The SLM plugin communicates with the SLM daemon via its HTTP API at localhost:8765. No Python import of superlocalmemory required — pure HTTP integration. This means:

• Hub works standalone when SLM is not installed (all hooks are no-ops)
• Hub auto-discovers SLM daemon on startup
• Same SLM daemon serves both the hub plugin AND direct Claude Code hooks
• Every tool call routed through hub__call_tool triggers the learning pipeline

For End Users: SLM Through the Hub

If you use SuperLocalMemory, you can put it inside the hub like any other MCP:

slm-hub setup import ~/.claude.json   # Imports all MCPs including SLM
slm-hub start                          # SLM runs as a hub backend

The SLM plugin replaces the need for separate Claude Code hooks:

• on_session_start replaces the session_init hook
• on_tool_call_after replaces the PostToolUse hook
• on_session_end replaces the Stop hook

Zero manual hook configuration. The hub handles it.

---

Mesh Plugin — Cross-Session Coordination

When the SLM daemon has mesh enabled, the hub registers as a mesh peer and coordinates across sessions:

Feature	What It Does
Peer registration	Hub appears on the mesh as an mcp-hub agent type
Tool usage broadcast	Other sessions see which tools are being used
Session notifications	Mesh peers notified when sessions start/end
Tool list changes	MCP connect/disconnect events broadcast to mesh
Distributed locking	Prevent conflicts when multiple sessions access the same resource

The mesh plugin uses the SLM daemon's mesh HTTP API at localhost:8765/mesh/*. Like the SLM plugin, it auto-discovers and is a no-op when mesh is not available.

---

What Works Today (v0.1.0)

Feature	Status
Federation — All MCPs behind single endpoint	Working
Federated Mode — 3 meta-tools, ~150K token savings	Working
Transparent Proxy — /mcp/{server}, original tool names	Working
SLM Plugin — Tool call learning, session recall, summaries	Working
Mesh Plugin — Peer registration, broadcast, distributed locks	Working
Intelligent Caching — SHA-256 content-hash, TTL, LRU	Working
Cost Tracking — Per-tool costs, session budgets, cascade routing	Working
Smart Tool Filtering — Project-type detection, frequency ranking	Working
Multi-Client Auto-Setup — Claude Code, VS Code, Cursor, Windsurf, Codex CLI	Working
Observability — Per-server metrics, request tracing, audit log	Working
Lifecycle Management — Lazy startup, idle shutdown, always-on	Working
Permission Model — Per-session role-based rules (ALLOW/DENY/WARN)	Working
Resilience — Auto-restart (launchd/systemd), PID management	Working
Network Discovery — mDNS/Zeroconf LAN discovery	Working
Secrets — ~/.claude-secrets.env loading, ${VAR} resolution	Working
HTTP + stdio + SSE transport	Working

---

Architecture

                    ┌───────────────────────────────────────────────┐
                    │             SLM MCP Hub                       │
AI Client 1 ──┐    │                                               │    ┌── GitHub (26 tools)
AI Client 2 ──┼────┤  Federation → Cache → Cost → Route ──────────┼────┤── Gemini (37 tools)
AI Client 3 ──┘    │       ↕           ↕         ↕                │    ├── Context7 (2 tools)
                    │   Permissions  Metrics   Learning            │    ├── SLM (32 tools)
                    │       ↕                     ↕                │    ├── SQLite (8 tools)
                    │  ┌─────────┐          ┌──────────┐           │    └── ...37+ more
                    │  │   SLM   │          │   Mesh   │           │
                    │  │ Plugin  │          │  Plugin  │           │
                    │  └────┬────┘          └────┬─────┘           │
                    └───────┼────────────────────┼─────────────────┘
                            │                    │
                            └────────┬───────────┘
                                     ↓
                           SLM Daemon (localhost:8765)
                           Memory · Learning · Mesh

Plugin Architecture

Plugins are discovered automatically via Python entry_points on hub startup. Each plugin receives lifecycle hooks:

class HubPlugin(ABC):
    async def on_hub_start(self, hub) -> None: ...
    async def on_hub_stop(self) -> None: ...
    async def on_tool_call_after(self, session_id, server, tool, args, result, duration_ms, success) -> None: ...
    async def on_session_start(self, session_id, client_info) -> None: ...
    async def on_session_end(self, session_id) -> None: ...
    async def on_mcp_connect(self, server_name) -> None: ...
    async def on_mcp_disconnect(self, server_name) -> None: ...

Built-in plugins:

Plugin	Connection	What It Adds
slm	HTTP → localhost:8765/api/v3/*	Memory, learning, session recall, warm-up predictions
mesh	HTTP → localhost:8765/mesh/*	Peer discovery, broadcast, distributed locks

---

CLI Reference

slm-hub start [--port PORT] [--config PATH] [--log-level LEVEL]
slm-hub status
slm-hub config show | init | import <file>
slm-hub setup detect | register | unregister | import
slm-hub network discover | info

Configuration

Hub config: ~/.slm-mcp-hub/config.json

Environment overrides: SLM_HUB_PORT, SLM_HUB_HOST, SLM_HUB_LOG_LEVEL, SLM_HUB_CONFIG_DIR, SLM_DAEMON_URL.

Secrets: ~/.claude-secrets.env (shared with Claude Code). All ${VAR} placeholders resolve on startup.

---

Documentation

Guide	What You'll Learn
Getting Started	Install, import, connect, verify — 5 minutes
Architecture	Two modes, plugin system, tool call flow
Migration Guide	Step-by-step from direct MCPs to hub, rollback
Configuration	All settings, API endpoints, CLI reference

---

Part of the Qualixar Ecosystem

SLM MCP Hub is the tool brain — it manages, routes, and learns from MCP tool calls. It joins the Qualixar suite of AI agent reliability tools:

Product	What It Does	Install
SuperLocalMemory	Local-first AI agent memory — Fisher-Rao geometry, 5-channel retrieval, zero cloud	npm install superlocalmemory
SLM Mesh	Peer-to-peer agent communication — real-time messaging, file locking, shared state	npm install slm-mesh
SLM MCP Hub	Intelligent MCP gateway — federation, caching, cost tracking, learning (this repo)	pip install slm-mcp-hub
Qualixar OS	Universal OS for AI agents — 12 topologies, Forge AI, 24-tab dashboard	npx qualixar-os
AgentAssert	Behavioral contracts for AI agents — ContractSpec DSL, drift detection	pip install agentassert-abc
AgentAssay	Token-efficient agent evaluation — 78-100% cost reduction, 10 adapters	pip install agentassay
SkillFortify	Agent skill security analysis — 100% precision, 22 frameworks, 3 citations	pip install skillfortify

Together: SuperLocalMemory (memory brain) + SLM Mesh (connected brain) + SLM MCP Hub (tool brain) = complete AI intelligence platform. Each works standalone. Together: unstoppable.

---

Competitive Landscape

Tool	Stars	What It Does	What's Missing
mcp-hub	472	HTTP federation	No memory, no cost tracking, no learning
Supergateway	2,573	Stdio-to-SSE bridge	Broadcasts all responses to all clients
mcpmu	87	Stdio multiplexer	Per-client process spawn, no sharing
mcp-proxy	249	Stdio-to-HTTP	New process per session
SLM MCP Hub	-	Federation + memory + learning + cost + mesh	The only gateway that learns

---

Author

Varun Pratap Bhardwaj · qualixar.com · superlocalmemory.com · varunpratap.com

7 research papers · 6 open source products · Building the AI Agent Reliability category.

License

AGPL-3.0-or-later. See LICENSE.

Commercial licensing: [e-mail]

---

⭐ Support This Project

If this project solves a real problem for you, please star the repo — it helps other developers discover Qualixar and signals that the AI agent reliability community is growing. Every star matters.

---

Part of the Qualixar AI Agent Reliability Platform

Qualixar is building the open-source infrastructure for AI agent reliability engineering. Seven products, seven peer-reviewed papers, one coherent platform. Each tool solves one reliability pillar:

Product	Purpose	Install	Paper
SuperLocalMemory	Persistent memory + learning for AI agents	npx superlocalmemory	arXiv:2604.04514
Qualixar OS	Universal agent runtime (13 execution topologies)	npx qualixar-os	arXiv:2604.06392
SLM Mesh	P2P coordination across AI agent sessions	npm i slm-mesh	—
SLM MCP Hub	Federate 430+ MCP tools through one gateway	pip install slm-mcp-hub	—
AgentAssay	Token-efficient AI agent testing	pip install agentassay	arXiv:2603.02601
AgentAssert	Behavioral contracts + drift detection	pip install agentassert-abc	arXiv:2602.22302
SkillFortify	Formal verification for AI agent skills	pip install skillfortify	arXiv:2603.00195

Zero cloud dependency. Local-first. EU AI Act compliant.

Start here → qualixar.com · All papers on Qualixar HuggingFace

---