A Brain She Owns

curl -fsSL https://ollama.com/install.sh | sh
ollama pull llama3.2:3b
uv add ollama

$ ollama run llama3.2:3b "Say exactly: facility online"
Facility online.

The pull downloads a few gigabytes once and stores them locally. The one-line test proves the whole stack (server, model, sampling) before any Python enters the picture. Even told to answer exactly, the model capitalized and punctuated on its own: your first sighting of the fact that model output is generated, not retrieved, and will vary run to run.

# labs/glados_llm.py
SYSTEM_PROMPT = """You are GLaDOS, the AI from Portal.
You are sardonic, passive-aggressive, and darkly witty.
Keep responses brief and in character."""

def build_messages(history: list[dict]) -> list[dict]:
    return [{"role": "system", "content": SYSTEM_PROMPT}] + history

history = [{"role": "user", "content": "Are you there?"}]
for msg in build_messages(history):
    print(f"[{msg['role']}] {msg['content'].splitlines()[0]}")

$ uv run python labs/glados_llm.py
[system] You are GLaDOS, the AI from Portal.
[user] Are you there?

Every message is a dict with a role and a content. The roles are a convention the whole industry shares: system for instructions and persona, user for what the human said, assistant for what the model said. The system prompt is prepended fresh on every build rather than stored in the history, because it is not part of the conversation; it is standing instructions, constant while the history grows. And note what this stage does not contain: a model. You can inspect the exact list the model will receive before one is involved, which is precisely the kind of seam chapter 2 promised returns would buy you.

import ollama

MODEL = "llama3.2:3b"

def chat(user_input: str, history: list[dict]) -> tuple[str, list[dict]]:
    history.append({"role": "user", "content": user_input})
    response = ollama.chat(
        model=MODEL,
        messages=build_messages(history),
    )
    reply = response["message"]["content"]
    history.append({"role": "assistant", "content": reply})
    return reply, history

The double append is the heart of the chapter. The user's line goes in before the call so the model sees it; the reply goes in after so the next call remembers it. Skip the second append and she forgets every answer she gives, replying to each line as if the conversation just started. And chat() takes the history as an argument and returns it updated, so the state is visible at every call site and testable with a fixed list. A hidden global would work today and haunt volume 4.

def main() -> None:
    print(f"GLaDOS online. Model: {MODEL}")
    print("Type 'quit' to exit.\n")
    history: list[dict] = []
    while True:
        user_input = input("You: ").strip()
        if user_input.lower() in ("quit", "exit"):
            print("GLaDOS: Goodbye. Don't come back.")
            break
        reply, history = chat(user_input, history)
        print(f"GLaDOS: {reply}\n")

if __name__ == "__main__":
    main()

$ uv run python labs/glados_llm.py
GLaDOS online. Model: llama3.2:3b
Type 'quit' to exit.

You: My name is Chell.
GLaDOS: Of course it is. The one test subject who simply refuses to stay filed away.

You: What's my name?
GLaDOS: Chell. I just said... never mind. Memory intact. Unlike some of us.

You: quit
GLaDOS: Goodbye. Don't come back.

Her wording will differ on your machine; what must not differ is the second exchange. She knows the name because the first exchange, both halves of it, was in the list she received. The history = [] sits outside the loop, created once and threaded through every call; move it inside and you reset her memory on every line, rebuilding the amnesia you just cured.