Discover Awesome MCP Servers

NexBrowser MCP Server

Connects MCP clients to a local NexBrowser desktop app for browser automation, environment management, and session-isolated page inspection via the Model Context Protocol.

FlowDot MCP Server

Connect any MCP-compatible AI client to the entire FlowDot platform, enabling management of workflows, recipes, custom nodes, apps, knowledge bases, agent toolkits, and community features.

AMEVA MCP Toolkit

A Model Context Protocol server integrating developer tools including Git control, document conversion, remote SSH execution, database operations, and utilities for automation and development productivity.

Product MCP Server

Enables natural language product management (CRUD) with multiple classification methods, including LLM-based and fast ML classifiers, for product creation, listing, updating, and deletion via a chat interface.

Azure MCP Server

Integrates Azure cloud services with GenAI applications via the Model Context Protocol, enabling comprehensive Azure API coverage with enterprise-ready features.

codex-photoshop-psd-automation

Enables Codex to orchestrate Adobe Photoshop via MCP to reconstruct AI-generated artwork into editable, validated layered PSDs, with automated saving, reopening, and verification.

simple-parallels

MCP server for managing Parallels Desktop VMs, including lifecycle operations and snapshots.

PostgreSQL MCP Server

Enables users to perform SQL query execution, schema exploration, and performance analysis on PostgreSQL databases through any MCP-compatible client. It prioritizes security with read-only protection by default and provides guided workflows for database documentation and optimization.

obsidian-bridge

Connects Codex and compatible ChatGPT desktop plugin hosts to local Obsidian vaults for search, reading, and optional note creation/appending.

sevdesk MCP Server

Enables management of sevdesk accounting and invoicing tasks including contacts, invoices, and offers through the Model Context Protocol. It provides tools for financial reporting, tax summaries, and KPI dashboards directly within AI interfaces.

Agent Lab

Run and test agentic systems in isolated Docker sandboxes, varying system prompts, models, and task prompts while capturing full behavior traces via MCP tools.

Kali MCP Server

Production-grade MCP server that exposes Kali Linux penetration testing tools to AI agents, enabling automated reconnaissance, web application testing, vulnerability assessment, and more.

SitePulsar MCP Server

Measures and improves how findable, readable, and usable a website is to AI answer engines and autonomous AI agents through hosted AEO audit tools.

Anam MCP Server

Enables managing AI personas, avatars, voices, and sessions from any MCP client, for integration with Anam AI.

Agent QA

Evaluates MCP servers by running read-only checks and returning a graded report with an A-F letter grade.

Godalo

Affiliate product search for AI agents. Indexes structured merchant feeds — real prices, live stock, affiliate links built in. Works with any MCP client.

MCP GitHub Dashboard

A comprehensive GitHub project dashboard for MCP that monitors multiple repositories, pull requests, issues, deployments, and health status through AI assistants.

browser-smoke

Enables browser automation and smoke testing via Playwright, with tools for navigation, DOM interaction, screenshots, network capture, and more.

Cloudflare Email MCP Server

Manages Cloudflare KV namespaces and automates email processing from ProtonMail Bridge to structured KV storage with folder mapping.

roiq-os-mcp

Lightweight connector to operate ROIQ OS from Claude Code, enabling management of spaces, pages, boards, tables, cards, scripts, and more within token-based permissions.

mcp-data-delaware

Query and explore Delaware Open Data datasets via Socrata API, including search, filtering, and metadata retrieval.

API Wrapper MCP Server

Okay, I understand you want to create an MCP (Mod Control Panel) server that can interact with *any* API. This is a broad request, as the specific implementation will depend heavily on the API you want to control and the features you want to expose in your MCP. Here's a breakdown of the concepts, a general outline, and some code snippets to get you started. Keep in mind this is a *framework* and you'll need to adapt it to your specific needs. **Core Concepts** * **MCP (Mod Control Panel):** A web-based interface (or other UI) that allows users to manage and control aspects of a system (in this case, an API). It typically involves: * **User Interface (UI):** Buttons, forms, tables, etc., for interacting with the API. * **Backend Server:** Handles requests from the UI, interacts with the target API, and manages user authentication/authorization. * **Database (Optional):** For storing user data, configuration settings, and potentially API response data. * **API (Application Programming Interface):** A set of rules and specifications that allow different software systems to communicate with each other. You'll need to understand the specific API you're targeting (its endpoints, request methods, data formats, authentication methods, etc.). * **Server-Side Framework:** A framework like Flask (Python), Express.js (Node.js), Django (Python), or Spring Boot (Java) to build the backend server. These frameworks provide tools for routing requests, handling data, and interacting with databases. * **Frontend Framework (Optional):** A framework like React, Angular, or Vue.js to build a dynamic and interactive user interface. If you want a simpler interface, you can use plain HTML, CSS, and JavaScript. **General Outline** 1. **Choose a Server-Side Framework:** Select a framework you're comfortable with. I'll use Flask (Python) in the examples below, but the principles apply to other frameworks. 2. **Set up the Backend Server:** * Create a project directory. * Install the necessary dependencies (e.g., `pip install flask requests`). * Create a main application file (e.g., `app.py`). * Define routes (endpoints) for your MCP. * Implement functions to handle requests to these routes. These functions will: * Receive data from the UI. * Make requests to the target API. * Process the API response. * Return data to the UI. 3. **Design the User Interface:** * Create HTML templates for your MCP pages. * Use CSS to style the pages. * Use JavaScript to handle user interactions and make requests to the backend server (if using a frontend framework, you'll use its components and data binding mechanisms). 4. **Implement API Interaction:** * Use a library like `requests` (Python) or `axios` (JavaScript) to make HTTP requests to the target API. * Handle authentication (if required by the API). * Handle different request methods (GET, POST, PUT, DELETE, etc.). * Handle different data formats (JSON, XML, etc.). * Implement error handling to gracefully handle API errors. 5. **Implement User Authentication/Authorization (Optional):** * Use a library like Flask-Login (Python) or Passport.js (Node.js) to handle user authentication. * Implement roles and permissions to control access to different features of the MCP. 6. **Database Integration (Optional):** * Choose a database (e.g., SQLite, PostgreSQL, MySQL). * Use an ORM (Object-Relational Mapper) like SQLAlchemy (Python) or Sequelize (Node.js) to interact with the database. * Store user data, configuration settings, and potentially API response data in the database. **Example (Flask - Python)** ```python from flask import Flask, render_template, request, jsonify import requests import json app = Flask(__name__) # Replace with your API's base URL API_BASE_URL = "https://api.example.com" # Example API # Replace with your API key or authentication token (if required) API_KEY = "YOUR_API_KEY" # Function to make API requests def make_api_request(endpoint, method="GET", data=None, headers=None): url = API_BASE_URL + endpoint try: if headers is None: headers = {} # Add API key to headers if needed if API_KEY: headers['Authorization'] = f'Bearer {API_KEY}' # Or 'X-API-Key': API_KEY if method == "GET": response = requests.get(url, headers=headers) elif method == "POST": response = requests.post(url, json=data, headers=headers) elif method == "PUT": response = requests.put(url, json=data, headers=headers) elif method == "DELETE": response = requests.delete(url, headers=headers) else: return {"error": "Invalid method"}, 400 response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) return response.json(), response.status_code except requests.exceptions.RequestException as e: print(f"API request failed: {e}") return {"error": str(e)}, 500 except json.JSONDecodeError as e: print(f"JSON decode error: {e}") return {"error": "Invalid JSON response from API"}, 500 # Example route to get data from the API @app.route("/get_data", methods=["GET"]) def get_data(): endpoint = "/data" # Replace with your API endpoint data, status_code = make_api_request(endpoint) return jsonify(data), status_code # Example route to post data to the API @app.route("/post_data", methods=["POST"]) def post_data(): endpoint = "/data" # Replace with your API endpoint request_data = request.get_json() # Get JSON data from the request data, status_code = make_api_request(endpoint, method="POST", data=request_data) return jsonify(data), status_code # Example route to display a form (you'll need to create a template) @app.route("/", methods=["GET"]) def index(): return render_template("index.html") # Create an index.html template if __name__ == "__main__": app.run(debug=True) ``` **`templates/index.html` (Example)** ```html <!DOCTYPE html> <html> <head> <title>MCP</title> </head> <body> <h1>MCP</h1> <button onclick="getData()">Get Data</button> <div id="data-output"></div> <script> function getData() { fetch('/get_data') .then(response => response.json()) .then(data => { document.getElementById('data-output').innerText = JSON.stringify(data, null, 2); }); } </script> </body> </html> ``` **Explanation:** * **`make_api_request()`:** This function encapsulates the logic for making API requests. It takes the endpoint, method, data, and headers as arguments. It handles different HTTP methods (GET, POST, PUT, DELETE), adds the API key to the headers (if needed), and handles errors. It returns the JSON response from the API and the HTTP status code. * **`/get_data` route:** This route handles GET requests to `/get_data`. It calls `make_api_request()` to get data from the API and returns the data as a JSON response. * **`/post_data` route:** This route handles POST requests to `/post_data`. It gets the JSON data from the request body, calls `make_api_request()` to post the data to the API, and returns the response. * **`/` route:** This route renders the `index.html` template, which contains a button to trigger the `getData()` function. * **`index.html`:** This is a simple HTML template with a button that calls the `/get_data` endpoint using JavaScript's `fetch` API. The response from the API is displayed in the `data-output` div. **Key Considerations and Next Steps:** * **API Documentation:** Thoroughly read the documentation for the API you're targeting. Understand its endpoints, request methods, data formats, authentication methods, and error codes. * **Error Handling:** Implement robust error handling to gracefully handle API errors, network errors, and other unexpected situations. Log errors for debugging purposes. * **Security:** Protect your API key and other sensitive information. Use HTTPS to encrypt communication between the UI and the backend server. Implement user authentication and authorization to control access to different features of the MCP. Sanitize user input to prevent injection attacks. * **Scalability:** If you expect a large number of users, consider using a more scalable architecture, such as a load balancer, multiple backend servers, and a distributed database. * **Testing:** Write unit tests and integration tests to ensure that your MCP is working correctly. * **Configuration:** Store configuration settings (e.g., API base URL, API key) in a configuration file or environment variables. This makes it easier to deploy your MCP to different environments. * **Rate Limiting:** Be mindful of the API's rate limits and implement appropriate throttling mechanisms in your MCP to avoid being blocked. * **Asynchronous Tasks:** For long-running API operations, consider using asynchronous tasks (e.g., Celery with Flask) to avoid blocking the main thread. **How to Adapt This to *Any* API:** 1. **Replace Placeholders:** Replace the placeholder values for `API_BASE_URL` and `API_KEY` with the actual values for the API you're targeting. 2. **Modify `make_api_request()`:** Adapt the `make_api_request()` function to handle the specific authentication method, data formats, and error codes of the API you're targeting. You might need to add custom headers, serialize data in a specific format, or parse the API's error responses. 3. **Create Routes:** Create routes for each API endpoint you want to expose in your MCP. Each route should call `make_api_request()` to interact with the API and return the response to the UI. 4. **Design the UI:** Design the UI to allow users to interact with the API endpoints. Create forms, buttons, and tables to display data and allow users to input data. This is a starting point. Building a fully functional MCP requires significant effort and depends on the complexity of the API you're targeting and the features you want to implement. Good luck!

chia-explorer

MCP server that answers questions about the Chia blockchain, including balances, blocks, transactions, offers, fees, and more, using the public coinset.org API and CoinGecko for pricing.

SSAS MCP Server

A read-only MCP server for querying SQL Server Analysis Services (multidimensional cubes via MDX and tabular models via DAX) using Windows Integrated Security.

mcp-google-oauth

A remote MCP server with Google OAuth authentication, deployable to Cloudflare Workers, that provides tools accessible after signing in with Google.

syplugin-anMCPServer

A Model Context Protocol server plugin for SiYuan note-taking application that enables searching documents, retrieving content, and writing to notes through an HTTP-based interface.

CMS Provider Data Catalog MCP

A remote MCP server that lets an LLM explore, query, aggregate, and benchmark the ~234 datasets in the CMS Provider Data Catalog — hospitals, dialysis facilities, nursing homes, home health, hospice, physicians, and more — in plain language.

MindPort MCP Server

Enables AI systems to store and search resources with fuzzy search, regex, and tag filtering, with domain isolation and prompt template management.

MCP Agent Bridge

An agent gateway that aggregates multiple local MCP servers into a single MCP endpoint with runtime control, hot-reloadable configuration, and meta tools like bridge__execute for calling any child server tool without restart.

Pyrus MCP

Enables authorized employees and AI hosts to perform Pyrus operations over the Model Context Protocol (MCP) with production-grade security and observability.