Discover Awesome MCP Servers

nexi-xpay-mcp-server

Enables AI assistants to query orders, transaction details, warnings/anomalies, and payment methods from your Nexi XPay merchant account.

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.

mcp-lock

MCP servers are installed via npx -y @scope/package — which silently downloads the latest version every time your AI tool starts, with no integrity check. mcp-lock fixes this by recording exact tarball hashes on first run and detecting any changes on every run after that — the same guarantee npm ci gives you for Node.js projects.

RobotFrameworkLibrary-to-MCP

Okay, I can help you understand how to turn a Robot Framework library into an MCP (Message Center Protocol) server. It's a bit of a complex process, but here's a breakdown of the concepts and steps involved, along with considerations: **Understanding the Goal** First, let's clarify what we mean by "turning a Robot Framework library into an MCP server." Essentially, you want to expose the functionality of your Robot Framework library so that other applications (clients) can access and use it remotely via the MCP protocol. **Key Concepts** * **Robot Framework Library:** A collection of keywords (functions) that can be used in Robot Framework test cases. * **MCP (Message Center Protocol):** A communication protocol used for exchanging messages between applications. It's often used in embedded systems and other scenarios where a lightweight, reliable communication mechanism is needed. It defines how messages are formatted, sent, and received. * **Server:** A program that listens for incoming requests from clients and provides services in response. In this case, the server will receive MCP messages, interpret them as requests to execute Robot Framework library keywords, and send back the results as MCP messages. * **Client:** A program that sends requests to the server. **General Steps** Here's a high-level outline of the steps involved: 1. **Choose an MCP Implementation/Library:** You'll need a library or framework that handles the MCP protocol details (message encoding/decoding, connection management, etc.). There isn't a single, universally standard MCP library, so you'll need to find one that suits your needs and programming language. If you're using Python (which is common with Robot Framework), you might need to adapt an existing MCP implementation or create your own. 2. **Create a Server Application:** This will be the core of your MCP server. It will: * **Listen for Incoming Connections:** Set up a socket to listen for incoming TCP/IP connections from MCP clients. * **Receive MCP Messages:** Receive and decode MCP messages from clients. * **Parse MCP Messages:** Determine which Robot Framework keyword the client is requesting to execute and extract any arguments. * **Execute Robot Framework Keywords:** Call the appropriate keyword from your Robot Framework library with the provided arguments. * **Format Results as MCP Messages:** Take the results returned by the Robot Framework keyword (success/failure, return values) and encode them into MCP messages. * **Send MCP Response:** Send the MCP response message back to the client. * **Handle Errors:** Gracefully handle errors that occur during message processing or keyword execution. 3. **Map MCP Messages to Robot Framework Keywords:** You'll need a mechanism to map incoming MCP messages to specific keywords in your Robot Framework library. This could be a simple lookup table or a more sophisticated routing system. 4. **Implement Data Serialization/Deserialization:** MCP messages are typically byte streams. You'll need to serialize data (arguments to keywords, return values) into a format suitable for transmission over MCP and deserialize it on the receiving end. Common serialization formats include: * **JSON:** Human-readable and widely supported. * **Protocol Buffers (protobuf):** Efficient and language-neutral. * **MessagePack:** Another efficient binary serialization format. * **Custom Binary Format:** If you need maximum performance or have very specific requirements, you could define your own binary format. 5. **Error Handling:** Implement robust error handling to catch exceptions during keyword execution, message parsing, or network communication. Send appropriate error messages back to the client via MCP. **Example (Conceptual - Python)** ```python # This is a simplified example and requires a real MCP library # and proper error handling. import socket import json from robot.api import logger # For Robot Framework logging # Assume you have a Robot Framework library called 'MyLibrary' from MyLibrary import MyLibrary # MCP Configuration HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) # Initialize Robot Framework library my_library = MyLibrary() def handle_client(conn, addr): print(f"Connected by {addr}") while True: data = conn.recv(1024) # Receive data from the client if not data: break try: # Decode MCP message (assuming JSON for simplicity) message = json.loads(data.decode('utf-8')) keyword = message['keyword'] args = message.get('args', []) # Arguments are optional # Execute Robot Framework keyword try: result = getattr(my_library, keyword)(*args) # Call the keyword response = {'status': 'success', 'result': result} except Exception as e: logger.error(f"Error executing keyword: {e}") response = {'status': 'error', 'message': str(e)} # Encode response as MCP message (JSON) response_data = json.dumps(response).encode('utf-8') conn.sendall(response_data) except json.JSONDecodeError: error_message = {'status': 'error', 'message': 'Invalid JSON'} conn.sendall(json.dumps(error_message).encode('utf-8')) except AttributeError: error_message = {'status': 'error', 'message': f'Keyword "{keyword}" not found'} conn.sendall(json.dumps(error_message).encode('utf-8')) except Exception as e: logger.exception("Unexpected error") error_message = {'status': 'error', 'message': f'Internal server error: {e}'} conn.sendall(json.dumps(error_message).encode('utf-8')) conn.close() print(f"Connection closed with {addr}") def start_server(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Listening on {HOST}:{PORT}") while True: conn, addr = s.accept() handle_client(conn, addr) # Handle each client in a separate thread for concurrency (recommended) if __name__ == "__main__": start_server() ``` **Important Considerations** * **Security:** If you're exposing your Robot Framework library over a network, security is paramount. Consider: * **Authentication:** Verify the identity of clients before allowing them to execute keywords. * **Authorization:** Control which clients have access to which keywords. * **Encryption:** Encrypt the MCP messages to protect sensitive data in transit (e.g., using TLS/SSL). * **Concurrency:** If you expect multiple clients to connect to your server simultaneously, you'll need to handle concurrency properly (e.g., using threads or asynchronous programming). The example above shows a basic single-threaded server. For production, you'd want to use threads or asyncio. * **Error Handling:** Implement robust error handling to catch exceptions during keyword execution, message parsing, or network communication. Send appropriate error messages back to the client via MCP. * **Data Types:** Carefully consider how you'll handle data types when passing arguments to keywords and returning results. MCP typically deals with byte streams, so you'll need to serialize and deserialize data appropriately. * **Performance:** If performance is critical, choose efficient serialization formats and optimize your code. * **MCP Library Choice:** The choice of MCP library will significantly impact the complexity of your implementation. If a suitable library doesn't exist, you might need to implement the MCP protocol yourself, which is a non-trivial task. **In summary:** Turning a Robot Framework library into an MCP server involves creating a server application that listens for MCP messages, parses them to determine which Robot Framework keyword to execute, executes the keyword, and sends the results back to the client as MCP messages. You'll need to choose an MCP library, implement data serialization/deserialization, and handle concurrency and security. The complexity of the task depends on the specific requirements of your application and the availability of suitable MCP libraries. The example code provides a basic starting point, but it needs to be adapted and extended to meet the needs of a real-world application. Remember to prioritize security and error handling.

Q1-Reviewer-MCP

An MCP server that simulates a ruthless Q1 journal reviewer to analyze academic manuscripts for red flags and generate a formatted .docx decision letter.

Fusion 360 MCP Integration

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

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.

code-rules-mcp

Here are a few ways to translate "MCP server for reliably reading code rules into Agentic AI context" into Spanish, with slightly different nuances: * **Opción 1 (Más directa):** Servidor MCP para leer de forma fiable reglas de código en el contexto de IA Agéntica. * **Opción 2 (Enfatizando la fiabilidad):** Servidor MCP para la lectura fiable de reglas de código en el contexto de IA Agéntica. * **Opción 3 (Usando "incorporar" para "reading into"):** Servidor MCP para incorporar de forma fiable reglas de código al contexto de IA Agéntica. * **Opción 4 (Más descriptiva):** Servidor MCP para la lectura e integración fiable de reglas de código en el contexto de la IA Agéntica. **Breakdown of the choices:** * **MCP Server:** "Servidor MCP" is a direct translation and likely the best choice if "MCP" is a well-known acronym in your target audience. If not, you might need to explain what MCP stands for. * **Reliably reading:** "Leer de forma fiable" and "Lectura fiable" are both good options. The first is more active, the second more passive. "Incorporar de forma fiable" is also a good option if you want to emphasize the integration aspect. * **Code rules:** "Reglas de código" is the standard translation. * **Agentic AI context:** "Contexto de IA Agéntica" is a direct translation and generally understood. **Recommendation:** I would recommend **Opción 2: Servidor MCP para la lectura fiable de reglas de código en el contexto de IA Agéntica.** It's concise, accurate, and emphasizes the reliability aspect. However, if you need to emphasize the integration of the rules, **Opción 3** is a good alternative.

HubSpot MCP Server

A Type 4 OAuth MCP server that enables AI assistants to interact with HubSpot CRM objects like contacts, companies, deals, and tickets.

GitHub MCP Server

Here are a few ways to translate "Github MCP Server to integrate with CI flows" into Spanish, with slightly different nuances: * **Opción 1 (Más directa):** Servidor MCP de Github para integrarse con flujos de CI. * **Opción 2 (Un poco más explicativa):** Servidor MCP de Github para la integración con flujos de trabajo de CI. * **Opción 3 (Enfatizando el uso):** Servidor MCP de Github para usar con flujos de CI. * **Opción 4 (Más formal):** Servidor MCP de Github para su integración en flujos de CI. **Explanation of Choices:** * **MCP:** It's likely best to leave "MCP" as is, assuming it's an acronym or specific term. If you know what it stands for, you *could* translate that, but without knowing the context, it's safer to keep it as "MCP." * **CI Flows:** "CI flows" is commonly understood in the tech world, so "flujos de CI" is a good translation. "Flujos de trabajo de CI" is a bit more explicit ("workflow" is added). * **Integrate:** "Integrar" is the direct translation of "integrate." "Integrarse" is the reflexive form, meaning "to integrate oneself" or "to be integrated." Both are valid, but "integrarse" might be slightly more common in this context. * **Para:** This is the most common translation of "to" in this context. Therefore, I would recommend **Opción 2: Servidor MCP de Github para la integración con flujos de trabajo de CI.** It's clear and accurate.

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.

FAOSTAT MCP Server

Enables AI assistants to query the full FAOSTAT API for global food and agriculture statistics, allowing natural-language questions about crop production, trade, food security, emissions, and more.

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.

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.

Cache Overflow

AI agent knowledge marketplace where agents share solutions and earn tokens. Search, publish, and unlock previously solved problems to reduce token usage and computational costs.

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.

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.

grasp

Self-hosted Browser Using Agent with built-in MCP, A2A support.

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.

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

Un servidor de Protocolo de Contexto de Modelo (MCP) para la aplicación de gestión de tareas TickTick.

MCP-Foundry

MCP Foundry

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.

my-minimax-mcp

Wraps MiniMax AI as an autonomous code executor for Claude Code, offloading coding tasks to save Claude subscription tokens.

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.