Discover Awesome MCP Servers

Github MCP Server

Menyediakan integrasi dengan Github melalui Model Context Protocol (MCP), memungkinkan Model Bahasa Besar untuk berinteraksi dengan repositori, isu, permintaan tarik, dan fungsionalitas pencarian Github.

PulseMCP Server

PulseMCP Server adalah server MCP berbasis TypeScript yang mengimplementasikan sistem catatan sederhana, memungkinkan pengguna untuk membuat, mengakses, dan meringkas catatan teks melalui Model Context Protocol dengan manajemen sumber daya berbasis URI dan perintah peringkasan LLM.

mcp-server-google-analytics

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

Jina.ai Grounding MCP Server

Integrates Jina.ai's Grounding API with LLMs for real-time, fact-based web content grounding and analysis, enhancing LLM responses with precise, verified information.

MCP JSON Document Collection Server

Server Protokol Konteks Model yang memungkinkan pembuatan dan pengelolaan banyak database JSON Fireproof dengan operasi CRUD, kemampuan kueri, dan sinkronisasi cloud untuk berbagi database dengan orang lain.

CockroachDB MCP Server

Terhubung ke instance CockroachDB dan mengekspos struktur database sebagai sumber daya, memungkinkan eksekusi kueri SQL dan analisis melalui antarmuka Claude.

MCP Command Proxy

Server proxy yang memungkinkan asisten AI untuk berjalan dan berinteraksi dengan aplikasi command-line seperti Expo melalui Model Context Protocol (MCP), menangkap log dan memungkinkan penerusan penekanan tombol.

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 Blockchain Server

Sistem aman yang memungkinkan asisten AI untuk berinteraksi dengan data blockchain dan menyiapkan transaksi, sambil memastikan pengguna mempertahankan kendali eksklusif atas kunci pribadi dan penandatanganan transaksi mereka.

MCP Security Audit Server

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

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.

WolframAlpha LLM MCP Server

Mengaktifkan kueri ke API LLM WolframAlpha untuk pertanyaan bahasa alami, menyediakan jawaban terstruktur dan disederhanakan yang dioptimalkan untuk konsumsi LLM.

Nostr MCP Server

Sebuah server Model Context Protocol (MCP) yang memungkinkan model AI berinteraksi dengan jaringan Nostr, memfasilitasi pengiriman catatan dan interaksi dengan protokol kebebasan berbicara.

Playwright Server MCP

Server ini menyediakan alat untuk otomatisasi web menggunakan Playwright, memungkinkan navigasi, interaksi, dan eksekusi JavaScript pada halaman web, serta mendukung penyimpanan catatan dengan kemampuan meringkas.

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.

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.

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.

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.

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.

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.

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.

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!

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.

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.

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.

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 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.

video-editing-mcp

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

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).