Visualizing & Navigating Your Hermes Knowledge Base

Deep Research: Solutions Comparison, Pros/Cons, Demo Links, and Auto-Linking Enforcement

Date: 2026-08-14 Why this doc exists: Rahul’s 5 pain points with the hermes repo (673 files, 362 markdown docs, 424 commits in 30 days):

Hard to visualize artifacts/documents on GitHub
Don’t understand what each document/folder is for
Can’t see how one document links to another / why something is relevant
Can’t find a document, topic, or output easily
Too much output — finding a needle in a haystack

Methodology: Deep-mined NotebookLM notebook “Building the Ultimate AI Second Brain with Hermes and Obsidian” (39 sources — Hermes docs, Reddit threads, GitHub repos, YouTube, articles) via 10 targeted queries, plus web research for verification. All raw Q&A responses are saved as notes inside that notebook. Every demo link in this doc was verified live (HTTP 200) on 2026-08-14.

1. The Solution Landscape (everything the research surfaced)

Tier 1 — Web Publishing for Markdown Vaults ⭐ (the serious candidates)

These turn your existing markdown repo into a website you open in any browser — no desktop app, no sync, no new device setup. This is the tier that solves your problems.

1.1 Quartz 4/5 (jackyzha0/quartz) — 13k stars, MIT, free

What: Static site generator built for Obsidian-style markdown. Converts a folder of .md into a full website with interactive graph view (click a node → see everything it links to and is linked by), backlinks section on every page, full-text search, tags, dark mode.
How you’d use it: A GitHub Action builds the site on every push → deploy to GitHub Pages or Netlify → https://<you>.github.io/<repo>/.
Auto-linking: Supports [[wikilinks]] natively; a community plugin adds automatic backlink generation; combined with a title-mention auto-linker script (see §3), the graph fills itself.
Pros: Purpose-built for exactly your case (Obsidian-flavored markdown → web with graph); free; huge community (Discord, 4k forks); fast (SPA-like); deployable to any static host; supports Mermaid, callouts, embeds.
Cons: Node.js toolchain (npm build step in CI); default UI is utilitarian (can be themed); graph of 360+ docs is only useful with filters/grouping.
Where to see it live:
- Quartz showcase page — curated list of real gardens with graphs (start here!)
- Jacky Zhao’s own garden — graph + backlinks in action
- Data Engineering Vault — “A Second Brain Knowledge Network” — a vault like yours
- Quartz docs themselves — dogfoods graph view
- Video: Publish your notes for free with Quartz (GitHub Pages)

1.2 Foam (foambubble/foam) — 17.4k stars, MIT, free

What: PKM system built on VS Code + GitHub. Same markdown + [[wikilinks]]; has graph visualization (in VS Code) and a built-in GitHub Pages publishing path — it generates markdown link-reference definitions so wikilinks work natively in GitHub’s UI and Pages without a build step.
Pros: Zero-lock-in plain markdown; your Obsidian vault is already a Foam workspace; git-native; Foam CLI (search/lint) and foam-mcp exist for agents; simplest possible web path (static markdown on Pages).
Cons: Officially “alpha-grade” (their words: “high tolerance for alpha-grade software”); graph view lives in VS Code, NOT on the published site (the web output is a plain wiki, no graph); requires VS Code on your desktop to get the graph experience.
Where to see it live: Foam docs site — note: this is a docs site, not a graph demo. The graph is in VS Code, so there is no public web graph demo — that’s the tradeoff.

1.3 obsidian-html — free, Python, MIT

What: Python converter: Obsidian vault → static HTML site. Supports [[wikilinks]], backlinks, graph view in 2D/3D (Note-Graph), FlexSearch full-text search.
Pros: No Node.js; simple pipeline (obsidian-html command → HTML → host anywhere); graph + search + backlinks included; actively developed.
Cons: Less polished UI than Quartz; smaller community; graph rendering is a library integration rather than a first-class feature.
Where to see it live: obsidian-html GitHub Pages demo — shows the converter’s own site; usage article

1.4 Flowershow — free OSS (hosted Pro $50/yr)

What: Publish Obsidian vault as a website with knowledge graph on every page (current note centered, connections radiating; global graph in a modal), backlinks, search, Bases support.
Pros: Graph-first like Quartz; very polished out of the box; deploy via GitHub Pages/Vercel/Netlify.
Cons: Smaller community than Quartz; hosted Pro tier for advanced features; younger project.
Where to see it live: Flowershow landing/showcase — has an examples list; Obsidian forum announcement

1.5 MkDocs Material — free, Python (no graph)

What: The standard docs-site generator. Beautiful navigation, instant search, tags.
Pros: Best-in-class search and navigation; trivial to deploy; huge ecosystem.
Cons: No graph view, no backlinks — it’s a documentation site, not a knowledge graph. Solves “find things” but not “see how things connect”.
Where to see it live: MkDocs Material demo

Tier 2 — Desktop-Only Visualization (work, but tied to a device)

2.1 Obsidian (native) — free

Graph view + backlinks of [[wikilinks]]. The gold standard locally. But: desktop app (mobile app exists but sync across VPS + devices is exactly the hassle you want to avoid). The Reddit research (see §5) shows global graph is “90% vibes” beyond ~50 nodes — your 362 docs would be a blob without heavy filtering.

2.2 Hermes Agent Obsidian Plugin “Smart Graph” — free, desktop-only

The most interesting find: the official Hermes Obsidian plugin has a Smart Graph that sends note titles + excerpts to Hermes in one LLM call and renders semantic edges (shared topics, prerequisites, contradictions) on top of wikilinks — a graph that understands why docs relate, not just that they do. Cached in graph-cache.json, max-notes cap, edge-strength filter.
Cons: Desktop-only (community listing: “Platforms: Desktop only”), no web view. Requires the local gateway (port 8642).
Where to see it: Obsidian Community Plugins → “Hermes Agent” (5k downloads). No web demo exists.

2.3 InfraNodus AI Graph View — Obsidian plugin, PAID (subscription)

3D knowledge graph of concepts extracted from text, network-science clustering, betweenness centrality, semantic gap detection (“blind holes” — ideas that should connect but don’t). Browser extension + web version exist via SaaS account.
Cons: Paid subscription (14-day trial; 50% lifetime discount code INFRANODUSOBSIDIAN2024); needs account for full features.
Where to see it live: infranodus.com (web version demos); plugin page on Obsidian directory.

2.4 Logseq (with Matryca MCP) — free, local-first

Block-level outliner; every bullet is a linkable node; built-in graph view; plain markdown on disk. The Reddit/source research strongly favors Logseq for agent-driven editing (surgical block edits, MOC auto-building, tag hygiene via the Matryca MCP server) — but no web publishing path was found in the research, and the outliner format would require migrating your existing docs. Logseq DB version is “rough/alpha” per users.

2.5 Augmented Canvas — free, desktop-only, stale (2 years, needs gpt-4-1106-preview)

GPT-4 canvas augmentation. Not relevant to your problem; listed for completeness.

Tier 3 — Agent Memory Layers (they manage agent context, not your browsing)

Tool	What it does	Auto-linking?	Web view?	Fit
open-second-brain (itechmeat)	Obsidian-native memory layer via MCP/CLI; `Brain/` of markdown; nightly “dream passes” consolidate rules; explainable search; co-occurrence edge proposals	✅ proposes edges (co-reference scoring)	❌ relies on Obsidian graph	Strong for agent-side context, doesn’t solve human browsing
ai-memory-vault (jaredrhod)	Template system (MEMORY.md/USER.md/VAULT-INDEX.md) + AI Priming	❌	❌	Lightweight, but manual memory promotion, token bloat at scale
obsidian-agent-memory-skills (AdamTylerLynch)	Agent skill package; scaffolds vault; graph-traversal orientation at session start	partial	❌	Agent-side only

Key finding: None of Tier 3 gives you a browser view. They improve my ability to remember — not your ability to see.

Tier 4 — Code/Repo Mappers ❌ (explicitly NOT for markdown docs)

GitDiagram (gitdiagram.com — replace “hub” with “diagram” in any GitHub URL), repo-visualizer (AbanteAI), ReposLens (reposlens.com), Repowise, Gource.

The research is unambiguous here: these parse code (ASTs, imports, dependencies, git history). The notebook synthesis states they are “not highly suitable for repositories consisting entirely of Markdown documents” — a markdown repo has no ASTs to analyze. GitDiagram would render your folder tree as boxes, not document relationships. Fun for a one-off map; wrong tool for your need. (Gource’s animated git-history tree is a cool “state of the repo” video, not a navigation tool.)

Tier 5 — Graph Databases for Agent Memory ❌ (infrastructure, not UI)

Mem0 + FalkorDB (property-graph agent memory, falkordb-browser exists but shows data triples, not your docs), Zep Graphiti (bi-temporal temporal knowledge graph, 20k stars, powers Zep’s Context Lake — for production agent pipelines, web dashboard is an ops portal). These are for the agent’s memory layer, not for you reading documents. Listed for completeness so you can rule them out confidently.

2. Master Comparison (vs your 5 pain points)

Solution	Web-based (no desktop/sync)?	Interactive graph of doc links?	Backlinks on each page?	Full-text search?	Auto-link docs at publish?	Free?	Setup effort
Quartz 4/5	✅	✅	✅	✅	✅ (script + plugin)	✅	Medium (Node + CI)
Flowershow	✅	✅	✅	✅	✅	✅ OSS	Low-Medium
obsidian-html	✅	✅ (2D/3D)	✅	✅	✅	✅	Low (Python)
Foam	✅ (wiki, no graph on web)	❌ on web (only VS Code)	partial on web	✅	✅ (reference gen)	✅	Low
MkDocs Material	✅	❌	❌	✅	n/a	✅	Low
Obsidian + Smart Graph	❌ desktop-only	✅ (semantic!)	✅	✅	✅ (agent skill)	✅	Medium + device sync
InfraNodus	⚠️ plugin + SaaS	✅ (concept-level)	✅	✅	partial	💰 Paid	Low
Logseq + Matryca	❌ no web path	✅	✅	✅	✅ (agent MCP)	✅	High (migration)
o2b / ai-memory-vault	❌	❌ (Obsidian graph only)	✅ in Obsidian	✅	partial	✅	Medium
GitDiagram / repo-visualizer / ReposLens	✅ (web)	❌ wrong kind (code)	❌	❌	n/a	mixed	n/a

Solves pain point: #1 visualization → Quartz/Flowershow/obsidian-html. #2 what-is-what → auto-generated folder index (any web tier + a script). #3 interconnections → graph + backlinks + auto-linker. #4 findability → full-text search + index. #5 overwhelm → navigation, search, and a clean home page instead of a raw file tree.

3. The Linking Enforcement Question (your core concern)

“How will we enforce linking? It needs to happen automatically or be done by you every time you generate an artifact.”

The research surfaced exactly this pattern — the sources describe the agent “automatically linking related pages during nightly compilation runs” and the official Hermes obsidian skill instructing: “When creating notes, use [[wikilinks]] to link related content.” Three-layer enforcement:

Layer	Mechanism	Who/What	Covers
A. Auto-linker script (deterministic)	GitHub Action runs a Python script on every push: scans all `.md`, finds plain-text mentions of other doc titles, rewrites them to `[[wikilinks]]` (same technique as Obsidian’s Automatic-Linker / Simple Auto-Link plugins, headless in CI)	Script (zero effort, zero tokens)	Exact-title mentions → graph fills automatically
B. Agent-side linking (me, at write time)	Every artifact I generate gets YAML frontmatter (`title/date/tags/related:`) + a `## Related` section with wikilinks to relevant existing docs (found via session_search before writing)	Me, every generation	Semantic links the script can’t catch (different wording, topic-level relations)
C. Pre-push hook (deterministic gate)	New `.md` without frontmatter, or that mentions another doc’s title without linking it → push blocked	Hook (your existing enforcement style)	Can’t be skipped

This matches your established philosophy (deterministic enforcement via hooks, not passive memory) and the notebook sources’ recommendations (agent persona “always use wikilinks” + nightly linking runs).

4. Reality Check (contradicting evidence — steel-man)

From the r/ObsidianMD thread “does anyone actually use graph view for something real, or is it mostly vibes?” (mined in depth):

Global graph = “90% vibes, 10% utility” — top comment: “It’s just productivity porn.” A 362-node global graph is an unreadable “note cloud” (“unstable… if you have more than 50 nodes. The value quickly diminishes”).
What IS useful: the local graph (connections around the current note — “find a pretty decent connection a few hops a lot quicker” +35), orphan/audit spotting (+30), and SEO-style internal-linking analysis (one user literally used it to map blog interlinks — your use case).
Power users bypass the graph for MOCs (Maps of Content / master index pages) + Dataview queries + search.
Implication for you: the graph is an exploration and audit feature, not your primary navigation. The index/MOC layer + search is what makes 362 docs usable. Any solution we pick must have both — which is why the recommendation pairs a graph-capable publisher with an auto-generated index (and why the auto-linker matters: thoughtful links are what keep the graph meaningful).

Other caveats:

Hosting cost analysis (verified 2026-08-14) — private repo scenario. GitHub Actions minutes are NOT the constraint (Free plan: 2,000 min/mo on private repos; a Quartz build is ~2–4 min → ~500+ builds/mo, well above the repo’s ~420 pushes/mo; Pro: 3,000 min/mo; Team/Enterprise: up to 50,000). The actual blocker is GitHub Pages itself: on GitHub Free, Pages CANNOT be published from a private repository (requires GitHub Pro ~$4/mo for personal accounts, GitHub Team for orgs). The site itself is always public even on paid plans — only the source stays private. Options:

Hosting	Private repo?	Free quota	Fits ~420 pushes/mo?
Cloudflare Pages	✅ native Git integration — Cloudflare builds from the private repo, no GitHub Actions needed	500 builds/mo (account-wide), unlimited bandwidth, 1 concurrent build, 20-min timeout	✅ ~420/mo fits
GitHub Pages	❌ Free plan; needs GitHub Pro (~$4/mo)	free builds (10/hr soft cap), 100 GB/mo bandwidth	✅ once on Pro
Netlify Free	✅	300 credits/mo ≈ ~20 prod deploys/mo (credit system since Sep 2025)	❌ not enough
GitHub Actions (for auto-linker CI only)	✅	2,000 min/mo free (private)	✅ (runs are ~30s)

Recommendation: Cloudflare Pages is the $0 p a t h — p r i v a t e - r e p o - na t i v e, u n l imi t e d ban d w i d t h, an d i t r e m o v es G i t H u b A c t i o n s f r o m t h ecr i t i c a l p a t h e n t i r e l y (A c t i o n ss t i l l r u n s t h e a u t o - l ink er / l in tC I, w hi c h f i t se a s i l y in t h e f r ee 2, 000 min / m o) . F a l l ba c k i f y o u p r e f er e v er y t hin g in G i t H u b : G i t H u b P r o a t$ 4/mo enables Pages from the private repo. Netlify is ruled out for this cadence.

Transcripts flood the graph — 170 timestamped session transcripts are chronological records, not knowledge nodes; the site should exclude transcripts/ (or a subfolder) initially.
Repo hygiene: duplicate folders exist (competitor-analysis vs competitor-analyses, cro-analysis vs cro-reports) — worth merging so the site’s structure matches intent.
No secrets found in the repo scan (checked cookies/tokens/keys) — publishing content is safe; still, profiles/ and hermes-config/ are internal plumbing and should be excluded from the published site.

5. Obsidian Deep-Dive: Agent Context vs Human Browsing + Sync (verified 2026-08-14)

Q: Does Obsidian solve agent-context but not human browsing? Partially — it solves both, but neither fully:

Need	Obsidian solves it?	Evidence
Human browsing — web	❌ No official web app exists. Obsidian’s forum: “Obsidian was created specifically because it did not want to be a web app.” Third-party hacks only (Neverinstall, Docker self-host) — unsupported	forum.obsidian.md/t/obsidian-for-web, xda-developers self-host guide
Human browsing — desktop/mobile app	✅ Graph view, backlinks, full-text search (best-in-class locally)	—
Agent context	✅ via the official obsidian skill (vault-native read/write/wikilinks) + Smart Graph plugin (LLM-inferred semantic edges)	hermes-agent obsidian SKILL.md
Turn notes into a website	⚠️ Obsidian Publish add-on — ** $8/ s i t e / m o * * ann u a l (or$ 10 monthly), includes graph view + search	obsidian.md/sync pricing page

Sync options (all verified):

Sync method	Cost	Effort	Covers	Notes
Obsidian Sync Standard	$4/user/mo (annual) — 1 vault, 1 GB, 5 MB max file, 1-mo history	5 min/device	Desktop + mobile, unlimited devices, E2EE	Easiest; official
Obsidian Sync Plus	$8/user/mo (annual) — 10 vaults, 10 GB, 200 MB files, 12-mo history	5 min/device	Same	If you want multiple vaults/long history
Syncthing (self-hosted)	Free	Medium (VPS + each device, share folder)	Desktop + Android ✅, iOS limited	The VPS is the always-on peer — fits existing infra
Self-hosted LiveSync + CouchDB	Free	High (CouchDB + Nginx + TLS on VPS)	All incl. iOS (needs valid HTTPS)	The “free Obsidian Sync” recipe
Git (bare repo + Working Copy)	Free	Medium-high (manual commit/push)	All	Matches existing git discipline; manual

The unified architecture (recommended): one source, three interfaces.

             ┌─────────────────────────────┐
             │  GitHub repo (the vault)     │  ← single source of truth
             │  362 markdown + wikilinks    │    (already exists, git-versioned)
             └──────────────┬──────────────┘
                            │
        ┌───────────────────┼───────────────────┐
        ▼                   ▼                   ▼
  Quartz → Cloudflare   Obsidian app        Hermes (me)
  Pages (web site)      (desktop/mobile,    reads the same files
  graph + search +      optional add-on,    via file tools +
  backlinks — human     synced via          obsidian skill —
  browsing anywhere,    Syncthing/git       agent context
  zero setup)           if you want it)     improves as links +
                                            frontmatter grow

Why this is the answer to “help the agent get better context” too:

The repo is the vault. The agent side needs no new system — every doc with frontmatter (tags, related:) and ## Related wikilinks makes my retrieval faster and more precise (I search these files constantly).
The auto-linker keeps links meaningful for both you and me; Smart-Graph-style semantic edges can be reproduced on the web site as a CI LLM pass (the “nightly dream” pattern from your notebook sources) if wanted.
Obsidian the app is an optional native viewer on the same data — additive, never a new silo, no data migration, no lock-in.
Web site remains the primary zero-setup path (any device, no sync, no app installs).

6. Recommendation

Quartz 4/5 as the publishing layer — it’s the only free option with all three of your headline features (web-based, interactive graph, backlinks + search) and the largest community; its showcase is full of vaults like yours. obsidian-html is the no-Node fallback if you want to avoid npm. Flowershow if you prefer the polished look over Quartz’s utilitarian default.

Plus the three-layer linking enforcement (§3) — the auto-linker script, my write-time linking discipline (frontmatter + Related sections), and the pre-push hook — because a graph without links is a blob, and links without enforcement rot.

Plus the index layer — auto-generated per-folder READMEs + a master index (the MOC idea from the Reddit research), which is what actually makes 362 docs navigable.

Not recommended: Tier 2–5 for this specific need. Obsidian/Smart Graph is excellent but desktop-locked (sync hassle you explicitly want to avoid); InfraNodus is paid; Logseq requires migration with no web path; Tier 3 is agent-side memory; Tier 4/5 are the wrong category entirely.

Proposed build plan (on approval)

Step	What	Time
0	Cloudflare Pages (free, private-repo-native, unlimited bandwidth) — or GitHub Pro (~$4/mo) + GitHub Pages if you prefer staying in GitHub	10 min
1	Scaffold Quartz in repo (or `docs/` branch), GitHub Action: push → build → deploy	30 min
2	Auto-linker script + Action (layer A) + frontmatter validation hook (layer C)	30 min
3	One-time pass: frontmatter + `## Related` sections on ~50 key non-transcript docs (layer B backlog)	45 min
4	Index generator (per-folder READMEs + master index), exclude `transcripts/` + config folders	20 min
5	~~Merge duplicate folder pairs~~ ✅ Done 2026-08-14 (`competitor-analysis`→`competitor-analyses`, `cro-reports`→`cro-analysis` via `git mv`)	10 min

Appendix: All Verified Demo Links (checked 2026-08-14, HTTP 200)

Web-publishable (the candidates):

Quartz showcase (see real graphs): https://quartz.jzhao.xyz/showcase
Quartz docs (dogfoods the graph): https://quartz.jzhao.xyz
obsidian-html demo: https://obsidian-html.github.io/
Flowershow showcase: https://flowershow.app/
Foam docs: https://foambubble.github.io/foam/
MkDocs Material demo: https://squidfunk.github.io/mkdocs-material/
Quartz setup video: https://www.youtube.com/watch?v=6s6DT1yN4dw

Code mappers (wrong category, for reference):

GitDiagram: https://gitdiagram.com
ReposLens: https://www.reposlens.com

Sources behind this research (in your NotebookLM notebook, “Building the Ultimate AI Second Brain with Hermes and Obsidian”, 39 sources):

https://notebooklm.google.com/notebook/a807bc7f-6292-454c-83fb-412c2c5fdb43
Key items: foambubble/foam, jackyzha0/quartz, itechmeat/open-second-brain, jaredrhod/ai-memory-vault, AdamTylerLynch/obsidian-agent-memory-skills, r/ObsidianMD graph-view thread, Hermes Obsidian Plugin docs (Smart Graph), InfraNodus, Mem0+FalkorDB, Zep Graphiti, Matryca/Logseq posts.

All 8 mining Q&A responses are saved as notes in the notebook for you to read in full.

Explorer

Knowledge Base Visualization Comparison