Discover Awesome MCP Servers

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

Um repositório de teste criado por Cline para verificar a funcionalidade do servidor MCP.

sdwan-netops-public-example

Enables LLMs to create, onboard, and diagnose Cisco SD-WAN branch edges using MCP tools that interact with a FastAPI automation backend, with guardrails for safe operations.

Sean-MCP

A GitHub integration tool that enables MCP clients to manage pull requests through tools for creating, updating, and listing PRs with automated descriptions. It also includes a webhook server for real-time PR updates and a customizable CLI with distinct personality modes.

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.

USDA Nutrition Database MCP Server

Provides intelligent access to the USDA nutrition database through AI assistants, enabling users to search foods, compare nutritional content, find foods high in specific nutrients, and query authoritative nutrition data across 7,146+ food items 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.

adt-mcp

Multi-system MCP server for reading and writing ABAP source via SAP ADT, with write safety controls and a local web admin.

vcenter-mcp

Enables plain English queries about VMware vCenter environments including clusters, VMs, datastores, and more, directly from VS Code via GitHub Copilot.

my-mcp-server

A FastMCP server that wraps a REST API as MCP tools, enabling AI agents to interact with the upstream API.

gdb-mcp

MCP server that wraps gdb to enable LLMs to drive live debugging sessions, including starting sessions on binaries, attaching to processes, and running commands.

sap_analytics_cloud_mcp

Enables interaction with SAP Analytics Cloud through an MCP server, exposing 90 tools for content management, data export/import, user management, and more via natural language.

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.

mcp_server

Okay, I can help you outline the steps and provide some code snippets to guide you in implementing a sample MCP (Microcontroller Communication Protocol) server using a Dolphin MCP client. Keep in mind that this is a general outline, and the specific details will depend on your exact requirements, the microcontroller you're using, and the Dolphin MCP client library you're working with. **Conceptual Overview** 1. **Understand the MCP Protocol:** Make sure you have a good understanding of the MCP protocol itself. This includes the message format, command codes, data types, and error handling. The Dolphin MCP client documentation should be your primary source for this. 2. **Choose a Microcontroller and Development Environment:** Select a microcontroller (e.g., Arduino, ESP32, STM32) and the corresponding development environment (e.g., Arduino IDE, PlatformIO, STM32CubeIDE). 3. **Set up Communication:** Decide on the communication interface between the microcontroller and the Dolphin MCP client (typically serial/UART, but could also be SPI or I2C). 4. **Implement the MCP Server Logic:** This is the core of your implementation. You'll need to: * Receive MCP messages from the client. * Parse the messages to extract the command code and data. * Execute the appropriate action based on the command code. * Prepare a response message (if required by the protocol). * Send the response message back to the client. **Steps and Code Snippets (Illustrative - Adapt to Your Specifics)** **1. Project Setup (Example: Arduino IDE with Serial Communication)** * **Install the Arduino IDE:** Download and install the Arduino IDE from the official website. * **Select Your Board:** In the Arduino IDE, go to `Tools > Board` and select the appropriate board for your microcontroller. * **Select Your Port:** Go to `Tools > Port` and select the serial port that your microcontroller is connected to. **2. Basic Serial Communication (Arduino Example)** ```arduino void setup() { Serial.begin(115200); // Adjust baud rate as needed while (!Serial); // Wait for serial port to connect (needed for some boards) Serial.println("MCP Server Started"); } void loop() { if (Serial.available() > 0) { // Read data from the serial port String receivedData = Serial.readStringUntil('\n'); // Read until newline character receivedData.trim(); // Remove leading/trailing whitespace Serial.print("Received: "); Serial.println(receivedData); // **TODO: Parse the MCP message and process it here** // **This is where you'll implement the MCP protocol logic** // Example: Send a simple response Serial.println("Response: OK"); } } ``` **3. MCP Message Parsing and Handling (Illustrative)** This is the most complex part. You'll need to define the structure of your MCP messages and implement the parsing logic. Here's a very basic example assuming a simple text-based MCP protocol: ```arduino // Example MCP Message Format (Text-based): // <COMMAND>:<DATA> // Example Commands: // GET_VALUE:sensor1 // SET_VALUE:led1,1 (LED 1 ON) void processMCPMessage(String message) { int separatorIndex = message.indexOf(':'); if (separatorIndex == -1) { Serial.println("Error: Invalid MCP message format"); return; } String command = message.substring(0, separatorIndex); String data = message.substring(separatorIndex + 1); command.trim(); data.trim(); Serial.print("Command: "); Serial.println(command); Serial.print("Data: "); Serial.println(data); if (command == "GET_VALUE") { // Handle GET_VALUE command if (data == "sensor1") { // Read sensor value (replace with actual sensor reading) int sensorValue = analogRead(A0); String response = "VALUE:" + String(sensorValue); Serial.println(response); } else { Serial.println("Error: Unknown sensor"); } } else if (command == "SET_VALUE") { // Handle SET_VALUE command int commaIndex = data.indexOf(','); if (commaIndex == -1) { Serial.println("Error: Invalid SET_VALUE data format"); return; } String target = data.substring(0, commaIndex); String valueStr = data.substring(commaIndex + 1); target.trim(); valueStr.trim(); if (target == "led1") { int value = valueStr.toInt(); digitalWrite(LED_BUILTIN, value); // Assuming LED_BUILTIN is defined Serial.println("Response: LED set"); } else { Serial.println("Error: Unknown target"); } } else { Serial.println("Error: Unknown command"); } } void loop() { if (Serial.available() > 0) { String receivedData = Serial.readStringUntil('\n'); receivedData.trim(); Serial.print("Received: "); Serial.println(receivedData); processMCPMessage(receivedData); // Call the MCP message processing function } } ``` **4. Error Handling** * Implement error checking at each stage (message parsing, command execution, etc.). * Send appropriate error responses back to the client. **5. Dolphin MCP Client Integration** * **Understand the Dolphin MCP Client API:** Carefully study the Dolphin MCP client library's documentation. This will tell you how to send commands, receive responses, and handle errors from the client side. * **Test Communication:** Use the Dolphin MCP client to send commands to your microcontroller server and verify that the server is correctly processing them and sending back the expected responses. **Important Considerations and Improvements** * **Data Types:** Handle different data types (integers, floats, strings) correctly. You might need to use functions like `toInt()`, `toFloat()`, and string manipulation techniques. * **Binary vs. Text-Based Protocol:** Consider using a binary protocol for efficiency and reduced overhead. This will require more complex parsing and packing of data. * **State Management:** If your server needs to maintain state (e.g., the current value of a variable), implement appropriate state management logic. * **Concurrency:** If you need to handle multiple requests concurrently, consider using interrupts or a real-time operating system (RTOS). * **Security:** If security is a concern, implement appropriate security measures (e.g., authentication, encryption). * **Robustness:** Add error handling and input validation to make your server more robust. * **Testing:** Thoroughly test your server with different commands and data values to ensure that it is working correctly. **Example Dolphin MCP Client Code (Illustrative - Adapt to Your Client Library)** This is a *very* generic example. You'll need to consult the Dolphin MCP client library's documentation for the correct API calls. ```python # Example using a hypothetical Dolphin MCP client library import dolphin_mcp # Configure the connection (e.g., serial port) client = dolphin_mcp.MCPClient(port="/dev/ttyACM0", baudrate=115200) try: client.connect() # Send a GET_VALUE command response = client.send_command("GET_VALUE", "sensor1") print("GET_VALUE Response:", response) # Send a SET_VALUE command response = client.send_command("SET_VALUE", "led1,1") # Turn LED on print("SET_VALUE Response:", response) response = client.send_command("SET_VALUE", "led1,0") # Turn LED off print("SET_VALUE Response:", response) except dolphin_mcp.MCPError as e: print("MCP Error:", e) finally: client.disconnect() ``` **Key Takeaways** * **Understand the MCP Protocol:** This is the foundation. * **Start Simple:** Begin with a basic implementation and gradually add features. * **Test Thoroughly:** Test each component as you build it. * **Consult Documentation:** Refer to the documentation for your microcontroller, development environment, and Dolphin MCP client library. * **Adapt the Code:** The code snippets provided are illustrative. You'll need to adapt them to your specific requirements. Remember to replace the placeholder code with your actual implementation logic. Good luck! Let me know if you have more specific questions as you work through the implementation.

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.

static-mcpify

Enables AI agents to access structured content by building static Markdown/JSON files served as a Model Context Protocol server.

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.

Migadu MCP Server

Enables AI assistants to manage Migadu email hosting services through natural language, including creating mailboxes, setting up aliases, configuring autoresponders, and handling bulk operations efficiently.

Ava MCP Adapter

A REST bridge that exposes Ava Agent's AI capabilities as MCP tools, enabling interaction with CommandDeck specialist brains through chat, project management, memory recall, and skill invocation.

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.

Skyforge MCP Server

Connects AI assistants to SkySpark and Haxall building automation systems by dynamically exposing SkySpark Axon functions as MCP tools. Enables natural language interaction with building data, equipment, and automation functions through real-time tool discovery.

OpenShift LightSpeed MCP Server

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

CLI MARKET

Servidor MCP para integrar la plataforma CLI MARKET con asistentes de IA. Permite gestionar productos, pedidos, clientes e inventario de tu tienda marketplace mediante lenguaje natural.

mcp-buttplug

An MCP server that connects Claude and other MCP clients to buttplug.io, allowing AI models to directly control and orchestrate intimate hardware in real-time. It provides a suite of tools for device discovery and haptic commands like vibration, rotation, and patterned pulses.

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.

Netlify MCP Server

Follows the Model Context Protocol to enable code agents to use Netlify API and CLI, allowing them to create, deploy, and manage Netlify resources using natural language prompts.

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.

verify-action

Verify AI agent tool calls with content-addressed, HMAC-attested receipts. Free third-party verification API for AI agents. Call verify_action(claim, evidence) to get an independent integrity check on whether your claimed action matches the actual evidence. Useful for catching silent failures: incorrect SQL operations, file-op mismatches, API call inconsi