Remember this: Agent state and memory with ADK

Key Takeaways

Hey everyone, my name is Ann Barrage and I'm a developer relations engineer on the Google Cloud team. Today I want to show you using ADK how you can give your AI agents memory. [Music] Learning new skills is often a journey and learning through conversation is a powerful way to do it. So in this video, we're going to create a Python tutor agent which uses ADK, Google's agent development framework. An ADK has some pretty cool features, one of which we're going to dive into today called memory. So, let's quickly recap some of the key components that make up a basic ADK agent. At its core, an agent has system instructions, which define its personality and goals. It also has a model, which acts as its brain, and a set of tools that act as its hands to perform actions in the world. So to get our Python tutor really working well, we want to give our agent the ability to quiz the user, allowing them to access their knowledge. To do this, we first configure our agent with a detailed system prompt. This is more than just a simple instruction. It's the agent's core identity. We're going to give it a stepbystep quiz management process, telling it exactly how to behave when a user gives a correct or incorrect answer. Next, we give our agent a brain. In this case, we'll use a Gemini 2.5 Flash as the model for reasoning. Then we equip it with tools. These are simply Python functions that give the agent special abilities beyond just talking. We'll give it tools like start quiz, submit answer, and get quiz status. So, it can actually manage the quiz. With these components in place, we actually have a clear quiz flow that starts to emerge. The agent starts the quiz, waits for a response, and then uses its tools to check the answer and fetch the next question, all while following the logic we gave it in the system prompt. It's pretty cool. We put all of these pieces together and define our agent using the LLM agent function provided by ADK. As you can see, we're passing in the model, the system prompt, and the list of tools we created before. This function wraps everything up into a single conversational agent. And voila, we've created a simple AI agent that could teach us Python. Okay, but what if we wanted this agent to remember things like the user's name or their previous quiz score. To create a truly personalized experience, an agent needs to remember past interactions. Firstly, to have our agent remember things within a single conversation, we need to use what ADK calls short-term memory. Let's start with the foundational concept of a session. You can think of an ADK session as one complete continuous phone call between the user and our agent. Every time a user starts a new chat, a new session is created with a unique ID and the session acts as a container. If we look at its anatomy, we can see it holds the session's identification information. The entire back and forth conversational history and most importantly for our purpose is the state. Okay, but what is state exactly? This fate is like the agents, a scratch pad for the current conversation. For our Python tutor, this is where we're going to track the quiz in real time. It's a simple list of key value pairs like curve question index, correct answers, and score percentage. These values are designed to change as the user interacts with the agent. This is really powerful because both the model and the tools that we've given it can actually interact with the state. The Gemini model can read the current score or the question number directly from the system prompt using curly braces like you see here, keeping it aware of the quizzes context. And our tools can actually read from and write to the state as well. When the user answers a question, for example, our submit answer tool gets the current state from the tool context. It then checks the answer and writes the updated score directly back to the state, which the user can see in its next turn. By default, the entire session, including its state, is stored in memory and is lost when the application stops. This is perfect for a temporary scratch pad, but it's still really just short-term. One way to solve this challenge is by introducing a database to store session data. ADK actually comes with a database session service that gives you this exact functionality. With this function, you can store session data in a persistent SQL database like a local SQL light file or a cloud SQL Postgress instance. ADK will set up the session tables plus schemas for you on startup and session data can survive ADK crashes and restarts. It's good for production grade agents, but at the end, this is still just managed session data. What if we wanted our agent to actually have long-term memory? How can we make our agent remember a user score the next time that they come back or topics that they're having challenges with historically while they've been learning Python? Okay, so now we know short-term memory is great for a single quiz, but what happens when you come back tomorrow to continue learning Python? A new session with a new idea is created and temporary scratch pad is gone. To solve this, we need long-term memories so the agent can have context from previous interactions and provide a truly personalized experience for our learners. With long-term memory, our agent is like a tutor who remembers you from previous sessions, including what you learned and where you usually struggle. So, luckily, ADK provides functionality that allows us to do this. One of which is called memory service. This service is responsible for storing and retrieving information across multiple sessions. While there's a simple in-memory version for local development, the real power comes from the Vert.ex AI memory bank service. Instead of just saving entire raw conversations which can become long and tedious, memory bank uses Gemini to intelligently process a conversation and extract and summarize the most important facts. This is efficient because it gives the agent just the key information it needs without overwhelming it with the full chat history. So when we pull it all together and define our final intelligent agent, we use the same LLM agent function from ADK, but now we enhance it with our new memory components. We add our memory instructions to the prompt, include our new search memory tool, and most importantly, we register our autosave to memory callback function that allows memory bank to store the important information. This callback is the key to automating our memory. It'll run after each interaction to save the session's events. So finally, this creates a new, more intelligent flow for our agent. When a conversation starts, the agent follows its new instructions. First, it asks for the user's name so it can personalize the session. Once it has a name, it calls the search memory tool to check for any history with that user. Then it proceeds with the quiz. The crucial final step is the call back. After the quiz is complete, our autos save to memory callback function automatically runs, sending the session to memory bank to be summarized and stored for the future. The result of this is a seamless experience. The agent guides a user, let's say Megan, for example, through the quiz and gives them a final score of 75%. But the magic is what happens under the hood. What did Memory Bank actually save from that session? It didn't just store the raw chat log. Instead, it used its intelligence to process the conversation and extract key summarized facts. My name is Megan. I took a quiz about Python dictionaries and I scored 75% on the dictionaries quiz. You can see how the usage of a smart LLM allows memory bank to store only the relevant most important contextual information for our Python tutor to get its job done. So, let's recap. We've seen how state and memory create more personalized and contextaware agents. For short-term memory, ADK uses a session and its state, which acts as a temporary scratch pad for a single conversation. For long-term memory, ADK uses a memory service. We focused on the Vert.ex AI memory bank, which intelligently summarizes conversations, allowing the agent to recall key facts from past interactions. So now you have the building blocks to go and create your own powerful, personalized, memoryful AI agents. Hope this one helped. See you all in. [Music]