CONTEXT SHOULD CONTINUE
Knowledge work creates more than chat history. It creates requirements, choices, facts, references, project state, and operational context. When that knowledge is trapped inside a single session or platform, the next person or agent starts with an incomplete picture and teams waste time reconstructing what already happened.
HotMem makes useful context explicit and operable. Applications and agents can store scoped memory, retrieve the most relevant facts, inspect provenance, create portable snapshots, and hydrate validated memory into a clean runtime. The result is a reproducible working brain that survives restarts, handoffs, project boundaries, and infrastructure changes.
A SIMPLE, AUDITABLE WORKFLOW
01 / Capture
An application or agent writes facts, decisions, observations, and project context through a local HTTP API, Python client, TypeScript client, CLI, or MCP integration. HotMem stores runtime memory in SQLite and keeps the core workflow local.
02 / Retrieve
Hybrid keyword and vector ranking surfaces relevant memory as LLM-ready message objects, retaining the identifiers, scores, and provenance needed for inspection.
03 / Snapshot and verify
Export canonical JSONL or a versioned Snapshot v2 directory. Snapshot v2 includes a manifest and SHA-256 checksums so a recipient can detect corruption before hydration.
04 / Hydrate and continue
A compatible HotMem runtime validates and loads the snapshot. Replaying the same snapshot is designed not to create duplicate logical memories, making restore and repeated delivery safer and more predictable.
BUILT FOR PORTABILITY
Local-first runtime
A SQLite-backed memory service with no mandatory hosted control plane.
Portable JSONL
A plain, inspectable record stream that can be versioned, transformed, archived, and transferred.
Verified snapshots
Snapshot v2 packages use versioned manifests and SHA-256 integrity checks.
Fast hybrid retrieval
Vector, keyword, and importance signals combine to return useful context.
Agent-operable interfaces
HTTP, Python, TypeScript, CLI, and MCP surfaces let agents add, search, snapshot, and restore scoped memory.
Provenance that travels
Source identity, hashes, timestamps, file references, and lifecycle data can survive movement.
HotMem also supports legacy JSONL and JSONL.GZ snapshots, a one-command Mem0 SQLite history importer, and integrations for LangChain, CrewAI, AutoGen, Pydantic AI, and Hermes Agent. Its deterministic offline embedding path does not require a transformer model, GPU, API key, or remote vector store.
THE PORTABLE COMPANY BRAIN
A digital organization brain is the governed context that helps people and agents continue useful work: what an organization knows, why decisions were made, which sources support a fact, and what changed over time. HotMem keeps that brain portable rather than platform-bound. SQLite is an efficient local runtime. JSONL is the canonical interchange stream. A versioned manifest adds integrity, compatibility, and package identity. External indexes, embedding providers, agent frameworks, and transport layers can evolve without making the durable memory artifact opaque or proprietary. That gives teams a practical path to capture a known state, reproduce it in a compatible environment, verify what arrived, and continue without context archaeology.
PORTABILITY IS A PRODUCT REQUIREMENT
Memory must be able to travel.
Retrieval quality matters. But operational memory also needs an answer to harder questions: Can it be exported in a documented, inspectable format? Can a clean target reproduce the useful state? Can integrity be checked before import? Does provenance survive movement? Is repeated hydration safe? Can an agent manage the lifecycle through clear interfaces? HotMem treats those questions as first-class product requirements. Its open JSONL interchange path, verified snapshots, local runtime, and explicit adapters provide a memory layer that can be moved and governed rather than merely queried.
HONEST ABOUT WHAT SHIPS TODAY
From verified clones to connected organization brains.
HotMem’s north star is an open standard for connected digital organization brains: snapshot a workspace, transfer a verified package through a trusted path, hydrate it in a supported target, and continue work with relevant context intact. Today, HotMem supports local runtime memory, snapshots, hydration, integrity verification, provenance, and documented integrations. Formal interchange packages, broader platform migration adapters, incremental synchronization, signing, encryption, secure transport, and deliberate multi-writer semantics are staged roadmap work. HotMem distinguishes shipped capability from direction so teams can evaluate it on reproducible guarantees rather than slogans.
START LOCALLY
pip install hotmem · hotmem serve --mount ./hotmem
Follow the documentation to add memory, search it, create a snapshot, and hydrate a clean runtime.
FREQUENTLY ASKED QUESTIONS