Skip to content
Back to search

mcpm.sh

CLI MCP package manager & registry for all platforms and all clients. Search & configure MCP servers. Advanced Router & Profile features.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/pathintegral-institute/mcpm.sh with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/pathintegral-institute/mcpm.sh'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/pathintegral-institute--mcpm-sh/badge.svg)](/listings/pathintegral-institute--mcpm-sh)

HTML

<a href="/listings/pathintegral-institute--mcpm-sh"><img src="/api/listings/pathintegral-institute--mcpm-sh/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

Recommended:

curl -sSL https://mcpm.sh/install | bash

Or choose [other installation methods](#-other-installation-methods) like `brew`, `pipx`, `uv` etc.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 444 lines · 1 finding marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ![Homebrew Formula Version](https://img.shields.io/homebrew/v/mcpm?style=flat-square&color=green)
  2. ![PyPI - Version](https://img.shields.io/pypi/v/mcpm?style=flat-square&color=green)
  3. ![GitHub Release](https://img.shields.io/github/v/release/pathintegral-institute/mcpm.sh?style=flat-square&color=green)
  4. ![GitHub License](https://img.shields.io/github/license/pathintegral-institute/mcpm.sh?style=flat-square&color=orange)
  5. ![GitHub contributors](https://img.shields.io/github/contributors/pathintegral-institute/mcpm.sh?style=flat-square&color=blue)
  6. ![PyPI - Downloads](https://img.shields.io/pypi/dm/mcpm?style=flat-square&color=yellow)
  7. ![GitHub commit activity](https://img.shields.io/github/commit-activity/m/pathintegral-institute/mcpm.sh?style=flat-square&color=red)
  8. English | [简体中文](README.zh-CN.md)
  9. ![mcpm.sh](https://socialify.git.ci/pathintegral-institute/mcpm.sh/image?custom_description=One+CLI+tool+for+all+your+local+MCP+Needs.+Search%2C+add%2C+configure+MCP+servers.+Router%2C+profile%2C+remote+sharing%2C+access+monitoring+etc.&description=1&font=Inter&forks=1&issues=1&name=1&pattern=Floating+Cogs&pulls=1&stargazers=1&theme=Auto)
  10. ```
  11. Open Source. Forever Free.
  12. Built with ❤️ by Path Integral Institute
  13. ```
  14. # 🌟 MCPM - Model Context Protocol Manager
  15. MCPM is an open source CLI tool for managing MCP servers. It provides a simplified global configuration approach where you install servers once and organize them with profiles, then integrate them into any MCP client. Features include server discovery through a central registry, direct execution, sharing capabilities, and client integration tools.
  16. Demo is showing outdated v1 commands, new demo is baking ...
  17. ![Demo of MCPM in action](.github/readme/demo.gif)
  18. ## 🤝 Community Contributions
  19. > 💡 **Grow the MCP ecosystem!** We welcome contributions to our [MCP Registry](mcp-registry/README.md). Add your own servers, improve documentation, or suggest features. Open source thrives with community participation!
  20. ## 🚀 Quick Installation
  21. ### Recommended:
  22. ```bash
  23. curl -sSL https://mcpm.sh/install | bash
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 34 on GitHub
  24. ```
  25. Or choose [other installation methods](#-other-installation-methods) like `brew`, `pipx`, `uv` etc.
  26. ## 🔎 Overview
  27. MCPM v2.0 provides a simplified approach to managing MCP servers with a global configuration model. Key features include:
  28. - ✨ **Global Server Management**: Install servers once, use everywhere
  29. - 📋 **Virtual Profiles**: Organize servers with tags for different workflows
  30. - 🔍 **Server Discovery**: Browse and install from the MCP Registry
  31. - 🚀 **Direct Execution**: Run servers over stdio or HTTP for testing
  32. - 🌐 **Public Sharing**: Share servers through secure tunnels
  33. - 🔄 **Server Updates**: Check for and apply updates to git-based, NPX, and binary servers
  34. - 🎛️ **Client Integration**: Manage configurations for Claude Desktop, Cursor, Windsurf, and more
  35. - 🤖 **AI Agent Friendly**: Non-interactive CLI with comprehensive automation support and [llm.txt](llm.txt) guide
  36. - 💻 **Beautiful CLI**: Rich formatting and interactive interfaces
  37. - 📊 **Usage Analytics**: Monitor server usage and performance
  38. MCPM v2.0 eliminates the complexity of v1's target-based system in favor of a clean global workspace model.
  39. ## 🖥️ Supported MCP Clients
  40. MCPM will support managing MCP servers for the following clients:
  41. - 🤖 Claude Desktop (Anthropic)
  42. - ⌨️ Cursor
  43. - 🏄 Windsurf
  44. - 🧩 Vscode
  45. - 📝 Cline
  46. - ➡️ Continue
  47. - 🦢 Goose
  48. - 🔥 5ire
  49. - 🦘 Roo Code
  50. - 💻 OpenCode
  51. - ✨ More clients coming soon...
  52. ## 🔥 Command Line Interface (CLI)
  53. MCPM provides a comprehensive CLI with a clean, organized interface. The v2.0 architecture uses a global configuration model where servers are installed once and can be organized with profiles, then integrated into specific MCP clients as needed.
  54. ### ℹ️ General
  55. ```bash
  56. mcpm --help # Display help information and available commands
  57. mcpm --version # Display the current version of MCPM
  58. ```
  59. ### 🌐 Server Management
  60. Global server installation and management commands:
  61. ```bash
  62. # 🔍 Search and Install
  63. mcpm search [QUERY] # Search the MCP Registry for available servers
  64. mcpm info SERVER_NAME # Display detailed information about a server
  65. mcpm install SERVER_NAME # Install a server from registry to global configuration
  66. mcpm uninstall SERVER_NAME # Remove a server from global configuration
  67. # 📋 List and Inspect
  68. mcpm ls # List all installed servers and their profile assignments
  69. mcpm edit SERVER_NAME # Edit a server configuration
  70. mcpm inspect SERVER_NAME # Launch MCP Inspector to test/debug a server
  71. ```
  72. ### 🚀 Server Execution
  73. Execute servers directly for testing or integration:
  74. ```bash
  75. mcpm run SERVER_NAME # Execute a server directly over stdio
  76. mcpm run SERVER_NAME --http # Execute a server over HTTP for testing
  77. mcpm share SERVER_NAME # Share a server through secure tunnel for remote access
  78. mcpm usage # Display comprehensive analytics and usage data
  79. ```
  80. ### 📂 Profile Management
  81. Profiles are virtual tags that organize servers into logical groups for different workflows:
  82. ```bash
  83. # 🔄 Profile Operations
  84. mcpm profile ls # List all profiles and their tagged servers
  85. mcpm profile create PROFILE # Create a new profile
  86. mcpm profile rm PROFILE # Remove a profile (servers remain installed)
  87. mcpm profile edit PROFILE # Interactive server selection for profile
  88. # 🚀 Profile Execution
  89. mcpm profile run PROFILE # Execute all servers in a profile over stdio or HTTP
  90. mcpm profile share PROFILE # Share all servers in a profile through secure tunnel
  91. mcpm profile inspect PROFILE # Launch MCP Inspector for all servers in profile
  92. ```
  93. ### 🖥️ Client Integration
  94. Manage MCP client configurations (Claude Desktop, Cursor, Windsurf, etc.):
  95. ```bash
  96. mcpm client ls # List all supported MCP clients and their status
  97. mcpm client edit CLIENT_NAME # Interactive server enable/disable for a client
  98. mcpm client edit CLIENT_NAME -e # Open client config in external editor
  99. mcpm client import CLIENT_NAME # Import server configurations from a client
  100. ```
  101. ### 🔄 Server Updates
  102. Check for and apply updates to installed MCP servers:
  103. ```bash
  104. mcpm update # Update all servers
  105. mcpm update SERVER_NAME # Update a specific server
  106. mcpm update --check # Dry run — check for updates without applying
  107. mcpm update --rebase # Use git rebase instead of fast-forward
  108. mcpm update --init # Scan servers and populate source metadata
  109. mcpm update --init --force # Re-detect all source metadata
  110. ```
  111. MCPM tracks where each server came from (git repo, npm package, HTTP remote) and can pull the latest changes automatically. Git-based servers are updated via `git pull --ff-only` by default, with `--rebase` as an opt-in alternative. NPX/UVX servers auto-update at runtime and are shown for informational purposes.
  112. ### 🛠️ System & Configuration
  113. ```bash
  114. mcpm doctor # Check system health and server status
  115. mcpm config # Manage MCPM configuration and settings
  116. mcpm migrate # Migrate from v1 to v2 configuration
  117. ```
  118. ### 📚 Registry
  119. The MCP Registry is a central repository of available MCP servers that can be installed using MCPM. The registry is available at [mcpm.sh/registry](https://mcpm.sh/registry).
  120. ## 🤖 AI Agent Integration
  121. MCPM is designed to be AI agent friendly with comprehensive automation support. Every interactive command has a non-interactive alternative using CLI parameters and environment variables.
  122. ### 🔧 Non-Interactive Mode
  123. Set environment variables to enable full automation:
  124. ```bash
  125. export MCPM_NON_INTERACTIVE=true # Disable all interactive prompts
  126. export MCPM_FORCE=true # Skip confirmations
  127. export MCPM_JSON_OUTPUT=true # JSON output for parsing
  128. ```
  129. ### 📋 LLM.txt Guide
  130. The [llm.txt](llm.txt) file provides comprehensive documentation specifically designed for AI agents, including:
  131. - Complete command reference with parameters and examples
  132. - Environment variable usage patterns
  133. - Best practices for automation
  134. - Error handling and troubleshooting
  135. - Batch operation patterns
  136. The llm.txt file is automatically generated from the CLI structure and kept up-to-date with each release.
  137. ### ⚡ Example Usage
  138. #### Use case 1: expose a local stdio server over HTTP
  139. 1) Add the server to MCPM
  140. ```bash
  141. mcpm new [MY_SERVER_NAME] --type stdio --command "[COMMAND]" --args "[ARG_1] [ARG_2] ..."
  142. ```
  143. (Add `--force` arg to bypass the confirmation interaction)
  144. Verify it appears in your installed servers:
  145. ```bash
  146. mcpm ls
  147. ```
  148. You should see `[MY_SERVER_NAME]` in the list.
  149. 2) Serve it over HTTP
  150. ```bash
  151. mcpm run [MY_SERVER_NAME] --http
  152. ```
  153. MCPM prints the server URL, for example:
  154. ```
  155. URL: http://127.0.0.1:6276/mcp/
  156. ```
  157. 3) Expose it on your network (optional)
  158. ```bash
  159. mcpm run [MY_SERVER_NAME] --http --host 0.0.0.0
  160. ```
  161. Tip: add `--port <PORT>` to choose a different port.
  162. #### Use case 2: combine multiple servers and serve them as one profile
  163. 1) Add the servers to MCPM
  164. ```bash
  165. # Stdio server
  166. mcpm new [SERVER_A] --type stdio --command "[COMMAND]" --args "[ARG_1] [ARG_2] ..." --force
  167. # Remote HTTP/SSE server
  168. mcpm new [SERVER_B] --type remote --url "http://SERVER_ADDR/mcp/" --force
  169. ```
  170. 2) Create a profile and add the servers
  171. Interactive:
  172. ```bash
  173. mcpm profile create [PROFILE_NAME]
  174. mcpm profile edit [PROFILE_NAME]
  175. ```
  176. MCPM would list out all installed servers, you can use arrows to navigate, space to select/deselect, type to search, and Enter to confirm.
  177. Verify:
  178. ```bash
  179. mcpm profile ls
  180. ```
  181. You should see your profile with the selected servers.
  182. 3) Run the profile
  183. ```bash
  184. # Stdio
  185. mcpm profile run [PROFILE_NAME]
  186. # HTTP
  187. mcpm profile run [PROFILE_NAME] --http
  188. # Optional: host and port
  189. mcpm profile run [PROFILE_NAME] --http --host 0.0.0.0 --port 8080
  190. ```
  191. #### Other common usage
  192. ```bash
  193. # Server management
  194. mcpm new myserver --type stdio --command "python -m server" --force
  195. mcpm edit myserver --env "API_KEY=secret" --force
  196. # Profile management
  197. mcpm profile edit web-dev --add-server myserver --force
  198. mcpm profile run web-dev --port 8080
  199. # Client integration
  200. mcpm client edit cursor --add-profile web-dev --force
  201. ```
  202. ## 🗺️ Roadmap
  203. ### ✅ v2.0 Complete
  204. - [x] Global server configuration model
  205. - [x] Profile-based server tagging and organization
  206. - [x] Interactive command interfaces
  207. - [x] Client integration management (`mcpm client edit`)
  208. - [x] Modern CLI with consistent UX
  209. - [x] Registry integration and server discovery
  210. - [x] Direct server execution and sharing
  211. - [x] Import from existing client configurations
  212. - [x] Additional client support (gemini-cli, codex, etc.)
  213. ### 🔮 Future Enhancements
  214. - [x] Server update management (`mcpm update`)
  215. - [ ] GitHub release binary updates (download + replace)
  216. - [ ] Advanced Server access monitoring and analytics
  217. - [ ] Execution in docker
  218. - [ ] Expose MCPM functionality as an MCP server (search, install, profile management etc.)
  219. - [ ] TUI interface for MCP inspect
  220. - [ ] TUI interface for MCP & profile management
  221. ## 📦 Other Installation Methods
  222. ### 🍺 Homebrew
  223. ```bash
  224. brew install mcpm
  225. ```
  226. ### 📦 pipx (Recommended for Python tools)
  227. ```bash
  228. pipx install mcpm
  229. ```
  230. ### 🪄 uv tool
  231. ```bash
  232. uv tool install mcpm
  233. ```
  234. ## More Installation Methods
  235. ### 🐍 pip
  236. ```bash
  237. pip install mcpm
  238. ```
  239. ### 🧰 X-CMD
  240. If you are a user of [x-cmd](https://x-cmd.com), you can run:
  241. ```sh
  242. x install mcpm.sh
  243. ```
  244. ## 👨‍💻 Development
  245. This repository contains the CLI and service components for MCP Manager, built with Python and Click following modern package development practices.
  246. ### 📋 Development Requirements
  247. - 🐍 Python 3.10+
  248. - 🚀 uv (for virtual environment and dependency management)
  249. - 🖱️ Click framework for CLI
  250. - ✨ Rich for enhanced console output
  251. - 🌐 Requests for API interactions
  252. ### 📁 Project Structure
  253. The project follows the modern src-based layout:
  254. ```
  255. mcpm.sh/
  256. ├── src/ # Source package directory
  257. │ └── mcpm/ # Main package code
  258. ├── tests/ # Test directory
  259. ├── test_cli.py # Development CLI runner
  260. ├── pyproject.toml # Project configuration
  261. ├── pages/ # Website content
  262. │ └── registry/ # Registry website
  263. ├── mcp-registry/ # MCP Registry data
  264. └── README.md # Documentation
  265. ```
  266. ### 🚀 Development Setup
  267. 1. Clone the repository
  268. ```
  269. git clone https://github.com/pathintegral-institute/mcpm.sh.git
  270. cd mcpm.sh
  271. ```
  272. 2. Set up a virtual environment with uv
  273. ```
  274. uv venv --seed
  275. source .venv/bin/activate # On Unix/Mac
  276. ```
  277. 3. Install dependencies in development mode
  278. ```
  279. uv pip install -e .
  280. ```
  281. 4. Run the CLI directly during development
  282. ```
  283. # Either use the installed package
  284. mcpm --help
  285. # Or use the development script
  286. ./test_cli.py --help
  287. ```
  288. 5. Run tests
  289. ```
  290. pytest tests/
  291. ```
  292. ### ✅ Best Practices
  293. - 📁 Use the src-based directory structure to prevent import confusion
  294. - 🔧 Develop with an editable install using `uv pip install -e .`
  295. - 🧩 Keep commands modular in the `src/mcpm/commands/` directory
  296. - 🧪 Add tests for new functionality in the `tests/` directory
  297. - 💻 Use the `test_cli.py` script for quick development testing
  298. ### 🔢 Version Management
  299. MCP uses a single source of truth pattern for version management to ensure consistency across all components.
  300. #### 🏷️ Version Structure
  301. - 📍 The canonical version is defined in `version.py` at the project root
  302. - 📥 `src/mcpm/__init__.py` imports this version
  303. - 📄 `pyproject.toml` uses dynamic versioning to read from `version.py`
  304. - 🏷️ Git tags are created with the same version number prefixed with 'v' (e.g., v1.0.0)
  305. #### 🔄 Updating the Version
  306. When releasing a new version:
  307. 1. Use the provided version bump script
  308. ```
  309. ./bump_version.sh NEW_VERSION
  310. # Example: ./bump_version.sh 1.1.0
  311. ```
  312. 2. Push the changes and tags
  313. ```
  314. git push && git push --tags
  315. ```
  316. 3. Create a GitHub release matching the new version
  317. This process ensures that the version is consistent in all places: code, package metadata, and git tags.
  318. PyPI release is handled by the CI/CD pipeline and will be triggered automatically.
  319. ## 📜 License
  320. MIT
  321. ## Star History
  322. [![Star History Chart](https://api.star-history.com/svg?repos=pathintegral-institute/mcpm.sh&type=Date)](https://www.star-history.com/#pathintegral-institute/mcpm.sh&Date)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.