Discover Awesome MCP Servers

Walrus MCP Server

Enables AI assistants to store and retrieve data using the Walrus decentralized storage network. Supports blob storage operations, retrieval by ID, and blockchain-verified availability through the Sui network.

OpenSearch MCP Server

OpenSearch 엔진 내에 메모리를 저장하고 검색할 수 있도록 LLM과 OpenSearch를 통합하는 시맨틱 메모리 레이어를 제공합니다.

barevalue-mcp

Submit podcast editing orders, check status, manage webhooks, and download deliverables via the Barevalue AI podcast editing API.

Focus Data SQL Server

FocusSearch 키워드 파싱 기반의 NL2SQL 플러그인으로, 더 높은 정확도, 더 빠른 속도, 그리고 더 높은 신뢰성을 제공합니다!

SQLite MCP Server

다음은 MCP 클라이언트에서 SQLite 데이터베이스에 접근하기 위한 MCP 서버 구현체입니다. SDIO와 SSE 구현체가 모두 있습니다.

TaskFlow MCP Server

Integrates task management capabilities into Claude Desktop, enabling users to create, track, search, and manage tasks with status updates, team assignments, overdue tracking, and automated standup reports.

AgentMCP: The Universal System for AI Agent Collaboration

Grupa.AI의 멀티 에이전트 협업 네트워크 (MACNET)를 위한 MCPAgent (모델 컨텍스트 프로토콜 (MCP) 기능 내장)

mcp-proxy

mcp proxy

MUI MCP Server

Provides real-time access to Material-UI component documentation, enabling users to search, browse, and generate MUI React components with up-to-date props and examples directly from official documentation.

HomeOps MCP Server

A Model Context Protocol server for home infrastructure management that provides a unified API for Docker and Emby. It enables users to monitor containers, manage media sessions, and search libraries through an extensible adapter-based architecture.

ServiceNow MCP Server (SSE)

A browser-accessible Model Context Protocol server that enables AI assistants to manage ServiceNow incidents using Server-Sent Events. It provides comprehensive tools for creating, listing, retrieving, and updating incidents through a type-safe RESTful interface.

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!

MCP Test

GitHub 연동 MCP 서버

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.

Mattermost MCP Server

Enables Claude to interact with Mattermost through search functionality, user management, channel operations, and team information retrieval. Supports message search by keywords/users/dates, thread viewing, and displays all timestamps in Korean Standard Time (KST).

SentimentAlpha

Social Arbitrage Intelligence: real-time X/Twitter sentiment, narrative velocity & contrarian signals for AI agents, powered by Grok

ApiPost MCP

A server that enables management of ApiPost API documentation and team collaboration through the Model Context Protocol, supporting complete interface management directly from compatible editors.

legends-mcp

Your personal council of tech titans, investing legends, and crypto builders. 36 personas. Zero API keys. One npx command.

Industrial MCP Server

Enables AI assistants to monitor and interact with industrial systems, providing real-time system health monitoring, operational data analytics, and equipment maintenance tracking. Built with Next.js and designed for industrial automation environments.

veyra-bookmarks

Bookmark manager for AI agents with tags, categories, and full-text search. Reads are free, writes require Veyra commit mode.

WebClone MCP Server

Enables AI agents to clone entire websites, download files, manage authentication sessions, and analyze site information with support for JavaScript-heavy SPAs and dynamic content.

IDA-doc-hint-mcp

Ida 문서 리더 (일종의) MCP 서버

ASCIIFlow MCP Server

Exposes ASCIIFlow drawing primitives as tools to enable AI assistants to generate ASCII wireframes and diagrams from natural language descriptions. It provides commands for creating canvases and drawing boxes, lines, arrows, and text using a character-grid coordinate system.

mcp-test

just a test

mcp-spacefrontiers

학술 데이터와 소셜 네트워크를 검색합니다.

Memory Server with Qdrant Persistence

Qdrant를 사용하여 시맨틱 검색으로 지식 그래프 표현을 용이하게 하고, 시맨틱 유사성을 위한 OpenAI 임베딩을 지원하며, 파일 기반 그래프 영속성을 통해 강력한 HTTPS 통합을 제공합니다.

Serveur MCP Airbnb

거울

Tensorus MCP

Model Context Protocol server and client that enables AI agents and LLMs to interact with Tensorus tensor database for operations like creating datasets, ingesting tensors, and applying tensor operations.

authorize-net-mcp

실험적인 Authorize.net Node.js TypeScript MCP 서버

RhinoMCP

Rhino3D를 모델 컨텍스트 프로토콜을 통해 Claude AI에 연결하여, Rhino의 기능을 직접 제어함으로써 AI 지원 3D 모델링 및 디자인 워크플로우를 가능하게 합니다.