Discover Awesome MCP Servers

Text-to-Speech MCP Server

Berikut adalah server MCP (Model Context Protocol) sederhana yang menyediakan kemampuan konversi teks ke ucapan, ditulis dalam TypeScript:

MCP Server Implementation Guide

Baik, berikut adalah panduan dan implementasi untuk membuat server MCP (Model Control Protocol) Anda sendiri untuk integrasi Cursor: **Panduan dan Implementasi untuk Membuat Server MCP (Model Control Protocol) Anda Sendiri untuk Integrasi Cursor** **Pendahuluan** Model Control Protocol (MCP) adalah protokol yang digunakan oleh Cursor untuk berkomunikasi dengan model bahasa eksternal. Dengan membuat server MCP Anda sendiri, Anda dapat mengintegrasikan model bahasa kustom Anda ke dalam Cursor dan memanfaatkan fitur-fitur seperti penyelesaian kode, pembuatan kode, dan obrolan. **Prasyarat** * **Pengetahuan Pemrograman:** Anda perlu memiliki pemahaman dasar tentang pemrograman, idealnya dengan Python, karena contoh implementasi akan menggunakan Python. * **Model Bahasa:** Anda harus memiliki model bahasa yang ingin Anda integrasikan. Ini bisa berupa model yang Anda latih sendiri atau model yang tersedia secara komersial. * **Python (Disarankan):** Python adalah bahasa yang populer untuk pengembangan server MCP karena kemudahan penggunaannya dan ketersediaan pustaka yang relevan. * **Pustaka:** Anda mungkin memerlukan pustaka seperti `Flask` atau `FastAPI` untuk membuat server web, dan pustaka untuk berinteraksi dengan model bahasa Anda (misalnya, `transformers` untuk model berbasis Transformer). **Langkah-langkah Implementasi** 1. **Definisikan Endpoint MCP:** * MCP menggunakan serangkaian endpoint HTTP untuk berkomunikasi. Endpoint yang paling penting adalah: * `/`: Endpoint dasar untuk pemeriksaan kesehatan. Server harus merespons dengan kode status 200 OK. * `/completion`: Endpoint untuk meminta penyelesaian kode. * `/chat`: Endpoint untuk meminta respons obrolan. * `/health`: Endpoint untuk pemeriksaan kesehatan yang lebih rinci. 2. **Buat Server Web:** * Gunakan kerangka kerja web seperti Flask atau FastAPI untuk membuat server web yang akan menangani permintaan MCP. * Contoh menggunakan Flask: ```python from flask import Flask, request, jsonify import json app = Flask(__name__) @app.route('/', methods=['GET']) def health_check(): return "OK", 200 @app.route('/health', methods=['GET']) def detailed_health_check(): # Tambahkan logika untuk memeriksa kesehatan model Anda di sini return jsonify({"status": "OK", "model_status": "running"}), 200 @app.route('/completion', methods=['POST']) def completion(): data = request.get_json() prompt = data.get('prompt') # Panggil model bahasa Anda untuk menghasilkan penyelesaian completion_result = generate_completion(prompt) return jsonify({"completion": completion_result}), 200 @app.route('/chat', methods=['POST']) def chat(): data = request.get_json() message = data.get('message') # Panggil model bahasa Anda untuk menghasilkan respons obrolan chat_response = generate_chat_response(message) return jsonify({"response": chat_response}), 200 def generate_completion(prompt): # Implementasikan logika untuk memanggil model bahasa Anda # dan menghasilkan penyelesaian berdasarkan prompt # Contoh (gunakan pustaka transformers): # from transformers import pipeline # generator = pipeline('text-generation', model='your_model') # completion = generator(prompt, max_length=50)[0]['generated_text'] # return completion return "Penyelesaian placeholder" def generate_chat_response(message): # Implementasikan logika untuk memanggil model bahasa Anda # dan menghasilkan respons obrolan berdasarkan pesan return "Respons obrolan placeholder" if __name__ == '__main__': app.run(debug=True, host='0.0.0.0', port=5000) ``` 3. **Implementasikan Logika Model Bahasa:** * Di dalam fungsi `generate_completion` dan `generate_chat_response`, Anda perlu mengintegrasikan model bahasa Anda. * Ini mungkin melibatkan pemuatan model, pra-pemrosesan input, meneruskan input ke model, dan memproses output. * Gunakan pustaka yang sesuai untuk model bahasa Anda. 4. **Tangani Permintaan dan Respons MCP:** * Pastikan server Anda dapat menerima permintaan POST dengan data JSON dan mengembalikan respons JSON yang sesuai. * Format permintaan dan respons harus sesuai dengan spesifikasi MCP. Lihat dokumentasi Cursor untuk detailnya. 5. **Konfigurasi Cursor:** * Di Cursor, Anda perlu mengonfigurasi untuk menggunakan server MCP Anda. * Ini biasanya melibatkan pengaturan URL server MCP di pengaturan Cursor. 6. **Uji Server MCP Anda:** * Setelah server MCP Anda berjalan, Anda dapat mengujinya dengan mengirimkan permintaan HTTP langsung ke endpoint atau dengan menggunakan Cursor. * Periksa log server untuk kesalahan atau masalah. **Detail Tambahan dan Pertimbangan** * **Keamanan:** Jika server MCP Anda akan diakses melalui jaringan, pastikan untuk menerapkan langkah-langkah keamanan yang sesuai, seperti autentikasi dan otorisasi. * **Skalabilitas:** Jika Anda mengharapkan volume permintaan yang tinggi, pertimbangkan untuk menggunakan arsitektur yang dapat diskalakan, seperti menggunakan load balancer dan beberapa instans server MCP. * **Penanganan Kesalahan:** Implementasikan penanganan kesalahan yang kuat untuk menangani kesalahan yang mungkin terjadi selama pemrosesan permintaan. * **Logging:** Gunakan logging untuk mencatat permintaan, respons, dan kesalahan untuk tujuan debugging dan pemantauan. * **Dokumentasi:** Dokumentasikan API MCP Anda dengan jelas untuk memudahkan pengguna lain untuk mengintegrasikan model bahasa mereka. * **Format Data:** Perhatikan format data yang diharapkan oleh Cursor dan format data yang dihasilkan oleh model Anda. Anda mungkin perlu melakukan konversi data. * **Latensi:** Usahakan untuk meminimalkan latensi respons dari server MCP Anda. Cursor akan memberikan pengalaman pengguna yang lebih baik jika respons cepat. Pertimbangkan untuk menggunakan teknik caching atau optimasi model. **Contoh Permintaan dan Respons MCP** * **Permintaan `/completion`:** ```json { "prompt": "def hello_world():\n " } ``` * **Respons `/completion`:** ```json { "completion": "print(\"Hello, world!\")" } ``` * **Permintaan `/chat`:** ```json { "message": "Write a function to calculate the factorial of a number." } ``` * **Respons `/chat`:** ```json { "response": "```python\ndef factorial(n):\n if n == 0:\n return 1\n else:\n return n * factorial(n-1)\n```" } ``` **Kesimpulan** Membuat server MCP Anda sendiri memungkinkan Anda untuk mengintegrasikan model bahasa kustom Anda ke dalam Cursor dan memanfaatkan fitur-fitur canggihnya. Dengan mengikuti panduan ini dan mengimplementasikan langkah-langkah yang diperlukan, Anda dapat membuat server MCP yang berfungsi dan mengintegrasikannya dengan Cursor. Ingatlah untuk mempertimbangkan keamanan, skalabilitas, dan penanganan kesalahan saat mengembangkan server Anda. Selalu rujuk ke dokumentasi Cursor untuk spesifikasi MCP terbaru.

yunxin-mcp-server

yunxin-mcp-server

Weather-server MCP Server

A TypeScript-based MCP server that provides weather information through resources and tools, allowing users to access current weather data and forecast predictions for different cities.

My Awesome MCP

A basic MCP server built with FastMCP framework that provides example tools including message echoing and server information retrieval. Supports both stdio and HTTP transports with Docker deployment capabilities.

PostgreSQL MCP Server by CData

PostgreSQL MCP Server by CData

TaskFlow MCP

A task management server that helps AI assistants break down user requests into manageable tasks and track their completion with user approval steps.

MCP Toolkit

A modular toolkit for building extensible tool services that fully supports the MCP 2024-11-05 specification, offering file operations, terminal execution, and network requests.

Deep Research MCP

A Model Context Protocol compliant server that facilitates comprehensive web research by utilizing Tavily's Search and Crawl APIs to gather and structure data for high-quality markdown document creation.

PostgreSQL MCP Server

Enables direct execution of PostgreSQL queries through the Model Context Protocol. Supports both SELECT and non-SELECT operations with dual communication modes (stdio and HTTP REST API).

ExecuteAutomation Database Server

A Model Context Protocol server that enables LLMs like Claude to interact with SQLite and SQL Server databases, allowing for schema inspection and SQL query execution.

Cline Code Nexus

Sebuah repositori pengujian yang dibuat oleh Cline untuk memverifikasi fungsionalitas server MCP.

Kaspersky OpenTIP MCP Server

Kaspersky OpenTIP Model Context Protocol Server. This server gives access to Kaspersky OpenTIP API to agentic applications.

Shopify MCP Server

Enables interaction with Shopify store data through GraphQL API, providing tools for managing products, customers, orders, blogs, and articles.

College Basketball Stats MCP Server

An MCP server for accessing college basketball statistics through the SportsData.io CBB v3 Stats API, enabling AI agents to retrieve and analyze college basketball data through natural language interactions.

Saros MCP Server

Enables AI agents to interact with Saros DeFi through natural language, providing tools for liquidity pool management, portfolio analytics, farming positions, and swap quotes on Solana.

mcp_server

Okay, here's a basic outline and example code snippets to guide you in implementing a sample MCP (Media Control Protocol) server using a Dolphin MCP client. This will be a simplified example to illustrate the core concepts. **Understanding the Components** * **MCP (Media Control Protocol):** A protocol for controlling media playback devices. It defines commands like play, pause, stop, seek, and volume control. * **Dolphin MCP Client:** A library or tool (presumably you have access to this) that acts as the client in the MCP communication. It sends commands to the MCP server. * **MCP Server:** The application you'll build. It listens for MCP commands from the Dolphin MCP client, interprets them, and then performs the corresponding actions (e.g., controlling a media player). **High-Level Steps** 1. **Choose a Programming Language and Framework:** Python is a good choice for its simplicity and networking libraries. You could use the `socket` module directly or a framework like `asyncio` for asynchronous handling. 2. **Set up a Socket Server:** Create a socket server that listens on a specific port (e.g., 5000). This server will accept connections from the Dolphin MCP client. 3. **Receive and Parse MCP Commands:** When a client connects, receive data from the socket. This data will be the MCP command. You'll need to parse the command string to determine the action to perform. 4. **Implement Command Handlers:** Create functions or methods to handle each MCP command (e.g., `handle_play()`, `handle_pause()`, `handle_seek()`). These handlers will interact with your media player (or a simulated media player for testing). 5. **Send Responses (Optional):** The MCP protocol may define response messages. You can send acknowledgements or status updates back to the client. 6. **Error Handling:** Implement error handling to gracefully deal with invalid commands, network issues, and other potential problems. **Python Example (using `socket` module)** ```python import socket import threading HOST = '127.0.0.1' # Loopback address (localhost) PORT = 5000 # Port to listen on # Simulated Media Player (replace with actual media player control) class MediaPlayer: def __init__(self): self.playing = False self.position = 0 # in seconds self.volume = 100 def play(self): print("Playing...") self.playing = True def pause(self): print("Pausing...") self.playing = False def stop(self): print("Stopping...") self.playing = False self.position = 0 def seek(self, position): print(f"Seeking to {position} seconds...") self.position = position def set_volume(self, volume): print(f"Setting volume to {volume}%") self.volume = volume media_player = MediaPlayer() # Create an instance of the media player def handle_client(conn, addr): print(f"Connected by {addr}") try: while True: data = conn.recv(1024) # Receive up to 1024 bytes if not data: break command = data.decode('utf-8').strip() # Decode and remove whitespace print(f"Received command: {command}") # Parse the command (very basic example) parts = command.split() action = parts[0].lower() if action == "play": media_player.play() conn.sendall(b"OK\n") # Send a simple acknowledgement elif action == "pause": media_player.pause() conn.sendall(b"OK\n") elif action == "stop": media_player.stop() conn.sendall(b"OK\n") elif action == "seek": try: position = int(parts[1]) media_player.seek(position) conn.sendall(b"OK\n") except (IndexError, ValueError): conn.sendall(b"ERROR: Invalid seek command\n") elif action == "volume": try: volume = int(parts[1]) media_player.set_volume(volume) conn.sendall(b"OK\n") except (IndexError, ValueError): conn.sendall(b"ERROR: Invalid volume command\n") else: print(f"Unknown command: {command}") conn.sendall(b"ERROR: Unknown command\n") except Exception as e: print(f"Error handling client: {e}") finally: conn.close() print(f"Connection closed with {addr}") def main(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Listening on {HOST}:{PORT}") while True: conn, addr = s.accept() thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.start() if __name__ == "__main__": main() ``` **Explanation:** 1. **Imports:** Imports the necessary modules (`socket` for networking, `threading` for handling multiple clients concurrently). 2. **Constants:** Defines the host and port for the server. 3. **`MediaPlayer` Class:** A simple class to simulate a media player. Replace the placeholder methods with actual media player control code (e.g., using a library like `vlc` or `pygame`). 4. **`handle_client(conn, addr)` Function:** * This function is executed in a separate thread for each client connection. * It receives data from the client using `conn.recv(1024)`. * It decodes the data (assuming UTF-8 encoding) and removes leading/trailing whitespace. * It parses the command string (very basic splitting on spaces). **Important:** A real MCP implementation would likely have a more robust parsing mechanism. * It calls the appropriate `media_player` methods based on the command. * It sends a simple "OK" or "ERROR" response back to the client. * It includes error handling to catch exceptions. * It closes the connection when the client disconnects or an error occurs. 5. **`main()` Function:** * Creates a socket object using `socket.socket(socket.AF_INET, socket.SOCK_STREAM)`. * Binds the socket to the specified host and port using `s.bind((HOST, PORT))`. * Starts listening for incoming connections using `s.listen()`. * Enters a loop that accepts incoming connections using `s.accept()`. * For each connection, it creates a new thread to handle the client using `threading.Thread(target=handle_client, args=(conn, addr))`. * Starts the thread using `thread.start()`. 6. **`if __name__ == "__main__":`:** Ensures that the `main()` function is only executed when the script is run directly (not when it's imported as a module). **How to Run:** 1. Save the code as a Python file (e.g., `mcp_server.py`). 2. Run the script from your terminal: `python mcp_server.py` 3. Use the Dolphin MCP client to connect to `127.0.0.1` on port `5000`. 4. Send MCP commands like "play", "pause", "stop", "seek 10", "volume 50". Observe the output in the server's terminal. **Important Considerations and Improvements:** * **MCP Protocol Specification:** You *must* have the full specification for the MCP protocol you're using. This example is a very simplified approximation. The specification will define the exact command formats, data types, and response codes. * **Robust Command Parsing:** Use a more robust parsing method (e.g., regular expressions, a dedicated parsing library) to handle complex command formats and arguments. * **Error Handling:** Implement comprehensive error handling to catch invalid commands, network errors, and other potential issues. Provide informative error messages to the client. * **Asynchronous I/O:** For a more scalable server, consider using `asyncio` for asynchronous I/O. This allows the server to handle multiple clients concurrently without using threads. * **Media Player Integration:** Replace the `MediaPlayer` class with actual code to control your media player. You might need to use a library specific to your media player (e.g., `vlc`, `pygame`, or a media player's API). * **Security:** If the MCP server will be exposed to a network, consider security implications and implement appropriate security measures (e.g., authentication, authorization, encryption). * **Threading vs. Asynchronous:** For a small number of clients, threading might be sufficient. For a larger number of clients, asynchronous I/O is generally more efficient. * **Dolphin MCP Client Documentation:** Refer to the Dolphin MCP client's documentation for details on how to connect to the server and send commands. **Example Commands from Dolphin MCP Client:** Assuming the Dolphin MCP client sends commands as simple text strings: * `PLAY` * `PAUSE` * `STOP` * `SEEK 60` (Seek to 60 seconds) * `VOLUME 75` (Set volume to 75%) **Indonesian Translation of Key Concepts:** * **MCP (Media Control Protocol):** Protokol Kontrol Media * **Dolphin MCP Client:** Klien Dolphin MCP * **MCP Server:** Server MCP * **Socket:** Soket * **Command:** Perintah * **Parse:** Mengurai (or Memproses) * **Handler:** Penangan * **Response:** Respon * **Error Handling:** Penanganan Kesalahan * **Media Player:** Pemutar Media * **Thread:** Utas (or Alur) * **Asynchronous I/O:** I/O Asinkron This detailed explanation and code example should give you a solid starting point for implementing your MCP server. Remember to adapt the code to your specific needs and the requirements of the Dolphin MCP client and the MCP protocol you're using. Good luck!

amap-weather-server

Server cuaca amap dengan MCP

mcp-trigger

Here are a few possible translations, depending on what you mean by "mcp server for trigger": **If you're talking about a server that *uses* MCP (Minecraft Coder Pack) to *trigger* something (like an event or action):** * **Server MCP untuk pemicu:** This is a direct translation and is understandable. * **Server yang menggunakan MCP untuk memicu [sesuatu]:** This is more descriptive and allows you to specify what is being triggered. For example: "Server yang menggunakan MCP untuk memicu event." (Server that uses MCP to trigger an event.) **If you're talking about a server *specifically designed* to *trigger* something using MCP:** * **Server MCP untuk memicu aksi/kejadian:** This implies the server's primary purpose is triggering actions or events. * **Server yang dirancang untuk memicu [sesuatu] menggunakan MCP:** This is a more formal and precise translation. For example: "Server yang dirancang untuk memicu perintah menggunakan MCP." (Server designed to trigger commands using MCP.) **If you're talking about a server that *triggers* something *related to* MCP (like updating it or running a script):** * **Server untuk memicu [sesuatu] terkait MCP:** This is a more general translation. For example: "Server untuk memicu pembaruan MCP." (Server to trigger MCP updates.) **In summary, the best translation depends on the context. Here are the most likely options:** * **General:** Server MCP untuk pemicu * **More descriptive:** Server yang menggunakan MCP untuk memicu [sesuatu] * **Designed for triggering:** Server MCP untuk memicu aksi/kejadian To give you the *best* translation, please provide more context about what you mean by "mcp server for trigger." What is the server doing? What is being triggered?

Jokes MCP Server

An MCP server that allows Microsoft Copilot Studio to fetch random jokes from three sources: Chuck Norris jokes, Dad jokes, and Yo Mama jokes.

Ghost MCP Server

Manage your Ghost blog content directly from Claude, Cursor, or any MCP-compatible client, allowing you to create, edit, search, and delete posts with support for tag management and analytics.

DeepChat 好用的图像 MCP Server 集合

Sebuah server MCP gambar untuk DeepChat.

Slack MCP Server

A FastMCP-based server that provides complete Slack integration for Cursor IDE, allowing users to interact with Slack API features using natural language.

Python MCP Sandbox

An interactive Python code execution environment that allows users and LLMs to safely execute Python code and install packages in isolated Docker containers.

Form.io MCP Server

Enables AI assistants to interact with Form.io's API to create, read, update, and manage forms using natural language. Includes safety guardrails to protect existing forms and supports real-time form previews.

Ares DevOps MCP Server

An MCP server that provides seamless interaction with Azure DevOps Git repositories, enabling users to manage repositories, branches, pull requests, and pipelines through natural language.

Guardian News MCP Server

Enables users to search for the latest news articles from The Guardian using keywords and check service status. Provides access to Guardian's news content through their API with configurable result limits.

Marketstack MCP Server

Exposes various Marketstack API endpoints as MCP tools, providing access to financial market data including EOD, intraday, splits, dividends, tickers, exchanges, and other financial information.