Make it remember you.It forgets everything.

Prove it forgets.

New here: no new code. We replay the agent.py you ended lesson 2 with, to see the problem.

Two quick questions from last time. Guessing first helps it stick, even when it feels harder.

A real run on our PC (qwen3:8b), recorded . Your own run will word the answers differently.

It did not know the second time, and it did not know the third time either. Ana was said one message ago.

It is a morgue attendant. Names are not the point. My mother forgets mine too, and she has no such excuse.Prof. Graves

The head keeps nothing.

New here: no new code. This step shows why step 1 happened.

Each call is a fresh trip. The head doesn't keep your earlier message. It only sees what is in the list you send right then. In the code, that list is called "messages".

So the memory has to live in your code. Keep every message in a list, and send the whole list every time.

It reads, answers and forgets. My mother calls that a good listener.Prof. Graves

Keep a list outside the loop.

New here: a list kept outside the loop, so it survives from one message to the next.

Three changes to agent.py. The list is called messages in the code. The loop is while True: it repeats the lines under it for every message you type. Each box shows the whole file; only the yellow lines are new, and the rest is lesson 2's file. The drawing on the right builds the list as you read each change.

import json
import urllib.error
import urllib.request

SYSTEM = "You are a burned-out morgue attendant. Answer in one grumpy sentence."
messages = [{"role": "system", "content": SYSTEM}]

while True:
    prompt = input("You: ")
    if prompt == "quit":
        break

    body = {
        "model": "qwen3:8b",
        "messages": [{"role": "system", "content": SYSTEM}, {"role": "user", "content": prompt}],
        "stream": False,
        "think": False,
    }

    URL = "http://localhost:11434/api/chat"
    note = json.dumps(body).encode()
    request = urllib.request.Request(URL, note, {"Content-Type": "application/json"})

    try:
        with urllib.request.urlopen(request) as response:
            answer = json.load(response)
    except urllib.error.URLError as error:
        raise SystemExit(f"Could not reach Ollama ({error}). "
                         "If it is not running, open another terminal and run: ollama serve")

    print(answer["message"]["content"])

import json
import urllib.error
import urllib.request

SYSTEM = "You are a burned-out morgue attendant. Answer in one grumpy sentence."
messages = [{"role": "system", "content": SYSTEM}]

while True:
    prompt = input("You: ")
    if prompt == "quit":
        break
    messages.append({"role": "user", "content": prompt})

    body = {
        "model": "qwen3:8b",
        "messages": [{"role": "system", "content": SYSTEM}, {"role": "user", "content": prompt}],
        "stream": False,
        "think": False,
    }

    URL = "http://localhost:11434/api/chat"
    note = json.dumps(body).encode()
    request = urllib.request.Request(URL, note, {"Content-Type": "application/json"})

    try:
        with urllib.request.urlopen(request) as response:
            answer = json.load(response)
    except urllib.error.URLError as error:
        raise SystemExit(f"Could not reach Ollama ({error}). "
                         "If it is not running, open another terminal and run: ollama serve")

    print(answer["message"]["content"])

import json
import urllib.error
import urllib.request

SYSTEM = "You are a burned-out morgue attendant. Answer in one grumpy sentence."
messages = [{"role": "system", "content": SYSTEM}]

while True:
    prompt = input("You: ")
    if prompt == "quit":
        break
    messages.append({"role": "user", "content": prompt})

    body = {
        "model": "qwen3:8b",
        "messages": messages,
        "stream": False,
        "think": False,
    }

    URL = "http://localhost:11434/api/chat"
    note = json.dumps(body).encode()
    request = urllib.request.Request(URL, note, {"Content-Type": "application/json"})

    try:
        with urllib.request.urlopen(request) as response:
            answer = json.load(response)
    except urllib.error.URLError as error:
        raise SystemExit(f"Could not reach Ollama ({error}). "
                         "If it is not running, open another terminal and run: ollama serve")

    print(answer["message"]["content"])

You: My name is Ana.
Ugh, another soul to file away—just another name to add to the list of people who didn't make it past the night.
You: What is my name?
Your name is Ana, and I'm so tired of this conversation.
You: quit

It remembers. Your code did the remembering and the head just read it. (A real run on our PC.)

Congratulations. The breakthrough is a list. Welcome to AI engineering.Prof. Graves

Keep its words too.

New here: the head's own answers go into the list too.

Every note in the list has a role, a label for who said it. system is the standing orders from lesson 2, user is you, and assistant is the head's own earlier replies. So far the list holds only the first two. After the print line, add the replies too. This is the whole of agent.py at the end of lesson 3; only the yellow line is new.

import json
import urllib.error
import urllib.request

SYSTEM = "You are a burned-out morgue attendant. Answer in one grumpy sentence."
messages = [{"role": "system", "content": SYSTEM}]

while True:
    prompt = input("You: ")
    if prompt == "quit":
        break
    messages.append({"role": "user", "content": prompt})

    body = {
        "model": "qwen3:8b",
        "messages": messages,
        "stream": False,
        "think": False,
    }

    URL = "http://localhost:11434/api/chat"
    note = json.dumps(body).encode()
    request = urllib.request.Request(URL, note, {"Content-Type": "application/json"})

    try:
        with urllib.request.urlopen(request) as response:
            answer = json.load(response)
    except urllib.error.URLError as error:
        raise SystemExit(f"Could not reach Ollama ({error}). "
                         "If it is not running, open another terminal and run: ollama serve")

    print(answer["message"]["content"])
    messages.append(answer["message"])

answer

The whole reply from Ollama, which json.load turned into a dictionary.

answer["message"]

Square brackets with a key look up one value in a dictionary, like answer.message in JavaScript. This value is itself a small dictionary: {"role": "assistant", "content": "..."}.

messages.append(...)

Adds that dictionary to the end of the list, right after your question. It is already in the right shape, with its role set to "assistant", so nothing needs rebuilding.

after the print

It runs at the end of the loop. Next time round, the list holds your question and the head's answer.

answer["message"]["content"]

The line above it, which prints the reply: two lookups in a row, first the message, then its text.

It can now quote itself, though it summarised rather than repeated. It reads its old answers like any other part of the list.

It has a memory and uses it to be rude. Progress.Prof. Graves

The list only grows.

New here: no new code. This step shows what the list costs.

Your list grows with every message. My mother's list of grudges works the same way, and nobody has ever dared to trim it.Prof. Graves