Discover Awesome MCP Servers

Cross-System Agent Communication MCP Server

Espelho de

Redmine MCP Server for Cline

Enables interaction with Redmine projects and issues via the Cline VS Code extension, supporting project management and issue creation through the Model Context Protocol.

ThinkDrop Vision Service

Provides screen capture, OCR text extraction, and visual language model scene understanding capabilities with continuous monitoring and automatic memory storage integration.

Local MCP-Server-with-HTTPS-and-GitHub-OAuth

Este projeto é um servidor MCP seguro construído com Node.js e Express. Ele apresenta criptografia HTTPS usando certificados autoassinados, autenticação GitHub OAuth e medidas de segurança adicionais, como limitação de taxa e proteção de cabeçalhos HTTP.

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.

TopicLake Insights FedPolicy

Federal Agency Rules and Executive Actions

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.

Ping MCP Server

An MCP server that allows users to ping other hosts to check network connectivity and diagnostic information. It enables LLMs to perform network latency tests and host availability checks through a standardized interface.

Fathom MCP Server

Enables AI agents to access Fathom AI meeting data including transcripts, summaries, teams, and team members. Provides tools to list meetings with filters, retrieve detailed transcripts and summaries, and manage team information.

MCP Spec Generator

Generates project specifications and file structures using Claude AI through MCP integration. Enables users to describe project ideas and automatically create corresponding documentation and project files.

MCP Plus

A lightweight MCP server that enhances AI agents with tools for codebase analysis, task delegation to sub-agents, multi-agent coordination through chatrooms, and project todo management.

Cursor n8n Builder

Enables AI assistants in Cursor IDE to manage n8n workflows through the n8n REST API, including creating, updating, activating workflows, viewing execution history, and triggering webhooks.

GMS2 MCP Server

An MCP server that parses GameMaker Studio 2 projects, providing developers and AI agents with quick access to project structure, GML code, and asset metadata.

CC Explorer MCP Server

Enables AI assistants to query the Canton Network blockchain explorer through the CC Explorer Pro API. It provides tools for accessing ledger updates, governance votes, validator information, and network consensus data.

vmware-nsx

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

Macroforge MCP Server

Enables AI assistants to access Macroforge documentation, validate TypeScript code with @derive decorators, expand macros, and retrieve macro documentation.

OpenFeature MCP Server

Provides OpenFeature SDK installation guidance through MCP tool calls. Enables AI clients to fetch installation prompts and setup instructions for various OpenFeature SDKs across different programming languages and frameworks.

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.

REMnux Documentation MCP Server

Enables AI assistants to search and retrieve information from the REMnux malware analysis toolkit documentation, allowing users to ask questions about reverse-engineering tools and get accurate, up-to-date answers from the live documentation.

Fusion 360 MCP Integration

Enables AI assistants to interact programmatically with Autodesk Fusion 360 for creating parametric 3D models through simple API calls.

Zulip MCP Server

A Model Context Protocol server that enables AI assistants to interact with Zulip workspaces by exposing REST API capabilities as tools for message operations, channel management, and user interactions.

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.

Tentahead MCP

Connects to the Tentahead API to facilitate campsite searching and group trip planning for Illinois state parks. It provides live availability, weather forecasts, safety alerts, and EV charging data to streamline outdoor adventure planning.

my-design MCP Server

An MCP server that enables AI to interact with the private 'my-design' React component library and design tokens for UI generation and technical support. It provides tools for component searching, API documentation retrieval, and migration guidance based on specific internal design specifications.

Shell Server

A lightweight MCP server that provides AI assistants with access to a system's terminal through a secure terminal tool. It enables users to execute shell commands and receive stdout, stderr, and exit codes directly within an MCP-compatible client.

MCP to LangChain/LangGraph Adapter

Okay, I understand. You want a way to wrap tools that interact with an MCP (Minecraft Protocol) server into a format that Langchain can use. This would allow you to build Langchain agents that can interact with and control a Minecraft server. Here's a breakdown of how you can approach this, along with code examples and explanations: **1. Understanding the Core Concepts** * **MCP (Minecraft Protocol):** This is the communication protocol used between Minecraft clients and servers. You'll need a library that can handle this protocol. Popular choices include: * **`mcstatus`:** A Python library specifically for querying Minecraft server status. It's good for basic information. * **`python-minecraft-nbt`:** For reading and writing NBT data (the format Minecraft uses for world data, player data, etc.). * **`minecraft-protocol`:** A more comprehensive library for interacting with the full Minecraft protocol. This is more complex but gives you more control. * **Langchain Tools:** Langchain tools are wrappers around functions that allow your Langchain agent to perform specific actions. They have a name, a description, and a function to execute. * **Langchain Agents:** Langchain agents use tools to interact with the environment and achieve goals. **2. General Structure** The basic structure will involve: 1. **MCP Interaction Logic:** Write Python functions that use your chosen MCP library to perform actions on the Minecraft server. Examples: * Get server status (player count, MOTD). * Send commands to the server console. * Read/write NBT data (more advanced). 2. **Tool Wrapping:** Wrap these functions into Langchain `Tool` objects. The `Tool` object will define the name, description, and the function to call. 3. **Agent Integration:** Provide these tools to your Langchain agent. **3. Example Code (using `mcstatus` for simplicity)** ```python from langchain.tools import Tool from mcstatus import JavaServer # --- MCP Interaction Functions --- def get_server_status(server_address): """Gets the status of a Minecraft server.""" try: server = JavaServer.lookup(server_address) status = server.status() return f"Server {server_address} has {status.players.online} players online. MOTD: {status.description}" except Exception as e: return f"Error getting server status: {e}" def send_server_command(server_address, command): """Sends a command to the Minecraft server console (requires RCON setup).""" # **IMPORTANT:** This requires RCON to be enabled and configured on the server. # RCON is a remote console protocol. It's a security risk if not properly secured. try: server = JavaServer.lookup(server_address) query = server.query() # Requires enabling query in server.properties # This is just an example, you'd need to use an RCON library for actual command execution # Example using mcrcon (install with pip install mcrcon): # from mcrcon import MCRcon # with MCRcon(server_address.split(":")[0], "your_rcon_password", int(server_address.split(":")[1])) as mcr: # resp = mcr.command(command) # return resp return f"Command '{command}' sent to server {server_address} (RCON not fully implemented in this example)." except Exception as e: return f"Error sending command: {e}" # --- Langchain Tool Definitions --- status_tool = Tool( name="Minecraft Server Status", func=get_server_status, description="Useful for getting the status of a Minecraft server, including player count and MOTD. Input should be a server address in the format 'host:port'." ) command_tool = Tool( name="Minecraft Server Command", func=send_server_command, description="Useful for sending commands to the Minecraft server console. Requires RCON to be enabled and configured. Input should be a server address in the format 'host:port' followed by the command to execute, separated by a comma. Example: 'localhost:25565,say Hello!'" ) # --- Example Usage (with a dummy agent) --- # In a real application, you'd integrate these tools into a Langchain agent. # This is a simplified example to show how the tools would be used. def dummy_agent(query): """A very simple agent that uses the tools based on keywords.""" if "status" in query.lower(): server_address = query.split("status of ")[-1].strip() # Extract server address return status_tool.run(server_address) elif "command" in query.lower(): parts = query.split("command")[-1].strip().split(",") if len(parts) != 2: return "Invalid command format. Use 'command <server_address>,<command>'." server_address = parts[0].strip() command = parts[1].strip() return command_tool.run(f"{server_address},{command}") else: return "I don't understand. Try asking for the server status or sending a command." # Example interaction print(dummy_agent("What is the status of localhost:25565")) print(dummy_agent("Send command localhost:25565,say Hello from Langchain!")) ``` **Explanation:** 1. **`get_server_status(server_address)`:** * Takes a server address (e.g., "localhost:25565") as input. * Uses `mcstatus` to query the server. * Returns a formatted string with the player count and MOTD. * Includes error handling. 2. **`send_server_command(server_address, command)`:** * Takes a server address and a command as input. * **Important:** This example *does not* fully implement RCON. It shows the basic structure but requires you to add the RCON library and authentication. I've included commented-out code using `mcrcon` as an example. * Returns a message indicating that the command was sent (or an error). 3. **`status_tool` and `command_tool`:** * `Tool` objects that wrap the functions. * `name`: A descriptive name for the tool. * `func`: The function to execute when the tool is called. * `description`: A crucial description for the Langchain agent. This is how the agent decides when to use the tool. Be very specific about the input format and what the tool does. 4. **`dummy_agent(query)`:** * This is a *very* basic example of how you might use the tools. In a real application, you would use a Langchain agent (e.g., `ZeroShotAgent`, `ReActAgent`) to intelligently decide when to use the tools based on the user's input. * The `dummy_agent` simply looks for keywords ("status", "command") in the query and calls the appropriate tool. * It extracts the server address and command from the query string. **Key Improvements and Considerations:** * **RCON Implementation:** The `send_server_command` function *must* be updated to use a proper RCON library (like `mcrcon`) to actually send commands to the server. You'll need to configure RCON on your Minecraft server (in `server.properties`) and provide the correct password. **Security is paramount with RCON.** Don't expose your RCON port to the internet without proper security measures. * **Error Handling:** Add more robust error handling to all functions. Catch exceptions and provide informative error messages to the agent. * **Input Validation:** Validate the input to the tools (e.g., server address format, command syntax) to prevent errors. * **Langchain Agent Integration:** Replace the `dummy_agent` with a real Langchain agent. You'll need to: * Choose an agent type (e.g., `ZeroShotAgent`, `ReActAgent`). * Define the agent's prompt (the instructions that tell the agent how to use the tools). The prompt is *critical* for agent performance. * Create an `AgentExecutor` to run the agent. * **More Advanced Tools:** Consider adding tools for: * Reading and writing NBT data (using `python-minecraft-nbt`). This would allow you to modify world data, player data, etc. * Managing server configuration (e.g., changing game rules). * Interacting with Minecraft plugins (if you have any installed). * **Security:** Be extremely careful about security, especially when dealing with RCON or NBT data. Sanitize inputs to prevent command injection or other vulnerabilities. Never hardcode passwords in your code. Use environment variables or a secure configuration file. * **Asynchronous Operations:** For more complex interactions, consider using asynchronous operations (using `asyncio`) to avoid blocking the main thread. This is especially important if you're running the agent in a web server or other interactive environment. **Example of integrating with a Langchain Agent (Conceptual):** ```python from langchain.agents import initialize_agent, AgentType from langchain.llms import OpenAI # Assuming you have the status_tool and command_tool defined as above llm = OpenAI(temperature=0) # Replace with your LLM tools = [status_tool, command_tool] agent = initialize_agent( tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True # Set to True for debugging ) # Now you can run the agent: response = agent.run("What is the status of localhost:25565? Then, send the command 'say Hello from the agent!' to localhost:25565") print(response) ``` **Important Notes about the Langchain Agent Example:** * **API Key:** You'll need an OpenAI API key to use the `OpenAI` LLM. * **Prompt Engineering:** The success of the agent depends heavily on the prompt used by the `ZERO_SHOT_REACT_DESCRIPTION` agent. You may need to experiment with different prompts to get the agent to behave as desired. The tool descriptions are a key part of the prompt. * **Dependencies:** Make sure you have all the necessary Langchain dependencies installed (`pip install langchain openai`). This comprehensive guide should give you a solid foundation for building Langchain tools that interact with your Minecraft server. Remember to prioritize security and error handling, and to carefully design your agent's prompt for optimal performance. Good luck!

Laptop Hardware MCP Server

A Windows-based MCP server that provides real-time hardware telemetry and system stats including CPU, RAM, disk, and battery information to GitHub Copilot. It enables users to monitor performance and retrieve detailed system specifications through natural language commands.

maya_mcp

A Model Context Protocol server that enables AI assistants to interact with active Autodesk Maya sessions using the maya.cmds API. It allows users to manage scene objects, control selections, and perform common 3D operations through natural language.

TreasuryOS

An AI-powered treasury management MCP server that enables users to perform commercial banking analysis, including cash flow forecasting, idle cash detection, and debt covenant monitoring. It provides tools to surface financial insights and optimize working capital through automated processing of bank and transaction data.