⚠ Updated 2026-06-28: scope narrowed to 2D renderers (3D dropped). The ADDENDUM below is the current verdict; the original full report follows.
Date: 2026-06-28 (same session). Trigger: operator narrowed scope — drop 3D ("confusing and overkill"); want a pure visual rendering engine like the Obsidian graph view, but more customizable. This supersedes §1–§2's 3D framing for the renderer pick. The agent layer (§3), integration (§5), UX (§6), and second-brain (§4) findings are unchanged.
Verified anchor (the framing fact): Obsidian's graph view — and its graph plugins (e.g. Graph Link Types) — render with PIXI.js (WebGL 2D) on a d3-force layout [deep-read: graphaware blog, Neo4j Medium, obsidianstats]. So "like Obsidian but more customizable" = a WebGL-2D force-graph renderer with deeper customization hooks than Obsidian exposes. That is exactly the category below.
All licenses/dates re-verified by Hermes against npm + GitHub API, 2026-06-28 (§ ledger).
| Engine | License | Render tech | Customization depth | Scale (smooth) | Recency (verified) | React | Verdict |
|---|---|---|---|---|---|---|---|
| Sigma.js v3 + graphology | MIT | WebGL 2D | Custom node/edge "programs" (WebGL shaders) + reducers for LOD/hover/highlight — unlimited, programmatic | ~10k–100k | sigma v3.0.3 2026-04-30; @react-sigma/core v5.0.6 2025-12 | @react-sigma/core |
★ PRIMARY — same architecture as Obsidian (WebGL+d3-force) but productized with far more hooks; the natural "Obsidian-but-better" |
| Cytoscape.js | MIT | Canvas (2D) | Deepest declarative styling — CSS-like stylesheet, arbitrary node shapes, compound/nested nodes, huge extension ecosystem (layouts, edgehandles, popper, context-menus) | ~few-thousand→~10k (canvas) | v3.34.0 2026-06-02 | 3rd-party wrappers | ★ ALT-PRIMARY — pick if customization = node shapes/styling/compound nodes + interaction plugins over raw scale |
cosmos.gl (@cosmos.gl/graph) |
MIT | GPU (WebGL2) | Points + lines + clusters; less per-node shape control | 1M+ | v3.0.0 2026-06-17 | DIY wrapper | BIG-GRAPH MODE — when scale dominates customization. Avoid the non-commercial @cosmograph/* packages |
| react-force-graph-2d | MIT | Canvas (2D) | nodeCanvasObject custom draw; easy, animated |
few-thousand | v1.29.1 2026-02-04 | First-class | FAST-SHIP — quickest Obsidian-ish feel; less deep than Sigma/Cytoscape |
| PIXI.js + d3-force (custom) | MIT | WebGL 2D | Total pixel-level control | 10k+ w/ effort | pixi v8.19.0 2026-06-04 | manual | DIY CEILING — literally Obsidian's stack; only if you want fully bespoke and accept build cost |
| reagraph (2D mode) | Apache-2.0 | WebGL (three.js) | Built-in clustering/edge-bundling; React-native | ~10k | v4.32.0 2026-06-25 | Native | Viable, but three.js under the hood is heavier than Sigma for pure-2D |
| AntV G6 v5 | MIT | Canvas/WebGL | Full 2D framework, very customizable | tens of thousands | v5.1.1 2026-05-08 | DIY | Powerful but heavy API; framework not just renderer |
The pick comes down to what "more customizable" means to you:
Primary engine: Sigma.js v3 + graphology — it is the WebGL-2D, d3-force renderer that matches
Obsidian's architecture while exposing far more customization (node/edge programs, reducers, theming),
embeds in React via @react-sigma/core, and consumes Graphify's {nodes,links,community} JSON directly
(map community → color; Louvain via graphology). Add cosmos.gl as the big-graph mode behind the
same data layer (it's the only verified OSS engine that scales to 1M+).
Choose Cytoscape.js instead as primary only if the product's differentiator is declarative node styling / compound nodes / interaction plugins and graphs stay ≤~10k — then customization depth beats Sigma and the scale ceiling is acceptable.
This keeps the rest of the architecture (§5/§6/§8 of the main report) intact — same Graphify-JSON pipeline, same Mastra read/write tools, same bidirectional chat↔graph wiring — just swap the 3D renderer for Sigma (2D-WebGL) as default and cosmos.gl for scale. Net: simpler than the two-renderer 3D plan, and a closer match to the Obsidian mental model the operator anchored on.
| Claim | Verified | Source |
|---|---|---|
| Obsidian graph view = PIXI.js (WebGL 2D) + d3-force | confirmed | graphaware.com blog; medium.com/neo4j; obsidianstats.com/tags/graph-view |
| Sigma.js v3.0.3, MIT, WebGL, custom programs + reducers | 2026-04-30 | registry.npmjs.org/sigma; api.github.com/repos/jacomyal/sigma.js |
| @react-sigma/core v5.0.6 MIT | 2025-12-01 | registry.npmjs.org/@react-sigma/core |
| Cytoscape.js v3.34.0, MIT, canvas, declarative stylesheet + extensions | 2026-06-02 | registry.npmjs.org/cytoscape |
| cosmos.gl v3.0.0 MIT, GPU, 1M+ | 2026-06-17 | registry.npmjs.org/@cosmos.gl/graph |
| react-force-graph-2d v1.29.1 MIT, canvas | 2026-02-04 | registry.npmjs.org/react-force-graph-2d |
| pixi.js v8.19.0 MIT (Obsidian's renderer) | 2026-06-04 | registry.npmjs.org/pixi.js |
| @cosmograph/* = CC-BY-NC non-commercial (avoid) | confirmed | registry.npmjs.org/@cosmograph/react |
Tier: T-deep (decision-grade). Owner: hermes (research). Date: 2026-06-28. For: Pantheon + Viska/client knowledge-base product (Graphify graphs + Mastra agents on Railway). Method: 4 parallel in-session research sub-agents (NOT the banned deep-research harness), each primary-source with per-claim recency tags, + Hermes independent verification of the load-bearing claims (npm registry + GitHub API, §9). Visual/UI build routes to Apollo (Hermes specs the content/data/capability layer; wireframes + visual design are Apollo's domain).
Scope answers (operator): web app = React/Next.js · scale = mixed (small isolated + giant) → tiered recommendation · 3D = preferred, open to 2.5D/2D-GPU where it wins at scale.
Adjacent in-flight work (cross-ref, not duplicate): proteus #207 Graph Viewer v1 — registry + collector + gallery (internal fleet graph viewer; different scope from this client-facing 3D product). Agora research-dashboard spec (Hermes, 2026-06-12) and OKF/graphify two-tier AION (2026-06-24) are the data-model lineage this plugs into.
There is no single library that renders a beautiful 3D graph at every scale. The honest, verified answer is a two-renderer tier with one shared data + agent layer:
react-force-graph-3d (vasturiano, MIT). The best
free out-of-box animated true-3D look: link particles, bloom/glow, camera fly-through, custom
Three.js node geometry. This is the "wow," navigable 3D view for a single client knowledge base.
React-native alternative with built-in cluster rendering: reagraph (Apache-2.0, freshest
serious option — v4.32.0, 2026-06-25) — use it if you want React components + 2D↔3D toggle +
community/edge-bundling out of the box rather than vanilla wiring.cosmos.gl (@cosmos.gl/graph, MIT, OpenJS
Foundation project, v3.0.0 2026-06-17). The only OSS engine that credibly runs an in-browser
GPU-resident force simulation at 1M+ nodes. It is 2D-GPU, not 3D — so this is an explicit
mode switch for the big-graph case, not a replacement for the 3D view.graphology (MIT) — standard JS graph model + Louvain
community detection, which maps directly onto Graphify's clustered-community output.🔴 License trap (verified, load-bearing): the polished Cosmograph product packages
(@cosmograph/cosmograph, @cosmograph/react) are CC-BY-NC-4.0 — non-commercial. You cannot ship
them in a paid client product. The underlying engine @cosmos.gl/graph is MIT and commercial-safe
— build a thin React wrapper around the engine, do not depend on the @cosmograph/* UI packages.
🔴 helios-web has NO license file → all-rights-reserved → unusable commercially.
Agent layer — the reframe that de-risks the whole thing: the client already has a graph (Graphify
output) and a TypeScript Mastra runtime on Railway. They do not need a Python GraphRAG engine to
build a graph. The thin, rule-#18-clean path is a graph DB (Neo4j or Postgres/pgvector) + two Mastra
tools (read + write), 100% TypeScript, one Railway service. Graduate to a Graphiti sidecar
(Apache-2.0, REST/MCP, temporal write-back, 28k★, very active) only when you want automatic temporal
entity-resolution instead of hand-written MERGE logic.
Fork-base to start from: ChristopherLyon/graphrag-workbench (MIT, 619★) — Next.js 15 + React 19
+ react-three-fiber 3D GraphRAG viewer with NL chat and color-coded communities. Caveat (verified): last
pushed 2025-09, so it's a skeleton to fork, not a maintained dependency.
All dates/licenses below independently re-verified by Hermes against npm + GitHub API (§9).
| Library | License | 3D? | React | Practical scale | Recency (verified) | Why it matters |
|---|---|---|---|---|---|---|
| react-force-graph-3d | MIT | True 3D (Three.js) | First-class component | ~5–10k (drops past ~7k) | v1.29.1, 2026-02-04 | Best turnkey animated 3D: particles, bloom, fly-to, custom nodes |
| reagraph | Apache-2.0 | 2D + 3D | Native React (r3f) | hundreds→~10k | v4.32.0, 2026-06-25 | Only pick with built-in clustering + edge-bundling + 2D↔3D toggle; freshest |
| react-three-fiber + drei + ngraph | MIT | True 3D, bespoke | The R3F substrate | engineer to 100k+ | r3f 2026-05-07; ngraph 2026-06-23 | Total control / custom shaders — multi-week build cost |
| Babylon.js | Apache-2.0 | True 3D (WebGPU backend) | 3rd-party wrapper | 100k+ instances | push 2026-06-27 | WebGPU-native engine; no graph abstraction (build it) |
cosmos.gl (@cosmos.gl/graph) |
MIT | 2D-GPU (flag) | DIY wrapper | 1M+ | v3.0.0, 2026-06-17 | The giant-graph engine; GPU force sim in shaders; OpenJS |
~~@cosmograph/cosmograph / /react~~ |
CC-BY-NC-4.0 ⚠ | 2D-GPU | yes | 1M+ | v2.3.2, 2026-05-03 | EXCLUDED — non-commercial. Use cosmos.gl engine instead |
| Sigma.js v3 | MIT | 2D only | @react-sigma/core |
~10k–100k | v3.0.3, 2026-04-30 | Mature 2D WebGL; LOD/reducer king; mid-tier middle ground |
| AntV G6 v5 | MIT | mostly 2D/2.5D | DIY | tens of thousands | v5.1.1, 2026-05-08 | Enterprise 2D framework + WebGPU layouts; heavy API |
| graphology | MIT | n/a (data) | n/a | millions (model) | v0.26.0, 2025-01-26 | Data + Louvain clustering layer under any renderer |
| ~~helios-web~~ | NONE ⚠ | 2D+3D GPU | DIY | "large" | push 2026-06-28 | EXCLUDED — no license = all-rights-reserved |
| NetV.js | MIT | 2D-GPU | DIY | 50k nodes/1M edges (paper) | push 2025-05-27 | Render-only (no layout), semi-dormant |
| GraphGPU / GraphWaGu | MIT | 2D | DIY | unproven | 2026-03 / 2025-07 | WebGPU frontier — experimental (<50★), watch don't ship |
| Graphistry | server commercial | 2D-GPU | client-api-react | 100M+ edges (server) | client 2025-07 | Needs a GPU server (paid SaaS/self-host); iframe embed |
| Ogma / ReGraph (KeyLines) | paid | 2D | ReGraph=React | 100k+ (vendor) | commercial | Polished commercial escape hatch if OSS support insufficient |
Recency-verified ALIVE (proven by npm/GitHub date): react-force-graph-3d, reagraph, cosmos.gl, Sigma.js v3, AntV G6, Babylon.js, react-three-fiber, ngraph, graphology. Release-stale / risky: VivaGraphJS (npm frozen 2019), Orb (npm 2024-02), NetV.js / GraphWaGu / GraphGPU (research-grade).
3D force graphs are gorgeous in demos but at 100k+ nodes they suffer occlusion (near nodes hide far ones), depth ambiguity (hard to judge connectivity), and per-node cost that caps Three.js in the low-tens-of-thousands. Every verified high-scale OSS engine (cosmos.gl, NetV.js) is 2D for this reason.
react-force-graph-3d / reagraph.Recommendation: ship a mode switch, not one renderer. Small/medium client graphs default to the 3D view; when a graph exceeds the Three.js comfort zone (~10k), transparently fall to the cosmos.gl 2D-GPU mode. Both read the same Graphify JSON and the same Louvain community ids.
Write-back reality check — genuine cheap runtime node/edge mutation: Graphiti, neo4j-graphrag, LightRAG, HippoRAG 2, txtai, Cognee. Batch index-then-query (read-only after build): MS GraphRAG, KAG. Per-doc-ingest-only: R2R, nano/fast-graphrag.
| Engine | License | Recency (verified) | Writes back? | TS/JS? | Integration shape | Best at |
|---|---|---|---|---|---|---|
| Graphiti (getzep) | Apache-2.0 | v0.29.2 2026-06-08, 28k★ | Yes (bi-temporal, incremental) | Python-only | MCP + FastAPI REST sidecar | Real-time temporal agent memory |
| Cognee | Apache-2.0 | v1.2.2 2026-06-26 | Yes | @cognee/cognee-ts (Py primary) |
REST + MCP | Mixed data → graph+vector memory |
| neo4j-graphrag | Apache-2.0 | v1.18.0 2026-06-24 | Yes (true runtime MERGE) | Python-only | library (front it yourself) | Official incrementally-writable Neo4j KG |
| LightRAG | MIT | v1.5.4 2026-06-24 | Yes (set-merge) | Python-only | REST server | Strongest incremental open GraphRAG + REST |
| MS GraphRAG | MIT | v3.1.0 2026-05-28 | No (batch re-index) | Python-only | CLI/lib (no REST) | Highest-fidelity community-summary retrieval (static corpus) |
| txtai | Apache-2.0 | v9.10.0 2026-06-04 | Yes (upsert) | JS/Java/Go bindings | REST + MCP | Polyglot embeddings+graph w/ native MCP |
| R2R (SciPhi) | MIT | v3.6.5 2025-06 | per-doc ingest | r2r-js |
REST + MCP | Production RAG platform w/ real JS SDK |
| Letta / MemGPT | Apache-2.0 | v0.16.8 2026-05-14 | Yes (self-edit memory) | Py + TS | REST (it's a whole runtime) | Turnkey stateful agents (heaviest lock-in) |
| Mem0 | Apache-2.0 | 2026-06-27 | OSS graph module REMOVED 2026-04 | First-class JS+Py | self-host/hosted REST | Conversational memory (NOT a KG in OSS anymore) |
| Zep OSS | — | EOL → legacy/ |
— | — | — | Deprecated → use Graphiti |
| KAG, nano-graphrag, fast-graphrag, HippoRAG | MIT/Apache | 2024–2025, research-pace | mixed | Python-only | varies | Research / niche / dormant |
neo4j-driver, first-class TS) or Postgres. Give
the Mastra agent a read tool (Cypher/SQL + vector search over node embeddings) and a write tool
(MERGE new node/edge). Agent reads → summarizes → proposes topics → writes back through the same
driver. One Railway service, 100% TS, zero Python sidecar, zero lock-in, rule-#18 clean. Graphify's
community structure maps to graph labels/properties directly.MERGE. Deploy its FastAPI or MCP
server as a 2nd (Python) Railway service; Mastra is a first-class MCP client. Cost: a Python service +
Neo4j/FalkorDB. The strongest engine if you outgrow hand-rolled tools.@neo4j-labs/agent-memory (Neo4jMastraMemory) — official TS Mastra memory provider. But it's
shaped for conversation/entity memory, not the domain KG — it complements option 1, not replaces it.@mastra/mem0 — add for conversational chat memory (Mem0-memorize/remember tools), NOT the
domain graph (Mem0 OSS dropped graph mode 2026-04).Honesty flag: the strongest engines (Graphiti, neo4j-graphrag, LightRAG, MS GraphRAG) are Python-only. Native-TS graph read+write is a much shorter list than the hype implies → which is exactly why option 1 (own the tools in TS over a graph DB) is the lowest-risk MVP path given the existing Mastra runtime.
| App | OSS? | Graph view? | AI read? | AI write back? | Note |
|---|---|---|---|---|---|
| Copilot for Obsidian | AGPL-3.0 | hosts Obsidian graph | Yes (Vault-QA RAG) | Yes — Composer writes/edits w/ diff | ⭐ cleanest OSS graph+chat+write-back combo |
| Smart Connections (Obsidian) | MIT | semantic "Smart Graph" | Yes (local embeds) | weak (suggests links) | meaning-based related notes |
| Logseq | AGPL-3.0 | Yes | plugins | plugins | DB-version beta |
| SiYuan | AGPL-3.0 | Yes | built-in chat | limited | block-based PKM |
| Khoj | AGPL-3.0 | partial | Yes (chat/RAG) | agents create notes | also an Obsidian plugin |
| AnythingLLM | MIT | no graph | Yes | Yes (Doc-Gen writes files) | great RAG, no graph view |
| Onyx/Danswer | MIT | AI-built retrieval KG | Yes (enterprise chat) | no | enterprise connectors |
| Reor | AGPL-3.0 | similarity links | Yes (local RAG) | no | ARCHIVED 2026-03 — dead |
| Cosma / Foam | OSS | Yes | no built-in | no | static MD→graph |
| Tana / Reflect / Saga / Mem | closed | structured graph | Yes | Yes (AI write) | closed-source patterns |
Takeaway: no OSS PKM ships a 3D graph + chat + agent write-back out of the box — that combination is a build, not an adopt. The closest pattern references to copy are Copilot-for-Obsidian (graph + Vault-QA + write-back-with-diff UX) and InfraNodus (gap detection + AI research-question generation — the literal "suggest new topics to research" feature, see §6).
Data shape: Graphify emits { nodes:[{id,label,community,…}], links:[{source,target,weight}] } —
already the exact {nodes,links} shape react-force-graph / cosmos.gl expect. Map community → color once
at load (nodeAutoColorBy="community" for zero-config, or a precomputed brand palette).
Layout by scale:
- ≤~5k → live d3-force-3d sim in react-force-graph-3d; warmupTicks≈100 to pre-settle, then
cooldownTicks={0} to freeze a stable, navigable layout.
- >~50k → do not live-sim in 3D. Either switch to cosmos.gl (GPU sim, 2D) or precompute layout
server-side (bake x,y,z into JSON, render frozen) and cache it keyed by graph version.
Next.js (App Router) gotchas — #1 failure mode:
1. WebGL is client-only → must dynamic(() => import('./Graph'), { ssr:false }); SSR throws
window is not defined.
2. Mark wrapper 'use client'; keep the graph a leaf so the rest of the page still SSRs.
3. Hold a ref to the ForceGraph instance for imperative calls (cameraPosition, zoomToFit,
emitParticle, d3ReheatSimulation) from chat handlers.
Streaming a large graph: ego-first (seed + k-hop, fetch next ring on click, merge immutably); viewport culling; for multi-million rows cosmos.gl uses Apache Arrow + DuckDB-Wasm for zero-copy transfer + in-browser filter/aggregate.
inputSchema + outputSchema: query-graph(query, seedId?) →
{ nodeIds[], answer, subgraph:{nodes,links} }. execute runs Cypher / SQL / JSON traversal.tool-{toolKey} message parts with
states input-streaming → input-available → output-available. Client useChat() maps message.parts;
on part.type==='tool-queryGraph' & state:'output-available', read part.output.nodeIds and drive
the 3D view → graphRef.current.cameraPosition(...) fly-to + recolor/highlight. For a progressive
"agent walking the graph" effect, emit custom data parts context.writer.custom({ type:
'data-graph-highlight', data:{ nodeIds } }); client lights nodes/particles as the agent reasons.onNodeClick(node) → sendMessage({ text:\Tell me about
${node.label}`, data:{ seedId:node.id } }); agent's ego-graph retrieval seeds onseedId`.mcp-neo4j (schema + read/write Cypher tools)
or gds-agent (centrality/community tools). Mastra is both an MCP client and can author one MCP
server reused by chat + other agents.community; push clusters apart spatially
(Force-Atlas / cosmos.gl setPointClusters + setClusterPositions) so clusters read by position,
not just hue (InfraNodus pattern).nodeReducer + labelRenderedSizeThreshold is canonical
— only labels above a screen-size threshold draw, so zooming reveals more. react-force-graph: gate
label/nodeThreeObject on camera distance.cameraPosition({x,y,z}, lookAt, ms) eased fly + zoomToFit; cosmos.gl
CosmographSearch + fitView.postProcessingComposer); linkDirectionalParticles +
emitParticle() for particle-flow ("agent traced this path"); depth fog via the Three scene; camera
easing; custom glowing nodeThreeObject sprites.| Repo | What it gives | Recency (verified) | License |
|---|---|---|---|
| ChristopherLyon/graphrag-workbench | Closest match: Next.js 15 + React 19 + R3F 3D GraphRAG viewer, NL chat (local/global/drift), color-coded communities, search→highlight. Best skeleton to fork; add the bidirectional nodeIds→camera wiring. |
619★, push 2025-09-09 (skeleton, not maintained) | MIT |
| vasturiano/react-force-graph | The 3D engine + dozens of copyable examples (bloom, particles, fly-to, highlight-neighbors, expandable tree) | active, ~3.2k★ | MIT |
| cosmosgl/graph (cosmos.gl) | GPU million-node engine; v3 setPointClusters, findPointsInRect, fitView, search |
v3 2026-06-17, 1.17k★ | MIT |
| SinketsuZao/AGENTiGraph | 7-agent pipeline (Intent→Concept→Planning→KG-Interaction→Reasoning→Response→Update) NL→Cypher→Neo4j→React. Copy the agent-role decomposition for Mastra. | 19★, 2025-03 (small but real) | MIT |
| getzep/graphiti | Temporal KG engine + MCP/FastAPI servers — the option-2 sidecar | 28k★, 2026-06-27 | Apache-2.0 |
| neo4j-contrib/mcp-neo4j | Official MCP servers (schema + read/write Cypher) — drop-in Mastra graph tools | active | MIT (verify) |
| logancyang/obsidian-copilot | Graph + Vault-QA + Composer write-back-with-diff UX to mimic | active | AGPL-3.0 |
| InfraNodus | Pattern reference for gap-detection + AI research-question generation (closed source) | active | proprietary |
Graphify JSON ──► Graph store (Neo4j OR Postgres/pgvector) ──► Mastra agent (Railway, TS)
{nodes, ▲ │ tools:
links, │ │ read (cypher/sql + vector)
community} │ └─ write (MERGE node/edge)
│ │ suggest-gaps (betweenness/community-bridge)
▼ │
React/Next client │ (agent writes back: new nodes/edges/topics)
├─ 3D mode → react-force-graph-3d (≤10k) │
├─ Big mode → cosmos.gl (2D-GPU, 1M+) │
├─ data layer → graphology (Louvain) │
└─ chat (assistant-ui / @ai-sdk/react useChat)
⇅ bidirectional:
agent answer → nodeIds → cameraPosition()+highlight (tool-output / data-graph-highlight parts)
node click → sendMessage(seedId) (ego-graph retrieval)
Build sequence:
1. Fork graphrag-workbench as the Next.js + R3F shell; strip its Python GraphRAG backend.
2. Load Graphify JSON into a graph DB (Neo4j first-class TS driver, or Postgres/pgvector if you want
one store for graph + embeddings). Keep community ids.
3. Wire two renderers behind a scale switch: react-force-graph-3d (default 3D) + cosmos.gl (big mode).
Use graphology for Louvain + client-side metrics.
4. Add three Mastra tools — query-graph (read), write-node (write-back), suggest-gaps (research
topics). Stream via @mastra/ai-sdk + useChat.
5. Bidirectional UI — tool output-available + custom data-graph-highlight parts drive the camera;
onNodeClick seeds the chat.
6. Defer: Graphiti sidecar (graduate when you want temporal entity-resolution); WebGPU engines (watch);
VR/AR (react-force-graph-vr, only if it's a product goal).
Rule #18 (no-vaporware) status: clean. Every component is adopt/integrate — graph DB + driver, existing OSS renderers, existing Mastra runtime. The only net-new code is the thin React wrapper around cosmos.gl, the three Mastra tools, and the bidirectional UI glue. No engine is rebuilt.
Hermes independently verified the load-bearing claims (npm registry + GitHub API, 2026-06-28):
| Claim (load-bearing) | Verified value | Source |
|---|---|---|
@cosmos.gl/graph is MIT (commercial-safe) |
MIT, v3.0.0, 2026-06-17 | registry.npmjs.org/@cosmos.gl/graph |
@cosmograph/react is non-commercial |
CC-BY-NC-4.0, v2.3.2 | registry.npmjs.org/@cosmograph/react |
| reagraph license/freshness | Apache-2.0, v4.32.0, 2026-06-25 | registry.npmjs.org/reagraph |
| react-force-graph-3d license | MIT, v1.29.1, 2026-02-04 | registry.npmjs.org/react-force-graph-3d |
| fork-base graphrag-workbench real + license + recency | MIT, 619★, pushed 2025-09-09, not archived | api.github.com/repos/ChristopherLyon/graphrag-workbench |
| cosmosgl/graph real + MIT + active | MIT, 1173★, pushed 2026-06-18 | api.github.com/repos/cosmosgl/graph |
| Graphiti real + Apache + very active | Apache-2.0, 28k★, pushed 2026-06-27 | api.github.com/repos/getzep/graphiti |
| AGENTiGraph real | MIT, 19★, 2025-03 | api.github.com/repos/SinketsuZao/AGENTiGraph |
Sub-agent-sourced claims (primary, recency-tagged in raw returns, not independently re-run by Hermes):
Mem0 OSS graph-module removal (PR #4805, 2026-04) [deep-read, mem0 docs]; Sigma.js/G6/deck.gl scale
ceilings [snippet]; Mastra streaming part-types + context.writer.custom [deep-read, mastra docs];
Next.js ssr:false WebGL requirement [deep-read]; InfraNodus gap-detection feature [deep-read].
Caveats (stated-confidence, not gating the verdict):
- No single 3D lib spans all scales — the recommendation is explicitly a two-renderer mode switch.
- graphrag-workbench is a skeleton (last push 2025-09) — fork it, don't depend on it as a live package.
- WebGPU graph engines (GraphGPU/GraphWaGu) are architecturally the future but too immature (<50★) to
ship — re-scout in ~6 months.
- "(verify)" licenses on mcp-neo4j and a few PKM repos not re-confirmed against LICENSE this pass.
- Raw sub-agent reports (4 clusters, full tables + ledgers) appended in raw/ for audit.
Method note: research run in-session with 4 parallel sub-agents + Hermes verification, per the standing ban on the deep-research Workflow harness. Tier declared T-deep up front; load-bearing claims gated on verified primary sources.