mcp-nexus
MCP Nexus
MCP Nexus は、Model Context Protocol のためのローカルファーストのインテリジェントルーターです。 あなたの AI ハーネスは 1 つの MCP エンドポイント( Nexus )に接続し、Nexus は舞台裏で実際の MCP サーバーをすべて管理します。ツールのインデックス化、必要に応じた機能の発見、サーバーの遅延起動、ルーティングされた呼び出しの実行、そしてローカルでの使用状況から学習して時間の経過とともに結果のランキングを向上させます。
Before With MCP Nexus
AI Harness AI Harness
├── GitHub MCP (30 tools) └── mcp-nexus (4 control tools)
├── Jira MCP (25 tools) ├── search_capabilities
├── Slack MCP (20 tools) ├──── describe_capabilities
├── Figma MCP (18 tools) ├──── execute_capability
... └──── search_servers
~90+ tool schemas in context │
(everything else stays indexed
on disk until actually needed)なぜ必要か
接続された MCP サーバーはそれぞれツールスキーマをモデルのコンテキストに追加します。10 台のサーバーを接続すると、モデルがほとんど使わない定義に数万トークンを費やし、ツール選択の品質が低下します。
Nexus はモデルを反転させます。ダウンストリームのスキーマをすべてコンテキストにプッシュする代わりに、軽量な機能インデックスをディスクに保持し、小さなコントロールプレーンを提供します。エージェントは必要なときに機能を発見し( search_capabilities )、選択した機能の正確なスキーマだけを調べ( describe_capabilities )、Nexus を介して実行します( execute_capability )。設定、インデックス、分析、学習されたシーケンスなど、すべての状態は .mcp-nexus/ にローカルに保存されます。
Related MCP server: MetaMCP
クイックスタート
# 1. Scaffold a project config
npx @fyrlabs/mcp-nexus init
# 2. Add downstream MCP servers (anything runnable over stdio)
npx @fyrlabs/mcp-nexus add github -- npx -y @modelcontextprotocol/server-github
# or import an existing config:
npx @fyrlabs/mcp-nexus import --from claude
# 3. Point your harness at Nexus (see docs/harness-setup.md)ハーネス設定( Claude Code 、 Cursor 、 Codex 、その他の MCP クライアント ):
{
"mcpServers": {
"mcp-nexus": {
"command": "npx",
"args": ["-y", "@fyrlabs/mcp-nexus"]
}
}
}Nexus は作業ディレクトリから上に移動して project-mcp.json を自動的に見つけるか、--config ./path/to/nexus.json を渡します。
次に、エージェントの視点から:
search_capabilities { "query": "find comments people left on my PR" }
→ github.review_comments.list score=0.94 ...
describe_capabilities { "capabilityIds": ["github.review_comments.list"] }
→ exact input schema
execute_capability { "capabilityId": "github.review_comments.list",
"arguments": { ... } }
→ forwarded verbatim to the right server, started on demandモデルに公開されるものとローカルに保持されるもの
モデルに公開されるもの | ローカルに保持されるもの | |
コントロールプレーンツール | 固定の 4 ツール | — |
機能メタデータ | 検索時のみ( id 、タイトル、説明、リスク、スコアの小レコード ) | SQLite 内の完全なインデックス |
ツール入力スキーマ | 説明された機能のみ | インデックス時に永続化 |
使用状況分析 | — | ローカルイベント + 集計 |
シークレット | 決して公開しない( env 参照は起動時に解決、ログからは除外 ) | シェル/環境変数内 |
ハイライト
ローカルファースト。 クラウドサービスもアカウントもテレメトリもありません。
.mcp-nexus/を削除すると、学習された状態はすべて消去されます。遅延ライフサイクル。 ダウンストリームサーバーはタスクが必要なときだけ起動し、階層化されたアイドルタイムアウト( ホット / ウォーム / コールド )後に停止します。
ハイブリッド検索。 重み付けされたフィールドに対する BM25 語彙ランキング、正確な ID / ツールマッチング、エイリアス展開(
pr → pull request、設定可能 )、およびオプションのセマンティックレイヤー用のプラグ可能なEmbeddingProviderインターフェース。適応的ランキングと説明。 各結果にはシグナルの内訳が含まれます。ブロックされた機能は決して提案されません。
シーケンス予測。 繰り返される使用パターンをローカルで学習し、次に起こりそうな機能のブーストに使用します。予測は自動実行されません。
ネイティブ依存関係ゼロ。 ストレージには Node 組み込みの
node:sqliteを使用します。このパッケージのインストール時にコンパイルは発生しません。ハーネス非依存。 MCP stdio を話す任意のハーネスを Nexus の前に置くことができます。
要件
Node.js >= 22.5 ( 24 LTS 推奨 )
ドキュメント
設定リファレンス — すべてのフィールド、解決順序、ストレージスキーマ
CLI リファレンス — すべてのコマンドとフラグ
アーキテクチャ — スコアリングモデル、ストレージスキーマ
ハーネスセットアップ — Claude Code 、 Cursor 、 Codex 、汎用 MCP クライアント
examples/project-mcp.json— 注釈付きスターター設定
開発
git clone https://github.com/fyrlabs/mcp-nexus && cd mcp-nexus
npm install
npm run build # tsc -> dist/
npm run test # vitest (unit + integration, mirrors src/ structure under src/tests/)
npm run typecheck # strict tsc, no emit
npm run lint # eslint統合テストでは、@modelcontextprotocol/server-everything パッケージを実際のダウンストリーム stdio サーバーとして起動し、完全なランタイムを通じて実行をルーティングします。パッケージを解決できない場合は自動的にスキップされます。
コントリビューションの規約( コミット、バージョニング、プルリクエスト )については AGENTS.md を参照してください。
プライバシー
Nexus は設定キャッシュ、インデックス、分析を .mcp-nexus/( または XDG データディレクトリ )に保存します。ルーター自体が外部に送信することはありません。外部の埋め込みプロバイダーを設定した場合、機能テキスト( タイトル / 説明 / キーワード )のみが送信されます。引数、シークレット、分析は送信されません。生のツール引数は永続化されません。
ライセンス
Available Tools
4 toolsdescribe_capabilitiesDescribe capabilitiesB
Return the full metadata and input schemas for the given capability IDs.
| Name | Required | Description | Default |
|---|---|---|---|
| capabilityIds | Yes | Capability IDs returned by search_capabilities |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It clearly states the tool returns metadata and schemas, which is a read-like operation, but it doesn't disclose any limitations, such as whether invalid IDs cause errors or whether the returned data is verbose. The description is accurate but sparse on behavioral nuances.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single clear sentence that is entirely on-topic. It front-loads the action and object, with no filler. Could earn a 5 if it referenced a sibling or workflow, but it remains efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given there is no output schema and no annotations, the description is the sole source of behavioral information. It tells the agent what the tool returns, but for a metadata-inspection tool, an agent might need to know whether it can be used before executing a capability or how errors are surfaced. Still, for a simple lookup tool, this is adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already documents the 'capabilityIds' parameter. The description adds the purpose context ('full metadata and input schemas') but doesn't add format or constraint details beyond the schema. Baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('Return') and resource ('metadata and input schemas') for given capability IDs. It distinguishes itself from sibling tools like search_capabilities (which likely finds capabilities) and execute_capability (which runs them), though it doesn't explicitly name them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage: given capability IDs, retrieve metadata. The parameter description notes IDs come from search_capabilities, implicitly showing a workflow step. However, it doesn't state when to use this vs execute_capability or search_servers, leaving some inference needed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
execute_capabilityExecute capabilityA
Execute a downstream MCP capability by ID. The underlying server is started on demand and the arguments are forwarded verbatim.
| Name | Required | Description | Default |
|---|---|---|---|
| arguments | No | Arguments matching the tool's input schema (see describe_capabilities) | |
| capabilityId | Yes | Capability ID to execute |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the transparency burden. It discloses two genuine behaviors: the backing server is 'started on demand' (affecting latency/resource use) and arguments are 'forwarded verbatim' (no transformation). It does not mention output shape, error behavior, or potential side effects of the downstream capability, so coverage is partial.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, each adding distinct information: the core action and two behavioral caveats. No redundant or filler wording, and the most important information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The definition is largely sufficient for a simple pass-through invocation, and the arguments schema points to describe_capabilities for the input contract. However, there is no output schema or description of the return value/error behavior, so an agent does not know what to expect after invocation. This is a moderate gap given no annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already documents both parameters completely (100% coverage), so the baseline is 3. The description's 'arguments are forwarded verbatim' reinforces the arguments parameter's semantics, but adds no new parameter-specific detail beyond the schema, which already tells the agent to see describe_capabilities for the expected argument shape.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific action – 'Execute a downstream MCP capability by ID' – with a clear verb and resource. The 'by ID' scoping and the 'downstream MCP' qualifier distinguish it from siblings like describe_capabilities and search_capabilities, which are informational rather than invocational.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage: you invoke this when you have a capability ID and want to run it, and the 'forwarded verbatim' phrasing indicates arguments should already conform to the target schema. It does not explicitly list exclusions or alternatives, but the sibling names make the distinction clear. This is adequate context without explicit when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_capabilitiesSearch capabilitiesA
Search every indexed downstream MCP capability by natural language, keywords, tags, server id, or capability id. Returns lightweight metadata only.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of results to return | |
| query | Yes | Natural language or keyword query describing the capability you need |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are absent, so the description carries the full behavioral burden. It usefully discloses that the tool is a search operation returning 'lightweight metadata only', which implies read-only behavior and no full payload or execution. However, it does not mention result shape, pagination behavior, indexing caveats, or what happens when nothing matches.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One dense, front-loaded sentence carries the purpose, scope, search dimensions, and return nature with no filler. Every phrase earns its place, and the most important information appears first.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple two-parameter search tool, the description is largely complete: the query semantics are enriched, the limit is documented in the schema, and the return type is characterized. The main remaining gap is the absence of an output schema or a more concrete list of returned metadata fields, but this does not prevent a capable agent from selecting and invoking the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is already 100%, so the baseline is 3. The description adds genuine meaning beyond the schema by expanding query to include tags, server id, and capability id as acceptable forms, which the schema's 'natural language or keyword query' line does not convey. The limit parameter remains fully covered by its schema description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description identifies the exact action ('Search'), the resource ('every indexed downstream MCP capability'), and the query dimensions (natural language, keywords, tags, server id, capability id), which clearly differentiates it from search_servers and the other sibling tools. It also specifies the return nature ('lightweight metadata only'), leaving no ambiguity about what the tool is for.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The scope phrasing implies when to use it—whenever you need to discover a capability across indexed downstream MCPs—but it never explicitly states when not to use it or points to describe_capabilities/execute_capability/search_servers. Sibling names hint at those alternatives, but the description itself provides no routing guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_serversSearch serversA
Rank configured downstream MCP servers against a domain-level query. Useful before drilling into capability search.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Domain-level query such as 'project management' |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It discloses the core behavior (ranking servers, not modifying them) and the scoping to configured downstream MCP servers. It doesn't cover details like ranking criteria, read-only guarantees, or response shape, but the disclosed behavior is accurate and non-contradictory.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences with no filler. The core action is front-loaded, and the usage context is a single additional clause that earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter search tool with no output schema, the description is largely complete: it states what is ranked, the query type, and when to use it. The main gap is the absence of any mention of the return value, which the absence of an output schema makes slightly more relevant.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and the query parameter is already documented in the schema. The description reinforces 'domain-level query' but adds no parameter format or constraints beyond the schema, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description uses a specific verb ('Rank'), a specific resource ('configured downstream MCP servers'), and a clear scope ('domain-level query'). It also positions itself against the capability-search siblings, so an agent can distinguish it from search_capabilities without opening the schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Description gives explicit temporal guidance: use this before drilling into capability search. It doesn't explicitly name the alternative or list when-not-to-use cases, but the context is clear enough given sibling names.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
4 tool updates
v0.10.0- First observed
describe_capabilities - First observed
execute_capability - First observed
search_capabilities - First observed
search_servers
TDQS
Scored across 4 tools
Each tool has a clear operational role: searching servers, searching capabilities, describing schemas, and executing. search_servers and search_capabilities are adjacent but their descriptions clearly separate domain-level server ranking from capability-level search.
All tool names follow a consistent verb_noun snake_case pattern. The only minor inconsistency is 'capabilities' being plural in search/describe but singular in execute_capability.
Four tools is well-scoped for a gateway or meta-server: discover servers, discover capabilities, inspect schemas, and execute. There is no redundancy or unnecessary bloat.
The discover → describe → execute workflow is covered end-to-end. Minor gaps such as explicit list-all-server or dedicated server metadata retrieval are missing, but search_servers can largely cover discovery needs.
Maintenance
Related MCP Connectors
Connect MCP clients to 2,000+ AI models without managing provider API keys.
Every service you connect, one MCP endpoint for all your AI tools. Sign in once.
The OpenRouter for tools. One MCP connection gives any AI agent 254 hosted tools, pay per call.
MCP gateway: one connection for your AI apps, with tool policies, PII redaction and audit logs.
Related MCP Servers
- AlicenseNot gradedqualityAmaintenanceA unified hub for centrally managing and dynamically orchestrating multiple MCP servers/APIs into separate endpoints with flexible routing strategies.3,315 npm2,634Apache 2.0
- AlicenseNot gradedqualityBmaintenanceEnables dynamic aggregation of multiple MCP servers into a unified endpoint with middleware, orchestration, and gateway capabilities.MIT
- AlicenseNot gradedqualityCmaintenanceEnables clients to connect once and access the union of multiple backend MCP servers' tools through a single unified interface, with namespaced tool routing, capability search, and health isolation.MIT
- AlicenseNot gradedqualityAmaintenanceEnables clients to connect through a unified MCP endpoint that aggregates and routes requests to multiple backend MCP resource servers, exposing their combined tools and resources with optional authentication and management.104 npmMIT