Discover Awesome MCP Servers

arbitrum-transaction-preflight

Paid Arbitrum transaction simulation, gas estimation, approval detection and risk scoring for wallets, bots and AI agents. Pay per check with USDC through MPP or x402.

Singularity MCP Server

Connects Claude AI to TradingView Desktop for multi-angle market analysis using 10 specialized agents, delivering verdicts, confidence scores, and trade levels for symbols like Nifty 50.

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.

aster-guard

Enables scanning MCP server configurations for security risks like prompt injection, hardcoded secrets, and dangerous commands, providing risk scores and detailed reports before connecting to an AI coding assistant.

Toast MCP Integration

An MCP server that enables Claude Desktop to interact with Toast restaurant data, including sales summaries, top items, and product mix analysis.

iturri

Access verified historical market data with quality flags, funding rates, and more, supporting micropayments for AI agents and trading bots.

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!

my-mcp-server

A minimal MCP server for task management with a widget-based UI, built using the @miragon/mcp-toolkit.

Fusion 360 MCP Integration

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

tech-trends-mcp-tools

Tech Trends MCP Tools: 3 real-time data extraction tools for AI agents, powered by the Apify MCP server. Hacker News trend tracker (caught the Stripe/OpenRouter $7B acquisition rumor in real time), Product Hunt daily launch tracker, and GitHub trending repositories tracker. Pay-per-use at $0.10 per 10 items.

proxmox-mcp

A read-only MCP server for Proxmox VE that provides AI assistants with structured visibility into cluster nodes, guests, storage, and Docker workloads. It is designed to prevent any mutating operations by construction.

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.

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.

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.

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

sargel

Lets AI agents visually inspect web elements, test CSS edits in real-time, and iterate until pixel-perfect, functioning like browser DevTools for debugging UI issues.

mcp-gemini-deep-research

MCP server that runs Google Gemini Deep Research using live Chrome session cookies, enabling autonomous web research and cited report generation without an API key.

Whoop MCP Server

鏡 (Kagami)

GasBuddy MCP Price Tracker

Scrapes real-time gas prices from GasBuddy.com to find the cheapest fuel in any US city or zip code.

git-intel

A local Git intelligence MCP server that provides deep repository analytics including hotspots, churn, knowledge maps, and risk scoring, all computed from commit history without data leaving your machine.

MCP Ollama

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

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.

Python Server MCP

CoinMarketCap APIと連携し、MCP (Model Context Protocol) フレームワークを通じてリアルタイムの暗号通貨価格情報を提供する暗号通貨価格サービス。

Renderer MCP Server

AI-powered assistant for the Renderer portfolio framework. Enables users to explore documentation, validate TOML configurations, generate templates, and customize portfolios through natural language.

warp-drive-mcp

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

HomeKB MCP Server

Enables natural language interaction with a personal knowledge base stored locally on your computer, supporting semantic search, note reading, and writing through Claude Code or mobile apps.

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.

Godot Universal MCP

Connects MCP-capable AI clients to a running Godot 4 editor for scene, node, project, and debug runtime operations via a local-first architecture.

vmware-nsx

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