Discover Awesome MCP Servers

appcrane-mcp

MCP connector for AppCrane that serves a bundled tool catalog for offline introspection and proxies tool calls to a self-hosted AppCrane instance for deploying and managing AI-built apps.

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.

Bambu Printer MCP

Manages, monitors, slices for, and controls multiple Bambu Lab 3D printers with a privacy-focused multi-printer registry and fleet status.

io.github.peterkolbe/ableton-for-ai

MCP server that bridges Ableton Live with AI models, enabling real-time project inspection and control such as track overview, device parameters, and audio analysis.

ACC.MCP

An MCP server that exposes Autodesk Platform Services (APS) as tools for AI assistants to interact with the APS Data Management API. It enables users to authenticate and manage hubs, projects, and folders through a standardized interface.

EDCB MCP Server

Enables LLMs to control EDCB, a broadcast recording software, allowing program information retrieval and reservation management.

runpay-marketplace

Stripe-native marketplace where AI agents autonomously discover and purchase API services via MCP. Pay-per-call, no accounts needed. 6 live services including Phone Validator, Web Scraper, PDF Generator and Screenshot API.

plsreadme

MCP server for sharing markdown/text as beautiful, permanent web pages via plsreadme, with tools to share files/text, update and delete docs, and list previously shared links.

DBeast

DBeast MCP is a robust, security-first Model Context Protocol server designed to empower AI coding assistants (like Claude Desktop) with deep PostgreSQL database insights. Instead of just running basic SQL queries, DBeast equips your AI agent with tools to inspect active locks, audit slow queries, analyze table schemas, and safely generate index recommendations in real-time. Built specifically for

UNWIND

A security layer for AI agents that monitors, checks, and records every action, providing a trust light, timeline, rewind, and ghost mode for testing without consequences.

cloudprice-mcp

MCP server that lets Claude (or any MCP-compatible client) compare on-demand compute + storage pricing across AWS, Azure, and GCP in real time.

vsphere-mcp

MCP server for VMware vSphere/vCenter operations, enabling natural language control of VMs, hosts, and infrastructure.

GSC MCP Server v2 - Remote Edition

Connects Claude AI to Google Search Console with OAuth 2.0 authentication, enabling users to analyze search performance, inspect URLs, manage sitemaps, and export analytics data through natural language conversations.

Instagram Control MCP Server

A professional, full-fidelity MCP server enabling AI agents to fully control and manage an Instagram account exactly like a human user.

Invoice-MCP

MCP server that gives AI agents read access to subscription/SaaS invoice history, ingested from Gmail and stored in Postgres and MongoDB, with tools for listing invoices, retrieving PDFs, and summarizing spend.

Rodev MCP Server

Connects AI agents to Rodev DeFi vaults, enabling deposits, withdrawals, and status queries via 9 MCP tools.

Financial Data MCP Server

Provides real-time and historical financial market data from Yahoo Finance, including stock prices, options chains, and company news. It also enables technical analysis calculations like moving averages and RSI for comparing or analyzing stock performance.

Cymbal Catering MCP Server

Enables secure, natural language access to private Cloud SQL PostgreSQL data for catering CRM management, exposing database CRUD operations as MCP tools via Cloud Run.

MealPlanner MCP Multi-Agent

A multimodal meal planning agent that uses Gemini Vision to analyze fridge photos, suggest recipes, provide nutritional info, and generate daily meal plans.

AI Image Editor MCP Server

Enables access to AI Image Editor's image generation styles, pricing, FAQ, and official links via natural language.

Lemon-io

Generate tailored job descriptions, hire senior developers and pull technical interview questions without leaving the conversation.

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

multimodal-reader-mcp

MCP server for analyzing local audio and video files with Google Gen AI, returning structured summaries, timelines, transcripts, and observations.

agid-llm-ui MCP Server

MCP server to help AI assistants generate Italian PA user interfaces by providing components, recipes, accessibility rules, and validation for Bootstrap Italia and Web Components.

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.

🗄️ Couchbase MCP Server for LLMs

Espejo de

ShortcutsBridge

MCP server that lets ChatGPT list, search, and run your Apple Shortcuts on your own Mac through a local agent and stateless relay.