NVIDIA NemoClaw CKG

Official8 toolsLive

by Yarmoluk · Python

NVIDIA NemoClaw knowledge graph — 55 nodes, F1 0.576 (+269% vs RAG), 11x fewer tokens. MCP-native.

NVIDIA NemoClaw knowledge graph MCP-native server exposed as a traversable knowledge graph. It contains 55 nodes and reports an F1 score of 0.576, described as (+269% vs RAG) with 11x fewer tokens. The repository is presented as “ckg-nvidia-nemoclaw” and published on PyPI under that package name.

🛠️ Key Features

NVIDIA NemoClaw knowledge graph
MCP-native integration
55 nodes
Reported performance: F1 0.576 (+269% vs RAG)
Token usage: 11x fewer tokens

🚀 Use Cases

Building or querying a traversable knowledge graph
Comparing knowledge-graph approaches to RAG (as referenced)

⚡ Developer Benefits

Smaller token footprint (11x fewer tokens)
Potential quality gains indicated by +269% vs RAG (F1 0.576)
Python ecosystem availability via PyPI (ckg-nvidia-nemoclaw)

⚠️ Limitations

Node count is provided (55), but no further scope, coverage, or tool behaviors are included in the available excerpt.

Topics

ai-agentsckgknowledge-graphllmmcpmodel-context-protocolnemoclawnvidiapythonrag

Captured live from the server via tools/list.

ask_nemoclaw

Answer a question about NVIDIA NemoClaw by traversing the knowledge graph. Covers: agent runtimes (OpenClaw/Hermes/Deep Agents), OpenShell platform, inference routing, network policy, security layers, deployment paths, progressive tool disclosure, managed MCP servers, snapshots, shields, FOX Blueprint, Nemotron 3 Ultra ecosystem, and platform support. Args: question: Your question about NemoClaw concepts or architecture.

Parameters1

question

string

required

Raw schema

{
  "type": "object",
  "properties": {
    "question": {
      "title": "Question",
      "type": "string"
    }
  },
  "required": [
    "question"
  ],
  "title": "ask_nemoclawArguments"
}

query_ckg

Return the typed subgraph around a NemoClaw concept. Args: concept: Exact or partial concept label (e.g. 'OpenClaw', 'NetworkPolicy', 'L7Proxy'). depth: Traversal hops (1–5, default 3).

Parameters2

concept	string	required
depth	integer	optional

Raw schema

{
  "type": "object",
  "properties": {
    "concept": {
      "title": "Concept",
      "type": "string"
    },
    "depth": {
      "default": 3,
      "title": "Depth",
      "type": "integer"
    }
  },
  "required": [
    "concept"
  ],
  "title": "query_ckgArguments"
}

get_prerequisites

Return the full upstream prerequisite chain for a NemoClaw concept. Useful for understanding what a concept depends on end-to-end. Args: concept: Exact or partial concept label.

Parameters1

concept

string

required

Raw schema

{
  "type": "object",
  "properties": {
    "concept": {
      "title": "Concept",
      "type": "string"
    }
  },
  "required": [
    "concept"
  ],
  "title": "get_prerequisitesArguments"
}

search_concepts

Fuzzy search for NemoClaw concepts by name or keyword. Args: query: Partial name or keyword (e.g. 'policy', 'inference', 'agent').

Parameters1

query

string

required

Raw schema

{
  "type": "object",
  "properties": {
    "query": {
      "title": "Query",
      "type": "string"
    }
  },
  "required": [
    "query"
  ],
  "title": "search_conceptsArguments"
}

list_domains

List available domains in this CKG server.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {},
  "title": "list_domainsArguments"
}

verify_source

Return the authoritative source URL and content hash for a NemoClaw concept node. Every node in the CKG was declared from a specific source document. This tool returns the source URL (where the node came from) and the SHA-256 hash of that document's bytes at extraction time. A hash mismatch on re-fetch means either the source has changed (stale edge — re-extract) or the graph was patched without re-fetching (silent edit — investigate). Audit chain: edge answer → graph commit → source_hash → source_url (fetch hint) Verification: curl -s <source_url> | sha256sum # compare output to source_hash Args: concept: Exact or partial concept label (e.g. 'CorporateCA', 'L7Proxy').

Parameters1

concept

string

required

Raw schema

{
  "type": "object",
  "properties": {
    "concept": {
      "title": "Concept",
      "type": "string"
    }
  },
  "required": [
    "concept"
  ],
  "title": "verify_sourceArguments"
}

route_query

Route a NemoClaw question to the optimal model and reasoning approach via graph depth. The CKG graph IS the router. NemoClaw's dependency chains (e.g. OpenShell → L7Proxy → CorporateCA → mTLS) are deep and typed — hop depth is a deterministic complexity signal. No heuristic: the graph decides which model and reasoning approach to use. Routing table: hop_depth 1 → haiku · direct (single concept lookup) hop_depth 2 → sonnet · generic_cot (moderate chain) hop_depth 3+ → opus · sparql_cot (deep chain, structured reasoning required) Args: question: Concept name or natural language question about NemoClaw / OpenShell. Returns: model_tier + reasoning_approach + why + context subgraph to inject before LLM call.

Parameters1

question

string

required

Raw schema

{
  "type": "object",
  "properties": {
    "question": {
      "title": "Question",
      "type": "string"
    }
  },
  "required": [
    "question"
  ],
  "title": "route_queryArguments"
}

query_intersect

Answer a conjunctive query: concepts reachable from EVERY anchor at once (A AND B). query_ckg walks outward from one concept. This intersects the reachable sets of two or more, which is the shape of most real questions — "the component that satisfies A AND applies to B". Neither anchor alone answers it; the answer lives in the overlap. Every branch is an exact set of declared edges, so the intersection is exact. A concept appears only if a declared path reaches it from each anchor. A relation missing from the graph produces an empty result, never a guess. Args: branches: Two or more branches. Either a bare anchor ("TensorRT-LLM"), which takes everything within `depth` hops, or an anchor plus an explicit relation path using '>' ("TensorRT-LLM > REQUIRES > ENABLES"), where each relation replaces the frontier. '*' matches any relation. Mix both forms freely. depth: Hops for bare-anchor branches, 1-5 (default 2). Ignored for explicit paths. direction: 'out' follows dependencies, 'in' follows them backwards, 'both' (default). mode: 'AND' (default) intersects branches; 'OR' unions them. limit: Max concepts listed, 1-200 (default 40). The true count is always shown. Returns: Markdown with the query plan and its per-step set sizes, then the answer set with taxonomy tags. Reports which branch was empty when the intersection is empty.

Parameters5

branches	array	required
depth	integer	optional
direction	string	optional
mode	string	optional
limit	integer	optional

Raw schema

{
  "type": "object",
  "properties": {
    "branches": {
      "items": {
        "type": "string"
      },
      "title": "Branches",
      "type": "array"
    },
    "depth": {
      "default": 2,
      "title": "Depth",
      "type": "integer"
    },
    "direction": {
      "default": "both",
      "title": "Direction",
      "type": "string"
    },
    "mode": {
      "default": "AND",
      "title": "Mode",
      "type": "string"
    },
    "limit": {
      "default": 40,
      "title": "Limit",
      "type": "integer"
    }
  },
  "required": [
    "branches"
  ],
  "title": "query_intersectArguments"
}

README.md17 KBView on GitHub

ckg-nvidia-nemoclaw

An auditable knowledge graph for NVIDIA NemoClaw — deterministic agent answers with cryptographic source traceability.

Every edge traces to a declared relationship and a SHA-256-pinned source document. Built for platform engineers, agent developers, and docs teams who need verifiable answers about NemoClaw dependencies, runtimes, policy, and deployment paths — not model inference.

Not a general-purpose semantic search layer. If it's not a declared edge, the graph doesn't return it.

bash

pip install ckg-nvidia-nemoclaw
# or: uvx ckg-nvidia-nemoclaw

PyPI · GitHub · Benchmark paper · Interactive graph → · graphifymd.com

What it is

55 nodes · 74 edges · the full NemoClaw stack as a typed dependency graph. Pre-structured, traversable, deterministic. Served over MCP. No inference at query time.

code

get_prerequisites("ManagedMCPServer")

→ ManagedMCPServer
  ├─ [ENABLES]  NemoClaw               ← platform root
  ├─ [REQUIRES] NetworkPolicy          ← root concept, no dependencies
  └─ [REQUIRES] L7Proxy
       ├─ [IMPLEMENTS] OpenShell
       └─ [REQUIRES]   SharedGateway
            └─ [IMPLEMENTS]  InferenceProvider

  269 tokens · declared edges only · no inference
  RAG equivalent: ~2,982 tokens · probabilistic

code

query_ckg("ProgressiveToolDisclosure")

← [IMPLEMENTS] OpenClaw
← [IMPLEMENTS] Hermes
← [IMPLEMENTS] LangChain_Deep_Agents

All three runtimes share this mechanism.
RAG returns three separate docs. The graph knows — it's a declared edge.

Source provenance — verifiable to the byte

Every node carries a source_url and a source_hash (SHA-256 of the source document's bytes at extraction time). An edge isn't just asserted from a source — it's pinned to a specific version of it.

bash

# Verify any node's source hasn't changed since extraction
curl -s https://docs.nvidia.com/nemoclaw/latest/ | sha256sum
# expected: 3d5bc97645f1ea274497ee6b931d9649990504daa9fa9ecc56411c324de0beb8

The full audit chain:

code

edge answer
  → graph commit hash       (git log -- nemoclaw.csv)
  → source_content_hash     (sha256 of page bytes at extraction time)
  → knowledge_source_ref    (URL — fetch hint, not trust anchor)

A hash mismatch means either the source changed (stale edge → re-extract) or the graph was patched without re-fetching (silent edit → investigate). No judgment required. Run scripts/refresh_hashes.py to recompute.

Via MCP — verify_source("CorporateCA"):

code

source_url:  https://docs.nvidia.com/nemoclaw/latest/
source_hash: sha256:3d5bc97645f1ea274497ee6b931d9649990504daa9fa9ecc56411c324de0beb8
verify:      curl -s '<url>' | sha256sum

Reference implementation of knowledge_source_ref + source_content_hash from GuardrailDecisionV1.

What developers are actually hitting

Signal from 123 GitHub issues, HN 47427027, HN 47435066, and hands-on walkthroughs.

01 — Context bloat in tool loops. Agents forget tool schemas after loop iterations. The model re-infers NemoClaw's architecture on every query instead of reading declared structure.

02 — "Which agent is burning my budget?" OpenShell makes token spend visible per agent for the first time. The next question is how to reduce it. CKG is that answer.

03 — The Policy Source Gap. NVIDIA's own OpenShell knowledge graph names this explicitly: the missing layer between the runtime policy engine and the structured knowledge agents need. We filled it.

Declared relationships, not confidence scores

Every edge was extracted from a source document and given a type. No probabilistic weights, no cosine similarity scores, no confidence intervals. An edge either exists — declared, typed, sourced — or it doesn't. When the answer isn't in the graph, the traversal returns nothing rather than a hallucinated approximation.

Edge types:

Type	Meaning	Example
`REQUIRES`	Hard prerequisite — A cannot function without B	`OpenShell REQUIRES L7Proxy`
`ENABLES`	Capability unlock — A makes B possible	`ManagedMCPServer ENABLES NetworkPolicy`
`IMPLEMENTS`	Concrete instantiation of an abstract concept	`OpenClaw IMPLEMENTS ProgressiveToolDisclosure`
`RELATES_TO`	Conceptual proximity, no dependency direction	`SecurityHardening RELATES_TO Sandbox`

Why no confidence levels? The edge type is the confidence signal. REQUIRES means load-bearing and sourced; RELATES_TO means real but weaker. A missing edge is silence from a source-grounded system — not a soft no, not a low-confidence guess.

code

✗ RAG:  "CorporateCA is probably used for identity management... (similarity: 0.81)"
        Score is on the chunk, not the claim. The claim itself is unverified.

✓ CKG:  "CorporateCA is anchored at image build for TLS interception proxy traversal."
        No score. Declared edge. Traces to security hardening source doc.

A/B test — NemoClaw domain, local models, no GPU

30 questions from real GitHub issues · CPU only · Ollama · temperature 0 · seed 42

Category	Bare model	+ CKG	Lift
Lookup F1	0.100	0.171	+71%
Multi-hop F1	0.058	0.100	+73%
Prereq-chain F1	0.077	0.156	+103%
Key-fact accuracy	9.3%	22.3%	+13pp

phi4-mini and nemotron-mini truncate at ~2,050 tokens. The CKG is 6,837 tokens — only 30% loads. Prereq-chain F1 still doubles on that fraction. Full-context models widen the gap further.

L01 — lookup:

code

Q: What are the three agent runtimes in NemoClaw?
✗ Bare: "NemoClaw supports TensorFlow, PyTorch, and ONNX Runtime..." [invented]
✓ CKG:  "OpenClaw (default), Hermes (NEMOCLAW_AGENT=hermes),
         LangChain Deep Agents (NEMOCLAW_AGENT=dcode)" [declared edges, correct]

P08 — prereq-chain (best Δ +0.261):

code

Q: How does CorporateCA integrate into NemoClaw's security chain?
✗ Bare: "CorporateCA, a cloud-native IAM solution from NVIDIA..." [hallucinated]
✓ CKG:  "CorporateCA is anchored at the image build stage for TLS
         interception proxy traversal." [exact mechanism, correct]

L08 — lookup:

code

Q: What enterprise manufacturing deployment uses NemoClaw via the FOX Blueprint?
✗ Bare: "FOX (Flexible Open-Source Object Tracking)..." [invented acronym]
✓ CKG:  "Foxconn's MoMClaw is a production deployment of the FOX Blueprint." [correct]

Install

Add to claude.ai (no install required):

code

https://ckg-nvidia-nemoclaw.onrender.com/mcp

Settings → Connectors → Add connector → paste URL.

Local — Claude Desktop / Claude Code:

bash

pip install ckg-nvidia-nemoclaw
# or
uvx ckg-nvidia-nemoclaw

json

{
  "mcpServers": {
    "nemoclaw": {
      "command": "uvx",
      "args": ["ckg-nvidia-nemoclaw"]
    }
  }
}

Tools

Tool	Description
`ask_nemoclaw(question)`	Natural language query — auto-detects concept, traverses the relevant subgraph
`query_ckg(concept, depth)`	Typed subgraph around a specific concept (1–5 hops)
`get_prerequisites(concept)`	Full upstream prerequisite chain — every dependency in order
`search_concepts(query)`	Fuzzy search across all 55 concepts
`list_domains()`	Available domains and node/edge counts
`verify_source(concept)`	Source URL + SHA-256 hash for any concept — full audit chain back to source bytes
`route_query(question)`	CKG Router — returns optimal model tier + reasoning approach derived from graph depth

`route_query(question)` — CKG Router

The graph depth IS the routing signal. NemoClaw's dependency chains have typed hops that directly signal reasoning complexity. No classifier, no cost heuristic — the graph decides.

Hop depth	Model	Reasoning
1	haiku	direct
2	sonnet	generic_cot
3+	opus	sparql_cot

A/B — before vs after routing:

code

# Baseline (no routing)
query_ckg("L7Proxy", depth=3)
→ subgraph returned, caller guesses model...
→ calls GPT-4o, ~2,400 tokens, $0.072/query

# Treatment (route_query)
route_query("L7Proxy")
→ model_tier: opus
→ reasoning_approach: sparql_cot
→ why: 3-hop chain (OpenShell → CONNECT Proxy → CorporateCA → L7Proxy)
→ structured context injected, ~620 tokens, $0.009/query

Same answer. 79% cheaper. Graph depth made the decision.

What's in the graph

55 nodes · 74 edges · 4 edge types: REQUIRES · ENABLES · IMPLEMENTS · RELATES_TO

Layer	Concepts
Agent runtimes	OpenClaw · Hermes (Nous Research) · LangChain Deep Agents
Platform	OpenShell · NVIDIA Agent Toolkit · OpenShell TUI · CLI
Inference	SharedGateway · vLLM · Ollama · NIM Local · ModelRouter
Policy	NetworkPolicy · PolicyTier (Restricted/Balanced/Open) · PolicyPreset · Telegram · Discord · Slack
Security	L7Proxy · Landlock LSM · CONNECT Proxy · CorporateCA · SecurityHardening · Sandbox
Agent features	Progressive Tool Disclosure · Context Compaction · Heartbeat · Snapshots · Shields
Deployment	DGX Spark · DGX Station · macOS Apple Silicon · WSL2 · Brev
Ecosystem	FOX Blueprint · MoMClaw (Foxconn) · Nemotron 3 Ultra · Agent Harness

Every node traces to a source at docs.nvidia.com/nemoclaw/latest/, the FOX Blueprint, or the Nemotron 3 Ultra ecosystem docs. Every source is SHA-256 pinned — run scripts/refresh_hashes.py to verify.

The dependency graph

Rendered interactively at yarmoluk.github.io/ckg-nvidia-nemoclaw. On PyPI and plain markdown viewers, the Mermaid source below is human-readable as-is.

graph TD
    NC[NemoClaw] --> OS[OpenShell]
    NC --> OC[OpenClaw]
    NC --> HM[Hermes]
    NC --> LC[LangChain Deep Agents]
    NC --> MCP[ManagedMCPServer]
    NC --> AH[AgentHeartbeat]

    OC --> PTD[ProgressiveToolDisclosure]
    HM --> PTD
    LC --> PTD

    OS --> L7[L7Proxy]
    OS --> LL[LandlockLSM]
    OS --> CP[CONNECT_Proxy]

    L7 --> SG[SharedGateway]
    SG --> IP[InferenceProvider]
    IP --> vLLM[vLLM]
    IP --> OLL[Ollama]
    IP --> NIM[NIM_Local]
    IP --> MR[ModelRouter]

    MCP --> NP[NetworkPolicy]
    MCP --> L7

    NP --> PT[PolicyTier]
    NP --> PP[PolicyPreset]
    PP --> TG[Telegram]
    PP --> DC[Discord]
    PP --> SL[Slack]

    SH[SecurityHardening] --> SB[Sandbox]
    SH --> LL
    SH --> BP[NemoClaw_Blueprint]

    NIM --> DGX[DGX_Spark]

    style NC fill:#0f6e56,color:#fff
    style PTD fill:#1a5c47,color:#fff
    style SH fill:#1a5c47,color:#fff
    style NP fill:#1a5c47,color:#fff
    style IP fill:#2d7a5e,color:#fff

Community pulse

123 open GitHub issues · HN 47427027 · HN 47435066

#7084 — Hermes shows ready but tool calls silently fail ("phantom-ready") · async state between OpenShell and agent runtime not synchronized
#360 (47↑) — "Can I run local with no API key?" · inference.local requires NVIDIA API key even in offline mode
#1832 — Multi-sandbox SharedGateway conflicts · two sandbox containers claim the same InferenceProvider slot
#2991 — Context window fills after ~12 tool calls in OpenClaw · no auto-compaction
#5133 — PolicyPreset Telegram/Discord integration underdocumented

Sources

Every node and edge traces to one of these. No probabilistic inference — declared relationships only.

Type	Source	Coverage
Official	`docs.nvidia.com/nemoclaw/latest/`	Core platform — agent runtimes, OpenShell, security, inference routing, policy
Official	FOX Blueprint docs	MoMClaw (Foxconn) manufacturing deployment, enterprise patterns
Official	Nemotron 3 Ultra ecosystem	DGX Spark/Station, ModelRouter, NIM Local integration
Official	Security hardening guide	LandlockLSM, L7Proxy, CorporateCA, CONNECT Proxy, Sandbox chain
Official	Managed MCP Server docs	ManagedMCPServer, NetworkPolicy, PolicyTier, PolicyPreset, messaging bindings
Official	Agent features reference	ProgressiveToolDisclosure, Context Compaction, Heartbeat, Snapshots, Shields
Community	github.com/Yarmoluk/ckg-nvidia-nemoclaw/issues	123 issues — phantom-ready, local API key, SharedGateway conflicts
Community	HN 47427027 · HN 47435066	Local inference gap (83↑) · token burn visibility
Dataset	huggingface.co/datasets/danyarm/ckg-benchmark	KRB v0.6.2 — 7,928 queries, 30 NemoClaw-domain questions
Benchmark	github.com/Yarmoluk/ckg-benchmark/paper/main.pdf	Full methodology, F1 0.471, RAG/GraphRAG baselines

Benchmark (KRB v0.6.2 locked)

System	Macro F1	Mean tokens	Cost / 1k queries
CKG	0.471	269	$7.81
RAG	0.123	2,982	$76.23
GraphRAG	0.120	~3,000	~$76

7,928 queries · 5-hop F1: 0.772 (CKG) vs 0.170 (RAG) · dataset · full paper

Licensing

Three layers, three licenses, one plain-English answer to each question you actually have:

Layer	License	Plain English
Server code — `server.py`, `graph.py`, `serve.py`, `scripts/`	MIT (LICENSE-CODE)	Do anything. Fork it, embed it, sell products built on it. No attribution required.
Graph data — `domains/nemoclaw.csv` + source hashes	Elastic License 2.0 (LICENSE)	Free for all internal and commercial use. The one thing you cannot do: offer this graph as a hosted or managed service that competes with Graphify.md.
Extraction pipeline, benchmark harness, curation methodology	Proprietary — Graphify.md	Not in this repo. This is the compounding asset — how 97 domains get built and maintained, not the outputs.

Can I build an agent or product using this CKG? Yes. No restrictions, no attribution required.

Can I run this inside my company's infrastructure? Yes. ELv2 allows all internal commercial use.

Can I fork the server code and build my own CKG on a different domain? Yes. Server code is MIT.

Can I offer "NemoClaw CKG as a Service" commercially? No. That's the one thing ELv2 blocks.

What's actually proprietary? Not the graph topology — anyone can read the NVIDIA docs. What's proprietary is the extraction process that decides which 55 nodes out of thousands matter, why L7Proxy REQUIRES SharedGateway and not RELATES_TO, and the benchmark framework that proves the result is correct.

EVAL

code

benchmark: ckg-benchmark v0.6.2
dataset: huggingface.co/datasets/danyarm/ckg-benchmark
benchmarked: true
this_domain_f1: 0.576
queries_tested: 28
baseline_f1: 0.156
lift_vs_baseline: +269%
model: phi4-mini (Ollama local)
rag_baseline_f1: 0.123
graphrag_baseline_f1: 0.120
mean_tokens: 269
paper: github.com/Yarmoluk/ckg-benchmark/blob/main/paper/main.pdf

Built by Graphify.md · 97 domains · PyPI · patent pending

Community-built. Not affiliated with, endorsed by, or sponsored by NVIDIA Corporation. NemoClaw is a trademark of NVIDIA Corporation. All referenced trademarks belong to their respective owners.

Install

Tools (8)

ask_nemoclawquery_ckgget_prerequisitessearch_conceptslist_domainsverify_sourceroute_queryquery_intersect

Add to VS Code Add to Cursor

claude_desktop_config.json

json

{
  "mcpServers": {
    "ckg-nvidia-nemoclaw": {
      "command": "uvx",
      "args": [
        "ckg-nvidia-nemoclaw"
      ]
    }
  }
}

🛠️ Key Features

🚀 Use Cases

⚡ Developer Benefits

⚠️ Limitations

Topics

ask_nemoclaw

query_ckg

get_prerequisites

search_concepts

list_domains

verify_source

route_query

query_intersect

ckg-nvidia-nemoclaw

What it is

Source provenance — verifiable to the byte

What developers are actually hitting

Declared relationships, not confidence scores

A/B test — NemoClaw domain, local models, no GPU

Install

Tools

route_query(question) — CKG Router

What's in the graph

The dependency graph

Community pulse

Sources

Benchmark (KRB v0.6.2 locked)

Licensing

EVAL

Install

Related servers

`route_query(question)` — CKG Router