Discover Awesome MCP Servers

PocketMCP

A lightweight, local-first MCP server that automatically watches folders, chunks and embeds files using Transformers.js, and exposes semantic search capabilities to VS Code and Cursor. Runs completely offline with SQLite vector storage, designed for resource-constrained environments.

Calendly MCP Server

Enables interaction with Calendly's scheduling platform via MCP, allowing users to manage events, invitees, and schedule meetings directly using the Calendly API.

beacon-mcp

MCP server for the beacon log analytics platform, exposing beacon's REST API as MCP tools and resources for AI agents to query and analyse AI-assistant usage data.

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.

Android MCP Server

Enables AI agents to directly control Android devices via Termux, providing 120+ tools for screen manipulation, file management, app control, and system operations with layered loading and security gating.

TRAECNclaw MCP

Control TraeCN desktop automation through explicit, profile-scoped MCP tools. Supports task delegation, model control, dialog handling, code review, and unattended workflows.

Cloudflare Remote PostgreSQL MCP Server

Enables natural language interaction with PostgreSQL databases through MCP tools, with GitHub OAuth authentication and role-based access control.

Tribunal TRF1: Processo

MCP server to query legal process information from Brazil's Tribunal Regional Federal da 1ª Região (TRF1), providing a read-only consultation tool using official sources.

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.

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.

SEFAZ PR: CADIN

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

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.

rybbit-mcp

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

tasks-mcp

An MCP server that exposes outputty's task tracker as typed tools backed by GitHub Issues, allowing coding agents to manage tasks with two-way sync.

dad-jokes-mcp

Enables fetching and managing dad jokes with tools for random jokes, multiple jokes, categories, and persistent storage.

CCCMemory MCP

Provides Claude with long-term memory by indexing conversation history, enabling semantic search, decision tracking, and cross-project search.

bhs-mcp

An MCP server for Blackhearts & Sparrows product data that enables searching products, retrieving details, listing stores, and managing carts via a sandboxed TypeScript execution environment.

Microsoft Copilot Studio ❤️ MCP

A lab demonstrating how to deploy a Model Context Protocol (MCP) server and integrate it with Microsoft Copilot Studio, allowing users to connect AI models to different data sources and tools through a standardized protocol.

MCP-Context-Provider

A static MCP server that helps AI models maintain tool context across chat sessions, preventing loss of important information and keeping conversations smooth and uninterrupted.

marm-mcp

MARM MCP provides persistent memory and structured session context beneath any AI tool, so your agents learn, remember, and collaborate across all your workflows.

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.

OpenAI Image Generation MCP Server

Enables image generation using OpenAI's DALL-E and GPT-Image models directly through the Model Context Protocol. It allows users to create and save images with fine-grained control over parameters like size, quality, and background transparency.

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.

mcp-inaturalist

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

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.

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.

Intern MCP

Local stdio MCP server for working on Intern-hosted sites through guarded Git checkouts. It enables authentication, site preparation, testing, validation, and publishing via coding harnesses like Codex and Claude Code.