Discover Awesome MCP Servers

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.

pyNastran MCP Server

An MCP server that enables AI agents to interact with Nastran FEA models by reading, writing, and analyzing BDF and OP2 files. It provides tools for mesh quality assessment, geometric analysis, and automated report generation for structural engineering workflows.

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.

DeepChat 好用的图像 MCP Server 集合

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

Baby-SkyNet

Provides Claude AI with persistent, searchable memory management across sessions using SQL database, semantic analysis with multi-provider LLM support (Anthropic/Ollama), vector search via ChromaDB, and graph-based knowledge relationships through Neo4j integration.

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.

MolTrust

MolTrust MCP Server provides AI agents with identity verification, reputation scoring, and verifiable credentials through W3C DID-based trust infrastructure. Includes ERC-8004 on-chain agent registration and Base blockchain anchoring for tamper-proof credential verification.

Usher MCP

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

Nano Banana

Generate, edit, and restore images using natural language prompts through the Gemini 2.5 Flash image model. Supports creating app icons, seamless patterns, visual stories, and technical diagrams with smart file management.

NHN Server MCP

Enables secure SSH access to servers through a gateway with Kerberos authentication, allowing execution of whitelisted commands with pattern-based security controls and server information retrieval.

amap-weather-server

Máy chủ amap-weather với MCP

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

mcp-gsheets

mcp-gsheets

Remote MCP Server

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

Transmission MCP Server

Provides tools for interacting with the Transmission BitTorrent client via natural language, enabling users to manage torrents, configure download settings, and monitor download activity.

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.

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.

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.

Android Tester MCP

An MCP server for automating virtual or physical Android devices using the Gbox SDK. It enables users to manage app installations, capture screenshots, and perform complex UI actions through natural language instructions.

Kintone Book Management MCP Tool

A Model Context Protocol (MCP) server that provides a tool for retrieving and managing book information from a Kintone database application.

MusicMCP.AI

Enables AI-powered music generation through natural language commands, supporting both inspiration mode (AI-generated lyrics and style) and custom mode (user-provided lyrics and parameters) to create songs with direct download links.

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.

MCP OpenAPI Connector

Enables Claude Desktop and other MCP clients to interact with any OAuth2-authenticated OpenAPI-based API through automatic tool generation from OpenAPI specifications, with built-in token management and authentication handling.

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

A Model Context Protocol (MCP) server that allows AI assistants like Claude to interact with Go's Language Server Protocol (LSP) and benefit from advanced Go code analysis features.

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.

Jina AI Remote MCP Server

Provides web content extraction, search capabilities (web, arXiv, SSRN, images), semantic deduplication, and reranking through Jina AI's Reader, Embeddings, and Reranker APIs.

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

Một kho lưu trữ thử nghiệm được tạo bởi Cline để xác minh chức năng của máy chủ MCP.