mcpm

Maintains a single source of truth for all installed MCP servers in ~/.mcpm/servers.json that automatically synchronizes across 14+ MCP clients (Claude Desktop, Cursor, VSCode, etc.) through client-specific configuration managers. Uses a layered architecture with bidirectional sync adapters that translate between MCPM's global config format and each client's native configuration file format (JSON, YAML, TOML variants), eliminating manual duplication and version drift across tools.

Organizes installed MCP servers into logical groups (profiles) using tags without duplicating server definitions, allowing developers to activate different server sets for different workflows. Profiles are stored in ~/.mcpm/profiles_metadata.json and reference servers by tag, enabling lightweight context switching between development, testing, and production server configurations without modifying the underlying global servers.json registry.

Automatically introspects MCP servers to extract their capabilities, available functions, argument schemas, and return types without requiring manual documentation or configuration. The introspection layer invokes servers with introspection requests (following MCP protocol), parses the responses, and builds a capability index that describes what each server can do, what arguments it accepts, and what it returns. This enables dynamic server discovery, capability-based server selection, and automatic documentation generation without manual schema definition.

Provides a hierarchical command-line interface with organized subcommands for server management (install, remove, update), client management (sync, list), profile management (create, list, activate), and execution/sharing (run, share, tunnel). The CLI uses a command router that dispatches to specialized managers based on the command hierarchy, with consistent flag parsing, help generation, and error handling across all subcommands. This enables developers to discover and use MCPM functionality through a familiar CLI interface with bash completion support and machine-readable help output.

Executes MCP servers in three distinct modes — STDIO for direct client integration, HTTP for testing and debugging, and SSE (Server-Sent Events) for streaming responses — with automatic mode selection based on client requirements. The execution layer abstracts the underlying transport protocol, allowing the same server definition to be deployed across different execution contexts without modification, using a mode-aware command wrapper that injects appropriate environment variables and protocol handlers.

Provides a centralized registry (mcpm.sh/registry) for discovering and installing MCP servers with automated manifest generation that extracts server metadata (name, version, description, capabilities, arguments) from server binaries or source code. The registry API enables programmatic server search, filtering by capability tags, and one-command installation via `mcpm install`, with manifest generation automatically creating standardized server.json entries that include command invocation, environment setup, and argument schemas without manual configuration.

Exposes MCP servers through encrypted tunnels using the FastMCP proxy system, enabling secure sharing of local servers with remote clients or team members without exposing raw server endpoints. The proxy layer handles encryption, authentication, and connection multiplexing, allowing a developer to share a server running on localhost:8000 with a remote collaborator via a secure tunnel URL that can be revoked or time-limited without modifying the underlying server.

Synchronizes server configurations across 14+ MCP clients by translating between MCPM's canonical JSON format and each client's native configuration format (Claude Desktop's JSON, Cursor's YAML, VSCode's JSON with extensions, etc.). The synchronization layer uses client-specific configuration managers that understand each client's file structure, environment variable handling, and server invocation patterns, enabling atomic updates where a single `mcpm sync` command propagates changes to all connected clients without manual editing.

Enables MCPM to be controlled entirely through environment variables and command-line flags without interactive prompts, allowing AI agents and automation scripts to manage MCP servers programmatically. The automation layer supports machine-readable output formats (JSON, YAML), environment variable substitution in server configurations, and non-blocking command execution, enabling agents to install, configure, and execute servers as part of larger automation workflows without human intervention.

Generates standardized, LLM-optimized documentation of all installed servers and their capabilities in ~/.config/mcpm/llm.txt, providing AI agents with a structured reference of available tools, arguments, and usage patterns. The documentation generator introspects server schemas, extracts capability descriptions, and formats them in a way that's optimized for LLM token efficiency and comprehension, enabling agents to understand and invoke servers without requiring separate documentation lookups or web searches.

Manages MCP servers across multiple installation types (binary executables, npm packages, Python packages, GitHub repositories, Docker containers) through a unified interface that abstracts the underlying installation mechanism. The lifecycle manager handles installation, updates, version pinning, dependency resolution, and removal, using type-specific handlers that understand each installation method's requirements and constraints, enabling developers to install servers from any source without learning installation-specific details.

Validates MCP server configurations against standardized schemas and maps user-provided arguments to server command-line invocations, ensuring type safety and preventing misconfiguration. The schema validation layer uses JSON Schema for server definitions, validates argument types (string, number, boolean, array), enforces required arguments, and provides helpful error messages when validation fails. The argument mapper translates high-level configuration into server-specific command-line flags and environment variables, handling escaping, quoting, and platform-specific differences automatically.