Discover Awesome MCP Servers

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.

Sunex Optics MCP Server

Enables AI assistants to search Sunex's lens and imager catalog using natural language queries. It provides tools for finding compatible lenses, sensor specifications, and product details through a public Model Context Protocol server.

LangChain Agent with MCP Servers

LangChain Agent với Máy chủ MCP: Sử dụng Bộ điều hợp LangChain MCP để tích hợp công cụ.

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.

mcp-k8s

Máy chủ Kubernetes MCP (Model Control Protocol) cho phép tương tác với các cụm Kubernetes thông qua các công cụ MCP.

Todoist MCP

Enables LLMs to interact with Todoist task management platform through its API, supporting all features from the official Todoist TypeScript Client.

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 Kali Server

Okay, here's a breakdown of how to configure an MCP (presumably referring to a **Management and Configuration Protocol**, though the exact meaning depends on the specific AI agent and its ecosystem) to connect an AI agent to a Linux machine. I'll cover the general concepts and common approaches, but you'll need to adapt this to the specific requirements of your AI agent and MCP implementation. **Understanding the Goal** The core idea is to enable your AI agent to: 1. **Execute commands** on the Linux machine. 2. **Retrieve information** from the Linux machine (e.g., system status, logs, file contents). 3. **Potentially configure** the Linux machine (e.g., change settings, install software). **General Steps and Considerations** 1. **Choose an MCP (Management and Configuration Protocol):** * **SSH (Secure Shell):** A very common and secure option. It allows you to execute commands remotely. You'll need an SSH client on the AI agent's side and an SSH server (usually `sshd`) running on the Linux machine. * **REST API:** You can create a REST API on the Linux machine that exposes specific functions for the AI agent to call. This requires more development effort but offers fine-grained control. Frameworks like Flask (Python) or Node.js (JavaScript) are often used. * **gRPC:** A high-performance, open-source RPC framework. Good for complex interactions and structured data. * **Message Queues (e.g., RabbitMQ, Kafka):** The AI agent can send commands as messages to a queue, and a process on the Linux machine can consume those messages and execute the commands. Useful for asynchronous communication. * **Custom Protocol:** If none of the above fit your needs, you can design your own protocol. This is the most complex option. * **Existing Management Tools:** Consider leveraging existing management tools like Ansible, Chef, or Puppet if they are already in use in your environment. The AI agent could interact with these tools' APIs. 2. **Security:** This is paramount. * **Authentication:** How will the AI agent prove its identity to the Linux machine? * **SSH Keys:** The most secure method for SSH. Generate an SSH key pair, place the public key on the Linux machine in the `~/.ssh/authorized_keys` file for the appropriate user, and configure the AI agent to use the private key. **Never** hardcode passwords in your AI agent's code. * **API Keys:** For REST APIs, use API keys that are securely stored and transmitted (e.g., using HTTPS). * **Certificates:** For gRPC, use TLS/SSL certificates for authentication and encryption. * **Username/Password (Discouraged):** Avoid this if possible, especially for SSH. If you must use it, ensure the password is very strong and stored securely (e.g., using a secrets management system). * **Authorization:** What permissions does the AI agent have on the Linux machine? * **Principle of Least Privilege:** Grant the AI agent only the minimum necessary permissions to perform its tasks. Create a dedicated user account for the AI agent with limited privileges. * **sudo:** Use `sudo` to allow the AI agent to execute specific commands as root, but only those commands that are absolutely necessary. Configure `sudoers` carefully. * **API Access Control:** For REST APIs, implement access control mechanisms to restrict which endpoints the AI agent can access. * **Encryption:** Use encryption (e.g., HTTPS for REST APIs, SSH for command execution) to protect data in transit. * **Firewall:** Configure the Linux machine's firewall (e.g., `iptables`, `ufw`) to allow only necessary connections from the AI agent's IP address or network. * **Auditing:** Log all actions performed by the AI agent on the Linux machine. This is crucial for security monitoring and troubleshooting. 3. **Configuration on the Linux Machine:** * **Install the necessary software:** This might include an SSH server, a web server (for REST APIs), gRPC libraries, message queue clients, etc. * **Configure the firewall:** Allow connections from the AI agent's IP address on the appropriate port (e.g., port 22 for SSH, port 443 for HTTPS). * **Create a user account (recommended):** Create a dedicated user account for the AI agent with limited privileges. * **Set up SSH keys (if using SSH):** Add the AI agent's public key to the `~/.ssh/authorized_keys` file for the user account. * **Configure `sudoers` (if needed):** If the AI agent needs to execute commands as root, configure the `sudoers` file to allow it to execute only those specific commands. Use `visudo` to edit the `sudoers` file safely. 4. **Configuration on the AI Agent Side:** * **Install the necessary libraries:** This might include an SSH client library, an HTTP client library, gRPC libraries, message queue clients, etc. * **Configure the connection parameters:** This includes the Linux machine's IP address or hostname, the port number, the username, the password or SSH key, and any other necessary parameters. **Store these parameters securely.** Avoid hardcoding them in the code. Use environment variables, configuration files, or a secrets management system. * **Implement the communication logic:** Write the code that sends commands to the Linux machine and receives responses. **Example: Using SSH** This is a common and relatively simple approach. * **Linux Machine:** 1. **Install SSH server:** `sudo apt-get update && sudo apt-get install openssh-server` (on Debian/Ubuntu) 2. **Create a user (optional but recommended):** `sudo adduser aiagent` 3. **Generate SSH key pair on the AI agent's machine:** `ssh-keygen -t rsa -b 4096` (Follow the prompts. Choose a strong passphrase.) 4. **Copy the public key to the Linux machine:** There are several ways to do this. One easy way is using `ssh-copy-id`: ```bash ssh-copy-id aiagent@<linux_machine_ip_address> ``` (You'll be prompted for the `aiagent` user's password on the Linux machine the first time.) 5. **Test the connection:** `ssh aiagent@<linux_machine_ip_address>` (You should be able to log in without a password if the SSH key is configured correctly.) 6. **Configure `sudoers` (if needed):** Use `sudo visudo` to edit the `sudoers` file. For example, to allow the `aiagent` user to execute `/sbin/reboot` without a password: ``` aiagent ALL=(ALL) NOPASSWD: /sbin/reboot ``` **Be very careful when editing the `sudoers` file.** Incorrect configuration can compromise the security of your system. * **AI Agent (Python example using `paramiko`):** ```python import paramiko def execute_command(hostname, username, private_key_path, command): """Executes a command on a remote Linux machine using SSH.""" try: ssh_client = paramiko.SSHClient() ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) # WARNING: Insecure for production! private_key = paramiko.RSAKey.from_private_key_file(private_key_path) ssh_client.connect(hostname=hostname, username=username, pkey=private_key) stdin, stdout, stderr = ssh_client.exec_command(command) output = stdout.read().decode('utf-8') error = stderr.read().decode('utf-8') ssh_client.close() return output, error except Exception as e: return None, str(e) if __name__ == '__main__': hostname = "your_linux_machine_ip" username = "aiagent" private_key_path = "/path/to/your/private/key" # Replace with the actual path command = "uname -a" # Example command output, error = execute_command(hostname, username, private_key_path, command) if output: print("Output:\n", output) if error: print("Error:\n", error) ``` **Important Notes about the SSH Example:** * **`paramiko.AutoAddPolicy()` is insecure for production.** It automatically adds the server's host key to the `known_hosts` file. In a production environment, you should verify the server's host key manually. * **Store the `private_key_path` securely.** Do not hardcode it in the code. Use environment variables or a secrets management system. * **Error Handling:** The example includes basic error handling, but you should implement more robust error handling in a production environment. * **Security Best Practices:** Always follow security best practices when working with SSH keys. Protect your private key. **Example: Using a REST API** * **Linux Machine (Python/Flask example):** ```python from flask import Flask, request, jsonify import subprocess import os app = Flask(__name__) API_KEY = os.environ.get("AI_AGENT_API_KEY") # Get API key from environment variable def check_api_key(api_key): return api_key == API_KEY @app.route('/execute', methods=['POST']) def execute_command(): api_key = request.headers.get('X-API-Key') if not check_api_key(api_key): return jsonify({'error': 'Invalid API key'}), 401 data = request.get_json() command = data.get('command') if not command: return jsonify({'error': 'Command is required'}), 400 try: result = subprocess.run(command, shell=True, capture_output=True, text=True, timeout=10) # Add timeout return jsonify({ 'output': result.stdout, 'error': result.stderr, 'returncode': result.returncode }) except subprocess.TimeoutExpired: return jsonify({'error': 'Command timed out'}), 504 except Exception as e: return jsonify({'error': str(e)}), 500 if __name__ == '__main__': app.run(debug=False, host='0.0.0.0', port=5000) ``` * **Install Flask:** `pip install Flask` * **Set the API key:** `export AI_AGENT_API_KEY="your_secure_api_key"` (or set it in your system's environment variables) * **Run the Flask app:** `python your_flask_app.py` * **AI Agent (Python example using `requests`):** ```python import requests import os def execute_remote_command(hostname, command): api_key = os.environ.get("AI_AGENT_API_KEY") if not api_key: print("Error: AI_AGENT_API_KEY environment variable not set.") return None, None url = f"http://{hostname}:5000/execute" # Replace with your API endpoint headers = {'Content-Type': 'application/json', 'X-API-Key': api_key} data = {'command': command} try: response = requests.post(url, headers=headers, json=data, timeout=5) # Add timeout response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) result = response.json() return result.get('output'), result.get('error') except requests.exceptions.RequestException as e: print(f"Request error: {e}") return None, str(e) if __name__ == '__main__': hostname = "your_linux_machine_ip" command = "ls -l /tmp" output, error = execute_remote_command(hostname, command) if output: print("Output:\n", output) if error: print("Error:\n", error) ``` * **Install `requests`:** `pip install requests` * **Set the API key:** `export AI_AGENT_API_KEY="your_secure_api_key"` (same as on the Linux machine) **Important Notes about the REST API Example:** * **HTTPS:** **Crucially, use HTTPS in a production environment.** This requires setting up SSL/TLS certificates for your Flask app. Let's Encrypt is a good option for free certificates. * **API Key Security:** Store the API key securely on both the AI agent and the Linux machine. Use environment variables or a secrets management system. * **Input Validation:** The Flask app should validate the `command` input to prevent command injection vulnerabilities. **Do not allow arbitrary commands to be executed.** Whitelist specific commands or use a safe command execution library. * **Error Handling:** The example includes basic error handling, but you should implement more robust error handling in a production environment. * **Timeouts:** The examples include timeouts to prevent commands from running indefinitely. Adjust the timeouts as needed. * **Rate Limiting:** Implement rate limiting on the API endpoint to prevent abuse. * **Logging:** Log all API requests and responses for auditing and troubleshooting. **Vietnamese Translation of Key Concepts** Here's a translation of some of the key concepts into Vietnamese: * **MCP (Management and Configuration Protocol):** Giao thức Quản lý và Cấu hình * **AI Agent:** Tác nhân AI * **Linux Machine:** Máy Linux * **SSH (Secure Shell):** Vỏ bảo mật (SSH) * **REST API:** Giao diện lập trình ứng dụng REST (REST API) * **Authentication:** Xác thực * **Authorization:** Ủy quyền * **Encryption:** Mã hóa * **Firewall:** Tường lửa * **SSH Key:** Khóa SSH * **API Key:** Khóa API * **Username:** Tên người dùng * **Password:** Mật khẩu * **Principle of Least Privilege:** Nguyên tắc đặc quyền tối thiểu * **sudo:** Lệnh sudo (cho phép thực thi lệnh với quyền root) * **Environment Variable:** Biến môi trường * **Secrets Management System:** Hệ thống quản lý bí mật * **Command Injection:** Tấn công chèn lệnh **Choosing the Right Approach** The best approach depends on your specific requirements: * **Simplicity:** SSH is often the simplest option for basic command execution. * **Fine-grained Control:** REST APIs offer the most fine-grained control over what the AI agent can do. * **Performance:** gRPC is a good choice for high-performance communication. * **Asynchronous Communication:** Message queues are useful for asynchronous communication. * **Security:** Security should be a primary consideration in all cases. **Important Considerations for Production Environments** * **Secrets Management:** Use a secrets management system (e.g., HashiCorp Vault, AWS Secrets Manager, Azure Key Vault) to store sensitive information such as passwords, API keys, and SSH private keys. * **Monitoring and Logging:** Implement comprehensive monitoring and logging to track the AI agent's activity and identify potential security issues. * **Regular Security Audits:** Conduct regular security audits to identify and address vulnerabilities. * **Least Privilege:** Always adhere to the principle of least privilege. * **Input Validation:** Thoroughly validate all input from the AI agent to prevent command injection and other vulnerabilities. * **Rate Limiting:** Implement rate limiting to prevent abuse. * **Timeouts:** Use timeouts to prevent commands from running indefinitely. * **Update Regularly:** Keep all software up to date with the latest security patches. Remember to adapt these guidelines to your specific AI agent and MCP implementation. Good luck!

Blind-Audition-MCP

A zero-cost MCP server that forces AI to self-correct code using prompt injection and context isolation.

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.

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.

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.

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.

MCP Node-Notifier Server

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

GPT MCP App - User & Loan Info Tools

An MCP server hosted on AWS Lambda that provides tools for retrieving user profiles and loan details via API Gateway. It enables GPT models to interact with structured user and financial data using the Streamable HTTP transport.

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.

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.

Depfender MCP Server

Enables users to scan software packages for data exfiltration and security threats directly within their IDE across npm, PyPI, Cargo, and Maven ecosystems. This tool helps ensure the safety of project dependencies by identifying potential risks before they are integrated.

Edge TTS MCP

A cross-platform MCP server that enables Claude to speak using Microsoft Edge TTS with support for over 300 voices across 50+ languages. It requires no API keys and allows for customization of speech rate, volume, and pitch.

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.

RPA MCP Server

Provides comprehensive desktop automation capabilities including AI-powered vision, OCR, and mouse/keyboard control via a Spring Boot REST API. It enables users to execute multi-step workflows, manage files, and automate browser interactions.

Google Play Store MCP

Manages Google Play Store listing text through the official Android Publisher API with dry-run-first safety, supporting CLI for humans/CI and MCP tools for agents.

Wuxing Search MCP

A privacy-focused search server built on SearXNG that provides unlimited, multi-source web searching across 100+ engines. It enables AI tools to perform advanced searches with specialized filters for time, language, and content categories without API costs or rate limits.

Axiom-hub

Persistent decision memory and contradiction detection for AI coding agents. Enforces architectural consistency across sessions — the agent cannot code until it loads prior decisions. Human resolves conflicts on a dashboard or in chat.

Chainlink MCP Server

Enables interaction with Chainlink's decentralized oracle network, providing access to real-time price feeds, serverless functions, smart contract automation, verifiable randomness, cross-chain messaging, and proof of reserve across multiple blockchain networks.

Diff MCP Server

Enables Claude to compare text strings for exact equality and display detailed line-by-line differences with flexible options to ignore whitespace, case, or line ending variations.

QuickBooks Online MCP Server by CData

QuickBooks Online MCP Server by CData