Discover Awesome MCP Servers

Barnsworthburning MCP

Một máy chủ Giao thức Bối cảnh Mô hình (Model Context Protocol) cho phép tìm kiếm nội dung từ barnsworthburning.net trực tiếp thông qua các ứng dụng AI tương thích như Claude cho Desktop.

MCP Server Template for Cursor IDE

Okay, here's a template and guide for creating custom tools for Cursor IDE using the Model Context Protocol (MCP), with instructions on deploying your MCP server to Heroku and connecting it to Cursor IDE. This template focuses on providing a solid foundation and clear instructions. **I. Project Structure** ``` my-cursor-tool/ ├── server/ # MCP Server Code (Python/Node.js/etc.) │ ├── app.py # Main application file (e.g., Flask/FastAPI) │ ├── requirements.txt # Python dependencies │ ├── Procfile # Heroku deployment instructions │ └── .env # Environment variables (API keys, etc.) ├── cursor_tool/ # Cursor IDE Tool Definition │ ├── package.json # Tool manifest for Cursor │ ├── src/ # Source code for the Cursor tool │ │ ├── index.ts # Main entry point for the Cursor tool │ │ └── ... # Other components, UI elements, etc. │ └── webpack.config.js # (Optional) Webpack configuration ├── README.md # Instructions for setup and deployment └── .gitignore # Files to ignore in Git ``` **II. MCP Server (Example: Python with FastAPI)** 1. **`server/app.py` (FastAPI Example):** ```python from fastapi import FastAPI, Request, HTTPException from fastapi.responses import JSONResponse from pydantic import BaseModel import os app = FastAPI() # Replace with your actual logic def process_query(query: str, context: dict) -> str: """ Processes the query using the provided context. This is where your custom tool's logic goes. """ # Example: Simple echo with context information return f"You asked: '{query}' with context: {context}" class QueryRequest(BaseModel): query: str context: dict @app.post("/query") async def handle_query(request: QueryRequest): try: query = request.query context = request.context result = process_query(query, context) return JSONResponse({"result": result}) except Exception as e: raise HTTPException(status_code=500, detail=str(e)) @app.get("/health") async def health_check(): return {"status": "ok"} if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=int(os.environ.get("PORT", 8000))) ``` 2. **`server/requirements.txt`:** ``` fastapi uvicorn[standard] python-dotenv ``` 3. **`server/Procfile`:** ``` web: gunicorn app:app --workers 3 --worker-class uvicorn.workers.UvicornWorker ``` 4. **`server/.env` (Optional):** ``` # API_KEY=your_api_key # Example: If your tool needs an API key ``` **III. Cursor IDE Tool Definition** 1. **`cursor_tool/package.json`:** ```json { "name": "my-cursor-tool", "version": "0.1.0", "description": "A custom tool for Cursor IDE.", "main": "dist/index.js", "scripts": { "build": "webpack", "watch": "webpack --watch" }, "devDependencies": { "@types/node": "^16.0.0", "ts-loader": "^9.0.0", "typescript": "^4.3.0", "webpack": "^5.0.0", "webpack-cli": "^4.0.0" }, "cursor": { "modelContextProtocol": { "url": "YOUR_HEROKU_APP_URL/query", // Replace with your Heroku app URL "healthCheckUrl": "YOUR_HEROKU_APP_URL/health" // Replace with your Heroku app URL } } } ``` 2. **`cursor_tool/src/index.ts`:** ```typescript // This file is intentionally left minimal. Cursor uses the // `modelContextProtocol` in `package.json` to communicate with your server. // You don't need to write code here to handle the query/response cycle. console.log("My Cursor tool is running!"); // You *can* add code here to: // 1. Register custom commands (e.g., using `cursor.registerCommand`) // 2. Interact with the Cursor IDE (e.g., using `cursor.activeTextEditor`) // 3. Perform any other setup or initialization. // Example: Registering a simple command // cursor.registerCommand("my-cursor-tool.helloWorld", () => { // cursor.showInformationMessage("Hello from my Cursor tool!"); // }); ``` 3. **`cursor_tool/webpack.config.js`:** ```javascript const path = require('path'); module.exports = { entry: './src/index.ts', module: { rules: [ { test: /\.tsx?$/, use: 'ts-loader', exclude: /node_modules/, }, ], }, resolve: { extensions: ['.tsx', '.ts', '.js'], }, output: { filename: 'index.js', path: path.resolve(__dirname, 'dist'), }, mode: 'development', // or 'production' }; ``` **IV. Deployment to Heroku** 1. **Create a Heroku Account and Install the Heroku CLI:** If you don't have one already, create a Heroku account at [https://www.heroku.com/](https://www.heroku.com/) and install the Heroku CLI: [https://devcenter.heroku.com/articles/heroku-cli](https://devcenter.heroku.com/articles/heroku-cli) 2. **Login to Heroku:** ```bash heroku login ``` 3. **Create a Heroku App:** ```bash heroku create my-cursor-tool-server # Replace with your desired app name ``` 4. **Deploy the Server Code:** ```bash cd server git init git add . git commit -m "Initial commit" heroku git:remote -a my-cursor-tool-server # Replace with your app name git push heroku main ``` 5. **Set Environment Variables (if needed):** ```bash heroku config:set API_KEY=your_api_key -a my-cursor-tool-server # Replace with your app name and API key ``` 6. **Scale the Dyno:** ```bash heroku ps:scale web=1 -a my-cursor-tool-server # Replace with your app name ``` 7. **Get the Heroku App URL:** ```bash heroku apps:info -a my-cursor-tool-server # Replace with your app name ``` Look for the "web_url" in the output. This is the URL you'll use in your `package.json`. **V. Connecting to Cursor IDE** 1. **Update `cursor_tool/package.json`:** Replace `YOUR_HEROKU_APP_URL` in the `cursor.modelContextProtocol.url` and `cursor.modelContextProtocol.healthCheckUrl` fields with the URL of your deployed Heroku app. Make sure to include `/query` and `/health` at the end of the URL, respectively. 2. **Build the Cursor Tool:** ```bash cd cursor_tool npm install # Or yarn install npm run build # Or yarn build ``` 3. **Install the Tool in Cursor:** * Open Cursor IDE. * Go to `File > Install Tool...` * Select the `cursor_tool` directory (the directory containing `package.json`). 4. **Test the Tool:** * Open a file in Cursor. * Type a query in the editor (e.g., `//cursor: What is the capital of France?`). * The response from your Heroku server should appear in the chat window. **VI. Important Considerations and Best Practices** * **Error Handling:** Implement robust error handling in your server code. Return meaningful error messages to Cursor so users understand what went wrong. * **Security:** If your tool requires API keys or other sensitive information, store them as environment variables on Heroku (as shown above) and *never* commit them directly to your code. Consider using more advanced authentication methods if necessary. * **Context:** Carefully consider the context information that Cursor provides to your tool. Use this information to provide more relevant and accurate results. The `context` object in the `QueryRequest` contains information about the current file, selected text, and other relevant details. * **Performance:** Optimize your server code for performance. Heroku dynos have limited resources, so efficient code is crucial. Consider using caching to reduce the load on your server. * **Logging:** Implement logging in your server code to help you debug issues and monitor performance. Heroku provides logging tools that you can use to view your server's logs. * **Rate Limiting:** Implement rate limiting on your server to prevent abuse and ensure fair usage. * **Asynchronous Operations:** Use asynchronous operations (e.g., `async/await` in Python or Node.js) to avoid blocking the main thread and improve responsiveness. * **Testing:** Write unit tests for your server code to ensure that it is working correctly. * **Documentation:** Write clear and concise documentation for your tool, including instructions on how to install, configure, and use it. * **Heroku Free Tier Limitations:** Be aware of the limitations of the Heroku free tier (e.g., dyno sleeping). If your tool is used frequently, you may need to upgrade to a paid plan. * **Node.js Example (Alternative to Python):** If you prefer Node.js, you can adapt the server code to use Express.js or another Node.js framework. The principles are the same. **VII. Example Query and Context** When you type a query like `//cursor: Explain the concept of recursion` in Cursor, the following data (or similar) will be sent to your server's `/query` endpoint: ```json { "query": "Explain the concept of recursion", "context": { "selectedText": "", "fullText": "//cursor: Explain the concept of recursion\n", "languageId": "typescript", "filePath": "/Users/yourname/projects/my-cursor-tool/src/index.ts", "cursorPosition": { "line": 0, "character": 40 } } } ``` Your server code should parse this JSON, extract the `query` and `context`, and use them to generate a response. This template provides a solid starting point for building custom tools for Cursor IDE using the Model Context Protocol. Remember to adapt the code to your specific needs and follow best practices for security, performance, and error handling. Good luck!

Redmine MCP Server

Một máy chủ Giao thức Bối cảnh Mô hình (Model Context Protocol) để tương tác với Redmine bằng API REST của nó, cho phép quản lý các ticket, dự án và dữ liệu người dùng thông qua tích hợp với LLM.

Better Auth MCP Server

Cho phép quản lý xác thực cấp doanh nghiệp với khả năng xử lý thông tin đăng nhập an toàn và hỗ trợ xác thực đa giao thức, hoàn chỉnh với các công cụ để phân tích, thiết lập và kiểm tra hệ thống xác thực.

Jenkins Server MCP

A Model Context Protocol server that enables AI assistants to interact with Jenkins CI/CD servers, providing tools to check build statuses, trigger builds, and retrieve build logs.

API Tester MCP Server

Một máy chủ Giao thức Bối cảnh Mô hình (Model Context Protocol) cho phép Claude thực hiện các yêu cầu API thay mặt bạn, cung cấp các công cụ để kiểm tra các API khác nhau bao gồm các yêu cầu HTTP và tích hợp OpenAI mà không cần chia sẻ khóa API của bạn trong cuộc trò chuyện.

mcp-omnisearch

🔍 Một máy chủ Giao thức Bối cảnh Mô hình (MCP) cung cấp quyền truy cập thống nhất vào nhiều công cụ tìm kiếm (Tavily, Brave, Kagi), công cụ AI (Perplexity, FastGPT) và dịch vụ xử lý nội dung (Jina AI, Kagi). Kết hợp các tính năng tìm kiếm, phản hồi AI, xử lý nội dung và nâng cao thông qua một giao diện duy nhất.

Morpho API MCP Server

Cho phép tương tác với Morpho GraphQL API, cung cấp các công cụ để truy cập dữ liệu thị trường, vaults (kho tiền), positions (vị thế) và transactions (giao dịch) thông qua máy chủ Model Context Protocol (MCP).

MCP Salesforce Connector

Một máy chủ Giao thức Ngữ cảnh Mô hình (Model Context Protocol) cho phép các LLM (Mô hình Ngôn ngữ Lớn) tương tác với dữ liệu Salesforce thông qua các truy vấn SOQL, tìm kiếm SOSL và các hoạt động API khác nhau bao gồm quản lý bản ghi.

video-editing-mcp

Tải lên, chỉnh sửa và tạo video từ LLM và Video Jungle được mọi người yêu thích.

MCP Node Fetch

Một máy chủ MCP cho phép tìm nạp nội dung web bằng thư viện Node.js undici, hỗ trợ nhiều phương thức HTTP, định dạng nội dung và cấu hình yêu cầu khác nhau.

Dify MCP Server

Tích hợp Dify AI API để cung cấp khả năng tạo mã cho các component của Ant Design, hỗ trợ cả đầu vào văn bản và hình ảnh với khả năng xử lý luồng (stream processing).

Govee MCP Server

Cho phép người dùng điều khiển các thiết bị đèn LED Govee bằng API của Govee, với các tính năng bật/tắt thiết bị, cài đặt màu sắc và điều chỉnh độ sáng thông qua CLI hoặc các ứng dụng khách MCP.

MCP-Server-IETF

Một máy chủ Giao thức Ngữ cảnh Mô hình (Model Context Protocol) cho phép các Mô hình Ngôn ngữ Lớn (Large Language Models) tìm kiếm và truy cập các tài liệu IETF RFC với hỗ trợ phân trang.

Huntress-MCP-Server

Máy chủ MCP để tích hợp API Huntress

MCP Local Web Search Server

Cho phép thực hiện tìm kiếm web cục bộ và trích xuất nội dung có cấu trúc từ các trang web bằng Giao thức Ngữ cảnh Mô hình (Model Context Protocol), với các giới hạn kết quả và bộ lọc miền có thể tùy chỉnh.

Solana MCP Server

Một máy chủ cung cấp các điểm cuối RPC đơn giản cho các hoạt động blockchain Solana phổ biến, cho phép người dùng kiểm tra số dư, lấy thông tin tài khoản và chuyển SOL giữa các tài khoản.

Higress AI-Search MCP Server

Một máy chủ giao thức Model Context (Ngữ cảnh Mô hình) cho phép các mô hình AI thực hiện tìm kiếm internet và tri thức theo thời gian thực thông qua Higress, tăng cường phản hồi của mô hình bằng thông tin cập nhật từ Google, Bing, Arxiv và các cơ sở tri thức nội bộ.

dbSNP MCP Plugin

An MCP plugin that provides access to NCBI's dbSNP database, allowing developers to retrieve genetic variant information, search for SNPs, and access clinical significance data directly in their development environment.

Strapi MCP Server

Một máy chủ Giao thức Bối cảnh Mô hình (Model Context Protocol) cho phép các trợ lý AI tương tác với các phiên bản Strapi CMS thông qua một giao diện chuẩn hóa, hỗ trợ các loại nội dung và các hoạt động REST API.

Docker MCP Server

An MCP server that allows managing Docker containers through natural language, enabling users to compose, introspect, and debug containers without running commands themselves.

WorkOS MCP Server

Một máy chủ MCP (Máy chủ điều khiển chính) gọn nhẹ cho phép các tác nhân tương tác với API WorkOS để đơn giản hóa các hoạt động WorkOS thông qua các lệnh bằng ngôn ngữ tự nhiên.

Fiscal Data MCP Server

Kết nối với API Dữ liệu Tài chính của Bộ Tài chính Hoa Kỳ, cho phép người dùng tìm nạp các báo cáo kho bạc cụ thể, truy cập dữ liệu lịch sử và tạo báo cáo được định dạng.

Trello MCP Server

Cho phép tương tác với các bảng, danh sách và thẻ Trello thông qua các công cụ Model Context Protocol (MCP), tận dụng TypeScript để đảm bảo an toàn kiểu dữ liệu và các thao tác bất đồng bộ.

Social Listening MCP Server

An MCP server offering AI-driven social mention analysis via Syften's API, featuring real-time notifications and trend analysis.

Stability AI MCP Server

Một máy chủ MCP tích hợp với API của Stability AI để cung cấp khả năng tạo, chỉnh sửa và thao tác hình ảnh chất lượng cao, bao gồm xóa nền, vẽ mở rộng, tìm và thay thế, và nâng cấp độ phân giải.

Florence-2 MCP Server

Máy chủ MCP để xử lý ảnh bằng Florence-2.

MongoDB MCP Server

Một máy chủ giao thức cho phép các LLM (Mô hình ngôn ngữ lớn) như Claude tương tác với cơ sở dữ liệu MongoDB, cung cấp các công cụ để khám phá lược đồ, truy vấn tổng hợp và phân tích dữ liệu thông qua ngôn ngữ tự nhiên trong Cursor.

Open Data Model Context Protocol

Access to many public datasets right from your LLM application.

Slim MCP

Một dịch vụ API nhẹ, dạng mô-đun, cung cấp các công cụ hữu ích như thời tiết, ngày/giờ, máy tính, tìm kiếm, email và quản lý tác vụ thông qua giao diện RESTful, được thiết kế để tích hợp với các tác nhân AI và quy trình làm việc tự động.