hotmemory · open source

Agent memory is just tables

hotmemory is an open source memory layer that keeps what your agents learn as rows in a Hotdata instant database. Each memory records what it is about, who can see it, where it came from, and when it was true. There is no separate memory service to run.

View on GitHub Install from PyPI

One memory, one row

content: The disk on db-3 fills up when the nightly backup overlaps log rotation.
subject: db-3
scope: incidents/storage
sources: alert-1842, investigation-0912
valid from: 2026-09-12
valid until: still true

The life of a memory

Save: Your model reads a conversation or an investigation and pulls out the facts. It sees what the agent already knows first, so it does not repeat itself. Each fact becomes a row linked to its source.
Recall: An agent asks in plain words, with a size budget. hotmemory turns the question into one SQL query and returns a block the agent can drop into its prompt.
Change: When a fact stops being true, the old row is closed with the date it ended and the new version is written beside it. Nothing is lost.
Forget: A memory can carry a forget date. After that date it drops out of every recall, and a cleanup pass deletes it later.

A conversation or investigation

Save

Your model pulls out the facts, one row each

Recall

One query finds the ones that matter

Change

Old row closed, new version beside it

Forget

Drops out of recall after its date

When a fact changes, history stays

Rows are never edited in place. Recall returns only the current version, and an agent can still read what it used to believe. Each memory keeps two clocks: when something was true in the world, and when the agent found out.

version	content	valid from	valid until
1	The nightly backup on db-3 runs at 00:00.	2026-09-12	2026-09-30
2	The nightly backup on db-3 runs at 03:00.	2026-09-30	still true

One recall, one SQL query

Hybrid search usually means a search engine, a vector database, and glue code to merge them. In Hotdata, both rankings and the filters run in one query over the same rows, with no second store to keep in sync.

A question

“When does the db-3 backup run?”

One SQL query, inside Hotdata

Exact filters

This agent's scope, latest versions only

Words

BM25

Meaning

Vectors

Merge

The two rankings into one list

The memories that matter

One line each, with sources and dates

Words, with BM25: Finds memories that contain the words of the question, such as an error code or a host name.
Meaning, with vectors: Connects a question about disk alerts to a memory that only says the volume ran out of space.
Exact filters: Only this agent's scopes, only current versions, nothing past its forget date. These are SQL WHERE clauses, so one team's agent never sees another team's memories.

Where the rows live

hotmemory is a small Python library that runs inside your agent's process. You bring the models that extract and embed facts.

Memories land as Parquet in object storage: durable, in an open format, in your own workspace, on an engine that scales to zero when no agent is asking.

Your agent's process

Your agent

Your models

Embed and extract

hotmemory

A Python library

Hotdata

Hotdata SQL engine

BM25, vector search, and exact filters in one query

Your memory database

Parquet in object storage

Get started

Install

pip install "hotmemory[hotdata,openai]"
export HOTDATA_API_KEY=...
export OPENAI_API_KEY=...

Coding agents like Claude Code and Codex get a skill to remember and recall from the command line. We use hotmemory every day in our own incident agent.

Remember a fact, then recall it

from hotmemory import Fact, Memory
from hotmemory.hotdata import HotdataStore
from hotmemory.openai import OpenAIEmbedder

embedder = OpenAIEmbedder()
store = HotdataStore.provision(
    "agent-memory",
    embedder=embedder,
    model=embedder.model,
    dimensions=1536,
)
memory = Memory(store)

scope = ("incidents", "storage")
memory.remember(
    [Fact(
        kind="fact",
        subject="db-3",
        content=(
            "The disk on db-3 fills up when the nightly "
            "backup overlaps log rotation."
        ),
        sources=("alert-1842",),
    )],
    scope,
)
records, block = memory.recall("disk alerts on db-3", [scope])
print(block)