Hardware Telemetry MCP Server

A Model Context Protocol (MCP) 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 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

• Implements the standard MCP methods initialize, tools/list, and tools/call.
• Exposes one tool, get_system_stats, which reads live host metrics.
• Runs in one of two modes, selected by the query input:
  • One-shot mode (default). For empty input, or any query that is a bare tool name or a raw JSON-RPC line, the Actor handles a single request, prints the JSON-RPC response to the log, saves it to the default key-value store as OUTPUT, and exits cleanly. Empty input defaults to calling get_system_stats.
  • Server mode. When query is serve or mcp-server, the Actor runs as a long-lived MCP server over stdio (newline-delimited JSON-RPC 2.0), reading requests from standard input until stdin closes.

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)	Selects the run mode. May be a bare tool name (e.g. get_system_stats), a raw JSON-RPC line (e.g. {"jsonrpc":"2.0","id":1,"method":"tools/list"}), or the literal serve / mcp-server to start the long-lived MCP stdio server. If empty, the Actor runs get_system_stats once, saves the result as OUTPUT, and exits.

Example input (one-shot):

{ "query": "get_system_stats" }

---

MCP tools

The server exposes exactly one tool:

Tool	Parameters	What it returns
get_system_stats	none (its inputSchema declares no properties)	Real host telemetry read from the Node.js os module — CPU model/count/speed, measured CPU load %, memory totals/usage, load average, uptime, platform and arch. Temperature is intentionally not reported (no sensor access; see note above). The payload is returned as JSON text inside the MCP tools/call result content.

---

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

On every one-shot run (including the default empty-input run), the full JSON-RPC response is also written to the default key-value store under the key OUTPUT. In server mode (query = serve / mcp-server), results are delivered only over stdio and OUTPUT is not written.

Example response:

{
  "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:

{ "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)

Set query to serve (or mcp-server) to start the long-lived server, then pipe JSON-RPC requests to stdin, one per line. Locally, set the Actor input to { "query": "serve" } first, then:

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

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).
• Containerized cloud environment. On the Apify platform the Actor runs inside a shared, containerized Linux environment. The reported metrics describe that container/VM and the OS-visible host — not dedicated physical hardware, and not your local machine. Values such as cpuModel, cpuCount and memoryTotalBytes reflect the underlying shared host or the container's cgroup limits, and cpuLoadPercent reflects the container's slice of a shared machine. There is no access to real physical hardware sensors (temperature, fan speed, voltages, SMART data, GPU counters) from this runtime.
• 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.