Discover Awesome MCP Servers

Brandfetch MCP Server

Enables AI assistants to fetch company logos, brand colors, fonts, and corporate information from the Brandfetch API using domain lookups or keyword searches.

VisualAI MCP Server

Enables local AI image generation on Apple Silicon Macs using MLX and Stable Diffusion. Supports conversational design iteration, asset generation, and wireframe creation with zero API costs through the Model Context Protocol.

BankRegPulse

BankRegPulse MCP Server connects AI assistants to live banking regulatory data from 100+ sources including OCC, FDIC, CFPB, Federal Reserve, and all 50 state banking departments. Three tools: daily intelligence briefings, regulatory podcast audio, and pre-formatted LinkedIn posts — all updated daily at 6 AM EST.

Hanzo MCP

Enables access to Hanzo APIs and Platform capabilities via MCP, along with development tools for managing and improving projects.

Plone MCP Server

Enables AI assistants to manage Plone CMS content, search, workflows, and Volto blocks via REST API.

HAOps MCP Server

Enables Claude to interact with the HAOps project management system for managing projects, modules, features, and issues.

HackTricks MCP Server

Enables searching and querying HackTricks pentesting documentation directly from Claude, with tools for quick lookup, grouped search results, page outlines, section extraction, and cheatsheet mode.

MCP Google Workspace Server

Exposes Gmail (send/draft) and Google Docs (append) capabilities as tools for any MCP-compliant agent.

icon-search-mcp

A Model Context Protocol server that enables unified fuzzy searching across multiple icon libraries (Bootstrap, Feather, Octicons, Tabler) with intelligent caching and comprehensive filtering options.

OriginForge NFT Generator

Enables fetching, viewing, and saving NFT data from the Origin Forge API, including retrieving random NFTs, accessing their attributes, color palettes, images, and saving SVG/JSON files locally.

mcp-hashline-edit-server

Provides hashline-based file editing using line-addressed edits and content hashes for integrity verification. It enables LLMs to perform precise file modifications while ensuring edits are rejected if the file content has changed since the last read.

LINE Bot MCP Server

Enables AI agents to send messages, manage rich menus, and interact with users through LINE Official Accounts via the LINE Messaging API. Supports both individual messaging and broadcasting to all followers with text and customizable flex messages.

rybbit-mcp

Exposes Rybbit Analytics as MCP tools for querying site traffic, page views, visitor sessions, and live visitor counts through natural language.

Doppler MCP Server

Enables secure secrets management through the Doppler CLI via natural language interactions. Supports managing secrets, projects, configs, and environments across different Doppler workspaces.

mcp-inaturalist

Enables querying citizen-science species observations from iNaturalist via the Pipeworx MCP gateway. Provides read-only access to species data without authentication.

Kiwoom API MCP Server

Provides tools to search and retrieve detailed documentation for the Kiwoom REST API, including parameters, categories, and code examples. It enables LLMs to generate request snippets in multiple programming languages to facilitate financial trading API integration.

cobos-apple-mail-mcp

Unifies fast on-disk read and search with complete AppleScript writes, behind a mandatory safety layer with read-only mode, batch caps, dry-run, and undo for reversible operations.

Vibe Blocks MCP

Connects Roblox Studio to AI coding editors via the Model Context Protocol, allowing AI agents to understand and interact with live Roblox Studio sessions through scene manipulation, scripting, and optional Roblox Open Cloud API integration.

SkySQL MCP Server

Repositório do servidor e cliente MCP do SkySQL.

mcp-infoblox

An MCP server that provides AI assistants with full access to Infoblox NIOS for managing DNS records, DHCP reservations, and IPAM through the WAPI REST API. It supports 35 tools for network discovery, record lifecycle management, and grid infrastructure status.

jankins

Token-optimized Jenkins MCP server with smart log handling and failure triage for AI coding assistants.

Multimodal RAG MCP Server

Connects Claude to a personal knowledge base with hybrid search over code, documents, and images. Allows the AI assistant to retrieve and answer from your own files during conversations.

Ember MCP Server

A Model Context Protocol server that provides tooling support for Ember.js development, allowing developers to execute CLI commands, run codemods, access documentation, and discover community resources.

MCP Kali Server

Okay, here's a breakdown of the MCP (Management Component Pack) configuration needed to connect an AI agent to a Linux machine, along with considerations and best practices. Since "MCP" can refer to different things depending on the context, I'll assume you're referring to a general management and monitoring framework that includes components for agent deployment, configuration, and communication. I'll cover the key aspects and provide examples where possible. **Core Components & Concepts** 1. **Agent Software:** This is the AI agent itself. It runs on the Linux machine and performs the tasks you've designed it for (e.g., monitoring system resources, executing commands, analyzing logs, etc.). 2. **Management Server (or Central Controller):** This is the central point of control. It's responsible for: * Deploying and updating agents. * Configuring agents. * Receiving data from agents. * Sending commands to agents. * Monitoring agent health. 3. **Communication Channel:** This is the network connection between the agent and the management server. Common options include: * **SSH (Secure Shell):** Secure and widely used, but can be resource-intensive if used for frequent communication. * **HTTPS (HTTP Secure):** Good for traversing firewalls, but requires TLS/SSL configuration. * **Message Queues (e.g., RabbitMQ, Kafka):** Excellent for asynchronous communication and handling large volumes of data. * **gRPC:** A modern, high-performance RPC framework. 4. **Configuration Management:** How you define and distribute the agent's settings. Options include: * **Configuration Files (e.g., YAML, JSON, INI):** Simple but can be difficult to manage at scale. * **Environment Variables:** Useful for simple settings. * **Centralized Configuration Server (e.g., etcd, Consul, ZooKeeper):** Best for dynamic and complex configurations. 5. **Security:** Crucial for protecting your systems. Consider: * **Authentication:** Verifying the identity of the agent and the management server. * **Authorization:** Controlling what actions the agent is allowed to perform. * **Encryption:** Protecting data in transit and at rest. **Configuration Steps (General Outline)** Here's a general outline of the steps involved in configuring the MCP to connect your AI agent: 1. **Install the Agent:** * **Package Management:** Use the Linux distribution's package manager (e.g., `apt`, `yum`, `dnf`) if the agent is available as a package. * **Manual Installation:** Download the agent software and install it manually. This usually involves extracting the archive and running an installation script. ```bash # Example (Debian/Ubuntu): sudo apt update sudo apt install <agent-package-name> # Example (RHEL/CentOS/Fedora): sudo yum install <agent-package-name> # or dnf install ``` 2. **Configure the Agent:** * **Agent Configuration File:** Locate the agent's configuration file (usually in `/etc/<agent-name>/`). Edit the file to specify: * The address of the management server. * Authentication credentials (e.g., API key, username/password, certificate). * Any other agent-specific settings. ```yaml # Example agent configuration (YAML) management_server: "https://your-management-server.example.com" api_key: "your_secret_api_key" agent_id: "linux-server-01" data_collection_interval: 60 # seconds ``` * **Environment Variables:** Set environment variables for the agent. ```bash # Example (setting environment variables) export MANAGEMENT_SERVER="https://your-management-server.example.com" export API_KEY="your_secret_api_key" ``` 3. **Start the Agent:** * Use the system's service manager (e.g., `systemd`, `init.d`) to start the agent. ```bash # Example (systemd) sudo systemctl start <agent-service-name> sudo systemctl enable <agent-service-name> # to start on boot sudo systemctl status <agent-service-name> # to check the status ``` 4. **Configure the Management Server:** * **Agent Registration:** The management server needs to be aware of the agent. This might involve: * Manually registering the agent in the management server's web interface. * The agent automatically registering itself with the server upon startup. * **Authentication/Authorization:** Configure the management server to authenticate the agent and authorize its actions. * **Data Processing:** Configure how the management server will process the data received from the agent. 5. **Test the Connection:** * Verify that the agent is connected to the management server. * Check that the agent is sending data to the server. * Test sending commands from the server to the agent. **Specific Considerations for AI Agents** * **Resource Consumption:** AI agents can be resource-intensive (CPU, memory, disk I/O). Monitor the agent's resource usage and adjust its configuration as needed. * **Data Security:** Be especially careful about the data that the AI agent collects and transmits. Encrypt sensitive data and implement appropriate access controls. * **Model Updates:** If the AI agent uses machine learning models, you'll need a mechanism for updating those models. This could involve: * The agent downloading new models from the management server. * The agent training models locally. * **Logging and Monitoring:** Implement comprehensive logging and monitoring to track the agent's behavior and identify any issues. **Example: Using SSH for Communication (Simplified)** This is a very basic example and not recommended for production due to security concerns if not properly configured. It's for illustrative purposes only. 1. **Agent (on Linux machine):** ```python # agent.py import subprocess import time import json def get_system_info(): # Example: Get CPU usage cpu_usage = subprocess.check_output("top -bn1 | grep 'Cpu(s)' | awk '{print $2 + $4}'", shell=True).decode().strip() return {"cpu_usage": cpu_usage} def main(): while True: data = get_system_info() print(json.dumps(data)) # Output to stdout time.sleep(60) if __name__ == "__main__": main() ``` 2. **Management Server:** ```python # management_server.py import subprocess import json def get_agent_data(hostname, username, ssh_key_path): command = f"ssh -i {ssh_key_path} {username}@{hostname} 'python3 /path/to/agent.py'" process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) stdout, stderr = process.communicate() if stderr: print(f"Error: {stderr.decode()}") return None try: data = json.loads(stdout.decode()) return data except json.JSONDecodeError: print(f"Invalid JSON: {stdout.decode()}") return None if __name__ == "__main__": hostname = "your_linux_machine_ip" username = "your_username" ssh_key_path = "/path/to/your/private_key" # Secure your key! data = get_agent_data(hostname, username, ssh_key_path) if data: print(f"Received data: {data}") else: print("Failed to retrieve data.") ``` **Important Notes:** * **Security is paramount.** Never hardcode passwords or API keys in your code. Use environment variables or a secrets management system. Properly configure SSH keys and restrict access. * **Error Handling:** Implement robust error handling in both the agent and the management server. * **Scalability:** Consider the scalability of your solution. Message queues and centralized configuration servers can help you scale to a large number of agents. * **Idempotency:** Ensure that your agent's actions are idempotent (i.e., running the same action multiple times has the same effect as running it once). This is important for reliability. * **Monitoring and Alerting:** Set up monitoring and alerting to detect any issues with the agent or the management server. **Translation to Portuguese:** **Configuração do MCP para conectar um agente de IA a uma máquina Linux** Aqui está uma análise da configuração do MCP (Management Component Pack) necessária para conectar um agente de IA a uma máquina Linux, juntamente com considerações e melhores práticas. Como "MCP" pode se referir a diferentes coisas dependendo do contexto, vou assumir que você está se referindo a um framework geral de gerenciamento e monitoramento que inclui componentes para implantação, configuração e comunicação de agentes. Vou cobrir os principais aspectos e fornecer exemplos sempre que possível. **Componentes e Conceitos Principais** 1. **Software do Agente:** Este é o próprio agente de IA. Ele é executado na máquina Linux e executa as tarefas para as quais você o projetou (por exemplo, monitorar recursos do sistema, executar comandos, analisar logs, etc.). 2. **Servidor de Gerenciamento (ou Controlador Central):** Este é o ponto central de controle. É responsável por: * Implantar e atualizar agentes. * Configurar agentes. * Receber dados de agentes. * Enviar comandos para agentes. * Monitorar a saúde do agente. 3. **Canal de Comunicação:** Esta é a conexão de rede entre o agente e o servidor de gerenciamento. As opções comuns incluem: * **SSH (Secure Shell):** Seguro e amplamente utilizado, mas pode consumir muitos recursos se usado para comunicação frequente. * **HTTPS (HTTP Secure):** Bom para atravessar firewalls, mas requer configuração TLS/SSL. * **Filas de Mensagens (por exemplo, RabbitMQ, Kafka):** Excelente para comunicação assíncrona e tratamento de grandes volumes de dados. * **gRPC:** Um framework RPC moderno e de alto desempenho. 4. **Gerenciamento de Configuração:** Como você define e distribui as configurações do agente. As opções incluem: * **Arquivos de Configuração (por exemplo, YAML, JSON, INI):** Simples, mas pode ser difícil de gerenciar em escala. * **Variáveis de Ambiente:** Útil para configurações simples. * **Servidor de Configuração Centralizado (por exemplo, etcd, Consul, ZooKeeper):** Melhor para configurações dinâmicas e complexas. 5. **Segurança:** Crucial para proteger seus sistemas. Considere: * **Autenticação:** Verificar a identidade do agente e do servidor de gerenciamento. * **Autorização:** Controlar quais ações o agente tem permissão para executar. * **Criptografia:** Proteger dados em trânsito e em repouso. **Etapas de Configuração (Roteiro Geral)** Aqui está um roteiro geral das etapas envolvidas na configuração do MCP para conectar seu agente de IA: 1. **Instale o Agente:** * **Gerenciamento de Pacotes:** Use o gerenciador de pacotes da distribuição Linux (por exemplo, `apt`, `yum`, `dnf`) se o agente estiver disponível como um pacote. * **Instalação Manual:** Baixe o software do agente e instale-o manualmente. Isso geralmente envolve extrair o arquivo e executar um script de instalação. ```bash # Exemplo (Debian/Ubuntu): sudo apt update sudo apt install <nome-do-pacote-do-agente> # Exemplo (RHEL/CentOS/Fedora): sudo yum install <nome-do-pacote-do-agente> # ou dnf install ``` 2. **Configure o Agente:** * **Arquivo de Configuração do Agente:** Localize o arquivo de configuração do agente (geralmente em `/etc/<nome-do-agente>/`). Edite o arquivo para especificar: * O endereço do servidor de gerenciamento. * Credenciais de autenticação (por exemplo, chave de API, nome de usuário/senha, certificado). * Quaisquer outras configurações específicas do agente. ```yaml # Exemplo de configuração do agente (YAML) management_server: "https://seu-servidor-de-gerenciamento.exemplo.com" api_key: "sua_chave_api_secreta" agent_id: "servidor-linux-01" data_collection_interval: 60 # segundos ``` * **Variáveis de Ambiente:** Defina variáveis de ambiente para o agente. ```bash # Exemplo (definindo variáveis de ambiente) export MANAGEMENT_SERVER="https://seu-servidor-de-gerenciamento.exemplo.com" export API_KEY="sua_chave_api_secreta" ``` 3. **Inicie o Agente:** * Use o gerenciador de serviços do sistema (por exemplo, `systemd`, `init.d`) para iniciar o agente. ```bash # Exemplo (systemd) sudo systemctl start <nome-do-serviço-do-agente> sudo systemctl enable <nome-do-serviço-do-agente> # para iniciar na inicialização sudo systemctl status <nome-do-serviço-do-agente> # para verificar o status ``` 4. **Configure o Servidor de Gerenciamento:** * **Registro do Agente:** O servidor de gerenciamento precisa estar ciente do agente. Isso pode envolver: * Registrar manualmente o agente na interface web do servidor de gerenciamento. * O agente se registrar automaticamente no servidor ao iniciar. * **Autenticação/Autorização:** Configure o servidor de gerenciamento para autenticar o agente e autorizar suas ações. * **Processamento de Dados:** Configure como o servidor de gerenciamento processará os dados recebidos do agente. 5. **Teste a Conexão:** * Verifique se o agente está conectado ao servidor de gerenciamento. * Verifique se o agente está enviando dados para o servidor. * Teste o envio de comandos do servidor para o agente. **Considerações Específicas para Agentes de IA** * **Consumo de Recursos:** Agentes de IA podem consumir muitos recursos (CPU, memória, E/S de disco). Monitore o uso de recursos do agente e ajuste sua configuração conforme necessário. * **Segurança de Dados:** Tenha cuidado especial com os dados que o agente de IA coleta e transmite. Criptografe dados confidenciais e implemente controles de acesso apropriados. * **Atualizações de Modelo:** Se o agente de IA usar modelos de aprendizado de máquina, você precisará de um mecanismo para atualizar esses modelos. Isso pode envolver: * O agente baixando novos modelos do servidor de gerenciamento. * O agente treinando modelos localmente. * **Registro e Monitoramento:** Implemente registro e monitoramento abrangentes para rastrear o comportamento do agente e identificar quaisquer problemas. **Exemplo: Usando SSH para Comunicação (Simplificado)** Este é um exemplo muito básico e não recomendado para produção devido a preocupações de segurança se não for configurado corretamente. É apenas para fins ilustrativos. 1. **Agente (na máquina Linux):** ```python # agent.py import subprocess import time import json def get_system_info(): # Exemplo: Obter o uso da CPU cpu_usage = subprocess.check_output("top -bn1 | grep 'Cpu(s)' | awk '{print $2 + $4}'", shell=True).decode().strip() return {"cpu_usage": cpu_usage} def main(): while True: data = get_system_info() print(json.dumps(data)) # Saída para stdout time.sleep(60) if __name__ == "__main__": main() ``` 2. **Servidor de Gerenciamento:** ```python # management_server.py import subprocess import json def get_agent_data(hostname, username, ssh_key_path): command = f"ssh -i {ssh_key_path} {username}@{hostname} 'python3 /path/to/agent.py'" process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) stdout, stderr = process.communicate() if stderr: print(f"Erro: {stderr.decode()}") return None try: data = json.loads(stdout.decode()) return data except json.JSONDecodeError: print(f"JSON inválido: {stdout.decode()}") return None if __name__ == "__main__": hostname = "seu_ip_da_maquina_linux" username = "seu_nome_de_usuario" ssh_key_path = "/caminho/para/sua/chave_privada" # Proteja sua chave! data = get_agent_data(hostname, username, ssh_key_path) if data: print(f"Dados recebidos: {data}") else: print("Falha ao recuperar dados.") ``` **Notas Importantes:** * **A segurança é fundamental.** Nunca coloque senhas ou chaves de API diretamente no seu código. Use variáveis de ambiente ou um sistema de gerenciamento de segredos. Configure corretamente as chaves SSH e restrinja o acesso. * **Tratamento de Erros:** Implemente um tratamento de erros robusto tanto no agente quanto no servidor de gerenciamento. * **Escalabilidade:** Considere a escalabilidade da sua solução. Filas de mensagens e servidores de configuração centralizados podem ajudá-lo a escalar para um grande número de agentes. * **Idempotência:** Garanta que as ações do seu agente sejam idempotentes (ou seja, executar a mesma ação várias vezes tem o mesmo efeito que executá-la uma vez). Isso é importante para a confiabilidade. * **Monitoramento e Alertas:** Configure o monitoramento e os alertas para detectar quaisquer problemas com o agente ou o servidor de gerenciamento. This detailed response should give you a solid foundation for configuring your MCP. Remember to adapt the examples to your specific environment and requirements. Good luck!

RunWhen Platform MCP

Lets your coding agent talk to the RunWhen platform — workspace chat, issues, SLXs, run sessions, and the Tool Builder — over the Model Context Protocol. Enables workspace chat with AI assistant, task authoring via Tool Builder, and direct data access to workspaces, issues, SLXs, run sessions, and more.

patents-mcp

MCP server for patent search and prior art discovery powered by Google Patents public dataset on BigQuery. Supports searching patents, fetching full patent details with CPC codes and citations, and retrieving legal claims text.

Simple Weather MCP

A cross-platform MCP server that provides weather forecasts by coordinates, location name, or IP address without requiring API keys. It leverages Open Meteo and OpenStreetMap to deliver fast, single-query weather lookups.

time-tracker-ai-mcp

Enables tracking work time with start/stop timers, logging entries, and generating reports.

Notion Schedule Agent

An MCP server that turns your Notion task list into an AI-optimized daily schedule, reading tasks with page content and priorities from an Eisenhower matrix, and writing a clean schedule back to Notion.

Enzan

Enables AI agents to store, retrieve, and reason over typed knowledge, skills, and patterns with confidence tracking, provenance, and self-maintenance capabilities.