AI Engineer World's Fair 2026
CrabRAG: Why Automated Assistants Need Graph Memory, Not More Tokens
Read the talk
CrabRAG: Giving an Assistant Memory It Can Traverse
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.
From a talk by Stephen Chin
Before you start: Familiarity with agent tool calls, embeddings and retrieval-augmented generation will help; graph terminology is introduced as needed.
Yesterday’s work, forgotten today
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.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The cost of rereading memory
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, 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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Learning a skill is only the beginning
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
A pluggable interface still needs a memory model
Goose approaches automation through MCP. It belongs to 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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Similarity does not establish a relationship
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, 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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Find a starting point, then follow the connections
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:
- Find seeds: use vector search to locate promising starting nodes.
- Expand relationships: traverse from those seeds to connected neighbors.
- 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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
A digital twin that cannot inspect the live network
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.
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.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Which internet-facing host runs obsolete software?
The first question asks whether any software exposed to the WAN—the public internet—is past end of life. The schematic supplies a concrete target: Tinksterland, Chin’s 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 Tinksterland and its outdated OS |
The graph answer names the guest Chin expected and flags its obsolete operating system. Chin 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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Follow the router to exposed services
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
From a finding to a repair
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Building the graph application
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Open-source platform for building persistent agent memory with knowledge graphs.
Further reading
Free practical course on conversation memory, knowledge extraction and queryable reasoning traces.
Research on representing agent skills as executable graphs with typed dependencies and testable steps.
The foundation’s launch announcement explains the contributions of MCP, goose and AGENTS.md.
Updates since the talk
Current reference for embedding providers, SQLite vector indexing and memory retrieval configuration.
Read the complete timestamped transcript
- 0:00
[on-hold jingle] My name's Stephen Chin. I run the developer relations team here at Neo4j,
- 0:21
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
I, I, I love crab, so our little boy, Crab-D.
- 0:45
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
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
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
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
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
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
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
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
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
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
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 sol.md for your agent's memory.
- 2:58
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
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
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
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
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
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
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
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
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
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
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
And sometimes you, you might get that clam open, but then you don't have the skill to eat them.
- 5:30
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
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
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
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
what it does is it treats memory just like another MCP server.
- 6:23
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
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
again, you end up with what if, what if you pick the wrong tool for the job, the wrong paddle?
- 6:55
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
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
So creation can be good when you have the wrong tools.
- 7:20
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
too many notes, too many memories. Or most dangerously,
- 7:36
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
Okay, so we wanna be able to do better than this.
- 7:48
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
So this is great. I mean, you have to pick the right vector database. Um,
- 8:04
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
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
I'm gonna use both of those in my demo. But the challenge here is similar, what, what vectors give you, which is similarity and vector space is not the same as actual relationships.
- 8:37
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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, Cogni.
- 12:35
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
It's really a couple computers around my desk. And
- 12:54
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
It can only answer from memory. It can't actually look up the hosts and guide-- get dynamic information. So
- 13:10
let's see how it does in a live demo. Okay, so...
- 13:23
All right. Here we have our, our CrabRAG cockpit.
- 13:27
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
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
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
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
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
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
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
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
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
Okay, let's try another one just for fun. Um,
- 15:30
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
And there's a bunch of these. So I have a, a new matrix server I set up and also HProxy, which are exposed to the internet. That's bad. The rest of these, like my Cogni demo, my OpenClaw instance, those are inside the LAN.
- 15:56
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
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
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
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
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
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
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
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
Our little boy Crab-D knows his whole crew, all the crustacean friends.
- 18:10
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
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
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
And then finally, a great free resource which everybody in this room can take advantage of is Neo4j, um, Graph Academy. So it's free online training, um, dev.neo4j.com/ga-rag, or the QR code below there.
- 19:07
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
So thank you so much for coming to the, the kickoff talk for the graph track. [audience applauding]
- 19:30
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
So hang out here, find out more, and then you can see me in the Neo4j booth. Thank you. [audience applauding] [upbeat music]