Discover Awesome MCP Servers

a2db

Most database MCP servers make you run one query at a time, repeat connection details on every call, and return results double-encoded inside JSON strings. a2db fixes all of that: Pre-configured connections — define databases in .mcp.json with --register, agent queries immediately Batch queries — run multiple named queries in a single tool call

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.

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

WhatsApp Evolution API를 위한 MCP SSE 서버

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.

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.

Apple MCP Server

Enables interaction with Apple apps like Messages, Notes, and Contacts through the MCP protocol to send messages, search, and open app content using natural language.

Amap MCP Server

Provides comprehensive geographic information services and route planning for AI agents via the Amap (Gaode Maps) API. It supports geocoding, multi-modal navigation, POI searches, and administrative region queries.

Serverless VPC Access MCP Server

An auto-generated MCP server for Google's Serverless VPC Access API, enabling communication with Google Cloud VPC networks through natural language interactions.

TradingView MCP Server

Enables trading analysis across Forex, Stocks, and Crypto with 25+ technical indicators, real-time market data, and Pine Script v6 development tools including syntax validation, autocomplete, and version conversion.

Document Organizer MCP Server

Enables systematic document organization with PDF-to-Markdown conversion, intelligent categorization, and automated workflow management. Supports project documentation standards and provides complete end-to-end document processing pipelines.

MCP Desktop Tools

An MCP server that provides Claude with comprehensive desktop automation capabilities including browser control, window management, and native mouse/keyboard input on Windows. It enables users to capture screenshots, launch applications, and interact with the system clipboard through natural language.

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.

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

I understand you're looking for a way to automatically generate an **Mock Control Plane (MCP) server** from an OpenAPI (formerly Swagger) specification. This is a great idea for testing, development, and prototyping! While I can't directly *generate* and run a server for you in this environment, I can provide you with the tools, concepts, and a detailed outline of how to achieve this. I'll focus on the most common and effective approaches. Here's a breakdown of how to do it, along with code examples and explanations: **1. Understanding the Goal: MCP Server from OpenAPI** * **OpenAPI Specification:** This is the contract that defines your API. It describes endpoints, request/response formats, authentication, and more. * **MCP Server (Mock Control Plane):** A lightweight server that *simulates* the behavior of your real API. It uses the OpenAPI spec to: * **Validate Requests:** Ensures incoming requests conform to the defined schema. * **Generate Mock Responses:** Returns pre-defined or dynamically generated responses based on the OpenAPI spec's examples or schemas. * **Handle Different Scenarios:** Allows you to configure different responses for various request parameters or headers, simulating error conditions, edge cases, etc. **2. Key Tools and Libraries** * **Prism (by Stoplight):** A very popular and powerful tool specifically designed for mocking APIs from OpenAPI specifications. It's a command-line tool that can be easily integrated into your development workflow. * **Swagger Editor/UI:** Useful for viewing and validating your OpenAPI specification. It helps ensure your spec is correct before you try to generate the mock server. * **Node.js and npm (Node Package Manager):** Required for installing and running Prism (and many other related tools). * **Python (with Flask or FastAPI):** If you prefer a more programmatic approach, you can use Python with a web framework like Flask or FastAPI to build a custom mock server. Libraries like `connexion` (for Flask) or `fastapi-mvc` (for FastAPI) can help you automatically generate routes and request/response handling based on your OpenAPI spec. **3. Approach 1: Using Prism (Recommended)** Prism is the easiest and most direct way to create an MCP server from an OpenAPI spec. * **Installation:** ```bash npm install -g @stoplight/prism-cli ``` * **Running the Mock Server:** ```bash prism mock -p 4010 your-openapi-spec.yaml ``` * `-p 4010`: Specifies the port (e.g., 4010) on which the mock server will run. Choose an available port. * `your-openapi-spec.yaml`: Replace this with the actual path to your OpenAPI specification file (YAML or JSON). * **How Prism Works:** 1. **Parses the OpenAPI Spec:** Prism reads your `your-openapi-spec.yaml` file. 2. **Creates Endpoints:** It automatically creates routes based on the `paths` section of your OpenAPI spec. 3. **Validates Requests:** When a request comes in, Prism validates it against the schema defined in the spec. If the request is invalid, it returns an error. 4. **Generates Responses:** * **Examples:** If your OpenAPI spec includes `examples` in the response schema, Prism will return those examples. This is the preferred way to define mock responses. * **Schema-Based Generation:** If no examples are provided, Prism can attempt to generate a response based on the schema. This is less reliable than using examples. * **Example OpenAPI Spec (Simplified):** ```yaml openapi: 3.0.0 info: title: My API version: 1.0.0 paths: /users/{userId}: get: summary: Get a user by ID parameters: - name: userId in: path required: true schema: type: integer responses: '200': description: Successful operation content: application/json: schema: type: object properties: id: type: integer name: type: string examples: user1: value: id: 123 name: "John Doe" '404': description: User not found ``` In this example, when you make a `GET` request to `/users/123`, Prism will return the JSON: ```json { "id": 123, "name": "John Doe" } ``` * **Customizing Prism's Behavior:** * **Dynamic Responses:** Prism supports dynamic responses using handlebars templates. This allows you to generate responses based on request parameters or headers. See the Prism documentation for details. * **Mocking Different Scenarios:** You can create multiple OpenAPI specs, each representing a different scenario (e.g., success, error, edge case). Then, you can switch between these specs to test different aspects of your application. * **Traffic Interception:** Prism can also act as a proxy, intercepting traffic to your real API and mocking responses based on the OpenAPI spec. This is useful for testing your application against a mock API without modifying your application's code. **4. Approach 2: Python with Flask/FastAPI and Connexion/fastapi-mvc** This approach gives you more control but requires more coding. * **Flask with Connexion (Example):** 1. **Install Dependencies:** ```bash pip install connexion flask ``` 2. **Create a `server.py` file:** ```python import connexion app = connexion.App(__name__, specification_dir='./') app.add_api('your-openapi-spec.yaml') # Replace with your spec file app.run(port=4010) ``` 3. **Run the Server:** ```bash python server.py ``` * **Connexion:** Connexion automatically creates Flask routes based on your OpenAPI spec. It handles request validation and response serialization. You'll need to provide *implementation functions* (called "operation handlers") for each endpoint. These functions will generate the mock responses. * **Example Operation Handler (in `server.py` or a separate module):** ```python def get_user(userId): """ This function handles the /users/{userId} endpoint. It returns a mock user object. """ if userId == 123: return {"id": 123, "name": "John Doe"} else: return {"message": "User not found"}, 404 ``` You'll need to tell Connexion which function to use for each operation in your OpenAPI spec using the `operationId` field. For example, in your OpenAPI spec: ```yaml paths: /users/{userId}: get: summary: Get a user by ID operationId: get_user # This tells Connexion to use the get_user function parameters: - name: userId in: path required: true schema: type: integer responses: '200': description: Successful operation content: application/json: schema: type: object properties: id: type: integer name: type: string '404': description: User not found ``` * **FastAPI with fastapi-mvc (Example):** 1. **Install Dependencies:** ```bash pip install fastapi uvicorn fastapi-mvc ``` 2. **Create a FastAPI-MVC project:** ```bash fastapi-mvc new my_mcp_server --openapi your-openapi-spec.yaml ``` Replace `your-openapi-spec.yaml` with the path to your OpenAPI file. `fastapi-mvc` will generate a project structure for you. 3. **Implement the Controllers:** `fastapi-mvc` will generate controller files (e.g., in the `app/controllers` directory) with placeholder functions. You'll need to implement these functions to return mock responses, similar to the Flask example above. 4. **Run the Server:** ```bash cd my_mcp_server fastapi-mvc run ``` * **fastapi-mvc:** This tool simplifies the creation of FastAPI applications from OpenAPI specifications. It generates a project structure, including controllers, models, and other necessary files. **5. Key Considerations and Best Practices** * **Realistic Data:** Use realistic data in your mock responses. This will help you catch potential issues in your application early on. Consider using libraries like `Faker` (Python) to generate realistic data. * **Error Handling:** Don't just focus on successful responses. Mock error conditions (e.g., 400 Bad Request, 404 Not Found, 500 Internal Server Error) to test how your application handles errors. * **Versioning:** If your API has multiple versions, create separate OpenAPI specs for each version and run separate mock servers. * **Security:** If your API uses authentication, mock the authentication process. You can use tools like JWT (JSON Web Tokens) to generate mock tokens. * **Documentation:** Keep your OpenAPI spec up-to-date. This is crucial for ensuring that your mock server accurately reflects the behavior of your real API. * **Integration Testing:** Use your mock server in integration tests to verify that your application interacts correctly with the API. * **Contract Testing:** Consider using contract testing tools (e.g., Pact) to ensure that your application and the API (real or mock) adhere to the same contract (defined by the OpenAPI spec). **In Summary:** Prism is generally the easiest and fastest way to create an MCP server from an OpenAPI spec. It's a great choice for simple mocking scenarios. If you need more control over the mock responses or want to implement more complex logic, Python with Flask/FastAPI and Connexion/fastapi-mvc provides a more flexible solution. Remember to focus on realistic data, error handling, and keeping your OpenAPI spec up-to-date. 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.

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.

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.

freqtrade-mcp

A read-only MCP server that provides LLMs with introspection data and documentation for the Freqtrade codebase. It enables AI tools to access class signatures, method details, and configuration schemas to assist in writing more reliable trading strategies.

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.

İhale MCP

Enables users to search and access Turkish public procurement data from EKAP v2 portal. Provides comprehensive tender search, detailed tender information, announcements, and authority/classification code lookups through natural language interactions.