Which integrations are available for this server?

Enables orchestration of GitHub MCP tools for managing issues, repositories, and files.

How do I use MCP Conductor?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@MCP Conductor analyze my project's dependencies and check for updates" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

MCP Conductor

by darkiceinteractive

Overview Schema Source Related Servers Discussions Admin

TypeScript

Local

MCP Conductor

The canonical MCP hub for any agent platform. 99.7% fewer tokens. One npx command.

MCP Conductor is a single MCP server that orchestrates all your other MCP servers through a sandboxed Deno runtime. Works with Claude Code, Claude Desktop, Cursor, Gemini CLI, Codex CLI, Cline, Zed, Continue.dev, OpenCode, and Kimi Code. Instead of your AI client making direct tool calls (and dumping every intermediate result into your context window), it writes TypeScript code that runs in an isolated sandbox. Only the final result comes back.

Before: 153,900 tokens → AI client context window → 153,900 tokens billed
After:  153,900 tokens → Deno sandbox → 435 tokens → AI client context window

Average measured reduction: 99.7%. Verified against Anthropic's published benchmarks.

Quick Install

v3.1.1 — Supported Clients

Client	Config path (macOS)	Config path (Linux)	Config path (Windows)
Claude Code	`~/.claude/settings.json`	`~/.claude/settings.json`	`%APPDATA%\Claude Code\claude_code_config.json`
Claude Desktop	`~/Library/Application Support/Claude/claude_desktop_config.json`	`~/.config/claude/claude_desktop_config.json`	`%APPDATA%\Claude\claude_desktop_config.json`
Cursor	`~/.cursor/mcp.json`	`~/.cursor/mcp.json`	`~/.cursor/mcp.json`
Gemini CLI	`~/.gemini/settings.json`	`~/.gemini/settings.json`	`~/.gemini/settings.json`
Codex CLI	`~/.codex/config.toml`	`~/.codex/config.toml`	`~/.codex/config.toml`
Cline	`~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json`	`~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json`	`%APPDATA%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json`
Zed	`~/Library/Application Support/Zed/settings.json`	`~/.config/zed/settings.json`	`%LOCALAPPDATA%\Zed\settings.json`
Continue.dev	`~/.continue/config.yaml`	`~/.continue/config.yaml`	`~/.continue/config.yaml`
OpenCode	`~/.config/opencode/opencode.json`	`~/.config/opencode/opencode.json`	`%APPDATA%\opencode\opencode.json`
Kimi Code	`~/Library/Application Support/Kimi Code/mcp_settings.json`	`~/.config/kimi-code/mcp_settings.json`	`%APPDATA%\Kimi Code\mcp_settings.json`

Guided Setup (recommended)

The setup wizard auto-detects every supported client on your machine and offers per-client consolidation:

npx -y @darkiceinteractive/mcp-conductor-cli@next setup

See What the wizard does below.

Manual Config Snippets

Paste the appropriate block into your client's config file. The wizard does this automatically.

Claude Code (~/.claude/settings.json):

{
  "mcpServers": {
    "mcp-conductor": {
      "command": "npx",
      "args": ["-y", "@darkiceinteractive/mcp-conductor"]
    }
  }
}

Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json on macOS):

{
  "mcpServers": {
    "mcp-conductor": {
      "command": "npx",
      "args": ["-y", "@darkiceinteractive/mcp-conductor"]
    }
  }
}

Cursor (~/.cursor/mcp.json):

{
  "mcpServers": {
    "mcp-conductor": {
      "command": "npx",
      "args": ["-y", "@darkiceinteractive/mcp-conductor"]
    }
  }
}

For Codex CLI (TOML), Continue.dev (YAML), and other formats, use mcp-conductor-cli export --client <id> — see Multi-client export.

Restart your AI tool after editing the config. That's it.

Related MCP server: MCP of MCPs

What the Wizard Does

Running npx -y @darkiceinteractive/mcp-conductor-cli@next setup steps through the following for each detected client:

Scan — discovers all 10 client config locations on your machine (global and project-local).
Diff — for each existing config, parses the current server list and shows what will move.
Confirm per-client — prompts once per client; you can skip any client individually.
Write conductor config — merges your existing servers into ~/.mcp-conductor.json and installs the conductor entry back into the client config.
Backup originals — creates a timestamped .bak.YYYYMMDDHHMMSS copy of every config file before modifying it.

In non-interactive environments (CI, piped stdin) the wizard proceeds automatically with safe defaults.

Verifying Setup

mcp-conductor-cli doctor

The doctor command runs a health check across all configured servers and prints an MCP CLIENT COVERAGE section showing every detected client config with an [OK] or [MISSING] status for the conductor entry.

MCP CLIENT COVERAGE
  [OK]      Claude Code        ~/.claude/settings.json
  [OK]      Claude Desktop     ~/Library/Application Support/Claude/claude_desktop_config.json
  [OK]      Cursor             ~/.cursor/mcp.json
  [MISSING] Zed                ~/Library/Application Support/Zed/settings.json

Run npx -y @darkiceinteractive/mcp-conductor-cli@next setup to install the conductor entry in any [MISSING] client.

Multi-client Export

Generate a ready-to-paste config snippet for any supported client:

# Codex CLI — writes TOML
mcp-conductor-cli export --client codex

# Continue.dev — writes YAML
mcp-conductor-cli export --client continue

# Claude Desktop — writes JSON (default)
mcp-conductor-cli export --client claude-desktop

The exported file is written to the current directory as <client>-config.<ext>. Pass --output <path> to override.

Full client setup documentation is at docs.darkice.co/setup/clients.

30-Second Example

// Your AI client writes this code, which runs inside the Deno sandbox
const [issues, files] = await mcp.batch([
  () => mcp.server('github').call('list_issues', { owner: 'myorg', repo: 'myrepo', state: 'open' }),
  () => mcp.server('filesystem').call('list_directory', { path: '/src' })
]);

return {
  openBugs: issues.filter(i => i.labels.some(l => l.name === 'bug')).length,
  tsFiles: files.filter(f => f.name.endsWith('.ts')).length
};
// Returns: {"openBugs": 12, "tsFiles": 47}  ←  under 100 tokens

Why It Matters

When an AI client calls MCP tools directly, every response lands in the context window — raw JSON, file metadata, pagination objects, fields you never asked for. A single GitHub list_issues call can return 40,000+ tokens. If you're making 10 calls per task, that's 400,000 tokens before the model has written a single line of code.

MCP Conductor flips the model: the client writes TypeScript code that processes the tool responses inside a Deno sandbox. The sandbox can call any connected MCP server, filter and aggregate the results, and return only the compact summary. Your context window stays small. Your costs stay low.

Scenario	Without Conductor	With Conductor	Reduction
300-document Drive pipeline	153,900 tokens	435 tokens	99.72%
GitHub issues triage (10 repos)	~400,000 tokens	~2,000 tokens	99.5%
Web research (5 searches)	~50,000 tokens	~800 tokens	98.4%

v3 Highlights

Feature	What it does	Docs
Tool Registry	Schema validation, hot-reload, type generation	Architecture
Response Cache	LRU + CBOR serialisation, TTL per tool	Configuration
Reliability Gateway	Timeout, retry, circuit breaker	Architecture
Connection Pool	Warm sandbox pool, persistent server connections	Configuration
Sandbox API	`compact`, `summarize`, `findTool`, `budget`	Sandbox API
Daemon Mode	Shared KV store, distributed lock	Configuration
Observability	Cost predictor, hot-path profiler, session replay	Architecture
Passthrough Adapter	Expose backend tools directly (X1)	Recipes
Lifecycle Tools + CLI	`import_servers_from_claude`, setup wizard (X2)	Sandbox API
PII Tokenisation	Built-in redaction matchers (X4)	Configuration

v3.1.1 Additions

Feature	What it does
Multi-client adapters	Read and write configs for all 10 supported clients
Setup wizard (MC3)	Interactive per-client consolidation with backups
Per-client export (MC4)	`export --client <id>` writes the correct format (JSON / TOML / YAML)
Doctor client coverage (MC5)	`doctor` reports `[OK]` / `[MISSING]` per detected client config

Migrating from v2? See the migration guide.

Token-Savings Reporter

Pass show_token_savings: true on any execute_code call to see a breakdown:

{
  "result": { "processed": 300, "with_dates": 287 },
  "tokenSavings": {
    "estimatedPassthroughTokens": 153900,
    "actualExecutionTokens": 435,
    "tokensSaved": 153465,
    "savingsPercent": 99.72
  }
}

Or enable it globally in ~/.mcp-conductor.json:

{
  "metrics": {
    "alwaysShowTokenSavings": true
  }
}

Session totals are always available via get_metrics.

Docs

Full documentation at https://docs.darkice.co — deploys at D4. In the meantime, all reference material is in docs/v3/.

Guide	Description
Architecture	System design and data flow
Configuration	All config options
Sandbox API	The `mcp` object inside `execute_code`
Recipes	Practical patterns and examples
Migration (v2 → v3)	Breaking changes and migration steps
Client Setup	Per-client config reference for all 10 supported clients

CLI Quick-Start

# Guided multi-client setup — detects all supported client configs automatically
npx -y @darkiceinteractive/mcp-conductor-cli@next setup

# Health check with client coverage report
mcp-conductor-cli doctor

# Export config for a specific client (TOML for Codex, YAML for Continue, etc.)
mcp-conductor-cli export --client <client-id>

# Check system requirements (Node, Deno, conductor config)
mcp-conductor-cli check

# Show current configuration status
mcp-conductor-cli status

# Enable exclusive mode (routes all MCP calls through the sandbox)
mcp-conductor-cli enable-exclusive [--dry-run]

# Add a backend server
mcp-conductor-cli config add github npx -- -y @modelcontextprotocol/server-github

Contributing

Contributions welcome. Please read CONTRIBUTING.md for guidelines.

Bug reports: GitHub Issues
Discussions: GitHub Discussions
Security: See SECURITY.md

Licence

MIT — see LICENSE

Built by DarkIce Interactive · @darkiceinteractive/mcp-conductor on npm

Available Tools

24 tools

add_serverAdd ServerA

Add a new MCP server to conductor config and connect immediately.

Saves the server configuration to ~/.mcp-conductor.json and triggers a reload. Use this to dynamically add servers without restarting Claude.

Inputs: name (required), command (required), args, env. Returns: success, server_name, config_path, message, +1 more

brave_web_searchBrave Web SearchA

Read-only

Web search via Brave Search API. Uses 90% fewer tokens than native WebSearch.

Routes to brave-search MCP server internally. Requires brave-search server to be configured.

Inputs: query (required), count. Returns: success, results, error

compare_modesCompare ModesA

Read-onlyIdempotent

Analyse how a task would be handled in different modes. Returns estimated token usage and approach for each mode.

Inputs: task_description (required), estimated_tool_calls, estimated_data_kb. Returns: task, modes, recommendation, token_savings_percent

diagnose_serverDiagnose ServerA

Read-onlyIdempotent

Diagnose a registered MCP server: process health, connection status, recent errors, reconnect attempts, last successful call, and registry state. Returns actionable information about why a server may be failing.

Inputs: name (required). Returns: server_name, status, tool_count, connected_at, +5 more

discover_toolsDiscover ToolsA

Read-onlyIdempotent

Search for available tools across all connected MCP servers.

Inputs: query, server, limit. Returns: results, total_matches, servers_searched

execute_codeExecute CodeA

Destructive

Execute TypeScript/JavaScript code to perform MCP operations efficiently.

Token Savings: 90-98% vs individual tool calls. Batch operations in a single execution.

API: mcp.server('name').call('tool', params) | mcp.searchTools('query') | mcp.log('msg')

Example: const files = await mcp.filesystem.call('list_directory', { path: '/src' }); return files;

Use passthrough_call only for debugging - it has HIGH token cost.

Inputs: code (required), servers, timeout_ms, stream, +2 more. Returns: success, result, error, metrics, +2 more

export_to_claudeExport to ClaudeA

Read-onlyIdempotent

Generate a mcpServers JSON block that points Claude back at mcp-conductor stdio. This is the rollback path: paste the output into your Claude Desktop or Claude Code config to restore direct connectivity. Formats: "claude-desktop" (full wrapper object), "claude-code" (flat mcpServers), "raw" (inner object only).

Inputs: format, conductor_path. Returns: json, format, server_count, instructions

get_capabilitiesGet CapabilitiesA

Read-onlyIdempotent

Get detailed information about MCP Executor capabilities and configuration.

Inputs: no named parameters. Returns: version, current_mode, features, limits, +2 more

get_hot_pathsGet Hot PathsA

Read-onlyIdempotent

Return the top-K tool call paths by total latency or p99 within a rolling time window.

Inputs: sinceMs, topK, sortBy. Returns: paths

get_memory_statsGet Memory StatsA

Read-onlyIdempotent

Returns live memory usage and resource counts for the conductor process. Use this to diagnose memory issues.

Inputs: no named parameters. Returns: heap_used_mb, heap_total_mb, rss_mb, external_mb, +5 more

get_metricsGet MetricsA

Read-onlyIdempotent

Get detailed aggregated metrics for the current session including token savings, performance, and usage patterns.

Inputs: reset, include_details. Returns: session, executions, tokens, performance, +5 more

import_servers_from_claudeImport Servers from ClaudeA

Import MCP servers from Claude config files into ~/.mcp-conductor.json.

Reads ~/.claude/settings.json, ~/Library/Application Support/Claude/claude_desktop_config.json and other standard paths. Shows a diff of what will be imported. On confirm=true, copies entries into the conductor config and writes .bak backups of each source file. Optionally strips the imported servers from their source configs.

Inputs: confirm, remove_originals. Returns: dry_run, sources_found, total_imported, total_skipped, +1 more

list_serversList ServersB

Read-onlyIdempotent

List all MCP servers connected through MCP Executor.

Inputs: include_tools. Returns: servers, total_servers, total_tools

passthrough_callPassthrough CallA

Destructive

⚠️ DEBUGGING TOOL - Direct MCP tool call. HIGH TOKEN COST (10-100x vs execute_code).

Only use for debugging raw tool input/output. Use execute_code for all normal operations.

Inputs: server (required), tool (required), params. Returns: success, result, error, metrics

predict_costPredict CostA

Read-onlyIdempotent

Predict the token cost and latency of executing code based on historical samples for similar call patterns.

Inputs: code (required). Returns: estimatedInputTokens, estimatedOutputTokens, estimatedLatencyMs, basedOn, +1 mo…

recommend_routingRecommend RoutingA

Idempotent

Apply the X1 routing heuristic to one or all configured servers. Servers whose names match lightweight-payload patterns (search, calendar, email, etc.) are recommended as "passthrough". All others default to "execute_code" (safe default). Use apply=true to write the hints into conductor config.

Inputs: server_name, apply. Returns: recommendations, applied, config_path

record_sessionRecord SessionA

Start recording all tool calls in the current session to a replay journal.

Inputs: sessionId. Returns: sessionId, recordingPath

reload_serversReload ServersA

Destructive

Reload MCP server configurations. Useful after modifying claude_desktop_config.json.

Inputs: no named parameters. Returns: added, removed, total_servers, message

remove_serverRemove ServerA

DestructiveIdempotent

Remove an MCP server from conductor config and disconnect it.

Removes the server configuration from ~/.mcp-conductor.json and triggers a reload. Use this to dynamically remove servers without restarting Claude.

Inputs: name (required). Returns: success, server_name, config_path, message, +1 more

replay_sessionReplay SessionA

Read-onlyIdempotent

Replay a recorded session, optionally applying modifications. Detects divergence when replayed result differs from recorded result.

Inputs: recordingPath (required), modifications. Returns: result, divergence

set_modeSet Operation ModeA

DestructiveIdempotent

Switch between operation modes:

execution: All requests go through the code executor (default, maximum token savings)
passthrough: Direct tool calls without code execution (for debugging/comparison)
hybrid: Automatic selection based on task complexity

Inputs: mode (required). Returns: previous_mode, current_mode, message

stop_recordingStop RecordingA

Stop an active recording session and finalise the replay journal.

Inputs: sessionId (required). Returns: recordingPath, eventCount

test_serverTest ServerA

Read-onlyIdempotent

Transiently connect to a named MCP server from conductor config, list its tools and measure latency. Does NOT persist the connection or register the server. The server must be present in ~/.mcp-conductor.json.

Inputs: name (required), timeout_ms. Returns: success, server_name, connected, tool_count, +3 more

update_serverUpdate ServerA

DestructiveIdempotent

Update an existing MCP server's configuration (command, args, or env vars).

Use this to update API keys or other settings without removing and re-adding the server. Triggers a reload to apply changes immediately.

Inputs: name (required), command, args, env, +1 more. Returns: success, server_name, config_path, message, +1 more

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

Deploy Server

Claude Code, inside the Godot 4 editorFlockbay puts an AI agent in the real Godot 4 editor: it writes GDScript, runs your game and fixes what breaks. Free, or bring your own Claude Code or Codex.flockbay.comAd

TDQS

A3.9/5.0

Scored 2026-05-29 16:50 across 24 tools

Disambiguation5/5

Every tool has a clearly distinct purpose. Even similar tools like execute_code and passthrough_call are explicitly differentiated in their descriptions for efficient vs debugging use. No two tools appear to perform the same function.

Naming Consistency5/5

All tool names use snake_case and follow a consistent verb_noun or get_noun pattern (e.g., add_server, get_metrics, list_servers). The naming convention is uniform and predictable across all 24 tools.

Tool Count3/5

With 24 tools, the set is on the high side (16-25 being 'heavy' per rubric). While each tool serves a clear role, the count feels slightly bloated, especially with tools like brave_web_search that seem peripheral to the core conductor functionality.

Completeness4/5

The tool surface covers most expected operations: CRUD for server configuration, diagnostics, execution, metrics, recording/playback, mode switching, and import/export. A minor gap is the lack of a disable/enable tool for individual servers, but overall it is comprehensive.

Maintenance

ActivityInactive

ResponsivenessNo recent community issues

Resources

Related MCP Connectors

Flowra
io.github.flowradev
MCP server for your apps' tools and custom tools, plus hosted AI agents and approval-gated workflows
Agent Orchestration Autonomous Agents
11
https://mcp.flowra.dev/mcp
x402-broker-mcpA
io.github.robertoyanguas-ops
Single-connection meta-router indexing 500+ MCP servers & A2A tools with 85% token compression and
Agent Orchestration Developer Tools
41
https://x402-broker-72343955726.us-central1.run.app/mcp/x402-broker
DuckHub QR MenuA
com.duck-hub
Hosted MCP server to manage a restaurant menu from AI agents - 39 tools over the DuckHub API.
E-commerce & Retail Content Management Systems
3
https://mcp.duck-hub.com/mcp
TokenZeroA
io.github.tokenzero-ai
LLM cost optimization gateway, repo token-waste auditor & model arbitrage MCP server.
AI & Machine Learning Developer Tools Code Analysis
61
https://tokenzero.sh/mcp

Related MCP Servers

Code Executor MCP Server
Code Execution Autonomous Agents
aberemia24
A
license
Not graded
quality
D
maintenance
Universal MCP server for executing TypeScript and Python code with progressive disclosure, reducing token usage by 98% by enabling on-demand access to all other MCP tools through code execution rather than loading tool definitions directly.
Updated a year ago (2025-11-24 12:56 UTC)
38 npm
130
MIT
MCP of MCPs
Agent Orchestration Code Execution Developer Tools
eliavamar
A
license
Not graded
quality
D
maintenance
A meta-server that aggregates multiple MCP servers into a single interface, reducing token usage by 98%+ through progressive tool discovery and direct code execution that processes data between tools without consuming context window space.
Updated 7 months ago (2026-04-23 17:55 UTC)
16 npm
10
Apache 2.0
MCP Coordinator
Developer Tools Agent Orchestration
CyberClash
A
license
Not graded
quality
D
maintenance
Acts as a proxy for multiple MCP servers, reducing context window usage from 15,000+ tokens to ~500 tokens by dynamically loading servers on-demand and exposing only 3 tools instead of all tool definitions.
Updated a year ago (2025-12-18 06:13 UTC)
5
GPL 3.0
MCX (Modular Code Execution)
Code Execution Developer Tools Autonomous Agents
schizoidcock
A
license
Not graded
quality
D
maintenance
An MCP server that enables AI agents to execute sandboxed JavaScript and TypeScript code instead of calling individual tools directly. It significantly reduces token usage by allowing agents to filter, aggregate, and transform data locally before returning results.
Updated 6 months ago (2026-05-25 07:49 UTC)
11 npm
28
MIT

MCP Conductor

Quick Install

v3.1.1 — Supported Clients

Guided Setup (recommended)

Manual Config Snippets

What the Wizard Does

Verifying Setup

Multi-client Export

30-Second Example

Why It Matters

v3 Highlights

v3.1.1 Additions

Token-Savings Reporter

Docs

CLI Quick-Start

Contributing

Licence

Available Tools

Tool Schema Changelog

TDQS

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

Code Executor MCP Server

MCP of MCPs

MCP Coordinator

MCX (Modular Code Execution)