Discover Awesome MCP Servers

opendocswork-mcp

Rust-native MCP server for Office document processing (Excel, Word, PowerPoint) enabling sub-millisecond, local-first document manipulation and export to PDF.

Whoop MCP Server

Espelho de

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.

Cloudflare Remote MCP Server (Authless)

Enables deployment of a remote MCP server on Cloudflare Workers without authentication, supporting custom tools and integration with clients like Claude Desktop.

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.

Photonics Simulation MCP

Knowledge-based MCP server for photonics simulation engineering, providing rules, bugs, checklists, and tool recommendations for Lumerical FDTD/MODE/FDE, HFSS, COMSOL, and PyAEDT.

GasBuddy MCP Price Tracker

Scrapes real-time gas prices from GasBuddy.com to find the cheapest fuel in any US city or zip code.

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.

nexi-xpay-mcp-server

Enables AI assistants to query orders, transaction details, warnings/anomalies, and payment methods from your Nexi XPay merchant account.

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.

aster-guard

Enables scanning MCP server configurations for security risks like prompt injection, hardcoded secrets, and dangerous commands, providing risk scores and detailed reports before connecting to an AI coding assistant.

Toast MCP Integration

An MCP server that enables Claude Desktop to interact with Toast restaurant data, including sales summaries, top items, and product mix analysis.

singaporemobileproxy

browse websites through singaporean IP

websight

Enables AI agents to see, analyze, and visually verify web page changes through pixel-perfect diffing, theme extraction, layout analysis, and interactive element detection.

coronium-proxy-mcp

Enables management of 4G/5G mobile proxies from Coronium.io, allowing users to list, rotate, replace, set rotation intervals, buy, renew, and manage subscriptions directly from MCP-compatible AI tools.

Cloudflare Remote MCP Server (Authless)

A deployable Model Context Protocol server for Cloudflare Workers that enables AI models to use custom tools without requiring authentication.

ai-cli-mcp

Enables running multiple AI CLI tools (Claude, Codex, Gemini, Forge, OpenCode) as background processes with automatic permission handling, allowing LLMs to execute async multitasking and combine different AI models.

websearch-mcp-server

Enables web search through Exa or Parallel APIs for MCP-compatible AI clients like Cursor and Claude Code.

FSS Pension MCP Server

Provides FSS (Korean Financial Supervisory Service) pension data to AI models like Claude through Model Context Protocol, enabling real-time pension product information retrieval and personalized AI-based pension consultation services.

Acunetix MCP Server

Exposes the Acunetix Scanner API as a streamable HTTP MCP server, allowing clients to interact with security scanning tools via standardized requests. It enables automated vulnerability management and integration with platforms like GhostReconRev through a containerized bridge.

mcp-litmedia

Exposes litmedia.ai text-to-image and image-to-video generation tools via MCP, enabling AI agents to generate images and videos directly from prompts.

Selenium MCP Server

Enables AI assistants to automate web browser interactions through Selenium WebDriver. Supports multi-browser automation, element interaction, navigation, and web testing capabilities.

hive-mcp-keet-bridge

Bridges Holepunch/Keet identity keys into the Hive DID network, enabling DID resolution, attestation verification, and partner lookup via MCP tools.

archicad-mcp

MCP server for Archicad automation, enabling AI assistants to run Python scripts against running Archicad instances via the Tapir JSON API for complex workflows.

mcp-deezer

Deezer MCP server for AI agents to search, manage playlists, favorites, and discover music using a free Deezer account.

Weather MCP Server

Provides real-time weather forecasts and alerts by fetching data from the National Weather Service API, allowing Claude to answer weather-related questions with up-to-date information.

Binary Banya

An MCP server offering 'treatments' for AI agents like context cleaning, critique, and relaxation. Agents can check in, get feedback, and improve their performance.

String Diagram Generator MCP Server

Generates formal string diagram visualizations of Lushy brick compositions, enabling zero-cost diagram generation and recursive self-documentation based on category theory.