# Reported issues for GPU MCP Server

Pod holds 17 of 19 problems reported by people outside the maintainer team. Issues filed by the project's own owners, members and collaborators are excluded entirely — a maintainer's release checklist is not a warning to a prospective user.

Back to [GPU MCP Server](/mcp/gpu-mcp-server).

## Most discussed

### feat(infra): cloud GPU test infrastructure for e2e validation (AWS, Azure, GCP)

**What problem does this solve?**

CI only ever tests against the mock collector — released images (#27) and
the Helm chart are never validated on real GPU hardware. Nothing verifies
that a released image initializes NVML and serves tool calls on a real GPU
node, on either architecture.

**Proposed solution**

Terraform-managed, ephemeral GPU test clusters plus an e2e harness, run
locally against your own cloud account, following the `infra/terraform/`
layout from [keda-gpu-scaler](https://githu

[Read the thread](https://github.com/pmady/gpu-mcp-server/issues/52) · 2026-07-04 · closed · outside contributor · 2 comments

### ci: add OpenSSF Scorecard workflow

## Summary

Add an OpenSSF Scorecard GitHub Actions workflow to continuously assess project security posture. This is important for foundation submission credibility (AAIF, CNCF).

## What is OpenSSF Scorecard?

[Scorecard](https://securityscorecards.dev/) checks open source projects for security best practices: branch protection, dependency pinning, CI/CD, code review, etc.

## Requirements

- Add `.github/workflows/scorecard.yml` using `ossf/scorecard-action`
- Trigger on push to main and week

[Read the thread](https://github.com/pmady/gpu-mcp-server/issues/38) · 2026-06-27 · closed · 2 comments

### ci: publish Docker image to GHCR on release

## Summary

Publish the Docker image to GitHub Container Registry (GHCR) on release tags, so users can run gpu-mcp-server without building from source.

## Requirements

- Add a `docker` job to the release workflow (`.github/workflows/release.yml`)
- Build multi-arch image (linux/amd64 at minimum)
- Push to `ghcr.io/pmady/gpu-mcp-server`
- Tag with version and `latest`
- Use the existing `Dockerfile`

## Suggested workflow addition

```yaml
docker:
  runs-on: ubuntu-latest
  permissions:
    con

[Read the thread](https://github.com/pmady/gpu-mcp-server/issues/27) · 2026-06-27 · closed · 2 comments

### Add GPU driver and CUDA version to metrics

Currently the Metrics struct doesn't include the NVIDIA driver version or CUDA version. These are useful for agents diagnosing compatibility issues.

**What to do:**
- Add `DriverVersion` and `CUDAVersion` fields to the `Metrics` struct in `gpu/gpu.go`
- Populate them in `gpu/nvml.go` using `nvml.SystemGetDriverVersion()` and `nvml.SystemGetCudaDriverVersion()`
- Update the mock with sample values
- Update tests

**Files to edit:** `gpu/gpu.go`, `gpu/nvml.go`, `gpu/mock.go`, `server/server_test.

[Read the thread](https://github.com/pmady/gpu-mcp-server/issues/5) · 2026-06-24 · open · 1 comment

### Add test coverage for gpu/mock.go edge cases

The mock collector in `gpu/mock.go` has basic tests through `server/server_test.go`, but there are no direct unit tests for the mock itself.

**What to do:**
- Create `gpu/mock_test.go`
- Test edge cases: empty device list, duplicate UUIDs, negative index, nil devices
- Verify the `Collector` interface contract is fully exercised

**Files to create:** `gpu/mock_test.go`

Good way to learn the codebase and the Collector interface.

[Read the thread](https://github.com/pmady/gpu-mcp-server/issues/4) · 2026-06-24 · closed · 1 comment

### Add JSON output example to README

The README shows how to configure Claude Desktop and Goose, but doesn't include an example of what the tool output looks like.

**What to do:**
- Run the mock collector or describe expected output
- Add a "Sample Output" section to README.md showing JSON responses for each tool
- Example for `list_gpus`, `get_gpu_metrics`, and `gpu_summary`

This helps users understand what data their agent will receive.

**Files to edit:** `README.md`

[Read the thread](https://github.com/pmady/gpu-mcp-server/issues/1) · 2026-06-24 · closed · 1 comment

### docs: create ARCHITECTURE.md

## Summary

Create an `ARCHITECTURE.md` documenting the project's design and data flow. Foundation reviewers and new contributors need this to understand the codebase quickly.

## Suggested sections

1. **Overview** — what gpu-mcp-server does and where it fits
2. **Data flow** — NVML → Collector → Handler → MCP SDK → Transport → Agent
3. **Key interfaces** — `Collector` (gpu.go), `Handler` (server.go)
4. **Build tags** — `nvml.go` (cgo+linux), `stub.go` (everything else), `mock.go` (tests)
5. **

[Read the thread](https://github.com/pmady/gpu-mcp-server/issues/39) · 2026-06-27 · open · 0 comments

### feat: multi-node GPU fleet aggregation

## Summary

Enable gpu-mcp-server to aggregate metrics from multiple GPU nodes, so an agent can query the entire GPU fleet from a single endpoint.

## Problem

Currently each gpu-mcp-server instance only sees GPUs on its local node. In a Kubernetes cluster with multiple GPU nodes, an agent would need to query each node separately.

## Proposed approach

When running in HTTP mode, a "coordinator" instance could:
1. Discover peer gpu-mcp-server pods via Kubernetes API or DNS
2. Fan out `list_gpus`

[Read the thread](https://github.com/pmady/gpu-mcp-server/issues/29) · 2026-06-27 · closed · 0 comments

## Most recent

### feat: add get_gpu_errors tool for ECC and XID error reporting

## Summary

Add a `get_gpu_errors` MCP tool that surfaces GPU error state — ECC memory errors, XID errors, and driver health.

## Background

GPUs can have silent errors that degrade inference accuracy or cause crashes. NVML exposes:
- `nvmlDeviceGetMemoryErrorCounter` — ECC single-bit and double-bit errors
- `nvmlDeviceGetTotalEccErrors` — total corrected/uncorrected errors
- XID errors via event monitoring

## Requirements

- New `get_gpu_errors` tool returning per-device error counts
- Fields

[Read the thread](https://github.com/pmady/gpu-mcp-server/issues/28) · 2026-06-27 · open · 0 comments

### docs: add Goose integration tutorial

## Summary

Add a tutorial or example showing gpu-mcp-server integrated with [Goose](https://github.com/block/goose) for an end-to-end GPU-aware agentic workflow.

## What to cover

- Goose configuration for gpu-mcp-server (already in README)
- Example prompts that use GPU metrics:
  - "Which GPU has the most free memory?"
  - "Is any GPU thermally throttling?"
  - "Show me which processes are using GPU 0"
- Screenshot or terminal recording of the interaction

## Acceptance criteria

- [ ] Tutor

[Read the thread](https://github.com/pmady/gpu-mcp-server/issues/26) · 2026-06-27 · open · 0 comments

### docs: add status badges to README

## Summary

Add status badges to the top of README.md for quick project health visibility.

## Badges to add

- CI status (GitHub Actions)
- Go Report Card
- Go Reference (pkg.go.dev)
- License (Apache 2.0)
- GitHub stars
- GitHub release (latest)

## Example format

```markdown
[![CI](https://github.com/pmady/gpu-mcp-server/actions/workflows/ci.yml/badge.svg)](https://github.com/pmady/gpu-mcp-server/actions/workflows/ci.yml)
[![Go Report Card](https://goreportcard.com/badge/github.com/pmady/gpu

[Read the thread](https://github.com/pmady/gpu-mcp-server/issues/24) · 2026-06-27 · open · 0 comments

### Helm chart for Kubernetes deployment

Create a Helm chart so gpu-mcp-server can be deployed as a DaemonSet on Kubernetes GPU nodes.

**Requirements:**
- Helm chart in `deploy/helm/gpu-mcp-server/`
- DaemonSet targeting GPU nodes (via `nvidia.com/gpu` resource or node labels)
- Mount NVML socket/library from host
- NVIDIA device plugin tolerance
- Configurable transport (stdio for sidecar, HTTP for standalone)
- Service and ServiceMonitor (optional Prometheus scraping)
- Values for resource limits, node selectors, tolerations

**Why 

[Read the thread](https://github.com/pmady/gpu-mcp-server/issues/11) · 2026-06-24 · closed · 0 comments

### AMD ROCm GPU support

Currently the server only supports NVIDIA GPUs via NVML. Adding AMD ROCm support would make gpu-mcp-server vendor-neutral.

**Requirements:**
- Implement a new `ROCmCollector` that satisfies the `gpu.Collector` interface
- Use `rocm-smi` CLI or AMD ROCm SMI library for GPU metrics
- Auto-detect GPU vendor at startup and choose the right collector
- Maintain parity with NVML metrics where possible (utilization, memory, temperature, power)
- Add build tag `//go:build cgo && linux` (ROCm is Linux-o

[Read the thread](https://github.com/pmady/gpu-mcp-server/issues/10) · 2026-06-24 · open · 0 comments

### GPU event notifications (thermal throttling, ECC errors, XID)

Add a tool or MCP notification mechanism that reports GPU hardware events.

**Requirements:**
- New tool: `get_gpu_events` — returns recent GPU events
- Track thermal throttling events via `nvml.DeviceGetViolationStatus()`
- Track ECC errors via `nvml.DeviceGetTotalEccErrors()`
- Track XID errors via `nvml.DeviceGetXidErrors()` (if available)
- Return events with timestamps, severity, and affected device

**Why this matters:**
- Agents can proactively alert on hardware degradation
- Thermal thro

[Read the thread](https://github.com/pmady/gpu-mcp-server/issues/9) · 2026-06-24 · open · 0 comments

### MCP Resources: expose GPU topology as context

In addition to tools (on-demand queries), MCP supports resources — static or semi-static data that agents can load into their context window.

**Requirements:**
- Expose GPU topology as an MCP resource (device count, names, UUIDs, MIG layout)
- Resource URI pattern: `gpu://topology`, `gpu://device/{index}`
- Use `mcp.AddResource()` from the Go SDK
- Topology data refreshes on server start, not on every request

**Why this matters:**
- Agents can preload GPU context without calling tools
- Reduce

[Read the thread](https://github.com/pmady/gpu-mcp-server/issues/8) · 2026-06-24 · open · 0 comments

### Per-process GPU usage (PID-level attribution)

Add a new tool `get_gpu_processes` that shows which processes are using GPU resources.

**Requirements:**
- New tool: `get_gpu_processes` — returns per-PID GPU memory and compute usage
- Use `nvml.DeviceGetComputeRunningProcesses()` and `nvml.DeviceGetGraphicsRunningProcesses()`
- Include PID, process name, GPU memory used, compute instance (if MIG)
- Input: optional GPU index or UUID filter

**Example output:**
```json
{
  "processes": [
    {"pid": 12345, "name": "python", "gpu_index": 0, "mem

[Read the thread](https://github.com/pmady/gpu-mcp-server/issues/7) · 2026-06-24 · closed · 0 comments

### Streamable HTTP transport support

Currently the server only runs over stdio, which requires the agent to spawn the process locally. Adding HTTP transport would allow gpu-mcp-server to run as a network service that multiple agents can connect to.

**Requirements:**
- Add a `--transport` flag: `stdio` (default) or `http`
- Add a `--port` flag for HTTP mode (default: 8080)
- Use `mcp.StreamableHTTPTransport` from the Go SDK
- Maintain backward compatibility — stdio remains the default
- Add health check endpoint at `/healthz`

**Wh

[Read the thread](https://github.com/pmady/gpu-mcp-server/issues/6) · 2026-06-24 · closed · 0 comments

The remaining reports are on [the project's issue tracker](https://github.com/pmady/gpu-mcp-server/issues).