Discover Awesome MCP Servers

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

これは、独自のMCPサーバーを迅速にセットアップするためのテンプレートです。GitHubでアカウントを作成して、mcpdotdirect/template-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.

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 create an **MCP (Mock Control Plane) server** that can simulate the behavior of any API endpoint described by an OpenAPI (formerly Swagger) document. This is a complex task, but I can outline the key steps and provide code snippets to get you started. Keep in mind that a fully functional, robust solution would require a significant amount of code and potentially external libraries. Here's a breakdown of the process and some example code (using Python and Flask, a popular choice for lightweight web servers): **1. Core Idea:** The MCP server will: * **Parse the OpenAPI document:** Read the OpenAPI specification (YAML or JSON) and understand the API's structure, endpoints, request parameters, and response schemas. * **Create routes:** Dynamically generate Flask routes (or equivalent in your chosen framework) based on the paths defined in the OpenAPI document. * **Handle requests:** When a request comes in, the server will: * **Validate the request:** Check if the request parameters (query parameters, headers, request body) match the OpenAPI specification. * **Generate a response:** Based on the OpenAPI document, generate a mock response. This could be: * **Static responses:** If the OpenAPI document provides example responses, use those. * **Dynamic responses:** Generate responses based on the schema defined in the OpenAPI document (e.g., create random data that conforms to the schema). * **Provide control:** Allow you to configure the server's behavior, such as: * **Response codes:** Specify which HTTP status code to return for a given endpoint. * **Response data:** Override the default mock response with custom data. * **Latency:** Simulate network latency by adding a delay before sending the response. **2. Example Code (Python and Flask):** ```python from flask import Flask, request, jsonify import yaml import json import jsonschema import random import time app = Flask(__name__) def load_openapi_spec(spec_file): """Loads an OpenAPI specification from a YAML or JSON file.""" try: with open(spec_file, 'r') as f: if spec_file.endswith('.yaml') or spec_file.endswith('.yml'): return yaml.safe_load(f) elif spec_file.endswith('.json'): return json.load(f) else: raise ValueError("Unsupported file type. Use YAML or JSON.") except FileNotFoundError: print(f"Error: OpenAPI specification file not found: {spec_file}") return None except Exception as e: print(f"Error loading OpenAPI specification: {e}") return None def validate_request(request, operation): """Validates the request against the OpenAPI operation definition.""" try: # Validate query parameters for param in operation.get('parameters', []): if param['in'] == 'query': param_name = param['name'] if param_name in request.args: # You could add more sophisticated validation here based on the schema pass # Example: check type, required, etc. elif param['required']: return f"Missing required query parameter: {param_name}", 400 # Validate request body (if present) if 'requestBody' in operation: request_body_schema = operation['requestBody']['content']['application/json']['schema'] # Assuming JSON try: jsonschema.validate(request.json, request_body_schema) except jsonschema.exceptions.ValidationError as e: return f"Invalid request body: {e}", 400 return None, 200 # Request is valid except Exception as e: print(f"Validation error: {e}") return "Internal server error during validation", 500 def generate_mock_response(operation): """Generates a mock response based on the OpenAPI operation definition.""" try: # Try to use example responses if available if 'responses' in operation: for status_code, response_def in operation['responses'].items(): if 'content' in response_def and 'application/json' in response_def['content']: if 'example' in response_def['content']['application/json']: return response_def['content']['application/json']['example'], int(status_code) elif 'schema' in response_def['content']['application/json']: # Generate a response based on the schema (more complex) # This is a placeholder - you'd need a library to generate data from a JSON schema print("Warning: Generating response from schema is not fully implemented.") return {"message": "Generated from schema (not fully implemented)"}, 200 return {"message": "No example or schema found in OpenAPI spec"}, 500 except Exception as e: print(f"Error generating mock response: {e}") return {"message": "Error generating mock response"}, 500 def create_routes_from_openapi(app, spec): """Creates Flask routes based on the OpenAPI specification.""" for path, path_def in spec['paths'].items(): for method, operation in path_def.items(): endpoint_name = operation.get('operationId', f"{method}_{path.replace('/', '_')}") def view_func(path=path, method=method, operation=operation): # Simulate latency (optional) latency = float(request.args.get('latency', 0)) # Get latency from query parameter time.sleep(latency) # Validate the request validation_error, status_code = validate_request(request, operation) if validation_error: return jsonify({"error": validation_error}), status_code # Generate the mock response response_data, status_code = generate_mock_response(operation) return jsonify(response_data), status_code view_func.__name__ = endpoint_name # Important for Flask routing app.add_url_rule(path, view_func=view_func, methods=[method.upper()]) return app if __name__ == '__main__': openapi_spec_file = 'openapi.yaml' # Replace with your OpenAPI file spec = load_openapi_spec(openapi_spec_file) if spec: app = create_routes_from_openapi(app, spec) app.run(debug=True) else: print("Failed to load OpenAPI specification. Exiting.") ``` **3. Explanation and Key Improvements:** * **`load_openapi_spec(spec_file)`:** Loads the OpenAPI specification from a YAML or JSON file. Handles file not found and parsing errors. * **`validate_request(request, operation)`:** Validates the incoming request against the OpenAPI definition. This example validates query parameters and the request body (if present). It uses the `jsonschema` library for body validation. You'll need to install it: `pip install jsonschema`. * **`generate_mock_response(operation)`:** Generates a mock response. It first tries to use the `example` provided in the OpenAPI document. If no example is found, it attempts to generate a response based on the `schema`. **Important:** The schema-based response generation is a placeholder. You'll need a library like `Faker` or `mimesis` to generate realistic data based on the schema. * **`create_routes_from_openapi(app, spec)`:** This is the core function. It iterates through the `paths` in the OpenAPI document and dynamically creates Flask routes for each endpoint. It uses `app.add_url_rule` to register the routes. The `view_func` is the function that will be called when a request is made to that endpoint. * **Latency Simulation:** The `view_func` includes an optional latency simulation using `time.sleep()`. You can pass a `latency` query parameter to the endpoint to simulate network delay (e.g., `http://localhost:5000/users?latency=0.5` will add a 0.5-second delay). * **Error Handling:** The code includes basic error handling for file loading, request validation, and response generation. * **`operationId`:** Uses the `operationId` from the OpenAPI spec as the endpoint name. If `operationId` is missing, it generates a name based on the method and path. **4. How to Use:** 1. **Install Dependencies:** ```bash pip install flask pyyaml jsonschema ``` 2. **Create an OpenAPI Specification:** Create a file named `openapi.yaml` (or `openapi.json`) with your OpenAPI specification. Here's a simple example: ```yaml openapi: 3.0.0 info: title: My API version: 1.0.0 paths: /users: get: summary: Get a list of users responses: '200': description: Successful operation content: application/json: example: - id: 1 name: John Doe - id: 2 name: Jane Smith post: summary: Create a new user requestBody: required: true content: application/json: schema: type: object properties: name: type: string description: The user's name example: "New User" required: - name responses: '201': description: User created successfully content: application/json: example: id: 3 name: New User ``` 3. **Run the Script:** Save the Python code as `mcp_server.py` and run it: ```bash python mcp_server.py ``` 4. **Test the API:** Use `curl`, `Postman`, or any other HTTP client to test the API endpoints. For example: ```bash curl http://localhost:5000/users curl -X POST -H "Content-Type: application/json" -d '{"name": "Alice"}' http://localhost:5000/users ``` **5. Further Improvements and Considerations:** * **Schema-Based Response Generation:** Implement a more robust schema-based response generation using libraries like `Faker` or `mimesis`. This is crucial for generating realistic mock data. You'll need to map OpenAPI schema types to the corresponding Faker/Mimesis data generators. * **More Comprehensive Validation:** Add more comprehensive request validation, including: * Data type validation (e.g., check if a parameter is an integer, string, etc.). * Regular expression validation. * Enum validation. * Header validation. * **Configuration:** Allow users to configure the server's behavior through a configuration file or command-line arguments. This could include: * Port number. * OpenAPI specification file path. * Default response codes. * Latency range. * **Logging:** Add logging to track requests, responses, and errors. * **Authentication/Authorization:** Implement basic authentication/authorization if your API requires it. You could use a simple token-based authentication scheme. * **Content Type Handling:** Support different content types (e.g., XML, plain text). * **Error Handling:** Improve error handling and provide more informative error messages. * **Testing:** Write unit tests to ensure the server is working correctly. * **UI:** Consider adding a simple web UI to view the OpenAPI specification and configure the server. * **Framework Choice:** While Flask is great for simple projects, consider using a more robust framework like FastAPI or Django REST Framework for larger, more complex APIs. FastAPI has excellent OpenAPI support built-in. **Example of Schema-Based Response Generation (using Faker):** ```python from faker import Faker fake = Faker() def generate_response_from_schema(schema): """Generates a response based on a JSON schema using Faker.""" if schema['type'] == 'object': response = {} for property_name, property_def in schema.get('properties', {}).items(): response[property_name] = generate_response_from_schema(property_def) return response elif schema['type'] == 'string': if 'format' in schema and schema['format'] == 'email': return fake.email() elif 'format' in schema and schema['format'] == 'uuid': return fake.uuid4() else: return fake.name() # Or fake.text(), fake.address(), etc. elif schema['type'] == 'integer': return fake.random_int() elif schema['type'] == 'boolean': return fake.boolean() elif schema['type'] == 'array': item_schema = schema.get('items', {}) return [generate_response_from_schema(item_schema) for _ in range(random.randint(1, 3))] # Generate a list of 1-3 items else: return None # Unknown type ``` **Important Notes:** * This is a starting point. Building a fully functional MCP server is a significant undertaking. * The complexity of the implementation will depend on the complexity of the OpenAPI specifications you need to support. * Consider using existing libraries and tools to simplify the development process. This detailed explanation and code example should give you a solid foundation for building your MCP server. Remember to adapt and extend the code to meet your specific requirements. Good luck!

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.

Zohairs-server

Test

WHOOP MCP Server for Poke

Connects WHOOP fitness data to Poke AI assistant, enabling natural language queries for recovery scores, sleep analysis, strain tracking, and healthspan metrics.

After Effects Motion Control Panel

A robust system that connects web UI to After Effects, enabling real-time command processing and monitoring with comprehensive error handling.

mcp-security-sandbox

MCP Security Playground - Hack with MCP Servers, MCP Clients. Try out different vulnerabilities and abuse LLMs and agents in a UI friendly experimentation lab

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.

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.

Weather MCP Service

A Model Control Protocol (MCP) based service that allows users to query weather forecasts by coordinates and receive weather alerts for U.S. states.

claude-mcp-server-gateway

A lightweight Claude MCP gateway that dynamically loads tools only when needed, cutting MCP token clutter by up to 95% and keeping your context lean, fast, and focused.

Selenium MCP Server

A server implementation that enables controlling web browsers programmatically through Claude's desktop application, providing comprehensive Selenium WebDriver operations for browser automation with Chrome and Firefox support.

AEM Block Collection MCP Server

Enables access to AEM block metadata by reading structured information from blocks.json files. Provides a simple tool to list available blocks with their descriptions, file paths, and counts.

Marketo MCP Server

A Model Context Protocol server for interacting with the Marketo API that provides tools for managing Marketo forms, including listing, cloning, and approving forms.

MCP SSH SRE

Provides read-only server monitoring and diagnostic tools for AI assistants to manage Linux and Unraid systems via SSH. It enables natural language interactions for container management, storage health checks, and system log analysis while keeping credentials secure.

SAS Data Sets MCP Server by CData

SAS Data Sets MCP Server by CData

Netmind Web3 MCP Server

Provides a comprehensive suite of Web3 tools for querying token addresses, news summaries, and real-time market data via CoinGecko. It also facilitates DeFi operations including token price tracking, pool information, and swap quotes through Sugar DeFi integration.

ODIADEV MCP Server

Nigeria's AI infrastructure server that provides business automation agents including WhatsApp automation, university support, travel management, and legal document processing. Integrates payment processing, text-to-speech capabilities, and webhook handling for Nigerian businesses.