发现优秀的 MCP 服务器

metoro-mcp-server

使用LLM查询和交互由Metoro监控的Kubernetes环境。查看APM、指标、追踪和性能分析信息。

官方

MCP2Lambda

通过 MCP 协议，人工智能模型能够与 AWS Lambda 函数交互，从而在安全的环境中访问私有资源、实时数据和自定义计算。

官方

mcp-k8s-go

这个项目旨在成为一个连接到 Kubernetes 的 MCP 服务器，同时也是一个用于为 Kubernetes 中任何自定义资源构建更多服务器的库。

Sandbox MCP Server

为代码执行提供隔离的 Docker 环境，使用户能够创建和管理容器、执行多语言代码、保存和重现开发环境，从而确保安全性和隔离性。

Room MCP

一个命令行工具，可以使用 Room 协议启用 MCP，允许代理创建点对点虚拟房间并进行交互，以实现目标导向的协作。

MCP 3D Printer Server

通过 MCP 服务器实现与 3D 打印机管理系统的交互，支持 STL 文件操作、切片以及对 OctoPrint、Klipper、Duet 等打印机的控制。

TypeScript

MCP Server Template

一个用于在 TypeScript 中创建模型上下文协议 (MCP) 服务器的模板，提供诸如基于容器的依赖注入、基于服务的架构以及与 LLM CLI 的集成等功能，以便通过自然语言获得架构设计反馈。

TypeScript

Ollama MCP Server

一个桥梁，能够将 Ollama 的本地 LLM 功能无缝集成到 MCP 驱动的应用程序中，允许用户在本地管理和运行 AI 模型，并提供完整的 API 覆盖。

MCP Code Executor

允许大型语言模型 (LLM) 在指定的 Conda 环境中执行 Python 代码，从而能够访问必要的库和依赖项，以实现高效的代码执行。

docker-mcp

一个强大的模型上下文协议（MCP）服务器，用于 Docker 操作，通过 Claude AI 实现无缝的容器和 Compose 堆栈管理。

MCP Server Modal

一个 MCP 服务器，允许用户直接从 Claude 将 Python 脚本部署到 Modal，并提供已部署应用程序的链接，以便与他人分享。

k8s-interactive-mcp

一个 MCP 服务器，可以使用给定的 kubeconfig 路径运行 Kubernetes 命令，并提供命令的解释。 (Or, a slightly more formal translation:) 一个 MCP 服务器，它能够使用指定的 kubeconfig 路径执行 Kubernetes 命令，并提供对这些命令的解释。

MCP Server Starter

一个生产就绪的模板，用于使用 TypeScript 创建模型上下文协议服务器，提供高效的测试、开发和部署工具。

kubernetes-mcp-server

一个强大且灵活的 Kubernetes MCP 服务器实现，支持 OpenShift。

MCP-IDB

模型上下文协议 (MCP) 与 Facebook 的 iOS 开发桥 (idb) 集成，通过自然语言实现自动化的 iOS 设备管理和测试执行。

Minecraft Docker MCP

允许AI通过RCON与Docker容器内运行的Minecraft服务器进行交互，从而使模型能够以编程方式创建Minecraft建筑并管理服务器。

Daytona MCP Python Interpreter

一个模型上下文协议服务器，允许在 Daytona 工作区内执行 Python 代码，从而为执行和管理 Python 脚本提供安全且隔离的环境。

MCP Server Template for Cursor IDE

Okay, here's a template and explanation for creating custom tools for Cursor IDE using the Model Context Protocol (MCP), allowing users to deploy their own MCP server to Heroku and connect it to Cursor IDE. This template focuses on providing a solid foundation and clear instructions. **I. Project Structure** ``` my-cursor-tool/ ├── server/ # MCP Server (Python/Flask) │ ├── app.py # Main Flask application │ ├── requirements.txt # Dependencies │ ├── Procfile # Heroku deployment instructions │ └── .env # Environment variables (API keys, etc.) ├── cursor-extension/ # Cursor IDE Extension (TypeScript) │ ├── package.json # Extension manifest │ ├── src/ │ │ └── extension.ts # Main extension logic │ └── tsconfig.json # TypeScript configuration ├── README.md # Instructions for setup and deployment └── LICENSE # (Optional) License ``` **II. `server/app.py` (MCP Server - Python/Flask)** ```python from flask import Flask, request, jsonify import os import json app = Flask(__name__) # Load environment variables (if any) # Example: OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY") @app.route('/.well-known/model-context', methods=['GET']) def model_context_discovery(): """ Returns the Model Context Protocol discovery document. """ discovery_document = { "model_context_protocol_version": "0.1", "capabilities": { "execute": { "path": "/execute", "http_method": "POST", "input_schema": { "type": "object", "properties": { "query": {"type": "string", "description": "The user's query."}, "context": { "type": "object", "description": "Contextual information from the IDE.", "properties": { "selectedText": {"type": "string", "description": "The currently selected text in the editor."}, "languageId": {"type": "string", "description": "The language of the current file."}, "filepath": {"type": "string", "description": "The path to the current file."}, "activeEditorContent": {"type": "string", "description": "The entire content of the active editor."}, }, "required": ["selectedText", "languageId", "filepath", "activeEditorContent"] } }, "required": ["query", "context"] }, "output_schema": { "type": "object", "properties": { "result": {"type": "string", "description": "The result of the execution."} }, "required": ["result"] } } } } return jsonify(discovery_document) @app.route('/execute', methods=['POST']) def execute(): """ Executes the tool based on the user's query and context. """ try: data = request.get_json() query = data['query'] context = data['context'] # --- Your Tool Logic Here --- # Example: Use the query and context to generate a response. # This is where you integrate with your desired service (e.g., OpenAI, a database, etc.) selected_text = context['selectedText'] language_id = context['languageId'] filepath = context['filepath'] active_editor_content = context['activeEditorContent'] # Simple example: Echo the query and selected text. result = f"Query: {query}\nSelected Text: {selected_text}\nLanguage: {language_id}\nFilepath: {filepath}" # --- End of Tool Logic --- return jsonify({"result": result}) except Exception as e: print(f"Error: {e}") # Log the error for debugging return jsonify({"error": str(e)}), 500 # Return an error response if __name__ == '__main__': port = int(os.environ.get('PORT', 5000)) # Heroku uses the PORT environment variable app.run(debug=True, host='0.0.0.0', port=port) ``` **III. `server/requirements.txt`** ``` Flask python-dotenv # For local development (optional) ``` **IV. `server/Procfile`** ``` web: gunicorn app:app --log-file - --log-level debug ``` **V. `server/.env` (Optional - for local development)** ``` # Example: # OPENAI_API_KEY=your_openai_api_key ``` **VI. `cursor-extension/package.json`** ```json { "name": "my-cursor-tool", "displayName": "My Cursor Tool", "description": "A custom tool for Cursor IDE.", "version": "0.0.1", "engines": { "vscode": "^1.75.0" // Or the minimum supported version of VS Code/Cursor }, "categories": [ "Other" ], "activationEvents": [ "*" // Activate on all events (adjust as needed) ], "main": "./dist/extension.js", "contributes": { "modelContextProviders": [ { "name": "my-tool", "displayName": "My Tool", "description": "Connects to my custom tool server.", "url": "YOUR_HEROKU_APP_URL" // <--- REPLACE THIS WITH YOUR HEROKU APP URL } ] }, "scripts": { "vscode:prepublish": "npm run compile", "compile": "tsc -p ./", "watch": "tsc -watch -p ./", "pretest": "npm run compile && npm run lint", "lint": "eslint src --ext ts", "test": "node ./out/test/runTest.js" }, "devDependencies": { "@types/vscode": "^1.75.0", // Or the appropriate version "@types/glob": "^8.0.1", "@types/mocha": "^10.0.1", "@types/node": "16.x", "@vscode/test-electron": "^2.2.0", "eslint": "^8.30.0", "@typescript-eslint/eslint-plugin": "^5.45.0", "@typescript-eslint/parser": "^5.45.0", "glob": "^8.1.0", "mocha": "^10.1.1", "typescript": "^4.9.4" } } ``` **VII. `cursor-extension/src/extension.ts`** ```typescript import * as vscode from 'vscode'; export function activate(context: vscode.ExtensionContext) { console.log('Congratulations, your extension "my-cursor-tool" is now active!'); // No specific activation logic needed here, as the Model Context Provider // is declared in package.json and handled by Cursor. } export function deactivate() {} ``` **VIII. `cursor-extension/tsconfig.json`** ```json { "compilerOptions": { "module": "commonjs", "target": "es2020", "lib": [ "es2020" ], "sourceMap": true, "rootDir": "src", "outDir": "dist", "strict": true, "esModuleInterop": true, "skipLibCheck": true, "forceConsistentCasingInFileNames": true, "moduleResolution": "node" }, "exclude": [ "node_modules", ".vscode-test" ] } ``` **IX. `README.md` (Crucial Instructions)** ```markdown # My Cursor Tool This is a custom tool for Cursor IDE that connects to a server deployed on Heroku using the Model Context Protocol (MCP). ## Prerequisites * **Heroku Account:** You'll need a Heroku account to deploy the server. * **Heroku CLI:** Install the Heroku Command Line Interface (CLI). See [https://devcenter.heroku.com/articles/heroku-cli](https://devcenter.heroku.com/articles/heroku-cli) * **Cursor IDE:** Install Cursor IDE. * **Node.js and npm:** Required for building the Cursor extension. * **Python 3.x:** Required for running the server locally (optional). ## Deployment to Heroku 1. **Login to Heroku:** ```bash heroku login ``` 2. **Create a Heroku App:** ```bash heroku create my-cursor-tool-server # Replace with a unique name ``` 3. **Navigate to the `server` directory:** ```bash cd server ``` 4. **Initialize a Git repository (if you haven't already):** ```bash git init git add . git commit -m "Initial commit" ``` 5. **Push the code to Heroku:** ```bash heroku git:remote -a my-cursor-tool-server # Replace with your app name git push heroku main ``` 6. **Set Environment Variables (if needed):** If your tool requires API keys or other sensitive information, set them as environment variables in Heroku: ```bash heroku config:set OPENAI_API_KEY=your_openai_api_key ``` 7. **Check the Heroku Logs:** After deployment, check the Heroku logs for any errors: ```bash heroku logs --tail ``` ## Installing the Cursor Extension 1. **Navigate to the `cursor-extension` directory:** ```bash cd ../cursor-extension ``` 2. **Install Dependencies:** ```bash npm install ``` 3. **Compile the Extension:** ```bash npm run compile ``` 4. **Open Cursor IDE.** 5. **Open the `cursor-extension` directory in Cursor IDE.** (File -> Open Folder...) 6. **Run the Extension:** * Press `F5` to start the extension in debug mode. This will open a new Cursor window with your extension loaded. ## Connecting the Extension to Your Heroku Server 1. **Get Your Heroku App URL:** Find the URL of your deployed Heroku app. It's usually in the format `https://my-cursor-tool-server.herokuapp.com`. You can find it on the Heroku dashboard for your app. 2. **Update `package.json`:** In the `cursor-extension/package.json` file, replace `YOUR_HEROKU_APP_URL` with the actual URL of your Heroku app in the `contributes.modelContextProviders.url` field. **Make sure to include the `https://` prefix.** ```json "contributes": { "modelContextProviders": [ { "name": "my-tool", "displayName": "My Tool", "description": "Connects to my custom tool server.", "url": "https://my-cursor-tool-server.herokuapp.com" // <--- REPLACE THIS } ] } ``` 3. **Reload the Extension:** After updating `package.json`, you'll need to reload the extension in Cursor IDE. If you're running in debug mode (F5), stop the debugger and run it again. If you installed the extension, you may need to uninstall and reinstall it. ## Using the Tool in Cursor IDE 1. **Open a file in Cursor IDE.** 2. **Select some text.** 3. **Type `@my-tool` followed by your query.** (Replace `my-tool` with the `name` you defined in `package.json`.) 4. **Press Enter.** 5. **The result from your Heroku server should appear in the chat window.** ## Troubleshooting * **Check Heroku Logs:** Use `heroku logs --tail` to see any errors on the server side. * **Check the Cursor IDE Developer Console:** Open the developer console in the Cursor IDE window (Help -> Toggle Developer Tools) to see any errors from the extension. * **Verify the URL:** Double-check that the URL in `package.json` is correct and includes `https://`. * **CORS Issues:** If you encounter CORS (Cross-Origin Resource Sharing) errors, you may need to configure CORS on your Flask server. (This is less likely with Heroku, but possible). You can use the `flask-cors` library. ## License [Your License Here (Optional)] ``` **X. Key Improvements and Explanations** * **Clear Project Structure:** Organized into `server` and `cursor-extension` directories for clarity. * **Complete `app.py`:** Includes the `/model-context` discovery endpoint and a basic `/execute` endpoint. The `/execute` endpoint now receives and prints the context data. Error handling is included. * **`Procfile` for Heroku:** Specifies how to run the Flask app on Heroku. * **Detailed `README.md`:** Provides step-by-step instructions for deployment, installation, and usage. Includes troubleshooting tips. This is the *most important* part for user-friendliness. * **Environment Variables:** Demonstrates how to use environment variables for API keys (important for security). * **Error Handling:** The server includes basic error handling to catch exceptions and return appropriate error responses to Cursor. * **CORS Note:** Adds a note about CORS issues and how to address them if they arise. * **`extension.ts`:** Kept minimal, as the core logic is handled by the MCP. * **Up-to-date Dependencies:** Uses more recent versions of dependencies. * **Heroku CLI Instructions:** Provides specific Heroku CLI commands. * **Debugging Tips:** Includes instructions for checking Heroku logs and the Cursor IDE developer console. * **Explicit URL Instructions:** Emphasizes the importance of the correct Heroku app URL in `package.json`. * **Example Tool Logic:** Provides a simple example of how to access the query and context data within the `/execute` endpoint. * **Gunicorn:** Uses Gunicorn, a production-ready WSGI server, in the `Procfile`. **XI. How to Use This Template** 1. **Clone the Template:** Copy the file structure and code into your own project. 2. **Implement Your Tool Logic:** Modify the `server/app.py` file to implement the core logic of your tool within the `/execute` endpoint. This is where you'll integrate with your desired services (e.g., OpenAI, a database, etc.). 3. **Deploy to Heroku:** Follow the instructions in the `README.md` file to deploy the server to Heroku. 4. **Install the Cursor Extension:** Follow the instructions in the `README.md` file to install the Cursor extension. 5. **Connect the Extension:** Update the `package.json` file with your Heroku app URL. 6. **Test Your Tool:** Use the tool in Cursor IDE by typing `@my-tool` followed by your query. **XII. Important Considerations** * **Security:** Be very careful about handling sensitive data (API keys, user credentials, etc.). Use environment variables and avoid hardcoding secrets in your code. * **Scalability:** For more complex tools, consider using a more scalable architecture for your server (e.g., using a database, message queue, etc.). * **Error Handling:** Implement robust error handling in your server to gracefully handle unexpected errors. * **Rate Limiting:** If you're using an external API, be mindful of rate limits and implement appropriate rate limiting in your server. * **User Experience:** Design your tool to be easy to use and provide helpful feedback to the user. * **Asynchronous Operations:** For long-running tasks, consider using asynchronous operations (e.g., using Celery or similar) to avoid blocking the Flask server. This template provides a solid starting point for creating custom tools for Cursor IDE using the Model Context Protocol. Remember to adapt the code and instructions to your specific needs. Good luck!

Docker MCP Server

一个 MCP 服务器，允许通过自然语言管理 Docker 容器，使用户无需亲自运行命令即可组合、检查和调试容器。 (Alternative, slightly more formal and detailed translation): 一个 MCP 服务器，它允许通过自然语言的方式来管理 Docker 容器。这使得用户能够使用自然语言来组合、内省（检查内部状态）和调试容器，而无需手动执行命令。

railway-mcp

让 Claude 和 Cursor 通过自然语言管理你的 Railway 基础设施。自主且安全地部署、配置和监控。

TypeScript

Deepseek MCP Server

一个模型控制协议（Model Control Protocol）服务器的实现，它允许 Claude Desktop 使用运行在 Docker 中的 Deepseek 模型，从而实现 Claude Desktop 和 Deepseek 语言模型之间的无缝集成。

DigitalFate MCP Server

DigitalFate provides an advanced, enterprise-ready framework for orchestrating LLM calls, agents, and computer-based tasks, - Kalyankensin/DigitalFate