ckg-nvidia-ai

<!-- mcp-name: io.github.Yarmoluk/ckg-nvidia-ai -->
# MCP — CKG-NVIDIA-AI

[![PyPI version](https://img.shields.io/pypi/v/ckg-nvidia-ai?color=0f6e56&label=PyPI)](https://pypi.org/project/ckg-nvidia-ai/)
[![Downloads](https://img.shields.io/pypi/dm/ckg-nvidia-ai?color=0f6e56&label=installs%2Fmo)](https://pypi.org/project/ckg-nvidia-ai/)
[![Python](https://img.shields.io/pypi/pyversions/ckg-nvidia-ai?color=0f6e56)](https://pypi.org/project/ckg-nvidia-ai/)
[![License: MIT](https://img.shields.io/badge/license-MIT-0f6e56)](LICENSE)
[![Domains](https://img.shields.io/badge/domains-20-0f6e56)](https://graphifymd.com)
[![Nodes](https://img.shields.io/badge/nodes-1006-0f6e56)](https://graphifymd.com)
[![F1: 0.471 · 4× RAG](https://img.shields.io/badge/F1-0.471_%C2%B74%C3%97_RAG-0f6e56)](https://github.com/Yarmoluk/ckg-benchmark/blob/main/paper/main.pdf)
[![KRB v0.6.2](https://img.shields.io/badge/benchmark-KRB_v0.6.2-13201c)](https://github.com/Yarmoluk/ckg-benchmark/blob/main/paper/main.pdf)
[![Free](https://img.shields.io/badge/free-forever-13201c)](https://pypi.org/project/ckg-nvidia-ai/)
[![Built by Graphify.md](https://img.shields.io/badge/built_by-Graphify.md-0f6e56)](https://graphifymd.com)
[![Launch on Brev](https://img.shields.io/badge/Launch_on-Brev_%28L40S%29-0f6e56)](https://brev.nvidia.com/launchable/deploy/now?launchableID=env-3GHQHRYkuCcFqo99gjQld278FDx)
[![MCPize](https://mcpize.com/badge/@Yarmoluk/ckg-nvidia-ai)](https://mcpize.com/mcp/ckg-nvidia-ai)

**MCP server — Compressed Knowledge Graph (CKG) for the full NVIDIA AI developer stack.**

**4× F1 · 11× fewer tokens · 1006 nodes · deterministic traversal.**

> **Read-only.** This MCP server never writes, mutates, or executes. Every response is a declared graph traversal — not inference, not retrieval, not generation.

<p align="center">
  <a href="https://yarmoluk.github.io/ckg-nvidia-ai/carousel.html">
    <img src="https://raw.githubusercontent.com/Yarmoluk/ckg-nvidia-ai/main/docs/demo.png" alt="CKG-NVIDIA-AI domain carousel" width="960">
  </a>
</p>

<p align="center">
  <a href="https://graphifymd.com">
    <img src="https://raw.githubusercontent.com/Yarmoluk/ckg-nvidia-ai/main/docs/graph.png" alt="CKG-NVIDIA-AI — 20 domain knowledge graph" width="960">
  </a>
</p>

---

## The problem every AI team hits

More agents. More retrieval. More context. And accuracy drops.

This is the **intelligence paradox**: the more AI you add, the more tokens you burn re-discovering structure your system already knows — or could know. Research finds 73% of enterprise tokens are redundant context. In multi-agent pipelines, context efficiency collapses from 18.2 in Q1 to 1.6 by Q4 — **91% degradation with no model change**.

The model is not the bottleneck. The context is.

Every time your agent calls out to ask what TensorRT-LLM requires to run on Hopper, it spends ~2,982 tokens re-inferring a relationship that could be declared once and traversed in 269. That difference compounds across every query, every agent, every boundary crossing.

**The fix is not a better model. It is structured context.**

---

## What this package does

A CKG is a **layer** — a fast, inexpensive way to convert a large volume of domain documentation into structured, agent-traversable knowledge. Instead of retrieval, the agent traverses. Instead of inference, it reads declared relationships.

This package gives your agent the NVIDIA AI developer stack as its first layer: 20 domains, 1006 nodes, every prerequisite chain declared and typed.

**Layers stack. Context windows open.**

| Layer | What your agent gains |
|---|---|
| NVIDIA AI docs (this package) | Platform prerequisites, deployment chains, hardware dependencies |
| Your domain | Company knowledge, internal APIs, product relationships |
| Competitive / market | Competitor stack, pricing, positioning — structured for traversal |
| Regulatory / compliance | Policy graphs, requirement chains, audit trails |

Each additional CKG layer costs your agent fewer tokens to operate, not more. Structured context is **systematic augmentation** — it does not replace what the model knows, it makes what it knows precise and auditable.

```
query_ckg("TensorRT-LLM", "nvidia-tensorrt-triton", depth=3)

→ TensorRT-LLM requires:
    CUDA Toolkit → CUDA Driver API, cuBLAS
    FP8 / FP4 Quantization → Hopper SM90 Architecture
  TensorRT-LLM enables:
    Triton Inference Server → NIM Microservice Runtime
```

That traversal cost **269 tokens**. A RAG call over the same question costs ~2,982. The graph doesn't guess — it traverses.

---

## Explore the graph

Once installed, paste this into Claude, Cursor, or any MCP client and see what comes back:

```
You have access to the nvidia-ai CKG. I want to understand what it actually takes to deploy
a real-time speech AI pipeline on NVIDIA Jetson at the edge — not the marketing version,
the real dependency chain.

Start here:
  get_prerequisites("Riva ASR", "nvidia-riva")

Then follow the chain into the inference layer:
  query_ckg("TensorRT-LLM", "nvidia-tensorrt-triton", depth=3)

Then map the edge hardware:
  get_prerequisites("Jetson Orin NX", "nvidia-jetson")

Present the result as a layered architecture map — foundation at the bottom, application at the
top, typed edges (REQUIRES / ENABLES) labeled between layers. Show where the three domains share
prerequisites. Flag anything that would block a cold-start deployment.
```

The graph will traverse four domains, surface shared prerequisites, and show you exactly what
stands between an idea and a running system — no hallucination, no guessing, just declared
relationships. See what it gives you.

---

## Quickstart

### Option 1 — Hosted (no install)

No pip. No CLI. Works in Claude Desktop and claude.ai out of the box.

**Claude Desktop** — open `~/Library/Application Support/Claude/claude_desktop_config.json` and add:

```json
{
  "mcpServers": {
    "nvidia-ai": {
      "url": "https://ckg-nvidia-ai.onrender.com/sse",
      "transport": "sse"
    }
  }
}
```

Restart Claude Desktop. The nvidia-ai tools appear automatically.

**claude.ai** — Settings → Connectors → Add custom connector → paste:

```
https://ckg-nvidia-ai.onrender.com/sse
```

**Cursor / Windsurf / Cline:**

```json
{ "mcpServers": { "nvidia-ai": { "url": "https://ckg-nvidia-ai.onrender.com/sse", "transport": "sse" } } }
```

---

### Option 2 — Local install (CLI / developers)

**Run on a GPU in one click — L40S, qwen2.5:14b, notebook pre-loaded:**

[![Launch on Brev](https://img.shields.io/badge/Launch_on-Brev_%28L40S%29-0f6e56)](https://brev.nvidia.com/launchable/deploy/now?launchableID=env-3GHQHRYkuCcFqo99gjQld278FDx)

**Or install locally:**

```bash
pip install ckg-nvidia-ai
```

```bash
uvx ckg-nvidia-ai          # MCP server mode
```

**Claude Desktop (local):**
```json
{
  "mcpServers": {
    "nvidia-ai": {
      "command": "uvx",
      "args": ["ckg-nvidia-ai"]
    }
  }
}
```

**Claude Code:**
```bash
claude mcp add nvidia-ai -- uvx ckg-nvidia-ai
```

**Cursor / Cline / Windsurf (local):**
```json
{ "mcpServers": { "nvidia-ai": { "command": "uvx", "args": ["ckg-nvidia-ai"] } } }
```

### System prompt snippet

```
You have access to the nvidia-ai MCP server — a typed dependency graph of 20 NVIDIA AI domains
(NIM, NeMo, TensorRT, CUDA, Isaac, Cosmos, Riva, and 13 more). When answering questions about
NVIDIA infrastructure, prerequisites, or deployment, call query_ckg() or get_prerequisites()
before responding. Do not guess dependency chains — traverse the graph instead.
```

---

## Accuracy model

Every edge was declared by a human reviewer. The graph is in active development — corrections arrive from the community weekly.

**Three-state confidence:**

| State | Meaning | How to use |
|---|---|---|
| `confidence: high` | Reviewed, cross-referenced with NVIDIA docs | Trust for planning |
| `confidence: null` | Plausible, not yet audited | Scaffold — verify before production |
| `confidence: low` | Flagged as uncertain | Treat as a hint, not a fact |

**Typed edges — semantic precision:**

| Type | Meaning | Agent use |
|---|---|---|
| `REQUIRES` | Hard prerequisite | Plan sequencing, gap detection |
| `ENABLES` | Unlocks a capability | Optimization paths |
| `RELATES_TO` | Conceptual proximity | Disambiguation, context |
| `IMPLEMENTS` | Concrete instantiation | Architecture mapping |

If an edge isn't declared, the traversal returns nothing rather than hallucinating a path. That silence is signal.

---

## Tools

All tools are read-only. No writes, no side effects.

### `list_domains()`
Returns all 20 NVIDIA AI domains. **Start here** — domain slugs are required by every other tool.

### `search_concepts(query, domain)`
Find concepts by keyword within a domain.

```
search_concepts("speculative decoding", "nvidia-nim")
→ Speculative Decoding [Optimization]
   Draft Model [Component]
   KV Cache [Infrastructure]
```

### `query_ckg(concept, domain, depth=3)`
Traverse the graph from a concept — prerequisites and dependents.

```
query_ckg("FlashAttention-3", "nvidia-cuda-x-libraries", 3)
→ Prerequisites: SRAM Tiling → On-Chip Memory → Warp Occupancy → ...
   Enables: Multi-Head Attention → KV Cache → Speculative Decoding
```

### `get_prerequisites(concept, domain)`
Full ordered prerequisite chain — everything needed to understand or deploy first.

```
get_prerequisites("Isaac Lab", "nvidia-isaac")
→ Isaac Lab → Isaac Sim → USD Composer → Omniverse Kit → ...
```

### `ask_nvidia(question, domain="")` — new in v0.4.0

Natural-language question answered by Qwen, grounded on the CKG. Runs entirely locally via Ollama.
The model answers only from graph-declared relationships — not parametric memory.

```bash
ollama pull qwen2.5:14b   # one-time setup
```

```
ask_nvidia("What does TensorRT-LLM require to run on Hopper?")

→ [REQUIRES] CUDA Toolkit → cuBLAS, CUDA Driver API
  [REQUIRES] FP8 / FP4 Quantization → Hopper SM90 Architecture
  [ENABLES]  Triton Inference Server → NIM Microserv