Discover Awesome MCP Servers

Zocialeye MCP Server

Enables access to Zocialeye's social media analytics API for campaign data analysis. Provides tools to retrieve campaign categories, keywords, word clouds, messages, summary statistics, and top influencers.

mcpware

Gateway MCP Server - Route MCP requests intelligently to multiple backend servers.

Apktool MCP Server

An MCP server that integrates with Apktool to provide live reverse engineering support for Android applications using Claude and other LLMs through the Model Context Protocol.

MCP Python Demo

An MCP-based project that integrates Zhipu AI and Tencent Map APIs to provide weather queries, geocoding, and web search functionality through both command-line and web interfaces.

URL Text Fetcher MCP Server

Enables AI models to fetch text content from URLs, extract links from web pages, and search the web using Brave Search with automatic content retrieval from top results. Provides comprehensive web scraping and search capabilities with robust error handling.

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.

Zen MCP Enhanced

An enhanced Model Context Protocol server that enables Claude to seamlessly collaborate with multiple AI models (Gemini, OpenAI, local models) for code analysis and development tasks, maintaining context across conversations.

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.

Monday.com MCP Server

Enables MCP clients to interact with Monday.com workspaces through comprehensive board management, item operations, updates, and document handling capabilities.

Github Copilot VScode MCP Server

A server that likely facilitates integration between GitHub Copilot and Visual Studio Code, though the README lacks specific details about its functionality.

HubSpot MCP Server

Memungkinkan model AI untuk berinteraksi dengan data dan operasi HubSpot CRM melalui antarmuka yang terstandarisasi, mendukung manajemen kontak dan perusahaan.

Call For Papers MCP

A Smithery MCP server that allows users to search for upcoming academic conferences and events from WikiCFP based on keywords, returning detailed event information including names, descriptions, dates, locations, and submission deadlines.

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.

Context Continuation MCP Server

Provides intelligent context management for AI development sessions, allowing users to track token usage, manage conversation context, and seamlessly restore context when reaching token limits.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Agentic AI System with MCP Integration

Enables integration with financial transaction data through REST APIs, PostgreSQL databases, and document storage systems. Demonstrates agentic AI capabilities by connecting to Alpha Vantage API and managing financial data through natural language interactions.

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.