Discover Awesome MCP Servers

Meals MCP Server

MCP server for discovering and retrieving meal recipes from TheMealDB API, enabling search, random meals, category/ingredient filtering, and full recipe details.

PostGrid MCP Server

Enables sending letters and MICR-encoded checks, managing contacts and templates, and verifying US/Canadian addresses via the PostGrid Print & Mail and Address Verification APIs from Claude.

ShipStation MCP Server by CData

This project builds a read-only MCP server. For full read, write, update, delete, and action capabilities and a simplified setup, check out our free CData MCP Server for ShipStation (beta): https://www.cdata.com/download/download.aspx?sku=HSZK-V&type=beta

Habit Tracker AI MCP

Habit Tracker AI - MCP server providing AI-powered tools and automation by MEOK AI Labs

gorgias-mcp

Enables AI agents to manage Gorgias support tickets: list open tickets, read conversation history, draft internal notes, send outbound replies (gated), and look up customer history.

storybook-mcp

Integrates with a running Storybook instance to let AI-powered coding tools browse, inspect, and scaffold components from natural language.

UberEats MCP Server Enhanced

A production-ready MCP server for UberEats automation, featuring Redis-backed sessions, n8n integration, and enterprise-grade security, enabling login, item addition, address setting, and checkout.

digital-twin

Enables natural language control of a digital twin simulation pipeline for phone drop tests, converting LS-DYNA .k meshes to solid .k files with hand grip poses using 7 MCP tools.

HacknPlan MCP

Enables Claude to manage game development projects on HacknPlan, including tasks, boards, milestones, and GDD documents through natural language.

AWS Documentation MCP Server

Enables users to access, search, and get recommendations from AWS documentation through natural language queries. Supports both global AWS documentation and AWS China documentation with tools to fetch pages, search content, and discover related resources.

ai.cabrini/market-data

Provides US stock market data for AI agents, including intraday and daily bars, SEC fundamentals, filings, and insider data, with pay-per-query via USDC on Base.

Remote MCP Server

A server implementation of the Model Context Protocol (MCP) that runs on Cloudflare Workers, enabling AI assistants like Claude to securely access external tools and APIs through OAuth authentication.

KiotViet MCP Server

Enables AI assistants to manage KiotViet retail and F\&B operations including products, orders, customers, invoices, and inventory through the Public API. Features 36 integrated tools with automatic token refresh, middleware chain support, and configurable presets for different access levels.

yfinance-mcp

MCP server wrapping yfinance to provide stock market data, financials, and analytics via 24 tools.

AgentRecall

A local-first memory for AI coding agents. AgentRecall turns the feedback and failures you run into while coding into reusable rules, then serves the right ones back — on the command line or directly to Claude Code over MCP. Everything stays on your machine: no cloud sync, no web UI, no API keys.

User Info MCP Server

An MCP server providing tools for user information management with capabilities for retrieving, searching, and adding user data stored in a JSON file.

rlm-tools

An MCP server that provides a persistent sandbox for AI coding agents to explore codebases server-side, returning only compact summaries to reduce context consumption.

Zyxel Switch MCP Server

Enables AI applications to interact with Zyxel switches via CLI for network configuration, monitoring, and management, supporting SSH/Telnet sessions and MCP-compliant tools, resources, and prompts.

Cocos MCP

Bridge for Cocos Creator 3.8.x enabling code agents to control the editor via 43+ tools for scene manipulation, asset management, UI creation, animation, and more.

aftr

Enables AI agents to control Adobe After Effects to create videos programmatically, with commands for comps, layers, effects, and rendering.

Changes Memory MCP

A local MCP server that stores user-approved corrections, preferences, and reusable criteria in plain Markdown files, with separate global and project memory. It provides tools to list, search, and retrieve relevant criteria to help agents avoid repeating mistakes.

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.

MCP Chat

MCP server providing tools for LLMs (via Ollama) to get current time, calculate arithmetic, list files, and read project README, with a web chat UI.

gsc-mcp

MCP server for querying Google Search Console data — search analytics, URL inspection, sitemap monitoring, and more — read-only tools for any MCP-compatible AI client.

termdat-mcp

MCP server for TERMDAT, the terminology database of the Swiss Federal Administration, giving AI agents officially validated designations of Swiss authorities, departments, and legal acts across DE/FR/IT/EN with source references and validation status.

MCP Ollama

Integrates Ollama's local AI models with MCP clients, enabling listing models, viewing model details, and asking questions to models.

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.

Buggy

A multi-agent system that autonomously analyzes code, proves bugs with formal certificates, generates repairs, and validates patches, all over the Model Context Protocol.

vmware-nsx

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

la-legislative

A read-only MCP server for querying Los Angeles City legislative data - Council Files, votes, member activity, and Neighborhood Council engagement - through parameterized tools without raw SQL.