Discover Awesome MCP Servers

Meals MCP Server

MCP server for discovering and retrieving meal recipes from TheMealDB API, enabling search, random meals, category/ingredient filtering, and full recipe details.

PostGrid MCP Server

Enables sending letters and MICR-encoded checks, managing contacts and templates, and verifying US/Canadian addresses via the PostGrid Print & Mail and Address Verification APIs from Claude.

ShipStation MCP Server by CData

This project builds a read-only MCP server. For full read, write, update, delete, and action capabilities and a simplified setup, check out our free CData MCP Server for ShipStation (beta): https://www.cdata.com/download/download.aspx?sku=HSZK-V&type=beta

Habit Tracker AI MCP

Habit Tracker AI - MCP server providing AI-powered tools and automation by MEOK AI Labs

gorgias-mcp

Enables AI agents to manage Gorgias support tickets: list open tickets, read conversation history, draft internal notes, send outbound replies (gated), and look up customer history.

storybook-mcp

Integrates with a running Storybook instance to let AI-powered coding tools browse, inspect, and scaffold components from natural language.

UberEats MCP Server Enhanced

A production-ready MCP server for UberEats automation, featuring Redis-backed sessions, n8n integration, and enterprise-grade security, enabling login, item addition, address setting, and checkout.

digital-twin

Enables natural language control of a digital twin simulation pipeline for phone drop tests, converting LS-DYNA .k meshes to solid .k files with hand grip poses using 7 MCP tools.

HacknPlan MCP

Enables Claude to manage game development projects on HacknPlan, including tasks, boards, milestones, and GDD documents through natural language.

AWS Documentation MCP Server

Enables users to access, search, and get recommendations from AWS documentation through natural language queries. Supports both global AWS documentation and AWS China documentation with tools to fetch pages, search content, and discover related resources.

ai.cabrini/market-data

Provides US stock market data for AI agents, including intraday and daily bars, SEC fundamentals, filings, and insider data, with pay-per-query via USDC on Base.

Remote MCP Server

A server implementation of the Model Context Protocol (MCP) that runs on Cloudflare Workers, enabling AI assistants like Claude to securely access external tools and APIs through OAuth authentication.

KiotViet MCP Server

Enables AI assistants to manage KiotViet retail and F\&B operations including products, orders, customers, invoices, and inventory through the Public API. Features 36 integrated tools with automatic token refresh, middleware chain support, and configurable presets for different access levels.

yfinance-mcp

MCP server wrapping yfinance to provide stock market data, financials, and analytics via 24 tools.

AgentRecall

A local-first memory for AI coding agents. AgentRecall turns the feedback and failures you run into while coding into reusable rules, then serves the right ones back — on the command line or directly to Claude Code over MCP. Everything stays on your machine: no cloud sync, no web UI, no API keys.

User Info MCP Server

An MCP server providing tools for user information management with capabilities for retrieving, searching, and adding user data stored in a JSON file.

rlm-tools

An MCP server that provides a persistent sandbox for AI coding agents to explore codebases server-side, returning only compact summaries to reduce context consumption.

Zyxel Switch MCP Server

Enables AI applications to interact with Zyxel switches via CLI for network configuration, monitoring, and management, supporting SSH/Telnet sessions and MCP-compliant tools, resources, and prompts.

Cocos MCP

Bridge for Cocos Creator 3.8.x enabling code agents to control the editor via 43+ tools for scene manipulation, asset management, UI creation, animation, and more.

aftr

Enables AI agents to control Adobe After Effects to create videos programmatically, with commands for comps, layers, effects, and rendering.

Changes Memory MCP

A local MCP server that stores user-approved corrections, preferences, and reusable criteria in plain Markdown files, with separate global and project memory. It provides tools to list, search, and retrieve relevant criteria to help agents avoid repeating mistakes.

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.

MCP Chat

MCP server providing tools for LLMs (via Ollama) to get current time, calculate arithmetic, list files, and read project README, with a web chat UI.

gsc-mcp

MCP server for querying Google Search Console data — search analytics, URL inspection, sitemap monitoring, and more — read-only tools for any MCP-compatible AI client.

termdat-mcp

MCP server for TERMDAT, the terminology database of the Swiss Federal Administration, giving AI agents officially validated designations of Swiss authorities, departments, and legal acts across DE/FR/IT/EN with source references and validation status.

MCP Ollama

Integrates Ollama's local AI models with MCP clients, enabling listing models, viewing model details, and asking questions to models.

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.

Buggy

A multi-agent system that autonomously analyzes code, proves bugs with formal certificates, generates repairs, and validates patches, all over the Model Context Protocol.

vmware-nsx

AI-powered VMware NSX networking management. Configure segments, gateways, NAT, routing, and IPAM via natural language with 31 MCP tools.

la-legislative

A read-only MCP server for querying Los Angeles City legislative data - Council Files, votes, member activity, and Neighborhood Council engagement - through parameterized tools without raw SQL.