Discover Awesome MCP Servers

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.

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.

Oceanir Memory

Provides persistent long-term memory for AI coding agents by storing entities, relations, and observations across different sessions. It enables users to manage and query structured knowledge like coding preferences, project patterns, and technical solutions via a graph-based storage system.

Ares DevOps MCP Server

An MCP server that provides seamless interaction with Azure DevOps Git repositories, enabling users to manage repositories, branches, pull requests, and pipelines through natural language.

@zhigang1992/uploadfile-mcp

An MCP server that enables users to upload local files to S3-compatible storage and retrieve shareable public URLs. Files are automatically organized into unique UUID-based folders to prevent naming conflicts while preserving original filenames.

PDF Reader MCP

A high-performance Model Context Protocol server that enables AI agents to extract text, images, and metadata from PDF documents using parallel processing. It features intelligent Y-coordinate content ordering to preserve natural reading flow and supports both local files and URL-based sources.

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.

Dedalus MCP Documentation Server

Enables serving and querying documentation with AI-powered capabilities including markdown file serving, keyword search, and intelligent Q\&A using OpenAI integration.

StarTree MCP Server for Apache Pinot

StarTree MCP Server for Apache Pinot

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.

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.

IntelliPlan

IntelliPlan

mcp-sse-server-demo

Demonstração do servidor MCP SSE

BMKG MCP Server

An unofficial MCP server that provides access to Indonesia's BMKG data, including real-time earthquake reports, village-level weather forecasts, and extreme weather alerts. It enables users to search for location codes and retrieve detailed meteorological and geophysical information through natural language.

OpenXAI MCP Server

Provides tools for evaluating and benchmarking AI explanation methods through a standard interface that can be used with AI assistants and MCP-compatible applications.

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.

Asana MCP Server

An MCP (Multi-Agent Conversation Protocol) server that enables interacting with the Asana API through natural language commands for task management, project organization, and team collaboration.

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.

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.

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.

Usher MCP

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

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

Um servidor amap-weather com MCP.

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.