Discover Awesome MCP Servers

Speelka Agent

Agente LLM Universal baseado em MCP

mcp-test

just a test

mcp-spacefrontiers

Pesquisar em dados acadêmicos e redes sociais.

🗄️ Couchbase MCP Server for LLMs

Espelho de

PyMCPAutoGUI

Um servidor MCP que conecta agentes de IA com capacidades de automação de GUI, permitindo que eles controlem o mouse, teclado, janelas e capturem screenshots para interagir com aplicativos de desktop.

mcp_repo9756c6c7-ee07-4f3a-ada4-f6e2705daa02

Este é um repositório de teste criado pelo script de teste do Servidor MCP para o GitHub.

hugeicons-mcp

Servidor MCP para integração e documentação do Hugeicons Este é um servidor MCP baseado em TypeScript que fornece ferramentas e recursos para integrar o Hugeicons em várias plataformas. Ele implementa um servidor Model Context Protocol (MCP) que ajuda assistentes de IA a fornecer orientação precisa para usar o Hugeicons.

Mcp Qdrant Docker

Okay, here's a Docker configuration example for a Qdrant MCP (Multi-Cluster Proxy) server, along with explanations and considerations. I'll provide a `docker-compose.yml` file, a Dockerfile (if needed), and some important notes. **Understanding the Qdrant MCP** The Qdrant MCP acts as a gateway to multiple Qdrant clusters. It handles routing requests to the appropriate cluster based on configuration. It's essential for managing and scaling Qdrant deployments across multiple environments or regions. **`docker-compose.yml` (Recommended)** This is the preferred way to configure and run Qdrant MCP with Docker. It allows you to define the service, its dependencies, and configuration in a single file. ```yaml version: "3.9" # Or a later version if you prefer services: qdrant-mcp: image: qdrant/qdrant-mcp:latest # Use the latest stable tag or a specific version container_name: qdrant-mcp ports: - "6333:6333" # MCP API port (default) - "6334:6334" # MCP GRPC port (default) environment: - QDRANT_MCP__CLUSTERS__CLUSTER1__ADDRESS=qdrant-cluster1:6333 # Replace with your Qdrant cluster address - QDRANT_MCP__CLUSTERS__CLUSTER1__GRPC_PORT=6334 - QDRANT_MCP__CLUSTERS__CLUSTER2__ADDRESS=qdrant-cluster2:6333 # Replace with your Qdrant cluster address - QDRANT_MCP__CLUSTERS__CLUSTER2__GRPC_PORT=6334 # Add more clusters as needed (CLUSTER3, CLUSTER4, etc.) - QDRANT_MCP__ADMIN_API_KEY=your_admin_api_key # Replace with a strong API key for admin operations - QDRANT_MCP__METRICS__ENABLED=true # Enable metrics endpoint - QDRANT_MCP__METRICS__PORT=9090 # Metrics port restart: unless-stopped networks: - qdrant-network # Define a network for communication networks: qdrant-network: driver: bridge ``` **Explanation:** * **`version`:** Specifies the Docker Compose file version. * **`services`:** Defines the services to run. * **`qdrant-mcp`:** The name of the Qdrant MCP service. * **`image`:** The Docker image to use. `qdrant/qdrant-mcp:latest` pulls the latest stable version. **Important:** Pin to a specific version tag (e.g., `qdrant/qdrant-mcp:v1.2.3`) for production to avoid unexpected updates. * **`container_name`:** A name for the container. * **`ports`:** Maps ports from the container to the host. `6333` is the default HTTP API port, and `6334` is the default gRPC port. You can change these if needed, but ensure they don't conflict with other services. * **`environment`:** Sets environment variables to configure the Qdrant MCP. This is the *most important* part. * **`QDRANT_MCP__CLUSTERS__CLUSTER1__ADDRESS`**: The address (hostname or IP) of your first Qdrant cluster's HTTP API endpoint. Replace `qdrant-cluster1` with the actual hostname or IP address. If the Qdrant cluster is running in Docker, use the service name from your `docker-compose.yml` for that cluster. * **`QDRANT_MCP__CLUSTERS__CLUSTER1__GRPC_PORT`**: The gRPC port of your first Qdrant cluster. * **`QDRANT_MCP__CLUSTERS__CLUSTER2__ADDRESS`**: The address of your second Qdrant cluster. * **`QDRANT_MCP__CLUSTERS__CLUSTER2__GRPC_PORT`**: The gRPC port of your second Qdrant cluster. * **`QDRANT_MCP__ADMIN_API_KEY`**: A strong API key for administrative operations on the MCP. **Crucially important for security!** Generate a strong, random key. * **`QDRANT_MCP__METRICS__ENABLED`**: Enables the metrics endpoint for monitoring. * **`QDRANT_MCP__METRICS__PORT`**: The port for the metrics endpoint (Prometheus format). * **`restart: unless-stopped`:** Automatically restarts the container unless it's explicitly stopped. Good for ensuring the MCP is always running. * **`networks`**: Connects the MCP container to a Docker network. This is essential for allowing the MCP to communicate with the Qdrant clusters if they are also running in Docker. * **`networks`:** Defines the Docker network. A `bridge` network is a common choice for connecting containers on the same host. **How to Use:** 1. **Save:** Save the above content as `docker-compose.yml`. 2. **Replace Placeholders:** **Crucially**, replace the placeholder values for `QDRANT_MCP__CLUSTERS__CLUSTER1__ADDRESS`, `QDRANT_MCP__CLUSTERS__CLUSTER2__ADDRESS`, and `QDRANT_MCP__ADMIN_API_KEY` with your actual values. 3. **Run:** Open a terminal in the directory where you saved the `docker-compose.yml` file and run: ```bash docker-compose up -d ``` This will download the Qdrant MCP image (if it's not already present), create the container, and start it in detached mode (running in the background). 4. **Verify:** Check the logs to ensure the MCP started successfully: ```bash docker-compose logs qdrant-mcp ``` Look for messages indicating that the MCP has connected to your Qdrant clusters. **Important Considerations and Customization:** * **Qdrant Cluster Addresses:** The `QDRANT_MCP__CLUSTERS__*__ADDRESS` values are *critical*. They must be resolvable from within the Docker container. If your Qdrant clusters are running on the same host but not in Docker, you can use `host.docker.internal` (on Docker Desktop) to refer to the host machine's IP address. If they are running in Docker, use the service names from their respective `docker-compose.yml` files. * **API Key Security:** The `QDRANT_MCP__ADMIN_API_KEY` is essential for security. **Never** use a weak or default API key in production. Generate a strong, random key and store it securely. * **Networking:** The `qdrant-network` is important for Docker-to-Docker communication. Make sure your Qdrant clusters are also connected to the same network. * **Version Pinning:** Always pin the Qdrant MCP image to a specific version tag (e.g., `qdrant/qdrant-mcp:v1.2.3`) in production to avoid unexpected breaking changes when the `latest` tag is updated. * **Configuration:** The Qdrant MCP has many other configuration options. Refer to the official Qdrant MCP documentation for a complete list of environment variables and their meanings: [https://qdrant.tech/documentation/mcp/](https://qdrant.tech/documentation/mcp/) * **Health Checks:** Consider adding a health check to your `docker-compose.yml` to automatically restart the container if it becomes unhealthy. This can improve the reliability of your deployment. * **Volumes:** If you need to persist the MCP configuration, you can mount a volume to the container. However, the primary configuration is typically done through environment variables. * **Monitoring:** Set up monitoring for the Qdrant MCP using the metrics endpoint (`/metrics`). Prometheus is a common choice for collecting and visualizing metrics. * **Routing:** The MCP uses a routing strategy to determine which cluster to send requests to. The default strategy is based on collection names. You can configure different routing strategies using environment variables. **Example with Dockerfile (Less Common, but Possible)** You generally don't need a Dockerfile for the Qdrant MCP unless you need to customize the image itself (e.g., install additional tools). However, here's an example: ```dockerfile FROM qdrant/qdrant-mcp:latest # Add any custom commands here, if needed # For example, installing extra utilities: # RUN apt-get update && apt-get install -y --no-install-recommends some-utility # The entrypoint is already defined in the base image, so you usually don't need to override it. ``` Then, in your `docker-compose.yml`, you would build the image from the Dockerfile: ```yaml version: "3.9" services: qdrant-mcp: build: . # Build from the Dockerfile in the current directory container_name: qdrant-mcp ports: - "6333:6333" - "6334:6334" environment: # ... (same environment variables as before) ... restart: unless-stopped networks: - qdrant-network networks: qdrant-network: driver: bridge ``` **Important Notes for Production:** * **Security:** The `ADMIN_API_KEY` is paramount. Use a strong, randomly generated key. Consider using Docker secrets to manage sensitive information. * **Resource Limits:** Set appropriate resource limits (CPU, memory) for the Qdrant MCP container to prevent it from consuming excessive resources. * **Monitoring and Alerting:** Implement comprehensive monitoring and alerting to detect and respond to issues with the Qdrant MCP. * **Backup and Recovery:** Develop a backup and recovery plan for your Qdrant clusters and the MCP configuration. * **Rolling Updates:** Use rolling updates to deploy new versions of the Qdrant MCP without downtime. Docker Compose supports rolling updates with the `docker-compose up -d` command. * **TLS/SSL:** Enable TLS/SSL encryption for communication between the Qdrant MCP and your Qdrant clusters, especially if they are running in different environments. You'll need to configure the MCP to use TLS certificates. **Troubleshooting:** * **Connectivity Issues:** If the MCP cannot connect to your Qdrant clusters, check the following: * Network configuration: Are the containers on the same network? Can they resolve each other's hostnames? * Firewall rules: Are there any firewall rules blocking communication between the MCP and the clusters? * Qdrant cluster configuration: Is the Qdrant cluster listening on the correct address and port? * **API Key Issues:** If you are getting authentication errors, double-check that the `ADMIN_API_KEY` is correct and that you are using it in your requests. * **Logs:** Examine the logs of the Qdrant MCP container for error messages. **Translation to Portuguese:** **Configuração do Docker para o servidor Qdrant MCP** Aqui está um exemplo de configuração do Docker para um servidor Qdrant MCP (Multi-Cluster Proxy), juntamente com explicações e considerações. Fornecerei um arquivo `docker-compose.yml`, um Dockerfile (se necessário) e algumas notas importantes. **Entendendo o Qdrant MCP** O Qdrant MCP atua como um gateway para vários clusters Qdrant. Ele lida com o roteamento de solicitações para o cluster apropriado com base na configuração. É essencial para gerenciar e escalar implantações do Qdrant em vários ambientes ou regiões. **`docker-compose.yml` (Recomendado)** Esta é a maneira preferida de configurar e executar o Qdrant MCP com o Docker. Ele permite que você defina o serviço, suas dependências e configuração em um único arquivo. ```yaml version: "3.9" # Ou uma versão posterior, se preferir services: qdrant-mcp: image: qdrant/qdrant-mcp:latest # Use a tag estável mais recente ou uma versão específica container_name: qdrant-mcp ports: - "6333:6333" # Porta da API MCP (padrão) - "6334:6334" # Porta GRPC MCP (padrão) environment: - QDRANT_MCP__CLUSTERS__CLUSTER1__ADDRESS=qdrant-cluster1:6333 # Substitua pelo endereço do seu cluster Qdrant - QDRANT_MCP__CLUSTERS__CLUSTER1__GRPC_PORT=6334 - QDRANT_MCP__CLUSTERS__CLUSTER2__ADDRESS=qdrant-cluster2:6333 # Substitua pelo endereço do seu cluster Qdrant - QDRANT_MCP__CLUSTERS__CLUSTER2__GRPC_PORT=6334 # Adicione mais clusters conforme necessário (CLUSTER3, CLUSTER4, etc.) - QDRANT_MCP__ADMIN_API_KEY=sua_chave_api_admin # Substitua por uma chave de API forte para operações de administração - QDRANT_MCP__METRICS__ENABLED=true # Ativar endpoint de métricas - QDRANT_MCP__METRICS__PORT=9090 # Porta de métricas restart: unless-stopped networks: - qdrant-network # Defina uma rede para comunicação networks: qdrant-network: driver: bridge ``` **Explicação:** * **`version`:** Especifica a versão do arquivo Docker Compose. * **`services`:** Define os serviços a serem executados. * **`qdrant-mcp`:** O nome do serviço Qdrant MCP. * **`image`:** A imagem Docker a ser usada. `qdrant/qdrant-mcp:latest` puxa a versão estável mais recente. **Importante:** Fixe em uma tag de versão específica (por exemplo, `qdrant/qdrant-mcp:v1.2.3`) para produção para evitar atualizações inesperadas. * **`container_name`:** Um nome para o contêiner. * **`ports`:** Mapeia as portas do contêiner para o host. `6333` é a porta da API HTTP padrão e `6334` é a porta gRPC padrão. Você pode alterá-las se necessário, mas certifique-se de que não entrem em conflito com outros serviços. * **`environment`:** Define variáveis de ambiente para configurar o Qdrant MCP. Esta é a parte *mais importante*. * **`QDRANT_MCP__CLUSTERS__CLUSTER1__ADDRESS`**: O endereço (nome do host ou IP) do endpoint da API HTTP do seu primeiro cluster Qdrant. Substitua `qdrant-cluster1` pelo nome do host ou endereço IP real. Se o cluster Qdrant estiver sendo executado no Docker, use o nome do serviço do seu arquivo `docker-compose.yml` para esse cluster. * **`QDRANT_MCP__CLUSTERS__CLUSTER1__GRPC_PORT`**: A porta gRPC do seu primeiro cluster Qdrant. * **`QDRANT_MCP__CLUSTERS__CLUSTER2__ADDRESS`**: O endereço do seu segundo cluster Qdrant. * **`QDRANT_MCP__CLUSTERS__CLUSTER2__GRPC_PORT`**: A porta gRPC do seu segundo cluster Qdrant. * **`QDRANT_MCP__ADMIN_API_KEY`**: Uma chave de API forte para operações administrativas no MCP. **Crucialmente importante para a segurança!** Gere uma chave forte e aleatória. * **`QDRANT_MCP__METRICS__ENABLED`**: Ativa o endpoint de métricas para monitoramento. * **`QDRANT_MCP__METRICS__PORT`**: A porta para o endpoint de métricas (formato Prometheus). * **`restart: unless-stopped`:** Reinicia automaticamente o contêiner, a menos que seja explicitamente interrompido. Bom para garantir que o MCP esteja sempre em execução. * **`networks`**: Conecta o contêiner MCP a uma rede Docker. Isso é essencial para permitir que o MCP se comunique com os clusters Qdrant se eles também estiverem sendo executados no Docker. * **`networks`:** Define a rede Docker. Uma rede `bridge` é uma escolha comum para conectar contêineres no mesmo host. **Como usar:** 1. **Salvar:** Salve o conteúdo acima como `docker-compose.yml`. 2. **Substituir Placeholders:** **Crucialmente**, substitua os valores de espaço reservado para `QDRANT_MCP__CLUSTERS__CLUSTER1__ADDRESS`, `QDRANT_MCP__CLUSTERS__CLUSTER2__ADDRESS` e `QDRANT_MCP__ADMIN_API_KEY` pelos seus valores reais. 3. **Executar:** Abra um terminal no diretório onde você salvou o arquivo `docker-compose.yml` e execute: ```bash docker-compose up -d ``` Isso fará o download da imagem Qdrant MCP (se ainda não estiver presente), criará o contêiner e o iniciará no modo detached (executando em segundo plano). 4. **Verificar:** Verifique os logs para garantir que o MCP foi iniciado com sucesso: ```bash docker-compose logs qdrant-mcp ``` Procure mensagens indicando que o MCP se conectou aos seus clusters Qdrant. **Considerações Importantes e Customização:** * **Endereços dos Clusters Qdrant:** Os valores `QDRANT_MCP__CLUSTERS__*__ADDRESS` são *críticos*. Eles devem ser resolvidos de dentro do contêiner Docker. Se seus clusters Qdrant estiverem sendo executados no mesmo host, mas não no Docker, você pode usar `host.docker.internal` (no Docker Desktop) para se referir ao endereço IP da máquina host. Se eles estiverem sendo executados no Docker, use os nomes de serviço de seus respectivos arquivos `docker-compose.yml`. * **Segurança da Chave API:** O `QDRANT_MCP__ADMIN_API_KEY` é essencial para a segurança. **Nunca** use uma chave de API fraca ou padrão em produção. Gere uma chave forte e aleatória e armazene-a com segurança. * **Rede:** O `qdrant-network` é importante para a comunicação Docker-to-Docker. Certifique-se de que seus clusters Qdrant também estejam conectados à mesma rede. * **Fixação de Versão:** Sempre fixe a imagem Qdrant MCP em uma tag de versão específica (por exemplo, `qdrant/qdrant-mcp:v1.2.3`) em produção para evitar alterações inesperadas quando a tag `latest` for atualizada. * **Configuração:** O Qdrant MCP tem muitas outras opções de configuração. Consulte a documentação oficial do Qdrant MCP para obter uma lista completa de variáveis de ambiente e seus significados: [https://qdrant.tech/documentation/mcp/](https://qdrant.tech/documentation/mcp/) * **Verificações de Saúde:** Considere adicionar uma verificação de saúde ao seu `docker-compose.yml` para reiniciar automaticamente o contêiner se ele ficar não saudável. Isso pode melhorar a confiabilidade da sua implantação. * **Volumes:** Se você precisar persistir a configuração do MCP, você pode montar um volume no contêiner. No entanto, a configuração primária é normalmente feita por meio de variáveis de ambiente. * **Monitoramento:** Configure o monitoramento para o Qdrant MCP usando o endpoint de métricas (`/metrics`). Prometheus é uma escolha comum para coletar e visualizar métricas. * **Roteamento:** O MCP usa uma estratégia de roteamento para determinar para qual cluster enviar as solicitações. A estratégia padrão é baseada em nomes de coleção. Você pode configurar diferentes estratégias de roteamento usando variáveis de ambiente. **Exemplo com Dockerfile (Menos Comum, mas Possível)** Geralmente, você não precisa de um Dockerfile para o Qdrant MCP, a menos que precise personalizar a própria imagem (por exemplo, instalar ferramentas adicionais). No entanto, aqui está um exemplo: ```dockerfile FROM qdrant/qdrant-mcp:latest # Adicione quaisquer comandos personalizados aqui, se necessário # Por exemplo, instalar utilitários extras: # RUN apt-get update && apt-get install -y --no-install-recommends some-utility # O entrypoint já está definido na imagem base, então você geralmente não precisa substituí-lo. ``` Então, no seu `docker-compose.yml`, você construiria a imagem a partir do Dockerfile: ```yaml version: "3.9" services: qdrant-mcp: build: . # Construir a partir do Dockerfile no diretório atual container_name: qdrant-mcp ports: - "6333:6333" - "6334:6334" environment: # ... (mesmas variáveis de ambiente de antes) ... restart: unless-stopped networks: - qdrant-network networks: qdrant-network: driver: bridge ``` **Notas Importantes para Produção:** * **Segurança:** O `ADMIN_API_KEY` é fundamental. Use uma chave forte, gerada aleatoriamente. Considere usar segredos do Docker para gerenciar informações confidenciais. * **Limites de Recursos:** Defina limites de recursos apropriados (CPU, memória) para o contêiner Qdrant MCP para evitar que ele consuma recursos excessivos. * **Monitoramento e Alerta:** Implemente monitoramento e alerta abrangentes para detectar e responder a problemas com o Qdrant MCP. * **Backup e Recuperação:** Desenvolva um plano de backup e recuperação para seus clusters Qdrant e a configuração do MCP. * **Atualizações Contínuas:** Use atualizações contínuas para implantar novas versões do Qdrant MCP sem tempo de inatividade. O Docker Compose suporta atualizações contínuas com o comando `docker-compose up -d`. * **TLS/SSL:** Ative a criptografia TLS/SSL para comunicação entre o Qdrant MCP e seus clusters Qdrant, especialmente se eles estiverem sendo executados em ambientes diferentes. Você precisará configurar o MCP para usar certificados TLS. **Solução de Problemas:** * **Problemas de Conectividade:** Se o MCP não conseguir se conectar aos seus clusters Qdrant, verifique o seguinte: * Configuração de rede: Os contêineres estão na mesma rede? Eles conseguem resolver os nomes de host uns dos outros? * Regras de firewall: Existem regras de firewall bloqueando a comunicação entre o MCP e os clusters? * Configuração do cluster Qdrant: O cluster Qdrant está escutando no endereço e porta corretos? * **Problemas de Chave API:** Se você estiver recebendo erros de autenticação, verifique se o `ADMIN_API_KEY` está correto e se você o está usando em suas solicitações. * **Logs:** Examine os logs do contêiner Qdrant MCP para mensagens de erro. This provides a comprehensive guide and a translated version. Remember to adapt the configuration to your specific environment and security requirements. Good luck!

MCP Test

Servidor MCP com integração GitHub

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.

MCP Gemini Server

Um servidor dedicado que envolve os modelos de IA Gemini do Google em uma interface de Protocolo de Contexto de Modelo (MCP), permitindo que outros LLMs e sistemas compatíveis com MCP acessem as capacidades do Gemini, como geração de conteúdo, chamada de função, chat e manipulação de arquivos, por meio de ferramentas padronizadas.

Perplexity Sonar MCP Server

Servidor MCP para integração da API Perplexity com Claude Desktop e outros clientes MCP.

UniProt MCP Server

Um servidor MCP que permite que modelos de linguagem busquem informações de proteínas do banco de dados UniProt, incluindo detalhes da proteína, sequências, funções e estruturas.

ethereum-tools

Um conjunto de ferramentas abrangente para análise da blockchain Ethereum dentro do Claude AI, permitindo auditoria de contratos, análise de carteiras, rastreamento de lucratividade e recuperação de dados on-chain.

MCP Security Analyst

Um servidor MCP (Model Context Protocol) para permitir revisões de segurança de código usando.

Context Manager MCP Server

Uma implementação de servidor do Protocolo de Contexto de Modelo (MCP) para gerenciar o fluxo de trabalho de desenvolvimento com recursos como gerenciamento de projetos, rastreamento de tarefas e suporte à revisão de QA.

Hi-AI

A simple AI development tool that helps users interact with AI through natural language commands, offering 29 tools across thinking, memory, browser, code quality, planning, and time management capabilities.

WebSearch

Construído como um servidor de Protocolo de Contexto de Modelo (MCP) que fornece recursos avançados de pesquisa na web, extração de conteúdo, rastreamento e scraping da web usando a API Firecrawl.

MCP Server for Slack

Uma implementação de servidor do Protocolo de Contexto de Modelo que permite que assistentes de IA interajam com espaços de trabalho do Slack, permitindo que eles naveguem por canais, enviem mensagens, respondam a threads, adicionem reações e recuperem informações de usuários.

Remote MCP Server Authless

A tool that deploys an authentication-free Model Context Protocol server on Cloudflare Workers, allowing you to create and access custom AI tools from the Cloudflare AI Playground or Claude Desktop.

GKE Hub API MCP Server

An auto-generated MCP server that enables interaction with Google Kubernetes Engine Hub API for multi-cluster management through natural language commands.

Redis MCP Server

Permite que os usuários realizem operações no banco de dados Redis usando as ferramentas do Protocolo de Contexto de Modelo (MCP), possibilitando o gerenciamento eficiente de dados por meio de comandos como definir, obter e escanear campos hash.

File Finder MCP Server

Permite a busca de arquivos por fragmentos de nome via JSON-RPC ou uma API REST HTTP, com opções para uso direto ou integração com outras ferramentas como o VS Code.

MCP Vector Sync

Um serviço multi-inquilino que monitora automaticamente as mudanças no banco de dados Supabase, gera embeddings da OpenAI e mantém capacidades de busca vetorial sincronizadas para os projetos de cada inquilino.