Discover Awesome MCP Servers

Unified History MCP

Config-driven MCP server for cross-domain full-text search across agent session logs, meeting transcripts, and notification files.

uol-mcp-http

Enables AI agents to interact with the UOL Accounting REST API through MCP, supporting reads immediately and mutating operations with explicit confirmation, and is designed for deployment on Railway and use with Cursor.

codescan-mcp

Scans codebases for TODOs, FIXMEs, code complexity, file stats, and dependencies, generating a health report with a letter grade. Zero configuration required.

MySQL MCP Server Pro

Enables comprehensive MySQL database operations including CRUD, performance optimization, health monitoring, index analysis, lock detection, and SQL execution plan analysis with role-based permission control.

dsh-mediacrawler

An MCP adapter that connects DeepSeek Harness to MediaCrawler, enabling search, post/video detail, creator feeds, and comments across multiple Chinese social platforms. It provides eight supervised tools for collecting, monitoring, and exporting crawl results.

Jira MCP Server

Provides read-only issue and project management tools for Jira Server/DC, enabling querying issues, projects, and assignments via natural language.

proxmox-mcp

MCP server for Proxmox VE that enables AI assistants to inspect and manage LXC containers, VMs, snapshots, and resource pools via the Proxmox API.

Pepesto MCP Server

MCP server for the Pepesto API — give your agent the ability to turn any recipe (a URL, plain text, or a photo) into a matched basket of real supermarket products with live prices, across 26 European supermarkets. The MCP covers the recipe → matched cart half of the grocery shopping workflow (parse / search / map ingredients to SKUs / check catalogs).

email-mcp

Local IMAP/SMTP MCP server that lets Claude read, search, draft, send, flag, and move mail across multiple IMAP mailboxes. Credentials stay on your machine.

LuzzyTool

A local smart tool collection based on MCP that enables AI assistants to perform file management, document editing, shell execution, semantic retrieval, and text processing.

LibreLink Up (CGM)

Read-only MCP server for accessing glucose readings, charts, logbook, and statistics from LibreLink Up sensors, supporting any MCP client.

Codecov MCP Server

Enables querying Codecov coverage data including file, commit, repository, and pull request coverage.

Heista MCP

Decode any video ad, load brand information, and generate ad scripts from inside MCP-compatible clients like Claude and ChatGPT.

video_agent

Enables probing, ingesting, transcribing, and searching Bilibili videos with timestamped evidence and frame extraction, without reading browser cookies.

dingdawg-healthcare-agent

Enables HIPAA-aware healthcare workflow automation including patient intake, clinical summaries, compliance checking, and appointment scheduling via MCP tools.

Arco Lexicon

Canonical vocabulary server for autonomous business design. Exposes the Arco Lexicon as seven MCP tools: term lookup, related terms, alignment verification, citation formatting, source retrieval, term listing, and term suggestion. No authentication required. Streamable HTTP transport.

gl-mcp-feedback

A feedback-oriented MCP server with a Web UI for AI development workflows, enabling interactive confirmations and reducing speculative tool calls.

think-mcp

Provides structured thinking tools including mental models, design patterns, debugging approaches, decision frameworks, and multi-persona reasoning to enhance AI assistant problem-solving capabilities.

MongoDB That Works - MCP Server

Enables interaction with MongoDB databases through CRUD operations, aggregation, and schema discovery, with automatic field validation and ObjectId conversion.

Mcp Qdrant Docker

Okay, here's a breakdown of Docker configuration for a Qdrant MCP (Multi-Cluster Proxy) server, along with explanations and best practices. I'll cover the key aspects: **1. Dockerfile (Example)** This is the foundation. It defines how your Docker image is built. ```dockerfile # Use an official Qdrant image as the base FROM qdrant/qdrant:latest # Or a specific version, e.g., qdrant/qdrant:v1.7.5 # Set environment variables (optional, but recommended) ENV QDRANT_MCP_ENABLED=true ENV QDRANT_MCP_BIND="0.0.0.0:6333" # Listen on all interfaces, port 6333 (default MCP port) ENV QDRANT_MCP_CLUSTERS="cluster1=http://qdrant1:6333,cluster2=http://qdrant2:6333" # Replace with your actual cluster addresses # Example for authentication # ENV QDRANT_MCP_API_KEY="your_secret_api_key" # Expose the MCP port EXPOSE 6333 # Optionally, copy custom configuration files (if needed) # COPY config/mcp_config.yaml /qdrant/config/mcp_config.yaml # The Qdrant image already has the entrypoint set up, so no need to define it here. ``` **Explanation of Dockerfile Instructions:** * **`FROM qdrant/qdrant:latest`**: This is crucial. It starts with the official Qdrant Docker image. Using `latest` is convenient for quick testing, but **strongly recommended** to use a specific version tag (e.g., `qdrant/qdrant:v1.7.5`) for production to ensure consistent behavior and avoid unexpected updates. * **`ENV QDRANT_MCP_ENABLED=true`**: Enables the Multi-Cluster Proxy functionality within the Qdrant instance. This is essential. * **`ENV QDRANT_MCP_BIND="0.0.0.0:6333"`**: Specifies the address and port the MCP will listen on. `0.0.0.0` means it will listen on all available network interfaces within the container. Port `6333` is the default MCP port. Change this if you have port conflicts. * **`ENV QDRANT_MCP_CLUSTERS="cluster1=http://qdrant1:6333,cluster2=http://qdrant2:6333"`**: This is the most important configuration. It defines the Qdrant clusters that the MCP will proxy requests to. The format is: * `cluster_name=cluster_address` * `cluster_name` is a logical name you give to the cluster. You'll use this name when making requests through the MCP. * `cluster_address` is the HTTP address of the Qdrant cluster's main API endpoint (usually the same port as the Qdrant server itself, which defaults to 6333). **Crucially, this address must be resolvable from *within* the Docker container.** If your Qdrant clusters are running in the same Docker network, you can use their service names (e.g., `qdrant1`, `qdrant2`). If they are on a different network or outside of Docker, you'll need to use their IP addresses or fully qualified domain names (FQDNs). * You can define multiple clusters, separated by commas. * **`ENV QDRANT_MCP_API_KEY="your_secret_api_key"` (Optional but Highly Recommended)**: Sets an API key for the MCP. **Never skip this in production!** This protects your MCP from unauthorized access. Clients will need to provide this API key in the `api-key` header when making requests. * **`EXPOSE 6333`**: This tells Docker that the container will listen on port 6333. It's mostly for documentation purposes and doesn't automatically publish the port. You'll need to use the `-p` flag when running the container to actually expose the port to the host. * **`COPY config/mcp_config.yaml /qdrant/config/mcp_config.yaml` (Optional)**: If you have a custom `mcp_config.yaml` file (for more advanced configuration), you can copy it into the container. The default location is `/qdrant/config/mcp_config.yaml`. You'll need to create the `config` directory locally and place your `mcp_config.yaml` file there. **2. Building the Docker Image** ```bash docker build -t qdrant-mcp . # The dot (.) means the Dockerfile is in the current directory ``` This command builds the Docker image and tags it as `qdrant-mcp`. **3. Running the Docker Container** ```bash docker run -d \ -p 6333:6333 \ --name qdrant-mcp \ --network my-qdrant-network \ # Important: Place in the same network as your Qdrant clusters (if applicable) qdrant-mcp ``` **Explanation of `docker run` Options:** * **`-d`**: Runs the container in detached mode (in the background). * **`-p 6333:6333`**: Publishes port 6333 from the container to port 6333 on the host machine. The format is `host_port:container_port`. If you want to use a different port on the host, change the `host_port` value. * **`--name qdrant-mcp`**: Assigns a name to the container, making it easier to manage. * **`--network my-qdrant-network`**: **Critical!** This places the MCP container in the same Docker network as your Qdrant cluster containers (if they are Dockerized). This allows the MCP to resolve the cluster addresses (e.g., `qdrant1`, `qdrant2`) defined in the `QDRANT_MCP_CLUSTERS` environment variable. Replace `my-qdrant-network` with the actual name of your Docker network. If your Qdrant clusters are *not* in Docker, you can omit this option, but you'll need to use the correct IP addresses or FQDNs in the `QDRANT_MCP_CLUSTERS` environment variable. * **`qdrant-mcp`**: The name of the Docker image to run. **4. Docker Compose (Recommended for Multi-Container Environments)** Docker Compose is a tool for defining and running multi-container Docker applications. It's highly recommended for managing Qdrant clusters and the MCP together. Here's an example `docker-compose.yml` file: ```yaml version: "3.9" services: qdrant1: image: qdrant/qdrant:latest ports: - "6333:6333" volumes: - qdrant_data1:/qdrant/storage networks: - qdrant-net qdrant2: image: qdrant/qdrant:latest ports: - "6334:6333" # Expose on a different host port volumes: - qdrant_data2:/qdrant/storage networks: - qdrant-net qdrant-mcp: build: . # Assumes the Dockerfile is in the same directory ports: - "6333:6333" environment: QDRANT_MCP_ENABLED: "true" QDRANT_MCP_BIND: "0.0.0.0:6333" QDRANT_MCP_CLUSTERS: "cluster1=http://qdrant1:6333,cluster2=http://qdrant2:6333" QDRANT_MCP_API_KEY: "your_secret_api_key" depends_on: - qdrant1 - qdrant2 networks: - qdrant-net volumes: qdrant_data1: qdrant_data2: networks: qdrant-net: ``` **Explanation of `docker-compose.yml`:** * **`version: "3.9"`**: Specifies the Docker Compose file version. * **`services`**: Defines the services (containers) that make up your application. * **`qdrant1` and `qdrant2`**: These define two Qdrant cluster nodes. * `image`: Uses the official Qdrant image. * `ports`: Maps ports. Note that `qdrant2` maps container port 6333 to host port 6334 to avoid conflicts. * `volumes`: Creates named volumes to persist data across container restarts. * `networks`: Places the containers in the `qdrant-net` network. * **`qdrant-mcp`**: Defines the MCP container. * `build: .`: Tells Docker Compose to build the image from the Dockerfile in the current directory. * `ports`: Maps the MCP port. * `environment`: Sets the environment variables for the MCP. **Important:** The `QDRANT_MCP_CLUSTERS` variable uses the service names (`qdrant1`, `qdrant2`) because the containers are in the same network. * `depends_on`: Ensures that the Qdrant cluster nodes are started before the MCP. * `networks`: Places the MCP container in the `qdrant-net` network. * **`volumes`**: Defines the named volumes for data persistence. * **`networks`**: Defines the Docker network. **To run the Docker Compose setup:** ```bash docker-compose up -d ``` This will build the images (if necessary) and start all the containers in detached mode. **5. Important Considerations and Best Practices:** * **Networking:** Proper networking is absolutely critical. The MCP container *must* be able to resolve the addresses of the Qdrant cluster nodes. Use Docker networks to simplify this if your clusters are also Dockerized. If not, use the correct IP addresses or FQDNs. * **API Key:** **Always set a strong `QDRANT_MCP_API_KEY` in production.** Without it, your MCP is vulnerable to unauthorized access. * **Version Pinning:** Use specific version tags for the Qdrant image (e.g., `qdrant/qdrant:v1.7.5`) instead of `latest` to ensure consistent behavior. * **Health Checks:** Implement health checks in your Docker Compose file or orchestration system (e.g., Kubernetes) to automatically restart the MCP container if it becomes unhealthy. You can use the Qdrant API to check the health of the MCP. * **Logging:** Configure proper logging for the MCP container to help with troubleshooting. Docker captures the standard output and standard error streams. Consider using a logging driver (e.g., `json-file`, `fluentd`, `gelf`) to send logs to a central logging system. * **Resource Limits:** Set resource limits (CPU, memory) for the MCP container to prevent it from consuming excessive resources. * **Configuration Files:** For more complex configurations, use a custom `mcp_config.yaml` file. See the Qdrant documentation for details on the available configuration options. * **Security:** * **Least Privilege:** Run the Qdrant containers with the least privileges necessary. Avoid running as root if possible. * **Network Segmentation:** Isolate your Qdrant cluster and MCP in a dedicated network to limit the blast radius of any security breaches. * **Firewall:** Use a firewall to restrict access to the Qdrant cluster and MCP to only authorized clients. * **Monitoring:** Monitor the performance of the MCP and the Qdrant clusters to identify and address any issues. Use metrics such as request latency, error rates, and resource utilization. * **Load Balancing:** If you have a large number of clients, consider using a load balancer in front of the MCP to distribute traffic across multiple MCP instances. This can improve performance and availability. * **TLS/SSL:** Enable TLS/SSL encryption for communication between the clients, the MCP, and the Qdrant clusters to protect sensitive data in transit. You'll need to configure certificates and update the cluster addresses in the `QDRANT_MCP_CLUSTERS` environment variable to use `https://`. **Example Client Request (with API Key):** ```python import requests url = "http://your_mcp_address:6333/collections" # Replace with your MCP address headers = {"api-key": "your_secret_api_key"} # Replace with your API key response = requests.get(url, headers=headers) print(response.status_code) print(response.json()) ``` **Korean Translation of Key Concepts:** * **Docker Configuration:** 도커 설정 (Dokeo Seoljeong) * **Dockerfile:** 도커파일 (Dokeopa-il) * **Docker Image:** 도커 이미지 (Dokeo Imiji) * **Docker Container:** 도커 컨테이너 (Dokeo Keonteineo) * **Multi-Cluster Proxy (MCP):** 멀티 클러스터 프록시 (Meolti Keulleoseuteo Peuroksi) * **Environment Variable:** 환경 변수 (Hwangyeong Byeonsu) * **Port Mapping:** 포트 매핑 (Poteu Maeping) * **Docker Compose:** 도커 컴포즈 (Dokeo Keompojeu) * **Network:** 네트워크 (Neteuweokeu) * **API Key:** API 키 (API Ki) * **Cluster Address:** 클러스터 주소 (Keulleoseuteo Juso) * **Security:** 보안 (Boan) * **Load Balancing:** 로드 밸런싱 (Rodeu Baelleonsing) * **TLS/SSL:** TLS/SSL This comprehensive guide should help you configure a Qdrant MCP server using Docker. Remember to adapt the examples to your specific environment and security requirements. Good luck!

Coffee Company MCP Server

An MCP adapter that maps Coffee Company B2B HTTP APIs to MCP tools, allowing AI agents to query member information, benefits, coupons, and payment statuses. It enables seamless integration for AI assistants to manage coffee-related customer assets and loyalty details through natural language.

Power Platform Pipeline MCP Server

Exposes Power Platform Pipeline operations as MCP tools for Copilot Studio agents, enabling pipeline discovery, deployments, approvals, and configuration management.

MCP Data Server

An MCP server that connects AI agents to cloud-native geospatial data via STAC metadata and DuckDB with H3 spatial indexing, enabling zero-configuration SQL queries on terabyte-scale datasets over S3.

tome-mcp

Manages a research paper library, providing PDF ingestion, bibliography management, semantic search, figure tracking, and integration with Semantic Scholar.

worldmonitor-mcp

MCP server wrapping worldmonitor global intelligence dashboard, exposing 140 tools across 32 services for live market, geopolitical, military, cyber, climate, and supply chain data.

obolpay-x402-mcp

MCP server for a live x402 payment gateway on Base (USDC). Lets AI agents discover, preview for free, then pay per call — with prepaid gasless payments, signed receipts, and delta delivery.

Singapore Location Intelligence MCP

Provides comprehensive Singapore transport routing with real-time public transport data, weather-aware journey planning, postal code resolution, and Google Maps-quality turn-by-turn navigation across MRT, LRT, buses, and walking routes.

PyMCPAutoGUI

GUI 자동화 기능을 통해 AI 에이전트를 연결하여 마우스, 키보드, 창을 제어하고 스크린샷을 찍어 데스크톱 애플리케이션과 상호 작용할 수 있도록 하는 MCP 서버.

ICP Intelligence MCP

Enables deep ICP analysis with 9 tools for ideal customer profiling, market sizing, buyer mapping, and account prioritization.