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

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.