Discover Awesome MCP Servers

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.

Bargainer MCP Server

A Model Context Protocol server that aggregates and compares deals from multiple sources including Slickdeals, RapidAPI marketplace, and web scraping, enabling users to search, filter, and compare deals through a chat interface.

Gemini Context MCP Server

Cermin dari

YouTube MCP Server

Enables LLMs to interact with YouTube videos by fetching transcripts, summarizing content, and answering questions based on video context.

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.

clipboard-image

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

Micro.blog Books MCP Server

Enables management of Micro.blog book collections through natural language, allowing users to organize bookshelves, add/move books, and track reading goals. Built with FastMCP for reliable integration with Claude Desktop.

Math Solver AI MCP

Math Solver AI - MCP server providing AI-powered tools and automation by MEOK AI Labs

Envoi MCP

Provides AI agents with a real email address to send, receive, and manage emails via the Envoi.work platform. It enables seamless email communication, including inbox management and threaded replies, directly within MCP-compatible clients.

Limitless AI MCP Server

Connects AI assistants to your Limitless AI lifelog data, enabling them to search, retrieve, and analyze your recorded conversations and daily activities from your Limitless pendant.

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

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.

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.

Customs Big Data MCP Server

Provides comprehensive import/export trade data queries including export trends, product category statistics, order geographic distribution, and overseas certification information to help users understand enterprises' international trade situations.

Slack MCP Server

A Model Context Protocol server that enables LLMs to interact with Slack workspaces through OAuth 2.0 authentication. It provides tools for listing channels and posting messages while supporting secure token persistence and dynamic client registration.

Terminal MCP Server

Enables interactive terminal sessions within Claude Code and Desktop, allowing users and AI to execute commands and manage multiple tabs.

Random.org MCP Server

A Model Context Protocol server that provides access to api.random.org for generating true random numbers, strings, UUIDs, and more.

Cakemail API MCP Server

Enables AI assistants to browse, inspect, and call the Cakemail API via dynamically loaded OpenAPI spec.

mcp-random

MCP server providing true randomness capabilities to Claude, enabling cryptographically secure random number generation for games, decision-making, sampling, simulations, and any operation requiring genuine randomness.

Jina AI Remote MCP Server

Provides access to Jina AI's suite of tools including web search, URL reading, image search, embeddings, and reranking capabilities. Enables users to extract web content as markdown, search academic papers, capture screenshots, and perform semantic operations through natural language.

Code Executor MCP Server

Provides sandboxed code execution for AI agents with support for Python, JavaScript, and shell commands. Includes comprehensive safety features like destructive pattern blocking, timeout protection, and restricted file access for secure production use.

huntflow-mcp

MCP server for HuntFlow ATS API v2, providing tools to manage vacancies, candidates, resumes, pipeline stages, rejection reasons, comments, and accounts.

mcp-all-in-one

Aggregates multiple MCP services into a single unified interface with self-configuration capabilities, enabling dynamic addition and removal of tools via conversation.

hyper-video-service

MCP server for programmatic video generation. Send a prompt, get an MP4.

Store Screenshot Generator MCP

Generates beautiful App Store and Play Store screenshots by inserting app images into iPhone/iPad mockup frames with customizable text overlays and gradient backgrounds. Supports multiple device types and batch generation with both free and pro subscription tiers.

Attio MCP Server

Provides tools to interact with the Attio API, enabling management of resources in an Attio workspace.