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 (Message Center Protocol) server, along with explanations and considerations: **Understanding the Goal** The core idea is to expose the functionality of your Robot Framework library as a service that can be accessed remotely via the MCP protocol. This allows other systems (clients) to send commands to your library and receive responses, effectively making your library a distributed component. **Key Concepts** * **Robot Framework Library:** A collection of keywords (functions) that can be used in Robot Framework test cases. * **MCP (Message Center Protocol):** A lightweight, text-based protocol often used for communication between systems, especially in embedded or resource-constrained environments. It's typically request-response oriented. * **MCP Server:** A process that listens for incoming MCP requests, processes them (by calling the appropriate Robot Framework library keywords), and sends back MCP responses. * **MCP Client:** A process that sends MCP requests to the server and receives responses. **General Approach** 1. **Choose an MCP Server Implementation:** You'll need a way to listen for MCP connections, parse requests, and send responses. You can either: * **Use an Existing MCP Library (Python):** Look for a Python library that handles the low-level MCP protocol details. This is the recommended approach. Search for "Python MCP library" on PyPI (the Python Package Index). Examples might include libraries that provide basic socket handling and message parsing. * **Implement MCP Yourself (Less Recommended):** You could write your own MCP server from scratch using Python's `socket` module. This is more complex and error-prone, as you'll need to handle all the protocol details yourself. 2. **Create a Mapping Between MCP Commands and Robot Framework Keywords:** You need a way to translate an incoming MCP command into a call to a specific keyword in your Robot Framework library. This is typically done using a dictionary or a similar data structure. 3. **Implement the MCP Server Logic:** This involves: * Listening for incoming connections. * Receiving MCP requests. * Parsing the MCP request to determine the command and any arguments. * Looking up the corresponding Robot Framework keyword in your mapping. * Calling the keyword with the provided arguments. * Formatting the result of the keyword call into an MCP response. * Sending the MCP response back to the client. 4. **Handle Errors:** Implement proper error handling to catch exceptions that might occur during keyword execution and return appropriate error responses to the client. **Example (Conceptual - Using a Hypothetical MCP Library)** ```python # Assuming you have a Robot Framework library called 'MyLibrary' from MyLibrary import MyLibrary import socket # For basic socket operations (if not using a dedicated MCP library) # Hypothetical MCP library (replace with a real one if you find it) # For demonstration purposes only class MCPHandler: def __init__(self, connection): self.connection = connection def receive(self): # Receive data from the connection (implement MCP parsing here) data = self.connection.recv(1024).decode() return data def send(self, response): # Send data to the connection (implement MCP formatting here) self.connection.send(response.encode()) def close(self): self.connection.close() # Robot Framework library instance mylibrary = MyLibrary() # Mapping of MCP commands to Robot Framework keywords command_map = { "do_something": mylibrary.do_something, # Assuming MyLibrary has a 'do_something' keyword "get_value": mylibrary.get_value, # Assuming MyLibrary has a 'get_value' keyword # Add more mappings as needed } # Server configuration HOST = "localhost" PORT = 12345 def handle_client(connection, address): print(f"Connected by {address}") mcp_handler = MCPHandler(connection) try: while True: data = mcp_handler.receive() if not data: break print(f"Received: {data}") # Parse the MCP request (very basic example) try: command, *args = data.split(" ") # Example: "do_something arg1 arg2" command = command.strip() args = [arg.strip() for arg in args] except ValueError: response = "ERROR: Invalid command format" mcp_handler.send(response) continue # Look up the keyword in the mapping if command in command_map: keyword = command_map[command] try: # Execute the keyword result = keyword(*args) # Pass arguments to the keyword response = f"OK: {result}" # Format the response except Exception as e: response = f"ERROR: {e}" # Handle errors else: response = "ERROR: Unknown command" mcp_handler.send(response) print(f"Sent: {response}") except Exception as e: print(f"Error handling client: {e}") finally: mcp_handler.close() print(f"Connection with {address} closed") def start_server(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Server listening on {HOST}:{PORT}") while True: conn, addr = s.accept() handle_client(conn, addr) if __name__ == "__main__": start_server() ``` **Explanation of the Example** 1. **Import Libraries:** Imports the Robot Framework library (`MyLibrary`), and the `socket` module. 2. **`MCPHandler` Class (Hypothetical):** This class *should* handle the MCP protocol details. In a real implementation, you would use a proper MCP library here. It provides methods for receiving data, sending data, and closing the connection. 3. **`mylibrary` Instance:** Creates an instance of your Robot Framework library. 4. **`command_map` Dictionary:** This is the crucial mapping. It associates MCP commands (strings) with the corresponding Robot Framework keyword functions. For example, `"do_something": mylibrary.do_something` means that if the server receives the MCP command "do_something", it will call the `do_something` keyword in the `MyLibrary` instance. 5. **`handle_client` Function:** This function handles the communication with a single client. * It receives data from the client using `mcp_handler.receive()`. * It parses the MCP request (in this example, it's a very simple space-separated command and arguments). **You'll need to implement proper MCP parsing here.** * It looks up the keyword in the `command_map`. * It calls the keyword using `keyword(*args)`. The `*args` syntax unpacks the arguments from the list into individual arguments for the function call. * It formats the result into an MCP response (e.g., "OK: result" or "ERROR: error message"). **You'll need to implement proper MCP formatting here.** * It sends the response back to the client using `mcp_handler.send()`. * It handles potential errors during keyword execution. 6. **`start_server` Function:** This function sets up the socket, listens for incoming connections, and spawns a new thread or process to handle each client connection. 7. **`if __name__ == "__main__":` Block:** This ensures that the server starts only when the script is run directly (not when it's imported as a module). **Important Considerations and Improvements** * **MCP Library:** The most important thing is to find and use a proper Python MCP library. This will greatly simplify the implementation and make it more robust. Search on PyPI. * **MCP Parsing and Formatting:** Implement the MCP protocol correctly. This includes defining the message format, handling different data types, and ensuring proper error handling. The example uses a very basic space-separated format, which is not suitable for real-world use. * **Error Handling:** Implement comprehensive error handling to catch exceptions that might occur during keyword execution and return informative error messages to the client. * **Threading/Asynchronous Handling:** For a production server, you'll want to use threading or asynchronous programming (e.g., `asyncio`) to handle multiple client connections concurrently. The example uses a simple blocking socket, which can only handle one client at a time. * **Security:** If your MCP server will be exposed to a network, consider security implications. You might need to implement authentication, authorization, and encryption. * **Data Serialization:** If your Robot Framework keywords return complex data structures (e.g., lists, dictionaries), you'll need to serialize them into a format that can be transmitted over MCP (e.g., JSON, XML, or a custom format). The client will then need to deserialize the data. * **Configuration:** Make the server configurable (e.g., port number, logging level, etc.) using command-line arguments or a configuration file. * **Logging:** Implement proper logging to track server activity and errors. * **Testing:** Write unit tests to ensure that the MCP server is working correctly. **Steps to Implement** 1. **Choose an MCP Library:** Search for a suitable Python MCP library on PyPI. If you can't find one that perfectly fits your needs, you might need to adapt an existing socket library or implement a basic MCP parser/formatter yourself. 2. **Install the Library:** Use `pip install <library_name>` to install the chosen MCP library. 3. **Adapt the Example Code:** Modify the example code above to use the chosen MCP library and to map your Robot Framework keywords to MCP commands. 4. **Implement MCP Parsing and Formatting:** Implement the MCP protocol parsing and formatting logic. 5. **Implement Error Handling:** Add error handling to catch exceptions and return appropriate error messages. 6. **Test the Server:** Write a simple MCP client to test the server. **Example MCP Client (Python)** ```python import socket HOST = "localhost" PORT = 12345 with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) command = "do_something arg1 arg2" # Replace with your MCP command s.sendall(command.encode()) data = s.recv(1024) print(f"Received: {data.decode()}") ``` **In summary, turning a Robot Framework library into an MCP server involves creating a bridge between the MCP protocol and the library's keywords. This requires choosing an MCP library, implementing the server logic, handling errors, and considering security and performance implications.** The example code provides a starting point, but you'll need to adapt it to your specific needs and the chosen MCP library.

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.