How do I use MacOS Resource Monitor MCP Server?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@MacOS Resource Monitor MCP Server What processes are using the most CPU?" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

MacOS Resource Monitor MCP Server

by Pratyay

Overview Schema Related Servers Score Discussions

Python

Local

MacOS Resource Monitor MCP Server

Trust Score

A Model Context Protocol (MCP) server that identifies resource-intensive processes on macOS across CPU, memory, and network usage.

Hosted deployment

A hosted deployment is available on Fronteir AI.

Related MCP server: System Information MCP Server

Overview

MacOS Resource Monitor is a lightweight MCP server that exposes an MCP endpoint for monitoring system resources. It analyzes CPU, memory, and network usage, and identifies the most resource-intensive processes on your Mac, returning data in a structured JSON format.

Requirements

macOS operating system
Python 3.10+
MCP server library

Installation

Option 1: Global Installation (Recommended)

Install the MCP server globally using uv for system-wide access:

git clone https://github.com/Pratyay/mac-monitor-mcp.git
cd mac-monitor-mcp
uv tool install .

Now you can run the server from anywhere:

mac-monitor

Option 2: Development Installation

Clone this repository:

git clone https://github.com/Pratyay/mac-monitor-mcp.git
cd mac-monitor-mcp

Create a virtual environment (recommended):

python -m venv venv
source venv/bin/activate

Install the required dependencies:
```
pip install mcp
```

Usage

Global Installation

If you installed globally with uv:

mac-monitor

Development Installation

If you're running from the project directory:

python src/mac_monitor/monitor.py

Or using uv run (from project directory):

uv run mac-monitor

You should see the message:

Simple MacOS Resource Monitor MCP server starting...
Monitoring CPU, Memory, and Network resource usage...

The server will start and expose the MCP endpoint, which can be accessed by an LLM or other client.

Available Tools

The server exposes three tools:

1. `get_resource_intensive_processes()`

Returns information about the top 5 most resource-intensive processes in each category (CPU, memory, and network).

2. `get_processes_by_category(process_type, page=1, page_size=10, sort_by="auto", sort_order="desc")`

Returns all processes in a specific category with advanced filtering, pagination, and sorting options.

Parameters:

process_type: "cpu", "memory", or "network"
page: Page number (starting from 1, default: 1)
page_size: Number of processes per page (default: 10, max: 100)
sort_by: Sort field - "auto" (default metric), "pid", "command", or category-specific fields:
- CPU: "cpu_percent", "pid", "command"
- Memory: "memory_percent", "resident_memory_kb", "pid", "command"
- Network: "network_connections", "pid", "command"
sort_order: "desc" (default) or "asc"

Example Usage:

# Get first page of CPU processes (default: sorted by CPU% descending)
get_processes_by_category("cpu")

# Get memory processes sorted by resident memory, highest first
get_processes_by_category("memory", sort_by="resident_memory_kb", sort_order="desc")

# Get network processes sorted by command name A-Z, page 2
get_processes_by_category("network", page=2, sort_by="command", sort_order="asc")

# Get 20 CPU processes per page, sorted by PID ascending
get_processes_by_category("cpu", page_size=20, sort_by="pid", sort_order="asc")

3. `get_system_overview()`

Returns comprehensive system overview with aggregate statistics similar to Activity Monitor. Provides CPU, memory, disk, network statistics, and intelligent performance analysis to help identify bottlenecks and optimization opportunities.

Features:

CPU Metrics: Usage percentages, load averages, core count
Memory Analysis: Total/used/free memory with percentages
Disk Statistics: Storage usage across all filesystems
Network Overview: Active connections, interface statistics
Performance Analysis: Intelligent bottleneck detection and recommendations
System Information: macOS version, uptime, process count

Example Usage:

 get_system_overview()  # Get comprehensive system overview

Use Cases:

System performance monitoring and analysis
Identifying performance bottlenecks and slowdowns
Resource usage trending and capacity planning
Troubleshooting system performance issues
Getting quick system health overview

Sample Output

`get_resource_intensive_processes()` Output

{
  "cpu_intensive_processes": [
    {
      "pid": "1234",
      "cpu_percent": 45.2,
      "command": "firefox"
    },
    {
      "pid": "5678",
      "cpu_percent": 32.1,
      "command": "Chrome"
    }
  ],
  "memory_intensive_processes": [
    {
      "pid": "1234",
      "memory_percent": 8.5,
      "resident_memory_kb": 1048576,
      "command": "firefox"
    },
    {
      "pid": "8901",
      "memory_percent": 6.2,
      "resident_memory_kb": 768432,
      "command": "Docker"
    }
  ],
  "network_intensive_processes": [
    {
      "command": "Dropbox",
      "network_connections": 12
    },
    {
      "command": "Spotify",
      "network_connections": 8
    }
  ]
}

`get_processes_by_category()` Output

{
  "process_type": "cpu",
  "processes": [
    {
      "pid": "1234",
      "cpu_percent": 45.2,
      "command": "firefox"
    },
    {
      "pid": "5678",
      "cpu_percent": 32.1,
      "command": "Chrome"
    }
  ],
  "sorting": {
    "sort_by": "cpu_percent",
    "sort_order": "desc",
    "requested_sort_by": "auto"
  },
  "pagination": {
    "current_page": 1,
    "page_size": 10,
    "total_processes": 156,
    "total_pages": 16,
    "has_next_page": true,
    "has_previous_page": false
  }
}

How It Works

The MacOS Resource Monitor uses built-in macOS command-line utilities:

ps: To identify top CPU and memory consuming processes
lsof: To monitor network connections and identify network-intensive processes

Data is collected when the tool is invoked, providing a real-time snapshot of system resource usage.

Integration with LLMs

This MCP server is designed to work with Large Language Models (LLMs) that support the Model Context Protocol. The LLM can use the get_resource_intensive_processes tool to access system resource information and provide intelligent analysis.

Contributing

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

Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add some amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

Management Commands

If you installed the server globally with uv:

List installed tools: uv tool list
Uninstall: uv tool uninstall mac-monitor
Upgrade: uv tool install --force . (from project directory)
Install from Git: uv tool install git+https://github.com/Pratyay/mac-monitor-mcp.git

Recent Updates

Version 0.2.0 (Latest)

✅ Added get_processes_by_category() tool with pagination and sorting
✅ Added comprehensive sorting options (CPU%, memory, PID, command name)
✅ Added proper Python packaging with pyproject.toml
✅ Added global installation support via uv tool install
✅ Enhanced error handling and input validation
✅ Added pagination metadata with navigation information

Potential Improvements

Here are some ways you could enhance this monitor:

Add disk I/O monitoring
Improve network usage monitoring to include bandwidth
Add visualization capabilities
Extend compatibility to other operating systems
Add process filtering by resource thresholds
Add historical data tracking and trends

Available Tools

3 tools

get_processes_by_categoryA

Get all processes filtered by category (cpu, memory, network) with pagination and sorting support.

Args: process_type: Type of processes to retrieve ('cpu', 'memory', or 'network') page: Page number (starting from 1, default: 1)
page_size: Number of processes per page (default: 10, max: 100) sort_by: Sort field - 'auto' (default metric), 'pid', 'command', or metric-specific fields CPU: 'auto'/'cpu_percent', 'pid', 'command' Memory: 'auto'/'memory_percent', 'resident_memory_kb', 'pid', 'command'
Network: 'auto'/'network_connections', 'pid', 'command' sort_order: Sort direction - 'desc' (default) or 'asc'

Returns: JSON string containing paginated and sorted process information for the specified category

ParametersJSON Schema

Name	Required	Default
`process_type`	Yes
`page`	No
`page_size`	No
`sort_by`	No	auto
`sort_order`	No	desc

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.2/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description fully carries the burden of behavioral disclosure. It accurately describes the operation as read-only (getting processes), includes pagination (page, page_size with defaults and max), sorting (sort_by, sort_order), and return format (JSON string). It does not mention destructive actions, auth, or rate limits, which is acceptable for a read tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is structured with Args and Returns, and the main purpose is front-loaded. It is somewhat long but every sentence adds value (defaults, categories, sort details). Minor redundancy: 'JSON string containing paginated and sorted process information' could be condensed, but overall efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 5 parameters (1 required), no annotations, and an existing output schema, the description covers all parameter semantics, defaults, return format, and behavioral constraints (max page size). It lacks edge cases (e.g., empty results, error handling), but completeness is high for a paginated list tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description provides all parameter details. It explains process_type values ('cpu', 'memory', 'network'), page defaults, page_size max, sort_by options with per-category specifics, and sort_order choices. This adds significant meaning beyond the schema's titles and types.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Get all processes filtered by category (cpu, memory, network) with pagination and sorting support.' It uses a specific verb ('Get') and resource ('processes'), and the categories distinguish it from siblings like 'get_resource_intensive_processes' and 'get_system_overview'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage (processes by category) but does not explicitly state when to use this tool versus siblings. It mentions 'filtered by category' but provides no guidance on alternatives (e.g., 'use get_resource_intensive_processes for high-usage processes'). Sibling tools are listed but not compared.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_resource_intensive_processesA

Identify resource-intensive processes on macOS across CPU, memory, and network.

Returns: A string containing information about resource-intensive processes, which can be analyzed to provide optimization suggestions.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It only mentions the return type (string) and potential analysis, lacking details on performance impact, privileges, or whether it's a snapshot.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is three sentences, front-loaded with the main action, and contains no unnecessary information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple no-parameter tool with an output schema, the description covers the basic purpose and return. Minor gaps: no format specifics or examples, and sibling differentiation could be stronger.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

There are no parameters, and schema coverage is 100%. The description adds no parameter semantics because none exist, achieving the baseline of 4.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it identifies resource-intensive processes on macOS across CPU, memory, and network, differentiating it from sibling tools like 'get_processes_by_category' and 'get_system_overview'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The tool's purpose is clear, but it does not explicitly state when to use it versus alternatives. The sibling names imply differentiation, but no direct guidance is provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_system_overviewA

Get comprehensive system overview with aggregate statistics similar to Activity Monitor. Provides CPU, memory, disk, network statistics, and performance analysis to help identify bottlenecks and optimization opportunities.

Returns: JSON string containing system overview with performance metrics and analysis

ParametersJSON Schema

Name	Required	Description	Default
No parameters

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A3.8/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It only states what it returns (JSON with metrics) but does not disclose behavioral traits like read-only nature, permission requirements, or potential performance impact. Lacks depth.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, front-loads the main purpose, and includes a return type. Every sentence adds value; no wasted words. Efficient and clear.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given zero parameters and an output schema present, the description adequately explains what the tool does and returns. However, it lacks usage context (when to use vs siblings) and behavioral notes, which would improve completeness for a simple tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters are present (schema coverage 100%), so the baseline is 4. The description does not need to add parameter meaning, but it correctly implies no input needed. No additional value beyond schema is required.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Get comprehensive system overview' and lists specific metrics (CPU, memory, disk, network) and purpose (identify bottlenecks). It differentiates from sibling tools like get_processes_by_category by being a broad overview, not process-specific.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies use for system health checks but does not explicitly state when to use this tool versus alternatives or provide any exclusion criteria. No guidance on prerequisites or context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4.1/5.0

Disambiguation4/5

Tools are generally distinct: one lists processes by category, another identifies intensive ones, and the third gives a system overview. However, there is slight overlap between the first and second, as both deal with processes, but their purposes differ (listing vs. highlighting intensive ones).

Naming Consistency5/5

All tool names follow a consistent pattern: verb_noun (get_*) with descriptive suffixes. The snake_case style is uniform, making the set predictable and easy to use.

Tool Count5/5

Three tools is well-scoped for a resource monitor. Each tool serves a clear, non-redundant purpose, covering per-category listings, intensive process detection, and system overview without being excessive.

Completeness4/5

The tool set covers the core monitoring needs: CPU, memory, network, disk, and performance analysis. Minor gaps exist, such as no tool for querying a single process by PID or filtering across all categories in one call, but these are not critical for the stated purpose.

Maintenance

ActivityInactive

ResponsivenessNo issues

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

New Relic MCP Server
io.github.newrelic-partners
Monitor, troubleshoot, and optimize your technology stack with Intelligent Observability.
Observability Monitoring
2
mcp A
com.googleapis.monitoring
Gain visibility into the performance, availability, and health of your apps and infrastructure.
Monitoring Observability
92
Netdata
io.github.netdata
Real-time infrastructure monitoring with metrics, logs, alerts, and ML-based anomaly detection.
Monitoring Observability
277,495
PGAuditor
com.mcpgatepro
Hosted MCP server for PostgreSQL diagnostics: slow queries, missing indexes, connection pressure.
Databases Monitoring Observability
1

Related MCP Servers

macOS Tools MCP Server
Monitoring File Systems OS Automation
tornikegomareli
A
license
B
quality
D
maintenance
Provides advanced system monitoring and file search capabilities for macOS, allowing users to track performance metrics and perform enhanced file searches with content analysis and tagging features.
Updated a year ago (2025-08-02 21:48 UTC)
2
27
24
MIT
System Information MCP Server
OS Automation Monitoring Developer Tools
ai-mcp-garage
A
license
A
quality
Not graded
maintenance
Provides comprehensive system diagnostics and hardware analysis through 10 specialized tools for troubleshooting and environment monitoring. Offers targeted information gathering for CPU, memory, network, storage, processes, and security analysis across Windows, macOS, and Linux platforms.
Updated a year ago (2025-09-06 02:52 UTC)
10
MCProcessMonitor
OS Automation Monitoring Developer Tools
kiralyzoltan98
F
license
Not graded
quality
D
maintenance
Enables AI to monitor and analyze local system processes through custom tools. Provides real-time access to process information including CPU usage, memory consumption, process counts, and process searching capabilities.
Updated a year ago (2025-09-06 08:53 UTC)
System Info MCP Server
Monitoring OS Automation Observability
srirama7
A
license
Not graded
quality
D
maintenance
Enables comprehensive system monitoring and diagnostics through 18 tools that provide detailed information about CPU, memory, disk usage, network interfaces, running processes, battery status, hardware details, and temperature monitoring. Allows users to query system information and performance metrics through natural language interactions.
Updated 10 months ago (2025-10-19 04:59 UTC)
24
ISC

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Pratyay/mac-monitor-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

MacOS Resource Monitor MCP Server

Hosted deployment

Overview

Requirements

Installation

Option 1: Global Installation (Recommended)

Option 2: Development Installation

Usage

Global Installation

Development Installation

Available Tools

1. get_resource_intensive_processes()

2. get_processes_by_category(process_type, page=1, page_size=10, sort_by="auto", sort_order="desc")

3. get_system_overview()

Sample Output

get_resource_intensive_processes() Output

get_processes_by_category() Output

How It Works

Integration with LLMs

Contributing

Management Commands

Recent Updates

Version 0.2.0 (Latest)

Potential Improvements

Available Tools

Output Schema

Output Schema

Output Schema

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

1. `get_resource_intensive_processes()`

2. `get_processes_by_category(process_type, page=1, page_size=10, sort_by="auto", sort_order="desc")`

3. `get_system_overview()`

`get_resource_intensive_processes()` Output

`get_processes_by_category()` Output