Discover Awesome MCP Servers

Memory Server with Qdrant Persistence

Facilita la representación de grafos de conocimiento con búsqueda semántica utilizando Qdrant, soportando embeddings de OpenAI para la similitud semántica y una robusta integración HTTPS con persistencia de grafos basada en archivos.

Serveur MCP Airbnb

Espejo de

Run Model Context Protocol (MCP) servers with AWS Lambda

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

authorize-net-mcp

Servidor MCP experimental de Authorize.net en Node.js TypeScript

Gerrit Review MCP Server

Provides integration with Gerrit code review system, allowing AI assistants to fetch change details and compare patchset differences for code reviews.

RhinoMCP

Conecta Rhino3D a Claude AI a través del Protocolo de Contexto de Modelo, permitiendo flujos de trabajo de modelado y diseño 3D asistidos por IA mediante el control directo de la funcionalidad de Rhino.

MindLayer TradingView MCP Agent

Connects TradingView's Pine Script indicators with MindLayer's MCP for cryptocurrency trading signals based on RSI and Stochastic RSI analysis.

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.

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.

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.

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

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.

Harvest Time Tracking MCP Server

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

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.

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.

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.

Speelka Agent

Agente LLM Universal basado en MCP

🗄️ Couchbase MCP Server for LLMs

Espejo de

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.

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.

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.

Outsource MCP

An MCP server that enables AI applications to access 20+ model providers (including OpenAI, Anthropic, Google) through a unified interface for text and image generation.

Understanding MCP Architecture: Single-Server vs Multi-Server Clients

Demostración de la arquitectura MCP con clientes de un solo servidor y de múltiples servidores utilizando LangGraph, llamadas de herramientas impulsadas por IA y comunicación asíncrona.

MCP LEDAPI Intent Controller

A Model Context Protocol server that translates high-level intents into commands for controlling an Arduino-based LED system via a RESTful interface.