Discover Awesome MCP Servers

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.

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.

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.

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.

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.

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.

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.

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.

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.

RobotFrameworkLibrary-to-MCP

Okay, here's a breakdown of how to turn a Robot Framework library into an MCP (Message Center Protocol) server, along with explanations and considerations: **Understanding the Goal** The core idea is to expose the functionality of your Robot Framework library as a service that can be accessed remotely via MCP. This allows other systems (clients) to call the keywords in your library without needing to run Robot Framework directly on the client machine. **Key Components and Concepts** 1. **Robot Framework Library:** This is your existing library containing the keywords you want to expose. 2. **MCP Server:** A server that listens for MCP requests, processes them, and sends back responses. You'll need to implement this server. 3. **MCP Client:** The system that sends requests to your MCP server to execute keywords. 4. **Serialization/Deserialization:** MCP involves sending data (keyword names, arguments, return values) over a network. You'll need to serialize data into a format suitable for transmission (e.g., JSON, XML, Protocol Buffers) and deserialize it on the other end. **General Steps** 1. **Choose an MCP Implementation (or Build Your Own):** * **Existing MCP Libraries (Python):** Check if there are existing Python libraries that provide MCP server/client functionality. Search for "Python MCP library" or "Message Center Protocol Python." If you find a suitable library, it will greatly simplify the process. I don't have specific recommendations without knowing your exact requirements, but this is the first place to look. * **Roll Your Own (using sockets):** If you can't find a suitable library, you'll need to implement the MCP protocol yourself using Python's socket library. This is more complex but gives you full control. You'll need to understand the MCP specification. 2. **Create the MCP Server (Python):** * **Import Your Robot Framework Library:** In your Python MCP server code, import the Robot Framework library you want to expose. * **Listen for Connections:** Use the chosen MCP library (or socket code) to listen for incoming connections on a specific port. * **Receive MCP Requests:** When a client connects, receive the MCP request. The request will typically contain: * The name of the Robot Framework keyword to execute. * The arguments to pass to the keyword. * **Deserialize the Request:** Convert the received data (e.g., JSON string) into Python data structures (e.g., a dictionary or list). * **Execute the Keyword:** ```python # Assuming you have your library imported as 'mylibrary' def handle_mcp_request(keyword_name, args): try: # Use getattr to dynamically call the keyword keyword_function = getattr(mylibrary, keyword_name) result = keyword_function(*args) # Execute the keyword return result, None # Return result and no error except Exception as e: return None, str(e) # Return None and the error message ``` * **Serialize the Response:** Convert the result (or any error message) into a format suitable for sending back to the client (e.g., JSON). * **Send the Response:** Send the serialized response back to the client. * **Close the Connection:** Close the connection with the client. 3. **Create the MCP Client (Python or other language):** * **Connect to the Server:** Use the chosen MCP library (or socket code) to connect to the MCP server's address and port. * **Create the MCP Request:** Construct the MCP request, including the keyword name and arguments. * **Serialize the Request:** Convert the request data into the chosen format (e.g., JSON). * **Send the Request:** Send the serialized request to the server. * **Receive the Response:** Receive the response from the server. * **Deserialize the Response:** Convert the received data back into Python data structures. * **Process the Result:** Handle the result (or any error message) returned by the server. * **Close the Connection:** Close the connection with the server. **Example (Illustrative - Using Sockets and JSON for Simplicity)** This is a simplified example to illustrate the concepts. It's not a complete, production-ready solution. *Server (server.py)* ```python import socket import json import mylibrary # Your Robot Framework library HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) def handle_request(data): try: request = json.loads(data.decode('utf-8')) keyword_name = request['keyword'] args = request['args'] keyword_function = getattr(mylibrary, keyword_name) result = keyword_function(*args) return json.dumps({'result': result, 'error': None}) except Exception as e: return json.dumps({'result': None, 'error': str(e)}) with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Server listening on {HOST}:{PORT}") conn, addr = s.accept() with conn: print(f"Connected by {addr}") while True: data = conn.recv(1024) if not data: break response = handle_request(data) conn.sendall(response.encode('utf-8')) ``` *Client (client.py)* ```python import socket import json HOST = '127.0.0.1' # The server's hostname or IP address PORT = 65432 # The port used by the server with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) request = { 'keyword': 'my_keyword', # Replace with your keyword name 'args': ['arg1', 'arg2'] # Replace with your arguments } request_json = json.dumps(request) s.sendall(request_json.encode('utf-8')) data = s.recv(1024) print('Received:', repr(data)) ``` *Example Robot Framework Library (mylibrary.py)* ```python def my_keyword(arg1, arg2): """This is a sample keyword.""" return f"Keyword called with {arg1} and {arg2}" def another_keyword(number): return number * 2 ``` **Important Considerations** * **Error Handling:** Robust error handling is crucial. Catch exceptions in the server and send meaningful error messages back to the client. * **Security:** If you're exposing this service over a network, consider security implications. Use encryption (e.g., TLS/SSL) to protect the data in transit. Implement authentication and authorization to control who can access the service. * **Data Types:** Be mindful of data types when serializing and deserializing. Ensure that the client and server agree on how to represent data (e.g., dates, numbers). * **Concurrency:** If you expect multiple clients to connect simultaneously, you'll need to handle concurrency in your server (e.g., using threads or asynchronous programming). * **MCP Specification:** If you are implementing the MCP protocol yourself, carefully study the MCP specification to ensure compliance. * **Existing Libraries:** Before you start writing a lot of code, thoroughly research existing Python libraries that might provide MCP functionality. This can save you a significant amount of time and effort. **How to Run the Example** 1. **Save the files:** Save the code as `server.py`, `client.py`, and `mylibrary.py` in the same directory. 2. **Run the server:** Open a terminal and run `python server.py`. 3. **Run the client:** Open another terminal and run `python client.py`. The client will send a request to the server, the server will execute the `my_keyword` function from `mylibrary.py`, and the client will print the response. Remember to replace `"my_keyword"` and the arguments in `client.py` with the actual keyword and arguments from your Robot Framework library. Also, replace `mylibrary` in `server.py` with the actual name of your library. This detailed explanation and example should give you a solid foundation for turning your Robot Framework library into an MCP server. Good luck!

GasBuddy MCP Price Tracker

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

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.

Python Server MCP

Layanan harga mata uang kripto yang menyediakan informasi harga kripto waktu nyata melalui kerangka kerja MCP (Model Context Protocol) dengan integrasi API CoinMarketCap.

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.

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.

MCP Ollama

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

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.

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.

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.

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.

vmware-nsx

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

obsidian-mcp-complete

Local-first MCP server for Obsidian vaults with 66 tools for reading, writing, searching, and managing notes, tasks, graphs, and more. Works without Obsidian running and requires no plugins.

quickbooks-desktop-mcp

Provides safe, structured access to a local QuickBooks Desktop company file for reading and writing transactions, with automatic undo logging.

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 LLDB Server

Enables AI assistants to start and manage LLDB debugging sessions, including loading programs, setting breakpoints, stepping through code, and examining memory.

coronium-proxy-mcp

Enables management of 4G/5G mobile proxies from Coronium.io, allowing users to list, rotate, replace, set rotation intervals, buy, renew, and manage subscriptions directly from MCP-compatible AI tools.