# Knowledge graph A pre-built weighted graph of skills, agents, MCP servers, and harnesses in the ctx ecosystem, shipped as `graph/wiki-graph.tar.gz`. The on-disk JSON and `resolve_graph` Python API are harness-aware, including plain-slug graph walks from `harness:` nodes. `ctx-monitor` exposes skill/agent/MCP/harness wiki and graph views. Harness installation, update, and uninstall are handled by `ctx-harness-install`; dashboard load/unload POSTs deliberately reject harnesses and return the dry-run CLI command to use instead. Quality scoring is exposed for sidecar-backed skills, agents, and MCP servers. ## What's in it Authoritative numbers from the shipped tarball. The curated-core snapshot is **12,934 nodes** (1,470 curated skills + 467 agents + 10,790 MCP servers + 207 harnesses). Harness pages under `entities/harnesses/` are ingested into local rebuilds and the separate harness recommendation path. The tarball also carries **68,494 skill pages**; **67,024** skill bodies are hydrated as installable `SKILL.md` files in the wiki-pack base under `converted/`; the **28,612** entries over the configured line limit were converted to gated micro-skill orchestrators. Full original bodies are used during graph rebuilds for semantic similarity, but `SKILL.md.original` backups, transient `.lock` files, `.ctx/` queue state, local generated markdown catalogs, and host-user paths are omitted from the shipped tarball. | | Count | |---|---:| | Total nodes | **79,958** | | Curated core nodes | **12,934** (1,470 skills + 467 agents + 10,790 MCP servers + 207 harnesses) | | Body-backed skill nodes | **67,024** hydrated installable skill entries | | Total edges | **1,778,069** | | Hydrated skill incident edges | **1,516,298** | | Hydrated skill semantic incident edges | **911,922** | | Communities | **52** (Louvain) | | Edge sources (overlap-deduped) | semantic 1,088,763 - tag 474,837 - token 280,275 | | Cross-type edges (skill <-> agent) | ~52,382 | | Cross-type edges (skill <-> MCP) | ~30,295 | | Cross-type edges (agent <-> MCP) | ~229 | | Harness edges | **5,063** | | Shipped skill index | **67,024** observed body-backed skill entries | ## Install Use `ctx-init --graph` to install the fast runtime graph. Source checkouts use `graph/wiki-graph-runtime.tar.gz`; pip installs download the matching GitHub release asset for the installed package version. This installs `graphify-out/*`, the skill index used by recommendations, and the harness pages used by `ctx-harness-install`: ```bash ctx-init --graph ``` The runtime install includes a small actionable fallback set that does not depend on an external catalog or API key: - skills: `ctx-python-testing`, `ctx-python-state-protocols`, `ctx-python-input-boundaries`, `ctx-python-api-compatibility`, `ctx-javascript-testing`, `ctx-rust-patterns`, and `ctx-typescript`; - agent: `ctx-python-reviewer`; - MCP server: `ctx-core`, installed only as the exact bare `ctx-mcp-server` command. These nine project-owned entities are MIT licensed and use reserved `ctx-*` identities. Installation preserves unrelated skill, agent, MCP, and converted-skill content; runtime-managed harness pages are refreshed from the installed artifact. Installation fails closed on identity or overlay collisions, changed reserved bodies, symlinked ancestors, command arguments, or substituted executable paths. To install the full shipped wiki, including the wiki-pack base for skill/agent/MCP entity pages, skill pages, concept pages, converted micro-skill pipelines, direct harness pages, and Obsidian vault metadata, request the full wiki artifact explicitly: ```bash ctx-init --graph --graph-install-mode full ``` Manual extraction is still supported for offline/source installs. Extract the full tarball into your `~/.claude/skill-wiki/` when you want local wiki browsing through ctx's merged pack/local view: ```bash mkdir -p ~/.claude/skill-wiki tar xzf graph/wiki-graph.tar.gz -C ~/.claude/skill-wiki/ ``` The extracted tree also opens directly as an Obsidian vault — the `.obsidian/` config ships inside the tarball — so you can use Obsidian's native graph view if you prefer it to the web dashboard. ## How edges are built Edges are built and explained by the `ctx-wiki-graphify` console script (`ctx.core.wiki.wiki_graphify`). A pair must first have at least one base signal: 1. **Semantic cosine** — when the embedding backend is available, entity text is embedded and semantic neighbors above the configured build floor contribute weighted edges. The default backend is `sentence-transformers`. Setting `intake.embedding.backend` to `ollama` uses `intake.embedding.base_url`, then `OLLAMA_URL` when set, then `http://localhost:11434`; non-local hosts require `intake.embedding.allow_remote: true`, and empty or malformed values fail closed. 2. **Explicit frontmatter tags** — each entity page's YAML `tags:` list contributes edges between every pair of entities that share a tag. Popular tags capped at 500 nodes to avoid noise-floor "everything connects to everything" mega-buckets like `typescript` or `frontend`. 3. **Slug-token pseudo-tags** — each hyphenated slug contributes its tokens as implicit tags. `fastapi-pro` contributes `fastapi`; `python-patterns` contributes `python` and `patterns`. A stop-word filter drops generic tokens like `skill`, `agent`, `pro`, `expert`, `core` so they don't over-connect the graph. 4. **Source overlap** — pages with the same high-specificity source URL, repository URL, homepage, detail URL, or package URL can connect even when their tags differ. Dense source buckets are skipped. 5. **Direct wikilinks** — explicit entity links such as `[[entities/agents/code-reviewer]]` create a direct graph edge. Edge `weight` is the final blended strength. Semantic, tag, and token weights form the base blend from `config.json`; source overlap and direct links add configured boosts. Existing edges can also receive explainable ranking boosts from Adamic-Adar shared-neighbor structure, type affinity, usage telemetry, and quality scores. Those boost-only signals do not create edges by themselves. The shipped default `graph.min_edge_weight` is `0.03`; calibration against the 2026-05 shipped graph showed this is the highest floor with zero edge loss, while `0.05` would remove roughly 29.7% of edges. Edge metadata keeps the ingredients explainable: `semantic_sim`, `shared_tags`, `shared_tokens`, `shared_sources`, `direct_link`, `adamic_adar`, `type_affinity`, `usage_score`, `quality_score`, `edge_reasons`, and `score_components`. Hydrated skill records use their full source bodies during graph rebuilds, so long converted entries keep full-body similarity even though the shipped installable `SKILL.md` files are short gated loaders. The raw `SKILL.md.original` backups are build inputs, not tarball members. ## Communities After edges are built, `wiki_graphify` runs NetworkX's Louvain community detection (`resolution=1.2`, `seed=42` for determinism). The result is **52 communities** ranging from single-member isolated specialists to several thousand members in broad clusters like `Community + Official + AI`. Each community also gets an auto-generated `concepts/.md` wiki page summarizing its members and top shared tags. The legacy CNM ("greedy modularity") algorithm is still available behind `CTX_GRAPH_COMMUNITY=cnm` — it's deterministic but O(n²) on dense graphs and hangs on the live 13K-node dataset (~50min run was killed on 2026-04-27 inside the priority-queue siftup). Louvain is the default because it finishes in seconds and produces equivalent quality clusters for the recommendation use case. ## Querying the graph ### Via the dashboard ```bash ctx-monitor serve # http://127.0.0.1:8765 ``` Then open `/graph?slug=&type=` for the dashboard's interactive SVG neighborhood view, or `/api/graph/.json?type=&hops=1&limit=40` for the dashboard-shaped JSON. The `type` query is optional for unique slugs and recommended for duplicate slugs such as `langgraph`. See the [dashboard reference](dashboard.md) for the full route catalogue. ### Via Python ```python import json from pathlib import Path from networkx.readwrite import node_link_graph raw = json.loads( Path("~/.claude/skill-wiki/graphify-out/graph.json").expanduser().read_text() ) edges_key = "links" if "links" in raw else "edges" G = node_link_graph(raw, edges=edges_key) # 79,958 nodes, 1,778,069 edges print(G.number_of_nodes(), G.number_of_edges()) # Find entities related to 'fastapi-pro' by edge weight seed = "skill:fastapi-pro" neighbors = sorted( G.neighbors(seed), key=lambda n: G[seed][n]["weight"], reverse=True, )[:10] for n in neighbors: shared = G[seed][n].get("shared_tags", []) print(f" w={G[seed][n]['weight']:>2} {G.nodes[n]['label']:<40} {shared[:3]}") ``` The node-link JSON schema's edges key is auto-detected (legacy NetworkX 2.x used `"links"`; current versions default to `"edges"`). The helper `resolve_graph.load_graph()` does this for you. ### Via recommendation paths The graph backs these recommendation paths: - Execution recommendation surfaces (`ctx.recommend_bundle`, `ctx.recommend_related`, MCP `ctx__recommend_bundle` / `ctx__recommend_related`, generic harness tools, LoopFlow/agent-loop adapter capability and related recommendations, Claude Code hook suggestions, and repo-scan advisory output) share `ctx.core.resolve.recommendations.recommend_by_tags` for skills, agents, and MCP servers. That engine ranks candidates by slug-token matches, tag overlap, graph degree, and semantic-cache signals when available. Imported skill results are normal `skill` nodes with detail URLs, install commands, duplicate hints, gated micro-skill loaders when over the line threshold, and quality/security metadata. Recommendation contracts also carry each row's full tags plus wiki availability fields (`installable`, `load_status`, and `source_path`), suppress selected/rejected/active/default-baseline context, and can filter unavailable, external-service, generic-planning, or wrong-language rows for local/no-key coding loops. If an older extracted wiki has the skill index JSON but no graph nodes for those records, the same recommender falls back to the index file. - Harness recommendations are a separate path for custom/API/local model onboarding (`ctx-init --model-mode custom ...`), `ctx-harness-install`, and LoopFlow/agent-loop adapter calls that pass explicit user-owned/API/local model consent. Model/provider fields can improve ranking, but the LoopFlow adapter does not treat them as consent by themselves. Harness paths use the same graph filtered to `harness` nodes and the higher harness match floor from `config.json`. - Repository scans still start from stack detections, then turn that profile into the same tag/query bundle used by the execution recommender. If a shipped graph is unavailable, scan output falls back to the legacy installed skill resolver so a plain profile scan remains useful. Harnesses are intentionally not emitted from repo scans or Claude Code hook bundles. This split is intentional: execution surfaces need identical ranking and a small top-K, while harness choice changes the model runtime itself and belongs in an explicit onboarding/install flow. ## Modular graph and wiki packs ctx is moving the graph and LLM-wiki from "one huge tarball is the mutable truth" to this operational model: ```text immutable base graph pack + small graph overlay packs + tombstones for deletes + immutable base wiki pack + small wiki overlay packs -> merged reader for dashboard, search, recommendations, and repair tools ``` The user-facing behavior is intended to stay the same: recommendations, dashboard graph views, wiki pages, and harness setup still read the merged graph/wiki as one catalog. The difference is how updates are stored. Adding or updating one skill, agent, MCP server, or harness can write a small overlay pack instead of forcing a full graph and wiki rebuild. For local dashboard/search reads, wiki-pack pages override physical files at the same relative path, active wiki tombstones hide deleted paths, and safe local-only entity files that are not present in a pack or tombstone still participate in the catalog. This makes normal updates faster and safer: - **Faster adds/updates** - the worker writes a page overlay and, when the vector index exists, attaches ANN-based graph edges for the changed entity. - **Efficient deletes** - deletes become tombstones in graph/wiki overlays, so removed entities disappear from merged reads without rewriting the base pack. - **Crash isolation** - overlay packs and compaction manifests are written atomically; a failed update does not corrupt the base snapshot. - **Same recommendation contract** - merged graph reads preserve edge metadata, scores, provenance, and tombstones before resolver/dashboard code sees the graph. Pack directories live inside the installed wiki: ```text ~/.claude/skill-wiki/ graphify-out/packs/base-/ graphify-out/packs/overlay-/ wiki-packs/base-/ wiki-packs/overlay-/ ``` Pack manifests require every checksum value to be a lowercase 64-character SHA-256 hex digest. Non-hex placeholders are rejected before merged graph/wiki readers can trust the pack contents. Overlay packs are the normal local-update path. Full rebuilds are still needed when you intentionally refresh the release artifact, change global scoring configuration, rebuild communities, or compact a long chain of overlays into a new base snapshot. To stage a coordinated graph+wiki compaction without mutating the active wiki: ```bash ctx-pack-compact compact \ --wiki-path ~/.claude/skill-wiki \ --base-export-id \ --staging-dir /tmp/ctx-pack-stage \ --json ``` The staging directory contains a top-level `pack-compaction-manifest.json` plus staged graph and wiki base packs. Promotion validates the top-level manifest, graph pack manifest, wiki pack manifest, checksums, matching export IDs, and graph/wiki entity consistency before replacing active packs: ```bash ctx-pack-compact validate \ --staged-graph-packs-dir /tmp/ctx-pack-stage/graph-packs \ --staged-wiki-packs-dir /tmp/ctx-pack-stage/wiki-packs \ --require-compaction-manifest \ --json ``` ```bash ctx-pack-compact promote \ --wiki-path ~/.claude/skill-wiki \ --staged-graph-packs-dir /tmp/ctx-pack-stage/graph-packs \ --staged-wiki-packs-dir /tmp/ctx-pack-stage/wiki-packs \ --json ``` Promotion refreshes the SQLite dashboard/recommendation graph store by default. Use `--graph-store-db ` to refresh a non-default store, or `--no-graph-store-refresh` only when you plan to rebuild it separately: ```bash ctx-pack-compact validate \ --wiki-path ~/.claude/skill-wiki \ --json ctx-graph-store build \ --graph-dir ~/.claude/skill-wiki/graphify-out \ --db ~/.claude/skill-wiki/graphify-out/graph-store.sqlite3 ctx-graph-store validate \ --db ~/.claude/skill-wiki/graphify-out/graph-store.sqlite3 ``` ### LLM-wiki design references ctx follows Karpathy's LLM-wiki pattern. We also reviewed [`nashsu/llm_wiki`](https://github.com/nashsu/llm_wiki) as a design reference for source traceability, persistent ingest queues, graph insights, and budgeted token/vector/graph retrieval. That repository is GPLv3, while ctx is MIT, so ctx can use those ideas as product inspiration but must not copy or vendor its code or assets. ## Rebuilding After you add a skill, agent, MCP server, or harness entity page: ```bash ctx-wiki-worker --wiki ~/.claude/skill-wiki --limit 1 ``` The `entity-upsert` worker path validates the queued page hash, updates the wiki index, and, when a persisted semantic vector index exists, runs a best-effort ANN attach into `graphify-out/entity-overlays.jsonl`. That overlay lets the runtime resolver connect a new or updated entity to existing graph neighbors without recomputing global all-pairs similarity. When modular wiki packs exist, the same write is mirrored into a wiki overlay pack; deletes are mirrored as wiki tombstones. The worker also queues a graph-store refresh so dashboard and resolver reads see the merged view. The active wiki page is the pack page when one exists, otherwise the local entity markdown file unless a pack tombstone hides that relative path. For manual review or debugging: ```bash ctx-incremental-attach calibrate \ --graph ~/.claude/skill-wiki/graphify-out/graph.json ctx-incremental-attach attach \ --index-dir ~/.claude/skill-wiki/.embedding-cache/graph/vector-index \ --overlay ~/.claude/skill-wiki/graphify-out/entity-overlays.jsonl \ --node-id skill:fastapi-review \ --type skill \ --label fastapi-review \ --text-file ~/.claude/skill-wiki/entities/skills/fastapi-review.md \ --dry-run ``` Shadow-gate a persisted index before trusting a new ANN backend, changed thresholds, or a large attach workflow: ```bash ctx-incremental-shadow \ --index-dir ~/.claude/skill-wiki/.embedding-cache/graph/vector-index \ --graph ~/.claude/skill-wiki/graphify-out/graph.json \ --sample-size 100 \ --min-overlap 0.85 ``` The shadow command pretends sampled existing nodes are new, compares the incremental attach result to batch graph semantic neighbors, and reports precision, recall, top-5/top-10/top-20 agreement, score deltas, and bad examples. A failing gate means either tune thresholds or use a full graph rebuild before shipping. If the vector index is missing, rebuild it without repacking artifacts: ```bash ctx-wiki-graphify \ --wiki-dir ~/.claude/skill-wiki \ --incremental \ --graph-only \ --semantic-vector-index numpy-flat ``` Then drain pending entity-upsert work with `ctx-wiki-worker --wiki ~/.claude/skill-wiki`. This is the current repair path for "build index" and "attach pending" without adding another command surface. Before publishing graph artifacts, run the full rebuild/export path: ```bash ctx-wiki-graphify # rebuild entity graph + communities ``` The pre-commit hook (`.githooks/pre-commit`) does **not** rebuild or repack graph artifacts from `~/.claude/skill-wiki/`; that local wiki can contain private entities. It refreshes cheap README stats when relevant checked-in files are staged and warns when entity sources changed. Run `ctx-wiki-graphify`, validate, repack, and stage the artifacts explicitly for skill, agent, MCP server, or harness releases. Graphify exports stage and validate each generated artifact before atomic promotion. `graph.json`, `graph-delta.json`, `communities.json`, `graph-report.md`, and `graph-export-manifest.json` each get a sibling `*.promotion.json` file with candidate, current, and `last_good` hashes plus rollback metadata. Queue-driven promotion accepts only graphify artifacts named `graph.json`, `graph-delta.json`, `communities.json`, `graph-report.md`, or `graph-export-manifest.json` under `/graphify-out/`, plus the release artifacts allowlisted under repo `graph/`, and always from sibling `.staged` files. Staged and target symlinks are rejected. Validators are selected from the target suffix: JSON, JSONL, gzip JSON, gzip JSONL, full wiki tar, and runtime graph tar each get the matching structural check before promotion. The manifest is promoted last, so a crash between artifact promotion and manifest promotion is detected as an incomplete export and the next run rebuilds instead of trusting mixed graph files. Artifact validation also treats privacy and fanout as release contracts: archive JSON, graph-pack node/edge metadata, markdown members, and merged wiki-pack markdown must not contain host-user paths; markdown members are capped at 10 MiB; local generated markdown such as `catalog.md`, `converted-index.md`, `log.md`, and `versions-catalog.md` must stay out of the full archive. When a shipped root artifact has sibling promotion metadata, validation also checks the `current` snapshot against the actual artifact size and SHA-256 so stale promotion records cannot describe a different file. ## Current artifact record This page is intentionally current-state only. Older graph sizes made the public page look stale even when the headline table was correct, so historical refresh notes live in `CHANGELOG.md` instead of being repeated here. The shipped artifact currently records **79,958 nodes**, **1,778,069 edges**, **52 Louvain communities**, **1,088,763 semantic edges**, **474,837 tag edges**, and **280,275 slug-token edges**. The current build is fully reproducible from the wiki content and the checked-in graph build configuration. ## Pre-ship gates Three advisory gates run before the tarball is repackaged. All three produce review reports and never auto-modify the inventory. - **`ctx-dedup-check`** — flags entity pairs (skill ↔ skill, skill ↔ agent, skill ↔ MCP, agent ↔ agent, agent ↔ MCP, MCP ↔ MCP) at or above 0.85 cosine similarity. Incremental: keeps a `dedup-state.json` next to the embedding cache, so follow-up runs only re-check pairs involving entities whose content changed. Allowlist support via `.dedup-allowlist.txt`. The current snapshot has 15,976 findings, most of which are within-MCP near-duplicates (multiple wrappers around the same upstream service). - **`ctx-tag-backfill`** — finds installed skills/agents with empty `tags:` frontmatter and proposes a backfill from slug tokens and an allowlist of body keywords. Existing tag frequency breaks keyword ties. Report-only by default; pass `--apply` to write. Backfills are additive only. - **`ctx-skillspector-audit`** — runs a static `--no-llm` check over shipped skill bodies with [NVIDIA SkillSpector](https://github.com/NVIDIA/SkillSpector), writes `graph/skillspector-audit.jsonl.gz`, and stamps skill entity pages in the full wiki artifact. This is a ctx-run check, not NVIDIA endorsement or certification.