Stellt Echtzeit-NVIDIA GPU-Metriken wie Auslastung, Speicher, Temperatur und Leistungsaufnahme über das Model Context Protocol für AI Agents bereit.
Auch bekannt als pmady/gpu-mcp-server, gpu-mcp-server
- Stars
- 15
- Tools
- 4
- Downloads, 30 Tage
- —
- Neueste Version
- 0.1.0
- Letzter Commit
- 14. Nov. 2026
- Lizenz
- Apache-2.0
Was ist GPU MCP?
Stellt Echtzeit-NVIDIA GPU-Metriken wie Auslastung, Speicher, Temperatur und Leistungsaufnahme über das Model Context Protocol für AI Agents bereit. Er stellt 4 Tools bereit, etwa list_gpus, get_gpu_metrics, get_gpu_processes.
Zusammenfassung generiert aus dem README des Projekts
Über GPU MCP server
Dieser Server ermöglicht es, die Performance von NVIDIA-Hardware direkt aus einem AI Agent heraus zu überwachen. Er bietet Echtzeit-Zugriff auf GPU-Metriken wie Auslastung, Speichernutzung, Temperatur und Leistungsaufnahme. Entwickler können diesen Server über eine lokale stdio-Verbindung mit kompatiblen Clients wie Claude, Goose, Cursor oder Windsurf verbinden.
Das Tool fungiert als lokaler Prozess, der über cgo direkt mit NVML kommuniziert, wodurch komplexe Metrik-Pipelines wie Prometheus oder dcgm-exporter überflüssig werden. Es unterstützt Multi-Instance GPU (MIG) Konfigurationen, bei denen MIG-Instanzen als eigenständige Geräte erscheinen, aber weiterhin gemeinsame Metriken der Parent-Hardware melden.
Nutzer können über spezifische Tools wie list_gpus, get_gpu_metrics, get_gpu_processes und gpu_summary mit der Hardware interagieren. Der Server kann als kompiliertes Go-Binary oder via Docker-Container bereitgestellt werden, vorausgesetzt, die Host-Maschine verfügt über die notwendigen NVIDIA-Treiber und das Container Toolkit.
Was du damit machen kannst
- 1Hardware-Auslastung prüfenFrag deinen AI Agent, um alle verfügbaren GPUs sowie deren aktuellen Speicher- und Auslastungsstatus aufzulisten.
- 2Ressourcenintensive Prozesse identifizierenFordere eine Aufschlüsselung an, welche spezifischen Prozess-IDs aktuell die GPU nutzen.
- 3Aggregierte Systemstatistiken abrufenFrag nach einer Zusammenfassung des gesamten Speichers und der durchschnittlichen Auslastung über alle verbundenen Geräte hinweg.
Geschrieben aus dem README des Projekts. Jeder Use Case wurde gegen ein Zitat daraus geprüft.
So installierst du GPU MCP
Formate geprüft am 10. Nov. 2026Zu Cursor hinzufügenZu Goose hinzufügenGPU MCP in Claude Code installieren
$ claude mcp add gpu-mcp-server -- docker run -i --rm ghcr.io/pmady/gpu-mcp-server:v0.1.0GPU MCP in Cursor installieren
~/.cursor/mcp.json
{
"mcpServers": {
"gpu-mcp-server": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/pmady/gpu-mcp-server:v0.1.0"
]
}
}
}GPU MCP in VS Code installieren
.vscode/mcp.json
{
"servers": {
"gpu-mcp-server": {
"type": "stdio",
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/pmady/gpu-mcp-server:v0.1.0"
]
}
}
}GPU MCP in VS Code CLI installieren
$ code --add-mcp '{"name":"gpu-mcp-server","type":"stdio","command":"docker","args":["run","-i","--rm","ghcr.io/pmady/gpu-mcp-server:v0.1.0"]}'GPU MCP in Claude Desktop installieren
claude_desktop_config.json
{
"mcpServers": {
"gpu-mcp-server": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/pmady/gpu-mcp-server:v0.1.0"
]
}
}
}GPU MCP in Codex installieren
$ codex mcp add gpu-mcp-server -- docker run -i --rm ghcr.io/pmady/gpu-mcp-server:v0.1.0GPU MCP in Codex config.toml installieren
~/.codex/config.toml
[mcp_servers.gpu-mcp-server] command = "docker" args = ["run", "-i", "--rm", "ghcr.io/pmady/gpu-mcp-server:v0.1.0"]
GPU MCP in Gemini CLI installieren
$ gemini mcp add -s user gpu-mcp-server docker -- run -i --rm ghcr.io/pmady/gpu-mcp-server:v0.1.0GPU MCP in Gemini settings.json installieren
~/.gemini/settings.json
{
"mcpServers": {
"gpu-mcp-server": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/pmady/gpu-mcp-server:v0.1.0"
]
}
}
}GPU MCP tools 4
Erkannt aus dem READMElist_gpusget_gpu_metricsget_gpu_processesgpu_summary
| list_gpus | — | |
| get_gpu_metrics | — | |
| get_gpu_processes | — | |
| gpu_summary | — |
Automatisierte Checks
Geluften am 12. Nov. 2026Vollständiger Bericht →Unsere automatisierten Checks bestanden. Das ist kein Security-Audit: Lies den Code und gib dem Server nur den minimal notwendigen Zugriff. Wie die Checks funktionieren
- Source Repository verknüpft und erreichbarBestanden
- Open Source Lizenz (OSI)Bestanden
- Commit oder Release im letzten JahrBestanden
- Package-Name ähnelt keinem populären PackageNicht geprüft
- Remote Endpoint nutzt HTTPSNicht geprüft
- Destruktive Tools sind markiertBestanden
- Keine versteckten Anweisungen an das ModellBestanden
- Keine kritischen Advisories im Paket oder seinen AbhängigkeitenNicht geprüft
README
Auf GitHub ansehengpu-mcp-server
Note: the OpenSSF Best Practices questionnaire is in progress. Once the project entry is registered at https://www.bestpractices.dev/en, swap the static badge above for the live one:
[](https://www.bestpractices.dev/projects/<ID>)
An MCP server that exposes NVIDIA GPU metrics as tools. Any MCP-compatible AI agent (Claude, Goose, Cursor, etc.) can query real-time GPU utilization, memory, temperature, power, PCIe and NVLink throughput no Prometheus or dcgm-exporter required.
Built on the official Go MCP SDK and NVIDIA go-nvml.
Tools
| Tool | Description |
|---|---|
list_gpus |
List all GPUs with utilization and memory info |
get_gpu_metrics |
Detailed metrics for a GPU by index or UUID |
get_gpu_processes |
PID-level GPU process attribution |
gpu_summary |
Aggregate stats across all devices |
All tools support MIG (Multi-Instance GPU) - MIG instances appear as separate devices with their parent GPU's shared metrics (temperature, power, PCIe).
Sample output
Each tool returns structured JSON. The examples below show the shape of the data an agent receives from a node with two NVIDIA A100 GPUs.
list_gpus:
{
"count": 2,
"devices": [
{
"index": 0,
"uuid": "GPU-aaaa-1111",
"name": "NVIDIA A100-SXM4-80GB",
"gpu_utilization_percent": 85,
"memory_used_mib": 57344,
"memory_total_mib": 81920
},
{
"index": 1,
"uuid": "GPU-bbbb-2222",
"name": "NVIDIA A100-SXM4-80GB",
"gpu_utilization_percent": 20,
"memory_used_mib": 12288,
"memory_total_mib": 81920
}
]
}
get_gpu_metrics (with {"index": 0} or {"uuid": "GPU-aaaa-1111"}):
{
"index": 0,
"uuid": "GPU-aaaa-1111",
"name": "NVIDIA A100-SXM4-80GB",
"gpu_utilization_percent": 85,
"memory_utilization_percent": 70,
"memory_used_mib": 57344,
"memory_total_mib": 81920,
"temperature_celsius": 72,
"power_draw_watts": 300,
"power_limit_watts": 400,
"pcie_tx_kbps": 0,
"pcie_rx_kbps": 0,
"nvlink_tx_mbps": 0,
"nvlink_rx_mbps": 0
}
gpu_summary:
{
"device_count": 2,
"avg_gpu_utilization": 52.5,
"avg_memory_utilization": 42.5,
"total_memory_used_mib": 69632,
"total_memory_total_mib": 163840,
"max_temperature_celsius": 72,
"total_power_draw_watts": 375
}
MIG instances add is_mig, parent_gpu, and mig_profile fields to the
get_gpu_metrics and list_gpus payloads.
Quick start
# build (requires CGO + NVML headers on Linux)
make build
# run the server communicates over stdio
./gpu-mcp-server
Claude Desktop
Add to claude_desktop_config.json:
{
"mcpServers": {
"gpu": {
"command": "/path/to/gpu-mcp-server"
}
}
}
Goose
extensions:
gpu-metrics:
type: stdio
cmd: /path/to/gpu-mcp-server
Cursor
Add to .cursor/mcp.json for a project, or ~/.cursor/mcp.json for all
projects:
{
"mcpServers": {
"gpu": {
"type": "stdio",
"command": "/path/to/gpu-mcp-server"
}
}
}
Windsurf
Add to ~/.codeium/windsurf/mcp_config.json:
{
"mcpServers": {
"gpu": {
"command": "/path/to/gpu-mcp-server"
}
}
}
Build
Requires Go 1.23+, CGO, and NVIDIA drivers on the target machine.
make build # compile binary
make test # run tests (no GPU needed uses mock)
make lint # golangci-lint
make docker # container image
Tests use a mock collector, so they run anywhere no GPU hardware required.
Docker
Prebuilt multi-arch images (linux/amd64, linux/arm64) are published to GHCR on every release.
docker pull ghcr.io/pmady/gpu-mcp-server:latest
docker run --rm -i --gpus all ghcr.io/pmady/gpu-mcp-server:latest
The host needs the NVIDIA Container Toolkit
installed for --gpus all to work. The server speaks MCP over stdio, so the
-i flag is required — don't drop it.
{
"mcpServers": {
"gpu": {
"command": "docker",
"args": ["run", "--rm", "-i", "--gpus", "all", "ghcr.io/pmady/gpu-mcp-server:latest"]
}
}
}
Pin a specific version via tag instead of :latest, e.g. ghcr.io/pmady/gpu-mcp-server:v0.1.0.
Architecture
Agent (Claude/Goose) ─── MCP (stdio) ──→ gpu-mcp-server ──→ NVML ──→ GPU
│
Tools:
• list_gpus
• get_gpu_metrics
• gpu_summary
The server runs as a local process alongside the agent. It calls NVML directly through cgo — no sidecar, no network hops, no metric pipeline to configure.
Project info
- License: Apache 2.0
- Language: Go
- AAIF project alignment: MCP
- Related: keda-gpu-scaler (GPU autoscaling for Kubernetes)
- Whitepaper: GPU-Aware Autoscaling in Cloud Native AI Infrastructure — CNCF TAG Infrastructure initiative (TOC #2188)
Citing
If you use gpu-mcp-server in your research or writing, please cite it via its DOI. Full citation metadata is in CITATION.cff.
@software{madduri_gpu_mcp_server,
author = {Madduri, Pavan},
title = {gpu-mcp-server: NVIDIA GPU metrics for AI agents over the Model Context Protocol},
year = {2026},
publisher = {Zenodo},
doi = {10.5281/zenodo.22866670},
url = {https://doi.org/10.5281/zenodo.22866670}
}
Roadmap
See ROADMAP.md for the 12-month public roadmap.
Contributing
See CONTRIBUTING.md for how to get involved.
Contributors
Thanks to all our contributors! Add yourself via PR.
Governance
This project follows Linux Foundation Minimum Viable Governance.
Documentation
- Full documentation - hosted on Read the Docs
- ROADMAP.md - public roadmap
- GOVERNANCE.md - decision-making process
- DEPENDENCIES.md - external dependencies and licenses
- SECURITY.md - vulnerability reporting
- AGENTS.md - instructions for AI agents working on this repo
- CODE_OF_CONDUCT.md - community standards
Star History
GPU MCP Fragen
Wie füge ich GPU MCP zu Claude Code hinzu?
Führe claude mcp add gpu-mcp-server -- docker run -i --rm ghcr.io/pmady/gpu-mcp-server:v0.1.0 in deinem Terminal aus. Füge --scope user hinzu, damit der Server in jedem Projekt verfügbar ist.
Wie füge ich GPU MCP zu Cursor hinzu?
Öffne ~/.cursor/mcp.json und füge den Server unter mcpServers hinzu, mit der Cursor-Config aus dem Installationsabschnitt oben.
Welche Tools bietet GPU MCP?
Er stellt 4 Tools bereit, darunter list_gpus, get_gpu_metrics, get_gpu_processes, gpu_summary.
Benötige ich dafür Prometheus oder dcgm-exporter?
Nein, der Server fragt die NVIDIA GPU-Metriken direkt ab, ohne dass ein Prometheus- oder dcgm-exporter-Setup erforderlich ist.
Wird Multi-Instance GPU (MIG) unterstützt?
Ja, alle Tools unterstützen MIG, wobei die Instanzen als separate Geräte mit gemeinsam genutzten Parent-Metriken wie Temperatur und Leistungsaufnahme erscheinen.
Kann ich das Ganze mit Docker ausführen?
Ja, vorgefertigte Multi-Arch-Docker-Images sind auf GHCR verfügbar, sofern auf dem Host das NVIDIA Container Toolkit installiert ist.