How Many MCP Tools Does OmniRoute Expose?

OmniRoute exposes exactly 94 distinct MCP tools that enable programmatic control over AI routing, memory management, skill execution, and third-party integrations.

The open-source OmniRoute repository (diegosouzapw/OmniRoute) ships with a comprehensive Multi-Client Protocol (MCP) server designed for AI orchestration. Understanding how many MCP tools OmniRoute exposes is essential for developers integrating automated routing and agent management into their applications.

The Definitive Count: 94 MCP Tools

According to the repository documentation in AGENTS.md, OmniRoute's MCP server provides 94 distinct tools covering core infrastructure and advanced capabilities. These tools are grouped into essential and advanced phases, offering a complete interface for programmatic AI management.

The tool set spans multiple functional domains:

• Core routing and health checks – Service status verification and request routing
• Quota and pricing management – Usage limits and cost calculation
• Combo and compression utilities – Request batching and data optimization
• Memory and skill execution – State persistence and capability invocation
• Agent-skill bridging – Communication between AI agents and skill sets
• Gamification and plugin handling – User engagement and extensibility features
• Third-party integrations – Native support for Notion and Obsidian

Where the 94 Tools Are Defined in the Source Code

The MCP tools are declared centrally and implemented across modular files in the codebase.

Schema Definition in tools.ts

All 94 tools are defined as structured objects in open-sse/mcp-server/schemas/tools.ts. This file exports the MCP_TOOLS collection that enumerates every available method, its parameters, and return types.

Server Registration in server.ts

The tools are registered at runtime in open-sse/mcp-server/server.ts via the createMcpServer() function. This initialization process loads the complete tool set into the MCP server, making all 94 methods available to connected clients.

Individual Implementation Files

Each tool category has dedicated implementation files under open-sse/mcp-server/tools/:

• memoryTools.ts – Memory persistence operations
• skillTools.ts – Skill execution and management
• compressionTools.ts – Data compression and optimization
• routingTools.ts – Request routing logic
• integrations/ – Notion and Obsidian connectors

Tool Categories and Capabilities

The 94 MCP tools are organized into logical groups that support both basic operations and complex AI workflows.

Essential Phase Tools handle critical infrastructure needs including health checks, quota verification (check_quota), and base routing functionality. These tools ensure the system remains operational and within usage limits.

Advanced Phase Tools provide sophisticated capabilities such as agent-skill bridging, gamification mechanics, and plugin lifecycle management. These enable complex multi-agent orchestration and platform extensibility.

Integration Tools offer first-class support for external knowledge bases, specifically Notion and Obsidian, allowing AI agents to read from and write to these platforms directly through the MCP interface.

How to List and Invoke MCP Tools

You can interact with the 94 tools programmatically via OmniRoute's HTTP endpoints.

Listing Available Tools

Use the built-in endpoint to retrieve the complete tool inventory and verify the count:

import { fetch } from 'node-fetch';

const endpoint = 'http://localhost:3000/api/mcp/tools/list';

async function listMcpTools() {
  const res = await fetch(endpoint, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({}),
  });
  const data = await res.json();
  console.log('Total MCP tools:', data.total);
  console.log('Available tools:', data.tools.map((t: any) => t.name));
}

listMcpTools();

Invoking a Specific Tool

The following example demonstrates calling the quota verification tool:

import { fetch } from 'node-fetch';

async function checkQuota(apiKey: string) {
  const res = await fetch('http://localhost:3000/api/mcp/tools/check_quota', {
    method: 'POST',
    headers: { 
      'Content-Type': 'application/json', 
      'Authorization': `Bearer ${apiKey}` 
    },
    body: JSON.stringify({}),
  });
  const result = await res.json();
  console.log('Quota status:', result);
}

checkQuota('your-api-key');

Summary

• OmniRoute exposes 94 distinct MCP tools as documented in AGENTS.md and implemented in the source code.
• Tools are defined in open-sse/mcp-server/schemas/tools.ts and registered via createMcpServer() in server.ts.
• The tool set covers routing, memory, skills, compression, gamification, and integrations with Notion and Obsidian.
• Individual implementations reside in open-sse/mcp-server/tools/ with separate files for each functional category.
• All 94 tools are accessible via HTTP POST endpoints under /api/mcp/tools/.

Frequently Asked Questions

What does MCP stand for in OmniRoute?

MCP stands for Multi-Client Protocol. It is OmniRoute's standardized interface that allows multiple AI agents and clients to interact with the routing system programmatically, accessing the 94 tools for tasks like memory management, skill execution, and quota checking.

How are the 94 tools organized in the codebase?

The tools are organized into essential and advanced phases based on functionality. Essential tools handle core operations like health checks and routing, while advanced tools manage agent-skill bridging, gamification, and third-party integrations. Each category has dedicated implementation files in open-sse/mcp-server/tools/.

Can I add custom tools to OmniRoute's MCP server?

Yes. You can extend the MCP_TOOLS object in open-sse/mcp-server/schemas/tools.ts to define new tool schemas, then implement the corresponding logic in a new file under open-sse/mcp-server/tools/. The createMcpServer() function in server.ts will automatically register any tools added to the schema.

Which OmniRoute integrations are available via MCP tools?

The 94-tool set includes native integrations for Notion and Obsidian, allowing AI agents to read, write, and manage content in these platforms. Additionally, there are tools for plugin management that enable custom third-party integrations beyond these built-in options.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}