Turning Agent Memory Into Skills That Work — Will Lyon, Neo4j

Let's get started. Let's get started. I see that some people want I see that some people want I see that some people want to join, so to join, so to join, so please come in. please come in. This session will be This session will be dedicated to actionable dedicated to actionable dedicated to actionable knowledge and knowledge and knowledge and context graphs. context graphs. So, my name is Will. So, my name is Will. I am a product manager at I am a product manager at I am a product manager at Neo4j. Em. There's been a Neo4j. Em. There's been a lot of talk about lot of talk about cycles at this conference, hasn't there? cycles at this conference, hasn't there? React loops, ReAct loops. React loops, ReAct loops. Sometimes I feel like Sometimes I feel like Sometimes I feel like we're in we're in we're in some kind of some kind of some kind of amnesia cycle, right? When amnesia cycle, right? When amnesia cycle, right? When our agents our agents our agents go through the go through the go through the reasoning phase, they act, reasoning phase, they act, reasoning phase, they act, successfully complete successfully complete successfully complete the task, but then they seem to the task, but then they seem to the task, but then they seem to forget what forget what forget what they learned. they learned. Today's Today's memory systems are mostly memory systems are mostly memory systems are mostly focused on focused on focused on embedding text, embedding text, embedding text, and during retrieval, on and during retrieval, on and during retrieval, on finding the most finding the most finding the most relevant data relevant data relevant data to insert into to insert into to insert into context, right? Um, context, right? Um, context, right? Um, something like this. something like this. something like this. We find similar We find similar We find similar pieces of data in pieces of data in pieces of data in our corpus, our corpus, our corpus, insert them into a insert them into a insert them into a context window, and context window, and context window, and hope that hope that hope that the agent can do the agent can do the agent can do something useful with it, something useful with it, something useful with it, right? The problem is that right? The problem is that right? The problem is that remembering remembering is not exactly actionable is not exactly actionable is not exactly actionable knowledge. One of knowledge. One of knowledge. One of the challenges the challenges the challenges we face is, we face is, we face is, for example, the for example, the for example, the lack of a lack of a lack of a canonical canonical canonical representation of representation of representation of an object. If we have an object. If we have an object. If we have three different ways to three different ways to three different ways to address Dr.

address Dr. address Dr. Nguyen: Robert N., Nguyen: Robert N., Nguyen: Robert N., cardiologist, correct? cardiologist, correct? Depending on Depending on the context the context the context of the discussion, we of the discussion, we of the discussion, we need to have some need to have some need to have some canonical representation canonical representation canonical representation of the object. In fact, of the object. In fact, of the object. In fact, agents need agents need agents need knowledge that is knowledge that is knowledge that is coherent, coherent, coherent, typed, and typed, and typed, and traceable. Not traceable. Not traceable. Not just ones that just ones that just ones that can be obtained. Search can be obtained. Search is only part of the is only part of the is only part of the problem when we problem when we problem when we talk about talk about talk about agent memory. So, in Neo4j, we agent memory. So, in Neo4j, we agent memory. So, in Neo4j, we see agent memory like this see agent memory like this see agent memory like this . We . We . We view it as a view it as a view it as a connected graph connected graph connected graph consisting of consisting of consisting of short-term, short-term, short-term, long-term, and long-term, and long-term, and logical memory. We'll logical memory. We'll logical memory. We'll look at this in a little more look at this in a little more look at this in a little more detail. But detail. But detail. But be patient with be patient with be patient with this idea of this idea of this idea of context graphs context graphs context graphs for agent memory, for agent memory, for agent memory, okay? What are the okay? What are the okay? What are the main components here? main components here? Well, first, it's a Well, first, it's a transition from transition from transition from unstructured unstructured unstructured data to a knowledge graph. data to a knowledge graph. Moving from the process...

agent messages, agent messages, right? Both right? Both right? Both user and user and user and assistant messages assistant messages assistant messages go through an go through an entity extraction process where we entity extraction process where we determine what these determine what these determine what these entities are and how they are entities are and how they are entities are and how they are related. Doing this in a related. Doing this in a related. Doing this in a graph where we have graph where we have graph where we have clear types, right? clear types, right? We have a relationship that We have a relationship that describes how these describes how these describes how these entities interact entities interact entities interact with each other. The with each other. The entity recognition phase is one of the entity recognition phase is one of the most important parts of most important parts of most important parts of building this building this building this knowledge graph, right? knowledge graph, right? knowledge graph, right? Understanding and Understanding and Understanding and ensuring that ensuring that ensuring that you have a canonical you have a canonical you have a canonical representation of representation of representation of an object. So when we an object. So when we an object. So when we talk about Dr. talk about Dr. talk about Dr. Nguyen, we know that Nguyen, we know that Nguyen, we know that this is a provider this is a provider this is a provider , his name, , his name, , his name, his role, etc. And a his role, etc. And a his role, etc. And a shared ontology is an shared ontology is an shared ontology is an important part of important part of important part of that, right? That is, that, right? That is, that, right? That is, having a certain description of having a certain description of having a certain description of your data model, your data model, your data model, the domain you are the domain you are the domain you are working with. This is one of the working with. This is one of the working with. This is one of the key elements key elements key elements that ensures a that ensures a that ensures a successful transition from successful transition from successful transition from unstructured unstructured unstructured text data to a text data to a text data to a knowledge graph. So for knowledge graph. So for knowledge graph. So for those who have those who have those who have worked with worked with worked with agent memory before, this should agent memory before, this should agent memory before, this should look a little look a little look a little familiar. One thing that familiar. One thing that I think is really I think is really I think is really important when we important when we important when we talk about talk about talk about agent memory and real agent memory and real agent memory and real knowledge is the idea of ​​a knowledge is the idea of ​​a knowledge is the idea of ​​a reasoning graph, reasoning graph, reasoning graph, right? If we've seen right? If we've seen right? If we've seen our three components of our three components of our three components of agent memory, agent memory, agent memory, reasoning memory reasoning memory reasoning memory is the primary one here, is the primary one here, is the primary one here, right? We talked

right? We talked right? We talked about short-term about short-term about short-term and long-term and long-term and long-term memory. These are memory. These are memory. These are the messages, the the messages, the the messages, the entities extracted, entities extracted, entities extracted, but what about the actual but what about the actual but what about the actual actions actions actions the agent performs? What about the the agent performs? What about the reasoning process itself? We want to reasoning process itself? We want to make sure make sure make sure we capture that because we capture that because we capture that because it's an important it's an important it's an important part as well. So, we part as well. So, we part as well. So, we want to make sure we want to make sure we want to make sure we 're preserving 're preserving 're preserving the thinking and the facts, the thinking and the facts, the thinking and the facts, not just the data itself, not just the data itself, not just the data itself, right? That is, how right? That is, how right? That is, how exactly the agent made exactly the agent made exactly the agent made the decision. And that's the decision. And that's the decision. And that's usually usually usually represented as a represented as a decision-making trail, decision-making trail, right? So every right? So every right? So every decision decision decision our agent makes involves our agent makes involves evidence-based reasoning, right? We have evidence-based reasoning, right? We have policies that we policies that we policies that we model explicitly, and we model explicitly, and we model explicitly, and we understand the understand the understand the execution plan: execution plan: execution plan: the tools that the the tools that the the tools that the agent called, and the agent called, and the agent called, and the results of those results of those results of those calls. We also calls. We also calls. We also want to record want to record want to record things like things like things like the number of the number of the number of tokens spent, tokens spent, tokens spent, execution time, etc. execution time, etc. execution time, etc. This is all part of This is all part of This is all part of fixing the memory of fixing the memory of fixing the memory of reasoning. And this is reasoning. And this is reasoning. And this is important not only so important not only so important not only so that one agent that one agent that one agent can perform better the can perform better the can perform better the next time they next time they next time they do the do the do the same task, but also same task, but also same task, but also for systems where you have for systems where you have for systems where you have hundreds or thousands of hundreds or thousands of hundreds or thousands of agents sharing a agents sharing a agents sharing a common set of common set of common set of tools, right tools, right tools, right ? So we can ? So we can ? So we can store these store these store these agent runs, these agent runs, these agent runs, these decision traces in a graph, and decision traces in a graph, and decision traces in a graph, and then share them with then share them with then share them with other agents in other agents in other agents in our organization, our organization, our organization, right? Thus, right? Thus, right? Thus, we have one we have one we have one shared shared shared context graph that

context graph that context graph that allows our allows our allows our agents to learn agents to learn agents to learn from each other through this from each other through this from each other through this shared shared shared memory element. Okay, that's the thing memory element. Okay, that's the thing memory element. Okay, that's the thing about memory about memory . This is, in fact, the . This is, in fact, the . This is, in fact, the system we system we system we built in Neo4j. A built in Neo4j. A built in Neo4j. A template that many template that many template that many follow for working follow for working follow for working with agent memory. with agent memory. with agent memory. But what about the idea of But what about the idea of But what about the idea of practical knowledge, huh? practical knowledge, huh? practical knowledge, huh? How do we allow How do we allow How do we allow our agents to act? our agents to act? our agents to act? Memory, one Memory, one Memory, one way of thinking way of thinking way of thinking about memory is that it's a about memory is that it's a about memory is that it's a beautiful beautiful beautiful reflection of what reflection of what reflection of what happened, right? We happened, right? We happened, right? We know the people we were know the people we were know the people we were talking about and how talking about and how talking about and how they are connected. We have they are connected. We have they are connected. We have these traces of decisions. The these traces of decisions. The next step next step is usually is usually is usually skill building, right? skill building, right? skill building, right? How many people How many people use use skills with their skills with their skills with their agents today? Most of them are agents today? Most of them are agents today? Most of them are cool. How many people cool. How many people cool. How many people wrote these wrote these wrote these skills themselves? Cool, skills themselves? Cool, skills themselves? Cool, most of them. How many most of them. How many most of them. How many people have asked an agent people have asked an agent people have asked an agent to write a skill for to write a skill for to write a skill for them? Steeply. So, that's what them? Steeply. So, that's what them? Steeply. So, that's what we're we're we're talking about here: how to move talking about here: how to move talking about here: how to move from this from this from this memory graph, this memory graph, this memory graph, this context graph, to how to context graph, to how to context graph, to how to use it to use it to use it to create create create grounded and grounded and grounded and actionable skills.

actionable skills. So, if you're not So, if you're not familiar with the concept of a familiar with the concept of a familiar with the concept of a skill, it's an open skill, it's an open skill, it's an open standard. Anthropic standard. Anthropic standard. Anthropic released it. released it. Agentskills.io seems to be Agentskills.io seems to be where this where this where this open standard is hosted. The open standard is hosted. The open standard is hosted. The main idea here is that main idea here is that main idea here is that we have some we have some we have some metadata, right? metadata, right? metadata, right? Some description of what Some description of what Some description of what this skill is about. And then this skill is about. And then this skill is about. And then it's a gradual it's a gradual it's a gradual disclosure of information disclosure of information , right? That is, I have a , right? That is, I have a , right? That is, I have a lot more detailed lot more detailed lot more detailed information. These are often information. These are often information. These are often files in markdown format, files in markdown format, files in markdown format, links that we links that we links that we can gradually can gradually can gradually select, if we go select, if we go select, if we go through the process of performing through the process of performing through the process of performing part of the skill, we part of the skill, we part of the skill, we can retrieve and can retrieve and can retrieve and load this data into the load this data into the load this data into the context. So this gives context. So this gives context. So this gives us common units us common units us common units that we can take, that we can take, that we can take, package the skill, and package the skill, and reuse across reuse across different agents. But different agents. But different agents. But skills have a similar skills have a similar skills have a similar problem to what we problem to what we problem to what we saw earlier when we saw earlier when we saw earlier when we talked about memory.

talked about memory. Namely, that we Namely, that we usually work with usually work with usually work with prose. And so we're prose. And so we're prose. And so we're still limited in still limited in still limited in understanding whether understanding whether understanding whether this is a canonical this is a canonical this is a canonical object and in object and in object and in providing providing debuggable steps and debuggable steps and results. So, to results. So, to results. So, to solve these solve these solve these skills problems, some of the skills problems, some of the Neo4j research team did some Neo4j research team did some interesting research and interesting research and interesting research and published a paper published a paper published a paper on APE—a graphical on APE—a graphical on APE—a graphical representation for representation for representation for training and training and training and managing managing managing agent skills. This is a screenshot agent skills. This is a screenshot agent skills. This is a screenshot from the article. Zach is here somewhere from the article. Zach is here somewhere from the article. Zach is here somewhere . If it's . If it's . If it's not here, it's not here, it's not here, it's at the Neo4j booth today, at the Neo4j booth today, at the Neo4j booth today, so be sure so be sure so be sure to chat with to chat with to chat with Zach if you're Zach if you're Zach if you're interested, but you interested, but you interested, but you can think of APE can think of APE can think of APE as an extension of the as an extension of the agent skills protocol with agent skills protocol with additional additional additional metadata, which now metadata, which now metadata, which now treats your treats your treats your skills as skills as skills as typed typed typed execution graphs, right? So execution graphs, right? So execution graphs, right? So we have steps we have steps we have steps modeled as modeled as modeled as nodes, and we have a very nodes, and we have a very nodes, and we have a very strict scheme that strict scheme that strict scheme that governs the description of how governs the description of how governs the description of how these steps become these steps become these steps become actionable. Yes? So, actionable. Yes? So, actionable. Yes? So, think of it as a think of it as a think of it as a way of representing a way of representing a way of representing a skill as a skill as a skill as a graph, broken down into graph, broken down into graph, broken down into steps that are performed steps that are performed steps that are performed using a schema using a schema using a schema that governs the description. This

that governs the description. This that governs the description. This is the APE protocol, and is the APE protocol, and is the APE protocol, and according to the benchmark according to the benchmark according to the benchmark used in used in used in the article, it really makes a the article, it really makes a the article, it really makes a difference: when difference: when difference: when applied to Skills applied to Skills applied to Skills Bench, we saw a significant Bench, we saw a significant Bench, we saw a significant increase in the number of increase in the number of increase in the number of tasks completed tasks completed tasks completed when using the when using the when using the APE protocol for APE protocol for APE protocol for human-selected human-selected human-selected skills. So, this skills. So, this skills. So, this looks interesting. How looks interesting. How looks interesting. How can we can we can we use some of use some of use some of these ideas and these ideas and these ideas and research to research to research to distill skills? distill skills? Essentially, we want to Essentially, we want to take this take this take this memory graph, this memory graph, this memory graph, this context graph, context graph, context graph, which may be which may be which may be limited to a limited to a limited to a workspace or a project workspace or a project workspace or a project in an organization, and in an organization, and in an organization, and distill it into a distill it into a distill it into a skill, but not skill, but not skill, but not just as a markdown just as a markdown file. We want file. We want file. We want it to be based on it to be based on it to be based on real data that real data that real data that we have observed. We we have observed. We we have observed. We want it to be want it to be want it to be deterministic, right? deterministic, right? deterministic, right? We want to have well- We want to have well- We want to have well- understood procedural understood procedural understood procedural steps in our graph steps in our graph steps in our graph and we want to be and we want to be and we want to be able to manage able to manage able to manage it over time, right? If the it over time, right? If the it over time, right? If the underlying data that underlying data that underlying data that forms our forms our forms our skill changes in skill changes in skill changes in memory, we want to memory, we want to memory, we want to be able to understand be able to understand be able to understand it and know about it.

it and know about it. Justification is the Justification is the important part important part important part here, right? here, right? here, right? Making sure that the data Making sure that the data that makes up our that makes up our that makes up our skill is based skill is based skill is based on our on our on our memory system, but that's memory system, but that's memory system, but that's not enough for it to not enough for it to not enough for it to be useful, right? There are be useful, right? There are be useful, right? There are other heuristics other heuristics other heuristics we should pay we should pay we should pay attention to. For example, attention to. For example, attention to. For example, coverage: do coverage: do coverage: do we make sure that we make sure that we make sure that the steps and descriptions throughout the steps and descriptions throughout the steps and descriptions throughout our skill are our skill are our skill are valid valid valid within the entire skill. within the entire skill. Coherence. Coherence. Coherence is Coherence is Coherence is interesting. This is a way interesting. This is a way interesting. This is a way we can we can we can detect whether detect whether detect whether the information or the information or the information or subgraph coming subgraph coming subgraph coming into the skill distillation is into the skill distillation is into the skill distillation is divided into multiple divided into multiple divided into multiple topics, and we can topics, and we can topics, and we can suggest: suggest: suggest: maybe you should maybe you should maybe you should create multiple create multiple create multiple skills here, and so skills here, and so skills here, and so on. So, these are some of the on. So, these are some of the on. So, these are some of the elements that lead elements that lead elements that lead to skill generation. to skill generation. to skill generation. Skill management Skill management is an important aspect that is an important aspect that is an important aspect that I mentioned, I mentioned, I mentioned, making sure that we making sure that we making sure that we can understand: as the can understand: as the skill changes, as the data changes, are data changes, are we able to update that we able to update that we able to update that skill? And thanks to skill? And thanks to skill? And thanks to dynamic dynamic dynamic loading, you can loading, you can loading, you can think of it as a think of it as a think of it as a managed managed managed skills inventory, which allows skills inventory, which allows skills inventory, which allows us to get us to get the most relevant the most relevant skills for any agent and understand skills for any agent and understand skills for any agent and understand whether they are outdated whether they are outdated whether they are outdated or have lost or have lost or have lost their relevance, their relevance, their relevance, right? Steeply. So, we right? Steeply. So, we right? Steeply. So, we implemented this in the implemented this in the Neo4j Agent Memory Service, or as we

Neo4j Agent Memory Service, or as we call it, NAMS. This is a call it, NAMS. This is a call it, NAMS. This is a memory service for memory service for memory service for agents, agents, agents, part of our part of our part of our development at Neo4j Labs. development at Neo4j Labs. development at Neo4j Labs. We also have We also have open source tools that open source tools that implement these implement these implement these patterns. Essentially, it patterns. Essentially, it patterns. Essentially, it works like this: we have a works like this: we have a works like this: we have a context graph within the context graph within the workspace, right? It workspace, right? It contains three types of contains three types of contains three types of agent memory: agent memory: agent memory: short-term, short-term, short-term, long-term, and long-term, and long-term, and reasoning memory reasoning memory . We have background . We have background . We have background processes capable of processes capable of processes capable of performing this performing this performing this distillation process. distillation process. distillation process. We'll We'll We'll see what that see what that see what that looks like in a minute. We also looks like in a minute. We also looks like in a minute. We also have a background have a background have a background creation process that creation process that creation process that provides control provides control provides control to detect when to detect when to detect when our skills become our skills become our skills become obsolete obsolete obsolete based on the data based on the data based on the data contained in the contained in the contained in the memory system. This is the pipeline memory system. This is the pipeline memory system. This is the pipeline we we we use to use to use to create them. I won't create them. I won't create them. I won't go into go into go into detail on this. The only thing detail on this. The only thing we want to we want to we want to point out here is that point out here is that point out here is that most of these steps most of these steps most of these steps are deterministic. We're are deterministic. We're are deterministic. We're really really only using LLM here to synthesize only using LLM here to synthesize some statements and some statements and some statements and generate some of generate some of generate some of the text that the text that the text that we use to we use to we use to describe skills. And describe skills. And describe skills. And one more thing I want to one more thing I want to one more thing I want to point out: the first point out: the first point out: the first stage is stage is stage is scoping. That is, where do scoping. That is, where do scoping. That is, where do you start you start you start distilling one of distilling one of distilling one of these skills? Is it these skills? Is it these skills? Is it related to a specific related to a specific related to a specific entity, or to entity, or to entity, or to the subgraph around the subgraph around the subgraph around it? Is this a specific it? Is this a specific it? Is this a specific conversation? Well, that's another thing conversation? Well, that's another thing conversation? Well, that's another thing . So we can

. So we can . So we can decompose the way decompose the way the skill is represented and the skill is represented and make sure that make sure that make sure that each of these each of these each of these components is again components is again components is again based on the based on the based on the original data. This is original data. This is original data. This is exactly the point where exactly the point where exactly the point where we check if we check if we check if the skill becomes the skill becomes the skill becomes obsolete if obsolete if any of this source any of this source any of this source data changes, data changes, data changes, is removed, or is removed, or is removed, or becomes inconsistent becomes inconsistent . Steeply. And then we . Steeply. And then we . Steeply. And then we can also, as I can also, as I can also, as I mentioned before, mentioned before, mentioned before, combine skills, combine skills, combine skills, right? This is where the right? This is where the right? This is where the principle of principle of principle of consistency comes in handy. We consistency comes in handy. We consistency comes in handy. We use use use graph algorithms graph algorithms graph algorithms like like like community detection, right? So community detection, right? So community detection, right? So if we are mixing topics if we are mixing topics if we are mixing topics from multiple communities, from multiple communities, from multiple communities, it could be a sign it could be a sign it could be a sign that we need to that we need to that we need to decompose our decompose our decompose our skill, and we will find skill, and we will find skill, and we will find this within this within this within skill management. Steeply. skill management. Steeply. skill management. Steeply. So, I have a So, I have a So, I have a few few few minutes left. Let's minutes left. Let's minutes left. Let's see what it see what it see what it looks like. So this is NAMS, the looks like. So this is NAMS, the looks like. So this is NAMS, the Neural Neural Neural Agent Memory Service. Agent Memory Service. It is currently It is currently free. Anyone free. Anyone free. Anyone can log in and can log in and can log in and try it out try it out try it out . This is what the . This is what the dashboard looks like. The basic idea is basic idea is that we have a REST API that we have a REST API that we have a REST API and MCP tools that and MCP tools that and MCP tools that we can provide to we can provide to we can provide to our agents to our agents to our agents to write, retrieve, and write, retrieve, and write, retrieve, and work with work with work with long-term, long-term, long-term, short-term, and short-term, and short-term, and logical memory. We logical memory. We logical memory. We go through the process of go through the process of entity extraction and recognition, so I entity extraction and recognition, so I can view a can view a can view a graphical graphical graphical representation of representation of representation of my agent's memory. I

my agent's memory. I my agent's memory. I can navigate it, can navigate it, can navigate it, etc. We can etc. We can etc. We can see the entities see the entities see the entities that have been marked. An that have been marked. An important part important part here is the concept of here is the concept of here is the concept of ontology. In this ontology. In this ontology. In this case, we case, we case, we use a use a use a medical ontology. We medical ontology. We medical ontology. We will work with will work with will work with data on visits, data on visits, data on visits, medical professionals, medical professionals, medical professionals, etc. I also etc. I also etc. I also uploaded uploaded uploaded a few conversations here. We a few conversations here. We a few conversations here. We can see can see can see the conversations that were the conversations that were the conversations that were uploaded regarding the uploaded regarding the uploaded regarding the medical agent, medical agent, medical agent, right? Now we are right? Now we are right? Now we are ready to highlight ready to highlight ready to highlight the skill. As we the skill. As we the skill. As we said, the first step is said, the first step is to determine the to determine the to determine the scope of this skill. scope of this skill. We can do this We can do this for the entire workspace for the entire workspace for the entire workspace . Although this is not . Although this is not . Although this is not always what we always what we always what we need. We can need. We can need. We can do this for a specific do this for a specific do this for a specific entity, specific entity, specific entity, specific conversations, or a class in an conversations, or a class in an conversations, or a class in an ontology. Let's ontology. Let's ontology. Let's do this for our do this for our do this for our last conversation. We last conversation. We last conversation. We will see how the will see how the will see how the process begins process begins process begins in the distillation queue: in the distillation queue: in the distillation queue: the system will receive data, the system will receive data, the system will receive data, go through a go through a go through a seven-stage pipeline, seven-stage pipeline, seven-stage pipeline, form a skill in the form a skill in the form a skill in the form of a graph, and form of a graph, and form of a graph, and package it for us.

package it for us. While it works, here is While it works, here is one example. one example. Let's just Let's just take a look at him. take a look at him. Here is the example we Here is the example we ran earlier. It ran earlier. It ran earlier. It was launched was launched was launched based on a conversation during a based on a conversation during a based on a conversation during a patient's appointment. patient's appointment. As you can see, we have As you can see, we have essentially highlighted the steps essentially highlighted the steps essentially highlighted the steps that make up a skill: that make up a skill: that make up a skill: from receiving a patient from receiving a patient from receiving a patient to filling out their to filling out their to filling out their medical record. We medical record. We medical record. We see that each of see that each of see that each of these steps is based these steps is based these steps is based on the actual on the actual tool calls and tool calls and entities that entities that entities that form the core form the core form the core components of the skill, and components of the skill, and components of the skill, and we package this we package this we package this together with the skill file. MD. together with the skill file. MD. If we were to If we were to upload this, it would be upload this, it would be upload this, it would be packaged with packaged with packaged with other reference other reference other reference materials materials materials in accordance with the in accordance with the progressive progressive disclosure standard disclosure standard we we we use for use for use for agent skills. Class agent skills. Class . So, this was a . So, this was a . So, this was a quick overview of quick overview of quick overview of how we look at how we look at how we look at agent memory agent memory agent memory within this within this within this context graph with Neo4j, and I'll context graph with Neo4j, and I'll context graph with Neo4j, and I'll leave you with some leave you with some leave you with some useful links.

useful links. The slides can be The slides can be downloaded here. Here is downloaded here. Here is downloaded here. Here is a link to the slides a link to the slides a link to the slides and a QR code. The and a QR code. The and a QR code. The Neo4j agent memory service Neo4j agent memory service Neo4j agent memory service I mentioned is I mentioned is I mentioned is also listed here, also listed here, also listed here, along with a bunch of along with a bunch of along with a bunch of documentation and documentation and documentation and resources for our resources for our open source tools. So , that's all. I'm out of , that's all. I'm out of , that's all. I'm out of time, but time, but time, but we have a Neo4j booth. So I will be we have a Neo4j booth. So I will be we have a Neo4j booth. So I will be there, as will many there, as will many there, as will many others from the others from the others from the Neo4j team. Neo4j team. Neo4j team. See you there. Thank you See you there. Thank you See you there. Thank you all.