Open the brain you already run.

Hands-on. Every concept from L1-L8, made real against your own Graphiti graph at scripts/graphiti/.

Goal of this lesson: run five real commands against your live graph and recognize each pipeline stage in the output. By the end you will have queried your own brain, seen its entity types, and watched a fact go in. Concepts become muscle memory here.

Run these in a terminal from the repo root (/Users/rt/Claude-Code/rejiglabs). If a step errors, that IS the lesson, paste it to me and we debug together. The README at scripts/graphiti/README.md has the troubleshooting table.

Step 1 · Confirm the brain is alive (stage 2: store)

Neo4j is the store. Check it is up and how big your graph is:

docker-compose -f scripts/graphiti/docker-compose.yml up -d
scripts/graphiti/.venv/bin/python scripts/graphiti/health.py

Expect {"status": "ok", "nodes": N, "latency_ms": ..}. That nodes count is the size of your store. Note it. If down: start docker. If empty: run backfill.py.

Step 2 · Query it (stage 3: retrieve)

This is hybrid retrieval from Lesson 2, running for real. The --group-ids flag scopes the search to a memory partition (rt-global = personal, ai-rejiglabs = business):

scripts/graphiti/.venv/bin/python scripts/graphiti/query.py \
  "what do I know about DuckyCutz" \
  --group-ids rt-global,ai-rejiglabs --limit 15 --format markdown

What comes back is not whole documents, it is retrieved facts. That is stage 3 handing chunks to what would be stage 4. Try --format json to see the raw structure.

Step 3 · Read your own schema (stage 5: typed nodes)

Lesson 5 said a graph is nodes + typed edges. Here are your node types, already defined:

grep -nE "^class " scripts/graphiti/entity_types.py

You will see Client, Project, Preference, Decision, Tool, Person. That is your ontology. When you ran step 2, Graphiti was resolving facts into these types and wiring typed edges between them. This file IS the "typed" in "typed edges."

Recognize it: a Decision node with a rationale field and a Client node with a fit_score are exactly the structured entities from Lesson 5. You did not have to design this from scratch, but now you can read it, and extend it.

Step 4 · Write a fact, watch the loop close (stage 1: ingest)

Ingest a test fact, then re-query to see it land. This is the link-back loop from Lesson 1:

echo "RT is learning knowledge-base architecture, June 2026" | \
  scripts/graphiti/.venv/bin/python scripts/graphiti/ingest.py \
  --group-id ai-rejiglabs --name "learning-kb" --source text --body -

# now retrieve it
scripts/graphiti/.venv/bin/python scripts/graphiti/query.py \
  "what is RT learning" --group-ids ai-rejiglabs --limit 5

The fact you wrote should come back. You just ran ingest → store → retrieve end to end, by hand.

Step 5 · See the temporal model (Lesson 6, live)

Open Neo4j Browser at localhost:7474 and run a Cypher query to inspect an edge's validity window:

MATCH (n)-[r]->(m) RETURN r LIMIT 5

Look for valid_at / invalid_at (or created_at) properties on the relationships. Those are the bitemporal clocks from Lesson 6, on your real data. Ask me to help read them if the property names differ.

Your tasks (do these, report back)

#	Task
1	Run steps 1-4. Tell me your node count and whether the test fact came back.
2	Query something you know is in there (a client, a decision) and judge: did retrieval find the right facts? Where did it miss?
3	Find one entity type you wish existed but doesn't (e.g. `Lead`, `Invoice`). That gap is your first real extension.

Primary source

★ Your own scripts/graphiti/README.md and context/graphiti-system.md. The architecture doc is the highest-trust source here because it describes your exact deployment.

Ask your teacher. This lesson is meant to be run with me live. Paste any output and I'll explain it. Good prompts: "my query missed an obvious fact, why?", "help me add a Lead entity type", or "show me a Cypher query to list all my Client nodes." Then "lesson 10" to install gbrain alongside it.

← Lesson 8: Synthesis and MCP Next → Lesson 10: APPLIED — run gbrain