Context7-grounded evaluation of every serious memory-layer option for Viewport's OpenClaw + Hermes stack. No defaults. No training data. Every claim cited.
What "never-amnesia" actually means for Viewport's stack.
Every fact, decision, and agent output lives as a .md file in a Git repo. Blame, diff, PR review — the human layer is always intact. No proprietary DB format holds the truth. If the index dies, git clone gets you back to 100%.
Every brain tool must be reachable as an MCP tool call from Hermes, OpenClaw, Claude Code, and Codex without a custom adapter. The brain is not a chat UI — it's a function library agents call on demand.
The brain gets smarter while Sam sleeps. A nightly dream cycle ingests new pages, extracts entity edges, consolidates duplicates, and writes gap-analysis notes back to the vault — without human intervention.
Querying the brain returns synthesized prose with inline citations, not a ranked list of page excerpts. The agent reads the pages; Sam reads the answer. Gap analysis ("what the brain doesn't know yet") is surfaced explicitly.
/opt/data/workspace/mac-platformx-deploy-audit/source (271 notes, 8.1 MB). The infrastructure is not zero-to-one — it's choosing which pieces to promote to canonical brain status.
Seven options, six axes. Every cell grounded in Context7 or live repo evidence — cited below.
| Tool | What it is | Git-versioned / files-as-truth | Agent-native (MCP) | Graph | Grounded answers | Self-enrichment loop | Fit for Viewport |
|---|---|---|---|---|---|---|---|
| GBrain garrytan/gbrain · GitHub |
Opinionated OpenClaw/Hermes agent brain. 21.6k stars. TypeScript. PGLite or Postgres. Built by Garry Tan (YC CEO) to run his own agents: 146,646 pages, 24,585 people, 5,339 companies, 66 cron jobs live in production. | Partial Pages stored in Postgres/PGLite, not raw markdown on disk. ADR-0001 compliance requires exporting markdown. Graph + semantic index are the truth in GBrain's model, not files. | Native gbrain serve exposes an MCP server. gbrain connect wires it into Claude Code or Codex in one command. OpenClaw/Hermes integration is first-class, documented in AGENTS.md. |
Yes Self-wiring knowledge graph. Every page write extracts entity refs and creates typed edges (attended, works_at, invested_in, founded, advises) with zero LLM calls. P@5 49.1%, R@5 97.9% on BrainBench. |
Yes Synthesis layer returns prose with inline citations + gap analysis ("what the brain doesn't know yet"). Not a ranked chunk list. | Yes 24/7 dream cycle: ingest, enrich, consolidate, fix citations overnight. 66 cron jobs verified in production. Agents install and operate the cycle autonomously. | Strong Purpose-built for OpenClaw+Hermes. MCP-native. Dream cycle is the loop Viewport needs. Main gap: files are not the truth (ADR-0001 tension). |
| Obsidian vault stevenstavrakis/obsidian-mcp · GitHub · Context7: /stevenstavrakis/obsidian-mcp |
Local markdown vault with backlinks, tags, Dataview queries. obsidian-mcp exposes read-note, create-note, edit-note, search-vault, manage-tags as MCP tools over stdio. | Yes Native. Vault IS the filesystem. Every note is a .md file. Git-commit the vault folder → full history. This is the canonical files-as-truth model. |
Yes obsidian-mcp: 9 tools (read, create, edit, delete, move, search, add-tags, remove-tags, rename-tag). Config: npx obsidian-mcp /path/to/vault. Multi-vault support. |
Weak Backlinks + tags give implicit graph. Obsidian-Dataview can query like a DB (TABLE file.ctime, tags FROM #project). No typed relationship edges. No graph traversal for "who invested in what". |
Partial Obsidian returns note content. Synthesis is the agent's job, not the vault's. No built-in gap analysis. Strong for human-readable capture; weak for auto-grounded answers. | Manual Obsidian has no built-in cron loop. Agent must be told to write back. Templater + Dataview can automate within sessions; nightly enrichment requires external tooling. | Primary layer ADR-0001 native. The markdown vault IS Sam's brain files. Pairs with GBrain or Graphify for graph indexing. Already running on VPS (271 notes, 8.1 MB). |
| NotebookLM Google · notebooklm.google.com |
Google's multi-source synthesis engine. Upload PDFs, docs, URLs. Generates grounded Q&A, summaries, podcasts, study guides, all with citations tied to source passages. | No Sources live in Google's cloud, not in a Git repo. No file-system truth model. No diff, no blame. Exporting is manual. Not suitable as the canonical brain. | No No MCP server. No programmatic API for agents to call. Interaction is browser-only or notebooklm CLI (requires browser auth). Cannot be called from Hermes/OpenClaw loops. | No No knowledge graph. Sources are flat documents. Relationships are inferred by the LLM at query time only — not persisted. | Yes NotebookLM's core strength: synthesis with source-grounded inline citations. Answers are traceable to exact passages. "What doesn't this notebook cover?" is surfaced implicitly. | No No self-enrichment. No cron. No write-back. Static once sources are uploaded. Manually maintained. | Specialist only Best-in-class for human-facing synthesis of a fixed document set (investor deck, legal docs, meeting corpus). Not a living agent brain. Use as output layer, not source of truth. |
| Graphify safishamsi/graphify · GitHub · Context7: /safishamsi/graphify |
AI coding assistant skill that reads files across multiple formats, builds a knowledge graph of the codebase, and surfaces architecture insights and relationships between concepts. 3,547 code snippets in Context7. | Yes Reads files from the filesystem. Source files are the truth. Graph is a derived index, not the canonical store. ADR-0002 compliant. | Yes Ships as a Claude Code skill. Extraction subagent dispatched per-chunk. Output is typed JSON graph fragments (nodes + edges + hyperedges). Integrates with OpenClaw/Hermes skill system. | Yes Extracts EXTRACTED (explicit), INFERRED (structural), AMBIGUOUS edges. Confidence scoring (0.1–1.0). Hyperedges for 3+ node patterns. Cross-file semantic similarity edges. Typed edge relations: calls, implements, references, rationale_for. | Partial Graph answers structural questions ("what calls what", "which files share this data structure"). Not a prose synthesis layer. Grounded on code/doc structure; not on meeting notes or people data. | Skill-triggered Runs per-session or per-cron when invoked. No built-in nightly dream cycle. Needs a cron job to re-extract after code changes. | Code-graph layer Fills the gap GBrain leaves for codebase architecture. Best choice for "how does the OpenClaw router work, structurally?" Not a people/decisions brain. Pairs with Obsidian vault. |
| LLM Wiki vanillaflava/llm-wiki-skills · GitHub · r0b0tlab/llm-wiki_obsidian_hermes_r0b0tlabbra1n |
Markdown-vault-as-wiki with six agent skills. Compounding knowledge grows with every conversation. Works with Obsidian, Logseq, or plain folders. Local LLM friendly. SQLite FTS5 search, tier-based memory. | Yes Markdown files on disk. Git-trackable. Filesystem is the truth. SQLite index is a helper (ADR-0002 compliant). | Partial Skills integrate with Claude Code and Hermes. No published standalone MCP server. Agent must call the skill, not an MCP endpoint directly. | No Flat markdown. No typed relationship graph. Backlinks only. Cannot answer relational queries without LLM inference at query time. | Partial FTS5 search + tier-based retrieval. LLM synthesizes from retrieved chunks. No dedicated synthesis layer or gap analysis built in. | Skill-triggered Grows with conversation. No autonomous cron loop. Enrichment happens when agents write notes. Human discipline required. | Lightweight alt Good if GBrain is overkill and Obsidian-MCP is already in place. Lower complexity; lower power. Not a primary brain for Viewport's scale (271+ notes, multi-agent, 24/7 loop). |
| Neo4j agent memory neo4j.com/labs/agent-memory · Context7: /llmstxt/neo4j_llms_txt |
Neo4j Labs MemoryClient: short-term (conversation), long-term (knowledge graph), reasoning traces. GraphRAG: hybrid vector + full-text + graph traversal. O(1) relationship lookups. MCP Toolbox integration. | No Neo4j is a graph DB, not a file store. Data lives in the DB. Exporting to markdown is a custom ETL job. Not files-as-truth. ADR-0001 requires treating Neo4j as a rebuildable index only. | Yes Google MCP Toolbox provides neo4j/execute-cypher and neo4j/schema as MCP tools. MemoryClient exposes short_term, long_term, reasoning APIs. Already running on VPS at bolt://127.0.0.1:7687 (Neo4j 5.26.23). |
Yes Native. Knowledge graph construction via SimpleKGPipeline. GraphRAG: HybridCypherRetriever combines vector index + full-text + Cypher graph traversal. P@5 and relationship queries at O(1). Best graph option in the stack. |
Yes GraphRAG returns LLM-synthesized answers grounded in graph context. Graph traversal answers relational questions that pure vector search cannot reach. | Possible Neo4j supports stored procedures and scheduled jobs (APOC triggers). MemoryClient reasoning traces can drive enrichment. Not turn-key; requires custom cron wiring. | Rebuildable index Already live. Best graph query engine in the stack. Use as the relational index rebuilt from markdown vault + Graphify output. Never as primary truth store per ADR-0001. |
| mem0 mem0ai/mem0 · mem0ai/mem0-mcp · Context7: /mem0ai/mem0 (score 91.9) |
Universal self-improving memory layer. Cloud-managed or self-hosted. Semantic search over memories scoped to user_id, agent_id, app_id, run_id. MCP server ships as mem0-mcp-server. Already running: platformx-mem0 (Up 5 weeks), Qdrant collections mem0_memories + mem0migrations live. |
No Memories stored in Qdrant vectors + Postgres metadata. Not raw markdown. No file-system truth model. Exporting to markdown is possible via API but not native. | Native mem0-mcp-server exposes 9 MCP tools: add_memory, search_memories, get_memories, get_memory, update_memory, delete_memory, delete_all_memories, delete_entities, list_entities. Connects via uvx mem0-mcp-server with MEM0_API_KEY env. |
Optional enable_graph: true on agent-scoped memories enables graph memory. Not the default. Graph is secondary to the vector/semantic layer. |
Partial Semantic search returns ranked memories. LLM synthesizes context. No dedicated prose-synthesis layer. No gap analysis. | Yes Self-improving: extracts entities and preferences automatically on add_memory. Memory decays and consolidates over time. The closest thing in the stack to an autonomous self-enrichment loop (other than GBrain). | Agent working memory Best for per-agent/per-session short-term recall ("what did this agent learn last run?"). Not a human-readable vault. Pairs with Obsidian as the long-term markdown truth. Already live on VPS. |
Sam's pattern: Obsidian + Hermes + NotebookLM as Capture → Automate → Answer → Publish → Repeat.
Meetings, decisions, agent outputs, code rationale — every artifact is written to the Obsidian vault as a .md file. The obsidian-mcp create-note tool is the agent's write path. Git commit anchors each write to a point in time. This satisfies ADR-0001: the files are the brain.
mem0 handles the ephemeral layer: per-session agent memories (what this specific Hermes agent learned in the last run) that do not yet deserve a permanent vault note. mem0's add_memory auto-extracts entities and preferences.
Hermes runs a cron that triggers GBrain's dream cycle: ingest new pages since last run, extract entity edges (zero LLM calls per GBrain's design), consolidate duplicate entries, fix broken citations, write gap-analysis notes back to vault. GBrain confirmed active in production with 66 cron jobs; Garry Tan's live deployment as evidence.
Graphify runs in parallel on the codebase: reads all source files, extracts EXTRACTED + INFERRED edges, builds the code knowledge graph. Output is JSON graph fragments ingested into Neo4j.
Source: garrytan/gbrain README (GitHub API, 2026-06-08 push) · Context7 /safishamsi/graphify extraction-specWhen Sam or an agent asks a question, GBrain's synthesis layer searches the vault + graph, then returns prose with inline citations plus an explicit gap analysis. For structural code questions, Neo4j GraphRAG (HybridCypherRetriever) combines vector search + full-text + graph traversal — answering relational queries that pure semantic search cannot.
mem0's search_memories handles per-agent context recall ("what did I learn about this customer last session?") before the main synthesis layer is consulted.
NotebookLM takes the output of a completed research cycle (a cluster of vault notes on a topic) and produces a source-grounded briefing, podcast, or study guide for human consumption. This is NotebookLM's role: final-mile synthesis for human readers, not agent queries. No API, no MCP — intentionally manual and high-quality.
Agent outputs are committed back to viewport-corp/viewport-ops as markdown, closing the Git loop and making the brain queryable via the next vault crawl.
create-note (or edit-note) to write its findings back to the vault. The vault is Git-committed. The next GBrain dream cycle ingests those notes. The brain compounds — no human required.
Not one tool. A four-layer combination — each piece doing exactly the job it is best at.
/opt/data/workspace/mac-platformx-deploy-audit/sourcegit clone + re-run cronContext7: /stevenstavrakis/obsidian-mcp · VPS audit section4-brain
No built-in graph or synthesis. Needs GBrain + Graphify on top to be intelligent, not just a file store.
gbrain serve → gbrain connect --install wires Claude Code + Codex in one commandGitHub API: garrytan/gbrain (fetched 2026-06-09) · README BrainBench scorecard
GBrain stores pages in Postgres/PGLite — not raw markdown files. ADR-0001 requires treating GBrain as a derived index, not the canonical truth. The vault is truth; GBrain reads and enriches it. 694 open issues; active but not perfect.
Context7: /safishamsi/graphify extraction-spec (v8, 3,547 snippets)
Code-graph only. Does not handle people, meetings, or decisions. Output needs to be ingested into Neo4j or GBrain to be queryable at runtime. Session-triggered, not always-on.
add_memory call — self-improving by designhttps://mcp.mem0.ai/mcp (HTTP) or uvx mem0-mcp-server (stdio)Context7: /mem0ai/mem0 (score 91.9) · /mem0ai/mem0-mcp tools · VPS section4-brain audit
Not files-as-truth. Memories live in Qdrant + Postgres. Treat as ephemeral agent context (working memory), not as canonical vault. Periodically flush important memories to vault notes via cron.
Already live (Neo4j 5.26.23 community, healthy). Best graph query engine in the stack. Use as the relational index rebuilt from vault + Graphify output. GraphRAG: HybridCypherRetriever gives vector + full-text + graph in one query. MCP Toolbox neo4j/execute-cypher makes it agent-callable. Never the truth store per ADR-0001 — a derived index only.
Best-in-class for synthesizing a fixed document corpus into a grounded, cited briefing. Use after a research cycle completes: export vault notes on a topic → upload to NotebookLM → generate investor briefing, podcast, or meeting prep doc. Not an agent tool. Not a living brain. No MCP. Intentionally manual and high-quality output.
rules/specialist-tools.md · rules/notebooklm.md · notebooklm.google.comGitHub as canonical truth → brain layers → Hermes/OpenClaw via MCP → memory writeback on every loop close.
Merges to ops/ branches trigger a webhook (n8n or GitHub Actions) that runs git pull on the VPS vault mirror. GBrain's cron picks up new/modified files within the next dream cycle window. The brain is always at most one dream cycle behind the repo.
create-note, search-vault, edit-note — write and read vaultadd_memory, search_memories — per-agent contextGBrain dream cycle runs at 02:00 VPS time via the n8n cron (platformx-n8n, Up 5 weeks). Graphify extraction runs at 03:00 on changed source files. Neo4j ingests Graphify output at 03:30. mem0 entity consolidation at 04:00. All outputs write back to vault as brain-digest-YYYYMMDD.md notes.
At the end of every Hermes agent run, the agent calls obsidian-mcp create-note with its session findings. The harness Stop hook fires git add . && git commit in the vault. The commit is pushed to viewport-corp/viewport-ops. The brain's next ingest cycle picks it up. Zero human steps required to close the loop.
GitHub (viewport-corp/viewport-ops) │ git push (every agent commit) ▼ Obsidian vault mirror (VPS: /opt/data/workspace/…) ← ADR-0001 truth │ cron 02:00: gbrain ingest ▼ GBrain (PGLite/Postgres) ← synthesis + graph │ dream cycle: enrich, consolidate, gap-analysis │ cron 03:00: Graphify extraction (code KG) ▼ Neo4j 5.26.23 (bolt://127.0.0.1:7687) ← rebuildable relational index │ │ MCP tool calls (runtime) ├── Hermes agents → gbrain serve (synthesis) ├── OpenClaw agents → obsidian-mcp (read/write vault) ├── All agents → mem0-mcp (per-agent working memory) └── Structural queries → neo4j/execute-cypher (MCP Toolbox) │ ▼ Agent writeback → obsidian-mcp create-note → git commit → push └── Loop closes. Brain compounds overnight.
Every claim in this evaluation is grounded in one of these sources. No training data used.
/stevenstavrakis/obsidian-mcp — obsidian-mcp tool list, vault path config, write-file implementation, Claude Desktop config. Score: 77.6./mem0ai/mem0 — OpenAI Agents SDK integration, LangGraph state agent, LlamaIndex memory, Pipecat voice pipeline. Score: 91.9./mem0ai/mem0-mcp — 9 MCP tool definitions, add_memory/search_memories API spec, pydantic-ai MCPServerStdio example. Score: 76.2./llmstxt/neo4j_llms_txt — MemoryClient (short-term, long-term, reasoning), SimpleKGPipeline, GraphRAG HybridCypherRetriever, MCP Toolbox neo4j/execute-cypher. Score: 78.33./safishamsi/graphify — Extraction subagent prompt spec (v8), EXTRACTED/INFERRED/AMBIGUOUS confidence scoring, hyperedge rules, 6 file types, OpenClaw/Claw/Copilot skill variants. Score: 76.6.viewport-corp/viewport-ops branch ops/openclaw-github-flow-44, path evidence/full-system-audit/raw/section4-brain.raw.txt — live container list (platformx-neo4j, platformx-mem0, platformx-qdrant, Obsidian vaults), Qdrant collections, Neo4j HTTP probe (version 5.26.23). Fetched 2026-06-09.rules/notebooklm.md + rules/specialist-tools.md.Brain evaluation grounded in Context7 + live docs (2026-06-09). Sources cited inline. Every claim has a URL. No training data used.