# Hardware Telemetry MCP Server (`constant_quadruped/hardware-telemetry-mcp`) Actor Model Context Protocol (MCP) server monitoring CPU, GPU, and memory load metrics. - **URL**: https://apify.com/constant\_quadruped/hardware-telemetry-mcp.md - **Developed by:** [CQ](https://apify.com/constant_quadruped) (community) - **Categories:** Developer tools, Automation, AI - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing Pay per usage This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A". ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md). If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## Hardware Telemetry MCP Server A [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) server that exposes **real system resource telemetry** of the machine it runs on. It speaks newline-delimited JSON-RPC 2.0 over stdio and provides a single tool, `get_system_stats`. All values are measured at request time from the Node.js built-in [`os`](https://nodejs.org/api/os.html) module. Nothing is randomized, hardcoded, or mocked. > **Note on temperature.** This Actor does **not** report CPU/GPU temperature. There is no portable way to read true hardware thermal sensors from pure Node.js, and the Apify container does not expose any thermal sensors. Rather than fabricate a number, temperature is intentionally omitted. The fields reported below are the ones the OS can measure truthfully. --- ### What it does - Runs as an MCP server over **stdio** (newline-delimited JSON-RPC 2.0). - Implements the standard MCP methods `initialize`, `tools/list`, and `tools/call`. - Exposes one tool, **`get_system_stats`**, which reads live host metrics. - Optional **one-shot mode**: if an `query` input is provided, it runs a single request, prints the JSON-RPC response, and saves it to the default key-value store as `OUTPUT`, then exits cleanly. It does **not** call any external network/API, and it does **not** require any credentials or API keys. --- ### Input | Field | Type | Required | Default | Description | |-------|------|----------|---------|-------------| | `query` | string | No | `""` (empty) | Optional one-shot command. May be a **bare tool name** (e.g. `get_system_stats`) or a **raw JSON-RPC line** (e.g. `{"jsonrpc":"2.0","id":1,"method":"tools/list"}`). If empty, the Actor starts as a long-lived MCP stdio server and reads JSON-RPC requests from standard input. | Example input (one-shot): ```json { "query": "get_system_stats" } ```` *** ### Output #### `get_system_stats` payload The tool returns a JSON object (inside the MCP `tools/call` result `content`) with these fields, all measured live: | Field | Type | Source / meaning | |-------|------|------------------| | `cpuModel` | string | CPU model string (`os.cpus()[0].model`) | | `cpuCount` | number | Number of logical CPUs (`os.cpus().length`) | | `cpuSpeedMhz` | number|null | Reported clock speed in MHz | | `cpuLoadPercent` | number | CPU utilization %, computed from idle/total time deltas over a ~250 ms sample | | `loadAverage` | number\[] | `[1m, 5m, 15m]` load average (`os.loadavg()`). **Returns `[0,0,0]` on Windows** — the OS does not provide it there | | `memoryTotalBytes` | number | Total physical memory (`os.totalmem()`) | | `memoryUsedBytes` | number | `totalmem - freemem` | | `memoryFreeBytes` | number | Free physical memory (`os.freemem()`) | | `memoryUsagePercent` | number | `used / total * 100`, one decimal | | `uptimeSeconds` | number | System uptime in seconds (`os.uptime()`) | | `platform` | string | `os.platform()` (e.g. `linux`, `win32`) | | `arch` | string | `os.arch()` (e.g. `x64`) | | `timestamp` | string | ISO 8601 reading time | When run with a `query` input, the full JSON-RPC response is also written to the default key-value store under the key **`OUTPUT`**. Example response: ```json { "jsonrpc": "2.0", "id": 1, "result": { "content": [ { "type": "text", "text": "{\"cpuModel\":\"Intel(R) Core(TM) i5-9400F CPU @ 2.90GHz\",\"cpuCount\":6,\"cpuSpeedMhz\":2904,\"cpuLoadPercent\":12.4,\"loadAverage\":[0,0,0],\"memoryTotalBytes\":68632096768,\"memoryUsedBytes\":38730981376,\"memoryFreeBytes\":29901115392,\"memoryUsagePercent\":56.4,\"uptimeSeconds\":384100,\"platform\":\"linux\",\"arch\":\"x64\",\"timestamp\":\"2026-06-24T11:35:32.088Z\"}" } ] } } ``` *** ### Authentication / setup **None required.** No API keys, no external services. The Actor only reads metrics of the host it runs on. *** ### Usage #### As a one-shot Actor run (Apify) Set the input and run: ```json { "query": "get_system_stats" } ``` The JSON-RPC response is printed to the log and saved to the key-value store as `OUTPUT`. #### As an MCP server (stdio) Leave `query` empty / unset and pipe JSON-RPC requests to stdin, one per line: ```bash printf '%s\n%s\n' \ '{"jsonrpc":"2.0","id":1,"method":"initialize"}' \ '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"get_system_stats"}}' \ | npm start ``` #### Run locally ```bash npm install echo '{"query":"get_system_stats"}' # set as INPUT, or run as a server (see above) npm start ``` *** ### Supported MCP methods | Method | Behavior | |--------|----------| | `initialize` | Returns protocol version `2024-11-05`, `capabilities.tools`, and server info | | `tools/list` | Lists the single `get_system_stats` tool | | `tools/call` | Executes `get_system_stats`; unknown tools return JSON-RPC error `-32601` | | (other) | Returns JSON-RPC error `-32601` (method not found) | Malformed input lines return a JSON-RPC parse error (`-32700`) instead of crashing. *** ### Limitations - **No temperature.** CPU/GPU thermal data is not reported (no sensor access in the runtime — see note above). - **What you measure is the runtime host.** On the Apify platform, the metrics describe the Actor's container/VM, not your local machine. - **`loadAverage` is `[0,0,0]` on Windows** (OS limitation). - **`cpuLoadPercent` is sampled over ~250 ms**, so it reflects the load during that short window, not a long-term average. - Single tool only (`get_system_stats`). No GPU-specific metrics, no per-process stats, no disk/network I/O metrics. *** ### License Provided as-is. See the actor listing for details. # Actor input Schema ## `query` (type: `string`): MCP Command query ## Actor input object example ```json { "query": "" } ``` # Actor output Schema ## `telemetry` (type: `string`): JSON-RPC response saved as OUTPUT when run with a query input. The inner tool payload contains: cpuModel, cpuCount, cpuSpeedMhz, cpuLoadPercent, loadAverage, memoryTotalBytes, memoryUsedBytes, memoryFreeBytes, memoryUsagePercent, uptimeSeconds, platform, arch, timestamp. # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = {}; // Run the Actor and wait for it to finish const run = await client.actor("constant_quadruped/hardware-telemetry-mcp").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = {} # Run the Actor and wait for it to finish run = client.actor("constant_quadruped/hardware-telemetry-mcp").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{}' | apify call constant_quadruped/hardware-telemetry-mcp --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=constant_quadruped/hardware-telemetry-mcp", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Hardware Telemetry MCP Server", "description": "Model Context Protocol (MCP) server monitoring CPU, GPU, and memory load metrics.", "version": "1.0", "x-build-id": "K1WibLIrP0PUWWeFf" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/constant_quadruped~hardware-telemetry-mcp/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-constant_quadruped-hardware-telemetry-mcp", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/constant_quadruped~hardware-telemetry-mcp/runs": { "post": { "operationId": "runs-sync-constant_quadruped-hardware-telemetry-mcp", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/constant_quadruped~hardware-telemetry-mcp/run-sync": { "post": { "operationId": "run-sync-constant_quadruped-hardware-telemetry-mcp", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "properties": { "query": { "title": "Query", "type": "string", "description": "MCP Command query", "default": "" } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```