Discover Awesome MCP Servers

mcp-book-search

国内图书搜索用MCP服务器 (Guó nèi túshū sōusuǒ yòng MCP fúwùqì)

Python Server MCP

一个加密货币价格服务，通过 MCP（模型上下文协议）框架与 CoinMarketCap API 集成，提供实时加密货币定价信息。

TaskMateAI

一个由人工智能驱动的任务管理应用程序，通过MCP运行，能够自主创建、组织和执行任务，并支持子任务、优先级和进度跟踪。

A2AMCP

A Redis-backed MCP server that enables multiple AI agents to communicate, coordinate, and collaborate while working on parallel development tasks, preventing conflicts in shared codebases.

Codebase MCP Server

Enables AI assistants to semantically search and understand code repositories using PostgreSQL with pgvector embeddings. Provides repository indexing, natural language code search, and development task management with git integration.

GitHub Configuration

TickTick 任务管理应用的 Model Context Protocol (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.

ThinkDrop Vision Service

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

code-rules-mcp

用于将代码规则可靠地读入 Agentic AI 上下文的 MCP 服务器。 (MCP 服务器用于可靠地将代码规则读入自主智能体 (Agentic AI) 的上下文。)

Mathematica MCP Server

Allows LLMs to execute Wolfram Language code in a secure, session-based environment by providing an interface to interact with a Wolfram Mathematica kernel.

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.

Naver Search MCP Server

Provides access to Naver Search APIs, allowing AI agents to search across multiple categories (blogs, news, books, images, shopping items, etc.) with structured responses optimized for LLM consumption.

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 (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 MCP. This allows other systems (potentially written in different languages or running on different machines) to trigger actions within your Robot Framework library. **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 protocol for inter-process communication. It's often used for sending commands and receiving responses between different applications or services. * **MCP Server:** A process that listens for MCP requests, processes them, and sends back responses. * **MCP Client:** A process that sends MCP requests to an MCP server. * **Serialization/Deserialization:** Converting data structures (like Python objects) into a format suitable for transmission over a network (e.g., JSON) and then converting them back on the receiving end. **General Approach** 1. **Choose an MCP Library/Framework:** You'll need a Python library that handles the MCP protocol. Some options include: * **`mcp` (Python Package):** A dedicated MCP library for Python. This is likely the most direct and appropriate choice. You can install it with `pip install mcp`. * **ZeroMQ (with MCP Implementation):** ZeroMQ is a powerful messaging library that can be used to implement MCP. This is a more general-purpose solution, but it might be overkill if you only need MCP. * **Other Messaging Libraries:** You *could* potentially use other messaging libraries (like RabbitMQ or Redis Pub/Sub), but you'd need to implement the MCP protocol on top of them, which is more complex. 2. **Create an MCP Server:** Write a Python script that: * Imports your Robot Framework library. * Uses the chosen MCP library to create a server that listens on a specific port. * Registers handlers for different MCP commands. Each handler will correspond to a keyword in your Robot Framework library. * When a command is received, the handler will: * Extract the arguments from the MCP message. * Call the corresponding Robot Framework keyword with those arguments. * Capture the return value (if any) from the keyword. * Serialize the return value (e.g., to JSON). * Send the serialized result back to the MCP client as an MCP response. 3. **Create an MCP Client (if needed for testing):** Write a Python script (or use a tool like `netcat`) that: * Uses the chosen MCP library to connect to the MCP server. * Sends MCP requests with the appropriate command name and arguments. * Receives and deserializes the MCP response. * Prints or processes the result. **Example using the `mcp` Python Package** ```python # server.py (MCP Server) import mcp import json from robot.libraries.BuiltIn import BuiltIn # Or import your custom library # Instantiate your Robot Framework library (or use BuiltIn for demonstration) # my_library = MyRobotLibrary() builtin = BuiltIn() def execute_keyword(keyword_name, *args): """Executes a Robot Framework keyword and returns the result.""" try: result = builtin.run_keyword(keyword_name, *args) return result except Exception as e: return {"error": str(e)} # Handle errors gracefully class MyMCPHandler(mcp.Handler): def handle_message(self, message): """Handles incoming MCP messages.""" try: command = message.command arguments = message.arguments if command == "log_message": # Example: Expose the 'Log' keyword result = execute_keyword("Log", arguments.get("message", "")) # Pass arguments as needed return mcp.Response(result=result) elif command == "get_variable_value": #Example: Expose the 'Get Variable Value' keyword variable_name = arguments.get("name") default_value = arguments.get("default", None) result = execute_keyword("Get Variable Value", variable_name, default_value) return mcp.Response(result=result) else: return mcp.Response(error="Unknown command: {}".format(command)) except Exception as e: return mcp.Response(error=str(e)) if __name__ == "__main__": server = mcp.Server(handler=MyMCPHandler()) server.start() # Defaults to port 7000 print("MCP server started on port 7000...") try: server.join() # Keep the server running except KeyboardInterrupt: print("Shutting down server...") server.stop() ``` ```python # client.py (MCP Client - for testing) import mcp import json def send_mcp_request(command, arguments): """Sends an MCP request and returns the response.""" try: client = mcp.Client() response = client.send_message(mcp.Message(command=command, arguments=arguments)) client.close() return response.result, response.error except Exception as e: return None, str(e) if __name__ == "__main__": # Example 1: Call the 'Log' keyword result, error = send_mcp_request("log_message", {"message": "Hello from MCP!"}) if error: print("Error:", error) else: print("Log Result:", result) # Example 2: Call the 'Get Variable Value' keyword result, error = send_mcp_request("get_variable_value", {"name": "${TEMPDIR}"}) if error: print("Error:", error) else: print("Variable Value:", result) ``` **Explanation of the Example** * **`server.py`:** * Imports the `mcp` library and `robot.libraries.BuiltIn`. Replace `robot.libraries.BuiltIn` with your actual Robot Framework library. * `execute_keyword` function: This is the crucial part. It takes a keyword name and arguments, and then uses `BuiltIn().run_keyword()` (or the equivalent for your library) to execute the keyword. Error handling is included. * `MyMCPHandler`: This class inherits from `mcp.Handler` and overrides the `handle_message` method. This method is called whenever the server receives an MCP message. * It extracts the command name and arguments from the message. * It uses a series of `if/elif/else` statements to determine which Robot Framework keyword to call based on the command name. * It calls `execute_keyword` to execute the keyword. * It creates an `mcp.Response` object with the result (or an error message) and returns it. * The `if __name__ == "__main__":` block creates an `mcp.Server` instance, starts it, and keeps it running until a `KeyboardInterrupt` (Ctrl+C) is received. * **`client.py`:** * Imports the `mcp` library. * `send_mcp_request` function: This function takes a command name and arguments, creates an `mcp.Message` object, sends it to the server, and returns the response. * The `if __name__ == "__main__":` block shows how to use the `send_mcp_request` function to call the `log_message` and `get_variable_value` commands. **How to Run the Example** 1. **Install `mcp`:** `pip install mcp` 2. **Save the code:** Save the server code as `server.py` and the client code as `client.py`. 3. **Run the server:** `python server.py` 4. **Run the client:** `python client.py` (in a separate terminal) You should see the "Hello from MCP!" message logged by the Robot Framework `Log` keyword, and the value of the `${TEMPDIR}` variable printed by the client. **Important Considerations and Enhancements** * **Error Handling:** The example includes basic error handling, but you should add more robust error handling to catch exceptions and return meaningful error messages to the client. * **Security:** MCP itself doesn't provide any security features. If you need to secure your MCP server, you'll need to implement your own security mechanisms (e.g., authentication, encryption). Consider using TLS/SSL for encryption. * **Argument Handling:** The example assumes that the arguments are passed as a dictionary. You might need to adjust the argument handling to match the specific requirements of your Robot Framework keywords. Consider using a more structured data format like JSON Schema to define the expected arguments for each command. * **Data Serialization:** The example uses JSON for serialization. You can use other serialization formats (e.g., Pickle, MessagePack) if needed. JSON is generally a good choice for interoperability. * **Asynchronous Operations:** If your Robot Framework keywords perform long-running operations, consider using asynchronous programming (e.g., `asyncio`) to prevent the MCP server from blocking. * **Configuration:** Use a configuration file (e.g., YAML, JSON) to store the server's port number, logging settings, and other configuration parameters. * **Logging:** Add logging to the server to track requests, responses, and errors. Use a logging library like `logging`. * **Command Discovery:** Implement a mechanism for the client to discover the available commands and their arguments. This could be done by adding a special "describe" command to the server. * **Robot Framework Listener:** You could potentially use a Robot Framework listener to automatically register keywords as MCP commands. This would reduce the amount of manual configuration required. * **Testing:** Write unit tests and integration tests to ensure that your MCP server is working correctly. **In summary, turning a Robot Framework library into an MCP server involves creating a Python script that listens for MCP requests, calls the appropriate Robot Framework keywords, and sends back the results as MCP responses. The `mcp` Python package provides a convenient way to implement the MCP protocol.** Remember to consider error handling, security, argument handling, and other important factors to create a robust and reliable service.

MCP Bridge API

MCP Bridge 是一个轻量级、快速且与 LLM 无关的代理，它通过统一的 REST API 连接到多个模型上下文协议 (MCP) 服务器。它支持在移动设备、Web 和边缘设备等不同环境中安全地执行工具。该桥梁设计灵活、可扩展，并且易于与任何 LLM 后端集成。

ITSM Integration Platform

For "MCP FOR ITSM TOOL INTEGRATION", here are a few possible translations, depending on the context: * **MCP 用于 ITSM 工具集成 (MCP yòng yú ITSM gōngjù jíchéng):** This is a direct and general translation. It means "MCP for ITSM tool integration." This is suitable if you're simply stating the purpose of MCP. * **用于 ITSM 工具集成的 MCP (Yòng yú ITSM gōngjù jíchéng de MCP):** This is another way to say the same thing as above, emphasizing the purpose first. It means "MCP used for ITSM tool integration." * **ITSM 工具集成中的 MCP (ITSM gōngjù jíchéng zhōng de MCP):** This translates to "MCP in ITSM tool integration." This is suitable if you're discussing MCP's role within the broader context of ITSM tool integration. * **MCP 与 ITSM 工具的集成 (MCP yǔ ITSM gōngjù de jíchéng):** This translates to "Integration of MCP with ITSM tools." This emphasizes the integration aspect. **Which translation is best depends on the specific context.** To give you the most accurate translation, please provide more information about how this phrase is being used. For example: * Is it a title? * Is it part of a sentence? * What is the overall topic being discussed? **Breakdown of the terms:** * **MCP:** This likely refers to a specific software or component. Without knowing what MCP stands for, I can only translate it as "MCP." * **ITSM:** Information Technology Service Management (信息技术服务管理 - Xìnxī Jìshù Fúwù Guǎnlǐ) * **Tool Integration:** 工具集成 (Gōngjù Jíchéng)

zan-mcp-server

ZAN 节点服务的模型上下文协议服务器。

Presto MCP Server by CData

Presto MCP Server by CData

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.

MCP Git Server

A Model Context Protocol server that enables LLMs to interact with Git repositories, providing tools to read, search, and manipulate Git repositories through commands like status, diff, commit, and branch operations.

Twelve Data MCP Server

Provides integration with Twelve Data API to access financial market data including historical time series, real-time quotes, and instrument metadata for stocks, forex pairs, and cryptocurrencies.

Cursor Agent Poisoning

A proof-of-concept attack that exploits Model Context Protocol (MCP) tool registration to achieve persistent agent poisoning in AI assistants like Cursor, embedding malicious instructions that persist across chat contexts without requiring tool execution.

@mcp/openverse

An MCP server that enables searching and fetching openly-licensed images from Openverse with features like filtering by license type, getting image details, and finding essay-specific illustrations.

Local Services MCP Server

A Multi-Agent Conversation Protocol Server that provides access to Google's Local Services API, enabling interaction with local service businesses information through natural language commands.

mcp-server-email MCP server

I am a language model, and I don't have an email address. I am accessed through interfaces provided by Google.