Discover Awesome MCP Servers

DevsContext

DevsContext is an MCP server that provides AI coding agents with synthesized engineering context—requirements, decisions, architecture, and standards—from tools like Jira and Slack. It fetches and synthesizes relevant information on demand to help agents work on tasks correctly.

vmware-nsx

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

nexi-xpay-mcp-server

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

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.

ai-verify-mcp

An MCP server for validating AI-generated code through automated browser testing, evidence collection, and intelligent diagnostics.

figma-mcp

Read-only Figma MCP server that enables design-to-code workflows by talking to the Figma REST API with a personal access token, for use with Claude Code and GitHub Copilot.

everything-slim

Token-optimized MCP server that reduces context window usage by 59.5% by grouping 12 tools into 5 semantic operations, preserving all original functionality for AI assistants.

ChunkTuner

Tools to benchmark chunking strategies for your RAG corpus.

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.

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.

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.

Python Server MCP

Un servicio de precios de criptomonedas que proporciona información de precios de criptomonedas en tiempo real a través de un marco MCP (Protocolo de Contexto de Modelo) con integración de la API de CoinMarketCap.

TOPdesk MCP Server

Enables interaction with TOPdesk service management platform through comprehensive API integration. Supports incident management, operator/person operations, document conversion, and FIQL querying for streamlined IT service desk workflows.

Obsidian MCP Server

Connects AI assistants directly to Obsidian vaults with intelligent note creation using templates, semantic search, smart tagging to avoid duplicates, and specialized agent roles (Guardian, Researcher, Connection Weaver) for managing knowledge bases.

warp-drive-mcp

MCP server that exposes WarpDrive and EmberData docs as tools, enabling assistants to look up real documentation instead of guessing.

ssh-mcp-jumpserver

Enables AI agents to execute commands on remote servers via SSH with dynamic host discovery through JumpServer and automatic username fallback.

gemini-search-mcp

MCP server for web search powered by Google AI Mode (Gemini). Enables any AI agent to search the web in real-time for free and without rate limits.

Apifox MCP

Enables AI assistants to automatically manage Apifox API documentation by importing OpenAPI/Swagger specifications and exporting existing API structures. Supports batch operations, intelligent deprecation marking, and smart scope detection for partial module imports.

execkit-mcp

Stateful, structured, safe shell sessions for AI agents, on real infrastructure.

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.

SentinelAI MCP Server

Enables secure enterprise AI agents to access internal tools like GitHub, Gmail, Calendar, file systems, databases, and knowledge bases through the Model Context Protocol, with built-in security, audit, and observability.

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.

@rosalinddb/mcp

Model Context Protocol server for RosalindDB, enabling AI clients to create datasets, ingest vectors, run similarity queries, and check usage on a cost-optimized vector search database.

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.

Chrome MCP Server (Security Hardened)

Enterprise-grade Chrome automation for AI agents with compliance-ready logging, post-quantum encryption, and SIEM integration.

Arcane MCP Server

Manage your entire Docker infrastructure through natural language with 180 tools.

Loop MCP Server

Enables LLMs to process arrays item-by-item or in batches with a specific task, storing and retrieving results with optional summarization after completion.

salonrunner-mcp

Enables AI assistants to find, book, and cancel salon appointments via SalonRunner accounts. Self-hosted for local or remote use.