Discover Awesome MCP Servers

Agile Luminary MCP Server

A Model Context Protocol server that connects AI clients to the Agile Luminary project management system, allowing users to retrieve project details, work assignments, and product information within AI conversations.

mcp_repo9756c6c7-ee07-4f3a-ada4-f6e2705daa02

Este es un repositorio de prueba creado por un script de prueba del Servidor MCP para GitHub.

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.

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.

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.

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

Spring AI MCP Server

Here are a few options for translating "스프링부트와 AI를 활용한 엑셀, PPT 생성 서버" depending on the nuance you want to convey: **Option 1 (Most Direct):** * **Servidor de generación de Excel y PPT utilizando Spring Boot e IA.** (This is a very literal and straightforward translation.) **Option 2 (Slightly More Natural):** * **Servidor para la generación de Excel y PPT con Spring Boot e IA.** (This emphasizes the server's *purpose*.) **Option 3 (Emphasizing "Leveraging"):** * **Servidor de generación de Excel y PPT que aprovecha Spring Boot e IA.** (This highlights the *use* of Spring Boot and AI.) **Option 4 (More Descriptive):** * **Servidor basado en Spring Boot para la generación de archivos Excel y PPT, impulsado por IA.** (This is a more descriptive translation, emphasizing that the server is *based on* Spring Boot and *powered by* AI.) **Which one is best depends on the context.** If you want a simple, direct translation, Option 1 is fine. If you want to emphasize the server's purpose, Option 2 is better. If you want to highlight the use of Spring Boot and AI, Option 3 is a good choice. Option 4 is suitable if you want a more descriptive and detailed translation.

MCP FishAudio Server

An MCP (Model Context Protocol) server that provides seamless integration between Fish Audio's Text-to-Speech API and LLMs like Claude, enabling natural language-driven speech synthesis.

MCP File Server

Here are a few ways to translate "MCP server for reading and writing local files" into Spanish, depending on the specific context and desired nuance: **Option 1 (Most straightforward):** * **Servidor MCP para leer y escribir archivos locales.** * This is a direct translation and is perfectly understandable. **Option 2 (Emphasizing functionality):** * **Servidor MCP para la lectura y escritura de archivos locales.** * Using "la lectura y escritura" (the reading and writing) is slightly more formal and emphasizes the *actions* of reading and writing. **Option 3 (If "MCP" is an acronym that's not commonly used in Spanish):** * **Servidor MCP para acceder y modificar archivos locales.** * If "MCP" is not well-known in the Spanish-speaking context, you might consider using a more general term like "acceder y modificar" (access and modify) to ensure clarity. This assumes that reading and writing are the primary ways of accessing and modifying the files. **Option 4 (More descriptive, if needed):** * **Servidor MCP diseñado para leer y escribir archivos en el sistema local.** * This translates to "MCP server designed to read and write files on the local system." It adds a bit more context. **Which option is best depends on the audience and the specific meaning you want to convey.** If "MCP" is a well-understood term, Option 1 is likely the best. If not, consider Options 3 or 4. Option 2 is a good alternative if you want to emphasize the actions of reading and writing.

M/M/1 Queue Simulation MCP Server

Enables LLMs to access M/M/1 queuing theory resources, validate parameters, calculate theoretical metrics, generate and execute SimPy simulations, and compare simulation results with theoretical predictions.

Multi-Cloud Infrastructure MCP Server

Enables deployment and management of GPU workloads across multiple cloud providers (RunPod, Vast.ai) with intelligent GPU selection, resource monitoring, and telemetry tracking through Redis, ClickHouse, and SkyPilot integration.

MCP Gemini Server

Un servidor dedicado que envuelve los modelos de IA Gemini de Google en una interfaz de Protocolo de Contexto de Modelo (MCP), permitiendo que otros LLMs y sistemas compatibles con MCP accedan a las capacidades de Gemini, como la generación de contenido, la llamada a funciones, el chat y el manejo de archivos, a través de herramientas estandarizadas.

Harvest Time Tracking MCP Server

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

OpenSearch MCP Server

Proporciona una capa de memoria semántica que integra LLMs con OpenSearch, permitiendo el almacenamiento y la recuperación de recuerdos dentro del motor OpenSearch.

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.

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.

FI-MCP

Provides AI assistants with access to 30+ validated financial independence calculation functions, eliminating hallucinations by ensuring accurate calculations for retirement planning, CoastFI, investment returns, and other FI metrics.

mcp-searxng

Here are a few options, depending on the nuance you want to convey: **Option 1 (Most straightforward):** > Acerca de un servidor MCP que permite a un Agente de IA buscar contenido e información de sitios web externos a través del servicio SearXNG. **Option 2 (More descriptive, emphasizing the purpose):** > Se trata de un servidor MCP diseñado para que un Agente de IA pueda buscar contenido e información en sitios web externos utilizando el servicio SearXNG. **Option 3 (Slightly more formal):** > Un servidor MCP para permitir que un Agente de IA realice búsquedas de contenido e información en sitios web externos a través del servicio SearXNG. **Explanation of choices:** * **Acerca de / Se trata de / Un servidor... para permitir...:** These are all ways to introduce the topic. "Acerca de" is a general "about." "Se trata de" is "it's about" or "it concerns." The third option is more direct. * **Agente de IA:** This is the standard translation for "AI Agent." * **buscar contenido e información:** This translates "search external website content and information." * **sitios web externos:** This translates "external websites." * **a través del servicio SearXNG:** This translates "through the SearXNG service." Choose the option that best fits the context and your desired level of formality. I would personally lean towards Option 1 or 2.

Bash MCP

Una aplicación en TypeScript que le permite a Claude ejecutar comandos de bash de forma segura con medidas de seguridad, proporcionando una interfaz segura a través del Protocolo de Contexto del Modelo.

LumiFAI MCP Technical Analysis Server

Proporciona herramientas de análisis técnico para datos de trading de criptomonedas, calculando EMAs (períodos de 12 y 26) para pares de Binance utilizando MongoDB para el almacenamiento de datos.

Gaggiuino MCP Server

A lightweight server that enables AI clients to access and analyze real-time data from Gaggiuino espresso machine controllers through a simple HTTP API.

MCP Server

Un servidor de ejecución de comandos shell multiplataforma que soporta entornos Windows, macOS y Linux con shells PowerShell, CMD, GitBash y Bash, optimizado para entornos de idioma japonés.

Employee Management MCP Server

Enables interaction with employee management systems through a standardized MCP interface. Supports comprehensive employee operations including CRUD operations, search, filtering by level/status, and data synchronization.