Discover Awesome MCP Servers

PySqlitMCP

Enables comprehensive SQLite database management through natural language including database creation, table operations, data CRUD operations, backup/restore, and CSV import/export functionality. Built on FastMCP framework with PySqlit library for reliable database interactions.

Chakra MCP Server

Native integration with Anthropic's Model Context Protocol.

File System MCP Server

Automates file system operations through natural language commands using a combination of LLM (Ollama), MCP tools, and a Python bridge agent.

Seafile MCP Server

Enables AI assistants to interact with Seafile cloud storage for managing self-hosted files and directories. It supports operations such as reading, writing, moving, and searching across libraries using either account-based or library-specific authentication.

Azure Key Vault MCP

Enables management of Azure Key Vault secrets and certificates, including creation, retrieval, deletion, format conversion (PEM/CRT to PFX), certificate chain imports, and self-signed certificate generation.

MCP TMDB

An implementation of the Model Context Protocol that provides tools to interact with The Movie Database (TMDB), allowing users to search for movie collaborations, actor filmographies, and other film industry data.

Deepgram MCP

Provides AI editors with access to Deepgram's speech-to-text transcription and audio intelligence tools. Dynamically fetches available capabilities from Deepgram's API at runtime, ensuring access to new features without package upgrades.

WeatherXM Pro MCP Server

WeatherXM Pro MCP Server

mcp-danish-weather

Provides access to Danish weather data from the Danish Meteorological Institute, enabling users to retrieve current conditions, hourly forecasts, and historical records. It supports location lookups via city names, postal codes, and coordinates for any Danish region.

iOS Automation MCP Server

A Model Context Protocol server that enables AI assistants to interact with iOS simulators, perform accessibility testing, manage apps, and automate complex iOS workflows.

Conversation Search MCP Server

Enables comprehensive search and analysis of Claude Code conversation history using full-text search, optional semantic vector search, and conversation management tools. Provides fast SQLite-based indexing with role-based filtering, project organization, and hybrid search capabilities combining keyword and semantic matching.

eBay Analytics MCP Server by CData

This project builds a read-only MCP server. For full read, write, update, delete, and action capabilities and a simplified setup, check out our free CData MCP Server for eBay Analytics (beta): https://www.cdata.com/download/download.aspx?sku=JJZK-V&type=beta

Xfinity MCP Server

Enables users to manage their Xfinity ISP accounts through automated browser sessions for tasks like checking data usage and paying bills. It supports monitoring service outages and remotely restarting equipment using natural language commands.

SuperMapMCP

Okay, here's the translation of "MCP Client and Server, implement shapefile import to database" into Spanish: **Cliente y Servidor MCP, implementar la importación de shapefiles a la base de datos.** Here's a breakdown of why I chose those words: * **Cliente y Servidor:** This is the standard translation of "Client and Server." * **MCP:** It's likely that "MCP" is an acronym and should be kept as is. If you have more context about what MCP stands for, I can provide a more specific translation if needed. * **implementar:** This translates to "implement." * **la importación de shapefiles:** This translates to "the import of shapefiles." "Shapefiles" is often used directly in Spanish, especially in technical contexts. * **a la base de datos:** This translates to "to the database." Therefore, the complete translation is: **Cliente y Servidor MCP, implementar la importación de shapefiles a la base de datos.**

Hevy MCP

An MCP server that connects AI clients to the Hevy workout tracking app, allowing users to manage routines and exercises. It enables reading workout history and logging new fitness sessions through simple natural language commands.

Jokes MCP Server

A Model Context Protocol server that provides jokes on demand, allowing users to request different types of jokes (Chuck Norris, Dad jokes, etc.) through Microsoft Copilot Studio or GitHub Copilot.

stdout-mcp-server

Espejo de

ScreenPilot

MCP server to let LLM take full control on your device by providing screen automation toolkit for controlling and interacting with graphical user interface

mcp-sketch

Local MCP server for parsing Sketch exported HTML zip archives and extracting design structure information.

EdgeOne Geo MCP Server

Enables AI models to access user geolocation information through EdgeOne Pages Functions, allowing location-aware AI interactions.

Cloudflare Playwright MCP

Enables AI assistants to control a browser through Playwright on Cloudflare Workers, allowing web automation tasks like navigation, typing, clicking, and taking screenshots through natural language commands.

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.

MCP Basics

A centralized Model Context Protocol server that provides common development tools (like formatting and translation) across all your Cline projects without needing to install them individually.

Vimango MCP Server

Enables Claude to create and organize markdown research notes directly in your local vimango SQLite databases, with support for contexts, folders, and automatic synchronization.

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!

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.

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.

CodeLogic

Interactúa con CodeLogic, una plataforma de Inteligencia de Software que grafica las dependencias complejas de la arquitectura de código y datos, para impulsar la precisión y el conocimiento de la IA.