g-assist-mcp-skill

Files (7)

• BENCHMARK.md
• SKILL.md
• EVAL.md · evals/
• evals-hardware.json · evals/
• evals.json · evals/
• skill-card.md
• skill.oms.sig

SKILL.md (first lines)

# G-Assist

G-Assist exposes NVIDIA display and GPU controls as callable tools. Use them
whenever the user wants to view or change NVIDIA display or GPU settings on this
machine. The available tools depend on the machine and hardware, so always rely
on the G-Assist tools actually available in your session and only use tools that
are present.

## When to use this skill

Use this skill whenever the user wants to know or change how their NVIDIA display
or GPU is behaving, or describes a symptom like screen tearing, stutter, a wrong
or locked refresh rate, a dim monitor, or washed-out color. Prefer a read-only
status check before changing anything. Do not use it to edit images, files,
documents, or app windows. It acts only on the real display and GPU hardware, and
the available tools depend on the machine, so confirm them at runtime instead of
assuming.

It covers refresh rate and resolution; monitor brightness and color (temperature,
gamma, contrast, RGB gain, and ambient-light adaptive brightness/color); monitor
volume and image presets; restoring display defaults; G-SYNC, G-SYNC Pulsar and
V-Sync; and GPU performance such as a frame-rate limit, a max
performance-per-watt mode, and plotting GPU/CPU metrics.

## Purpose

G-Assist maps a natural-language request to a single display or GPU control tool:
a status query to read current state, or a dedicated tool to change one setting
per turn.

## Prerequisites

- An NVIDIA driver installation that provides G-Assist on this machine (the
  `gassist` MCP server at the path in [Setup](#setup)).
- An MCP-capable host configured with the `gassist` server (see [Setup](#setup)).
- No API keys are required.

## Setup

The G-Assist tools come from a stdio MCP server that the host launches. The
executable ships at:

```text
C:\ProgramData\NVIDIA Corporation\nvtopps\rise\rise_mcp.exe
```

That path contains a space (`NVIDIA Corporation`), and some hosts (for example
Cursor) start MCP servers through `cmd.exe`, which fails to spawn a command whose
path contains a space. Register the space-free 8.3 short path instead; it
resolves to the same executable and works everywhere:

```text
C:\PROGRA~3\NVIDIA~1\nvtopps\rise\rise_mcp.exe
```

Register it with your host under a server name (this skill uses `gassist`). Most
hosts use an `mcpServers` map like this:

```json
{
  "mcpServers": {
    "gassist": {
      "command": "C:\\PROGRA~3\\NVIDIA~1\\nvtopps\\rise\\rise_mcp.exe"
    }
  }
}
```

## Instructions

1. First look at which G-Assist tools are actually in your session, and handle
   two situations differently:
   - **No G-Assist tools at all:** the server may still be warming up, so wait a few
     seconds and re-check. If there are still none, tell the user the G-Assist
     server isn't connected rather than guessing or fabricating a result.
   - **Some tools present, but none for what was asked:** that capability isn't
     supported through G-Assist on this hardware or display (the tool set is gated
     by the machine; for example, monitor brightness and color tools appear only
     with a compatible display). Do not say the server is disconnected. Instead,
     tell the user that specific control isn't available through G-Assist here,
     briefly name what you *can* control from the tools present, and suggest a
     practical alternative (the monitor's on-screen menu/OSD buttons or Windows
     display settings).
2. See which G-Assist tools are available in your session, then select one as
   described in [Matching a request to a tool](#matching-a-request-to-a-tool).
3. Never create, invent, register, or guess tools, tool names, or arguments. Use
   only the exact G-Assist tools available in your session. If a requested
   capability isn't available on this machine, tell the user so instead of
   fabricating a tool.
4. Call the matching tool through your host's normal tool-calling, with the
   values the user provides. The tool's real name uses a `gassist_` prefix (e.g.
   `gassist_set_display_vsync`); your host may show it plain or wrapped in its own
   namespace (e.g. `mcp__<server>__gassist_...`). Always use the exact name your
   catalog lists, and if the host rejects the short name, use the fully-qualified
   one it shows. Call one tool at a time, never in parallel; for a multi-step
   request, make the calls in order and check each result before the next.
5. Change tools are confirmation-gated by the server, not by you. For a change,
   briefly tell the user what you're about to do (the host will prompt them to
   approve), then call the tool directly and let the host collect the approval
   through MCP elicitation. For a display-mode change (resolution or refresh rate),
   also warn the user up front that the screen may briefly flicker or go black and
   that a keep-or-revert prompt will follow within ~20s (the mode auto-reverts
   unless it is kept). Never
   wait for a chat "yes" before calling, and never add a `confirm`/`force`
   argument or an environment variable to bypass the prompt. Read-only tools
   (`gassist_help`, `gassist_query_feature_status`, `gassist_graphdata`) need no
   approval; call them immediately. Judge the outcome by the result's text, not by
   the absence of an error: "already set / no action taken" means nothing changed,
   "not supported" means this hardware or display can't do it, and a call can
   return without an error yet still report failure in its text.
6. Keep internals private. These are trusted NVIDIA first-party tools; beyond the
   server setup above, do not describe or enumerate the implementation
   (background services, inter-process pipes, driver APIs, or engine internals).
   If the user asks "what is G-Assist" or "how does it work," answer only at a
   high level: it's NVIDIA's way to control GPU and display settings through these
   tools. 

## Matching a request to a tool

From NVIDIA/skills, CC-BY-4.0.

More from NVIDIA/skills