Discover Awesome MCP Servers

mirador-mcp

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

recon-fuzz-chimera-mcp

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

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.

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.

sargel

Lets AI agents visually inspect web elements, test CSS edits in real-time, and iterate until pixel-perfect, functioning like browser DevTools for debugging UI issues.

mcp-gemini-deep-research

MCP server that runs Google Gemini Deep Research using live Chrome session cookies, enabling autonomous web research and cited report generation without an API key.

GasBuddy MCP Price Tracker

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

Python Server MCP

Một dịch vụ giá tiền điện tử cung cấp thông tin giá tiền điện tử theo thời gian thực thông qua khung MCP (Giao thức Bối cảnh Mô hình) với tích hợp API CoinMarketCap.

Renderer MCP Server

AI-powered assistant for the Renderer portfolio framework. Enables users to explore documentation, validate TOML configurations, generate templates, and customize portfolios through natural language.

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.

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.

Personal Library MCP Server

A demo server that allows AI models to manage a personal reading list stored in a local SQLite database. It provides tools for searching, adding, and updating books while demonstrating core Model Context Protocol features like resources and tools.

Godot Universal MCP

Connects MCP-capable AI clients to a running Godot 4 editor for scene, node, project, and debug runtime operations via a local-first architecture.

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.

vmware-nsx

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

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 LLDB Server

Enables AI assistants to start and manage LLDB debugging sessions, including loading programs, setting breakpoints, stepping through code, and examining memory.

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.

agentic-platform

Score your agent's governance (0-100), lint MCP tool definitions, and estimate costs across all major models. Free diagnostic tools with no API key needed. Expert skill files on governance, economics, and system architecture available with free tier.

quickbooks-desktop-mcp

Provides safe, structured access to a local QuickBooks Desktop company file for reading and writing transactions, with automatic undo logging.

obsidian-mcp-complete

Local-first MCP server for Obsidian vaults with 66 tools for reading, writing, searching, and managing notes, tasks, graphs, and more. Works without Obsidian running and requires no plugins.

Biolab MCP Server

Intercepts AI agent queries to biological databases, logs full retrieval context, and returns a retrieval_id for end-to-end auditability of scientific evidence.

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.

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.

verifiedstate-mcp

Verified memory infrastructure for AI agents. Every assertion signed, timestamped, and cryptographically proven. Includes session continuity across Claude Code, Cursor, and Windsurf, plus Proof Meter billing attestation.

w3c-mcp

MCP Server for accessing W3C/WHATWG/IETF web specifications. Provides AI assistants with access to official web standards data including specifications, WebIDL definitions, CSS properties, and HTML elements.

Simple MCP POC

A proof-of-concept MCP server that enables reading local files and performing basic arithmetic operations. It provides a simple foundation for understanding how tools are exposed to MCP clients.