Memory

You see your family doctor twice a year. They do not remember you; they see hundreds of people. But in the minute before you walk in, they read your file: allergies, current medication, what you agreed last time. A good file makes it feel like they remember. An empty file means starting over. A file that still says you smoke, ten years after you quit, is worse than either.

AI apps with "memory" work the same way. The model does not learn from your conversation as it happens. The app keeps a file and slips the right parts of it into the context before each call.

#Where memory actually lives

A model's weights are fixed while you use it. Nothing you say changes them. So every kind of memory is the app storing text somewhere and sending some of it back later. There are three common layers.

• The conversation itself. The history resent on every call, as in What Is Context. It lasts until the chat ends or the window trims it.
• A running summary. When a chat gets long, the app replaces old turns with a short summary of what was said and decided. It keeps the gist in far fewer tokens, but details can be lost.
• Long-term notes. Facts saved across chats: "vegetarian", "prefers short answers", "working on the billing project". A small set can be loaded every time. A large set is searched like any document collection, with the same retrieval tools.

Every memory system makes two decisions over and over:

1. Write: what is worth saving, and does it replace something already saved?
2. Read: which saved notes belong in the context for this call?

#A memory over three sessions

Here is a small note store, keyed by topic, so a new fact on the same topic replaces the old one. Step through three separate chats.

write: notes[topic] = fact   (replaces any older fact)read:  load notes for the topics this message needscontext = notes loaded + message

The important step is the fourth one. If the store had only ever appended, the context in session 3 would hold both "lives in Leeds" and "moved to Bristol", and the model would have to work out which is current. Sometimes it would get it wrong.

#The store in code

class Memory {
  constructor() {
    this.notes = new Map(); // topic -> { fact, saved }
  }
  remember(topic, fact, saved) {
    this.notes.set(topic, { fact, saved }); // newer replaces older
  }
  forget(topic) {
    this.notes.delete(topic);
  }
  recall(topics) {
    return topics
      .filter((t) => this.notes.has(t))
      .map((t) => `- ${t}: ${this.notes.get(t).fact} (saved ${this.notes.get(t).saved})`)
      .join("\n");
  }
}
 
const memory = new Memory();
memory.remember("diet", "vegetarian", "March");
memory.remember("city", "Leeds", "March");
memory.remember("city", "Bristol", "June");
console.log(memory.recall(["city"])); // - city: Bristol (saved June)

class Memory:
    def __init__(self):
        self.notes = {}  # topic -> (fact, saved)
 
    def remember(self, topic, fact, saved):
        self.notes[topic] = (fact, saved)  # newer replaces older
 
    def forget(self, topic):
        self.notes.pop(topic, None)
 
    def recall(self, topics):
        return "\n".join(
            f"- {t}: {self.notes[t][0]} (saved {self.notes[t][1]})"
            for t in topics if t in self.notes
        )
 
memory = Memory()
memory.remember("diet", "vegetarian", "March")
memory.remember("city", "Leeds", "March")
memory.remember("city", "Bristol", "June")
print(memory.recall(["city"]))  # - city: Bristol (saved June)

Real systems are messier in two places. Deciding what to save is usually done by a model reading the conversation and proposing notes, which means it can save the wrong thing. And choosing which notes to load is usually a similarity search rather than exact topics. The shape stays the same: write with replacement, read selectively, and keep the date.

#Stale memory in action

The saved date is not decoration. Compare two versions of the same request, where the app's notes were never updated after a move.

The second version costs one extra question and avoids a confidently wrong answer.

#Common mistakes

#Try it yourself

#Check yourself

#What to practise next

Notes and documents are text you prepare in advance. Tools and MCP shows how a model can fetch fresh information itself, in the middle of answering. For what happens when a single chat runs too long, see Context Rot.