Discover Awesome MCP Servers

Swagger/Postman MCP Server

Enables AI agents to dynamically discover and interact with APIs through Swagger/OpenAPI specifications and Postman collections using a strategic four-tool approach. It streamlines API integration by providing universal tools for endpoint discovery, detailed request information, and authenticated execution.

lunchmoney-mcp

A comprehensive MCP server that enables AI assistants to manage Lunch Money finances through 37 tools for transactions, budgets, and accounts. It supports both local stdio and remote HTTP transport modes with secure, encrypted credential storage.

MCP-Server

A Model Context Protocol implementation that enables large language models to call external tools (like weather forecasts and GitHub information) through a structured protocol, with visualization of the model's reasoning process.

Websearch MCP Server

Enables web searching via DuckDuckGo and page fetching with automatic HTML-to-Markdown conversion to reduce LLM token usage by approximately 60%. It provides tools for search, content extraction, and combined operations without requiring any external API keys.

mssql-mcp-server

Espelho de

Chess.com MCP Server

Fornece acesso a dados de jogadores do Chess.com, registros de partidas e informações públicas através de interfaces MCP padronizadas, permitindo que assistentes de IA pesquisem e analisem informações sobre xadrez.

WordPress Standalone MCP Server

A Model Context Protocol server that automatically discovers WordPress REST API endpoints and creates individual tools for each endpoint, enabling natural language management of WordPress sites.

Perplexity Search

Permite a integração da API de IA da Perplexity com LLMs, oferecendo preenchimento de chat avançado através da utilização de templates de prompt especializados para tarefas como documentação técnica, revisão de código e documentação de API.

mcp-server

servidor mcp

competlab-mcp-server

Competitive intelligence platform with 24 tools. Monitor competitor pricing, content, positioning, tech stacks, and AI visibility — track how ChatGPT, Claude, and Gemini rank your brand.

mmnt-mcp-server

Servidor MCP para o motor de busca Mamont

Open-Meteo MCP Server

Provides comprehensive access to Open-Meteo APIs for weather forecasts, historical data, air quality, and marine conditions. It enables LLMs to query specialized meteorological models, perform geocoding, and access advanced climate or flood projections.

MCP Platform

A reusable runtime infrastructure for hosting Model Context Protocol servers and tool registries over HTTP. It provides built-in validation, authentication, and logging to simplify the deployment of AI-powered workflows.

Obsidian MCP Learning System

A local MCP server that transforms an Obsidian vault into a structured learning interface through tools for concept extraction and gap analysis. It enables AI agents to generate study plans and align note-taking with implementation projects for a more cohesive learning workflow.

DB Analytics & Query Platform

A FastAPI-based server that enables executing SQL queries, managing database connections, and retrieving analytics reports through MCP-integrated endpoints. It allows users to interact with database schemas, performance metrics, and access logs using structured queries.

Nmap MCP Server

Enables network scanning and security assessment using Nmap through MCP, allowing AI assistants to perform port scans, service detection, and network reconnaissance on specified targets with configurable scan parameters.

Last9 Observability MCP

Seamlessly bring real-time production context—logs, metrics, and traces—into your local environment to auto-fix code faster.

Cloud TPU API MCP Server

Provides Multi-Agent Conversation Protocol access to Google Cloud TPU services, enabling management of Tensor Processing Units through natural language interactions with the Google TPU API.

MCP UUID Server

Um serviço simples que gera UUIDs aleatórios quando solicitado através do Claude Desktop.

ReadPDFx - OCR PDF MCP Server

Provides intelligent OCR and PDF processing capabilities that automatically detect whether PDFs contain digital text or scanned images and apply appropriate extraction methods. Supports text extraction, OCR processing, structure analysis, and batch operations.

FastMCP Dummy Server

A minimal example server implementing the Model Context Protocol, providing addition and multiplication tools for learning and experimentation with MCP clients.

Freshservice MCP server

Freshservice MCP server

DigitalOcean MCP Server

Provides comprehensive access to 471+ DigitalOcean API endpoints, enabling AI assistants to manage cloud infrastructure including droplets, databases, load balancers, DNS, Kubernetes, and other DigitalOcean resources programmatically.

Geth MCP Proxy

Bridges Ethereum JSON-RPC queries from Geth nodes to the Model Context Protocol ecosystem, exposing blockchain operations as MCP tools. Enables AI models and applications to securely interact with Ethereum data including blocks, transactions, balances, and advanced debug functions through schema-validated access.

Apollo.io MCP Server

Enables AI assistants to interact with Apollo.io API for sales and marketing activities. Provides tools to search for companies and contacts, enrich person and organization data, and manage accounts with comprehensive lead generation capabilities.

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.

mac-use-mcp

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

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