# How Many MCP Tools Does OmniRoute Expose?

> Discover how many MCP tools OmniRoute exposes. OmniRoute offers 94 MCP tools for AI routing, memory management, and integrations, enabling programmatic control.

- Repository: [Diego Rodrigues de Sa e Souza/OmniRoute](https://github.com/diegosouzapw/OmniRoute)
- Tags: how-to-guide
- Published: 2026-07-09

---

**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`](https://github.com/diegosouzapw/OmniRoute/blob/main/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`](https://github.com/diegosouzapw/OmniRoute/blob/main/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`](https://github.com/diegosouzapw/OmniRoute/blob/main/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`](https://github.com/diegosouzapw/OmniRoute/blob/main/memoryTools.ts) – Memory persistence operations
- [`skillTools.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/skillTools.ts) – Skill execution and management
- [`compressionTools.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/compressionTools.ts) – Data compression and optimization
- [`routingTools.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/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:

```typescript
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:

```typescript
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`](https://github.com/diegosouzapw/OmniRoute/blob/main/AGENTS.md) and implemented in the source code.
- Tools are defined in [`open-sse/mcp-server/schemas/tools.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/mcp-server/schemas/tools.ts) and registered via `createMcpServer()` in [`server.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/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`](https://github.com/diegosouzapw/OmniRoute/blob/main/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`](https://github.com/diegosouzapw/OmniRoute/blob/main/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.