Discover Awesome MCP Servers

Parzley MCP Server

Enables AI-powered form filling through natural language by exposing the Parzley AI Form Filling Agent API as an MCP server.

plaud-mcp

Enables querying Plaud AI recordings, transcripts, and summaries through the Plaud Desktop app's authenticated session via Chrome DevTools Protocol.

mikrotik-mcp

Turns a MikroTik router into 310 MCP tools for AI-driven configuration over SSH, covering firewall, routing, VPN, and more.

cartridge-mcp

An MCP server that enables users to treat behaviors as swappable cartridges, each with its own tools, onboarding flow, and personality skins. It allows building scenes by combining cartridges with different personas and sharing them via git repositories.

memgrep

Enables AI agents to search and retrieve past chat transcripts from Cursor, Claude Code, and Kiro, providing a global, local memory for context-aware assistance.

Asgard MCP Server

A modular MCP server that provides file search, URL fetching, text reading, knowledge base search, and image embedding tools, with a web interface powered by an Ollama agent.

Supabase MCP HTTP Stream Server

Docker-deployable server that enables interaction with Supabase databases via HTTP streaming, allowing n8n workflows, AI agents, and automation tools to execute SQL queries, manage database migrations, deploy edge functions, and search documentation.

Vastu Compliance MCP Server

An MCP server for checking architectural designs against Vastu principles, integrating with Autodesk tools to provide deterministic compliance scoring and explainable recommendations.

CloakBrowser MCP

CloakBrowser MCP server for AI agents: Playwright-powered browsing, clean tool forwarding, Docker support, and multi-session HTTP transport.

cnbs-mcp-server

Enables querying statistical data from China NBS, World Bank, IMF, OECD, BIS, census, and department statistics via MCP tools.

Seamless

Local-first shared memory and task coordination for AI coding agents. One Go binary, MCP server, markdown files you own. Hooks for Claude Code and Codex CLI (and their desktop apps).

@node2flow/google-docs-mcp

MCP server for Google Docs — create, read, edit, format, and manage documents through 26 tools via the Model Context Protocol.

mcp-jira-server

MCP server that provides AI assistants with access to Jira Cloud for issue management, search, and workflow operations.

Airflow MCP

Enables natural language interaction with Apache Airflow for querying DAGs, monitoring execution, and troubleshooting failures.

Remote MCP Server

A Cloudflare Workers-based implementation of a Model Context Protocol server that enables AI assistants like Claude to access external tools through OAuth authentication.

ThreadMine MCP Server

Enables analysis of JVM thread dumps to detect deadlocks, CPU spikes, pool exhaustion, and virtual thread pinning, returning a health score and interactive report link.

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.

mcp-bing-webmaster

Provides secure, read-only access to Bing Webmaster Tools analytics and non-destructive URL submission for indexing, without destructive site management capabilities.

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.

weixin-devtools-mcp

Enables automated testing of WeChat mini-programs via Model Context Protocol, providing tools for connecting to WeChat Developer Tools, querying and interacting with page elements, making assertions, navigating, and debugging.

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.

eosl-mcp

Source-backed hardware end-of-life (EOL/EOSL) lookups by part number for enterprise gear — support status, end-of-sale and end-of-support dates, with the vendor's own bulletin URL on every answer. Unknown parts return found:false, never a guess.

clipboard-image

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

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!

Universal AI Memory MCP Server

Provides a local-first secure memory store with encrypted payloads, entity extraction, and vector persistence, exposing read, write, and delete tools with granular capability controls.

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.

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.

wemp-operator-mcp

Enables to operate a WeChat Official Account via MCP tools, including searching and executing API workflows and uploading files.

Nura MCP Policy Interceptor

A governance and policy enforcement gateway for MCP servers that provides hard guardrails, dynamic parameter bounds, human-in-the-loop approvals, and audit telemetry.