Discover Awesome MCP Servers

Mcp Qdrant Docker

Okay, here's a breakdown of a Docker configuration for a Qdrant MCP (Multi-Cluster Proxy) server, along with explanations and best practices. I'll cover the `Dockerfile` and `docker-compose.yml` examples. **Understanding Qdrant MCP** Before diving into the Docker configuration, let's briefly recap what Qdrant MCP does: * **Multi-Cluster Management:** It acts as a single entry point to manage multiple Qdrant clusters. * **Routing:** It intelligently routes requests to the appropriate cluster based on configuration. * **Abstraction:** It hides the complexity of managing multiple clusters from client applications. * **Load Balancing:** It can distribute load across multiple clusters. **1. Dockerfile (for building the Qdrant MCP image)** ```dockerfile # Use an official Rust base image for building FROM rust:1.75-slim-bookworm AS builder # Set the working directory inside the container WORKDIR /usr/src/qdrant-mcp # Copy the Cargo.toml and Cargo.lock files to the container COPY Cargo.toml Cargo.lock ./ # Build dependencies (this caches them for faster builds) RUN cargo build --release --target x86_64-unknown-linux-gnu # Copy the source code COPY src ./src # Build the application in release mode RUN cargo build --release --target x86_64-unknown-linux-gnu # Create a minimal runtime image FROM debian:bookworm-slim # Install necessary runtime dependencies (if any) RUN apt-get update && apt-get install -y --no-install-recommends \ libssl-dev \ ca-certificates \ && rm -rf /var/lib/apt/lists/* # Set the working directory WORKDIR /app # Copy the built binary from the builder stage COPY --from=builder /usr/src/qdrant-mcp/target/x86_64-unknown-linux-gnu/release/qdrant-mcp ./qdrant-mcp # Expose the port that the MCP server will listen on EXPOSE 6333 # Define the command to run when the container starts CMD ["./qdrant-mcp", "--config-path", "/app/config.yaml"] ``` **Explanation of the Dockerfile:** 1. **Base Image:** * `FROM rust:1.75-slim-bookworm AS builder`: Starts with an official Rust image based on Debian Bookworm. The `AS builder` gives this stage a name, allowing us to copy artifacts from it later. Using a specific Rust version ensures consistency. The `slim-bookworm` variant is smaller than the full image. 2. **Working Directory:** * `WORKDIR /usr/src/qdrant-mcp`: Sets the working directory inside the container. 3. **Dependency Caching:** * `COPY Cargo.toml Cargo.lock ./`: Copies the `Cargo.toml` and `Cargo.lock` files (Rust's package manager files). * `RUN cargo build --release --target x86_64-unknown-linux-gnu`: Builds the dependencies. This is a crucial step for caching. Docker will only re-run this step if the `Cargo.toml` or `Cargo.lock` files change. `--release` optimizes the build for production. `--target x86_64-unknown-linux-gnu` specifies the target architecture. 4. **Copy Source Code:** * `COPY src ./src`: Copies the source code of your Qdrant MCP application. 5. **Build Application:** * `RUN cargo build --release --target x86_64-unknown-linux-gnu`: Builds the application in release mode. 6. **Minimal Runtime Image:** * `FROM debian:bookworm-slim`: Starts with a minimal Debian Bookworm image for the runtime environment. This keeps the final image size small. 7. **Runtime Dependencies:** * `RUN apt-get update && apt-get install -y --no-install-recommends ...`: Installs any necessary runtime dependencies. `libssl-dev` is often needed for TLS/SSL support. `ca-certificates` are needed for verifying SSL certificates. `--no-install-recommends` avoids installing unnecessary recommended packages. `rm -rf /var/lib/apt/lists/*` cleans up the APT package lists to further reduce image size. 8. **Working Directory (Runtime):** * `WORKDIR /app`: Sets the working directory for the runtime environment. 9. **Copy Binary:** * `COPY --from=builder /usr/src/qdrant-mcp/target/x86_64-unknown-linux-gnu/release/qdrant-mcp ./qdrant-mcp`: Copies the compiled binary from the `builder` stage to the runtime image. 10. **Expose Port:** * `EXPOSE 6333`: Exposes port 6333, which is the default port for Qdrant MCP. You can change this if needed. 11. **Command:** * `CMD ["./qdrant-mcp", "--config-path", "/app/config.yaml"]`: Defines the command to run when the container starts. This runs the `qdrant-mcp` executable and specifies the path to the configuration file. **Important:** You'll need to create a `config.yaml` file (see example below) and copy it into the container (usually done in the `docker-compose.yml` file). **2. `docker-compose.yml` (for orchestrating the container)** ```yaml version: "3.9" services: qdrant-mcp: image: qdrant-mcp:latest # Or your preferred tag build: context: . dockerfile: Dockerfile ports: - "6333:6333" volumes: - ./config.yaml:/app/config.yaml # Mount the config file environment: # Optional environment variables (e.g., for logging) RUST_LOG: "info" restart: unless-stopped networks: - qdrant-network networks: qdrant-network: driver: bridge ``` **Explanation of the `docker-compose.yml`:** 1. **Version:** * `version: "3.9"`: Specifies the Docker Compose file version. 2. **Services:** * `qdrant-mcp:`: Defines the service for the Qdrant MCP container. 3. **Image:** * `image: qdrant-mcp:latest`: Specifies the image to use. If the image doesn't exist locally, Docker Compose will build it. You can replace `latest` with a specific tag. 4. **Build:** * `build:`: Defines how to build the image. * `context: .`: Sets the build context to the current directory. * `dockerfile: Dockerfile`: Specifies the Dockerfile to use. 5. **Ports:** * `ports:`: Maps ports between the host machine and the container. * `"6333:6333"`: Maps port 6333 on the host to port 6333 in the container. This allows you to access the Qdrant MCP server from your host machine. 6. **Volumes:** * `volumes:`: Mounts volumes to share data between the host and the container. * `./config.yaml:/app/config.yaml`: Mounts the `config.yaml` file from the current directory on the host to `/app/config.yaml` inside the container. This is how you provide the configuration to the Qdrant MCP server. 7. **Environment:** * `environment:`: Sets environment variables for the container. * `RUST_LOG: "info"`: Sets the `RUST_LOG` environment variable to `info`, which controls the logging level of the Qdrant MCP server. You can use other levels like `debug`, `warn`, or `error`. 8. **Restart:** * `restart: unless-stopped`: Configures the restart policy. The container will automatically restart unless it is explicitly stopped. 9. **Networks:** * `networks:`: Connects the container to a Docker network. * `qdrant-network`: Connects the container to the `qdrant-network`. This allows the Qdrant MCP server to communicate with other Qdrant clusters within the same network. 10. **Networks Definition:** * `networks:`: Defines the Docker network. * `qdrant-network:`: Defines the `qdrant-network`. * `driver: bridge`: Specifies the bridge network driver. **3. `config.yaml` (Qdrant MCP Configuration)** This is a crucial file that tells Qdrant MCP how to route requests to your Qdrant clusters. Here's an example: ```yaml listen_address: "0.0.0.0:6333" clusters: cluster1: address: "qdrant-cluster1:6333" # Replace with the actual address of your Qdrant cluster cluster2: address: "qdrant-cluster2:6333" # Replace with the actual address of your Qdrant cluster rules: - collection_name: "my_collection" cluster: "cluster1" - collection_name: "another_collection" cluster: "cluster2" - collection_name: "shared_collection" cluster: "cluster1" # Or cluster2, depending on your setup load_balancing: true # Enable load balancing between clusters if needed ``` **Explanation of the `config.yaml`:** * `listen_address`: The address the MCP server listens on. `0.0.0.0` means it listens on all interfaces. * `clusters`: Defines the Qdrant clusters that the MCP server will manage. * `cluster1`, `cluster2`: Names for your clusters. These names are used in the `rules` section. * `address`: The address of the Qdrant cluster. **Important:** If your Qdrant clusters are running in Docker, use the service names (e.g., `qdrant-cluster1`) as the hostnames, assuming they are on the same Docker network. Otherwise, use the actual IP addresses or hostnames. * `rules`: Defines the routing rules. * `collection_name`: The name of the Qdrant collection. * `cluster`: The name of the cluster to route requests to for the specified collection. * `load_balancing`: (Optional) If set to `true`, the MCP server will load balance requests for this collection across the specified clusters. This is useful if you have multiple clusters hosting the same data. **Important Considerations and Best Practices:** * **Networking:** Ensure that the Qdrant MCP container and the Qdrant cluster containers are on the same Docker network so they can communicate. * **Configuration:** The `config.yaml` file is critical. Make sure the cluster addresses and routing rules are correct. * **Security:** * **TLS/SSL:** Enable TLS/SSL for secure communication between the client and the Qdrant MCP server, and between the MCP server and the Qdrant clusters. You'll need to configure certificates and update the `config.yaml` file accordingly. * **Authentication:** Implement authentication to restrict access to the Qdrant MCP server. * **Logging:** Configure logging to monitor the Qdrant MCP server's activity and troubleshoot issues. The `RUST_LOG` environment variable controls the logging level. * **Monitoring:** Monitor the health and performance of the Qdrant MCP server and the Qdrant clusters. * **Image Tagging:** Use specific image tags (e.g., `qdrant-mcp:1.0.0`) instead of `latest` for production deployments to ensure consistent deployments. * **Environment Variables:** Use environment variables to configure sensitive information (e.g., passwords, API keys) instead of hardcoding them in the `config.yaml` file. * **Health Checks:** Add health checks to the `docker-compose.yml` file to ensure that the Qdrant MCP container is healthy. * **Resource Limits:** Set resource limits (e.g., CPU, memory) for the Qdrant MCP container to prevent it from consuming too many resources. * **Dockerignore:** Create a `.dockerignore` file to exclude unnecessary files and directories from the Docker image, reducing its size and build time. Example: ``` .git target **/__pycache__ ``` **How to Build and Run:** 1. **Create the `Dockerfile`, `docker-compose.yml`, and `config.yaml` files.** 2. **Build the image:** ```bash docker-compose build ``` 3. **Run the container:** ```bash docker-compose up -d ``` 4. **Check the logs:** ```bash docker-compose logs -f qdrant-mcp ``` **Example with TLS/SSL (Simplified)** This is a simplified example. In a real-world scenario, you'd use proper certificates. 1. **Generate Self-Signed Certificates (for testing only):** ```bash openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes ``` 2. **Update `config.yaml`:** ```yaml listen_address: "0.0.0.0:6333" tls: enabled: true cert_path: "/app/cert.pem" key_path: "/app/key.pem" clusters: cluster1: address: "qdrant-cluster1:6333" cluster2: address: "qdrant-cluster2:6333" rules: - collection_name: "my_collection" cluster: "cluster1" ``` 3. **Update `docker-compose.yml`:** ```yaml version: "3.9" services: qdrant-mcp: image: qdrant-mcp:latest build: context: . dockerfile: Dockerfile ports: - "6333:6333" volumes: - ./config.yaml:/app/config.yaml - ./cert.pem:/app/cert.pem - ./key.pem:/app/key.pem environment: RUST_LOG: "info" restart: unless-stopped networks: - qdrant-network networks: qdrant-network: driver: bridge ``` **Important Notes about TLS/SSL:** * **Self-Signed Certificates:** The example above uses self-signed certificates, which are **not secure** for production environments. Use certificates issued by a trusted Certificate Authority (CA). * **Certificate Paths:** Make sure the `cert_path` and `key_path` in the `config.yaml` file match the paths where you mount the certificate and key files in the `docker-compose.yml` file. * **Client Configuration:** When using TLS/SSL, your client applications will also need to be configured to trust the certificate used by the Qdrant MCP server. This comprehensive guide should help you set up a Docker configuration for your Qdrant MCP server. Remember to adapt the configuration to your specific needs and environment.

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 Test

Here are a few ways to translate "MCP server with GitHub integration" into Spanish, depending on the specific context and what you want to emphasize: **Option 1 (Most General):** * **Servidor MCP con integración de GitHub** * This is a direct translation and is perfectly understandable. It's suitable for most situations. **Option 2 (Emphasizing the connection/link):** * **Servidor MCP integrado con GitHub** * "Integrado" emphasizes that the GitHub functionality is built-in or closely connected. **Option 3 (More descriptive, if needed):** * **Servidor MCP con integración a través de GitHub** * This clarifies that the integration happens *through* GitHub. **Option 4 (If you want to be very specific about what kind of server it is):** * **Servidor MCP con integración de GitHub para [purpose/application]** * For example: "Servidor MCP con integración de GitHub para gestión de mods" (MCP server with GitHub integration for mod management). You would replace `[purpose/application]` with the specific use case. **Which one should you use?** * If you just need a general translation, **"Servidor MCP con integración de GitHub"** is the best choice. * If you want to highlight the built-in nature of the integration, use **"Servidor MCP integrado con GitHub"**. * If you need to be more specific about the integration's purpose, use **"Servidor MCP con integración de GitHub para [purpose/application]"**.

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.

CrewAI MCP Orchestrator

Transforms any compatible LLM or AI Assistant into a master orchestrator of CrewAI, providing tools to dynamically generate, edit, test, and execute multi-agent systems.

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.

tracepass-mcp-server

MCP server for TracePass — the EU Digital Product Passport platform. Create products, build and audit DPPs, set economic-operator parties, and read/capture GS1 EPCIS 2.0 supply-chain events.

Perplexity Sonar MCP Server

Servidor MCP para la integración de la API de Perplexity con Claude Desktop y otros clientes MCP.

pancake-pos-mcp

Enables AI assistants to manage Vietnamese e-commerce POS operations including orders, products, customers, inventory, supply chain, sales, CRM, and multi-channel integration via Pancake POS API.

Reddit Universal MCP Server

Provides a standardized interface for interacting with Reddit's tools and services through a unified API, enabling seamless integration with MCP-compliant applications.

barevalue-mcp

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

Focus Data SQL Server

¡Un plugin NL2SQL basado en el análisis de palabras clave de FocusSearch, que ofrece mayor precisión, mayor velocidad y más fiabilidad!

git-slim

A token-optimized Git MCP server that reduces context window tokens by 59% while preserving full functionality, enabling AI assistants to interact with Git repositories using only 5 grouped tool operations.

mcp-proxy

mcp proxy

google-maps-mcp-server

Production-ready MCP server for Google Maps Platform APIs, providing 11 tools for directions, places, geocoding, traffic, and road data to empower AI agents with location intelligence.

Grabba MCP Server

Microservice Connector Protocol server that exposes Grabba API functionalities as callable tools, allowing AI agents and applications to interact with Grabba's data extraction and management services.

Harvest Time Tracking MCP Server

Servidor MCP (Protocolo de Contexto del Modelo) para el seguimiento del tiempo de Harvest.

Dify External Knowledge MCP Server

Integrates Dify's external knowledge base API with the Model Context Protocol to enable AI agents to retrieve and query relevant information. It supports relevance scoring, metadata filtering, and flexible configuration through environment variables or command-line arguments.

weixin-articles-mcp

Read WeChat (微信) Official Account articles with native multimodal output — body, images, and video keyframes returned as MCP content blocks. Handles all three embed types: Tencent Video, WeChat-native, and Channels (视频号 metadata via public API).

Google Forms MCP Server

Enables creation and management of Google Forms with support for all 12 question types, response collection, CSV export, and form publishing through OAuth-authenticated API access.

bt-panel-mcp-server

This MCP server enables AI assistants to interact with a BT Panel server through natural language, allowing users to query logs, manage websites, and monitor system status without manual panel login.

Safe Unix MCP

Provides read-only access to Unix/Linux command-line tools for AI agents, blocking dangerous operations like file deletion, modification, and command execution while enabling safe file inspection, searching, and system information gathering.

Run Model Context Protocol (MCP) servers with AWS Lambda

Run existing Model Context Protocol (MCP) stdio-based servers in AWS Lambda functions

Lorem Ipsum By Api Ninjas

Generates Lorem Ipsum placeholder text with customizable parameters including paragraph count, length, and formatting options through the API Ninjas service.

MCP Context Server

A secure multi-tenant server that provides real-time context to LLMs via REST API, using JWT authentication and PostgreSQL row-level security for tenant isolation.

blitz-mcp

Blitz-mcp gives AI agents full control over iOS/macOS development — boot simulators, interacts with physical iPhones, browse databases, trigger builds, and submit apps to App Store Connect via 30+ MCP tools.

mysql-mcp-server

Provides read-only access to MySQL database schema and sample data, offering tools to list tables, get schema, and fetch sample rows for safe backend development.