Discover Awesome MCP Servers

Devpipe MCP Server

Enables AI assistants to interact with devpipe, a local pipeline runner, allowing them to list tasks, run pipelines, validate configurations, debug failures, analyze security findings, and generate CI/CD configs through natural language.

Roblox MCP Unified Server

Comprehensive Roblox development server with 8 tools for managing Lua/Luau scripts including creation, validation, backup/restore, and project management with SQLite storage and HMAC authentication.

Google Docs MCP Server

Enables Claude to read, create, and update Google Docs through OAuth authentication. Deployed as a remote Next.js server on Vercel with support for multiple users and secure API key management.

MCP Agents Server

Facilitates interaction and context sharing between AI models using the standardized Model Context Protocol (MCP) with features like interoperability, scalability, security, and flexibility across diverse AI systems.

Cloudflare Remote MCP Server (Authless)

A deployable Model Context Protocol server for Cloudflare Workers that enables AI models to use custom tools without requiring authentication.

Time MCP Server

Provides current time information and timezone conversion capabilities using IANA timezone names. Enables LLMs to get current time in any timezone and convert times between different timezones with automatic system timezone detection.

WeatherAPI MCP Server

WeatherAPI を使用して、あらゆる都市の現在の天気と大気質データを提供します。n8n や Claude Desktop App などの MCP クライアントと簡単に統合できます。

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.

CodeMerge

A Model Context Protocol server that uses Osmosis-Apply-1.7B to intelligently apply code edits while preserving the structure of the original code.

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.

MCP to LangChain/LangGraph Adapter

Okay, here's a translation of "Adapter that turns MCP server tools into Langchain usable tools" into Japanese, along with some considerations for different nuances: **Option 1 (Most Direct Translation):** * **MCPサーバーツールをLangchainで利用可能なツールに変換するアダプター** * *MCP sābā tsūru o Langchain de riyō kanō na tsūru ni henkan suru adaputā* * This is a very literal translation. It's clear and understandable. **Option 2 (More Natural Flow):** * **MCPサーバーツールをLangchainツールとして使えるようにするアダプター** * *MCP sābā tsūru o Langchain tsūru to shite tsukaeru yō ni suru adaputā* * This version emphasizes the *usability* of the tools within the Langchain framework. It reads a bit more naturally in Japanese. **Option 3 (Focus on Integration):** * **MCPサーバーツールとLangchainを統合するアダプター** * *MCP sābā tsūru to Langchain o tōgō suru adaputā* * This focuses on the *integration* aspect, highlighting that the adapter bridges the gap between the two systems. **Option 4 (Technical, Emphasizing "Interface"):** * **MCPサーバーツールをLangchainツールとして利用するためのインターフェースアダプター** * *MCP sābā tsūru o Langchain tsūru to shite riyō suru tame no intāfēsu adaputā* * This is a more technical translation, using the word "interface" to describe the adapter's function. It's suitable if you want to emphasize the technical aspect of providing a connection point. **Which one to choose depends on the context:** * If you want a simple, direct translation, **Option 1** is a good choice. * If you want to emphasize the ease of use within Langchain, **Option 2** is better. * If you want to highlight the connection between the two systems, **Option 3** is best. * If you're targeting a technical audience and want to emphasize the adapter's role as an interface, **Option 4** is the most appropriate. I would personally lean towards **Option 2** as it sounds the most natural and conveys the intended meaning effectively.

Selenium MCP Server

Enables AI assistants to automate web browser interactions through Selenium WebDriver. Supports multi-browser automation, element interaction, navigation, and web testing capabilities.

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.

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.

MCPServerTransportDemo

A demonstration project for building and testing Model Context Protocol (MCP) servers using the MCP inspector and client tools. It provides a practical implementation for exploring MCP transport mechanisms and server-client interactions.

RobotFrameworkLibrary-to-MCP

Okay, I can help you understand how to turn a Robot Framework library into an MCP (Message Center Protocol) server. This is a more advanced topic, and it involves understanding both Robot Framework library development and network programming. Here's a breakdown of the concepts and a general approach: **Understanding the Goal** The core idea is to expose the functionality of your Robot Framework library over a network using the MCP protocol. This allows other applications (clients) to call the keywords in your library remotely. **Key Concepts** * **Robot Framework Library:** A collection of keywords (functions) that can be used in Robot Framework test cases. * **MCP (Message Center Protocol):** A simple, text-based protocol for communication between applications. It's often used for remote procedure calls (RPC). It typically involves sending commands and receiving responses. * **Server:** A program that listens for incoming network connections and processes requests. * **Client:** A program that connects to a server and sends requests. * **Serialization/Deserialization:** Converting data structures (like Python objects) into a format suitable for transmission over the network (serialization) and converting the received data back into usable data structures (deserialization). JSON is a common choice. * **Threading/Asynchronous Programming:** Handling multiple client connections concurrently. **General Approach** Here's a high-level outline of the steps involved: 1. **Choose a Network Library:** * **Python's `socket` module:** The built-in, low-level option. Gives you the most control but requires more manual handling of network details. * **`socketserver` module:** Provides a framework for creating network servers. Simplifies some of the socket handling. * **`asyncio` (for asynchronous programming):** A more modern approach for handling concurrent connections efficiently, especially if your library involves I/O-bound operations. Requires Python 3.4 or later. * **Frameworks like `Twisted` or `Tornado`:** More powerful, event-driven frameworks for building network applications. They offer more features but have a steeper learning curve. 2. **Create a Server Class:** * This class will handle incoming client connections, receive MCP requests, and send responses. * If using `socketserver`, you'll typically subclass `socketserver.BaseRequestHandler` or `socketserver.StreamRequestHandler`. * If using `asyncio`, you'll create a coroutine to handle each connection. 3. **Implement MCP Request Parsing:** * Define how you'll parse the incoming MCP requests. MCP is text-based, so you'll need to read the request from the socket, split it into its components (command, arguments), and validate it. * Example MCP request format (this is just an example; you can define your own): ``` CALL <keyword_name> <arg1> <arg2> ... ``` ``` GET_VARIABLE <variable_name> ``` 4. **Map MCP Requests to Robot Framework Library Keywords:** * This is the core logic. Based on the parsed MCP request, you'll need to: * Identify the Robot Framework keyword to call. * Extract the arguments from the MCP request. * Call the keyword in your Robot Framework library with the extracted arguments. * Handle any exceptions that occur during keyword execution. 5. **Serialize the Response:** * Convert the result of the keyword execution (or any error information) into a format suitable for sending back to the client. JSON is a good choice because it's relatively easy to parse in many languages. * Example response format (JSON): ```json { "status": "OK", "result": "The result of the keyword" } ``` ```json { "status": "ERROR", "message": "An error occurred: ..." } ``` 6. **Send the Response:** * Send the serialized response back to the client over the socket. 7. **Handle Client Connections:** * The server needs to be able to handle multiple client connections concurrently. This is where threading or asynchronous programming comes in. * For each new client connection, you'll typically create a new thread or task to handle the requests from that client. 8. **Error Handling:** * Implement robust error handling to catch exceptions during request parsing, keyword execution, and response serialization. Send appropriate error messages back to the client. 9. **Start the Server:** * Create an instance of your server class and start it listening for incoming connections on a specific port. **Example (Conceptual - Using `socketserver`)** ```python import socketserver import json from robot.libraries.BuiltIn import BuiltIn # Or your custom library class RobotFrameworkHandler(socketserver.BaseRequestHandler): def handle(self): data = self.request.recv(1024).strip().decode() # Receive data print(f"Received: {data}") try: # Parse the MCP request (very basic example) parts = data.split() command = parts[0] keyword_name = parts[1] args = parts[2:] # Get the Robot Framework BuiltIn library instance rf = BuiltIn() # Or your custom library instance # Execute the keyword result = rf.run_keyword(keyword_name, args) # Serialize the response response = {"status": "OK", "result": result} response_json = json.dumps(response) except Exception as e: # Handle errors response = {"status": "ERROR", "message": str(e)} response_json = json.dumps(response) # Send the response self.request.sendall(response_json.encode()) class RobotFrameworkServer(socketserver.TCPServer): allow_reuse_address = True # Allows the server to restart quickly if __name__ == "__main__": HOST, PORT = "localhost", 9999 # Create the server, binding to localhost on port 9999 with RobotFrameworkServer((HOST, PORT), RobotFrameworkHandler) as server: print(f"Server listening on {HOST}:{PORT}") # Activate the server; this will keep running until you # interrupt the program with Ctrl-C server.serve_forever() ``` **Explanation of the Example:** * **`RobotFrameworkHandler`:** This class handles each client connection. * `handle()`: This method is called when a client connects. * It receives data from the client. * It parses the MCP request (very simplified in this example). * It gets an instance of the Robot Framework `BuiltIn` library (you'd replace this with your own library). * It uses `run_keyword` to execute the keyword. * It serializes the result into JSON. * It sends the JSON response back to the client. * It includes basic error handling. * **`RobotFrameworkServer`:** This class creates the TCP server. * `allow_reuse_address = True`: This is important for development; it allows you to restart the server quickly without getting "Address already in use" errors. * **`if __name__ == "__main__":`:** This is the main part of the script that starts the server. **Important Considerations:** * **Security:** If you're exposing your Robot Framework library over a network, security is crucial. Consider using encryption (e.g., SSL/TLS) to protect the communication. Also, carefully validate all input from clients to prevent malicious code injection. * **Authentication/Authorization:** You might want to implement authentication to verify the identity of clients and authorization to control which clients can access which keywords. * **Error Handling:** Implement comprehensive error handling to catch exceptions and provide informative error messages to clients. * **Concurrency:** Choose the appropriate concurrency model (threading, `asyncio`, etc.) based on the nature of your library and the expected number of concurrent clients. * **MCP Protocol Design:** Design your MCP protocol carefully. Consider using a more structured format like JSON-RPC or XML-RPC for more complex interactions. * **Testing:** Thoroughly test your MCP server to ensure it handles requests correctly, handles errors gracefully, and performs well under load. **Steps to Adapt the Example:** 1. **Replace `BuiltIn()` with your library:** Import your Robot Framework library and create an instance of it. 2. **Implement proper MCP parsing:** The example's parsing is very basic. You'll need to define a more robust MCP protocol and implement parsing logic to extract the keyword name and arguments correctly. 3. **Handle different data types:** The example assumes all arguments are strings. You'll need to handle different data types (numbers, booleans, lists, dictionaries) correctly when passing arguments to the Robot Framework keywords. JSON serialization/deserialization can help with this. 4. **Add error handling:** The example's error handling is basic. Add more specific error handling to catch different types of exceptions and provide more informative error messages. 5. **Implement concurrency:** If you need to handle multiple clients concurrently, use threading or `asyncio`. The `socketserver` module provides some built-in support for threading. This is a complex task, but by breaking it down into smaller steps and understanding the underlying concepts, you can successfully turn your Robot Framework library into an MCP server. Remember to start with a simple example and gradually add more features. Good luck!

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.

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.

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.

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.