Discover Awesome MCP Servers

Weather MCP Server

Provides real-time weather forecasts and alerts by fetching data from the National Weather Service API, allowing Claude to answer weather-related questions with up-to-date information.

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.

Agentic Workbench

An MCP-based tool orchestrator that exposes a single execute_task tool to Claude while internally managing 100+ tools through hierarchical navigation with a cheaper LLM, preventing context overflow from loading all tool definitions.

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.

ThinkDrop Vision Service

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

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.

GitHub MCP Server

GitHub MCP (presumably referring to "Minecraft Protocol") Server を CI (継続的インテグレーション) フローに統合する

EntityIdentification

A MCP server that helps determine if two sets of data belong to the same entity by comparing both exact and semantic equality through text normalization and language model integration.

Ultimate-MCP-Server

Provides a suite of tools like agent orchestration and token optimization for Claude

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, 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!

Gold Standard Apology MCP

Provides guidelines for writing proper apologies based on the situation, relationship, and severity. Returns structured prompts that help LLMs generate sincere and appropriate apology letters in Korean.

Fusion 360 MCP Integration

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

MCP Bridge API

MCP Bridgeは、軽量かつ高速で、LLMに依存しないプロキシであり、統一されたREST APIを通じて複数のModel Context Protocol (MCP)サーバーに接続できます。モバイル、ウェブ、エッジデバイスなど、多様な環境での安全なツール実行を可能にします。柔軟性、拡張性、そしてあらゆるLLMバックエンドとの容易な統合を目的として設計されています。

ITSM Integration Platform

ITSMツール連携のためのMCP

Google Chat MCP Server

Enables posting text messages to Google Chat spaces through webhook-based integration, providing simple and secure message delivery without OAuth setup requirements.

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.

GitHub Configuration

TickTickタスク管理アプリケーション用のモデルコンテキストプロトコル（MCP）サーバー

makefilemcpserver

An MCP server that exposes Makefile targets as callable tools for AI assistants, allowing Claude and similar models to execute Make commands with provided arguments.

Pilldoc User MCP

Provides access to pharmaceutical management system APIs including user authentication, pharmacy account management, and advertising campaign controls. Enables querying pharmacy information, updating account details, and managing ad blocking through natural language interactions.

HubAPI Auth MCP Server

An MCP server for interacting with HubSpot's authentication API, enabling secure authentication and authorization operations through natural language.

ContextKeep

Provides infinite long-term memory for AI agents with persistent, searchable storage of project details, preferences, and snippets. Reduces token costs by retrieving only relevant memories while keeping all data stored locally.

Pulsar Edit MCP Server

Enables LLMs to interact with and control the Pulsar text editor through a variety of file and text manipulation commands. It allows for tasks like code editing, context retrieval, and project navigation using either a built-in chat panel or external MCP clients.

AutoCAD MCP Server

Enables AI agents to interact with AutoCAD through Python automation to draw geometric shapes like lines, circles, and polylines in real-time. It facilitates direct control of a running AutoCAD instance on Windows for basic geometric element creation.

MusicGPT MCP Server

Provides AI-powered audio generation and processing through the MusicGPT API, enabling music creation, voice conversion, audio manipulation, stem extraction, and audio analysis capabilities.

TaskMateAI

MCPを介して動作するAI駆動型タスク管理アプリケーション。サブタスク、優先度、進捗状況の追跡をサポートし、タスクの自律的な作成、整理、実行を可能にします。