varandrew/moor

Moor

Local MCP Gateway Manager for AI Agents Aggregate multiple MCP servers into a single endpoint, filter tools by Profile, and manage everything from a beautiful native UI.

Install · Quickstart · Features · Architecture · Development · API

English | 汉语 | 日本語 | Español

---

AI Agents need tools, but managing dozens of MCP servers across different clients is a mess. I wanted a single gateway that aggregates everything, filters by context, and keeps running in the background — all controllable from a beautiful native UI.

Moor exposes one endpoint (http://127.0.0.1:/mcp) that dynamically serves only the tools you want, based on your active Profile. Switch profiles without disconnecting your Agent, and every tool call is audited. That’s why I built it.

Dashboard — Overview of active Profile, server status, and audit stats.

Servers — Manage MCP servers, import configs, monitor health.

Profiles — Create profiles, toggle servers, enable/disable tools.

Audit — Inspect every tool call with full context and filters.

Install

macOS App

Download the .dmg from Releases, drag to Applications, done. The app bundles the HTTP server as an in-process Rust binary — no pre-installed Node.js runtime required.

Windows App

Download the Windows installer from Releases and run it. The app bundles the HTTP server as an in-process Rust binary — no pre-installed Node.js runtime required.

Linux App

Download the .deb, .rpm, or .AppImage from Releases (x86_64 and aarch64 builds are produced by CI). The app bundles the HTTP server as an in-process Rust binary — no pre-installed Node.js runtime required. macOS remains the primary target; Linux builds are produced by CI but less extensively tested.

Build from Source

Requires macOS (Apple Silicon / Intel), Windows x64, or Linux (x86_64 / aarch64), Node.js >= 22 (CI uses 24), pnpm >= 10, and Rust >= 1.77.

git clone https://github.com/varandrew/moor.git
cd moor
pnpm install

See Development for build instructions.

Quickstart

Launch the App

Open Moor.app. The Dashboard shows your active Profile, server status, and recent audit logs at a glance.

Scan Existing Configs

Moor can automatically detect MCP servers you’ve already configured for Claude Code, Codex, OpenCode, and Cursor:

1. Go to Servers → Import
2. Click Scan — Moor reads ~/.claude/settings.json, ~/.codex/config.toml, ~/.config/opencode/opencode.json / .jsonc, and ~/.cursor/mcp.json
3. Select the servers you want to import

You can also paste a JSON MCP configuration with Import JSON. Moor imports stdio and HTTP/SSE servers, and reports unsupported entries such as OpenAPI configs without saving them.

Create a Profile

Profiles let you group servers and control which tools are exposed to Agents:

1. Go to Profiles → New Profile
2. Name it (e.g., “Coding”, “Research”)
3. Toggle servers on/off
4. Expand a server to enable/disable individual tools
5. Click Activate — the change is instant

Connect Your Agent

Point any MCP-compatible client to Moor’s single endpoint:

http://127.0.0.1:9223/mcp

9223 is the default gateway port. If it is already in use, Moor picks the next available port and shows the actual endpoint in the Dashboard and Client Config pages.

The /mcp endpoint is loopback-only and does not require X-Moor-Token. Moor uses X-Moor-Token only for local management APIs between the WebView and gateway, so you do not need to paste it into agent configs.

Moor handles the rest — aggregating tools/list, routing tools/call, and filtering based on your active Profile.

Features

MCP Gateway Aggregation

A single HTTP endpoint (/mcp) proxies all backend MCP servers. Agents see a unified tool catalog — no need to configure multiple endpoints.

Multi-Transport Support

Connect to both stdio (subprocess) and HTTP/SSE MCP servers. Moor manages connection lifecycles, restarts, and health checks automatically.

Profile Management

Create unlimited Profiles for different workflows. Each Profile stores:

• Which servers are enabled
• Which tools are disabled per server
• A global active state

Switch Profiles with hot-swap — connected Agents stay connected, and the next tools/list reflects the new configuration immediately.

Tool-Level Toggles

Beyond server-level on/off, drill into any server to disable specific tools. Disabled tools disappear from the Agent’s tool catalog in real time.

Config Import

One-click import from:

• Claude Code: ~/.claude/settings.json
• Codex: ~/.codex/config.toml
• OpenCode: ~/.config/opencode/opencode.json / .jsonc
• Cursor: ~/.cursor/mcp.json

Manual entry and pasted JSON batch import are also supported for stdio and HTTP/SSE servers.

Client Configuration

Generate ready-to-copy configuration snippets for Claude Code, Codex, OpenCode, and Cursor. The snippets contain only the /mcp endpoint; Moor’s X-Moor-Token is reserved for internal management API calls.

Audit Logs

Every tools/call is recorded with:

• Timestamp, Profile, Server, Tool name
• Arguments (with sensitive data redaction)
• Result or error
• Duration and Agent info

Filter by time range, server, or tool. View aggregate statistics on the Dashboard.

System Tray

Close the window — Moor keeps running in the macOS menu bar or Windows system tray. The gateway stays alive, so your Agents never lose connection.

Real-Time Status

Server status changes and Profile switches are pushed to the UI via SSE. No refresh needed.

Architecture

Communication Flow

AI Agent ──HTTP──▶ POST /mcp ──▶ Moor Gateway ──stdio/HTTP──▶ MCP Servers
                              │
WebView ──IPC──▶ get_sidecar_info ─┐
WebView ──fetch──▶ /api/runtime ───┤ (fallback in browser dev mode)
WebView ──fetch──▶ /api/* ─────────┘
WebView ◀──SSE──── /api/events

• Runtime discovery: WebView → Tauri IPC (get_sidecar_info) → Rust (port, token); falls back to HTTP GET /api/runtime in browser dev mode
• Business operations: WebView → HTTP fetch() → In-process Axum server (Rust)
• System operations: WebView → Tauri IPC → Rust (tray, window, auto-start)

Development

Prerequisites

• macOS (Apple Silicon / Intel), Windows x64, or Linux (x86_64 / aarch64)
• Node.js >= 22 (CI uses 24)
• pnpm >= 10
• Rust >= 1.77
• Xcode Command Line Tools on macOS

Install Dependencies

pnpm install

Development Mode

Start the full desktop app (Tauri, with the in-process Rust gateway):

pnpm tauri dev

• Frontend dev server: http://localhost:1420 (Vite HMR runs inside the WebView)

Production Build

pnpm tauri build

Outputs:

• macOS: src-tauri/target/release/bundle/macos/Moor.app
• macOS DMG: src-tauri/target/release/bundle/dmg/Moor__aarch64.dmg
• Windows: src-tauri/target/release/bundle/nsis/Moor__x64-setup.exe

Code Quality

vp check       # format + lint + type check
vp lint        # lint only
vp lint --fix  # auto-fix
vp fmt         # format

Testing

# Rust gateway tests
cargo test --manifest-path src-tauri/Cargo.toml

# Frontend + scripts tests
vp test

API

MCP Gateway

Server Management

Profile Management

Audit Logs

Settings Management

Other

Tech Stack

Acknowledgements

Thanks to the linuxdo community for discussion, sharing, and feedback.

❤️ Sponsor

🌟 Star History

License

MIT