What She Brings Into the Room

# labs/memory_context.py
import sqlite3
from datetime import datetime, timezone

def init_db(conn: sqlite3.Connection) -> None:
    conn.executescript("""
        CREATE TABLE IF NOT EXISTS facts (
            key TEXT PRIMARY KEY,
            value TEXT NOT NULL,
            created_at TEXT NOT NULL
        );
        CREATE TABLE IF NOT EXISTS conversations (
            id INTEGER PRIMARY KEY,
            summary TEXT NOT NULL,
            created_at TEXT NOT NULL
        );
    """)
    conn.commit()

def save_fact(conn, key: str, value: str) -> None:
    conn.execute(
        "INSERT OR REPLACE INTO facts (key, value, created_at) VALUES (?, ?, ?)",
        (key, value, datetime.now(timezone.utc).isoformat()),
    )
    conn.commit()

$ uv run python labs/memory_context.py
Tables: ['conversations', 'facts']
After two saves of user_name: [('user_name', 'Kaleb')]

One schema change from chapter 11, and it carries the chapter's philosophy: key is now the PRIMARY KEY, and INSERT OR REPLACE makes save_fact an upsert. A fact like user_name has exactly one current value, so telling her your name twice updates one row instead of accumulating contradictions. Summaries keep their append-only table, because a log of what happened should accumulate. State deduplicates; history appends. You met this distinction as an exercise; now it is load-bearing.

def load_context(conn, max_facts: int = 10, max_summaries: int = 3) -> str:
    facts = conn.execute(
        "SELECT key, value FROM facts ORDER BY created_at DESC LIMIT ?",
        (max_facts,),
    ).fetchall()
    summaries = conn.execute(
        "SELECT summary FROM conversations ORDER BY created_at DESC LIMIT ?",
        (max_summaries,),
    ).fetchall()
    lines = []
    if facts:
        lines.append("Known facts about the user:")
        for key, value in facts:
            lines.append(f"  - {key}: {value}")
    if summaries:
        lines.append("Recent conversation summaries:")
        for (summary,) in summaries:
            lines.append(f"  - {summary}")
    return "\n".join(lines)

$ uv run python labs/memory_context.py
Known facts about the user:
  - favorite_language: Python
  - user_name: Kaleb
Recent conversation summaries:
  - User switched the wake word to 'Hey GLaDOS'.

The limits are a budget, and the budget is the design. Context windows are finite, so the engine caps how much memory rides along, and ORDER BY created_at DESC decides what survives the cap: the newest. When she someday holds five hundred facts, the ten most recent make the cut and the stale ones wait on disk. Note the unpacking, for (summary,) in summaries: single-column rows are still tuples, and forgetting that produces one of Python's more baffling beginner tracebacks.

def build_system_prompt_with_memory(base_prompt: str, conn) -> str:
    context = load_context(conn)
    if context:
        return f"{base_prompt}\n\nMemory context:\n{context}"
    return base_prompt

$ uv run python labs/memory_context.py
You are GLaDOS. Be sardonic and brief.

Memory context:
Known facts about the user:
  - user_name: Kaleb

This ten-line function is the entire bridge between her past and her mouth. The if context: guard matters more than it looks: on a fresh install there is no memory, and without the guard every prompt carries an empty "Memory context:" header, wasted tokens that can also confuse a small model. When there is nothing to say, the base prompt passes through untouched. Chapter 12's engine slots in here directly; its assembled personality is the base_prompt argument, and the two systems compose without either knowing the other exists.

import re

FACT_PATTERNS = [
    (re.compile(r"\bmy name is (\w+)", re.I), "user_name"),
    (re.compile(r"\bi (?:use|prefer|write) (\w+) for", re.I), "favorite_language"),
    (re.compile(r"\bi live in ([\w\s]+?)[.,!]", re.I), "location"),
]

def extract_facts(text: str) -> list[tuple[str, str]]:
    found = []
    for pattern, key in FACT_PATTERNS:
        m = pattern.search(text)
        if m:
            found.append((key, m.group(1).strip()))
    return found

print(extract_facts("Hey, my name is Kaleb and I use Python for everything."))

$ uv run python labs/memory_context.py
[('user_name', 'Kaleb'), ('favorite_language', 'Python')]

The last piece closes the loop: facts get into the database by listening. A handful of regex patterns over the user's lines catches the explicit declarations, and each hit becomes a save_fact upsert. It is deliberately humble. Regexes catch "my name is Kaleb" and miss "call me Kaleb," and that is fine for now: a memory that reliably catches plain statements beats one that cleverly misunderstands subtle ones. Volume 9's retrieval work upgrades the mining; the plumbing it feeds is finished today.