Discover Awesome MCP Servers

MCP Stripe Server

Sebuah server yang terintegrasi dengan Stripe untuk menangani pembayaran, pelanggan, dan pengembalian dana melalui Model Context Protocol, menyediakan API yang aman untuk mengelola transaksi keuangan.

X MCP Server

Server untuk integrasi X (Twitter) yang menyediakan alat untuk membaca linimasa Anda dan berinteraksi dengan tweet. Dirancang untuk digunakan dengan Claude desktop.

mcp-server-google-analytics

An MCP server implementation for accessing Google Analytics 4 (GA4) data, built using the Model Context Protocol TypeScript SDK.

GitLab MCP Server

Implementasi server khusus yang memungkinkan asisten AI berinteraksi dengan repositori GitLab, menyediakan kemampuan untuk mencari, mengambil berkas, membuat/memperbarui konten, dan mengelola isu dan permintaan penggabungan.

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.

MCP Security Audit Server

Memeriksa dependensi paket npm untuk kerentanan keamanan, menyediakan laporan terperinci dan rekomendasi perbaikan dengan integrasi MCP.

MCP Intercom Server

Menyediakan akses ke percakapan dan obrolan Intercom melalui Model Context Protocol, memungkinkan LLM untuk menanyakan dan menganalisis percakapan Intercom dengan berbagai opsi penyaringan.

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.

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.

Barnsworthburning MCP

Server Protokol Konteks Model yang memungkinkan pencarian konten dari barnsworthburning.net secara langsung melalui klien AI yang kompatibel seperti Claude untuk Desktop.

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.

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.

mcp-omnisearch

🔍 Sebuah server Model Context Protocol (MCP) yang menyediakan akses terpadu ke berbagai mesin pencari (Tavily, Brave, Kagi), alat AI (Perplexity, FastGPT), dan layanan pemrosesan konten (Jina AI, Kagi). Menggabungkan pencarian, respons AI, pemrosesan konten, dan fitur peningkatan melalui satu antarmuka.

Redmine MCP Server

Server Protokol Konteks Model untuk berinteraksi dengan Redmine menggunakan REST API-nya, memungkinkan pengelolaan tiket, proyek, dan data pengguna melalui integrasi dengan LLM.

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!

Better Auth MCP Server

Mengaktifkan manajemen autentikasi tingkat perusahaan dengan penanganan kredensial yang aman dan dukungan untuk autentikasi multi-protokol, lengkap dengan alat untuk menganalisis, mengatur, dan menguji sistem autentikasi.

video-editing-mcp

Unggah, edit, dan hasilkan video dari LLM dan Hutan Video favorit semua orang.

MCP Salesforce Connector

Sebuah server Protokol Konteks Model yang memungkinkan LLM (Model Bahasa Besar) untuk berinteraksi dengan data Salesforce melalui kueri SOQL, pencarian SOSL, dan berbagai operasi API termasuk manajemen rekaman.

API Tester MCP Server

Server Protokol Konteks Model yang memungkinkan Claude untuk membuat permintaan API atas nama Anda, menyediakan alat untuk menguji berbagai API termasuk permintaan HTTP dan integrasi OpenAI tanpa membagikan kunci API Anda di obrolan.

Morpho API MCP Server

Memungkinkan interaksi dengan Morpho GraphQL API, menyediakan alat untuk mengakses data pasar, vault, posisi, dan transaksi melalui server Model Context Protocol (MCP).

Dify MCP Server

Mengintegrasikan Dify AI API untuk menyediakan pembuatan kode untuk komponen Ant Design, mendukung input teks dan gambar dengan kemampuan pemrosesan aliran (stream).

MCP Node Fetch

Sebuah server MCP yang memungkinkan pengambilan konten web menggunakan pustaka Node.js undici, mendukung berbagai metode HTTP, format konten, dan konfigurasi permintaan.

Solana MCP Server

Sebuah server yang menyediakan titik akhir RPC sederhana untuk operasi blockchain Solana yang umum, memungkinkan pengguna untuk memeriksa saldo, mendapatkan informasi akun, dan mentransfer SOL antar akun.

Higress AI-Search MCP Server

Sebuah server Protokol Konteks Model yang memungkinkan model AI untuk melakukan pencarian internet dan pengetahuan secara real-time melalui Higress, meningkatkan respons model dengan informasi terkini dari Google, Bing, Arxiv, dan basis pengetahuan internal.

Huntress-MCP-Server

Here are a few possible translations, depending on the specific context of "MCP server": **Option 1 (Most likely, assuming MCP refers to a management or control plane):** * **Server MCP untuk integrasi API Huntress** (This is a direct translation and likely the most accurate if "MCP" refers to a management or control plane server.) **Option 2 (If MCP refers to a specific software or platform):** * **Server [Nama MCP] untuk integrasi API Huntress** (Replace "[Nama MCP]" with the actual name of the MCP software or platform.) **Option 3 (More general, if the exact meaning of MCP is unclear):** * **Server untuk integrasi API Huntress yang menggunakan MCP** (This translates to "Server for Huntress API integration that uses MCP" and is useful if you want to be less specific.) **Which option is best depends on the context. If you can provide more information about what "MCP" refers to, I can give you a more precise translation.**

MCP-Server-IETF

Server Protokol Konteks Model yang memungkinkan Model Bahasa Besar untuk mencari dan mengakses dokumen IETF RFC dengan dukungan paginasi.

MCP Local Web Search Server

Memungkinkan melakukan pencarian web lokal dan mengekstrak konten terstruktur dari halaman web menggunakan Model Context Protocol, dengan fitur batasan hasil yang dapat disesuaikan dan penyaringan domain.

Govee MCP Server

Memungkinkan pengguna untuk mengontrol perangkat LED Govee menggunakan Govee API, dengan fitur untuk menghidupkan/mematikan perangkat, mengatur warna, dan menyesuaikan kecerahan melalui CLI atau klien MCP.

Docker MCP Server

Sebuah server MCP yang memungkinkan pengelolaan kontainer Docker melalui bahasa alami, memungkinkan pengguna untuk menyusun, memeriksa, dan men-debug kontainer tanpa menjalankan perintah secara manual.

Strapi MCP Server

Server Protokol Konteks Model yang memungkinkan asisten AI untuk berinteraksi dengan instance Strapi CMS melalui antarmuka terstandarisasi, mendukung tipe konten dan operasi REST API.