Discover Awesome MCP Servers

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

Memory MCP

A knowledge-graph-based memory system for AI agents that enables persistent information storage between conversations.

Firebase Management MCP Server

An MCP Server providing access to Google's Firebase API, allowing natural language interaction with Firebase services and resources.

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.

Sauce Labs MCP Server

Enables AI assistants to interact with Sauce Labs testing platform through natural language, providing access to device cloud management, test job analysis, build monitoring, and testing infrastructure insights. Supports both Virtual Device Cloud (VDC) and Real Device Cloud (RDC) with comprehensive test analytics and team collaboration features.

Google Cloud DNS API MCP Server

Auto-generated MCP server that enables interaction with Google's Cloud DNS API for managing DNS zones and records through natural language.

onx-mcp-server

Khám phá giao thức ngữ cảnh mô hình (model context protocol) bằng cách xây dựng một máy chủ MCP.

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.

MCP Vulnerability Management System

Một hệ thống toàn diện giúp các tổ chức theo dõi, quản lý và ứng phó hiệu quả với các lỗ hổng bảo mật thông qua các tính năng như theo dõi lỗ hổng, quản lý người dùng, phiếu hỗ trợ, quản lý khóa API và quản lý chứng chỉ SSL.

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.

HDFS MCP Server

A Model Context Protocol server that enables interaction with Hadoop Distributed File System, allowing operations like listing, reading, writing, and managing HDFS files and directories.

Planning Center Online API and MCP Server Integration

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

Simple MCP Server

A minimalist MCP server that provides a single tool to retrieve a developer name, demonstrating the basic structure for Claude's Model Completion Protocol integration.

mcp_stdio2sse

Phiên bản SSE của các máy chủ Stdio MCP

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.

GoHighLevel MCP Server

Connects Claude Desktop to GoHighLevel CRM with 269+ tools across 19+ categories for complete contact management, messaging, sales pipeline automation, e-commerce operations, and business management through natural language.

ScreenshotOne MCP Server

A simple implementation of an MCP server for the ScreenshotOne API

mcp-server

Bản demo MCP

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.

Bear MCP Server

An MCP server that integrates Bear Note Taking App with Claude Desktop, allowing Claude to read, create, search notes and manage tags directly from Bear.

IntelliPlan

IntelliPlan

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.

Remote MCP Server

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

mediawiki-mcp-server

Model Context Protocol (MCP) server for MediaWiki

Kokkai Minutes MCP Agent

Provides a structured interface to the Japanese National Diet Library's parliamentary proceedings API, allowing AI models to search and retrieve Diet meeting records and speeches.

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.