MCP Manager

A cross-platform desktop application for managing Model Context Protocol servers

---

What It Does

MCP Manager is a native desktop application for managing Model Context Protocol (MCP) servers. It provides centralized discovery, monitoring, and control of MCP servers across different clients (Claude Desktop, Cursor, etc.). Built with Go and Wails, MCP Manager offers a unified interface for all your MCP server management needs.

Features at a Glance

Feature	Description
🔍 Auto-Discovery	Finds servers from client configs, extensions, filesystem, and running processes
🎮 Lifecycle Control	Start, stop, restart with transport-aware handling (stdio/HTTP/SSE)
📊 Real-Time Monitoring	Log aggregation, CPU/memory metrics, status tracking
⚙️ Configuration	GUI-based editing of settings, environment variables, arguments
🛠️ Utilities	Network analysis (Netstat), system services, file explorer, shell access
📦 Dependency Management	Auto-detect Node.js, Python, and other runtime requirements

Why It's Useful

Managing multiple MCP servers means juggling config files, terminal windows, and log outputs. MCP Manager consolidates this complexity into a single interface.

Before MCP Manager:

• 🔍 Hunt through config files to find which servers are installed
• 📝 Track multiple terminal windows for logs
• 🔧 Manually edit JSON files for configuration changes
• ❓ No visibility into server health or resource usage

With MCP Manager:

• ✅ See all servers at a glance with real-time status
• ✅ Unified log viewer with filtering and search
• ✅ GUI-based configuration editing
• ✅ Resource monitoring and dependency validation
• ✅ One-click start/stop/restart operations

Built for power users: Efficiently handles up to 50 servers - ideal for developers and teams with complex MCP deployments.

Prerequisites

• Go 1.21+ - Download
• Node.js 16+ - For frontend development (optional for building from source)
• Wails v2 - Desktop application framework

Platform-specific:

• Windows: WebView2 (usually pre-installed on Windows 10+)
• macOS: macOS 10.13+ (High Sierra or later)
• Linux: webkit2gtk package (sudo apt install webkit2gtk-4.0 on Debian/Ubuntu)

Quick Start

# Install Wails
go install github.com/wailsapp/wails/v2/cmd/wails@latest

# Clone and run
git clone https://github.com/Positronikal/MCPManager.git
cd MCPManager
wails dev

MCP Manager will automatically discover your installed MCP servers on first launch.

For detailed installation and usage, see USING.md.

Development Verification

Before committing changes, run local verification to ensure code quality:

# Unix/macOS/Linux
./scripts/verify-build.sh

# Windows
scripts\verify-build.bat

# Quick check (faster, skips race detection and integration tests)
./scripts/verify-build.sh --quick

# Skip the full Wails build (faster for iterative development)
./scripts/verify-build.sh --skip-build

These scripts replace GitHub Actions CI and run the same quality gates locally:

• Backend unit, integration, and contract tests
• Go formatting, vet, and staticcheck linting
• Frontend TypeScript checking and tests
• Build verification

See USING.md for more details on the verification workflow.

Project Status

• ✅ Core Features: Complete (98/98 specification tasks)
• ✅ Cross-Platform: Windows, macOS, Linux
• ✅ Transport Support: stdio, HTTP, SSE
• ✅ Test Coverage: All tests passing (unit, contract, integration, performance)
• 📦 Version: v1.3.1
• 📚 Documentation: Complete

Community & Support

• 📖 Documentation: See the docs/ directory for development documentation
• 🐛 Bug Reports: See BUGS.md for bug tracking and reporting guidelines
• 🔒 Security: See SECURITY.md for vulnerability reporting procedures
• 🤝 Contributing: See CONTRIBUTING.md for contribution guidelines

Adherence to Standards

This project adheres to the Positronikal Coding Standards. All contributors are expected to be familiar with these standards.

Repository Structure Notes

This project follows Go and Wails framework conventions where they provide better tooling support and developer experience. While we maintain compatibility with Positronikal standards for documentation and security practices, the directory structure reflects idiomatic Go project layout and Wails requirements:

Go/Wails Conventions Used

• internal/: Private application code (Go standard)
• pkg/: Public library code (Go standard)
• tests/: Test files and fixtures (Go convention - note the plural)
• frontend/: Svelte frontend code (Wails requirement - must be at root)
• build/: Wails build output and assets (Wails requirement)
• Root .go files: app.go, main.go for Wails bindings (Wails requirement)

Positronikal Standard Directories Maintained

• docs/: Development documentation
• etc/: Scratch workspace for developers
• rel/: Release packages (alpha, beta, stable)
• ref/: Reference materials and future user manual content

Special Directories

• .claude/: Claude Code configuration and slash commands
• .github/: GitHub Actions workflows and configuration

This hybrid approach allows the project to benefit from Go's excellent tooling (go modules, go test, gopls) and Wails' build system while maintaining Positronikal documentation and security standards.

Repository Map

The following directories and files comprise the MCP Manager repository:

Go Application Structure

internal/

• Private application code (not importable by other projects)
• api/ - REST API handlers and routing
• core/ - Core business logic services (discovery, lifecycle, monitoring, config, events)
• models/ - Data structures and domain models
• platform/ - Cross-platform abstractions (Windows, macOS, Linux)
• storage/ - Application state persistence

pkg/

• Public library code (potentially importable by other projects)

tests/

• Test files organized by type:
  • unit/ - Unit tests for individual packages
  • contract/ - API contract validation tests
  • integration/ - Service interaction tests
  • performance/ - Benchmarks for startup time and memory usage

Frontend Application

frontend/

• Svelte 4.x frontend application
• src/ - Source code (components, services, stores, types)
• node_modules/ - NPM dependencies
• public/ - Static assets
• package.json - Frontend dependencies and scripts

build/

• Wails build output and platform-specific assets (gitignored)
• bin/ - Compiled executables (development and testing)
• windows/, darwin/, linux/ - Platform-specific build artifacts
• Note: This is the single source of truth for built executables during development

Documentation & Standards

docs/

• Development documentation for understanding and maintaining the project

ref/

• Reference materials and external documentation

etc/

• Developer scratch workspace, session notes, test reports, and temporary files

rel/

• Release packages (alpha, beta, stable versions) for distribution
• Production installers and packaged executables belong here

scripts/

• Build scripts, automation tools, and helper utilities

Special Directories

.claude/

• Claude Code configuration and custom slash commands
• Contains project-specific commands for AI-assisted development

.github/

• GitHub Actions CI/CD workflows
• Issue templates and repository configuration

Go/Wails Build Files

app.go

• Wails application bindings exposing Go methods to frontend

main.go

• Application entry point

wails.json

• Wails configuration (frontend commands, build settings, app metadata)

go.mod / go.sum

• Go module dependencies

.editorconfig

• Editor configuration for consistent code formatting

.gitattributes / .gitignore

• Git configuration for line endings and ignored files

Standard Repository Files

ATTRIBUTION.md

• Credit to upstream projects and dependencies

AUTHORS.md

• Project contributors (human and AI)

BUGS.md

• Bug tracking and reporting process

CONTRIBUTING.md

• Contribution guidelines

COPYING.md

• GPLv3 license terms

SECURITY.md

• Security policy and vulnerability reporting

USING.md

• Installation and usage instructions

docs/PACKAGING.md

• Production build and packaging instructions (for maintainers)

README.md

• This document - project overview and navigation

---

Last Updated: 2026-03-14