Discover Awesome MCP Servers

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.

Nano Banana MCP Server

Enables AI image generation, editing, and composition using Google's Gemini image models (Nano Banana Pro and Nano Banana). Supports text-to-image generation, multi-image composition, flexible aspect ratios, high-resolution output up to 4K, and real-time information grounding.

MCP Evolution API Supergateway

Here are a few possible translations, depending on the specific context you're looking for: **More literal translation:** * **Server MCP SSE untuk API evolusi WhatsApp** **More natural/contextual translations:** * **Server MCP SSE untuk API Evolusi WhatsApp** (This is likely the best option if "WhatsApp Evolution API" is a well-known term in the Indonesian tech community.) * **Server MCP SSE untuk API evolusi WhatsApp** (This is a good option if you want to emphasize the "evolution" aspect of the API.) **Explanation of choices:** * **MCP SSE:** These terms are likely technical and should be kept as is unless there's a very common Indonesian equivalent. * **API:** "API" is often used directly in Indonesian tech discussions. * **evolusi:** This is the Indonesian word for "evolution." * **WhatsApp:** This is generally used as is in Indonesian. Therefore, the best translation is likely: **Server MCP SSE untuk API Evolusi WhatsApp**

MCP Terminal Server

A simple MCP server that allows running terminal commands with output capture, enabling command execution on the host system from MCP-compatible clients like Claude Desktop.

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.

Local DeepWiki MCP Server

Generates DeepWiki-style documentation for private code repositories with RAG-based Q\&A capabilities, semantic code search, and multi-language AST parsing. Supports local LLMs (Ollama) or cloud providers for privacy-focused codebase analysis.

Create MCP Server

Template to quickly set up your own MCP server

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.

Autodesk Build MCP Server

A Model Context Protocol server implementation for Autodesk Construction Cloud Build that enables AI assistants to manage construction issues, RFIs, submittals, photos, forms, and costs through natural language.

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.

Yak MCP

Enables coding agents to speak aloud using text-to-speech functionality. Works with agents running inside devcontainers and provides configurable voice settings for creating chatty AI companions.

Real Estate MCP Server

Enables real estate property searches with location and criteria filtering, plus comprehensive mortgage calculations including monthly payments and affordability analysis. Currently uses mock data for property searches but provides full mortgage calculation functionality.

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.

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.

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.

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.

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.

SWLC MCP Server

A lottery information query service for the Shanghai region that provides winning number lookups and analysis functions for various lottery games including Double Color Ball, 3D Lottery, and Seven Happiness Lottery.

Tri-Tender Pricing MCP

An MCP server designed to automate tender and RFQ pricing by extracting requirements from documents and building structured pricing models. It enables users to calculate final costs, compare market rates, and generate styled HTML pricing reports for PDF export.

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.

Istek MCP Server

Enables AI assistants to interact with Istek API Client for managing workspaces, collections, environments, variables, and request history. Allows natural language control of API development workflows including creating collections, adding requests, and managing environment configurations.

Ghost MCP Server

A Model Context Protocol server that enables management of Ghost blog content (posts, pages, and tags) through Claude, supporting both SSE and stdio transports.

MCP Fetch With Proxy

mcp-fetch

Cisco MCP Pods Server

Enables AI agents to interact with Cisco API Gateway pods endpoints for complete pod management including CRUD operations, credential updates, and configuration management through natural language. Supports multiple deployment modes including local Claude Desktop integration and cloud deployment for remote AI agents like Webex Connect.

Basecoat UI MCP

Provides access to 77 pre-built, accessible Basecoat CSS UI components across forms, navigation, feedback, interactive, and layout categories, enabling AI assistants to retrieve HTML components and usage documentation for building user interfaces.

IBHack MCP Server

Enables intelligent discovery and recommendation of Python tools using Google Gemini AI. Automatically scans directories for tool classes and recommends the most relevant tools based on user queries with complete code generation.