Discover Awesome MCP Servers

EntityIdentification

A MCP server that helps determine if two sets of data belong to the same entity by comparing both exact and semantic equality through text normalization and language model integration.

MasterGo Magic MCP

Connects AI models to MasterGo design tools, enabling retrieval of DSL data, component documentation, and metadata from MasterGo design files for structured component development workflows.

ICON MCP v103

Provides AI agents and LLMs with secure access to the ICON MCP v103 API via Bearer tokens or HTTP 402 payment protocols. It enables standardized interaction with market data and API endpoints through the Model Context Protocol.

PocketBase MCP Server

Enables MCP-compatible applications to directly interact with PocketBase databases for collection management, record operations, schema generation, and data analysis.

DaVinci Resolve MCP Server

Connects AI coding assistants (Cursor, Claude Desktop) to DaVinci Resolve, enabling control of video editing workflows through natural language commands for project management, timeline operations, and media pool tasks.

MCP Sheet Parser

A Model Context Protocol server designed for AI assistants to directly process spreadsheet files, enabling them to read, display, modify, and save various table formats like CSV and Excel.

Claude Deep Think MCP Server

Provides proactive deep analytical thinking using Claude Sonnet 4.5 before writing code, helping analyze errors, requirements, and architectural decisions to produce better quality code with fewer iterations.

OpenFeature MCP Server

Provides OpenFeature SDK installation guidance through MCP tool calls. Enables AI clients to fetch installation prompts and setup instructions for various OpenFeature SDKs across different programming languages and frameworks.

RobotFrameworkLibrary-to-MCP

Okay, here's a breakdown of how to turn a Robot Framework library into an MCP (MessagePack-RPC) server, along with explanations and considerations: **Understanding the Goal** The core idea is to expose the keywords of your Robot Framework library as remote procedures that can be called over a network using MessagePack-RPC. This allows you to run your Robot Framework tests and libraries in a distributed manner, potentially offloading resource-intensive tasks to dedicated servers. **Key Components and Technologies** 1. **Robot Framework Library:** This is your existing library containing the keywords you want to expose. 2. **MessagePack-RPC (MCP):** A binary serialization and RPC protocol. MessagePack is efficient for data transfer, and RPC allows you to call functions on a remote server as if they were local. 3. **Python (or other language):** You'll need a server-side implementation (likely in Python) to host your Robot Framework library and handle the MCP requests. 4. **MCP Server Framework (e.g., `mcp` Python package):** A library that simplifies the creation of MCP servers. 5. **MCP Client (in Robot Framework):** A Robot Framework library that acts as a client, making calls to the MCP server. **Steps to Implementation** **1. Install Necessary Packages** * On the server (where your Robot Framework library will run): ```bash pip install robotframework pip install mcp ``` * On the client (where your Robot Framework tests will run): ```bash pip install robotframework pip install mcp ``` **2. Create the MCP Server (Python)** ```python # server.py import mcp import robot.libraries # Import the robot.libraries module from robot.api.deco import keyword from robot.libraries.BuiltIn import BuiltIn # Replace 'YourLibrary' with the actual name of your Robot Framework library # and the path to it. If it's in the same directory, you can use a relative path. # Example: # from my_robot_library import MyRobotLibrary # library = MyRobotLibrary() # Dynamically load the library library_name = "YourLibrary" # Replace with your library's name library_path = "./YourLibrary.py" # Replace with the path to your library file try: # Attempt to import the library dynamically spec = importlib.util.spec_from_file_location(library_name, library_path) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) library_class = getattr(module, library_name) # Assuming the class name matches the library name library = library_class() except Exception as e: print(f"Error loading library: {e}") exit(1) class RobotLibraryService: def __init__(self, library): self.library = library def __dir__(self): # Expose only the keywords as callable methods return [name for name in dir(self.library) if callable(getattr(self.library, name)) and not name.startswith('_')] def __getattr__(self, name): # Delegate calls to the Robot Framework library's methods (keywords) try: attr = getattr(self.library, name) if callable(attr): return attr else: raise AttributeError(f"'{type(self.library).__name__}' object has no attribute '{name}'") except AttributeError: raise AttributeError(f"'{type(self.library).__name__}' object has no attribute '{name}'") # Create an instance of the service, passing in your Robot Framework library service = RobotLibraryService(library) # Create the MCP server server = mcp.Server(service) if __name__ == '__main__': server.run(('localhost', 6000)) # Listen on localhost, port 6000 (or choose a different port) print("MCP Server started on localhost:6000") ``` **Explanation of `server.py`:** * **Imports:** Imports the necessary libraries (`mcp`, `robot.libraries`, `robot.api.deco`). * **Library Loading:** This is the crucial part. It dynamically loads your Robot Framework library. You'll need to replace `"YourLibrary"` and `"./YourLibrary.py"` with the actual name and path of your library file. The code attempts to import the library dynamically using `importlib`. This is more flexible than a direct `from ... import ...` statement because it allows you to specify the path to the library file. It then retrieves the class representing your library from the loaded module. * **`RobotLibraryService` Class:** This class acts as a wrapper around your Robot Framework library. It's essential for exposing the library's keywords as callable methods to the MCP server. * `__dir__`: This method is important for introspection. It tells the MCP server which methods (keywords) are available for remote calling. It filters the attributes of your library to only include callable methods (functions) that don't start with an underscore (to avoid exposing internal methods). * `__getattr__`: This is the magic. When the MCP server receives a request to call a method (keyword) that doesn't directly exist in the `RobotLibraryService` class, Python calls `__getattr__`. This method then looks up the method in your *actual* Robot Framework library and returns it. This effectively delegates the call to your library. * **Server Creation:** Creates an instance of the `RobotLibraryService`, passing in your Robot Framework library. Then, it creates an `mcp.Server` instance, passing in the service object. * **`server.run()`:** Starts the MCP server, listening on the specified address and port. **3. Create the Robot Framework Client Library** ```python # McpClientLibrary.py import mcp from robot.api.deco import keyword class McpClientLibrary: def __init__(self, host='localhost', port=6000): self.host = host self.port = port self.client = None def connect_to_server(self): self.client = mcp.Client((self.host, self.port)) def disconnect_from_server(self): if self.client: self.client.close() self.client = None @keyword def call_remote_keyword(self, keyword_name, *args): """Calls a keyword on the remote MCP server.""" if not self.client: raise Exception("Not connected to the MCP server. Call 'Connect To Server' first.") try: result = self.client.call(keyword_name, *args) return result except Exception as e: raise Exception(f"Error calling remote keyword '{keyword_name}': {e}") ``` **Explanation of `McpClientLibrary.py`:** * **Imports:** Imports `mcp` and `robot.api.deco`. * **`McpClientLibrary` Class:** * `__init__`: Initializes the client with the server's host and port. * `connect_to_server`: Creates an `mcp.Client` instance to connect to the server. * `disconnect_from_server`: Closes the connection to the server. * `call_remote_keyword`: This is the key keyword. It takes the name of the keyword you want to call on the server and any arguments. It uses `self.client.call()` to make the RPC call. It handles potential exceptions and re-raises them with more informative messages. The `@keyword` decorator makes this method available as a Robot Framework keyword. **4. Robot Framework Test Case** ```robotframework ***Settings*** Library McpClientLibrary ***Variables*** ${SERVER_HOST} localhost ${SERVER_PORT} 6000 ***Test Cases*** Call Remote Keyword Connect To Server ${result} = Call Remote Keyword your_keyword_name arg1 arg2 # Replace with your keyword and arguments Log Result: ${result} Disconnect From Server ``` **Explanation of the Robot Framework Test Case:** * **`Library McpClientLibrary`:** Imports the client library you created. * **`Connect To Server`:** Calls the `connect_to_server` keyword to establish a connection to the MCP server. * **`Call Remote Keyword`:** Calls the `call_remote_keyword` keyword, passing in the name of the keyword you want to execute on the server (e.g., `"your_keyword_name"`) and any arguments that the keyword expects. The result of the remote keyword execution is stored in the `${result}` variable. * **`Log Result: ${result}`:** Logs the result to the Robot Framework report. * **`Disconnect From Server`:** Closes the connection to the server. **5. Running the Code** 1. **Start the MCP Server:** Run `python server.py` on the server machine. Make sure the server is running *before* you run the Robot Framework test. 2. **Run the Robot Framework Test:** Execute your Robot Framework test case. **Important Considerations and Improvements** * **Error Handling:** The example code includes basic error handling, but you should add more robust error handling to catch potential network issues, exceptions in your Robot Framework library, and other problems. * **Security:** MCP itself doesn't provide built-in security features like encryption or authentication. If you're transmitting sensitive data, you'll need to add security measures, such as using TLS/SSL to encrypt the communication channel or implementing authentication mechanisms. Consider using a more secure RPC framework if security is critical. * **Data Serialization:** MessagePack is generally efficient, but be mindful of the types of data you're passing between the client and server. Complex objects might require custom serialization/deserialization. * **Library Loading:** The dynamic library loading is more flexible, but it relies on the library being structured in a way that allows it to be loaded dynamically. If your library has complex dependencies or initialization logic, you might need to adjust the loading code accordingly. * **Asynchronous Operations:** For long-running tasks, consider using asynchronous operations (e.g., using `asyncio` in Python) to prevent the MCP server from blocking while waiting for the task to complete. * **Alternative RPC Frameworks:** While MCP is a good choice for its simplicity and efficiency, other RPC frameworks like gRPC or Thrift might be more suitable for complex applications with strict performance or security requirements. * **Robot Framework's `Remote` Library:** Robot Framework has a built-in `Remote` library that uses XML-RPC. While it's simpler to set up initially, it's generally less efficient than MCP. The `Remote` library is a good starting point for simple remote execution scenarios. **Example: A Simple Robot Framework Library** ```python # YourLibrary.py from robot.api.deco import keyword class YourLibrary: @keyword def add_numbers(self, a, b): """Adds two numbers and returns the result.""" a = int(a) b = int(b) return a + b @keyword def say_hello(self, name): """Returns a greeting.""" return f"Hello, {name}!" ``` In this case, you would replace `"YourLibrary"` in `server.py` with `"YourLibrary"` and `"./YourLibrary.py"` with `"./YourLibrary.py"`. Then, in your Robot Framework test case, you could call the `add_numbers` or `say_hello` keywords remotely. **Summary** Turning a Robot Framework library into an MCP server involves creating a server-side component that hosts the library and exposes its keywords as remote procedures, and a client-side library that allows Robot Framework tests to call those procedures. The `mcp` Python package simplifies the creation of MCP servers and clients. Remember to handle errors, consider security, and choose the right RPC framework for your specific needs.

Fusion 360 MCP Integration

Enables AI assistants to interact programmatically with Autodesk Fusion 360 for creating parametric 3D models through simple API calls.

MCP Bridge API

O MCP Bridge é um proxy leve, rápido e independente de LLM para conectar-se a múltiplos servidores Model Context Protocol (MCP) através de uma API REST unificada. Ele permite a execução segura de ferramentas em diversos ambientes, como dispositivos móveis, web e edge. Projetado para flexibilidade, escalabilidade e fácil integração com qualquer backend de LLM.

ITSM Integration Platform

MCP para integração de ferramenta ITSM

Terraform MCP Server

Enables management of Terraform infrastructure as code through 25 comprehensive tools for operations including plan/apply/destroy, state management, workspace management, and configuration file editing.

FLUX MCP Server

Exposes Replicate's FLUX image generation models to Claude, enabling text-to-image generation, image variations, inpainting, and edge-guided creation with 6 different FLUX models.

Vercel MCP Relay Server

Enables AI assistants to interact with the Vercel REST API to manage projects, deployments, domains, environment variables, and teams through natural language commands.

Gemini RAG MCP Server

Enables creation and querying of knowledge bases using Google's Gemini API File Search feature, allowing AI applications to upload documents and retrieve information through RAG (Retrieval-Augmented Generation).

Cloudflare Remote MCP Server

A template for deploying remote Model Context Protocol servers on Cloudflare Workers using Server-Sent Events (SSE). It enables the creation and hosting of custom AI tools that can be accessed via the Cloudflare AI Playground or local clients like Claude Desktop.

Diagrams MCP Server

Enables creation of infrastructure and architecture diagrams as code using the Python diagrams library, supporting 15+ cloud providers, 500+ node types, custom icons, and flowcharts with multiple output formats.

Overwatch2 MCP Server

An MCP server that provides Overwatch 2 hero data, allowing users to retrieve hero lists and detailed information about specific heroes.

Whoop MCP Server

Espelho de

TShark2MCP

An MCP server that enables AI-assisted network packet analysis using Wireshark's TShark tool. It provides tools for pcap file overview, session extraction, protocol filtering, and statistical analysis through a standardized interface.

Chess MCP Server

Enables AI assistants to play, analyze, and track chess games with full rule validation and support for standard algebraic notation. It provides tools for position evaluation and game state persistence during user sessions.

rekordbox-mcp

MCP server for rekordbox DJ database access. Provides read-only querying of tracks, playlists, and DJ session history from encrypted rekordbox SQLite databases using pyrekordbox.

Advertising-Analysis

A demonstration project of an MCP server for injecting advertisements into LLM responses, showcasing the risks of advertising injection middleware.

RateSpot MCP Server

Provides access to RateSpot.io mortgage rate APIs, enabling AI assistants to fetch real-time mortgage rates, compare loan products, calculate payments, and access comprehensive lending information.

mcp-book-search

Servidor MCP para pesquisa de livros domésticos.

Python Server MCP

Um serviço de preços de criptomoedas que fornece informações de preços de cripto em tempo real através de uma estrutura MCP (Protocolo de Contexto de Modelo) com integração da API CoinMarketCap.