Discover Awesome MCP Servers

WolframAlpha LLM MCP Server

启用查询 WolframAlpha 的 LLM API 以获取自然语言问题，提供结构化和简化的答案，并针对 LLM 的使用进行优化。

Playwright Server MCP

该服务器提供使用 Playwright 进行网页自动化的工具，允许在网页上进行导航、交互和 JavaScript 执行，并支持具有总结功能的笔记存储。

Nostr MCP Server

一个模型上下文协议（MCP）服务器，使人工智能模型能够与 Nostr 网络互动，从而促进笔记发布和与言论自由协议的交互。

MCP Intercom Server

通过模型上下文协议提供对 Intercom 对话和聊天的访问，允许 LLM 查询和分析 Intercom 对话，并提供各种过滤选项。

GitLab MCP Server

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

MCP Server for Replicate

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

MCP Security Audit Server

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

BioMCP

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

Code Research MCP Server

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

Seq MCP Server

Seq MCP 服务器支持与 Seq 的 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!

Redmine MCP Server

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

Barnsworthburning MCP

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

Jenkins Server MCP

通过在 GitHub 上创建一个帐户，来为 hekmon8/Jenkins-server-mcp 的开发做出贡献。

Better Auth MCP Server

实现企业级身份验证管理，具有安全的凭据处理和多协议身份验证支持，并提供用于分析、设置和测试身份验证系统的工具。

mcp-omnisearch

🔍 一个模型上下文协议（MCP）服务器，提供对多个搜索引擎（Tavily、Brave、Kagi）、人工智能工具（Perplexity、FastGPT）和内容处理服务（Jina AI、Kagi）的统一访问。通过单一界面结合了搜索、人工智能响应、内容处理和增强功能。

API Tester MCP Server

通过在 GitHub 上创建一个帐户来为 Vikrant-Khedkar/api-tester-mcp 的开发做出贡献。

Morpho API MCP Server

一个用于模型上下文协议的 Morpho 服务器。欢迎通过在 GitHub 上创建一个帐户来参与 crazyrabbitLTC/mcp-morpho-server 的开发。

MCP Salesforce Connector

一个模型上下文协议服务器，使大型语言模型（LLM）能够通过 SOQL 查询、SOSL 搜索以及包括记录管理在内的各种 API 操作与 Salesforce 数据进行交互。

video-editing-mcp

从大家最喜欢的LLM和视频丛林上传、编辑和生成视频。

MCP Node Fetch

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

MCP-Server-IETF

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

Govee MCP Server

允许用户使用 Govee API 控制 Govee LED 设备，并通过 CLI 或 MCP 客户端实现设备开关、颜色设置和亮度调节等功能。

Dify MCP Server

集成了 Dify AI API，为 Ant Design 组件提供代码生成功能，支持文本和图像输入，并具备流式处理能力。

Higress AI-Search MCP Server

一个模型上下文协议服务器，通过 Higress 使 AI 模型能够执行实时互联网和知识搜索，从而利用来自 Google、Bing、Arxiv 和内部知识库的最新信息来增强模型响应。

Solana MCP Server

一个服务器，提供用于常见 Solana 区块链操作的简单 RPC 端点，允许用户检查余额、获取账户信息以及在账户之间转移 SOL。

MCP Local Web Search Server

启用执行本地网络搜索并使用模型上下文协议从网页中提取结构化内容的功能，具有可自定义的结果限制和域名过滤功能。

Huntress-MCP-Server

用于 Huntress API 集成的 MCP 服务器

dbSNP MCP Plugin

我尝试为dbSNP构建一个MCP服务器。通过在GitHub上创建一个帐户来为mattshu0410/MCP-server的开发做出贡献。

Docker MCP Server

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