Discover Awesome MCP Servers

DeepChat 好用的图像 MCP Server 集合

DeepChat用の画像MCPサーバー

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.

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

MCP を使用した amap-weather サーバー

mcp_server

Okay, I understand. You want guidance on implementing a sample `mcp_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. This will be a simplified example, focusing on the core concepts. **1. Understanding the MCP Protocol (Simplified)** * **MCP (Microcontroller Protocol):** A lightweight protocol for communication between a host (your `dolphin_mcp` client) and a microcontroller (your `mcp_server`). It's often used for things like reading sensor data, controlling actuators, and configuring settings. * **Request-Response:** The client sends a request to the server, and the server sends back a response. * **Commands/Opcodes:** Requests are identified by a command code (or opcode). Each command tells the server what action to perform. * **Data:** Requests and responses can include data. For example, a request to set a motor speed might include the desired speed value. A response to a sensor read request would include the sensor reading. * **Framing:** The protocol needs a way to know where a message starts and ends. Common methods include: * **Length-Prefixed:** The message starts with a byte or two indicating the total length of the message. * **Start/End Markers:** Special characters (e.g., `0x02` for start, `0x03` for end) are used to delimit messages. * **Fixed Length:** All messages are the same length. **2. Choosing a Communication Method** The `mcp_server` needs to communicate with the `dolphin_mcp` client. Common options include: * **Serial (UART):** Simple, widely supported, good for basic communication. Often used with microcontrollers. * **TCP/IP (Sockets):** More complex, but allows communication over a network. Suitable if the client and server are on different machines. * **USB:** Can be used for higher bandwidth communication. For this example, I'll focus on **Serial (UART)** because it's the most common and easiest to demonstrate. **3. Server Implementation (Python Example)** Here's a Python example using the `pyserial` library to simulate an `mcp_server` communicating over a serial port. This is a *simulation* because you'd typically run this code on a microcontroller. ```python import serial import time # Configuration SERIAL_PORT = 'COM3' # Replace with your serial port BAUD_RATE = 115200 # MCP Command Opcodes (Example) CMD_GET_SENSOR_DATA = 0x01 CMD_SET_LED_STATE = 0x02 CMD_GET_VERSION = 0x03 # MCP Response Codes RESPONSE_OK = 0x00 RESPONSE_ERROR = 0x01 def process_request(request): """Processes an MCP request and returns a response.""" opcode = request[0] # First byte is the opcode if opcode == CMD_GET_SENSOR_DATA: # Simulate reading sensor data sensor_value = 42 # Replace with actual sensor reading response = bytearray([RESPONSE_OK, sensor_value]) return response elif opcode == CMD_SET_LED_STATE: led_state = request[1] # Second byte is the LED state (0 or 1) if led_state == 0: print("LED OFF") elif led_state == 1: print("LED ON") else: return bytearray([RESPONSE_ERROR]) # Invalid LED state response = bytearray([RESPONSE_OK]) return response elif opcode == CMD_GET_VERSION: version = 123 #Simulate version number response = bytearray([RESPONSE_OK, version]) return response else: # Unknown command return bytearray([RESPONSE_ERROR]) def main(): try: ser = serial.Serial(SERIAL_PORT, BAUD_RATE) print(f"Connected to {SERIAL_PORT}") while True: if ser.in_waiting > 0: request = ser.read(ser.in_waiting) # Read all available bytes print(f"Received request: {request.hex()}") response = process_request(request) print(f"Sending response: {response.hex()}") ser.write(response) time.sleep(0.01) # Small delay to avoid busy-waiting except serial.SerialException as e: print(f"Error: {e}") finally: if 'ser' in locals() and ser.is_open: ser.close() print("Serial port closed.") if __name__ == "__main__": main() ``` **Explanation:** * **`serial`:** Imports the `pyserial` library for serial communication. Install it with `pip install pyserial`. * **`SERIAL_PORT` and `BAUD_RATE`:** Configure the serial port and baud rate. **Important:** Make sure these match the settings used by your `dolphin_mcp` client. You'll need to change `COM3` to the correct port on your system. * **`CMD_*` constants:** Define command opcodes. These are just examples; you'll need to define the opcodes that your `dolphin_mcp` client uses. * **`RESPONSE_*` constants:** Define response codes. * **`process_request(request)`:** This function is the heart of the server. It takes the raw request data, parses the opcode, and performs the appropriate action. It then constructs a response and returns it. * **`main()`:** * Opens the serial port. * Enters a loop that continuously checks for incoming data. * If data is available, it reads the request, processes it, and sends the response. * Includes error handling to catch serial port exceptions. * Closes the serial port when the program exits. **4. Dolphin-MCP Client (Example)** I don't have specific details about your `dolphin_mcp` client, but here's a general example of how you might use it to interact with the server above. This assumes your `dolphin_mcp` library has functions for sending requests and receiving responses. ```python # Assuming you have a dolphin_mcp library # import dolphin_mcp # Replace with the actual import # Example usage (replace with your actual dolphin_mcp library calls) def send_get_sensor_data_request(): # Construct the request (opcode only in this case) request = bytearray([CMD_GET_SENSOR_DATA]) # Send the request using dolphin_mcp (replace with actual function) # response = dolphin_mcp.send_request(request) # Simulate sending and receiving print(f"Sending request: {request.hex()}") # Simulate response from server response = bytearray([RESPONSE_OK, 42]) #Simulate response print(f"Received response: {response.hex()}") if response[0] == RESPONSE_OK: sensor_value = response[1] print(f"Sensor value: {sensor_value}") else: print("Error getting sensor data") def send_set_led_state_request(led_state): # Construct the request (opcode and LED state) request = bytearray([CMD_SET_LED_STATE, led_state]) # Send the request using dolphin_mcp (replace with actual function) # response = dolphin_mcp.send_request(request) # Simulate sending and receiving print(f"Sending request: {request.hex()}") response = bytearray([RESPONSE_OK]) #Simulate response print(f"Received response: {response.hex()}") if response[0] == RESPONSE_OK: print("LED state set successfully") else: print("Error setting LED state") def send_get_version_request(): # Construct the request (opcode only in this case) request = bytearray([CMD_GET_VERSION]) # Send the request using dolphin_mcp (replace with actual function) # response = dolphin_mcp.send_request(request) # Simulate sending and receiving print(f"Sending request: {request.hex()}") response = bytearray([RESPONSE_OK, 123]) #Simulate response print(f"Received response: {response.hex()}") if response[0] == RESPONSE_OK: version = response[1] print(f"Version: {version}") else: print("Error getting version") # Example usage send_get_sensor_data_request() send_set_led_state_request(1) # Turn LED on send_set_led_state_request(0) # Turn LED off send_get_version_request() ``` **Important Notes and Next Steps:** 1. **Replace Placeholders:** The `dolphin_mcp` client code is heavily commented with placeholders. You *must* replace these with the actual functions and methods provided by your `dolphin_mcp` library. Consult the library's documentation. 2. **Error Handling:** The examples include basic error handling, but you should add more robust error checking and reporting. 3. **Data Types:** Pay close attention to data types. Make sure the data you're sending and receiving is in the correct format (e.g., integers, floats, strings). Use `struct.pack` and `struct.unpack` in Python to convert between Python data types and byte representations if needed. 4. **Framing:** The example assumes a very simple framing where the server reads all available bytes. If your `dolphin_mcp` client uses a more sophisticated framing method (e.g., length-prefixed messages), you'll need to modify the `process_request` function in the server to handle the framing correctly. For example, if the first byte is the length, you'd read that byte first, then read the remaining bytes based on the length. 5. **Microcontroller Implementation:** The Python server is a simulation. To run this on a real microcontroller, you'll need to use a language like C or C++ and a microcontroller library that provides serial communication functions. The logic for `process_request` would be the same, but the implementation details would be different. 6. **Testing:** Thoroughly test your implementation with different commands and data values to ensure that it's working correctly. Use a serial port monitor (like PuTTY or RealTerm) to inspect the raw data being sent and received. 7. **Dolphin-MCP Documentation:** The most important thing is to consult the documentation for your `dolphin_mcp` library. It will provide the details you need to use the library correctly. **Example with Length-Prefixed Framing (Server-Side)** If your protocol uses length-prefixed framing (the first byte indicates the length of the message *including* the length byte itself), the `process_request` function in the server would need to be modified: ```python def process_request(request): """Processes an MCP request with length-prefixed framing.""" if len(request) < 1: return bytearray([RESPONSE_ERROR]) # Invalid request (no length byte) message_length = request[0] if len(request) < message_length: return bytearray([RESPONSE_ERROR]) # Incomplete request if message_length < 2: #Need at least opcode return bytearray([RESPONSE_ERROR]) #Invalid request opcode = request[1] # Opcode is the second byte data = request[2:message_length] #The rest is data if opcode == CMD_GET_SENSOR_DATA: # Simulate reading sensor data sensor_value = 42 # Replace with actual sensor reading response_data = bytearray([RESPONSE_OK, sensor_value]) response_length = len(response_data) + 1 # +1 for the length byte response = bytearray([response_length]) + response_data return response elif opcode == CMD_SET_LED_STATE: if len(data) != 1: return bytearray([RESPONSE_ERROR]) #Invalid data length led_state = data[0] # Second byte is the LED state (0 or 1) if led_state == 0: print("LED OFF") elif led_state == 1: print("LED ON") else: return bytearray([RESPONSE_ERROR]) # Invalid LED state response_data = bytearray([RESPONSE_OK]) response_length = len(response_data) + 1 response = bytearray([response_length]) + response_data return response elif opcode == CMD_GET_VERSION: version = 123 #Simulate version number response_data = bytearray([RESPONSE_OK, version]) response_length = len(response_data) + 1 response = bytearray([response_length]) + response_data return response else: # Unknown command return bytearray([RESPONSE_ERROR]) ``` In this case, the client would need to construct the request with the length byte at the beginning. For example: ```python # Example of sending a length-prefixed request request_data = bytearray([CMD_SET_LED_STATE, 1]) # Opcode and LED state request_length = len(request_data) + 1 # Length of data + length byte itself request = bytearray([request_length]) + request_data # Now 'request' contains the length-prefixed message ``` Remember to adapt the code to match the specific requirements of your `dolphin_mcp` library and the MCP protocol you're using. Good luck!

Plex MCP Account Finder

Connects to multiple Plex accounts to perform fuzzy searches for users across servers by email, username, or display name, and generates authentication tokens for new account access.

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.

mcp_stdio2sse

Stdio MCP サーバーの SSE バージョン

twitter-voice-mcp

An MCP server that analyzes your unique Twitter voice to generate, manage, and post AI-powered tweets and quote tweet drafts. It supports multiple AI providers and provides tools for draft management, voice profiling, and automated content creation from images.

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.

Kali MCP Server

Provides access to 20+ Kali Linux penetration testing tools through isolated Docker containers, enabling network scanning, vulnerability assessment, password cracking, web security testing, and forensics through natural language commands.

Claude Code AI Collaboration MCP Server

An MCP server that enables multi-provider AI collaboration using models like DeepSeek, OpenAI, and Anthropic through strategies such as parallel execution and consensus building. It provides specialized tools for side-by-side content comparison, quality review, and iterative refinement across different AI providers.

Zendesk MCP Server

Enables AI agents to interact with Zendesk ticket data for customer support analysis and insights. It supports searching tickets by tags or keywords, retrieving ticket details, and analyzing agent performance and service trends.

mcp-server

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.

IntelliPlan

IntelliPlan

mcp-sse-server-demo

MCP SSEサーバーのデモ

Delphi Build MCP Server

Enables AI coding agents to compile Delphi projects programmatically by parsing .dproj files, executing the Delphi compiler, and returning structured error results with multi-language support and automatic configuration generation from IDE build logs.

MCP Code Assistant

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

EduChain MCP Server

Enables the generation of educational content such as multiple choice questions, lesson plans, and flashcards by connecting local Ollama models to Claude. It leverages the Educhain library to provide structured AI-powered learning tools through the Model Context Protocol.

mcp-server-python

鏡 (Kagami)

Terminal MCP

Enables management of visible, interactive terminal sessions across platforms (macOS, Windows, Linux, WSL). Supports creating, executing commands, capturing output, and managing multiple terminal windows simultaneously.

Delia

Routes AI tasks to appropriate local LLM models (quick, coder, MoE, thinking) with automatic model selection, multi-backend support (Ollama, llama.cpp, Gemini), and parallel processing capabilities.

Lifetechia Mcp Server

ライフテクニア MCP サーバー

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.