Discover Awesome MCP Servers

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.

hugeicons-mcp

Servidor MCP para la integración y documentación de Hugeicons Este es un servidor MCP basado en TypeScript que proporciona herramientas y recursos para integrar Hugeicons en varias plataformas. Implementa un servidor del Protocolo de Contexto de Modelo (MCP) que ayuda a los asistentes de IA a proporcionar una guía precisa para usar Hugeicons.

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.

DeFi Rates MCP Server

Provides AI assistants with access to real-time DeFi lending rates and yield data across 14+ protocols and multiple blockchains. Enables querying borrow/supply rates, comparing platforms, calculating leverage strategies, and finding best earn opportunities.

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.

Harvest Time Tracking MCP Server

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

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!

mcp-proxy

mcp proxy

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.

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.

mcp-scraper-engine

Here are a few options for translating "Basic MCP Server for Web Scraping," depending on the nuance you want to convey: **Option 1 (Most straightforward):** * **Servidor MCP básico para web scraping** This is a direct translation and is perfectly understandable. **Option 2 (Emphasizing "simple"):** * **Servidor MCP sencillo para web scraping** "Sencillo" translates to "simple" or "easy," highlighting the ease of use. **Option 3 (More technical, using "mínimo"):** * **Servidor MCP mínimo para web scraping** "Mínimo" translates to "minimal," suggesting the server has the bare minimum features needed. **Option 4 (If you mean "example" or "template"):** * **Servidor MCP de ejemplo para web scraping** * **Plantilla de servidor MCP para web scraping** These options are appropriate if you're providing a basic example or template. "Ejemplo" means "example" and "Plantilla" means "template." **Which one should you use?** * If you just want a basic, understandable translation, use **"Servidor MCP básico para web scraping."** * If you want to emphasize the simplicity, use **"Servidor MCP sencillo para web scraping."** * If you want to emphasize the minimal features, use **"Servidor MCP mínimo para web scraping."** * If it's an example or template, use **"Servidor MCP de ejemplo para web scraping"** or **"Plantilla de servidor MCP para web scraping."** Therefore, the best option depends on the specific context. Without more information, I recommend **"Servidor MCP básico para web scraping"** as the most generally applicable translation.

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.

Self-Hosted EdgeOne Pages MCP Server

Enables AI assistants to deploy and manage static websites directly on EdgeOne Pages. Simple self-hosted solution with one-click deployment and KV storage for website files.

FastMail MCP Server

Enables AI-powered email management through FastMail's JMAP API with features like smart email analysis, automated organization, inbox zero automation, and intelligent reply generation. Supports advanced email operations, contact management, calendar integration, and hierarchical email organization systems.

mac-use-mcp

Zero-dependency macOS desktop automation for AI agents. Screenshot, mouse, keyboard, clipboard, and window control via MCP. 18 tools, macOS 13+, one command: npx mac-use-mcp.

Gemini MCP Server

Una implementación de servidor MCP que permite usar los modelos de IA Gemini de Google (específicamente Gemini 1.5 Pro) a través de Claude u otros clientes MCP mediante el Protocolo de Contexto de Modelos.

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.

Gitea MCP Proxy Agent

A comprehensive MCP server suite that enables AI interaction with Gitea for repository management, secure command execution, and Docker monitoring. It provides additional tools for long-term memory, filesystem access, and web searching to support full development cycles.

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.

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]"**.

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).

Register UZ MCP Server

Enables access to Slovak Registry of Financial Statements data, allowing users to search companies, retrieve financial reports, balance sheets, income statements, and analyze Slovak business financial data through natural language queries.

PAL - Project API Locker

Enables secure API key management for development projects by storing keys in OS keychains, auto-generating .env files and SDK client code, and providing AI-assisted key management through Claude Code integration.

mcp-google-gdrive

An MCP server that enables AI assistants to list, read, create, and manage files in Google Drive. It features automatic conversion of Google Workspace formats into Markdown, CSV, and plain text for seamless integration with AI workflows.

Storyden

A modern community hub with forum and knowledge base. Native MCP built-in, ready for the next era of internet culture.

RagMCP

A local command-based assistant that enables users to control system tools, play YouTube music, and search various websites using Playwright automation. It supports tasks ranging from media playback and browser navigation to file system operations and system power management.

Slack MCP Server

Enables comprehensive Slack workspace integration through AI assistants, allowing users to manage channels, send messages, upload files, search conversations, and interact with users through natural language commands.

OpenAI Image Generation MCP Server

Provides tools for generating and editing images using OpenAI's gpt-image-1 model via an MCP interface, enabling AI assistants to create and modify images based on text prompts.