Discover Awesome MCP Servers

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.

Usher MCP

Enables users to search and view detailed movie information from TMDB, including cast, ratings, and showtimes, through an interactive widget interface.

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.

mcp_server

Okay, I understand. You want guidance on implementing a sample MCP (Management Control Protocol) server that can interact with a Dolphin MCP client. Here's a breakdown of the steps involved, along with code snippets and explanations to get you started. Keep in mind this is a simplified example and you'll need to adapt it to your specific needs and the full Dolphin MCP specification. **1. Understanding the Basics** * **MCP (Management Control Protocol):** A protocol used for managing and controlling devices or applications. It typically involves a client (the Dolphin MCP client in your case) sending commands to a server, and the server responding with status updates or data. * **Dolphin MCP Client:** This is the client application that will be sending requests to your server. You'll need to understand the specific commands and data formats that the Dolphin MCP client uses. **Crucially, you need the Dolphin MCP client's documentation or API specification.** Without that, you're essentially guessing. * **Server Implementation:** You'll need to choose a programming language and framework to build your server. Common choices include Python, Java, Go, or C++. I'll provide examples in Python because it's relatively easy to read and prototype with. * **Communication:** MCP often uses TCP/IP sockets for communication. Your server will need to listen on a specific port for incoming connections from the Dolphin MCP client. **2. Key Steps** 1. **Define the MCP Protocol (Based on Dolphin MCP Client Documentation):** * **Commands:** List the commands the Dolphin MCP client will send (e.g., `GET_STATUS`, `SET_VALUE`, `REBOOT`). * **Data Formats:** Determine the format of the data exchanged (e.g., plain text, JSON, XML, binary). This is *critical*. If the Dolphin client expects JSON, you *must* send JSON. * **Error Handling:** Define how the server will report errors to the client. 2. **Set up a TCP Socket Server:** * Create a socket that listens on a specific port. * Accept incoming connections from clients. 3. **Receive and Parse Client Requests:** * Read data from the socket. * Parse the data to identify the MCP command and any associated parameters. 4. **Process the Command:** * Implement the logic to handle each MCP command. This might involve reading data from a database, controlling hardware, or performing other actions. 5. **Send a Response:** * Format a response according to the MCP protocol. * Send the response back to the client over the socket. 6. **Error Handling:** * Implement error handling to catch exceptions and send appropriate error responses to the client. **3. Python Example (Simplified)** ```python import socket import threading import json # For JSON data format (if used) # Configuration HOST = '127.0.0.1' # Listen on localhost PORT = 12345 # Choose a port # Sample MCP Commands (Adapt to Dolphin MCP Client's commands!) CMD_GET_STATUS = "GET_STATUS" CMD_SET_VALUE = "SET_VALUE" CMD_REBOOT = "REBOOT" # Sample Data (Replace with your actual data) device_status = "OK" device_value = 50 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 message = data.decode('utf-8').strip() # Decode the message print(f"Received: {message}") # **Crucially, parse the message based on the Dolphin MCP client's format.** # This is a very basic example. You'll likely need a more robust parser. parts = message.split() command = parts[0] if command == CMD_GET_STATUS: response = f"STATUS: {device_status}\n" # Simple text response conn.sendall(response.encode('utf-8')) elif command == CMD_SET_VALUE: try: new_value = int(parts[1]) device_value = new_value response = f"VALUE_SET: {device_value}\n" conn.sendall(response.encode('utf-8')) except (IndexError, ValueError): response = "ERROR: Invalid SET_VALUE command\n" conn.sendall(response.encode('utf-8')) elif command == CMD_REBOOT: print("Simulating reboot...") response = "REBOOTING\n" conn.sendall(response.encode('utf-8')) # Add actual reboot logic here (carefully!) else: response = "ERROR: Unknown command\n" conn.sendall(response.encode('utf-8')) except Exception as e: print(f"Error handling client: {e}") finally: conn.close() print(f"Connection closed with {addr}") def main(): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 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 of the Python Code:** * **`import socket, threading, json`:** Imports necessary modules. `socket` for network communication, `threading` for handling multiple clients concurrently, and `json` for handling JSON data (if needed). * **`HOST`, `PORT`:** Defines the IP address and port the server will listen on. * **`CMD_GET_STATUS`, `CMD_SET_VALUE`, `CMD_REBOOT`:** Defines the MCP commands. **Replace these with the actual commands used by the Dolphin MCP client.** * **`device_status`, `device_value`:** Sample data that the server will manage. * **`handle_client(conn, addr)`:** This function handles communication with a single client. * `conn.recv(1024)`: Receives data from the client. * `data.decode('utf-8').strip()`: Decodes the data (assuming UTF-8 encoding) and removes leading/trailing whitespace. * `message.split()`: Splits the message into parts (command and parameters). **This is a very basic parsing method. You'll likely need a more sophisticated parser based on the Dolphin MCP client's data format.** * The `if/elif/else` block handles the different MCP commands. **Implement the actual logic for each command here.** * `conn.sendall(response.encode('utf-8'))`: Sends the response back to the client. * Error handling is included in the `try...except...finally` block. * **`main()`:** * Creates a TCP socket. * Binds the socket to the specified host and port. * Listens for incoming connections. * When a client connects, it creates a new thread to handle the client. **Important Considerations and Next Steps:** 1. **Dolphin MCP Client Documentation is Essential:** You *must* have the documentation for the Dolphin MCP client to understand the protocol it uses. This is the most important step. Contact the vendor or developer of the Dolphin MCP client to obtain this documentation. 2. **Data Format:** Determine the data format used by the Dolphin MCP client (e.g., JSON, XML, plain text, binary). Adjust the parsing and response formatting in the code accordingly. If it's JSON, use the `json` module to encode and decode data. 3. **Error Handling:** Implement robust error handling to catch exceptions and send appropriate error responses to the client. 4. **Security:** If the MCP protocol is used over a network, consider security implications. You might need to implement authentication and encryption. 5. **Scalability:** If you need to handle a large number of clients, consider using a more scalable architecture, such as asynchronous I/O (e.g., using `asyncio` in Python). 6. **Testing:** Thoroughly test your server with the Dolphin MCP client to ensure that it works correctly. **Example with JSON (if the Dolphin MCP client uses JSON):** ```python import socket import threading import json # ... (HOST, PORT, etc. as before) def handle_client(conn, addr): print(f"Connected by {addr}") try: while True: data = conn.recv(1024) if not data: break message = data.decode('utf-8').strip() print(f"Received: {message}") try: request = json.loads(message) # Parse JSON command = request.get("command") params = request.get("params", {}) # Get parameters (optional) if command == "GET_STATUS": response_data = {"status": device_status} response = json.dumps(response_data) + "\n" conn.sendall(response.encode('utf-8')) elif command == "SET_VALUE": try: new_value = int(params.get("value")) device_value = new_value response_data = {"result": "VALUE_SET", "value": device_value} response = json.dumps(response_data) + "\n" conn.sendall(response.encode('utf-8')) except (KeyError, ValueError): response_data = {"error": "Invalid SET_VALUE command"} response = json.dumps(response_data) + "\n" conn.sendall(response.encode('utf-8')) # ... (other commands) else: response_data = {"error": "Unknown command"} response = json.dumps(response_data) + "\n" conn.sendall(response.encode('utf-8')) except json.JSONDecodeError: response_data = {"error": "Invalid JSON format"} response = json.dumps(response_data) + "\n" conn.sendall(response.encode('utf-8')) except Exception as e: print(f"Error handling client: {e}") finally: conn.close() print(f"Connection closed with {addr}") # ... (main() function as before) ``` **Key changes in the JSON example:** * `json.loads(message)`: Parses the incoming message as JSON. * `request.get("command")`: Extracts the command from the JSON object. * `params = request.get("params", {})`: Extracts the parameters (if any) from the JSON object. The `{}` provides a default empty dictionary if the "params" key is missing. * `json.dumps(response_data)`: Converts the response data to a JSON string. * `json.JSONDecodeError`: Handles errors if the incoming message is not valid JSON. **In summary, the most important thing is to get the Dolphin MCP client's documentation and understand the protocol it uses. Then, adapt the code examples above to match the specific requirements of the protocol.**

DeepChat 好用的图像 MCP Server 集合

Một máy chủ MCP hình ảnh cho DeepChat

StarTree MCP Server for Apache Pinot

StarTree MCP Server for Apache Pinot

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.

Google Calendar MCP Server

Enables natural language queries to Google Calendar API for checking appointments, availability, and events. Supports flexible time ranges, timezone handling, and both service account and OAuth authentication methods.

MCP Redirect Server

A Model Context Protocol server built with NestJS that provides OAuth 2.1 authentication with GitHub and exposes MCP tools through Server-Sent Events transport. Enables secure, real-time communication with JWT-based protection and dependency injection.

ikaliMCP Server

Provides a secure interface for AI assistants to interact with penetration testing tools like nmap, hydra, sqlmap, and nikto for educational cybersecurity purposes. Includes input sanitization and runs in a Docker container with Kali Linux tools for authorized testing scenarios.

Remote MCP Server

A server that implements the Model Context Protocol (MCP) on Cloudflare Workers, allowing AI models to access custom tools without authentication.

mcp-gsheets

mcp-gsheets

Bitso MCP Server

Enables interaction with the Bitso cryptocurrency exchange API to access withdrawals and fundings data. Provides comprehensive tools for listing, filtering, and retrieving withdrawal and funding transactions with proper authentication and error handling.

IntelliPlan

IntelliPlan

mcp-sse-server-demo

Demo máy chủ MCP SSE

MCP Code Assistant

Provides file operations (read/write) with an extensible architecture designed for future C code compilation and executable execution capabilities.

Fortune MCP Server

Enables users to perform tarot card readings and generate horoscopes based on specified dates, times, and locations. Provides mystical divination services through tarot draws and astrological calculations.

Salesforce DX MCP Server

Enables secure interaction with Salesforce orgs through LLMs, providing tools for managing orgs, querying data, deploying metadata, running tests, and performing code analysis. Features granular access control and uses encrypted auth files to avoid exposing secrets in plain text.

Planning Center Online API and MCP Server Integration

Máy chủ MCP của Planning Center Online

Reddit User MCP Server

Enables interaction with Reddit through a Reddable account, allowing users to fetch posts and comments, reply to discussions, and manage comment visibility using secure API key authentication.

AskTheApi Team Builder

Trình xây dựng mạng lưới đại diện (agent) để giao tiếp với các API OpenAPI, dựa trên AutoGen.

Netlify MCP Server

Follows the Model Context Protocol to enable code agents to use Netlify API and CLI, allowing them to create, deploy, and manage Netlify resources using natural language prompts.

MonteWalk

Provides AI agents with institutional-grade quantitative finance tools including real-time market data, paper trading via Alpaca, risk analysis with Monte Carlo simulations, backtesting, and multi-source news sentiment analysis for portfolio management and trading strategy development.

USolver

A best-effort universal logic and numerical solver interface using MCP that implements the 'LLM sandwich' model to process queries, call dedicated solvers (ortools, cvxpy, z3), and verbalize results.

Skyforge MCP Server

Connects AI assistants to SkySpark and Haxall building automation systems by dynamically exposing SkySpark Axon functions as MCP tools. Enables natural language interaction with building data, equipment, and automation functions through real-time tool discovery.

MCP PDF Reader

Intelligent PDF processing server that automatically detects PDF types (text or scanned), extracts text, performs OCR recognition in 10 languages, searches content with regex support, and retrieves metadata through the Model Context Protocol.

Dual MCP Server for IoT & Memory

Provides two Model Context Protocol servers that enable controlling IoT devices and managing persistent memory storage with semantic search capabilities.