Discover Awesome MCP Servers

graphql2mcp

Convert GraphQL schemas and endpoints into Model Context Protocol (MCP) servers.

Spotify MCP Server

Connects Claude to Spotify, enabling play control, playlist management, lyrics retrieval, and music recommendations through natural language.

Forge

Terminal MCP server for AI coding agents with persistent PTY sessions, ring-buffer incremental reads, headless xterm screen capture, multi-agent orchestration, and a real-time web dashboard.

REAPER MCP Server

A Model Context Protocol server that enables AI agents to create fully mixed and mastered tracks in REAPER DAW, supporting project management, MIDI composition, audio recording, and mixing automation.

GitBranchMCP

A local-first MCP server for AI programming branch notes and mainline decision logging, supporting branch management, summary merging, and Markdown export with optional Git-mode for isolated branch conversations.

imagedimensions-mcp

Audits images on any public web page to detect oversized images, compare natural vs rendered dimensions, and provide format breakdown, helping AI agents check image performance during development.

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.

Sketchup Integration

Conecta SketchUp con Claude AI a través del Protocolo de Contexto del Modelo, permitiendo que Claude interactúe directamente y controle SketchUp para el modelado 3D asistido por indicaciones y la manipulación de escenas.

Godalo

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

FHIR MCP Server

A comprehensive MCP server that bridges AI applications with FHIR healthcare data systems, enabling patient data access, clinical data retrieval, and data quality assessment.

mcp-stm-montevideo

MCP server exposing Montevideo public transportation data (STM) as tools for AI assistants, enabling natural language queries about routes, stops, arrivals, and trip planning.

MCP Sigmund

Enables AI assistants to analyze personal financial data from Open Banking sources stored in PostgreSQL database. Provides educational financial analysis tools with intelligent formatting for learning about spending patterns, account balances, and transaction history.

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!

MISP-mcp

Enables AI assistants to interact with MISP threat intelligence platforms through natural language, supporting event search, creation, user management, and report generation.

Name.com MCP Server

Enables management of domains and DNS records through the Name.com REST API. Users can search for available domains, check bulk availability, and configure DNS records or nameservers using natural language.

MCP Twitter/X Server

Provides integration with Twitter/X, enabling reading posts from users and creating new posts.

YouTrack MCP Server

A comprehensive Model Context Protocol server for YouTrack integration, providing extensive tools for issue tracking, project management, workflow automation, and team collaboration.

goodvat

Enables AI assistants to answer tax compliance questions (VAT, sales tax, GST) and validate EU VAT numbers in real time via the VIES registry.

Jokes MCP Server

A Model Context Protocol server that provides jokes on demand, allowing users to request jokes from different categories (Chuck Norris, Dad jokes, etc.) and integrate them into Microsoft Copilot Studio and Visual Studio Code.

MCP GitHub Dashboard

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

WhisperGraph MCP Server

Self-hostable MCP server for WhisperGraph — a graph of 7.39B nodes / 39B edges mapping DNS, BGP, GeoIP, WHOIS, and threat intelligence. Six read-only tools (Cypher query + schema introspection + threat assessment), six resources, eight investigation prompts. stdio and Streamable HTTP transports.

golf-reports

Pulls golf data from Arccos, GHIN, and 18Birdies, and generates interactive HTML and PDF round reports with shot maps and stats via local MCP tools.

Anam MCP Server

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

Jira MCP Server

Enables comprehensive interaction with self-hosted Jira instances using Personal Access Token authentication, supporting issue management, JQL searches, comments, transitions, projects, and custom fields through 27 specialized tools.

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.

xamp

MCP server that gives Claude Code and OpenCode direct access to your XAMPP MariaDB/MySQL databases, enabling database listing, table inspection, and read/write query execution.

Typefully MCP Server

A Model Context Protocol server that enables AI assistants to create and manage Twitter drafts on Typefully, supporting features like thread creation, scheduling, and retrieving published content.

Barebones MCP Server

A minimal, dockerized template for creating HTTP-based Model Context Protocol servers. Provides a starting point with FastMCP framework integration and includes a sample cat fact tool that can be replaced with custom functionality.

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.