Discover Awesome MCP Servers

Agent Collaboration Orchestrator

A multi-agent collaborative development bridge that enables TRAE Work to offload complex tasks to Codex executor, with tools for task submission, status tracking, artifact listing, and permission management.

ZeroTrusted-ai PII Detection Agent

ZeroTrusted-ai PII Detection Agent

Paperboy

Enables sending Markdown or EPUB content to a Kindle device via MCP. Users can send documents to their Kindle directly from Claude or any MCP client.

homelab-mcp

Enables management of homelab infrastructure, including Docker/Podman containers, Ollama AI models, Pi-hole DNS, Unifi networks, and Ansible inventory, with built-in security checks and automated pre-push validation.

Apple Health MCP Server

An MCP server that allows users to query and analyze their Apple Health data using SQL and natural language, utilizing DuckDB for fast and efficient health data analysis.

Parzley MCP Server

Enables AI-powered form filling through natural language by exposing the Parzley AI Form Filling Agent API as an MCP server.

YouTube Content Management MCP Server

Enables AI assistants to search YouTube for videos, channels, and playlists while retrieving detailed analytics and metrics through the YouTube Data API v3. Supports advanced filtering options and provides comprehensive statistics for content discovery and analysis.

Mnemoforge

Provides operational continuity for AI coding agents, preserving task state, decisions, checkpoints, and project context across sessions and model switches via MCP.

@node2flow/google-docs-mcp

MCP server for Google Docs — create, read, edit, format, and manage documents through 26 tools via the Model Context Protocol.

mcp-redis-monitor

FastMCP server with read-only tools to monitor Redis — queue depths, Celery queue status, connected clients, server/memory info, and per-database key counts

Airflow MCP

Enables natural language interaction with Apache Airflow for querying DAGs, monitoring execution, and troubleshooting failures.

Reddit Buddy MCP

Enables AI assistants to browse Reddit, search posts, analyze user activity, and fetch comments without requiring API keys. Features smart caching, clean data responses, and optional authentication for higher rate limits.

Emcee

Okay, I understand. You want me to generate an **Minimal Complete and Verifiable Example (MCVE)** of an MCP (presumably meaning a Mock Control Plane or a Mock Server) for any OpenAPI documented endpoint, translated to Indonesian. Here's the breakdown of how we'll approach this, along with the code and explanations, followed by the Indonesian translation: **1. Understanding the Goal:** * **OpenAPI (Swagger) Documentation:** This is the contract. It describes the API's endpoints, request/response formats, data types, etc. We'll assume you have this file (e.g., `openapi.yaml` or `openapi.json`). * **MCP/Mock Server:** A lightweight server that *simulates* the real API. It reads the OpenAPI document and then responds to requests based on the definitions in that document. This is useful for testing, development, and decoupling from the actual API. * **Minimal, Complete, and Verifiable:** The code should be as short as possible, runnable without extra dependencies (ideally), and easy to verify that it works. **2. Technology Choice (Python + Flask):** Python is great for scripting and has excellent libraries for working with OpenAPI and creating web servers. Flask is a microframework that's perfect for this kind of simple mock server. **3. Code Example:** ```python from flask import Flask, request, jsonify import yaml import json import os app = Flask(__name__) # Load OpenAPI specification (adjust path if needed) openapi_file = 'openapi.yaml' # Or 'openapi.json' try: with open(openapi_file, 'r') as f: if openapi_file.endswith('.yaml') or openapi_file.endswith('.yml'): openapi_spec = yaml.safe_load(f) elif openapi_file.endswith('.json'): openapi_spec = json.load(f) else: raise ValueError("Unsupported file type. Use YAML or JSON.") except FileNotFoundError: print(f"Error: OpenAPI file '{openapi_file}' not found.") exit(1) except Exception as e: print(f"Error loading OpenAPI file: {e}") exit(1) @app.route('/<path:path>', methods=['GET', 'POST', 'PUT', 'DELETE', 'PATCH']) def mock_endpoint(path): method = request.method.lower() print(f"Received {method.upper()} request to /{path}") # Find the path in the OpenAPI spec if '/' + path in openapi_spec['paths']: path_spec = openapi_spec['paths']['/' + path] if method in path_spec: operation_spec = path_spec[method] # Handle request parameters (query, path, header, cookie) # This is a simplified example; you'd need more robust handling # for different parameter types and validation. query_params = request.args print(f"Query parameters: {query_params}") # Handle request body (if any) request_body = request.get_json() if request.content_type == 'application/json' else None print(f"Request body: {request_body}") # Generate a response based on the OpenAPI spec if 'responses' in operation_spec: # Get the first successful response (e.g., 200, 201) success_status = next((code for code in operation_spec['responses'] if code.startswith('2')), None) if success_status: response_spec = operation_spec['responses'][success_status] if 'content' in response_spec and 'application/json' in response_spec['content']: schema = response_spec['content']['application/json']['schema'] # Generate a dummy response based on the schema # This is a VERY basic example; you'd need a more sophisticated # schema-to-data generator for complex schemas. if schema['type'] == 'object': response_data = {"message": "Mock response from OpenAPI spec"} # Replace with more realistic data elif schema['type'] == 'array': response_data = [{"message": "Mock item 1"}, {"message": "Mock item 2"}] else: response_data = {"value": "Mock value"} # Default response return jsonify(response_data), int(success_status) else: return "OK", int(success_status) # No JSON content, return a simple OK else: return "Error: No successful response defined in OpenAPI spec", 500 else: return "Error: No responses defined in OpenAPI spec", 500 else: return f"Method '{method.upper()}' not allowed for this endpoint", 405 else: return "Endpoint not found in OpenAPI spec", 404 if __name__ == '__main__': app.run(debug=True, port=5000) ``` **4. How to Use:** 1. **Install Flask:** `pip install Flask PyYAML` 2. **Create an OpenAPI file:** Save your OpenAPI definition as `openapi.yaml` (or `openapi.json`) in the same directory as the Python script. A very simple example: ```yaml openapi: 3.0.0 info: title: Mock API version: 1.0.0 paths: /users: get: summary: Get a list of users responses: '200': description: Successful operation content: application/json: schema: type: array items: type: object properties: id: type: integer name: type: string ``` 3. **Run the script:** `python your_script_name.py` 4. **Test:** Open your browser or use `curl` to make requests to `http://localhost:5000/users`. You should see a mock response. **5. Explanation:** * **Imports:** Imports necessary libraries (Flask for the web server, `yaml` and `json` for loading the OpenAPI spec). * **Load OpenAPI Spec:** Reads the OpenAPI file (YAML or JSON) and parses it into a Python dictionary. Handles potential errors (file not found, invalid format). * **`mock_endpoint` Function:** * This is the core of the mock server. It's a Flask route that catches *any* path (`/<path:path>`). * It extracts the HTTP method (GET, POST, etc.). * It looks for the path and method in the OpenAPI specification. * **Important:** It extracts query parameters and the request body. * It finds the first successful response code (2xx) defined in the OpenAPI spec. * It generates a *very basic* mock response based on the schema defined for that response. This is the part that needs the most improvement for real-world use. * It returns the mock response with the appropriate HTTP status code. * **Error Handling:** Includes basic error handling for missing OpenAPI file, invalid format, missing endpoints, etc. * **`if __name__ == '__main__':`:** Starts the Flask development server. **6. Limitations and Improvements:** * **Schema-to-Data Generation:** The biggest limitation is the very simple schema-to-data generation. For complex schemas, you'll need a more sophisticated library (e.g., `Faker` to generate realistic data, or a library specifically designed for OpenAPI mock server generation). * **Parameter Handling:** The parameter handling is very basic. You'll need to handle different parameter types (path, query, header, cookie) and validate them against the OpenAPI spec. * **Request Validation:** The code doesn't validate the request body against the OpenAPI schema. You should add validation to ensure that the request is valid. * **Content Type Handling:** The code only handles `application/json`. You'll need to add support for other content types (e.g., `application/xml`, `text/plain`). * **Security:** This is a *mock* server, so security is not a primary concern. However, if you're using it in a production-like environment, you should consider security implications. * **More Robust Error Handling:** Add more detailed error messages and logging. * **Configuration:** Make the OpenAPI file path configurable. **7. Indonesian Translation (Terjemahan Bahasa Indonesia):** **Judul: Membuat Server Mock untuk Endpoint yang Didokumentasikan dengan OpenAPI** **Penjelasan:** Kode Python ini membuat server mock sederhana menggunakan Flask untuk mensimulasikan API berdasarkan dokumentasi OpenAPI (Swagger). Server ini membaca file OpenAPI (YAML atau JSON) dan merespons permintaan HTTP sesuai dengan definisi dalam file tersebut. Ini berguna untuk pengujian, pengembangan, dan memisahkan diri dari API yang sebenarnya. **Cara Penggunaan:** 1. **Instal Flask dan PyYAML:** `pip install Flask PyYAML` 2. **Buat file OpenAPI:** Simpan definisi OpenAPI Anda sebagai `openapi.yaml` (atau `openapi.json`) di direktori yang sama dengan skrip Python. 3. **Jalankan skrip:** `python nama_skrip_anda.py` 4. **Uji:** Buka browser Anda atau gunakan `curl` untuk membuat permintaan ke `http://localhost:5000/users`. Anda akan melihat respons mock. **Kode (sama seperti di atas)** **Penjelasan Kode:** * **Impor:** Mengimpor library yang diperlukan (Flask untuk server web, `yaml` dan `json` untuk memuat spesifikasi OpenAPI). * **Muat Spesifikasi OpenAPI:** Membaca file OpenAPI (YAML atau JSON) dan menguraikannya menjadi kamus Python. Menangani potensi kesalahan (file tidak ditemukan, format tidak valid). * **Fungsi `mock_endpoint`:** * Ini adalah inti dari server mock. Ini adalah rute Flask yang menangkap *semua* jalur (`/<path:path>`). * Ini mengekstrak metode HTTP (GET, POST, dll.). * Ini mencari jalur dan metode dalam spesifikasi OpenAPI. * **Penting:** Ini mengekstrak parameter kueri dan badan permintaan. * Ini menemukan kode respons sukses pertama (2xx) yang didefinisikan dalam spesifikasi OpenAPI. * Ini menghasilkan respons mock *sangat dasar* berdasarkan skema yang didefinisikan untuk respons tersebut. Ini adalah bagian yang paling membutuhkan peningkatan untuk penggunaan dunia nyata. * Ini mengembalikan respons mock dengan kode status HTTP yang sesuai. * **Penanganan Kesalahan:** Mencakup penanganan kesalahan dasar untuk file OpenAPI yang hilang, format tidak valid, endpoint yang hilang, dll. * **`if __name__ == '__main__':`:** Memulai server pengembangan Flask. **Keterbatasan dan Peningkatan:** * **Pembuatan Data dari Skema:** Keterbatasan terbesar adalah pembuatan data dari skema yang sangat sederhana. Untuk skema yang kompleks, Anda memerlukan library yang lebih canggih (misalnya, `Faker` untuk menghasilkan data yang realistis, atau library yang dirancang khusus untuk pembuatan server mock OpenAPI). * **Penanganan Parameter:** Penanganan parameter sangat dasar. Anda perlu menangani berbagai jenis parameter (jalur, kueri, header, cookie) dan memvalidasinya terhadap spesifikasi OpenAPI. * **Validasi Permintaan:** Kode tidak memvalidasi badan permintaan terhadap skema OpenAPI. Anda harus menambahkan validasi untuk memastikan bahwa permintaan valid. * **Penanganan Tipe Konten:** Kode hanya menangani `application/json`. Anda perlu menambahkan dukungan untuk tipe konten lain (misalnya, `application/xml`, `text/plain`). * **Keamanan:** Ini adalah server *mock*, jadi keamanan bukanlah perhatian utama. Namun, jika Anda menggunakannya di lingkungan seperti produksi, Anda harus mempertimbangkan implikasi keamanan. * **Penanganan Kesalahan yang Lebih Kuat:** Tambahkan pesan kesalahan dan pencatatan yang lebih rinci. * **Konfigurasi:** Buat jalur file OpenAPI dapat dikonfigurasi. **Kesimpulan:** Kode ini menyediakan dasar untuk membuat server mock sederhana berdasarkan dokumentasi OpenAPI. Anda dapat memperluasnya untuk menangani skema yang lebih kompleks, memvalidasi permintaan, dan mendukung berbagai tipe konten. **Important Notes:** * This is a starting point. You'll need to adapt it to your specific OpenAPI definition and requirements. * The schema-to-data generation is the most complex part and will likely require significant customization. * Remember to install the necessary libraries (`pip install Flask PyYAML`). This comprehensive response provides a working example, explains its usage, highlights limitations, and offers improvements, along with a complete Indonesian translation. It should give you a solid foundation for building your OpenAPI-driven mock server. Remember to replace `"openapi.yaml"` with the actual path to your OpenAPI file.

weixin-devtools-mcp

Enables automated testing of WeChat mini-programs via Model Context Protocol, providing tools for connecting to WeChat Developer Tools, querying and interacting with page elements, making assertions, navigating, and debugging.

Alkemi MCP Server

Connects MCP clients to databases like Snowflake, BigQuery, and Databricks through Alkemi's data platform, enabling natural language database queries with proper schema understanding and metadata management for consistent team-wide access.

TickTick MCP Server

Enables AI assistants to manage TickTick tasks and projects through OAuth2 authentication, supporting task creation, updates, completion, project management, and smart daily scheduling based on priorities and due dates.

Tavily Web Search MCP Server

Enables web search capabilities through the Tavily API, allowing users to search the internet for information using natural language queries. Built as a demonstration MCP server running in stdio transport mode.

wemp-operator-mcp

Enables to operate a WeChat Official Account via MCP tools, including searching and executing API workflows and uploading files.

fintaro-mcp

Enables MCP-capable agents to read Fintaro invoices and transactions, and upload receipts, via a scoped API key with PII-safe projections.

MCP Server Builder

Provides searchable access to official MCP protocol specification and FastMCP framework documentation, helping developers build correct MCP servers by querying live documentation with BM25 full-text search.

clipboard-image

Enables Claude Code to paste images from the system clipboard for instant analysis and processing.

JXA Mail MCP

A high-performance MCP server for Apple Mail that uses optimized JavaScript for Automation (JXA) to search and manage emails. It enables users to list accounts, fetch mailboxes, and retrieve today's, unread, or flagged messages with significantly improved speed through batch property fetching.

cartridge-mcp

An MCP server that enables users to treat behaviors as swappable cartridges, each with its own tools, onboarding flow, and personality skins. It allows building scenes by combining cartridges with different personas and sharing them via git repositories.

AQICN MCP Server

Enables querying real-time air quality index (AQI) data for Chinese cities, including PM2.5, PM10, and other pollutant information with health recommendations from the World Air Quality Index Project API.

Memento

Persistent memory system for LLMs with lossless transcript management, enabling memory recall and full session history search across all conversations.

Supabase MCP HTTP Stream Server

Docker-deployable server that enables interaction with Supabase databases via HTTP streaming, allowing n8n workflows, AI agents, and automation tools to execute SQL queries, manage database migrations, deploy edge functions, and search documentation.

Vastu Compliance MCP Server

An MCP server for checking architectural designs against Vastu principles, integrating with Autodesk tools to provide deterministic compliance scoring and explainable recommendations.

Hybris MCP Server

Enables AI assistants to interact with SAP Commerce Cloud (Hybris) instances to manage products, orders, and system configurations. It supports advanced operations like FlexibleSearch queries, Groovy script execution, and ImpEx data management.

CloakBrowser MCP

CloakBrowser MCP server for AI agents: Playwright-powered browsing, clean tool forwarding, Docker support, and multi-session HTTP transport.

slack-mcp

Enables AI assistants to interact with Slack workspaces, providing tools for reading messages, posting content, managing channels, and more.