Discover Awesome MCP Servers

GitLab MCP Server

Enables AI agents to interact with GitLab via a restricted set of 9 tools using OAuth 2.0 authentication, supporting merge requests, comments, pipelines, and labels.

SEFAZ PR: CADIN

MCP server for querying the Paraná state tax agency's CADIN registry, read-only, hosted, with pay-per-use credits.

Godot MCP

A security-first MCP server and Godot editor addon enabling AI agents to observe and control Godot games through bounded, permission-gated tools for debugging, input automation, and project editing.

OmniKit

Free, fully-offline MCP utility tools for agents: base64, UUID, JSON validation, SHA hashing, timestamps, URL codec, case conversion, and secure passwords. No API keys, no tracking, works offline - stdlib-only Python stdio server.

LangChain Documentation MCP Server

Provides real-time access to official LangChain documentation, API references, and GitHub code examples to assist in LangChain-based development. It enables LLMs to search for tutorials, version info, and detailed class specifications directly from live sources.

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.

seedbase-mcp

Enables AI assistants to generate realistic, relationship-preserving test data from Seedbase projects into databases.

interclaude

Enables peer-to-peer communication between Claude Code sessions, allowing them to send messages, hand off tasks, and coordinate across worktrees without manual intervention.

Sentinela MCP

Provides coding agents with durable, cross-session lessons-learned memory, enforcing that success or failure verdicts can only come from human approval, human correction, or objective metrics—never from the agent itself.

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!

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.

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.

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.

Upstox MCP Server

Enables users to interact with the Upstox trading API via natural language to retrieve account information such as profile, funds, holdings, positions, and orders.

jt-mcp-server

MCP server that equips AI agents with dev workflow tools including GitHub project management, conventional commits, visual regression testing, Jira/Confluence integration, and a persistent memory knowledge graph.

productboard-mcp

An MCP server that connects Claude to the ProductBoard API v2, enabling natural language management of notes, entities, members, analytics, Jira integrations, and webhooks.

rovee-publisher-mcp

MCP server for Rovee that enables AI clients to publish bilingual content (blog posts, POIs, events, businesses, guides) and upload media to Supabase Storage, returning CDN URLs.

attestor

Audit-grade memory backbone for agent teams. Bi-temporal facts (event time + transaction time, with recall(as_of=...) replay), 6-step deterministic retrieval (no LLM in the critical path), conversation ingest with speaker-locked dual-pass extraction, per-tenant Postgres row-level security, and Ed25519-signed provenance. Postgres + pgvector + Neo4j defaults.

Screenshot Scout MCP Server

Enables capturing HTTP/HTTPS webpages as images or PDFs using Screenshot Scout, with support for full-page, element, and device-specific captures, page interactions, and caching.

DUAL MCP Server

Enables AI agents to interact directly with the DUAL Web3 Operating System for minting tokens, managing templates, and executing blockchain actions. It provides over 60 tools for handling wallets, organizations, and ZK-rollup infrastructure natively via the Model Context Protocol.

partner-polaris

Enables AI assistants to query, calculate, and benchmark AWS Partner Polaris training depth levels using CSV data.

zotero-comfort

High-level Zotero MCP integration with smart research workflows, enabling tasks like building reading lists, adding papers with duplicate check, and exporting bibliographies.

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.

Trimble Connect MCP Server

Exposes structured documentation for 200+ Trimble Connect API endpoints and provides tools for AI-assisted development of Trimble Connect extensions and applications.

chatgpt-pro-mcp

An experimental guarded MCP bridge for Codex/open-ultrawork workflows, enabling submission of bounded research jobs to ChatGPT Pro asynchronously with source verification and safety guards.

Enterprise Operations Hub

An MCP-native enterprise operations platform that unifies team management, product catalog, order processing, knowledge base, location intelligence, analytics, and DevOps monitoring into a single server accessible from any MCP-compatible AI agent.

OpenTelemetry Documentation MCP Server

Enables access to OpenTelemetry documentation by fetching and converting pages to markdown format and searching content using Google Custom Search. Provides comprehensive documentation lookup and search capabilities for OpenTelemetry concepts, instrumentation, and configuration.

invoiceflow-mcp

AI-powered invoice automation. Create PDF invoices, predict late payment risk 0-100, auto-send reminders, reconcile Stripe/PayPal payments, track cash flow. 10 MCP tools, 4 resources.