Discover Awesome MCP Servers

OpenShift LightSpeed MCP Server

Integrates OpenShift LightSpeed with Claude Code to provide AI-powered OpenShift assistance and troubleshooting.

mcp-ad4m

Enables Claude Code with persistent semantic memory, cross-session context, and memory hygiene via a local AD4M executor, offering 13 tools for managing semantic graphs and cross-terminal relay.

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.

swiss-road-mobility-mcp

MCP Server for Swiss road mobility — shared vehicles, EV charging, traffic alerts, Park & Rail, and multimodal trip planning.

DataCite MCP Server

Provides read-only access to DataCite's index of 125M+ research DOIs via natural language queries, enabling searching, metadata retrieval, citation formatting, and relationship exploration.

helloworld-demo-mcp

A minimal MCP server offering a hello_world tool that returns a greeting and current UTC time via streamable HTTP.

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.

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.

mcp-sse-server-demo

MCP SSEサーバーのデモ

mcp-docparser

A lightweight document parser MCP server that enables Claude to parse PDFs, Word, Excel, images (OCR), and other document formats with support for chunking and metadata extraction.

VibeGuard MCP Server

Enables AI coding tools to scan projects for security vulnerabilities, hardcoded secrets, injection flaws, and privacy violations with 699 rules and 76 MCP tools, all running locally with zero telemetry.

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!

Wise MCP Server

Enables access to Wise API functionality for managing recipients and sending money transfers. Supports listing recipients, creating new recipients, validating account details, and executing money transfers with authentication handling.

typescript-mcp-server

A TypeScript boilerplate for building Model Context Protocol (MCP) servers with example tools (calculator, greet) and resources (system info).

MCP Toolkit

A modular toolkit for building extensible tool services that fully supports the MCP 2024-11-05 specification, offering file operations, terminal execution, and network requests.

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.

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

Clineによって作成された、MCPサーバーの機能を検証するためのテストリポジトリです。

Reqable Capture Reader MCP Server

Enables AI assistants to query, filter, and analyze local HTTP capture records and REST API test data from the Reqable tool. It provides read-only access to inspect request/response details, headers, and statistics through natural language.

Proxmox MCP Enhanced

Provides a complete MCP server for managing Proxmox VE infrastructure with 115 specialized tools, enabling AI assistants and automation systems to perform complex virtualization tasks seamlessly.

Neuratel MCP Server

Control your voice AI platform through natural language from any MCP-compatible assistant.

Basic MCP Server

A minimal Model Context Protocol (MCP) server demonstrating the implementation of tools, resources, and prompts. It serves as a starter template built with the Smithery SDK for developing custom integrations.

velesdb-memory

Local-first agent-memory MCP server with a why() tool: recall a fact together with its connected subgraph (multi-hop), so linked memories surface even when they share no words with the query. remember/recall/relate/forget/why over one fused vector + graph + columnar engine a single offline Rust binary.

UniFi Network MCP Server

Enables AI assistants to manage UniFi network infrastructure through 50+ tools covering devices, clients, networks, WiFi, firewall rules, and guest access using the official UniFi Network API.

Windows CLI MCP Server

A Model Context Protocol server that provides secure command-line access to Windows systems, allowing MCP clients like Claude Desktop to safely execute commands in PowerShell, CMD, and Git Bash shells with configurable security controls.

x402-agent-data

Pay-per-call MCP server offering crypto market signals, web page extraction, and GitHub repo auditing, with automatic settlement in USDC via the x402 protocol.

Payments Agent Gateway (MCP)

An MCP server that enables AI agents to safely interact with a double-entry payments ledger, enforcing idempotency, policy-based access control, and human-in-the-loop approval for high-value actions.

Neo4j MCP Server

A Model Context Protocol server that enables running Cypher queries and retrieving schema from Neo4j databases, supporting AI-driven graph exploration and text-to-Cypher workflows.