A Memory She Can Search

# glados/knowledge.py
import sqlite3
from datetime import datetime, timezone
from pathlib import Path

DB_PATH = Path("glados/data/memory.db")

CONFIDENCE = {"stated": 1.0, "mined": 0.6, "inferred": 0.4}

def init_knowledge(conn: sqlite3.Connection) -> None:
    conn.execute("""
        CREATE TABLE IF NOT EXISTS knowledge (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            topic TEXT NOT NULL,
            content TEXT NOT NULL,
            source TEXT NOT NULL,
            confidence REAL NOT NULL,
            created_at TEXT NOT NULL
        )
    """)
    conn.commit()

def remember(conn: sqlite3.Connection, topic: str, content: str,
             source: str = "stated") -> None:
    conn.execute(
        "INSERT INTO knowledge (topic, content, source, confidence, created_at)"
        " VALUES (?, ?, ?, ?, ?)",
        (topic, content, source, CONFIDENCE[source],
         datetime.now(timezone.utc).isoformat()),
    )
    conn.commit()

if __name__ == "__main__":
    conn = sqlite3.connect(":memory:")
    init_knowledge(conn)
    remember(conn, "network", "The office printer is on 192.168.1.40.")
    remember(conn, "network", "The printer might be on the guest network.",
             source="inferred")
    for row in conn.execute("SELECT topic, source, confidence FROM knowledge"):
        print(row)

$ uv run python glados/knowledge.py
('network', 'stated', 1.0)
('network', 'inferred', 0.4)

This is a new table beside chapter 11's, not a replacement for it, because the two hold different kinds of thing. facts is keyed state: one current value for user_name, upserted. Knowledge is a growing pile of statements about topics, and three true sentences about the printer can coexist without contradicting each other. State deduplicates, history appends, and knowledge accumulates.

The CONFIDENCE dict is the load-bearing part. Confidence here is not measured, it is assigned, and the thing it is assigned from is provenance: you said it, a regex mined it, or the model guessed it. That keeps the number defensible in one sentence, and it means the caller never picks a float out of the air. Add a fourth source someday and you have to decide what it is worth before you can store anything through it, which is the point.

def search(conn: sqlite3.Connection, terms: list[str],
           limit: int = 5) -> list[dict]:
    if not terms:
        return []
    clause = " OR ".join(["topic LIKE ? OR content LIKE ?"] * len(terms))
    params: list = []
    for term in terms:
        params += [f"%{term}%", f"%{term}%"]
    params.append(limit)
    rows = conn.execute(
        "SELECT topic, content, confidence FROM knowledge"
        f" WHERE {clause}"
        " ORDER BY confidence DESC, created_at DESC LIMIT ?",
        params,
    ).fetchall()
    return [{"topic": r[0], "content": r[1], "confidence": r[2]} for r in rows]

if __name__ == "__main__":
    remember(conn, "network", "The printer jams on thick paper.", source="mined")
    for hit in search(conn, ["printer"]):
        print(f"{hit['confidence']:.1f}  [{hit['topic']}] {hit['content']}")

$ uv run python glados/knowledge.py
1.0  [network] The office printer is on 192.168.1.40.
0.6  [network] The printer jams on thick paper.
0.4  [network] The printer might be on the guest network.

Three sentences about one printer, returned in the order you would want a person to read them: the one you told her, then the one a regex found, then the guess. That ordering is the entire difference between a search box and a knowledge store. created_at DESC breaks ties so two rows at the same confidence come back newest-first and never in whatever order SQLite feels like, which matters the day you diff two prompts to explain a behavior change.

Look hard at the f-string in the middle of that SQL, because chapter 11 told you never to write one. Read what it splices: len(terms) copies of a fixed clause containing question marks. The only thing formatted into the statement is punctuation generated from an integer, and every value still travels as a bound parameter. The rule was never "no f-strings near SQL", it was "no data in the SQL text", and knowing which one you are obeying is what lets you build a variable-length WHERE without reopening the injection you closed in volume 2.

import re

STOPWORDS = {
    "the", "and", "but", "for", "with", "you", "your", "was", "were", "are",
    "did", "does", "what", "when", "where", "who", "why", "how", "that",
    "this", "about", "have", "has", "had", "say", "said", "tell", "know",
    "can", "could", "would", "there", "then", "from", "into", "not", "get",
    "got", "please", "again", "any", "all", "its", "her", "his", "our",
}

def keywords(line: str, limit: int = 4) -> list[str]:
    words = re.findall(r"[a-z0-9]+", line.lower())
    out: list[str] = []
    for word in words:
        if len(word) < 3 or word in STOPWORDS or word in out:
            continue
        out.append(word)
    return out[:limit]

if __name__ == "__main__":
    print(keywords("What did I say the printer's address was?"))
    print(keywords("Tell me about Whisper."))

$ uv run python glados/knowledge.py
['printer', 'address']
['whisper']

Nobody types a search term at a house assistant. They ask a question, and a question is mostly grammar: seven of the nine words in the first line carry no information about which row you want. Three filters do the work. The character class splits on everything that is not a letter or digit, so printer's becomes printer plus a stray s; the length floor of three drops that s and every me and it; the stopword set removes the question words that appear in half your sentences and would therefore match half your rows. The cap of four keeps one rambling sentence from turning into a query with twenty clauses.

def knowledge_context(conn: sqlite3.Connection, line: str,
                      limit: int = 3) -> str:
    hits = search(conn, keywords(line), limit=limit)
    if not hits:
        return ""
    lines = ["Relevant knowledge (confidence in brackets, 1.0 means the user said so):"]
    for hit in hits:
        lines.append(f"  - [{hit['confidence']:.1f}] {hit['content']}")
    return "\n".join(lines)

if __name__ == "__main__":
    print(knowledge_context(conn, "What did I say the printer's address was?"))
    print(repr(knowledge_context(conn, "How was your day?")))

$ uv run python glados/knowledge.py
Relevant knowledge (confidence in brackets, 1.0 means the user said so):
  - [1.0] The office printer is on 192.168.1.40.
  - [0.6] The printer jams on thick paper.
  - [0.4] The printer might be on the guest network.
''

The empty string on the second call is chapter 14's guard, kept deliberately: a query with no hits contributes nothing, so a small model never reads a "Relevant knowledge" header with nothing under it and never has to work out what that means. Printing the confidence into the prompt is a judgment call you can argue with. A 3b model will not do arithmetic on those numbers, but it does treat a bracketed 0.4 as a hedge, and her answers get noticeably more careful about the low rows. Delete the brackets and she states the guess as flatly as the fact.

# glados/knowledge.py -- the boundary, and the real file
from labs.memory_context import load_context   # chapter 14's budgeted loader

def build_prompt(base_prompt: str, conn: sqlite3.Connection,
                 user_text: str) -> str:
    parts = [base_prompt]
    memory = load_context(conn)
    if memory:
        parts.append(f"Memory context:\n{memory}")
    knowledge = knowledge_context(conn, user_text)
    if knowledge:
        parts.append(knowledge)
    return "\n\n".join(parts)

if __name__ == "__main__":
    DB_PATH.parent.mkdir(parents=True, exist_ok=True)
    conn = sqlite3.connect(DB_PATH)
    init_knowledge(conn)
    remember(conn, "network", "The office printer is on 192.168.1.40.")
    remember(conn, "network", "The printer jams on thick paper.", source="mined")
    print(build_prompt("You are GLaDOS. Be sardonic and brief.", conn,
                       "What did I say the printer's address was?"))
    conn.close()

$ uv run python glados/knowledge.py
You are GLaDOS. Be sardonic and brief.

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

Relevant knowledge (confidence in brackets, 1.0 means the user said so):
  - [1.0] The office printer is on 192.168.1.40.
  - [0.6] The printer jams on thick paper.

Two retrieval strategies, one prompt, and each block earns its place a different way. The memory block is unconditional and recency-ranked: who you are travels with every call, because she needs your name whatever you asked about. The knowledge block is conditional and relevance-ranked: it appears only when the question shares vocabulary with something stored. The whole chapter reduces to the third argument on build_prompt. Chapter 14's boundary took a database and a persona; this one also takes the question, and a retriever that never sees the question can only ever guess with a clock.

One wart is deliberate. Run this file twice and the printer rows appear twice, since knowledge has no unique key. A UNIQUE(topic, content) constraint plus INSERT OR IGNORE ends that in one line, and you should add it only once you have decided that two identical sentences are never two separate observations.