Discover Awesome MCP Servers

javaDemo

javaDemo。通过在 GitHub 上创建一个帐户来参与 zf0497/mydemo 的开发。

MCP Server for X/Twitter

使用真正的浏览器 API 自动化你的 X 账户 - JoshMayerr/mcp-x

Minima

可配置容器的本地对话式 RAG - dmayboroda/minima

NutJS Windows Control

用于操作系统自动化的跨平台 MCP 服务器。通过在 GitHub 上创建一个帐户来参与 Cheffromspace/MCPControl 的开发。

Unofficial dubco-mcp-server

一个模型上下文协议服务器，它使 AI 助手能够通过 Dub.co API 创建、更新和删除 Dub.co 短链接。

Systemprompt MCP Gmail Server

使用户能够通过 MCP 协议，使用 AI 代理辅助操作来管理 Gmail 帐户，支持电子邮件搜索、阅读、删除和发送，并具有语音驱动的界面。

Strava MCP Server

一个模型上下文协议服务器，为语言模型提供访问 Strava API 数据的能力，使其能够查询和分析来自 Strava 的运动员活动数据。

TfNSW Realtime Alerts MCP Server

这个服务器使大型语言模型能够访问并与新南威尔士州交通局 (Transport for NSW) 网络中的实时交通警报进行交互，支持按交通方式进行筛选，并返回有关中断和计划工程的格式化警报信息。

salesforce-mcp-server

一个模型上下文协议服务器实现，用于通过其 REST API 与 Salesforce 进行交互。

Dataset Viewer MCP Server

允许与 Hugging Face Dataset Viewer API 交互，使用户能够浏览、搜索、过滤和分析托管在 Hugging Face Hub 上的数据集。

Release Notes MCP Server

生成来自 GitHub 仓库的全面且格式化的发布说明，通过智能 API 使用高效地按类型组织提交，并包含详细的统计信息。

WeCom Bot MCP Server

一个通过 FastMCP 使用企业微信机器人发送消息的服务器，支持异步通信和通过 Webhook 进行消息追踪。

Snyk MCP Server

一个独立的服务器，通过模型上下文协议启用 Snyk 安全扫描，支持存储库和项目分析、令牌验证以及 CLI 集成。

MCP Zotero

允许人工智能与您的 Zotero 文献库互动。

Manifold Markets MCP Server

通过简洁的 MCP 界面，提供对 Manifold Markets 预测平台的全面访问，使用户能够通过自然语言创建市场、下注、管理流动性以及使用社交功能。

DevDocs MCP

一个模型上下文协议的实现，它支持通过 AI 驱动的方式访问文档资源，具有基于 URI 的导航、模板匹配和结构化文档管理等功能。

MCP Development Framework

一个强大的模型上下文协议框架，它通过网页内容检索、PDF 处理和 Word 文档解析等工具来扩展 Cursor IDE 的功能。

Alchemy MCP Plugin

这个插件可以通过 Alchemy SDK 与区块链数据和 NFT 进行交互，从而实现诸如检索 NFT 元数据、获取钱包地址的 NFT 以及获取最新区块号等操作。

Google OR-Tools server

MCP-ORTools 通过 MCP 将 Google 的 OR-Tools 约束编程求解器与大型语言模型集成，使 AI 模型能够： * 提交和验证约束模型 * 设置模型参数 * 求解约束满足和优化问题 * 检索和分析解决方案

FastAPI MCP SSE

使用 FastAPI 框架实现的服务器发送事件 (Server-Sent Events, SSE)，集成了模型上下文协议 (Model Context Protocol, MCP)，允许 AI 模型访问外部工具和数据源，例如天气信息。

Inoyu Apache Unomi MCP Server

一个模型上下文协议服务器，使 Claude 能够通过 Apache Unomi 配置文件管理来维护用户上下文。

Coolify MCP Server

从 Claude 桌面与你的 Coolify 服务器交互 - StuMason/coolify-mcp-server

JVM MCP Server

一个基于 Arthas 的 JVM 监控和控制平台服务器，提供 Python 接口，用于监控和分析 Java 进程，具备线程分析、内存监控和性能诊断等功能。

mitmproxy-mcp MCP Server

一个服务器，用于使用自定义 URI 方案管理和总结笔记，并提供添加笔记和创建样式化摘要的工具。

MCP Server for Replicate

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

Code Research MCP Server

促进跨平台（如 Stack Overflow、MDN、GitHub、npm 和 PyPI）搜索和访问编程资源，帮助大型语言模型 (LLM) 查找代码示例和文档。

BioMCP

一个模型上下文协议服务器，通过整合蛋白质结构分析能力来增强语言模型，从而能够通过已建立的蛋白质数据库进行详细的活性位点分析和疾病相关蛋白质搜索。

Seq MCP Server

Seq MCP 服务器支持与 Seq 的 API 端点进行交互，用于日志记录和监控，并提供管理信号、事件和警报的工具，具有广泛的过滤和配置选项。

Barnsworthburning MCP

一个模型上下文协议（Model Context Protocol）服务器，它能够让用户直接通过兼容的 AI 客户端（例如 Claude for Desktop）搜索 barnsworthburning.net 上的内容。

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!