Have you ever wanted your AI agent to remember certain details about you, like your preferences? So that way the responses are tailored around you as an individual. You might have seen this exact same feature implemented in something like chatgpt.

So if I said something like, "My dog's name is Ruby and she is 8 years old. " You will notice that chatgpt shows this message saying that the memory was updated. And if we had to start a new conversation, and then ask something like, "What is my dog's name?

" Chatgpt remembered that my dog's name is Ruby. And this is actually being pulled from our memories. And we can see those memories by going to settings, personalization, manage.

And here we can see all the memories that were collected by chatgpt. Now you might be wondering how this is different to rag or conversation history. So I'll try to explain the differences between what we'll refer to as memories versus rag versus conversation history.

And hopefully this will explain the difference between all three of these techniques. So let's say we've got our user over here, and on the right hand side we've got our AI agent. So let's say for the sake of this example that this is a travel agent.

So let's say our agent has access to some Victor database. And this database could contain information about hotels or resorts or some packages that's available to this agent. So if the user asks something like, "What specials do you have?

" This will call our agent. Our agent will reach out to the rag database. It will find some relevant information about special deals, and then respond back to the user with the list of specials.

Great, so we're all familiar with rag and the use cases for it. But what if the user says, "I love the ocean. " Well, the agent will reach out to the rag database, grab the most relevant packages, and return it back to the user.

And if we wanted to, we could also assign memory to this agent. And let's be very clear, this is conversation memory. So this means the back and forth conversation between the agent and the user is stored in this little database.

So that means if the user had to come back to this conversation, this same conversation, and they asked, "What specials do you have? " The agent will first grab the conversation history, and from the history, it will see that the user said they like staying at the ocean. So therefore, it will go to the vector database and grab the most relevant packages.

This is all fine and dandy as long as the user doesn't start a new conversation. So what happens when the user starts a new conversation? Well, if they send this question, the agent will reach out to the conversation history and find there were no messages for this new conversation, and it will simply go to the rag database, grab the most relevant documents based on this question, and return that to the user.

So at that point, the user's preferences have been forgotten, and the results are no longer tailored around the user's preferences. And that is where the concept of long-term memory comes in. So with long-term memory, what will happen is the user will send their question, but before we call the agent, our workflow will first retrieve all the memories that we've said so far and then inject those memories into the agent's system prompt.

These memories are not linked to any one specific conversation. They span all conversations. So this spans all conversations, whereas the conversation history is specific to one specific conversation.

Let's have a look at this in N8N, and hopefully you'll see that same workflow here. We'll send our chat message, we'll grab the memories, we'll simply aggregate those memories, we will merge the user's chat message along with those memories and then pass all of that to the agent. And of course, if we tell the agent to store memories or if the agent determined itself that you've just shared something significant, it will automatically store that memory as well.

Let's give this a spin. Let's say, I like Italian food. And we are getting our response back.

Now, watch what happens when we start a brand new conversation. And remember, my preferences will not be available in the buffer memory node, as this is a new conversation. So let's try this by asking, "Please recommend a restaurant in Cape Town.

" So this is retrieving our memories and we get our response back. But now have a look at this response. It's saying that Cape Town has a fantastic dining scene.

Since you like Italian food, I highly recommend the following. So although we've started a brand new conversation, it was able to recall our preferences. So this means that the more we chat with the agent, irrespective of how many different conversations we're having with it, it will collect information about us and improve that final result.

Right, let's build this. So let's start a new workflow. Let's call this memory agent.

And let's add a new trigger node. And let's add the on chat message node. Cool.

Of course, you can integrate this into WhatsApp, Telegram, or whatever you want. For the sake of this demo, we'll just keep it simple by using the chat node. Let's also add our AI agent.

And for this agent, we will be setting a system prompt. So let's open up this. So let's go to expression.

Let's open this up. And by the way, you can download this workflow for free, along with the prompts that I'm using in this demo. You can get that by clicking on the link in the description of this video.

So let's have a look at this prompt. This is simply saying that you are a friendly AI assistant, and you are currently talking to Leon. Again, if you were using Telegram, you could dynamically populate this name.

But for now, I'm just going to arc code it to my name. And under rules, we're just saying when the user sends a new message, the site of the user provided any noteworthy information that should be stored in memory. If so, call the save memory tool, which is a tool that people add in a minute, to store this information in memory.

Do not inform the user that this information was saved in memory. Now, this is absolutely up to you. Maybe you want to inform the user of this.

I personally don't care. Simply continue to answer the question or executing the next tasks. Then I like to create this tool section where I just mentioned the tool name and when this tool should be used.

Cool. Let's go back to our canvas. And let's assign our chat model.

I'll use open AI. And here I'll just select my credentials. And I'll use GPT40 Mini.

That's perfectly fine. Let's also add a memory node. Again, this is the conversation history.

So let's add this window buffer memory node. I'll select the last 20 messages. Now, under tools, we will add a tool to store these memories in some sort of database.

Now, really, this could be anything. It's totally up to you. But for the sake of this tutorial, I will be using Airtable because it's really easy to set up.

And it actually works quite well for something like this. So let's search for Airtable. And let's add the Airtable tool.

Let's create our credentials. So let's click on create new credential. And this needs an access token.

To get that access token, go to Airtable. com and sign into your account. Then under workspaces, click on create a workspace.

Give it a name like Agent Memories. Then let's create a new database. Let's start from scratch.

Let's rename this to Agent Memories. Let's rename this tab to Memories. And then for the column names, let's rename this one to Memory.

And we'll leave it as a single line text. For the second column, let's edit this field. Let's rename this to User.

Let's change this type to single line text. Let's save this. Then I'm going to delete these two columns.

So I'll delete that and I'll delete status. And let's add a new column. Let's call this created.

And for the type, let's go all the way down. And let's select created time. And let's click on create field.

Cool. And let's also delete each of these blank records. Like so.

Awesome. So just to show you what this will look like. If I look at this example, this will have a summary of the memory along with the user that this memory belongs to.

So this way we can cater for multiple users in our application. And we also have the created date and time. And there's a reason for this.

I might tell my agent that I like Italian food. But tomorrow I might change my mind and tell it that actually I now like something else. So this date and time will give our agent a better idea of what the latest preferences are.

So one memory could override another. Cool. Now that we have the stable setup, we have to get an access key by going to account.

Then go to builder hub. Then click on create new token. Give it a name by agent memory tutorial.

Add the scope like records read. Let's add another scope for records write. And let's add one more scope for schema basis read.

Then under access, click on add a base and select the agent memories base, which we just created. Then click on create token, copy your token and add it to an eight in. Let's click on save.

And this was successful. Great. Right now back in our air table node, I'm just going to rename this note to save memory.

Then under operation, let's change this to create. Then for the base, let's select memory. And for the table, let's select memory as well.

Now for the user, I'm simply going to archive this to Leon. But again, if you are using telegram or something else, you can dynamically populate this value as well. Now for this memory field, we want the agent to intelligently grab the memory from the user's message and then store a summary of that memory in this field.

Now, how can we do that? Thankfully, that's quite easy. And it is kind enough to give us this little tool tip.

All we have to do is grab everything from these opening curly braces to the closing braces. And for this memory field, switch to expression and paste in that text. I'm actually going to open this up so it's a bit more visible.

And let's change this placeholder name to memory. And that should be it. Let's close this pop up.

Let's go back to the canvas and let's test this. Let's start our chat window and let's say hello. Just to make sure our connection to the large language model is working, which it is.

Now, let's say my dog's name is Ruby. Right, we get our response back and looking at the canvas, we can see that safe memory was indeed called. And if we look at our database, we can see that that memory was successfully stored.

Let's try one more. Let's say I like Italian food and we can see that it is calling the safe memory tool. We can see that this memory was stored as well.

So now that we're able to store memories, how do we now retrieve those memories and use it in our agent? So what we'll do first, let's just close this chat window. Let's move this trigger up and let's add a new node.

And let's grab the air table node and more specifically the search records node. Let's rename this to get memories. And from the base, let's select our air table base.

Let's also grab our table. And for this folder, we do want to folder on the user's name. So we can simply use their example, which is to enter parentheses and curly braces, then the air table column name, which we called user.

And outside of these braces, we can enter equals and in quotes, the user name. And again, you can switch to expression and make that name dynamic. We'll just hard code it for this demo.

Then what we also want to do is to sort these values by the creation date. So in this field, let's select created and we'll sort in ascending order. This will just ensure that each of these memories is passed to the agent in the correct sequence.

Great. So let's test this by just saying hello and looking at the get memories node, we do get those two memories coming back for this user. You might run into one bug here though.

If the stable is empty, this node won't output anything, which will cause issues down the line. So we can force it to always output some value by going to settings and enable always output data. So if there are no memories in the database, it will simply return an array with an empty object.

Right now, if we run this, we will run into a few issues. The first issue is that this AI agent node will fail saying that it can't find the session ID. That is because at the moment, this agent is expecting to receive the input from the chat node.

So it's expecting this node to be directly connected to this AI agent node. Also, this get memories node is returning two values. So we can see it over there, which means that even if we resolve this error, this agent will actually be called twice, which is not correct either.

So what we'll do instead is run the get memories node in parallel to passing the input to this AI agent node. So running it like this obviously won't work either because this will still cause the agent to be called twice. So what we'll do instead is the following.

First, for this get memories path, we want to merge all these items into a single result. So we can do that by clicking on aggregate. Then let's change this to all item data.

And for the output field name, let's rename this to memories. And under include, let's change this to specified fields. And in here, I want to grab the memory field and the created field like so.

Now when we run this, we will get an array with exactly one item, which contains all the different memories, but this time in one record. Cool. Next, we want to merge the value that the user sent through the chat message along with these memories.

So merging is very easy. Let's simply add a new action. Let's add merge.

Let's change the mode to combine and combine by. Let's select all possible combinations. Great.

Let's go back to the canvas. Let's also attach the chat message to this merge node. In fact, I want this to go to the input one and I want the aggregate node to go to input two.

Cool. Then we can connect the merge node to our AI agent. Right.

Now let's have a look at this. Let's send a new message like hello. So the chat message was passed to this merge node and the get memories node then ran.

It aggregated all the memories into one item and the merge node now received everything from the chat window and the results from this aggregate node, which means that the final output now gives us everything from the chat window along with all of our memories. Now it becomes very easy to use these values in our agent. Now, obviously that error message was resolved because the agent is now receiving the chat input values from that merge node.

But what we want to do now is to inject the memories into our system prong. So below tools, I'm actually going to add this new section called memories. So this is simply saying here are the last noteworthy memories that you've collected from the user, including the date and time this information was collected.

Important. Think carefully about your responses and take the user's preferences into account. Also consider the date and time that the memory was shared in order to respond with the most up to date information.

And then finally, we're simply injecting all the values from this memory node over here. So the end result would look something like this. This is injecting this memory node along with the text and the timestamp information.

Cool. Let's give this a spin. Let's start a new conversation.

At the moment, we have these two values available. So I'm actually going to delete these like so. Then it's a I have a dog named Ruby.

Okay, cool. So let's then also say Ruby is eight years old. Okay, cool.

We can see those two entries in the database as well. So if we start a new conversation, again, this information is not available in the conversation memory at all. So we can now ask what is my dog's name?

And it was able to recall that information. Now this is a very simple demo to get your agent to remember details about you. Now imagine taking this technique and adding it to an AI assistant.

That assistant will collect more and more information about you over time and provide way more personalized responses. So if you would like to learn how to build an AI assistant using M8N, then check out this video over here. Otherwise, I'll see you in the next one.

Bye bye.

Build an AI Agent That Actually Remembers You (n8n Tutorial)