User:
"Get me the prices of iPhone 17 from these 5 websites."

    ↓

Claude:
"I need a scraping tool."

    ↓ (MCP)

Apify MCP Server
└─ scrape_website(url) //tool-1
└─ extract_product_data(...) //tool-2

    ↓

Returns structured data

    ↓

Claude: understands data and show
"Here are the prices across the websites..."

mkdir ~/mcp-stats
cd ~/mcp-stats
python3 -m venv venv
source venv/bin/activate
pip install "mcp[cli]" psutil

import psutil #cross-platform system stats (CPU, RAM, disk, network, processes)
import platform
import time
from datetime import timedelta
from mcp.server.fastmcp import FastMCP

#This creates the server instance named "local-stats" — the name Claude uses
#to identify it in the MCP config.
mcp = FastMCP("local-stats")



#@mcp.tool()
#Decorating any function with @mcp.tool() registers it as a callable tool that
#Claude can invoke. FastMCP automatically:

#Reads the function name → becomes the tool name
#Reads the docstring → becomes the description Claude uses to decide when to call it
#Reads the type hints → generates the JSON schema for inputs/outputs 

@mcp.tool()
def get_cpu_usage() -> dict:
    """Get current CPU usage across all cores."""
    per_core = psutil.cpu_percent(interval=1, percpu=True)
    overall = round(sum(per_core) / len(per_core), 1)
    freq = psutil.cpu_freq()
    return {
        "overall_percent": overall,
        "per_core_percent": per_core,
        "core_count": psutil.cpu_count(),
        "frequency_mhz": round(freq.current, 1) if freq else None,
    }


@mcp.tool()
def get_memory_usage() -> dict:
    """Get RAM and swap memory usage."""
    ram = psutil.virtual_memory()
    swap = psutil.swap_memory()
    return {
        "ram": {
            "total_gb": round(ram.total / 1e9, 2),
            "used_gb": round(ram.used / 1e9, 2),
            "free_gb": round(ram.available / 1e9, 2),
            "percent_used": ram.percent,
        },
        "swap": {
            "total_gb": round(swap.total / 1e9, 2),
            "used_gb": round(swap.used / 1e9, 2),
            "percent_used": swap.percent,
        },
    }


@mcp.tool()
def get_disk_usage() -> list:
    """Get disk usage for all mounted partitions."""
    results = []
    for part in psutil.disk_partitions():
        try:
            usage = psutil.disk_usage(part.mountpoint)
            results.append({
                "mountpoint": part.mountpoint,
                "device": part.device,
                "total_gb": round(usage.total / 1e9, 2),
                "used_gb": round(usage.used / 1e9, 2),
                "free_gb": round(usage.free / 1e9, 2),
                "percent_used": usage.percent,
            })
        except PermissionError:
            pass
    return results


@mcp.tool()
def get_network_stats() -> dict:
    """Get cumulative network I/O statistics since last boot."""
    net = psutil.net_io_counters()
    return {
        "bytes_sent_mb": round(net.bytes_sent / 1e6, 2),
        "bytes_recv_mb": round(net.bytes_recv / 1e6, 2),
        "packets_sent": net.packets_sent,
        "packets_recv": net.packets_recv,
    }


@mcp.tool()
def get_top_processes(limit: int = 10, sort_by: str = "cpu") -> list:
    """
    Get top processes sorted by resource usage.
    sort_by: 'cpu' or 'memory'
    limit: number of processes to return (default 10)
    """
    procs = []
    for p in psutil.process_iter(["pid", "name", "cpu_percent", "memory_percent", "status"]):
        try:
            procs.append(p.info)
        except (psutil.NoSuchProcess, psutil.AccessDenied):
            pass
    key = "cpu_percent" if sort_by == "cpu" else "memory_percent"
    return sorted(procs, key=lambda x: x.get(key) or 0, reverse=True)[:limit]


@mcp.tool()
def get_system_info() -> dict:
    """Get general system information: OS, uptime, hostname, load averages."""
    boot_time = psutil.boot_time()
    uptime_seconds = time.time() - boot_time
    uptime = str(timedelta(seconds=int(uptime_seconds)))
    load = psutil.getloadavg()
    return {
        "hostname": platform.node(),
        "os": f"{platform.system()} {platform.release()}",
        "architecture": platform.machine(),
        "python_version": platform.python_version(),
        "uptime": uptime,
        "load_avg_1_5_15": [round(x, 2) for x in load],
        "cpu_count": psutil.cpu_count(),
    }


if __name__ == "__main__":
    mcp.run()  # stdio transport by default — Claude Code manages the process

claude mcp add --scope user local-stats -- python3 /home/YOUR_USERNAME/{path_to_your_mcp_server}/mcp-stats/server.py

claude #press enter on "I trust this folder"
/mcp  #this will list connected MCPs