Context Optimization — The Problem

Every agent that reasons about a domain — HIPAA, GPU inference, calculus, contract law — does one of three things:

All three share the same failure: the agent re-infers domain structure on every query instead of reading structure that was declared once.

In our open benchmark (KRB v0.6.2 — reproduce it yourself): RAG achieves 0.123 macro F1 on multi-hop domain queries. CKG achieves 0.471. At 5 hops, the gap widens: RAG 0.170, CKG 0.772.

The token cost compounds the accuracy problem: the average RAG query costs 2,982 tokens. The average CKG traversal costs 269 — measured across 19 benchmark domains.

These numbers are ours, on our benchmark. The dataset is public on HuggingFace. Run it yourself.

Agent Traversal — The Solution

A Compressed Knowledge Graph (CKG) is a domain structured for traversal, not retrieval.

Not a document. Not a vector index. A pre-compiled DAG of concepts, typed dependency relationships, and prerequisite chains — compressed to the minimum tokens that carry the maximum structure. Served over MCP. Traversed deterministically.

Agent asks:   "What does TensorRT-LLM require to run on Hopper?"

CKG returns:  TensorRT-LLM
              ├─ [REQUIRES] CUDA Toolkit
              │    ├─ [ENABLES] cuBLAS
              │    └─ [ENABLES] CUDA Driver API
              ├─ [REQUIRES] FP8/FP4 Quantization
              │    └─ [REQUIRES] Hopper SM90 Architecture
              └─ [ENABLES] Triton Inference Server
                   └─ [ENABLES] NIM Microservice Runtime

              269 tokens · declared edges only · no inference at query time

RAG would:    ~2,982 tokens · probabilistic retrieval · degrades at 3+ hops

You go from prompting the domain into existence to asking questions inside it.

One Use Case — Becoming Nemotron-Enabled

Perplexity is a model aggregator. Shortest route to Nemotron — click the dropdown, select the model, query. But it's their pipeline, their infrastructure. Your queries go through their system.

If you want to run Nemotron yourself — sovereign, private, on your own hardware — you need to navigate NVIDIA's stack: NGC API key, NIM container, Enterprise License, inference endpoint. The dependency chain is non-obvious. Most developers hit the wrong door first.

Without CKG: search the docs, hit the Enterprise License wall, spend two hours finding build.nvidia.com.

With CKG:

query_ckg("Nemotron Model", "nvidia-nim")
→ [REQUIRES] Model Weights
  → [REQUIRES] NGC Container Registry
    → [REQUIRES] NGC API Key        ← start here

query_ckg("NIM Docker Container", "nvidia-nim")
→ [REQUIRES] NGC API Key
→ [REQUIRES] NVIDIA AI Enterprise License   ← production path
→ [ENABLES]  NIM Microservice               ← what you're building toward

Two traversals. Correct path. No wrong doors. The graph knew — the model just told you.

Typed edges carry semantic meaning

Every domain is a plain-text DAG

ConceptID, ConceptLabel,      Dependencies,      TaxonomyID
1,         Taylor Series,     "",                Analysis
2,         Power Series,      "",                Analysis
3,         Convergence,       "2:REQUIRES",      Analysis
4,         Higher-Order Der., "5:REQUIRES",      Calculus
5,         Derivative,        "6:REQUIRES",      Calculus
6,         Continuity,        "7:REQUIRES",      Calculus

No embeddings. No probabilistic retrieval. Built once, reviewed once, traversed forever.

Agent Team Orchestration — The Scale Story

Single-agent traversal is the efficiency gain. Multi-agent orchestration is where it compounds.

Liu et al. (arXiv:2606.30986) measure Context Transaction Cost (CTC): the tax paid every time context crosses an agent boundary. Their finding: context efficiency collapses from 18.2 in Q1 to 1.6 by Q4 across pipeline stages — 91% degradation with no model change.

CKG addresses all three root causes they identify:

When agent A hands off to agent B, neither re-retrieves the domain. They both traverse the same declared graph. Structured context doesn't consume your context window — it opens it.

Quickstart

uvx ckg-mcp          # no install — runs immediately
# or
pip install ckg-mcp  # Python ≥ 3.10

Claude Desktop

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

Claude Code

claude mcp add ckg -- uvx ckg-mcp

Cursor / Cline / Windsurf / any MCP client

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

System prompt snippet

You have access to the ckg MCP server — a typed dependency graph catalog
of 97 domains (mathematics, GPU inference, healthcare, law, robotics,
regulatory, AI tooling, and more). When answering questions about any of
these domains, call query_ckg() or get_prerequisites() before responding.
Do not infer dependency chains — traverse the graph instead.

Try it immediately

list_domains()
→ see all 68 free domains

query_ckg("Taylor Series", "calculus", 3)
→ prerequisite chain: Function → Limit → Continuity → Derivative →
  Higher-Order Derivatives → Convergence → Power Series → Taylor Series

get_prerequisites("Business Associate Agreement", "hipaa-compliance")
→ Covered Entity → PHI Definition → Minimum Necessary Standard →
  Access Controls → Breach Notification Rule → BAA

query_ckg("FlashAttention-3", "nvidia-gpu-inference", 3)
→ SRAM Tiling · On-Chip Memory Budget · Transformer Attention ·
  Softmax Stability → FlashAttention-3 → Multi-Head Attention → KV Cache

Source provenance — verifiable to the byte

Every node carries a source_url and a source_hash (SHA-256 of source bytes at extraction time) where available. The full audit chain: edge answer → graph commit hash → source_content_hash → knowledge_source_ref.

# For domains with per-node hashes:
curl -s <source_url> | sha256sum
# compare to source_hash — mismatch = stale edge or silent upstream edit

Via MCP — verify_source(concept, domain) returns source URL, hash, and verification command. Run scripts/refresh_hashes.py to recompute.

Reference implementation from GuardrailDecisionV1.

Benchmark

These are our numbers on our open benchmark. The dataset is on HuggingFace. Run it yourself before citing them.

git clone https://github.com/Yarmoluk/ckg-benchmark && cd ckg-benchmark
pip install -r evaluation/requirements.txt
python evaluation/ckg_harness.py --domain calculus
python evaluation/analyze_results.py

What this means:

• 4× F1 — in our benchmark, on our dataset. Open and reproducible.
• 11× fewer tokens — the 269 and 2,982 figures are averages across 19 benchmark domains.
• F1 rises with depth — CKG 0.37 at 1 hop → 0.77 at 5 hops. RAG is flat. Graph traversal does not degrade at depth; retrieval does.
• GraphRAG — not a meaningful improvement over RAG at higher token cost. The word "graph" is not the win. A pre-compiled, declared graph is.

One derived metric we use internally: Retrieval Density Score (F1 ÷ tokens per query). CKG scores roughly 42× higher than RAG on this ratio. It is not a standard benchmark metric — we use it to reason about accuracy-per-token efficiency.

Full benchmark paper →

Domain Library

68 free · no API key required

Mathematics calculus · pre-calc · algebra-1 · linear-algebra · geometry-course · statistics-course · functions · fft-benchmarking

Engineering & Computer Science circuits · digital-electronics · computer-science · quantum-computing · signal-processing · intro-to-graph

Life Sciences biology · bioinformatics · genetics · ecology · chemistry

Clinical & Health (free) glp1-obesity · glp1-muscle-loss · dementia

Regulatory & Government fda-drug-approval-chain · fda-adverse-event-chain · federal-procurement-chain · gao-oversight-chain

AI, ML & Data machine-learning-textbook · data-science-course · conversational-ai · langchain-core · dbt-core · apache-iceberg

AI Tools (provider graphs) claude-anthropic · claude-skills · cursor · deepseek · gemini-api · grok-xai · kimi-moonshot · midjourney · openai-platform · qwen · vercel-ai-sdk

Robotics & Physical AI ros2-architecture · robot-motion-planning

Learning & Pedagogy prompt-class · tracking-ai-course · automating-instructional-design · microsims · infographics · it-management-graph

Business & Society economics-course · personal-finance · ethics-course · theory-of-knowledge · systems-thinking · digital-citizenship · blockchain · unicorns

Reference & Culture art-of-war · laudato-si · learning-linux · us-geography · asl-book · reading-for-kindergarten · moss

Free vs Pro

Activate in 60 seconds:

export CKG_API_KEY=cs_live_your_key_here
# restart your MCP client — all 97 domains appear in list_domains()

Get Pro → graphifymd.com/pro

Agent Blueprints

Pre-built agent specs: which domains to load, step-by-step workflow, ready-to-paste system prompt, and a LangGraph orchestration hint. Skip writing the context layer from scratch.

list_agent_blueprints()
→ gpu-inference-optimizer      — trace GPU bottlenecks, surface optimization paths
  context-as-a-service-advisor — design CKG-based retrieval pipelines

get_agent_blueprint("gpu-inference-optimizer")
→ Required domains: nvidia-gpu-inference, context-as-a-service
  Workflow: diagnose → trace prerequisites → identify path → recommend
  Prompt template: [ready to paste]
  LangGraph hint: StateGraph · 4 nodes

The Six Tools

All read-only. No database. No embeddings. No API key for free domains.

Why Graphify.md

ckg-mcp is the core product of Graphify.md.

We build the context optimization layer that sits between agents and the domains they operate in. The same layer that powers this package runs inside enterprise deployments, sealed appliances, and custom vertical CKGs.

What we can say without overstating:

• The benchmark is open and reproducible — not self-reported, verifiable
• The graphs are human-authored and human-reviewed — not generated
• The methodology is patent pending — not just a wrapper around an existing system
• Plain CSV DAGs, MIT-licensed for free domains — no lock-in

Compatibility — model-agnostic:

No graph database. No vector store. Python ≥ 3.10. Single dependency (mcp). stdio transport.

Custom Domains & Enterprise

The free and Pro catalog covers breadth. Enterprise needs are specific: your regulatory environment, your internal taxonomy, your product domain, your data stack.

Graphify.md builds and maintains custom CKG domain graphs for enterprise teams — compressed, versioned, deployed over your MCP stack.

Sealed Appliance — a private CKG + query server in your environment. Air-gapped. Your data stays yours.

Typical entry: a pilot on your highest-value domain, delivered in one session, measured against your existing retrieval setup.

Corrections Welcome

Spotted a wrong edge? A RELATES_TO that should be REQUIRES? A missing concept?

Edge corrections are the highest-value contribution — the graph gets more useful with every fix. Open an issue or PR on GitHub.

Ecosystem

EVAL

benchmark: ckg-benchmark v0.6.2
dataset: huggingface.co/datasets/danyarm/ckg-benchmark
benchmarked: true
this_domain_f1: 0.471
queries_tested: 19
rag_baseline_f1: 0.123
graphrag_baseline_f1: 0.120
mean_tokens: 269
paper: github.com/Yarmoluk/ckg-benchmark/blob/main/paper/main.pdf

Citation

@misc{yarmoluk2026ckg,
  title  = {Benchmarking Knowledge Retrieval Architectures Across Educational
            and Commercial Domains: RAG, GraphRAG, and Compressed Knowledge Graphs},
  author = {Yarmoluk, Daniel and McCreary, Dan},
  year   = {2026},
  note   = {v0.6.2. https://github.com/Yarmoluk/ckg-benchmark}
}