Discover Awesome MCP Servers

MCP Linear

A Model Context Protocol server that enables AI assistants to interact with Linear project management systems, allowing users to create, update, and manage issues, projects, teams, and comments through natural language.

QuantConnect MCP Server

Enables AI assistants to interact with the QuantConnect cloud platform for algorithmic trading. Supports creating and managing trading strategies, running backtests, deploying live algorithms, and performing comprehensive trading operations through the QuantConnect API.

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.

Hi-GCloud

Enables interaction with Google Cloud Platform services through gcloud CLI, supporting operations like querying logs, checking Cloud Run status, managing secrets, executing Cloud SQL queries, and monitoring billing information.

Lifetechia Mcp Server

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

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.

MCP-Server-MySSL

MySSL MCPサーバー (MySSL MCP sābā)

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!

Playwright MCP

A Model Context Protocol server that provides browser automation capabilities using Playwright, enabling LLMs to interact with web pages through structured accessibility snapshots without requiring screenshots or visually-tuned models.

StarTree MCP Server for Apache Pinot

StarTree MCP Server for Apache Pinot

Owner avatar beijing-car-quota-draw

Owner avatar beijing-car-quota-draw

amap-weather-server

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

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.

Usher MCP

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

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.

HiveFlow MCP Server

Connects AI assistants (Claude, Cursor, etc.) directly to the HiveFlow automation platform, allowing them to create, manage, and execute automation flows through natural language commands.

mcp-trigger

トリガー用のMCPサーバー

DeepChat 好用的图像 MCP Server 集合

DeepChat用の画像MCPサーバー

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.

SSH MCP Server

Enables managing Ubuntu/Linux servers through natural language by establishing SSH connections and executing remote commands. Supports real-time command execution and output through Claude Desktop or Cursor IDE.

Amazon Q Custom Prompt MCP Server

Provides custom prompts for Amazon Q by serving markdown files from the local filesystem as prompt templates through the Model Context Protocol.

Palo Alto MCP Server

Enables interaction with Palo Alto Networks APIs through a Model Context Protocol server. Generated using Postman MCP Generator, it provides automated tools for managing Palo Alto services through natural language commands.

Knowledge Base MCP Server

Enables AI assistants to manage a personal markdown-based knowledge base with natural language interactions. Supports creating, searching, updating, and organizing notes across categories like people, recipes, meetings, and procedures.

HTTP OAuth MCP Server

A reference implementation for creating an MCP server supporting Streamable HTTP & SSE Transports with OAuth authorization, allowing developers to build OAuth-authorized MCP servers with minimal configuration.

Remote MCP Server

A Cloudflare Workers-based deployment that implements the Model Context Protocol, allowing AI models to use custom tools without authentication.

Local Documents MCP Server

A Model Context Protocol server that allows AI assistants to discover, load, and process local documents on Windows systems, with support for multiple file formats and OCR capabilities for scanned PDFs.

Personal JIRA MCP

An MCP server that enables AI assistants to interact with JIRA, allowing for querying issue details, creating and updating work items, and managing attachments through a standardized interface.