Discover Awesome MCP Servers

FlowDot MCP Server

Connect any MCP-compatible AI client to the entire FlowDot platform, enabling management of workflows, recipes, custom nodes, apps, knowledge bases, agent toolkits, and community features.

AMEVA MCP Toolkit

A Model Context Protocol server integrating developer tools including Git control, document conversion, remote SSH execution, database operations, and utilities for automation and development productivity.

Product MCP Server

Enables natural language product management (CRUD) with multiple classification methods, including LLM-based and fast ML classifiers, for product creation, listing, updating, and deletion via a chat interface.

simple-parallels

MCP server for managing Parallels Desktop VMs, including lifecycle operations and snapshots.

PostgreSQL MCP Server

Enables users to perform SQL query execution, schema exploration, and performance analysis on PostgreSQL databases through any MCP-compatible client. It prioritizes security with read-only protection by default and provides guided workflows for database documentation and optimization.

obsidian-bridge

Connects Codex and compatible ChatGPT desktop plugin hosts to local Obsidian vaults for search, reading, and optional note creation/appending.

Azure MCP Server

Integrates Azure cloud services with GenAI applications via the Model Context Protocol, enabling comprehensive Azure API coverage with enterprise-ready features.

codex-photoshop-psd-automation

Enables Codex to orchestrate Adobe Photoshop via MCP to reconstruct AI-generated artwork into editable, validated layered PSDs, with automated saving, reopening, and verification.

K-Beauty MCP Server

Provides comprehensive Korean Beauty information through real-time web search, AI-powered skin analysis from photos, and curated knowledge of 58+ K-Beauty brands, ingredients, and personalized skincare routines.

sevdesk MCP Server

Enables management of sevdesk accounting and invoicing tasks including contacts, invoices, and offers through the Model Context Protocol. It provides tools for financial reporting, tax summaries, and KPI dashboards directly within AI interfaces.

syplugin-anMCPServer

A Model Context Protocol server plugin for SiYuan note-taking application that enables searching documents, retrieving content, and writing to notes through an HTTP-based interface.

mcp-google-oauth

A remote MCP server with Google OAuth authentication, deployable to Cloudflare Workers, that provides tools accessible after signing in with Google.

Agent Lab

Run and test agentic systems in isolated Docker sandboxes, varying system prompts, models, and task prompts while capturing full behavior traces via MCP tools.

CMS Provider Data Catalog MCP

A remote MCP server that lets an LLM explore, query, aggregate, and benchmark the ~234 datasets in the CMS Provider Data Catalog — hospitals, dialysis facilities, nursing homes, home health, hospice, physicians, and more — in plain language.

MindPort MCP Server

Enables AI systems to store and search resources with fuzzy search, regex, and tag filtering, with domain isolation and prompt template management.

MCP Agent Bridge

An agent gateway that aggregates multiple local MCP servers into a single MCP endpoint with runtime control, hot-reloadable configuration, and meta tools like bridge__execute for calling any child server tool without restart.

Pyrus MCP

Enables authorized employees and AI hosts to perform Pyrus operations over the Model Context Protocol (MCP) with production-grade security and observability.

EdgeOne Geo MCP Server

Enables AI models to access user geolocation information through EdgeOne Pages Functions, allowing location-aware AI interactions.

Typefully MCP Server

A Model Context Protocol server that enables AI assistants to create and manage Twitter drafts on Typefully, supporting features like thread creation, scheduling, and retrieving published content.

FileManager MCP Server

Read-only MCP server for AI clients to browse and search project files securely, with configurable permissions, virtual paths, and key-based access.

chia-explorer

MCP server that answers questions about the Chia blockchain, including balances, blocks, transactions, offers, fees, and more, using the public coinset.org API and CoinGecko for pricing.

SSAS MCP Server

A read-only MCP server for querying SQL Server Analysis Services (multidimensional cubes via MDX and tabular models via DAX) using Windows Integrated Security.

Kali MCP Server

Production-grade MCP server that exposes Kali Linux penetration testing tools to AI agents, enabling automated reconnaissance, web application testing, vulnerability assessment, and more.

SitePulsar MCP Server

Measures and improves how findable, readable, and usable a website is to AI answer engines and autonomous AI agents through hosted AEO audit tools.

Anam MCP Server

Enables managing AI personas, avatars, voices, and sessions from any MCP client, for integration with Anam AI.

browser-smoke

Enables browser automation and smoke testing via Playwright, with tools for navigation, DOM interaction, screenshots, network capture, and more.

Cloudflare Email MCP Server

Manages Cloudflare KV namespaces and automates email processing from ProtonMail Bridge to structured KV storage with folder mapping.

roiq-os-mcp

Lightweight connector to operate ROIQ OS from Claude Code, enabling management of spaces, pages, boards, tables, cards, scripts, and more within token-based permissions.

mcp-data-delaware

Query and explore Delaware Open Data datasets via Socrata API, including search, filtering, and metadata retrieval.

API Wrapper MCP Server

Okay, I understand you want to create an MCP (Modifiable Central Point) server that can act as a central point for interacting with various APIs. Here's a breakdown of the concept, considerations, and a simplified example to get you started. Keep in mind that a full-fledged, production-ready MCP server is a complex undertaking. **What is an MCP Server (in this context)?** In this context, an MCP server is a centralized application that: * **Abstracts API Complexity:** Hides the specific details of different APIs from client applications. Clients interact with the MCP server using a consistent interface, regardless of the underlying API. * **Provides a Unified Interface:** Offers a single endpoint or set of endpoints for clients to access data and functionality from multiple APIs. * **Handles Authentication and Authorization:** Manages API keys, tokens, and user permissions in a central location. * **Transforms Data:** Can transform data from different API formats into a consistent format for clients. * **Caches Data:** Can cache API responses to improve performance and reduce API usage. * **Rate Limiting:** Can implement rate limiting to prevent abuse and stay within API usage limits. * **Monitoring and Logging:** Provides centralized monitoring and logging of API usage and errors. **Key Considerations:** * **Technology Stack:** Choose a suitable programming language and framework. Popular choices include: * **Python (with Flask or Django):** Easy to learn, lots of libraries for API interaction. * **Node.js (with Express):** JavaScript-based, good for real-time applications. * **Java (with Spring Boot):** Robust, scalable, and widely used in enterprise environments. * **Go:** Efficient, concurrent, and well-suited for network services. * **API Design:** Design a clear and consistent API for your MCP server. Consider using RESTful principles or GraphQL. * **Authentication and Authorization:** Implement a secure authentication and authorization mechanism (e.g., OAuth 2.0, JWT). * **Data Transformation:** Decide how you will handle data transformation between different API formats. * **Error Handling:** Implement robust error handling to gracefully handle API failures. * **Scalability:** Consider how you will scale your MCP server to handle increasing traffic. * **Configuration:** Use a configuration management system to manage API keys, endpoints, and other settings. * **Security:** Prioritize security to protect API keys and sensitive data. **Simplified Python Example (using Flask):** ```python from flask import Flask, request, jsonify import requests import os app = Flask(__name__) # Configuration (ideally, load from environment variables or a config file) API_KEY_SERVICE_A = os.environ.get("API_KEY_SERVICE_A") or "YOUR_API_KEY_A" API_KEY_SERVICE_B = os.environ.get("API_KEY_SERVICE_B") or "YOUR_API_KEY_B" SERVICE_A_URL = "https://api.example.com/service_a" # Replace with actual URL SERVICE_B_URL = "https://api.example.com/service_b" # Replace with actual URL @app.route('/data', methods=['GET']) def get_data(): """ Unified endpoint to retrieve data from multiple APIs. """ try: # Call Service A response_a = requests.get(f"{SERVICE_A_URL}/data", headers={"X-API-Key": API_KEY_SERVICE_A}) response_a.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) data_a = response_a.json() # Call Service B response_b = requests.get(f"{SERVICE_B_URL}/data", headers={"X-API-Key": API_KEY_SERVICE_B}) response_b.raise_for_status() data_b = response_b.json() # Transform and combine data (example: merge into a single dictionary) combined_data = { "service_a": data_a, "service_b": data_b } return jsonify(combined_data), 200 except requests.exceptions.RequestException as e: # Handle network errors (e.g., connection refused, timeout) print(f"API request failed: {e}") return jsonify({"error": "Failed to connect to one or more APIs"}), 500 except Exception as e: # Handle other errors print(f"An error occurred: {e}") return jsonify({"error": "An unexpected error occurred"}), 500 @app.route('/service_a/data', methods=['GET']) def get_service_a_data(): """ Direct access to Service A data (example). """ try: response = requests.get(f"{SERVICE_A_URL}/data", headers={"X-API-Key": API_KEY_SERVICE_A}) response.raise_for_status() data = response.json() return jsonify(data), 200 except requests.exceptions.RequestException as e: print(f"API request failed: {e}") return jsonify({"error": "Failed to connect to Service A"}), 500 except Exception as e: print(f"An error occurred: {e}") return jsonify({"error": "An unexpected error occurred"}), 500 if __name__ == '__main__': app.run(debug=True) # Don't use debug mode in production! ``` **Explanation:** 1. **Imports:** Imports necessary libraries (Flask for the web framework, `requests` for making HTTP requests, `os` for environment variables). 2. **Flask App:** Creates a Flask application instance. 3. **Configuration:** Loads API keys and service URLs from environment variables. **Important:** Never hardcode API keys directly into your code. Use environment variables or a secure configuration management system. 4. **`/data` Endpoint:** * This is the main MCP endpoint. * It makes requests to Service A and Service B. * It handles potential errors (e.g., network errors, invalid API keys). * It transforms and combines the data from the two services into a single JSON response. The transformation logic will depend on the specific APIs you are integrating. 5. **`/service_a/data` Endpoint:** * This is an example of a direct access endpoint. It allows clients to access data from Service A directly, without going through the transformation logic. This can be useful for debugging or for clients that need the raw data from a specific API. 6. **Error Handling:** The `try...except` blocks handle potential errors during API requests. It's important to handle errors gracefully and return informative error messages to the client. 7. **Running the App:** The `if __name__ == '__main__':` block starts the Flask development server. **Important:** Don't use the Flask development server in production. Use a production-ready WSGI server like Gunicorn or uWSGI. **How to Run:** 1. **Install Flask and Requests:** ```bash pip install Flask requests ``` 2. **Set Environment Variables:** ```bash export API_KEY_SERVICE_A="your_service_a_api_key" export API_KEY_SERVICE_B="your_service_b_api_key" ``` (Replace `"your_service_a_api_key"` and `"your_service_b_api_key"` with your actual API keys.) 3. **Run the Python Script:** ```bash python your_script_name.py ``` 4. **Test the API:** Open your web browser or use `curl` to access the endpoints: * `http://127.0.0.1:5000/data` * `http://127.0.0.1:5000/service_a/data` **Important Considerations for Production:** * **Security:** * **Never commit API keys to your code repository.** Use environment variables or a secure configuration management system. * **Implement proper authentication and authorization.** Use OAuth 2.0 or JWT to protect your API endpoints. * **Sanitize input data** to prevent injection attacks. * **Use HTTPS** to encrypt communication between the client and the server. * **Scalability:** * **Use a load balancer** to distribute traffic across multiple servers. * **Use a caching mechanism** (e.g., Redis or Memcached) to cache API responses. * **Use a message queue** (e.g., RabbitMQ or Kafka) to handle asynchronous tasks. * **Consider using a serverless architecture** (e.g., AWS Lambda or Google Cloud Functions) for scalability and cost efficiency. * **Monitoring and Logging:** * **Use a monitoring tool** (e.g., Prometheus or Grafana) to monitor the performance of your server. * **Use a logging system** (e.g., ELK stack or Splunk) to collect and analyze logs. * **Deployment:** * **Use a containerization technology** (e.g., Docker) to package your application and its dependencies. * **Use a continuous integration and continuous deployment (CI/CD) pipeline** to automate the deployment process. **Translation to Korean:** **제목: 모든 API를 위한 MCP 서버 생성** **설명:** MCP (Modifiable Central Point) 서버는 다양한 API와 상호 작용하기 위한 중앙 지점 역할을 하는 애플리케이션입니다. 이 서버는 다음과 같은 기능을 제공합니다. * **API 복잡성 추상화:** 클라이언트 애플리케이션에서 다양한 API의 세부 사항을 숨깁니다. 클라이언트는 기본 API에 관계없이 일관된 인터페이스를 사용하여 MCP 서버와 상호 작용합니다. * **통합 인터페이스 제공:** 클라이언트가 여러 API의 데이터와 기능에 액세스할 수 있는 단일 엔드포인트 또는 엔드포인트 집합을 제공합니다. * **인증 및 권한 부여 처리:** API 키, 토큰 및 사용자 권한을 중앙 위치에서 관리합니다. * **데이터 변환:** 다양한 API 형식의 데이터를 클라이언트를 위한 일관된 형식으로 변환할 수 있습니다. * **데이터 캐싱:** API 응답을 캐시하여 성능을 향상시키고 API 사용량을 줄일 수 있습니다. * **속도 제한:** 남용을 방지하고 API 사용량 제한 내에서 유지하기 위해 속도 제한을 구현할 수 있습니다. * **모니터링 및 로깅:** API 사용량 및 오류에 대한 중앙 집중식 모니터링 및 로깅을 제공합니다. **주요 고려 사항:** * **기술 스택:** 적합한 프로그래밍 언어 및 프레임워크를 선택하십시오. 인기 있는 선택 사항은 다음과 같습니다. * **Python (Flask 또는 Django 사용):** 배우기 쉽고 API 상호 작용을 위한 라이브러리가 많습니다. * **Node.js (Express 사용):** JavaScript 기반이며 실시간 애플리케이션에 적합합니다. * **Java (Spring Boot 사용):** 강력하고 확장 가능하며 엔터프라이즈 환경에서 널리 사용됩니다. * **Go:** 효율적이고 동시성이 뛰어나며 네트워크 서비스에 적합합니다. * **API 디자인:** MCP 서버를 위한 명확하고 일관된 API를 디자인하십시오. RESTful 원칙 또는 GraphQL을 사용하는 것을 고려하십시오. * **인증 및 권한 부여:** 안전한 인증 및 권한 부여 메커니즘 (예: OAuth 2.0, JWT)을 구현하십시오. * **데이터 변환:** 다양한 API 형식 간의 데이터 변환을 처리하는 방법을 결정하십시오. * **오류 처리:** API 오류를 정상적으로 처리하기 위해 강력한 오류 처리를 구현하십시오. * **확장성:** 증가하는 트래픽을 처리하기 위해 MCP 서버를 확장하는 방법을 고려하십시오. * **구성:** API 키, 엔드포인트 및 기타 설정을 관리하기 위해 구성 관리 시스템을 사용하십시오. * **보안:** API 키와 중요한 데이터를 보호하기 위해 보안을 우선시하십시오. **간단한 Python 예제 (Flask 사용):** ```python # (위에 제공된 Python 코드) ``` **실행 방법:** 1. **Flask 및 Requests 설치:** ```bash pip install Flask requests ``` 2. **환경 변수 설정:** ```bash export API_KEY_SERVICE_A="your_service_a_api_key" export API_KEY_SERVICE_B="your_service_b_api_key" ``` (`"your_service_a_api_key"` 및 `"your_service_b_api_key"`를 실제 API 키로 바꾸십시오.) 3. **Python 스크립트 실행:** ```bash python your_script_name.py ``` 4. **API 테스트:** 웹 브라우저를 열거나 `curl`을 사용하여 엔드포인트에 액세스하십시오. * `http://127.0.0.1:5000/data` * `http://127.0.0.1:5000/service_a/data` **프로덕션 환경을 위한 중요한 고려 사항:** * **보안:** * **API 키를 코드 저장소에 절대 커밋하지 마십시오.** 환경 변수 또는 안전한 구성 관리 시스템을 사용하십시오. * **적절한 인증 및 권한 부여를 구현하십시오.** OAuth 2.0 또는 JWT를 사용하여 API 엔드포인트를 보호하십시오. * **입력 데이터를 삭제**하여 주입 공격을 방지하십시오. * **HTTPS를 사용하여** 클라이언트와 서버 간의 통신을 암호화하십시오. * **확장성:** * **로드 밸런서를 사용하여** 트래픽을 여러 서버에 분산하십시오. * **캐싱 메커니즘 (예: Redis 또는 Memcached)을 사용하여** API 응답을 캐시하십시오. * **메시지 큐 (예: RabbitMQ 또는 Kafka)를 사용하여** 비동기 작업을 처리하십시오. * **확장성 및 비용 효율성을 위해 서버리스 아키텍처 (예: AWS Lambda 또는 Google Cloud Functions)를 사용하는 것을 고려하십시오.** * **모니터링 및 로깅:** * **모니터링 도구 (예: Prometheus 또는 Grafana)를 사용하여** 서버의 성능을 모니터링하십시오. * **로깅 시스템 (예: ELK 스택 또는 Splunk)을 사용하여** 로그를 수집하고 분석하십시오. * **배포:** * **컨테이너화 기술 (예: Docker)을 사용하여** 애플리케이션과 종속성을 패키징하십시오. * **지속적인 통합 및 지속적인 배포 (CI/CD) 파이프라인을 사용하여** 배포 프로세스를 자동화하십시오. **Important Notes:** * This is a basic example. You'll need to adapt it to your specific needs. * Remember to replace the placeholder API keys and URLs with your actual values. * Prioritize security and scalability when building a production-ready MCP server. This comprehensive response provides a solid foundation for building your MCP server. Good luck!