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.

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.

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

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.

# 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:

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"):

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:

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.

✗ 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

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:

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):

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:

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):

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

Settings → Connectors → Add connector → paste URL.

Local — Claude Desktop / Claude Code:

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

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

Tools

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.

A/B — before vs after routing:

# 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

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.

Benchmark (KRB v0.6.2 locked)

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:

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

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.