System Health

What is MCP System Health Monitoring?

MCP System Health Monitoring is a server monitoring system built on the Multi-Channel Protocol (MCP) framework. It provides real-time health and performance metrics for remote Linux servers by establishing SSH connections to collect various system metrics.

How to use MCP System Health Monitoring?

Installation: Clone the repository, create and activate a virtual environment, then install dependencies using pip install -r requirements.txt.
Configuration: Create a JSON configuration file for each server you want to monitor, specifying hostname, IP, SSH port, username, and key path. Alternatively, use the command-line launcher to dynamically create configurations.
Usage: Launch the system using the mcp_launcher.py script with command-line options for username, password/key-path, SSH port, and server IPs. It can also be used as a library by configuring server details and calling the serve function.
Integration with MCP Clients: For integration with AI assistants like Claude, add the server configuration to the client's MCP settings, specifying the command, arguments, and description.

Key Features of MCP System Health Monitoring

Comprehensive Metrics Collection: Gathers CPU, memory, disk, network, and security metrics.
Real-time Monitoring: Provides live system status checks and performance insights.
Multi-Server Support: Allows monitoring of multiple servers from a single MCP instance.
Threshold-based Alerts: Automatically detects critical system conditions based on predefined thresholds for CPU, memory, disk, and security.
SSH Connection Management: Efficiently manages SSH connections with pooling and reuse.
Security-focused: Monitors for failed login attempts, suspicious processes, and security updates.
MCP Integration: Designed for interaction with AI assistants via the MCP protocol.
Available Tools: Exposes tools like system_status, cpu_metrics, memory_metrics, disk_metrics, network_metrics, security_metrics, process_list, system_alerts, and health_summary.

Use Cases of MCP System Health Monitoring

Monitoring the health and performance of multiple remote Linux servers.
Integrating server health data with AI assistants for automated insights and responses.
Proactive identification of potential system issues through threshold-based alerts.
Ensuring security by monitoring for suspicious activities and security updates.

FAQ from MCP System Health Monitoring

Q: What operating systems are supported? A: Currently, it only supports Linux-based servers.

Q: Does it store historical data? A: No, metrics are real-time only and there is no historical data storage.

Q: Does it have a notification system for alerts? A: No, alerts are only available via tool calls and there is no built-in notification system.

Q: Can I customize alert thresholds? A: There is limited customization of alert thresholds.

Q: What are the security considerations? A: It is recommended to prefer key-based authentication, use dedicated monitoring accounts with limited permissions, store SSH credentials securely, and run the MCP server on a secure, trusted host.

Q: How can I troubleshoot issues? A: Ensure SSH credentials are correct, target servers allow SSH connections, the user has sufficient permissions, and enable debug logging for detailed output.

MCP System Health Monitoring

A robust server monitoring system built on the Multi-Channel Protocol (MCP) framework, designed for seamless integration with Claude and other AI assistants.

Overview

MCP System Health Monitoring provides real-time health and performance metrics for remote Linux servers. It establishes SSH connections to collect system metrics including CPU usage, memory utilization, disk space, network statistics, security metrics, and more.

Features

Comprehensive Metrics Collection: CPU, memory, disk, network, security metrics, and more
Real-time Monitoring: Live system status checks and performance insights
Multi-Server Support: Monitor multiple servers from a single MCP instance
Threshold-based Alerts: Automatic detection of critical system conditions
SSH Connection Management: Efficient connection pooling and reuse
Security-focused: Monitor for failed login attempts, suspicious processes, and security updates
MCP Integration: Ready for AI assistant interaction via the MCP protocol

Requirements

Python 3.10+
MCP Python SDK
SSH access to target servers

Installation

Clone the repository:

git clone https://github.com/yourusername/mcp-system-health.git
cd mcp-system-health

Create a virtual environment:
```
python -m venv venv
```
Activate the virtual environment
- On macOS/Linux:
```
source venv/bin/activate
```
- On Windows:
```
venv\Scripts\activate
```
Install dependencies:
```
pip install -r requirements.txt
```

Configuration

Create a configuration file for each server you want to monitor:

{
  "hostname": "server1",
  "ip": "192.168.1.100",
  "ssh_port": 22,
  "username": "admin",
  "key_path": "~/.ssh/id_rsa"
}

Alternatively, you can use the command-line launcher to dynamically create configurations.

Usage

Using the Launcher

./mcp_launcher.py --username=admin --key-path=~/.ssh/id_rsa --servers=192.168.1.100,192.168.1.101

Command-line Options

--username: SSH username (required)
--password: SSH password (either this or key-path required)
--key-path: Path to SSH private key (either this or password required)
--ssh-port: SSH port (default: 22)
--servers: Comma-separated list of server IPs (required)
--repository: Path to existing server repository
--log-level: Logging level (debug, info, warning, error)

Integration with MCP Clients

To use the MCP System Health server with MCP clients like Claude, you'll need to add the server configuration to your client's MCP settings.

Claude Integration

Add this configuration to Claude's MCP settings and restart for changes to take effect: You can use either password or key_path

{
  "mcpServers": {
    "system-health": {
      "command": "/path/to/your/venv/bin/python3",
      "args": [
        "/path/to/your/system-health-mcp-server/src/mcp_launcher.py", 
        "--username=your_ssh_username", 
        "--password=your_ssh_password",
        "--key-path=~/.ssh/id_rsa",
        "--servers=server1.example.com,server2.example.com", 
        "--log-level=debug"
      ],
      "description": "System Health MCP Server for monitoring remote servers"
    }
  }
}

#Using as a Library
#Configure your servers, you can use either password or key_path
from src.server import serve

server_configs = [
    {
        "hostname": "server1",
        "ip": "192.168.1.100",
        "ssh_port": 22,
        "username": "admin",
        "password": "password",
        "key_path": "~/.ssh/id_rsa"
    }
]

#Start the MCP server
await serve(server_configs)

Available Tools

The MCP server exposes the following tools:

system_status: General system status information
cpu_metrics: Detailed CPU metrics
memory_metrics: Memory usage and swap statistics
disk_metrics: Disk usage for all or specific mount points
network_metrics: Network interface statistics
security_metrics: Security-related metrics
process_list: List of top CPU-consuming processes
system_alerts: Current alerts based on threshold violations
health_summary: Comprehensive health summary

Alert Thresholds

The system provides automatic alerts based on these default thresholds:

CPU:
- Critical: Usage ≥ 90%
- Warning: Usage ≥ 80%
- Warning: Load average > 1.5 × core count
- Warning: I/O wait > 20%
Memory:
- Critical: Usage ≥ 95%
- Warning: Usage ≥ 85%
- Warning: Swap usage ≥ 80%
- Warning: Free memory < 1GB (on systems with ≥ 2GB)
Disk:
- Critical: Usage ≥ 95%
- Warning: Usage ≥ 85%
- Warning: Free space < 1GB (on disks ≥ 10GB)
- Warning: Inode usage ≥ 90%
- Warning: Disk I/O utilization > 80%
Security:
- Warning: Failed logins > 10
- Critical: Security updates > 5
- Warning: Security updates ≥ 1
- Warning: System not updated for ≥ 30 days
- Critical: Suspicious processes detected
- Warning: Unusual ports open

Security Considerations

Prefer key-based authentication over password authentication
Use dedicated monitoring accounts with limited permissions
Store SSH credentials securely
Run the MCP server on a secure, trusted host

Limitations

Currently only supports Linux-based servers
No historical data storage (metrics are real-time only)
No notification system for alerts (alerts are only available via tool calls)
Limited customization of alert thresholds

Troubleshooting

Ensure SSH credentials are correct
Check that target servers allow SSH connections
Verify that the user has sufficient permissions to execute system commands
Enable debug logging for more detailed output

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

MIT License

System Health Overview