发现优秀的 MCP 服务器

Portkey MCP Server

将 Claude 连接到 Portkey 的 API，以管理 AI 配置、工作区、分析和用户访问，从而全面控制 API 使用和设置。

MCP GitHub Repository Server

一个服务器，允许 AI 助手浏览和读取指定 GitHub 仓库中的文件，并通过模型上下文协议提供对仓库内容的访问。

MCP JIRA Server

通过标准化的 MCP 接口，使 AI 应用程序能够管理 JIRA 问题、工作流程和任务，从而促进实时更新并与 JIRA 的 API 实现无缝交互。

n8n MCP Server

一个 MCP 服务器，通过模型上下文协议实现与 n8n 工作流、执行和设置的安全交互，专为与大型语言模型 (LLM) 集成而设计。

Business Central MCP Server

一个服务器，为 Business Central 项目提供标准化的开发规则和上下文，并针对 Cursor 编辑器进行了优化。

Authenticated MCP SSE Server

一个安全的 MCP（模型上下文协议）服务器，托管在 Google Cloud Run 上，通过 Google Cloud IAM 提供身份验证访问，从而实现团队协作。这使得团队能够在官方 MCP 身份验证实施之前，通过互联网共享自定义 MCP 服务器。 **更流畅的翻译版本：** 一个安全的 MCP（模型上下文协议）服务器，部署在 Google Cloud Run 上，它通过 Google Cloud IAM 进行身份验证，从而实现团队协作。 这样，团队就可以在官方 MCP 身份验证功能上线之前，通过互联网共享自定义的 MCP 服务器。

confluence-mcp

Jira, Wiki, MCP 可以翻译为： Jira，Wiki，MCP (通常这些都是专有名词，直接使用英文即可。如果需要更具体的翻译，需要知道MCP的全称以及上下文。) 如果MCP指的是“主控制程序 (Master Control Program)”，那么可以翻译为： Jira，Wiki，主控制程序

Jira MCP Server

使人工智能模型能够使用标准化协议与 Jira 交互，提供完整的 Jira REST API 集成，并具有诸如通过连接池实现最佳性能、错误处理和请求监控等功能。

MCP Architect

通过专门的代理、丰富的资源和强大的工具，促进全面的架构设计和评估，涵盖云计算、人工智能和区块链等不同的架构领域。

Modal MCP Toolbox

促进在沙箱中运行 Python 代码，并通过与 Goose 和 Claude Desktop App 等客户端兼容的 MCP 服务器，使用 FLUX 模型生成图像。

Targetprocess MCP Server

提供与 Targetprocess 交互的工具，Targetprocess 是一个项目管理和敏捷规划平台，使 AI 助手能够搜索、创建和更新项目实体，并进行适当的验证。

Sanity MCP Server

一个 MCP 服务器，使 Claude Desktop 能够与 Sanity.io 内容交互，并提供创建、编辑、列出文档和获取模式模板的工具。

JSON Canvas MCP Server

一个模型上下文协议服务器，它能够根据 JSON Canvas 1.0 规范创建、修改和验证无限画布数据结构。

Box MCP Server

Box MCP 服务器方便使用开发者令牌认证在 Box 中搜索和读取 PDF 和 Word 文件。

Workers MCP Demo

一个演示项目，使用 Cloudflare Workers MCP 创建自定义 AI 工具，这些工具可以与 Claude、Cursor 以及其他支持模型上下文协议 (Model Context Protocol) 的 AI 助手集成。

mcp-github-project-manager

提供全面的工具来管理 GitHub 项目、里程碑、任务和冲刺。此服务器与 GitHub Projects V2 深度集成，提供诸如自动化看板工作流、冲刺计划和自定义字段管理等功能。

drupal-modules-mcp MCP Server

这个基于 TypeScript 的 MCP 服务器实现了一个简单的笔记系统，允许使用 MCP 概念以及 note:// URI 和元数据来创建、列出和总结文本笔记。

PulseMCP Server

PulseMCP Server 是一个基于 TypeScript 的 MCP 服务器，它实现了一个简单的笔记系统，允许用户通过模型上下文协议，使用基于 URI 的资源管理和 LLM 摘要提示来创建、访问和总结文本笔记。

Github MCP Server

通过模型上下文协议 (MCP) 提供与 Github 的集成，允许大型语言模型与 Github 的存储库、问题、拉取请求和搜索功能进行交互。

GitLab MCP Server

一个自定义服务器实现，允许 AI 助手与 GitLab 仓库进行交互，提供搜索、获取文件、创建/更新内容以及管理议题和合并请求等功能。

MCP Security Audit Server

审计 npm 包依赖项以查找安全漏洞，提供详细报告和修复建议，并与 MCP 集成。

MCP Server for Replicate

一个 FastMCP 服务器实现，它为访问 Replicate API 上托管的 AI 模型提供了一个标准化的接口，目前支持图像生成，并提供可自定义的参数。

Redmine MCP Server

一个模型上下文协议服务器，用于通过与 LLM 集成，使用 Redmine 的 REST API 来交互，从而实现对工单、项目和用户数据的管理。

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!

MCP Node Fetch

一个 MCP 服务器，它可以使用 Node.js undici 库来获取 Web 内容，支持各种 HTTP 方法、内容格式和请求配置。

MCP-Server-IETF

一个模型上下文协议服务器，它使大型语言模型能够搜索和访问带有分页支持的 IETF RFC 文档。

Strapi MCP Server

一个模型上下文协议服务器，它使 AI 助手能够通过标准化的接口与 Strapi CMS 实例进行交互，支持内容类型和 REST API 操作。

Docker MCP Server

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

MongoDB MCP Server

一个协议服务器，使像 Claude 这样的大型语言模型能够与 MongoDB 数据库交互，在 Cursor 中通过自然语言提供模式探索、聚合查询和数据分析工具。

railway-mcp

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