Discover Awesome MCP Servers

ANSYS MCP Server

Enables natural language-driven ANSYS simulations (Fluent, Mechanical, Geometry) with automatic TUI script generation for reproducibility.

io.github.DiaaAj/a-mem-mcp

A-MEM is a self-evolving memory system for coding agents that automatically organizes knowledge into a Zettelkasten-style graph with dynamic relationships, enabling semantic and structural search.

garmin-mcp-triathlon

Enables triathlon coaches and athletes to interact with Garmin Connect, including retrieving health/activity data, building and uploading structured workouts (cycling, running, swimming, brick), and accessing coaching analytics like readiness, load, and performance trends.

Tavily Cloud MCP

A cloud MCP server providing Tavily-powered tools for web search, extraction, crawling, mapping, and research, with multi-key load balancing, real-time quota tracking, and a web admin panel.

etsy-mcp-server

A full-featured MCP server for the Etsy Open API v3 that enables managing an Etsy shop, including listings, inventory, images, digital files, and orders, through Claude or any MCP-compatible client.

Ghost MCP Server

Enables AI assistants to securely manage Ghost CMS blogs, including posts, pages, members, newsletters, tiers, and more via natural language.

bhoonidhi-mcp

An MCP server that lets AI agents search, save, preview, download, and cart satellite scenes from ISRO's Bhoonidhi portal in natural language, with search and saved queries requiring no login and downloads/cart operations using an out-of-band session.

MCP Spark Documentation Server

Provides full-text search and retrieval tools for Apache Spark documentation using SQLite FTS5 with BM25 ranking. It enables AI assistants to efficiently search, filter by section, and read specific Spark documentation pages.

TradingView MCP Bridge

Enables AI assistants to interact with locally running TradingView Desktop for chart analysis, Pine Script development, and workflow automation via Chrome DevTools Protocol.

ICON MCP v103

Provides AI agents and LLMs with secure access to the ICON MCP v103 API via Bearer tokens or HTTP 402 payment protocols. It enables standardized interaction with market data and API endpoints through the Model Context Protocol.

MCP Webhook Server

An MCP server that enables sending data to webhooks via HTTP POST for both local and remote team environments. It provides a tool for relaying task descriptions, custom metadata, and automated notifications to external services.

MCP Sheet Parser

A Model Context Protocol server designed for AI assistants to directly process spreadsheet files, enabling them to read, display, modify, and save various table formats like CSV and Excel.

LAIN-mcp

A persistent code-intelligence MCP server that builds a queryable knowledge graph of your codebase, enabling AI assistants to perform cross-file structural reasoning, dependency analysis, and blast radius detection.

Claude Deep Think MCP Server

Provides proactive deep analytical thinking using Claude Sonnet 4.5 before writing code, helping analyze errors, requirements, and architectural decisions to produce better quality code with fewer iterations.

taiwan-isbn-mcp

A MCP server for querying Taiwan ISBN book data, supporting search by title, author, publisher, batch ISBN lookup, and browsing new books.

recon-fuzz-chimera-mcp

Recon Fuzz Chimera MCP knowledge to multi fuzzing enviornments compatibility in Solidity Smart contracts

HubSpot MCP Server

A Type 4 OAuth MCP server that enables AI assistants to interact with HubSpot CRM objects like contacts, companies, deals, and tickets.

Eldermind Astro Engine API

MCP server exposing eight esoteric calculation systems (Western/Vedic astrology, Human Design, Gene Keys, and more) through 14 tools, with deterministic profiles, partial success, and OAuth integration.

polyhaven-mcp

Enables AI assistants to search and retrieve metadata and download links for CC0 HDRIs, textures, and 3D models from PolyHaven's public library.

tracetify-mcp

MCP server for Tracetify — trace how any product actually grew, without leaving Claude Code or Cursor.

FAOSTAT MCP Server

Enables AI assistants to query the full FAOSTAT API for global food and agriculture statistics, allowing natural-language questions about crop production, trade, food security, emissions, and more.

mirador-mcp

Thin MCP adapter for Mirador Core that exposes data tools through the Core Internal API, enabling business data queries and schema exploration.

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.

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.

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!

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.

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.