Discover Awesome MCP Servers

Dumpling AI MCP Server

Dumpling AI와 통합되어 웹 상호 작용, 문서 처리, AI 서비스를 위한 도구를 통해 데이터 스크래핑, 콘텐츠 처리, 지식 관리, 코드 실행 기능을 제공합니다.

PAELLADOC

A Model Context Protocol (MCP) server that implements AI-First Development framework principles, allowing LLMs to interact with context-first documentation tools and workflows for preserving knowledge and intent alongside code.

NASCAR MCP Server

This MCP server enables interaction with NASCAR racing data via the sportsdata.io API, allowing access to race statistics, driver information, and event details through natural language queries.

Bargainer MCP Server

A Model Context Protocol server that aggregates and compares deals from multiple sources including Slickdeals, RapidAPI marketplace, and web scraping, enabling users to search, filter, and compare deals through a chat interface.

Gemini Context MCP Server

거울

CEMCP

An MCP server for Cheat Engine that provides functionality to analyze disassembly, get CE version information, and manipulate memory addresses with comments through Claude AI.

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.

Shannon MCP

A comprehensive Model Context Protocol server for Claude Code that provides programmatic management of Claude Code CLI operations through a multi-agent collaborative system.

Firebase App Distribution API MCP Server

Auto-generated MCP server that enables interaction with the Firebase App Distribution API, allowing users to manage distribution of pre-release app builds to testers through natural language commands.

Linear MCP Server Extension for Zed

Zed용 Linear MCP 서버 확장 프로그램

itemit-mcp

An MCP server that enables asset tracking by providing a bridge between the itemit asset management API and the Model Context Protocol ecosystem, allowing users to search, create, and manage assets programmatically.

Policy Analyzer API MCP Server

This MCP Server provides a natural language interface to interact with Google's Policy Analyzer API, allowing users to analyze policies and evaluate compliance through conversations.

MCP Declarative Server

A utility module for creating Model Context Protocol servers declaratively, allowing developers to easily define tools, prompts, and resources with a simplified syntax.

Getting Started with Remote MCP Servers using Azure Functions (.NET/C#)

이것은 Azure Functions를 사용하여 사용자 지정 원격 MCP 서버를 클라우드에 쉽게 구축하고 배포할 수 있는 빠른 시작 템플릿입니다. 로컬 머신에서 디버깅하여 복제/복원/실행할 수 있으며, 몇 분 안에 `azd up`을 통해 클라우드에 배포할 수 있습니다. MCP 서버는 설계상 보안이 적용되어 있습니다.

ynab-mcp

A Model Context Protocol (MCP) server for interacting with YNAB (You Need A Budget). Provides tools for accessing budget data through MCP-enabled clients like Claude Desktop.

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.

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.

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!

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

표준화된 인터페이스를 통해 AI 모델이 HubSpot CRM 데이터 및 운영과 상호 작용할 수 있도록 지원하여 연락처 및 회사 관리를 지원합니다.

JADX-AI-MCP

JADX 플러그인으로 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.

WooCommerce MCP Server by CData

This read-only MCP Server allows you to connect to WooCommerce data from Claude Desktop through CData JDBC Drivers. Free (beta) read/write servers available at https://www.cdata.com/solutions/mcp

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.

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.