Stand up gbrain, and compare it to what you run.

Hands-on. Install the local PGLite build, ingest, query, and map every part to the lessons.

Goal of this lesson: get gbrain running locally with zero cloud setup, write a few pages, query them, and inspect its git-markdown store. You will see the same five stages as Graphiti, implemented with different organs (L7's verdict, in your hands).

gbrain needs bun. Check with bun --version; if missing, curl -fsSL https://bun.sh/install | bash. We do the --pglite path: a local zero-config store, nothing to provision. Treat this as a sandbox, keep it separate from your Graphiti data.

Step 1 · Install (stage 0: the tool)

bun install -g github:garrytan/gbrain
gbrain --help

Skim the verb list. With Lessons 1-8 done, you should recognize most of them as pipeline operations (search, write, link, sync).

Step 2 · Init the local brain (stage 2: store)

mkdir -p ~/gbrain-sandbox && cd ~/gbrain-sandbox
gbrain init --pglite

This creates the store: a git repo of markdown as the system-of-record, plus a PGLite index. Run ls -la and git log after, gbrain treats your brain as version-controlled files. That git-as-store bet is the thing that differs most from Graphiti's Neo4j (Lesson 7).

Step 3 · Write pages (stage 1: ingest, stage 5: auto-link)

Write a few connected facts. Use real Rejig entities so the auto-linker has something to wire:

gbrain write "DuckyCutz is a barbershop chain in Phuket, a Rejig Labs client."
gbrain write "RT founded Rejig Labs, an AI automation agency."
gbrain write "Rejig Labs built a VAPI voice agent for DuckyCutz."

Now look at what it did to the store: cat *.md and git log --oneline. Watch for auto-wired typed edges (DuckyCutz → client_of → Rejig Labs) created with zero LLM calls, the deterministic linking from Lesson 5.

Step 4 · Ask it (stage 3 + 4: retrieve + synthesize)

gbrain ask "what is the relationship between RT and DuckyCutz?"

This is the part Graphiti delegates to Claude but gbrain does itself: a synthesized, cited answer walking RT → founded → Rejig Labs → built-for → DuckyCutz, plus a gap note if it's unsure. That is Lesson 8 stage 4, running locally.

Step 5 · Wire it into Claude Code (Lesson 8: MCP)

gbrain ships an MCP server. Get the install command and add it as an MCP server so Claude Code can call it as tools:

gbrain mcp --help   # shows the stdio command to register

Once added, your agent can search and write the gbrain store mid-conversation, exactly like /prime calls Graphiti. Ask me to help wire the MCP config if the flags are unclear, this is fiddly and worth getting right.

The comparison (the real payoff)

Stage	Your Graphiti (L9)	gbrain (this lesson)
Store	Neo4j graph in Docker	Git markdown + PGLite, version-controlled
Link	LLM extraction into typed entities	Deterministic wiring, 0 LLM calls
Time	Bitemporal edges (valid/transaction)	Git history as the timeline
Synthesis	Delegated to Claude via /prime	Built-in cited answer + gaps
Reach	MCP via /prime, /handoff	MCP via install URL

Your tasks (do these, report back)

#	Task
1	Get steps 1-4 running. Paste me gbrain's answer from step 4 and we'll judge its synthesis vs a raw Graphiti query.
2	`cat` a generated markdown page. Decide: do you prefer files-as-truth (gbrain) or graph-as-truth (Graphiti)? Why?
3	Pick which one you'd run for your personal brain vs which fits a client deliverable. That instinct feeds Lesson 11.

Primary source

★ garrytan/gbrain README + its --help output. The README is authoritative for exact verbs and flags (they may have moved since this lesson was written, trust the live --help over me).

Ask your teacher. Try: "gbrain init failed with X", "help me register the gbrain MCP server in Claude Code", or "gbrain's answer was better/worse than Graphiti's, why?" Then "lesson 11" for the client-product capstone.

← Lesson 9: Your Graphiti graph Next → Lesson 11: Build a client KB product