mcpField
P
Performance Co-Pilot

Performance Co-Pilot

Local
github.com/majorData & Analytics0Updated 29w ago

About Performance Co-Pilot

Performance Co-Pilot is an MCP server for querying system performance metrics from PCP. It serves operators monitoring local or remote hosts, with tools for snapshots, process rankings, metric queries, discovery, and descriptions.

Key features

  1. 01Get CPU, memory, disk, and network snapshots
  2. 02Rank processes by CPU, memory, or I/O
  3. 03Query current PCP metric values
  4. 04Search available metrics by pattern
  5. 05Retrieve metric metadata

Use cases

  1. 01Investigate system performance bottlenecks
  2. 02Check production server health
  3. 03Find processes with high resource use
  4. 04Review metrics for capacity planning

MCP support

Exposes PCP metrics to MCP clients through tools for system snapshots, process rankings, metric queries, metric search, and metric descriptions. It connects to pmproxy and can target a remote pmcd host.

Configuration

Local server config is the same for every client. Copy it into your client’s MCP config file.

mcp.json · Universal config
{
"mcpServers": {
"major-pcp": {
"command": "uvx",
"args": [
"pcp-mcp"
],
"env": {
"PCP_HOST": "<PCP_HOST>",
"PCP_PORT": "<PCP_PORT>",
"PCP_TARGET_HOST": "<PCP_TARGET_HOST>"
}
}
}
}
Run commanduvx pcp-mcp
Environment variables to set
PCP_HOSTpmproxy host
PCP_PORTpmproxy port
PCP_TARGET_HOSTTarget pmcd host to monitor

Local servers need a runtime on your machine (e.g. Node.js 18+). Config file locations differ by client; see your client’s docs.

Packages
pypipcp-mcp1.5.1

Tools

No tool list yet

Local servers expose tools only once running on your machine, and the maintainer has not provided a tool list.

Details

From the project README

pcp-mcp

MCP server for Performance Co-Pilot (PCP) metrics.

Query system performance metrics via the Model Context Protocol - CPU, memory, disk I/O, network, processes, and more.

📖 Full Documentation | 🚀 Getting Started

CI codecov PyPI version Python 3.10+ License: MIT

🚀 Quick Start (No Install)

Run immediately with uvx — no installation required:

uvx pcp-mcp

Or install as a persistent global tool:

uvx tool install pcp-mcp
pcp-mcp

📦 Installation

pip install pcp-mcp

Or with uv:

uv add pcp-mcp

📋 Requirements

  • Python: 3.10+
  • PCP: Performance Co-Pilot with pmcd and pmproxy running
    # Fedora/RHEL/CentOS
    sudo dnf install pcp
    sudo systemctl enable --now pmcd pmproxy
    
    # Ubuntu/Debian
    sudo apt install pcp
    sudo systemctl enable --now pmcd pmproxy
    

⚙️ Configuration

Configure via environment variables:

VariableDescriptionDefault
PCP_HOSTpmproxy hostlocalhost
PCP_PORTpmproxy port44322
PCP_TARGET_HOSTTarget pmcd host to monitorlocalhost
PCP_USE_TLSUse HTTPS for pmproxyfalse
PCP_TLS_VERIFYVerify TLS certificatestrue
PCP_TLS_CA_BUNDLEPath to custom CA bundle(optional)
PCP_TIMEOUTRequest timeout (seconds)30
PCP_USERNAMEHTTP basic auth user(optional)
PCP_PASSWORDHTTP basic auth password(optional)
PCP_ALLOWED_HOSTSHostspecs allowed via host param(optional)

🎯 Usage

Monitor localhost (default)
pcp-mcp
Monitor a remote host
PCP_TARGET_HOST=webserver1.example.com pcp-mcp

Or use the CLI flag:

pcp-mcp --target-host webserver1.example.com
Connect to remote pmproxy
PCP_HOST=metrics.example.com pcp-mcp
Use SSE transport
pcp-mcp --transport sse

🔌 MCP Client Configuration

Claude Desktop

Add to ~/.config/claude/claude_desktop_config.json:

{
  "mcpServers": {
    "pcp": {
      "command": "uvx",
      "args": ["pcp-mcp"]
    }
  }
}

For remote monitoring:

{
  "mcpServers": {
    "pcp": {
      "command": "uvx",
      "args": ["pcp-mcp", "--target-host", "webserver1.example.com"]
    }
  }
}

💡 Using uvx means you don't need pcp-mcp installed — it runs directly from PyPI.

🛠️ Available Tools

System Monitoring
  • get_system_snapshot - Point-in-time system overview (CPU, memory, disk, network, load)
  • get_process_top - Top processes by CPU, memory, or I/O usage
  • query_metrics - Fetch current values for specific PCP metrics
  • search_metrics - Discover available metrics by name pattern
  • describe_metric - Get detailed metadata about a metric
Example Queries
"What's the current CPU usage?"
→ Uses get_system_snapshot

"Show me the top 10 processes by memory usage"
→ Uses get_process_top(sort_by="memory", limit=10)

"What metrics are available for network traffic?"
→ Uses search_metrics(pattern="network")

"Get detailed info about kernel.all.load"
→ Uses describe_metric(name="kernel.all.load")

💡 Use Cases

Performance Troubleshooting

Ask Claude to:

  • "Analyze current system performance and identify bottlenecks"
  • "Why is my disk I/O so high?"
  • "Which processes are consuming the most CPU?"
System Monitoring
  • "Give me a health check of the production server"
  • "Compare CPU usage over the last minute"
  • "Monitor network traffic on eth0"
Capacity Planning
  • "What's the memory utilization trend?"
  • "Show me disk usage across all filesystems"
  • "Analyze process resource consumption patterns"

🏗️ Architecture

┌─────────┐         ┌─────────┐          ┌─────────┐         ┌─────────┐
│   LLM   │ ◄─MCP─► │ pcp-mcp │ ◄─HTTP─► │ pmproxy │ ◄─────► │  pmcd   │
└─────────┘         └─────────┘          └─────────┘         └─────────┘
                                         (REST API)          (metrics)
  • pcp-mcp: FastMCP server exposing PCP metrics via MCP tools
  • pmproxy: PCP's REST API server (runs on port 44322 by default)
  • pmcd: PCP metrics collector daemon
  • Remote monitoring: Set PCP_TARGET_HOST to query a different pmcd instance via pmproxy

🔧 Development

# Install dependencies
uv sync --dev

# Run all checks
make check

# Individual commands
make lint       # ruff check
make format     # ruff format
make typecheck  # ty check
make test       # pytest with coverage

📖 Documentation

Full documentation at https://major.github.io/pcp-mcp

📄 License

MIT

Comments

Markdown supported

New to MCP?

From what the protocol is to installing your first server, these answers cover most first questions.

An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.