Discover Awesome MCP Servers

MCPDocSearch

Crawls documentation websites and provides semantic search capabilities over the content through vector embeddings, enabling natural language queries of technical documentation.

Random Word By Api Ninjas

Provides access to API Ninjas Random Word API to generate random words by type (noun, verb, adjective, adverb) for creative writing, games, and language learning applications.

Querysharp MCP Server

Enables AI assistants to analyze and optimize PostgreSQL database performance by identifying missing indexes and suggesting query rewrites. It allows users to retrieve database projects and implement performance fixes directly through natural language in their code editor.

LumiFAI MCP Technical Analysis Server

Forneço ferramentas de análise técnica para dados de negociação de criptomoedas, calculando EMAs (períodos de 12 e 26) para pares da Binance usando MongoDB para armazenamento de dados.

Speelka Agent

Agente LLM Universal baseado em MCP

CodeGraph MCP Server

Enables querying and analyzing code relationships by building a lightweight graph of TypeScript and Python symbols. Supports symbol lookup, reference tracking, impact analysis from diffs, and code snippet retrieval through natural language.

mcp-test

just a test

mcp-spacefrontiers

Pesquisar em dados acadêmicos e redes sociais.

Big Brain MCP

Um servidor MCP que recupera estatísticas dos principais protocolos na Rede Mantle para ajudar os usuários a tomar decisões de investimento mais informadas.

Code Execution Server

Enables execution of code in a sandbox environment with integrated web search capabilities. Provides a basic framework for running code safely, primarily designed for AI agents and research applications.

DICOM-MCP

A Model Context Protocol server that allows working with DICOM medical images through a simple note storage system.

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

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

mcp_repo9756c6c7-ee07-4f3a-ada4-f6e2705daa02

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

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

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.

Brave Search MCP Server

Um servidor MCP que integra a API do Brave Search para fornecer capacidades de pesquisa tanto na web quanto localmente, com funcionalidades como paginação, filtragem e retornos inteligentes (smart fallbacks).

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.

Self MCP Server

Enables developers to integrate privacy-preserving identity verification from the Self protocol into their apps. Provides integration guides, code generation, blockchain configuration reading, and debugging assistance for age verification, airdrop eligibility, and humanity checks.

Ashra Structured Data Extractor MCP

Extraia dados estruturados de qualquer site com uma simples chamada de SDK. Sem código de scraping, sem navegadores headless - apenas solicite e obtenha JSON.

DA Live Admin MCP Server

Enables LLM assistants to manage Document Authoring (DA) repositories through the DA Live Admin API, supporting operations like listing, creating, updating, and deleting source files, managing configurations, and looking up media and fragment references.

instant-meshes-mcp

An MCP server for 3D model processing that provides automated retopology, decimation, and quality analysis for OBJ and GLB files. It integrates Instant Meshes, pymeshlab, and Blender 3.6 to support smart simplification, texture preservation, and structured model archiving.

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.

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.