Discover Awesome MCP Servers

Biomart MCP

Sebuah server Protokol Konteks Model yang berinteraksi dengan database Biomart, memungkinkan model untuk menemukan dataset biologis, menjelajahi atribut/filter, mengambil data biologis, dan menerjemahkan antara pengidentifikasi biologis yang berbeda.

Unofficial dubco-mcp-server

Server Protokol Konteks Model yang memungkinkan asisten AI untuk membuat, memperbarui, dan menghapus tautan pendek Dub.co melalui API Dub.co.

Systemprompt MCP Gmail Server

Memungkinkan pengguna untuk mengelola akun Gmail menggunakan operasi yang dibantu oleh agen AI melalui protokol MCP, mendukung pencarian, pembacaan, penghapusan, dan pengiriman email dengan antarmuka bertenaga suara.

Strava MCP Server

Server Protokol Konteks Model yang menyediakan model bahasa dengan akses ke data API Strava, memungkinkan mereka untuk meminta dan menganalisis aktivitas atlet dari Strava.

TfNSW Realtime Alerts MCP Server

Server ini memungkinkan model bahasa besar untuk mengakses dan berinteraksi dengan peringatan transportasi waktu nyata dari jaringan Transport for NSW, mendukung penyaringan berdasarkan moda transportasi dan mengembalikan informasi peringatan yang diformat tentang gangguan dan pekerjaan yang direncanakan.

Inoyu Apache Unomi MCP Server

Server Protokol Konteks Model yang memungkinkan Claude untuk mempertahankan konteks pengguna melalui manajemen profil Apache Unomi.

Coolify MCP Server

Enables interaction with Coolify applications and resources through the Coolify API via a standardized interface, supporting application management operations such as listing, starting, stopping, restarting, and deploying.

JVM MCP Server

Server platform pemantauan dan kontrol JVM berbasis Arthas yang menyediakan antarmuka Python untuk memantau dan menganalisis proses Java dengan kemampuan untuk analisis thread, pemantauan memori, dan diagnostik kinerja.

mitmproxy-mcp MCP Server

Sebuah server untuk mengelola dan meringkas catatan menggunakan skema URI khusus, dengan alat untuk menambahkan catatan dan membuat ringkasan bergaya.

MCP Server for Replicate

Implementasi server FastMCP yang menyediakan antarmuka terstandarisasi untuk mengakses model AI yang dihosting di API Replicate, saat ini mendukung pembuatan gambar dengan parameter yang dapat disesuaikan.

Code Research MCP Server

Memfasilitasi pencarian dan akses sumber daya pemrograman di berbagai platform seperti Stack Overflow, MDN, GitHub, npm, dan PyPI, membantu LLM dalam menemukan contoh kode dan dokumentasi.

BioMCP

Server Protokol Konteks Model yang meningkatkan kemampuan model bahasa dengan analisis struktur protein, memungkinkan analisis situs aktif yang mendetail dan pencarian protein terkait penyakit melalui basis data protein yang sudah mapan.

Seq MCP Server

Server Seq MCP memungkinkan interaksi dengan titik akhir API Seq untuk pencatatan dan pemantauan, menyediakan alat untuk mengelola sinyal, peristiwa, dan peringatan dengan opsi pemfilteran dan konfigurasi yang ekstensif.

Barnsworthburning MCP

Server Protokol Konteks Model yang memungkinkan pencarian konten dari barnsworthburning.net secara langsung melalui klien AI yang kompatibel seperti Claude untuk 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 own MCP server to Heroku and connecting it to Cursor IDE. **I. Project Structure (Recommended)** ``` my-cursor-tool/ ├── server/ # MCP Server Implementation (Python/Node.js/Go) │ ├── app.py # (Python example) Main server file │ ├── requirements.txt # (Python example) Dependencies │ ├── Procfile # Heroku deployment instructions │ └── ... ├── cursor-extension/ # Cursor IDE Extension (JavaScript/TypeScript) │ ├── package.json │ ├── src/ │ │ ├── extension.ts # Main extension file │ │ └── ... │ └── ... └── README.md # Instructions for setup and usage ``` **II. MCP Server (Example: Python with Flask)** 1. **`server/app.py` (Example):** ```python from flask import Flask, request, jsonify import os app = Flask(__name__) @app.route('/model_context', methods=['POST']) def model_context(): data = request.get_json() query = data.get('query', '') context = data.get('context', []) # List of file paths and content # --- Your Tool Logic Here --- # Process the query and context to generate a response. # This is where your custom tool's functionality resides. # Example: response_text = f"You asked: {query}\nContext files: {len(context)} files" return jsonify({"response": response_text}) if __name__ == '__main__': port = int(os.environ.get('PORT', 5000)) # Heroku uses PORT env var app.run(debug=False, host='0.0.0.0', port=port) ``` 2. **`server/requirements.txt`:** ``` Flask ``` 3. **`server/Procfile`:** ``` web: gunicorn app:app --log-file - --log-level debug ``` **Explanation:** * **Flask:** A lightweight Python web framework. You can use other frameworks like FastAPI or Django if you prefer. * **`/model_context` endpoint:** This is the core of the MCP server. Cursor IDE will send POST requests to this endpoint with a `query` (the user's question) and `context` (a list of files and their content). * **`request.get_json()`:** Parses the JSON data sent by Cursor IDE. * **`data.get('query', '')` and `data.get('context', [])`:** Safely retrieves the `query` and `context` from the JSON data. The second argument provides a default value if the key is missing. * **`# --- Your Tool Logic Here ---`:** This is where you implement the actual logic of your custom tool. You'll need to process the `query` and `context` to generate a relevant response. This could involve: * Parsing the code in the `context`. * Running static analysis. * Searching external databases. * Using a language model (e.g., OpenAI API) to generate a response based on the context. * **`jsonify({"response": response_text})`:** Returns the response as a JSON object. The `response` key is required by the MCP. * **`os.environ.get('PORT', 5000)`:** Gets the port number from the environment variable `PORT`. Heroku sets this environment variable. If it's not set (e.g., when running locally), it defaults to port 5000. * **`Procfile`:** Tells Heroku how to run your application. `gunicorn` is a production-ready WSGI server. **III. Deploying to Heroku** 1. **Create a Heroku Account:** If you don't have one, sign up at [https://www.heroku.com/](https://www.heroku.com/). 2. **Install the Heroku CLI:** Follow the instructions on the Heroku website to install the Heroku command-line interface (CLI). 3. **Login to Heroku:** Open your terminal and run: ```bash heroku login ``` 4. **Create a Heroku App:** ```bash heroku create my-cursor-tool-server # Replace with your desired app name ``` 5. **Deploy the Server:** ```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 ``` 6. **Check the Logs:** After deployment, check the Heroku logs to ensure the server started correctly: ```bash heroku logs --tail -a my-cursor-tool-server # Replace with your app name ``` 7. **Get the Heroku App URL:** Find the URL of your deployed Heroku app. You can find it in the Heroku dashboard or by running: ```bash heroku apps:info -a my-cursor-tool-server # Replace with your app name ``` The URL will be something like `https://my-cursor-tool-server.herokuapp.com`. **IV. Cursor IDE Extension** 1. **`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.70.0" // Or the minimum version Cursor IDE supports }, "activationEvents": [ "*" // Activate on all events (adjust as needed) ], "main": "./out/extension.js", "contributes": { "configuration": { "title": "My Cursor Tool", "properties": { "myCursorTool.mcpServerUrl": { "type": "string", "default": "YOUR_HEROKU_APP_URL", // Replace with your Heroku URL "description": "The URL of your MCP server." } } } }, "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.70.0", "@types/glob": "^7.2.0", "@types/mocha": "^9.1.1", "@types/node": "16.x", "@typescript-eslint/eslint-plugin": "^5.31.0", "@typescript-eslint/parser": "^5.31.0", "eslint": "^8.21.0", "glob": "^8.0.3", "mocha": "^10.0.0", "typescript": "^4.7.4", "@vscode/test-electron": "^2.1.5" }, "dependencies": { "node-fetch": "^3.2.10" } } ``` 2. **`cursor-extension/src/extension.ts`:** ```typescript import * as vscode from 'vscode'; import fetch from 'node-fetch'; export function activate(context: vscode.ExtensionContext) { console.log('My Cursor Tool is now active!'); let disposable = vscode.commands.registerCommand('my-cursor-tool.ask', async () => { const editor = vscode.window.activeTextEditor; if (!editor) { vscode.window.showInformationMessage('No active text editor.'); return; } const query = await vscode.window.showInputBox({ prompt: 'Ask your question:' }); if (!query) { return; } const document = editor.document; const contextFiles = [{ path: document.uri.fsPath, content: document.getText() }]; const config = vscode.workspace.getConfiguration('myCursorTool'); const mcpServerUrl = config.get<string>('mcpServerUrl'); if (!mcpServerUrl) { vscode.window.showErrorMessage('MCP Server URL not configured. Please set it in the settings.'); return; } try { const response = await fetch(mcpServerUrl + '/model_context', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ query: query, context: contextFiles }) }); if (!response.ok) { vscode.window.showErrorMessage(`MCP Server Error: ${response.status} ${response.statusText}`); return; } const data = await response.json(); const answer = data.response; vscode.window.showInformationMessage(answer); // Or display in a more sophisticated way } catch (error: any) { vscode.window.showErrorMessage(`Error communicating with MCP Server: ${error.message}`); } }); context.subscriptions.push(disposable); } export function deactivate() {} ``` **Explanation:** * **`package.json`:** * `name`, `displayName`, `description`, `version`: Basic metadata for your extension. * `engines.vscode`: Specifies the minimum VS Code (or Cursor IDE) version your extension requires. * `activationEvents`: Determines when your extension is activated. `"*"` means it activates on all events. You can make this more specific for better performance. * `main`: Specifies the entry point of your extension (the compiled JavaScript file). * `contributes.configuration`: Defines configuration settings that users can customize in the Cursor IDE settings. Here, we define a setting called `myCursorTool.mcpServerUrl` where users can enter the URL of their MCP server. **Important:** Replace `YOUR_HEROKU_APP_URL` with a placeholder value. * `dependencies`: Includes `node-fetch` for making HTTP requests to your MCP server. * **`extension.ts`:** * **`activate(context: vscode.ExtensionContext)`:** This function is called when your extension is activated. * **`vscode.commands.registerCommand('my-cursor-tool.ask', ...)`:** Registers a command that users can execute (e.g., from the command palette). The command ID is `my-cursor-tool.ask`. * **`vscode.window.activeTextEditor`:** Gets the currently active text editor. * **`vscode.window.showInputBox(...)`:** Displays an input box where the user can enter their query. * **`document.uri.fsPath`:** Gets the file path of the current document. * **`document.getText()`:** Gets the content of the current document. * **`vscode.workspace.getConfiguration('myCursorTool')`:** Gets the configuration settings for your extension. * **`config.get<string>('mcpServerUrl')`:** Retrieves the value of the `myCursorTool.mcpServerUrl` setting. * **`fetch(...)`:** Sends a POST request to your MCP server with the query and context. * **`response.json()`:** Parses the JSON response from the server. * **`vscode.window.showInformationMessage(...)`:** Displays the response from the server in an information message. You can use other ways to display the response, such as creating a new editor window or using a webview. * **Error Handling:** The code includes error handling to catch potential problems, such as network errors or invalid responses from the server. **V. Building and Testing the Extension** 1. **Install Dependencies:** ```bash cd cursor-extension npm install ``` 2. **Compile the Extension:** ```bash npm run compile ``` 3. **Run the Extension in Cursor IDE:** * Open Cursor IDE. * Open the `cursor-extension` folder in Cursor IDE. * Press `F5` to start the extension in debug mode. This will open a new Cursor IDE window with your extension loaded. 4. **Test the Extension:** * Open a file in the debug Cursor IDE window. * Press `Ctrl+Shift+P` (or `Cmd+Shift+P` on macOS) to open the command palette. * Type `My Cursor Tool: Ask` (or whatever you named your command) and select it. * Enter a query in the input box. * You should see the response from your MCP server displayed in an information message. **VI. Connecting to Your Heroku Server** 1. **Set the `mcpServerUrl` Configuration:** * In Cursor IDE, go to `File` -> `Preferences` -> `Settings`. * Search for `My Cursor Tool: Mcp Server Url` (or whatever you named your configuration setting). * Enter the URL of your Heroku app (e.g., `https://my-cursor-tool-server.herokuapp.com`). 2. **Test Again:** Repeat the testing steps above to verify that your extension is now communicating with your Heroku server. **VII. Important Considerations and Improvements** * **Security:** * **Authentication:** If your tool requires authentication, you'll need to implement a secure authentication mechanism (e.g., API keys, OAuth) between the Cursor IDE extension and your MCP server. Store API keys securely (e.g., using environment variables). * **Input Validation:** Always validate the input you receive from Cursor IDE to prevent security vulnerabilities (e.g., injection attacks). * **Error Handling:** Implement robust error handling in both the extension and the server. Log errors to help with debugging. * **Performance:** * **Asynchronous Operations:** Use asynchronous operations (e.g., `async/await`) to avoid blocking the Cursor IDE UI. * **Caching:** Cache frequently accessed data to improve performance. * **Optimize Server Logic:** Optimize the logic in your MCP server to minimize response times. * **User Interface:** Consider using more sophisticated UI elements than just information messages. You could use webviews to create custom panels or editors. * **Context Management:** Think carefully about how you want to use the context provided by Cursor IDE. You might want to filter the context to only include relevant files. * **Rate Limiting:** Implement rate limiting on your MCP server to prevent abuse. * **Logging:** Add detailed logging to your server to help debug issues. Heroku provides logging services. * **Environment Variables:** Use environment variables for sensitive configuration settings (e.g., API keys, database credentials). Set these environment variables in your Heroku app settings. * **Deployment Pipeline:** Set up a CI/CD pipeline to automate the deployment of your MCP server to Heroku. **VIII. Example: Using OpenAI API** Here's an example of how you could use the OpenAI API in your MCP server to generate responses based on the context: ```python from flask import Flask, request, jsonify import os import openai app = Flask(__name__) openai.api_key = os.environ.get("OPENAI_API_KEY") # Set OpenAI API key in Heroku @app.route('/model_context', methods=['POST']) def model_context(): data = request.get_json() query = data.get('query', '') context = data.get('context', []) context_string = "\n".join([f"File: {file['path']}\n{file['content']}" for file in context]) prompt = f"Based on the following code context:\n\n{context_string}\n\nAnswer the question: {query}" try: response = openai.Completion.create( engine="text-davinci-003", # Or another suitable engine prompt=prompt, max_tokens=200, n=1, stop=None, temperature=0.7, ) answer = response.choices[0].text.strip() except Exception as e: answer = f"Error using OpenAI: {str(e)}" return jsonify({"response": answer}) if __name__ == '__main__': port = int(os.environ.get('PORT', 5000)) app.run(debug=False, host='0.0.0.0', port=port) ``` **Important:** * **Install the OpenAI Python library:** `pip install openai` * **Set the `OPENAI_API_KEY` environment variable in your Heroku app settings.** Do *not* hardcode your API key in your code. * **Choose an appropriate OpenAI engine:** `text-davinci-003` is a powerful engine, but it's also more expensive. Consider using a cheaper engine like `text-curie-001` or `text-babbage-001` if appropriate. * **Adjust the `max_tokens` and `temperature` parameters:** These parameters control the length and creativity of the generated text. This template provides a solid foundation for building custom tools for Cursor IDE using the Model Context Protocol. Remember to adapt the code to your specific needs and to follow best practices for security, performance, and error handling. Good luck!

Azure MCP Server

Server ini mengimplementasikan Protokol Konteks Model untuk interaksi tanpa hambatan dengan Azure Blob Storage dan Cosmos DB, memungkinkan pencatatan log dan pelacakan audit operasi secara otomatis.

DocsFetcher MCP Server

Mengambil dan mengekstrak dokumentasi paket yang komprehensif dari berbagai ekosistem bahasa pemrograman (JavaScript, Python, Java, dll.) untuk LLM seperti Claude tanpa memerlukan kunci API.

File Context MCP

Server ini menyediakan API untuk menanyakan Large Language Models (Model Bahasa Besar) menggunakan konteks dari file lokal, mendukung berbagai model dan tipe file untuk respons yang sadar konteks.

Neon MCP Server

Lightweight MCP server to give your Cursor Agent access to the Neon API

EDUCHAIN Agent Kit

Sebuah server MCP yang menyediakan alat untuk berinteraksi dengan EDUCHAIN, memungkinkan Claude untuk menanyakan informasi tentang token dan pool serta melakukan swap melalui SailFish DEX.

MCP Databricks Server

Ini adalah server Model Context Protocol (MCP) untuk menjalankan kueri SQL terhadap Databricks menggunakan Statement Execution API. Ini memungkinkan asisten AI untuk langsung menanyakan gudang data Databricks, menganalisis skema database, dan mengambil hasil kueri dalam format terstruktur.

Fetch MCP Server

Memungkinkan pengambilan dan pemrosesan konten halaman web untuk LLM dengan mengubah HTML menjadi markdown, dengan dukungan untuk pemotongan konten dan penomoran halaman.

XTBApiServer

Sebuah server MCP yang mengekspos API perdagangan XTB, memungkinkan pengguna untuk berinteraksi dengan akun perdagangan XTB mereka melalui Model Context Protocol untuk melakukan operasi seperti manajemen akun, pengambilan data pasar, dan eksekusi perdagangan.

Lichess MCP

Sebuah server MCP yang memungkinkan interaksi bahasa alami dengan platform catur Lichess, memungkinkan pengguna untuk bermain game, menganalisis posisi, mengelola akun mereka, dan berpartisipasi dalam turnamen melalui Claude.

noaa-tidesandcurrents-mcp

Ini adalah server MCP (Model Context Protocol) yang menyediakan alat untuk berinteraksi dengan NOAA Tides and Currents API.

MCP Server for Ticketmaster Events

Menyediakan alat untuk menemukan acara di Madison Square Garden melalui Ticketmaster API, mengembalikan data terstruktur dengan detail acara seperti nama, tanggal, harga, dan tautan pembelian tiket.

Jenkins MCP

Memungkinkan pengelolaan operasi Jenkins seperti menampilkan daftar pekerjaan, memicu build, dan memeriksa status build melalui server MCP yang dapat dikonfigurasi.

CouchDB MCP Server

Server MCP berbasis TypeScript yang memungkinkan asisten AI untuk berinteraksi dengan database CouchDB melalui antarmuka yang sederhana, menyediakan alat untuk membuat, membaca, dan menanyakan database dan dokumen.

mcp-server-ollama-deep-researcher

Ini adalah adaptasi server Model Context Protocol (MCP) dari LangChain Ollama Deep Researcher. Ini menyediakan kemampuan riset mendalam sebagai alat MCP yang dapat digunakan dalam ekosistem protokol konteks model, memungkinkan asisten AI untuk melakukan riset mendalam tentang topik (secara lokal) melalui Ollama.

FreeAgent MCP Server

Server Claude MCP yang memungkinkan Claude berinteraksi dengan akun FreeAgent Anda untuk melacak waktu, mengelola timer, dan menangani operasi timeslip.