I’ve been thinking about memory — not human memory, but how machines store and retrieve it. Most systems today are either key-value stores (fast, exact, dumb) or vector databases (semantic, but still just nearest-neighbour). Neither of them works the way a brain does.

So I started building something different. I called it Attractor.

The Problem with How Machines Remember

When you search a database, you give it a key and it returns a value. When you search a vector database, you give it a query and it returns the closest vectors by distance (usually via an approximate index like HNSW). Both are useful. But neither captures something important about how biological memory works — context.

Think about how you remember things. You don’t retrieve memories by key. You retrieve them by partial cues — a smell, a phrase, a situation. And the retrieval is shaped by context: what you were doing, who you were with, what problem you were trying to solve. Two memories with identical content mean different things depending on when and why they were formed.

Machines don’t do this. And for AI agents that need to reason across long conversations or accumulated knowledge, this is a real limitation.

Hopfield Networks — The Intriguing Part

In 1982, John Hopfield described a type of recurrent neural network that stores memories as energy minima [1]. The idea is elegant: each memory is a stable state — a basin of attraction — in an energy landscape. When you give the network a partial or noisy input, it doesn’t search for the closest match. It converges — like a ball rolling downhill — to the nearest stable state.

This is called content-addressable memory. You don’t need the exact key. You need something close enough to fall into the right basin.

Energy landscape: memories as basins of attraction A qualitative sketch. The vertical axis is energy and the horizontal axis is the space of possible states. The curve has two valleys. Memory A, "switched from JWT to session tokens", sits at the bottom of the first valley; Memory B, "auth tokens should never be stored in localStorage", sits at the bottom of the second. A query partway up the slope of the first valley rolls downhill and settles on Memory A, without needing an exact match. Energy query Memory A JWT → session tokens Memory B no localStorage tokens Possible states
Memories sit at the bottom of basins. A partial cue doesn't need an exact match: it rolls downhill into the nearest one.

The name Attractor comes directly from this. In dynamical systems, an attractor is a state that a system converges to over time. Hopfield memories are attractors. Retrieval is the process of finding which attractor your input belongs to.

What makes this intriguing is that it mirrors something real about biological memory. Your brain isn’t doing a database lookup when you remember something. It’s doing something closer to energy minimisation — pattern completion from partial cues.

What’s also interesting: in 2020, researchers showed that modern Hopfield networks with continuous states have exponentially higher storage capacity than the original binary version [2] — and that the attention mechanism in transformers is mathematically equivalent to a single Hopfield update step. The architecture powering every LLM today is, at its core, a Hopfield retrieval operation.

What I Built — Phase 1

Attractor is a standalone memory service. Right now it’s Phase 1: a working foundation that stores memories with context and retrieves them by meaning.

Attractor Phase 1 architecture A client — memlog, an agent, or any HTTP client — calls a FastAPI service over REST. FastAPI exposes POST /memories, POST /memories/search, GET /memories/:id and DELETE /memories/:id. It uses an encoder (sentence-transformers all-MiniLM-L6-v2, producing a 384-dimensional vector) and PgStore (an asyncpg connection pool for write, get, search and delete). Both lead to PostgreSQL with pgvector, which stores content as TEXT, context and tags as JSONB, vector as vector(384), access_count as INT and created_at as TIMESTAMPTZ. The service runs on port 7747, "loci" on a phone keypad. Client memlog, an agent, or any HTTP client REST FastAPI POST /memories POST /memories/search GET /memories/:id DELETE /memories/:id Encoder sentence-transformers all-MiniLM-L6-v2 → 384-dim vector PgStore asyncpg connection pool write / get / search / delete PostgreSQL + pgvector content TEXT context JSONB tags JSONB created_at TIMESTAMPTZ vector vector(384) access_count INT Service runs on port 7747 — “loci” on a phone keypad
Phase 1: a FastAPI service that embeds each memory and stores it, with its context, in Postgres + pgvector.

The data model is built around something I call a ContextFrame — the situational state at the time a memory was formed:

class ContextFrame(BaseModel):
    topic: str | None      # what was being discussed
    entities: list[str]    # who or what was involved
    task: str | None       # what was being done
    session_id: str | None # which session it came from

This isn’t metadata. It’s a retrieval key. When you search, you can filter by context — “find memories from this topic” or “find memories from this session” — and combine that with semantic search over the content itself.

The storage layer uses PostgreSQL with pgvector [3]. Each memory stores its content, context frame, tags, timestamps, access count, and a 384-dimensional embedding from a sentence-transformers model [4]. The embedding enables semantic search — retrieving by meaning rather than exact words.

The API is simple:

POST /memories          — store a memory with context
GET  /memories/:id      — retrieve by ID
POST /memories/search   — search by content + context filters
DELETE /memories/:id    — remove a memory

The CLI wraps the service:

attractor start    # starts the service on port 7747
attractor connect  # verifies it's running

Port 7747 is “loci” on a phone keypad — a nod to the method of loci, the memory palace technique [5], which was the project’s original name before I found a better one.

A Concrete Example

Here’s what makes it different from a plain vector search. Say you store these two memories:

"auth tokens should never be stored in localStorage"
  context: { topic: "security review", task: "reviewing PR #42" }

"switched from JWT to session tokens — stateless was causing issues"
  context: { topic: "auth refactor", task: "architecture decision" }

Now you search: "why did we change the auth approach" with context_filter: { topic: "auth refactor" }.

Context filtering: same query, different results The query "why did we change the auth approach" is embedded as a 384-dimensional vector. With vector search only, both memories surface: "switched from JWT to session tokens" and "auth tokens should never be stored in localStorage". Running the same query with the context filter topic equals "auth refactor" surfaces only the session-tokens memory; the localStorage memory, formed during a security review, is filtered out. “why did we change the auth approach” query + 384-dim embedding Vector search only “switched from JWT to session tokens…” “auth tokens should never be stored in…” both surface: semantic match, no context same query, plus context_filter: topic = “auth refactor” With the context filter “switched from JWT to session tokens…” “auth tokens should never be stored in…” filtered out: formed in a security review semantic match + context = precision
Same query, two searches. Vector search alone returns both auth memories; adding the context filter keeps only the one formed during the auth refactor.

The second memory surfaces — not because the words match, but because:

  1. The embedding is semantically close to the query
  2. The context filter narrows to the right topic

Without the context filter, both memories are relevant. With it, you get the one that was formed in the right situation. That’s the difference.

The Roadmap

Phase 1 is the foundation. The more interesting work is ahead:

Phase 2 — Association graph: Memories aren’t just points in a vector space. They’re nodes in a graph with typed edges — supports, contradicts, caused_by, followed_by. Retrieval triggers spreading activation: surface the memory you asked for, and the ones connected to it.

Phase 3 — Decay and consolidation: Not all memories are equally important. The access_count field is already tracking how often each memory is retrieved. Phase 3 uses this to implement decay — memories that are never accessed fade, memories that are frequently retrieved strengthen. This mirrors how biological memory consolidation works [6].

Phase 4 — Hopfield retrieval: Replace vector similarity with a proper Hopfield weight matrix. Retrieval becomes pattern completion — give the network a partial cue and it converges to the full memory. This is the step that moves from “semantic search with context” to something genuinely brain-inspired.

Isn’t This Already Being Done?

Honestly — yes, in parts. Vector search with metadata filtering exists in Pinecone, Weaviate, and Qdrant. Memory layers for agents exist in LangChain and LlamaIndex. And the “Hopfield Networks is All You Need” paper already showed that transformer attention is mathematically a Hopfield update — so in a sense, every LLM is already doing content-addressable retrieval implicitly.

Phase 1 of Attractor is not novel. It’s a clean, focused implementation of something that exists in various forms.

The bet is on Phases 3 and 4. Most agent memory systems don’t implement decay — memories don’t weaken over time unless reinforced, they don’t consolidate the way biological memory does, and retrieval is always ranking rather than convergence. That’s the gap Attractor is trying to close.

Whether that gap matters in practice is an open question — and the honest answer is that it depends entirely on whether the difference shows up in real use. That’s why I’m building memlog on top of Attractor as a daily-use testbed: log thoughts, decisions, and notes every day, and see whether context-aware retrieval with decay actually surfaces better results than a plain vector search would. If it does, the model is right. If it doesn’t, the model needs revision.

Theory is cheap. The feedback loop is the thing.

Why This Matters for AI Agents

Most AI agents today are stateless between sessions or rely on crude context windows. The ones that do have memory bolt it on as an afterthought — store the last N messages, embed them, retrieve by cosine similarity.

Attractor is an attempt to do it properly. Not because the engineering is especially hard, but because the model of memory matters. If you treat memory as a lookup table, you get lookup-table behaviour. If you treat it as an energy landscape with context and decay, you get something closer to how intelligence actually works.

Phase 1 is live. pip install attractor-engine — start storing memories with context, retrieve by meaning.

The interesting phases are coming.


References

  1. Hopfield, J.J. (1982). Neural networks and physical systems with emergent collective computational abilities. Proceedings of the National Academy of Sciences, 79(8), 2554–2558. Plain-language summary: Paper TL;DR.

  2. Ramsauer, H., Schäfl, B., Lehner, J., et al. (2020). Hopfield Networks is All You Need. arXiv:2008.02217. (Shows modern Hopfield networks have exponential capacity and that transformer attention is a Hopfield update.) Plain-language summary: Paper TL;DR.

  3. pgvector. (2021). Open-source vector similarity search for Postgres. GitHub.

  4. Reimers, N. & Gurevych, I. (2019). Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks. arXiv:1908.10084. Plain-language summary: Paper TL;DR.

  5. Yates, F.A. (1966). The Art of Memory. University of Chicago Press. (The definitive account of the method of loci — the memory palace technique.)

  6. McClelland, J.L., McNaughton, B.L., & O’Reilly, R.C. (1995). Why there are complementary learning systems in the hippocampus and neocortex. Psychological Review, 102(3), 419–457. (The foundational paper on memory consolidation and why some memories strengthen while others decay.) Plain-language summary: Paper TL;DR.


Source: github.com/aag1091-alt/attractor

Context frames, consolidation, decay and associative memory are each defined in a sentence or two in the agent memory glossary.