Discover Awesome MCP Servers

POEditor MCP Server

Enables comprehensive translation management through POEditor's API with project, language, term, and translation operations. Includes automation scripts for reporting, monitoring, AI-powered suggestions, and multi-format exports.

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-server-google-cloud-logging

Para obter registros do Logging usando o gcloud, você pode usar o comando `gcloud logging read`. Aqui estão algumas maneiras de usá-lo: **1. Obter os registros mais recentes:** ```bash gcloud logging read ``` Este comando exibirá os registros mais recentes do seu projeto atual. **2. Obter registros de um determinado período de tempo:** ```bash gcloud logging read --start-time="2023-10-27T00:00:00Z" --end-time="2023-10-28T00:00:00Z" ``` Este comando exibirá os registros entre 27 de outubro de 2023 e 28 de outubro de 2023. Certifique-se de ajustar as datas e horários conforme necessário. O formato da data/hora deve ser ISO 8601 (como no exemplo). **3. Filtrar registros por severidade:** ```bash gcloud logging read --severity=ERROR ``` Este comando exibirá apenas os registros com severidade ERROR. Outras opções de severidade incluem: `DEBUG`, `INFO`, `WARNING`, `ERROR`, `CRITICAL`, `ALERT`, `EMERGENCY`. **4. Filtrar registros por um filtro específico:** ```bash gcloud logging read "resource.type=gce_instance AND logName:\"projects/YOUR_PROJECT_ID/logs/YOUR_LOG_NAME\"" ``` Substitua `YOUR_PROJECT_ID` pelo ID do seu projeto do Google Cloud e `YOUR_LOG_NAME` pelo nome do log que você deseja consultar. Este exemplo filtra registros de instâncias GCE (máquinas virtuais) e de um log específico. **5. Salvar os registros em um arquivo:** ```bash gcloud logging read > logs.txt ``` Este comando salvará todos os registros recuperados no arquivo `logs.txt`. **6. Limitar o número de registros retornados:** ```bash gcloud logging read --limit=100 ``` Este comando retornará apenas os 100 registros mais recentes. **7. Especificar o projeto:** Se você não estiver no projeto padrão, você pode especificar o projeto usando a flag `--project`: ```bash gcloud logging read --project=YOUR_PROJECT_ID ``` Substitua `YOUR_PROJECT_ID` pelo ID do seu projeto. **Recursos adicionais:** * **Documentação oficial do `gcloud logging read`:** [https://cloud.google.com/sdk/gcloud/reference/logging/read](https://cloud.google.com/sdk/gcloud/reference/logging/read) * **Documentação sobre filtros de registro:** [https://cloud.google.com/logging/docs/view/advanced-queries](https://cloud.google.com/logging/docs/view/advanced-queries) **Dicas:** * Use aspas duplas para envolver filtros complexos. * Você pode combinar várias opções para criar consultas mais específicas. * Para obter ajuda com o comando `gcloud logging read`, execute `gcloud logging read --help`. Lembre-se de substituir os valores de espaço reservado (como `YOUR_PROJECT_ID` e `YOUR_LOG_NAME`) pelos valores reais do seu ambiente.

EDT Unicaen MCP Server

Enables querying University of Caen (Unicaen) schedule data to find next classes for professors, students, or rooms and check room availability. Integrates with ADE scheduling system to provide real-time schedule information through natural language queries.

Goodreads MCP Server

A CLI tool that integrates with Claude Desktop to allow users to retrieve their Goodreads library data through MCP.

Discourse MCP

Enables AI agents to interact with Discourse forums through search, reading topics/posts, browsing categories and tags, and creating posts. Supports both read-only public access and authenticated operations with configurable write permissions.

NotionMCP Server

A Python server that integrates MCP with Notion to automate documentation workflows and manage Notion pages via LLMs, supporting operations like creating, updating, and searching Notion content.

Capture Win MCP

Enables AI assistants to interact with macOS windows through yabai, providing window listing organized by Spaces and screenshot capture capabilities.

Klipper MCP Server

An MCP server that enables AI assistants to control and monitor Klipper 3D printers via the Moonraker API. It supports comprehensive printer management, including G-code execution, toolchanger operations, and real-time status monitoring.

freedcamp

freedcamp

Enhanced Sequential Thinking MCP Server

Enables structured problem-solving through sequential thinking stages with persistent storage and analysis. Helps break down complex problems into manageable cognitive steps while tracking progress and generating summaries of the entire thought process.

TypeScript MCP Server Boilerplate

A boilerplate project for quickly developing Model Context Protocol (MCP) servers using TypeScript SDK, with example tools (calculator, greeting) and resources pre-configured.

EndNote Library Reader

Enables programmatic access to EndNote .enl libraries, allowing users to list, search, and extract full text from bibliographic references and their attached PDFs through MCP tools.

Locations MCP Server

Enables WordPress content extraction, keyword research using Google autocomplete and Trends data, and generation of SEO-optimized content with quality metrics.

Ronin Defense MCP

Detects and sanitizes hidden-payload attacks in MCP communications to protect LLMs in agentic IDEs from malicious prompt injection and adversarial content delivery.

microsandbox

microsandbox

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-angular-cli

mcp-angular-cli

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!

GitHub DeepWiki MCP Server

This MCP server provides detailed GitHub repository information by integrating with mcp.deepwiki.com and GitHub API to fetch repository wiki content, README files, and enable intelligent question-answering about repositories.

Salesforce MCP Server

Enables natural language interactions with Salesforce data and metadata, allowing users to query records, manage custom objects, and manipulate Apex code. It provides comprehensive tools for schema exploration, aggregate queries, and field-level security management.

MCP Node-Notifier Server

A Model Context Protocol server that provides system notification capabilities across various platforms (macOS, Windows, Linux) using node-notifier.

Snippets MCP

Enables storing, searching, and managing code snippets using hybrid semantic search and keyword matching with automatic language detection and tag-based organization.

Jina AI Remote MCP Server

Provides access to Jina AI's web reading, search, embeddings, and reranking capabilities. Enables URL content extraction, web/arXiv/image search, document deduplication, and relevance ranking through natural language.

UniAuto MCP Server

Servidor MCP de Automação de Testes Universal com capacidades de auto-recuperação e integração com Smithery.ai.

Playwright Fetch MCP Server

Provides web content fetching capabilities using Playwright browser automation, enabling LLMs to retrieve and process JavaScript-rendered content from web pages and convert HTML to markdown for easier consumption.

openai-agents-chat-demo

Demonstração de chat de agentes da OpenAI. Integração de LLM customizado e servidor MCP e ferramenta de função.

Source Parts MCP Server

Enables Claude to search and manage electronic components, PCB parts, and manufacturing services through direct access to the Source Parts API. Provides comprehensive product search, pricing, inventory checking, and parametric filtering capabilities for electronics procurement.