Discover Awesome MCP Servers

ANSYS MCP Server

Enables natural language-driven ANSYS simulations (Fluent, Mechanical, Geometry) with automatic TUI script generation for reproducibility.

io.github.DiaaAj/a-mem-mcp

A-MEM is a self-evolving memory system for coding agents that automatically organizes knowledge into a Zettelkasten-style graph with dynamic relationships, enabling semantic and structural search.

garmin-mcp-triathlon

Enables triathlon coaches and athletes to interact with Garmin Connect, including retrieving health/activity data, building and uploading structured workouts (cycling, running, swimming, brick), and accessing coaching analytics like readiness, load, and performance trends.

Tavily Cloud MCP

A cloud MCP server providing Tavily-powered tools for web search, extraction, crawling, mapping, and research, with multi-key load balancing, real-time quota tracking, and a web admin panel.

etsy-mcp-server

A full-featured MCP server for the Etsy Open API v3 that enables managing an Etsy shop, including listings, inventory, images, digital files, and orders, through Claude or any MCP-compatible client.

Ghost MCP Server

Enables AI assistants to securely manage Ghost CMS blogs, including posts, pages, members, newsletters, tiers, and more via natural language.

bhoonidhi-mcp

An MCP server that lets AI agents search, save, preview, download, and cart satellite scenes from ISRO's Bhoonidhi portal in natural language, with search and saved queries requiring no login and downloads/cart operations using an out-of-band session.

MCP Spark Documentation Server

Provides full-text search and retrieval tools for Apache Spark documentation using SQLite FTS5 with BM25 ranking. It enables AI assistants to efficiently search, filter by section, and read specific Spark documentation pages.

TradingView MCP Bridge

Enables AI assistants to interact with locally running TradingView Desktop for chart analysis, Pine Script development, and workflow automation via Chrome DevTools Protocol.

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.

MCP Webhook Server

An MCP server that enables sending data to webhooks via HTTP POST for both local and remote team environments. It provides a tool for relaying task descriptions, custom metadata, and automated notifications to external services.

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.

LAIN-mcp

A persistent code-intelligence MCP server that builds a queryable knowledge graph of your codebase, enabling AI assistants to perform cross-file structural reasoning, dependency analysis, and blast radius detection.

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.

taiwan-isbn-mcp

A MCP server for querying Taiwan ISBN book data, supporting search by title, author, publisher, batch ISBN lookup, and browsing new books.

recon-fuzz-chimera-mcp

Recon Fuzz Chimera MCP knowledge to multi fuzzing enviornments compatibility in Solidity Smart contracts

HubSpot MCP Server

A Type 4 OAuth MCP server that enables AI assistants to interact with HubSpot CRM objects like contacts, companies, deals, and tickets.

Eldermind Astro Engine API

MCP server exposing eight esoteric calculation systems (Western/Vedic astrology, Human Design, Gene Keys, and more) through 14 tools, with deterministic profiles, partial success, and OAuth integration.

polyhaven-mcp

Enables AI assistants to search and retrieve metadata and download links for CC0 HDRIs, textures, and 3D models from PolyHaven's public library.

tracetify-mcp

MCP server for Tracetify — trace how any product actually grew, without leaving Claude Code or Cursor.

FAOSTAT MCP Server

Enables AI assistants to query the full FAOSTAT API for global food and agriculture statistics, allowing natural-language questions about crop production, trade, food security, emissions, and more.

mirador-mcp

Thin MCP adapter for Mirador Core that exposes data tools through the Core Internal API, enabling business data queries and schema exploration.

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.

git-intel

A local Git intelligence MCP server that provides deep repository analytics including hotspots, churn, knowledge maps, and risk scoring, all computed from commit history without data leaving your machine.

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.

proxmox-mcp

A read-only MCP server for Proxmox VE that provides AI assistants with structured visibility into cluster nodes, guests, storage, and Docker workloads. It is designed to prevent any mutating operations by construction.

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.

Financial Data MCP Server

A Model Context Protocol server that provides financial tools for retrieving real-time stock data, analyst recommendations, financial statements, and web search capabilities for a LangGraph-powered ReAct agent.