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.

Kiwi MCP

A unified MCP server that consolidates directives, Python scripts, and knowledge management into four streamlined tools for AI agents. It enables users to search, load, and execute workflows or scripts within isolated virtual environments while maintaining a consistent interface for local and registry-based resources.

Wikipedia MCP Server

Provides comprehensive access to Wikipedia content including article search, full text retrieval, summaries, categories, links, images, language versions, and external references through 9 specialized tools.

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.

Crawl4AI Web Scraper MCP Server

Server MCP yang memanfaatkan crawl4ai untuk web scraping dan ekstraksi konten berbasis LLM (Markdown, potongan teks, ekstraksi cerdas). Dirancang untuk integrasi agen AI.

Next.js MCP Server Template

A template for building MCP servers in Next.js applications using the Vercel MCP Adapter. Provides a foundation for adding custom tools, prompts, and resources to any Next.js project with deployment support on Vercel.

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.

Create MCP Server

Template to quickly set up your own MCP server

Rini MCP Server

A collection of custom MCP servers providing various AI-powered capabilities including web search, YouTube video analysis, GitHub repository analysis, reasoning, code generation/execution, and web crawling.

Lighthouse Explorer MCP Server

Provides tools for AI assistants to query the Canton Network for data on contracts, governance, validators, and party transactions through the Lighthouse Explorer API. It enables seamless interaction with blockchain statistics, price history, and name services without requiring an API key.

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.

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.

Brazilian Law Research MCP Server

A MCP server for agent-driven research on Brazilian law using official sources

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.

mcp_slack

fetch the latest channels messages chat

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.

MCP CRUD Tools

Enables interaction with Users and Products through a CRUD service REST API, providing tools for listing, creating, reading, updating, and deleting records via HTTP transport.

JADX-AI-MCP

Plugin untuk JADX untuk mengintegrasikan server MCP.

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.

CloudStack MCP Server

A high-performance server that enables integration between Apache CloudStack infrastructure and AI assistants through the Model Context Protocol, providing comprehensive tools for managing virtual machines, storage, networking, and other cloud resources.

Ensembl MCP Server

Provides access to the Ensembl genomics REST API with 30+ tools for genomic data including gene lookup, sequence retrieval, genetic variants, cross-species homology, phenotypes, and regulatory features.

Acemcp

Provides code repository indexing and semantic search capabilities, allowing natural language queries to find relevant code snippets with automatic incremental indexing and multi-language support.

MCP-BAMM

A Model Context Protocol server that enables interaction with Borrow Automated Market Maker (BAMM) contracts on the Fraxtal blockchain, allowing users to manage positions, borrow against LP tokens, and perform other BAMM-related operations.