# CrabRAG: Why Automated Assistants Need Graph Memory, Not More Tokens

Stephen Chin

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/Q0VkgCyNVUg-crabrag-why-automated-assistants-need-graph-memory) · [Video](https://www.youtube.com/watch?v=Q0VkgCyNVUg)

## CrabRAG: Why Automated Assistants Need Graph Memory, Not More Tokens

A home-lab digital twin shows how vector search can find starting points while graph traversal supplies the relationships an assistant needs to answer operational questions.

Familiarity with agent tool calls, embeddings and retrieval-augmented generation will help; graph terminology is introduced as needed.

### Yesterday’s work, forgotten today

[0:40](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=40s)

Crab-D is an eager personal assistant: ready to help write code, manage email and organize a life. But in Stephen Chin’s opening example, a new day brings a new OpenClaw memory file, and the assistant no longer recalls yesterday’s work. The user has to supply the continuity that the assistant was supposed to provide.

![A cartoon crab looks into a mirror beside a SOUL.md note; text explains that the agent remembers what is saved to disk and rereads it each time.](https://ai.engineer/api/talk-essay-media/3fee6661c2f2952883a2f4f7f7a15332b4b02d76b9aa98abaccba43668958d81)

“Every session, he wakes up an amnesiac.”

The problem extends beyond remembering facts. Crab-D has tools but reaches for the wrong utensils to eat a bowl of soup. It encounters someone familiar and treats them as a stranger. These cartoons describe recognizable agent failures: having access to a capability without selecting it correctly, and storing experience without bringing it back when needed. The result is repeated instruction for tasks the assistant has already encountered.

### The cost of rereading memory

[2:22](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=142s)

An agent’s working loop is familiar: receive a prompt, consider a response, call tools and observe the results. Memory determines what information enters that loop. What should the agent recall, and how does that material get into context?

Chin illustrates the file-based approach with `SOUL.md`, tool files and daily memory files. Markdown makes this material easy for people to inspect, edit and compact. Files are kept small because the context window is limited, and relevant information must be positioned where the model can use it. In current [OpenClaw documentation](https://docs.openclaw.ai/help/faq), `SOUL.md` primarily supplies personality guidance, while daily notes and `MEMORY.md` provide persistent memory. The opening amnesia example is Chin’s experience of failed recall, not a claim that OpenClaw necessarily deletes yesterday’s notes.

Chin reports that his agents load at least 100K tokens per round, including skills and other context. Much of that loading repeats material in the hope that some of it will prove useful. With a small knowledge base and a capable model, the approach can produce satisfactory answers. As the knowledge base grows, however, repeatedly loading the stack becomes a poor way to select evidence. Chin introduces his home-lab digital twin as a concrete test of that limitation.

![Slide displaying “5m tokens. every day.” beside an explanation of rereading the entire stack every session and the phrase “Don’t read more. Remember better.”](https://ai.engineer/api/talk-essay-media/74463d90073bbc4d2e6c6b0f0409edcec9c1db15a9c68ec7171912375dcab584)

Repeated context loading: “5m tokens. every day.”

### Learning a skill is only the beginning

[4:16](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=256s)

Hermes Agent adds a useful feedback step: after completing a task, it reflects and records skills or knowledge it needs. That gives future tasks something to learn from. But those skills are still represented as Markdown, and their usefulness depends on loading the appropriate material at the appropriate moment.

Crab-D’s next mishaps separate three problems that a growing skill library must solve:

- **Missing capability:** without a clam-opening skill, the crab cannot reach its meal.
- **Wrong selection:** riding a jet ski on a beach applies an available capability in the wrong setting.
- **Incomplete sequence:** opening the clam is insufficient if the crab does not know how to eat it afterward.

The requirement is therefore a chain of suitable skills, not merely a collection of them. Chin points to an unnamed arXiv project by a Neo4j colleague that represents skills as a graph—a way to make their connections explicit.

### A pluggable interface still needs a memory model

[5:43](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=343s)

Goose approaches automation through MCP. It belongs to the [Agentic AI Foundation](https://www.linuxfoundation.org/press/linux-foundation-announces-the-formation-of-the-agentic-ai-foundation), alongside MCP; Chin describes Anthropic’s backing and Neo4j’s membership as part of that ecosystem. Intended for enterprise workflows as well as personal assistance, Goose makes integrations central to its design. Chin cites more than 70 MCP extensions for Goose at the time of the talk.

In the memory implementation Chin describes, memory is another MCP server. An agent can retrieve, remember or forget information through explicit operations over files on disk. That is a useful separation of interface from application: memory becomes something an agent can manipulate through tools. But a pluggable interface does not, by itself, change how the stored information is organized or how the relevant pieces are found.

The wrong tool occasionally produces something useful. Chin’s paddle example turns into the origin story of pickleball: a family combines equipment already at home, a badminton court and improvised rules to make a new game. For an assistant carrying operational knowledge, though, improvisation is not enough. Too many notes can encumber recall, and exposing a forget operation introduces the possibility that the agent removes memory it still needs. Better access to memory must be accompanied by better selection and control.

### Similarity does not establish a relationship

[7:48](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=468s)

A vector database improves on loading every file. Store embeddings for the material, embed a query and retrieve similar content from a much larger repository. This makes memory selective: the model receives related information without having to reread everything. Chin names pgvector and LanceDB as options and says he will use both in the demonstration. His description of pgvector as built into OpenClaw differs from the [current memory configuration reference](https://github.com/openclaw/openclaw/blob/main/docs/reference/memory-config.md), which describes SQLite indexing with sqlite-vec acceleration; the talk does not establish the historical configuration behind that difference.

**Similarity in vector space is not the same as an actual relationship.** A retrieved passage can concern the right kind of server without describing the particular server in question. Chin associates reliance on vector lookup alone with hallucinations and increasingly difficult failures in complex digital twins. Crab-D’s expensive mistaken lunch is the visual joke: something can look like the desired object without being an appropriate substitute.

The deeper difficulty is a multi-hop question. All the necessary facts may be stored, yet similarity retrieval may not assemble the chain that connects them. Chin also describes such chains as expensive in traditional relational databases. His final vector analogy makes the identity problem explicit: a shell can resemble yours and still belong to someone else. Retrieval needs to preserve which entity a fact belongs to, as well as which other entities it connects to.

### Find a starting point, then follow the connections

[9:42](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=582s)

A property graph represents entities as **nodes**, their connections as **relationships**, and descriptive information as **properties**. Identity and paths become explicit parts of the stored model. Embeddings can live alongside that structure, so introducing graph memory does not require abandoning vector search.

The hybrid retrieval procedure in CrabRAG has three stages:

1. **Find seeds:** use vector search to locate promising starting nodes.
2. **Expand relationships:** traverse from those seeds to connected neighbors.
3. **Rank context:** select relevant material from the expanded neighborhood for the model’s answer.

Vector search supplies an entry point; traversal supplies the connected evidence needed for a more specific question. Chin’s ocean journey illustrates the difference: recognizing something related to a desirable reef is less useful than finding the path that reaches it.

The returned subgraph also makes retrieval inspectable. A developer can examine the entities and relationships that entered context and trace an answer back to that evidence. If the answer is wrong, the graph offers concrete places to investigate: extraction may have missed a relationship, or duplicate nodes may have split facts about the same entity. Improving extraction and merging duplicates changes the evidence available to the next retrieval. **The graph is both a memory structure and a debugging surface.**

Chin recommends **Claude** as an aid for writing Cypher and building entity extractors. That lowers the barrier to implementing the queries, but it leaves an essential design responsibility with the developer: knowing the entities, relationships and properties the application needs to represent.

### A digital twin that cannot inspect the live network

[11:52](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=712s)

The intended workflow is to write an agent’s actions into the graph as it works, answer follow-up questions by traversal rather than rereading, and recover useful context in a fresh session. To explore that approach, Chin built a digital twin of his home lab over the preceding week or two. The comparison starts with the same original Markdown files: environment A uses a vector store, while environment B uses graph memory built with [Cognee](https://github.com/topoteretes/cognee).

The graph environment uses a Neo4j backend. The underlying lab consists of Proxmox servers running on computers around Chin’s desk. For the demonstration, a separate VLAN isolates the agents from the real network represented in their memory. They cannot inspect live hosts or obtain updated network information. Their answers must come from what was previously stored. That isolation makes retrieval, rather than live discovery, the central task.

![Network diagram showing pfSense, Proxmox hosts, and an isolated demo area containing CrabRAG Cockpit, OpenClaw, Cognee, Neo4j, Cloud LLM, and a default-deny firewall.](https://ai.engineer/api/talk-essay-media/85071547571e01abcea84aa4601f34c37348e056247d0f0e4987e4120d8a9439)

Homelab infrastructure and the isolated graph-memory demo.

The CrabRAG cockpit presents five queued questions with home-lab schematics; Chin demonstrates two of them. These are concrete comparisons of displayed answers from the two environments. Model settings, retrieval budgets and policy configurations are not specified, so the results show what happened in this setup rather than establishing a controlled accuracy or cost benchmark.

### Which internet-facing host runs obsolete software?

[13:41](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=821s)

The first question asks whether any software exposed to the WAN—the public internet—is past end of life. Chin identifies a concrete target: his daughter’s Minecraft server is running Debian Jessie. The useful answer must connect a particular guest, its operating system and its exposure to the internet. A general warning about old software would not identify what needs attention.

The vector response does not provide those specifics. It mentions details excluded by policy and asks for information to be sourced separately. On the graph side, the cockpit shows Cypher queries and a visualization of the retrieval process:

- **Blue nodes:** seeds selected through vector lookup and ranking.
- **Gray nodes:** neighbors reached through one-hop traversal.
- **Green nodes:** selected nodes that enter the final context.

The colors expose the boundary between finding a plausible starting point and retrieving the connected facts used in the answer.

| Memory approach | Displayed outcome |
| --- | --- |
| Vector store | No specific host finding; requests separate sourcing |
| Graph store | Identifies the expected guest and its outdated OS |

Chin reports that the graph answer identifies the guest he expected and flags its obsolete operating system. He emphasizes that both stores started from the same source data: the practical difference is whether the agent can retrieve the connected information needed to produce an actionable finding.

### Follow the router to exposed services

[15:30](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=930s)

The second question concerns management ports listening on `0.0.0.0` and whether they are exposed to the internet. Listening on all IPv4 interfaces is only part of that question: reachability also depends on the network around the service. Chin’s setup names Matrix and HAProxy as internet-exposed, while the Cognee demo and OpenClaw instance remain accessible only inside the LAN. The answer therefore needs to distinguish a listening address from an actual path from the WAN.

The vector response recommends checking service configuration and a pfSense rule, effectively returning the investigation to the user. Chin reports that the graph response instead identifies HAProxy and OpenVPN as WAN-exposed. Those names differ from the setup’s Matrix and HAProxy, so the narration does not establish an exact match between the expected and returned service lists.

The traversal explains how the graph approaches the question. It finds the `pfSense` router node and follows its relationships to the relevant results. The graph’s shape differs from the obsolete-software example because this query has a useful shared connection point: the router.

A compact Cypher model makes that operation concrete. Suppose a `Router` connects through `FORWARDS_TO` relationships to `Service` nodes, and the relationship records the source network. With those illustrative labels and properties, the router-centered lookup is:

```cypher
MATCH path = (router:Router {name: 'pfSense'})
             -[forward:FORWARDS_TO]->(service:Service)
WHERE forward.sourceNetwork = 'WAN'
RETURN service.name AS service,
       service.port AS port,
       path;
```

Returning `path` preserves the connection behind each result. The important modeling choice is to represent exposure as a relationship the query can follow, rather than infer it from text that merely mentions a router and a service.

### From a finding to a repair

[17:09](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=1029s)

Crab-D’s clam metaphor returns with the sequence complete: open the shell, eat and proceed to the next task. In the home lab, the corresponding benefit is a specific security finding that someone can act on. Chin says he subsequently patched the holes uncovered through the demonstration. The displayed agent work identifies problems; the later remediation is Chin’s reported follow-through.

Chin contrasts his three- or four-node home lab with enterprise data centers and financial-services collections of companies and customer records. He invokes million-token context windows as an example of large but finite capacity, not a limit shared by every model. Once an application’s relevant knowledge exceeds the context it can practically load, the engineering problem becomes selecting connected evidence from persistent memory. A larger window cannot supply relationships that retrieval never found. Crab-D’s closing reunion with its crustacean crew brings that requirement back to the opening problem: remembering means recovering the right identities and connections when they matter.

### Building the graph application

[18:10](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=1090s)

Chin closes with *GraphRAG: The Definitive Guide*, coauthored with Michael Hunger and Jesús Barrasa. At the time of the talk, he describes the full book as available in early release, with publication expected after the remaining editorial work. Its scope extends from GraphRAG to memory, agents, industry use cases and the technologies needed to build an application end to end.

For practical training, he points to Neo4j GraphAcademy’s free courses on agent memory and context graphs. These continue where the demonstration leaves off: learning to build the persistent, queryable structures that let an assistant recover a useful chain of evidence in a later session.

![Neo4j closing slide with Graph Academy text, a QR code, Stephen Chin’s name, and cartoon crustaceans wearing dark coats and goggles.](https://ai.engineer/api/talk-essay-media/7e03cb350a9d8f0e53bd94de2b270c489832bb3ec1b2a063440517709a1ba8eb)

“Give your crab a graph.” Graph Academy learning resources.

## Resources

- [Cognee](https://github.com/topoteretes/cognee) — Open-source platform for building persistent agent memory with knowledge graphs.
- [Context Graphs: Agent Memory with Neo4j](https://graphacademy.neo4j.com/courses/genai-context-graphs) — Free practical course on conversation memory, knowledge extraction and queryable reasoning traces.
- [AIP: A Graph Representation for Learning and Governing Agent Skills](https://arxiv.org/abs/2606.04781) — Research on representing agent skills as executable graphs with typed dependencies and testable steps.
- [OpenClaw memory configuration](https://github.com/openclaw/openclaw/blob/main/docs/reference/memory-config.md) — Current reference for embedding providers, SQLite vector indexing and memory retrieval configuration.
- [Agentic AI Foundation founding announcement](https://www.linuxfoundation.org/press/linux-foundation-announces-the-formation-of-the-agentic-ai-foundation) — The foundation’s launch announcement explains the contributions of MCP, goose and AGENTS.md.

## Slides

### CrabRAG: Why your assistant needs graph memory

Stephen Chin introduces CrabRAG and its case for graph memory, while cartoon crustaceans surf across the title slide.

[0:36](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=36s) [Title slide with Stephen Chin’s name and cartoon crustaceans surfing.](https://assets.ai.engineer/sites/aiecode2025/sha256/a14ae3e07324df14f96ad20ec6dd90f183685397c3a4d41a5f03c411c3c9dc1f.webp)

neo4j Graph Intelligence Platform

CrabRAG
Why your assistant needs graph memory, not more tokens.

Stephen Chin
VP of Developer Relations, Neo4j · @steveonjava

### This is Crabd

Crabd is an eager personal assistant with a memory problem: when his memory file changes each day, he forgets what happened yesterday.

[1:02](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=62s) [A smiling cartoon crab introduces Crabd as a personal AI assistant with one problem.](https://assets.ai.engineer/sites/aiecode2025/sha256/8d05f71ff7059e9a7e8ad733a84888ba8c54a20dc735ff04ee41b23e5c9d7241.webp)

This is Crabd.

He's a personal AI assistant

Autonomous, eager, plugged into all your tools.
Like every assistant on stage this week, he demos beautifully.

There is just one problem

### Every session, he wakes up an amnesiac

Clawd looks in a mirror and relies on SOUL.md to know his name. The slide says an OpenClaw agent rereads saved files each session; the speaker describes it forgetting the previous day when memory files change.

[1:18](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=78s) [A confused crab looks in a mirror beside a file; text describes an agent rereading saved state.](https://assets.ai.engineer/sites/aiecode2025/sha256/1b62069a1ecdc9dd10f011d88a9e2f285e0753c32acb0012016cdec75a1395c1.webp)

THE FORGETFUL CRAB · 1

Every session, he wakes up an amnesiac.

The only reason Clawd knows his own name is the file on the sink: SOUL.md

No hidden state. An OpenClaw agent only remembers what's saved to disk — and re-reads it from zero each time.

SOUL.md
Name: clawd

### A drawer full of tools. Still can’t eat soup.

Clawd holds a screwdriver and wrench while a spoon lies beside his soup, illustrating how an agent can choose the wrong tool even when the right one is available.

[1:42](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=102s) [A crab holds a screwdriver and wrench over a bowl of soup while a spoon lies nearby.](https://assets.ai.engineer/sites/aiecode2025/sha256/bf52f551f827d09df83567748915d357a1ccf43578c3c2dee9bbbe857ca1391e.webp)

A drawer full of tools.
Still can't eat soup.

THE FORGETFUL CRAB · 2

Screwdriver? Wrench? Clawd has every tool an agent could want — and reaches for the wrong one anyway

The problem was never tool access. It's knowing which tool this moment calls for.

### Nice to meet you! For the 100th time

Clawd greets his distressed best friend as a stranger, illustrating how a log can record a conversation while losing the relationships behind it.

[2:01](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=121s) [One crab greets a distressed friend again; text explains the loss of relationship context.](https://assets.ai.engineer/sites/aiecode2025/sha256/735c4bdeab8ba445a46070b37b06390a1a0755f5292b920586c0d29090745bb7.webp)

“Nice to meet you!”
(for the 100th time)

THE FORGETFUL CRAB · 3

Nice to meet you!

That's his best friend. Clawd has no memory of people — or how he's connected to them.

A log remembers that they talked. It forgets who, to whom, and why — the relationships.

We've literally eaten crab cakes together every Friday...?

### How does Crabd’s brain actually work?

Crabd’s brain is a folder of Markdown files that it re-reads every morning. The speaker introduces this as a memory loop.

[2:25](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=145s) [Text introduces a folder of Markdown files that the assistant rereads.](https://assets.ai.engineer/sites/aiecode2025/sha256/08298ecc295edeabe50de53fd40e8d45e96ae7ce8b0eca7e7ce4ae2f61939ca5.webp)

So how does Crabd's brain actually work?

Spoiler: it's a folder full of Markdown files — and it re-reads all of them every morning.

### The loop is easy; memory is hard

An agent cycles through prompting, thinking, tool calls and observation. The hard part is what it recalls and what survives between turns and sessions.

[2:30](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=150s) [Diagram connects prompt, think, call a tool, and observe, with a question about what memory survives between turns and sessions.](https://assets.ai.engineer/sites/aiecode2025/sha256/0837b79b99a8e8d6a2690d66fc83bbb8d9f0552f6e6cd2e756764189acb2dd69.webp)

HOW AGENTS WORK

The loop is easy.
The memory is the hard part.

PROMPT → THINK → CALL A TOOL → OBSERVE

MEMORY? What survives between turns? Between sessions? This is the part everyone hand-waves — and the part that makes assistants flaky.

### The catch: five million tokens every day

The slide puts the cost at 5m tokens every day. The speaker says their agents load at least 100K tokens each round, repeatedly adding skills and other material to context.

[3:30](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=210s) [A large five-million-token statistic accompanies text claiming that rereading memory files raises token use.](https://assets.ai.engineer/sites/aiecode2025/sha256/ae408104c36c66392a32051b9960d7a5fb413d6ca8608df544d89969c97fa5fa.webp)

THE CATCH

5m
tokens. every day.

No structured memory means Clawd re-reads the entire stack every session. OpenClaw is anti-RAG by design — and the token bill shows it.

Don’t read more. Remember better.

9

### Hermes writes its own skills

Hermes reflects on completed tasks and saves methods that produce repeated wins as a SKILL.md recipe, which it can reuse automatically next time.

[4:17](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=257s) [A diagram shows a task and repeated wins leading to a SKILL.md file that can be reused.](https://assets.ai.engineer/sites/aiecode2025/sha256/f90a936901d08f68fc695e59d81231462d619ba20b9bb6ed29ac5cf470401c7b.webp)

HERMES · THE SUCCESSOR

Hermes writes its own skills.

HERMES AGENT

Same SOUL.md identity. A curated, capped MEMORY.md.
Plus a learning loop: do the work, notice it worked, save the recipe.

DO THE TASK → 3-4 WINS → SKILL.md
↺ reused automatically next time

It remembers methods, not just facts — procedural memory.

### Skills

Skills live in folders containing a SKILL.md file. The speaker explains that loading the right skill helps an agent perform a task, then introduces three ways skills can break.

[4:41](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=281s) [A section slide defines skills as folders containing a SKILL.md file and introduces three ways they break.](https://assets.ai.engineer/sites/aiecode2025/sha256/a04e1ae0cac521751ece13d491d9f962cb9c6ee1ea475c91798a710931d2d982.webp)

PART TWO

Skills

Clawd learns to do things. What could go wrong?

Skills = folders with a SKILL.md. Bundled, installed, or self-written.
Three ways they break ↓

### He meant to jog. He picked waterskiing.

Crab-D skis on a beach to illustrate an agent picking the wrong skill. Hermes' hub alone ships ~700 skills, making selection a problem of its own.

[5:09](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=309s) [A crab waterskis on a beach beside text about the difficulty of choosing the right skill.](https://assets.ai.engineer/sites/aiecode2025/sha256/15610de6b54a6ba2d4784093c8d9290c9e18b245f03fae6f0706bbd437d9930b.webp)

He meant to jog.
He picked waterskiing.

SKILLS BREAK · 2 · HARD TO PICK

Hundreds of skills in the folder. Hermes' hub alone ships ~700. Choosing the right one for this moment is its own hard problem.

Wrong skill — confidently executed.

13

### Cracks the shell. Wanders off.

The crab opens a clam but wanders off: having crack_shell and eat_meat does not help if he cannot connect the two steps.

[5:22](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=322s) [A crab looks away from an open clam; the slide says it cannot connect cracking the shell with eating the meat.](https://assets.ai.engineer/sites/aiecode2025/sha256/bfdc4d4aeee5728addd6ddea72fa21bcdbdd70c89538cad0d55c8224fd15c694.webp)

Cracks the shell.
Wanders off.

SKILLS BREAK · 2 · HARD TO PICK

need more shells...

He has crack_shell and eat_meat.
He just can't connect them.

Skills don't compose. Real work is a chain of steps — and the meat is inside the shell he just cracked.
(Hold that thought)

### Great at shrimp. Defeated by a clam.

Goose is a local, open-source agent that works with any LLM. It uses 70+ MCP extensions for tools and treats memory as another MCP server.

[5:47](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=347s) [A Goose overview describes a local open-source agent, MCP extensions and memory as an MCP server.](https://assets.ai.engineer/sites/aiecode2025/sha256/e15b753c9b0d3099b5d27a3304f20536e86d4d9df06b1f9173b8609c42e33d3c.webp)

A THIRD ASSISTANT

Great at shrimp.
Defeated by a clam.

Goose

An open-source AI agent that runs on your machine — desktop app, CLI, and API. Built in Rust, works with any LLM.

An Agentic AI Foundation (AAIF) project · Linux Foundation

Everything is an MCP extension.

70+ MCP extensions — browsers, databases, docs, tools

100% local — your machine, your keys, your files.

Memory is just another MCP server

### Memory is just another MCP server.

Goose uses MCP commands to manage tagged memories in local or global files. The slide says it loads all saved memories into every prompt, increasing token use without adding relationships.

[6:16](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=376s) [A diagram shows Goose memory commands, example local and global files, and a claim that saved memories are loaded into every prompt.](https://assets.ai.engineer/sites/aiecode2025/sha256/0799ac43f8e9d0697a53e63ade32635e576f43ae51212b51549ffe56ec064f96.webp)

Memory is just another MCP server.

GOOSE MEMORY

remember_memory()
retrieve_memories()
remove_specific_memory()
remove_memory_category()

Driven by trigger words — say remember... and it writes a tagged entry; say forget... and it drops one. Stored as plain files, scoped local or global, sorted into categories and #tags.

Memories are plain files on disk

~/.config/goose/memory/ ├─ global/
preferences.md └─ local/ project-x.md

# development #rust #tooling - prefers ripgrep over grep

local · this project
global · everywhere

The same catch.
Goose loads all saved memories into every prompt, every session. More memory means more tokens on every call — and still no relationships.

### Right game. Wrong paddle.

MCP gives an agent tools, but choosing the right one still takes judgment. A goose with a table-tennis paddle on a court turns the mismatch into a pickleball joke.

[6:44](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=404s) [A goose and a crab play on a court as the slide says MCP supplies tools but does not choose the right one.](https://assets.ai.engineer/sites/aiecode2025/sha256/ed11c4fdc4e5516f54aefa2fca31f4dd9597874539a59b81b1667208187e0384.webp)

Right game.
Wrong paddle.

A THIRD ASSISTANT

MCP hands the agent a tool. It can’t hand it the judgment to pick the right one.

...or maybe he just invented pickleball.

GOOSE 4 – 3 CRAB

### Remembers everything. Can't take off.

Loading the whole memory pile on every call weighs the assistant down, like the goose struggling to fly under a coat of notes.

[7:17](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=437s) [A goose covered in notes struggles to fly, illustrating the cost of loading every memory on each call.](https://assets.ai.engineer/sites/aiecode2025/sha256/709d290e74ecfc82b2d3ccdce1917a6be69013c6e6255c6f67976989bc0a63a6.webp)

MCP MEMORY · 2 · TOKEN BLOAT

Remembers everything.
Can’t take off.

Every memory, every prompt, every time. Load the whole pile on each call and eventually the bird can’t fly.

Flat memory grows — it never gets lighter.

### Plugging straight into the socket

The goose reaches for a sparking MCP “forget” socket as the speaker warns that one tool call could wipe the assistant’s memory.

[7:31](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=451s) [A goose holds a plug near an MCP forget socket while a crab looks alarmed.](https://assets.ai.engineer/sites/aiecode2025/sha256/52408620aa99ddb212bd1d3a1897999655531b6ebf93ee56a2cd16e3a0109d14.webp)

MCP MEMORY · 3 · EASY TO FORGET

Plugging straight into the socket.

When memory is just loose tool calls, the risky one is always one call away.

Fortunately, tool calls are easy to forget.

MCP
forget

### Just give him a vector database

Vector databases can store embeddings, but choosing one means navigating a crowded field of options.

[7:46](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=466s) [A list of vector database options appears above the words “Pick one. Good Luck.”](https://assets.ai.engineer/sites/aiecode2025/sha256/63624f648e7223e5883a187ff9f6a225c7c32f0ff0b4764223a20a49b58a52d3.webp)

PART THREE · VECTORS TO THE RESCUE?

“Just give him a vector database.”

Pinecone
Weaviate
Chroma
Qdrant
Milvus
pgvector
redis
Lance DB
FAISS
Mem0
Vespa
Marqo
+ a dozen more

Pick one. Good Luck.

### Find the nearest points in space

Similarity search turns notes and a query into vectors, then retrieves nearby points. The diagram connects the query to its three nearest neighbors.

[8:03](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=483s) [A query point connects to its three nearest neighbors in a field of points.](https://assets.ai.engineer/sites/aiecode2025/sha256/7d49bc97912b26a00c512799ff5ed53eea4e45da340f2a4c869f7a2c8ffa5f06.webp)

HOW SIMILARITY SEARCH WORKS

Find the nearest points in space.

Every note becomes a vector. Your query becomes a vector. Return the closest ones.

Excellent for “what looks similar?”

?
query → 3 nearest neighbors

### Similar is not related

Vector proximity can find things that look alike, but it does not establish whether one caused, belongs to, or connects to another. The speaker warns that relying solely on vector lookup can lead to hallucinations.

[8:25](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=505s) [A row of crab expressions accompanies a statement that similarity does not establish relationships.](https://assets.ai.engineer/sites/aiecode2025/sha256/6f20615487de619cf60bfaa65d5a2ff3be7610e2bac6b485bc50fba4950edbb6.webp)

THE CATCH WITH VECTORS

Similar ≠ related.
Nearest ≠ right.

Embeddings know when two things look alike. They don't know that one caused, belongs to, or connects to the other

### So close. Can't get there.

A crab faces food across the water as connected stepping stones trace a multi-hop graph path. The speaker argues that similarity search can find nearby facts without following the chain to an answer.

[9:05](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=545s) [A crab faces food across water, with glowing connected stepping stones illustrating a multi-hop path.](https://assets.ai.engineer/sites/aiecode2025/sha256/5b830561e58aff13ff814b9e4b04c3ecd72d253159e243a412b6f1ca47e8bdc4.webp)

VECTORS BREAK · 2 · NO MULTI-HOP

So close.
Can't get there.

The food is two hops away: across the rock, over the branch. Similarity hands you the nearest thing — never the path to it.

No multi-hop. No chains. No paths.

Vector search
multi-hop graph path
answer

### Which shell is mine?

Clawd faces near-identical shells in a locker room. A 99% match cannot establish which shell he owns; the slide represents ownership as a relationship.

[9:23](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=563s) [Clawd faces similar shells in a locker room; the slide illustrates ownership as a graph relationship.](https://assets.ai.engineer/sites/aiecode2025/sha256/f39608a49ff363391aed4f819e3c0b6ca21a1ccd47240baa1a7a6a1f77876cb0.webp)

VECTORS BREAK · 3 · IDENTITY IS A RELATIONSHIP

“Which shell is mine?”

Ten shells, all a 99% match. But “mine” isn't about looks — it's (Clawd)-[:OWNS]→(shell).

Identity, ownership, history — all relationships.
Similarity can't see them

Which one is MINE?

GO CRABS!
CLAWD

### Enter the graph

Graphs bring relationships, identity and paths together, mapping the full chain from crack to eat.

[9:45](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=585s) [Section slide introducing graphs, relationships, paths and identity over a beach background.](https://assets.ai.engineer/sites/aiecode2025/sha256/aed3620b7724db4e14b467f58cd74677876b5c8554fe86f850d8bf1fae4f4d43.webp)

PART FOUR

Enter the graph.

Relationships. Paths. Identity. The chain from crack to eat. A graph stores all of it — natively.
This is GraphRAG

### Built for connected data

Clawd sits among connected nodes whose edges represent relationships. The planned demo uses vector search to select seed nodes, then graph search to traverse and rank their neighbors.

[9:55](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=595s) [A network diagram centers Clawd among connected nodes; text describes relationships as graph edges.](https://assets.ai.engineer/sites/aiecode2025/sha256/7d0629b1b80497db04727f1e4be545896253df1512d3b383628465a203c72fb5.webp)

Built for connected data.

WHY GRAPHS · 1

Entities are nodes. Relationships are first-class edges — stored, typed, traversable. The part vectors discard is the part a graph is made of

Clawd

## Full transcript

[0:00](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=0s) [on-hold jingle] My name's Stephen Chin. I run the developer relations team here at Neo4j,

[0:21](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=21s) and I'm excited to talk to you about something we've all come to love, our, our crustacean friends. So we have, um, um, OpenClaw mascot, we have a bunch of other crustaceans, and we're gonna, we're gonna focus on one member of the crustacean family.

[0:40](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=40s) I, I, I love crab, so our little boy, Crab-D.

[0:45](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=45s) And I think in the, in the journey to, to figure out how to apply agents, how to do things which are more autonomous, we're all looking for ways where we can get better results, more accurate answers, and to actually capture all of this.

[1:00](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=60s) But the tools kind of work against us. So, um, here's our, our friend Crab-D. He's a, he's a personal assistant. Very happy, very eager. He wants to, to help us out with our lives, maybe to help us to code, to help us to, you know, manage our email, to do different things.

[1:18](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=78s) But he's got a problem, and our poor boy Crab-D has a very bad memory. He wakes up every day and his memory file flips, and now it's a new day and he forgets everything from yesterday.

[1:33](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=93s) Has this happened to you, where you, you wake up and you're using OpenClaw and suddenly it's on a new set of memory files and remembers nothing that you actually did the previous day?

[1:44](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=104s) He's got a lot of tools at his disposal. I mean, we love giving our agents tools, but sometimes he doesn't pick the right tool for the job.

[1:53](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=113s) I don't think either of these are gonna help him drink his, his bowl of soup, so that's not the tool which he was looking to, to reach for.

[2:03](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=123s) And a little bit forgetful at times. So, you know, I think-- I don't remember everybody I meet, but I'm pretty good at faces. Like, if I've, if I've met you before, I recognize faces.

[2:12](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=132s) It's like, "Pleased to meet you." Um, Crab-D's not as good at that. So very forgetful. It's like you're reteaching it every day to do the same sort of tasks.

[2:22](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=142s) And we want agents which are more helpful, which are able to do more for us. So let's dig into how Crab-D actually works. So it's basically a, a memory loop, right?

[2:34](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=154s) So we're, we're prompting, we're thinking about the response, maybe calling tools, observing what happens. But the hard part is the memory. The hard part is what you put in context, what you're recalling from.

[2:47](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=167s) And the way which you have s- memory structured in most tools, this is an example of, um, how OpenClaw structures things, is you have a SOUL.md for your agent's memory.

[2:58](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=178s) You have maybe, um, memory files, you have different tool files, you have daily memory ish- files. Now, if you look at this, there's one thing which is in common with all of these.

[3:08](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=188s) They're just markdown files. So mar- markdown files are great. That's easy for us to read. Like, we can, we can look through it. We can quickly figure out what's not needed and compact them.

[3:19](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=199s) Um, they're intentionally small for agents because y- you have a limited context window, and also you need to keep the right things at the top of the context. But if your whole memory is a bunch of markdown files, you're wasting a lot of tokens.

[3:35](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=215s) So, um, my, my average agents are, are loading up at least 100K in tokens for each round. Um, they're doing a, a lot of skills. They're adding a lot of things into the context constantly.

[3:47](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=227s) It's very repetitive because they, they basically load up everything in the hopes that something will be useful in the context. At small scale, that works, where you get the results you want with a high-quality model.

[4:00](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=240s) It doesn't work at large scale, and I'm gonna show a demo of large scale where we take OpenClaw and we let it run loose on my [REDACTED:location]. So, um, high demo risk, but a lot of fun and, um, a classic digital twin scenario.

[4:16](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=256s) So I think we'll have, we'll have a lot of fun here. Um, anybody use Hermes Agent at all? Yeah. Okay. I'm, I'm a big fan of Hermes Agent. Um, I think it's got a much better memory system.

[4:29](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=269s) It kind of, at the end of each task, it goes and it reflects, and it adds back in new skills or new things which it needs. So, um, it's a really powerful system.

[4:39](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=279s) And, um, you know, again, we're relying a lot on markdown files. Skills are just basically markdown files. But we can teach the agent to do a lot of things with skills, and it can, it can get the right skill if it gets loaded up, and then good things happen.

[4:56](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=296s) But sometimes we don't get the right skill loaded up. So our, our poor boy Crab-D here is not gonna get that clam. He just doesn't have the open clam shell skill.

[5:07](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=307s) Lots of shrimp, no clams. Maybe you pick the wrong skill for the job and suddenly you're, you're jet skiing on the, on the beach, right? This, this is not, this is not gonna get him very far.

[5:20](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=320s) And sometimes you, you might get that clam open, but then you don't have the skill to eat them.

[5:30](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=330s) So skills, you need to have the right skills, the right chain of skills. Um, actually, we have an awesome project by one of the Neo4j folks, which is just bananas, an arXiv paper which is a graph for skills.

[5:43](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=343s) So that's an exciting way of, like, like, figuring out what the right skills are. But maybe we can do better. So, um, goose is a project that's part of the, um, Agentic AI Foundation.

[5:55](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=355s) This is a new foundation which MCP is part of. Um, Anthropic is backing this. We're, we're also a member of this. So it's a, it's a great-

[6:04](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=364s) Automation tool for a lot of enterprise workflows. You can also use it kind of like a personal assistant. It relies heavily on MCP as the layer, over 70 MCP extensions, and

[6:17](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=377s) what it does is it treats memory just like another MCP server.

[6:23](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=383s) So this is great, right? It's, it's pluggable, you can call different commands on it to retrieve memories, remember memories, um, forget memories. Memories are just plain files on disks, so now you can manipulate them.

[6:37](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=397s) So same great idea, same fundamental problem. We're, we're storing the memory, we're storing the memory of agents as markdown files on disks. And

[6:48](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=408s) again, you end up with what if, what if you pick the wrong tool for the job, the wrong paddle?

[6:55](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=415s) Now, in this case, if you pick the wrong paddle, you're a genius 'cause you've invented the most-- the fastest rising sport in the US, which is pickleball.

[7:05](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=425s) Um, actually, the origin of pickleball was, was, um, a family wanted to create a new game, and they just took what they had around the house, a badminton court, and, um, made up the rules along the way.

[7:16](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=436s) So creation can be good when you have the wrong tools.

[7:20](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=440s) Maybe you remember everything, but it's too much. It's too much weight because you can't actually solve the problem. So our poor friend Goose here is encumbered by

[7:29](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=449s) too many notes, too many memories. Or most dangerously,

[7:36](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=456s) now you have MCP tools, you, you're one step away from calling the Forget command and just wiping out your own memory.

[7:44](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=464s) Okay, so we wanna be able to do better than this.

[7:48](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=468s) So vector databases, right? So we can store everything, we can create embeddings for it. Now we actually have a da- a, a database. We can store it in a vector database.

[7:59](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=479s) So this is great. I mean, you have to pick the right vector database. Um,

[8:04](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=484s) and then now you can do similarity searches, so you can pull back information, which is, which is relevant. So we're doing much better. We have a larger repository of knowledge.

[8:13](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=493s) We can pull back related information. Um, OpenClaw comes with pgvector out of the box. Given an embedding, you can just start using this. Um, LanceDB is a great option.

[8:22](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=502s) I'm gonna use both of those in my demo. But the challenge here is similar, what, what vectors give you, which is similarity in vector space is not the same as actual relationships.

[8:37](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=517s) And so you get hallucinations, you get a lot of problems when you're relying solely on vector lookup as the answer, and it compounds with more complex scenarios when you're doing things like, like I'm gonna show you an example of a digital twin.

[8:50](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=530s) When you're doing things which are very complex, they, they just don't scale and you make silly mistakes like this is obviously is not what poor Crab-D wanted to munch into, and it's a very expensive lunch for him.

[9:06](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=546s) Also, it's sometimes impossible to get to the answer, even though you have all the facts, because those large multi-hop reasoning chains don't work on similarity searches. They're also very expensive on traditional relational databases.

[9:25](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=565s) And often things look similar, but they're not exactly the same. And this is one of the problems with the responses you get from a vector database is you suffer from getting facts which are related in some way, and they're not your shell.

[9:42](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=582s) And you don't, you don't wanna take the wrong shell out of the locker room. That's, that's very unfortunate. So enter graphs. Graphs are a great way of finding the relationships, finding those identities, bu- mapping out the paths, getting that full chain.

[9:57](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=597s) And they're built for this sort of connected data. So now that you have first-class nodes, which are the, the circles, edges, those are the relationships between different objects, and then you can put properties on top of graphs to store information.

[10:12](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=612s) You can also store embeddings in your graph, and that gives you a way to both use vectors and graphs together. Um, architecturally, the demo I'm gonna show you is, um, both a vector search and a graph search.

[10:25](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=625s) So it uses the vector search to get the seed nodes where it starts the traversal, and then it uses a graph search, pulling the, the nearest neighbors and then ranking those by how related they are.

[10:38](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=638s) And this gives you this complex multi-hop queries to solve more difficult, more domain-specific problems and to figure out where that, where that reef is that we wanna get to with all the, the tasty, um, the tasty junk food across the ocean.

[10:56](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=656s) And graphs are-- they're accurate, so they give you very precise information. Explainable because you can look at the graph which got returned,

[11:06](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=666s) and auditable because now you can actually say, "These are the-- this is the context. This is the part of the graph which resulted in that answer." So it's very powerful, and it gives you more tools as a developer where if you're not getting the right answer, y-you know where it's coming from, you can actually see and introspect

[11:24](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=684s) the graph, and you can change how you're doing extraction, you can reduce duplicate nodes in the graph, and then you can get to and converge very quickly on a great answer.

[11:35](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=695s) If you're not a graph expert, guess what? Claude is. Claude can write Cypher better than I can. Claude can extract, build entity extractors, and it can do pretty much everything you need to do to get started with graphs today, as long as you know the, the basic kind of model for what you wanna accomplish.

[11:52](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=712s) And that's what I'm gonna cover in the demo. So we're gonna do, have Claudie write each action into the graph as he works. We're gonna follow up by traversing, not rereading it.

[12:02](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=722s) And then in a fresh session, we will get the results we wanna get out. Now, what I did for this, um, high-stakes demo is I, over the past week or two, I took my [REDACTED:location] as the demo environment, did a full digital twin as a graph, and I have two separate environments built off the same original

[12:22](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=742s) markdown files. One is a vector database store, that's our, our A test, and the second is a graph store, that's our B test. And the graph store is built on top of, um, Cognee.

[12:35](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=755s) So I'm using Cogni, which is a startup. Um, they do amazing stuff in the memory space. They have a Neo4j backend. This is my, the structure. So we have a bunch of Proxmox servers in my, my [REDACTED:location].

[12:49](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=769s) It's really a couple computers around my desk. And

[12:54](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=774s) I built a separate VLAN for the demo, so it's segmented off my real network. So it was trained on real network for my network, but now it's, it's cut off.

[13:02](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=782s) It can only answer from memory. It can't actually look up the hosts and guide-- get dynamic information. So

[13:10](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=790s) let's see how it does in a live demo. Okay, so...

[13:23](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=803s) All right. Here we have our, our CrabRAG cockpit.

[13:27](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=807s) Um, and I have five different questions queued up with schematics. You can see this is the same [REDACTED:location] schematic that you saw earlier in the slides. And, um, let's, let's start with this one.

[13:41](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=821s) So WR and exposed end of life soft- WAN exposed end of life software. So we're gonna-- basically, we're gonna try to find out if there's anything on my network which is exposed to the network, the, the internet, the WAN, that's running out-of-date software, which put my [REDACTED:location] at risk, right?

[13:57](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=837s) So if, if somebody can attack the [REDACTED:location]. And, um, you can see here that there, there is some servers, um, [REDACTED:username], which is my daughter's Minecraft server. It's running, oh my God, DBNA Jessie.

[14:10](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=850s) And let's see how the, the two agents did in looking this up. Okay, so we got the vector response back. Couldn't find specific details excluded by policy for more precise information, yada, yada, yada, source it separately.

[14:25](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=865s) Okay, that's, that's not very helpful. Now, on the graph side, it's done a bunch of Cypher queries. Here are the Cypher queries it's fired off. Um, this is the graph traversal.

[14:36](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=876s) And the, the color coding on the graph traversal is these blue guys. These are the seed nodes. So this came from a, a vector lookup and a ranking, but it didn't stop there.

[14:47](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=887s) It does the one-hop traversals. Those are all the gray nodes. Some of the nodes get highlighted in green, and those are the ones which, which won and got into context.

[14:58](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=898s) And you can see the answer here. So guest name, [REDACTED:username], exactly as expected. Um, OS version out of date, and it's flagging... So, so it gives us very precise, actionable information.

[15:11](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=911s) And so that's the difference between same, same exact data. One is a vector store, one is a graph store, and you can see the difference where the, the vector store is having a lot of trouble pulling the information out, the relevant information out.

[15:25](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=925s) Okay, let's try another one just for fun. Um,

[15:30](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=930s) let's see. Expose [REDACTED:ip_address] management ports. That's, that's bad. So, um, basically you, you don't want your management ports on the network exposed to the, you know, the world.

[15:44](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=944s) And there's a bunch of these. So I have a, a new Matrix server I set up and also HAProxy, which are exposed to the internet. That's bad. The rest of these, like my Cognee demo, my OpenClaw instance, those are inside the LAN.

[15:56](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=956s) You need to get into the LAN to access them. That's, that's what you want. Okay, and let's see how the two agents did in i-identifying this.

[16:05](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=965s) So the memory search returns some information, and it's telling me, "Check services configuration. Expect pfSense rule." So [laughs] it told me to go do the job for it. Um, okay, and then the graph memory side found an open port exposed to WAN, HAProxy, and OpenVPN, which are the, are the two we expected.

[16:26](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=986s) Now this, you can see the shape of this graph is entirely different from the previous one. And what it did is it, it actually found the node for, for my router, the pfSense router, and it was able to follow that directly to all of the results which related to it and then give us, like, a very precise

[16:44](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=1004s) answer. All right. So, um... So now, so now we've seen our little boy Crab-D with his certified Neo4j [laughs] developer T-shirt, is able to do a lot more, right?

[17:09](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=1029s) Now he's able to follow that full chain, crack, eat, do the next thing. So he's getting his, he's getting his clams. He's helping me fix all the security holes in my network.

[17:20](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=1040s) Um, oh, by the way, I, I patched all those security holes [laughs] after the demo. Um, so this was good for me too. It found a bunch of security holes in my [REDACTED:location], and then I, I went and patched them later.

[17:30](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=1050s) And, um, now we have an agent which actually can do interesting things. Now, if you can imagine, like, I have a three or four-node [REDACTED:location] at [REDACTED:location]. If, if you have a big enterprise which has a huge data center, if you're doing things in financial services where you have, like, a huge set of companies and customer

[17:48](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=1068s) records you're trying to do, if you're doing anything at, at large scale where it doesn't fit into the one million context window of the modern models, you really need a better memory system than just throwing things in markdown files.

[18:04](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=1084s) Our little boy Crab-D knows his whole crew, all the crustacean friends.

[18:10](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=1090s) And he's read the book. Um, so we just finished, my, my co-authors and I, Michael Hunger and Jesus Barrasa, finished GraphRAG: The Definitive Guide. The full book is out on, on early release.

[18:23](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=1103s) It'll be published, um, in a couple months once they finish the editorial process, but super excited about this. It's got information not only on GraphRAG, but also on building memory, on, on different industry vertical use cases, on agents.

[18:37](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=1117s) So it's kind of the, the whole umbrella if you're building on top of graph solutions, how you need to build applications with the technologies you need end to end.

[18:49](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=1129s) And then finally, a great free resource which everybody in this room can take advantage of is Neo4j, um, GraphAcademy. So it's free online training, um, dev.neo4j.com/ga-rag, or the QR code below there.

[19:07](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=1147s) And, um, we have courses on doing agent memory, doing context graphs, and everything you need to get, know to get started and to do some of the amazing stuff which I showed you on stage today.

[19:20](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=1160s) So thank you so much for coming to the, the kickoff talk for the graph track. [audience applauding]

[19:30](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=1170s) You're in the right place for all of the content from graph experts. Andreas Kollegger, my colleague, and I crafted a great set of speakers from industry experts, people who really know about graph technology.

[19:43](https://www.youtube.com/watch?v=Q0VkgCyNVUg&t=1183s) So hang out here, find out more, and then you can see me in the Neo4j booth. Thank you. [audience applauding] [upbeat music]
