mnem vs graphify

graphify: “AI coding assistant skill (Claude Code, Codex, OpenCode, …). Turn any folder of code, docs, papers, images, or videos into a queryable knowledge graph.” (repo description, safishamsi/graphify) mnem: a content-addressed graph substrate. graphify builds a graph from a folder; mnem is the graph.

At a glance

Feature comparison

Benchmarks (where comparable)

Not directly comparable. graphify produces a static knowledge graph artefact for an assistant to read, not a retrieval API benchmarked on LongMemEval / LoCoMo / etc. Their headline number is a token-efficiency claim (“71.5x fewer tokens per query vs reading the raw files”), measured against a different baseline than mnem’s R@K-on-public-corpora methodology.

graphify’s README points at the memorybench skill (npx skills add supermemoryai/memorybench) for benchmarking, but that harness is supermemory-tilted by default; running mnem through it would require an adapter we have not built.

mnem’s measured retrieval numbers under ONNX MiniLM-L6-v2:

Latency (where measured)

graphify’s user-perceived latency at query time is “LLM reads GRAPH_REPORT.md then traverses graph.json,” which is a different loop entirely.

Architecture differences

graphify is a one-shot CLI you point at a folder. It runs a deterministic AST pass (tree-sitter, 25 languages), transcribes audio and video with faster-whisper using a domain-aware prompt, then runs Claude subagents in parallel to extract concepts and relationships from docs, papers, images, and transcripts. Results are merged into a NetworkX graph, clustered with Leiden community detection (no embeddings; graph topology is the similarity signal), and exported as graph.html (interactive viewer), GRAPH_REPORT.md (plain-language audit), graph.json (queryable), and a SHA256 cache for incremental re-runs. Coding assistants integrate via platform- specific install commands that wire the graph into rules / hooks / AGENTS.md so the assistant always considers it before searching raw files.

mnem is a runtime substrate, not a one-shot extractor. You commit nodes and edges, then retrieve via a 3-lane fused query (HNSW dense + BM25 / SPLADE sparse + graph traversal) under explicit RRF weights and a token budget. There is no LLM in the write path. Identity is a content CID, history is a signed commit DAG, and the graph evolves by commit + diff + merge rather than by re-extraction. mnem ships embedded; the same Rust core compiles to WASM unchanged.

The two are complementary more than competitive: graphify is a great ingestor for the kind of corpora mnem stores (run graphify on a folder, ingest the resulting graph into mnem). They do not solve the same problem.

Where graphify clearly wins

• Multimodal ingest in one command. Code, PDFs, markdown, screenshots, diagrams, whiteboard photos, video, audio, in 25 languages via tree-sitter. mnem ingests text and structured commits; you bring your own multimodal extractor.
• Coding-assistant integration breadth. 15+ named platforms with install commands (Claude Code, Codex, OpenCode, Copilot CLI, VS Code Copilot Chat, Aider, Cursor, Gemini CLI, OpenClaw, Factory Droid, Trae, Hermes, Kiro, Antigravity).
• PreToolUse hooks. Inject “the graph exists, read it first” into Claude Code / Codex / OpenCode tool flows automatically.
• Static, portable artefact. graph.html opens in any browser; graph.json ships in a repo; auditors read GRAPH_REPORT.md.
• Confidence tags on relations. EXTRACTED / INFERRED / AMBIGUOUS lets a reader filter what was found vs guessed.
• No vector DB needed. Leiden over graph topology produces communities without embeddings.

Where mnem clearly wins

• Runtime, not one-shot. mnem keeps serving as your corpus grows; graphify is a re-extract loop.
• No LLM in the write path. graphify’s concept extraction is Claude-subagent-driven by design. mnem ingests deterministically.
• Content-addressed identity + commit DAG. Stable identity across re-runs and machines; full diff / 3-way merge. graphify regenerates a fresh NetworkX graph.
• Hybrid retrieval API. Vector + sparse + graph fused with token- budget metadata. graphify exposes traversal slash-commands but no retrieval API.
• Embedded + WASM. Same retrieval logic in Rust, Python, TS, MCP, Workers, Lambda. graphify is a Python CLI.
• License. Apache-2.0 vs MIT (both permissive; matters in some corporate review contexts).

When to pick graphify, when to pick mnem

Pick graphify if: you want a folder -> queryable knowledge graph in one command, you need multimodal extraction (video / audio / images), you want an always-on coding-assistant integration, or you need a static artefact you can ship in a repo.

Pick mnem if: you need a runtime memory substrate, you require deterministic ingest, you want content-addressed identity and a real commit DAG, you are building a product (not a personal coding assistant), or you need embedded / WASM deployment.

You can also pair them: graphify as the multimodal extractor, mnem as the runtime substrate that holds the resulting graph and serves queries.

Sources

• graphify repo, sha 770d7f54c40d on v5, 2026-04-26: https://github.com/safishamsi/graphify
• graphify README (“How it works”, “Install”, “Make your assistant always use the graph”, “Benchmarks”): https://github.com/safishamsi/graphify/blob/v5/README.md
• mnem README: /README.md
• mnem benchmarks: /benchmarks/proofs/v0.1.0/