Compared

FluctlightDB beside Mem0, Zep, Letta and vector stores

FluctlightDB is an embedded memory database for AI agents: a Rust engine inside your Python process, one brain directory per agent. Most of what it gets compared with is a layer above that or a runtime around it. Here is where each one sits, and when to pick it instead.

At a glance

Project	What it is	Where it runs	What it stores	How recall works
FluctlightDB	Embedded memory database for agents	In your Python process; a brain is a directory	Engrams: text with context, salience and provenance	activate(cue): full-text, vector neighbours and spreading activation fused in one call
Mem0	Memory layer for AI apps	Python/TS library over a vector store, or a hosted platform	Facts an LLM extracts from conversations	Search over extracted facts
Zep and Graphiti	Context engineering service over a temporal knowledge graph	Zep is a hosted service; Graphiti is an open-source library over a graph database	Entities and relations with validity over time	Graph, semantic and keyword search over the knowledge graph
Letta (MemGPT)	Agent framework and server with self-editing memory	A server that hosts stateful agents	Memory blocks the agent edits, plus archival storage	The agent calls tools to search its own archive
LangMem	LangChain library for agent memory	Inside a LangGraph application, over a LangGraph store	Memories extracted and managed by an LLM	Search over the LangGraph store
Chroma, Qdrant, LanceDB	Vector databases	Embedded or as a server, depending on the product	Embeddings with metadata	Nearest-neighbour search over vectors
SQLite with embeddings	A SQL database plus a vector search extension	In-process, wherever SQLite runs	Rows, and vectors in a virtual table	SQL, plus nearest-neighbour search over vectors you insert

There is no benchmark column. FluctlightDB’s published figures are evidence recall — did the right turn come back — and most memory products publish end-to-end QA scored by an LLM judge. The two measure different things, and putting them side by side would imply a ranking neither supports.

The figures this project does publish, with the harness and the retraction, are on the benchmarks page.

FluctlightDB and Mem0

Mem0 sits above storage: it runs an LLM over the conversation, decides which facts to keep, and writes them to a vector store (and optionally a graph). FluctlightDB sits below that line. The agent records what happened at the moment it happens, with where it came from, and nothing is extracted from a transcript later.

Pick Mem0: when you want a managed service, automatic fact extraction from chat, and the largest ecosystem in this category.
Pick FluctlightDB: when you want memory that runs in-process with no server and no LLM call on the write path, and recall that ranks a memory with a source above one the agent was merely told.

Longer comparison Mem0 on GitHub

FluctlightDB and Zep and Graphiti

Zep builds a temporal knowledge graph of entities and facts and tracks when each was true. That is a different shape from FluctlightDB, which stores episodes and lets a cue spread through the associations between them rather than asking you to model entities first.

Pick Zep: when your problem is facts that change over time about well-defined entities, and you are happy to run or rent a graph database.
Pick FluctlightDB: when you want one directory per agent with no database to operate, and episodic recall from a cue rather than an entity graph.

Longer comparison Zep and Graphiti on GitHub

FluctlightDB and Letta (MemGPT)

Letta is where the agent lives: it runs the loop and gives the model tools to edit its own memory. FluctlightDB is not an agent runtime. It is the storage engine an agent in any framework calls, so the comparison is closer to a runtime and a database than to two memory products.

Pick Letta: when you want a complete runtime for long-lived agents and are not attached to a framework.
Pick FluctlightDB: when you already have an agent loop — LangChain, LlamaIndex, the OpenAI Agents SDK, your own — and want memory it can call.

Longer comparison Letta (MemGPT) on GitHub

FluctlightDB and LangMem

LangMem is LangChain’s own answer to long-term memory and is the natural default inside LangGraph. FluctlightDB also plugs into LangChain, as FluctlightMemory and a chat message history, but is not tied to it.

Pick LangMem: when you are all-in on LangGraph and want the path its maintainers support.
Pick FluctlightDB: when you want the same memory to work across frameworks and in plain Python, with durability you can reason about on disk.

Longer comparison LangMem on GitHub

FluctlightDB and Chroma, Qdrant, LanceDB

A vector database answers “what is nearest to this embedding?”. That is one of the three signals inside activate(), not the whole of it. FluctlightDB also does not ship an embedder: without a vector you bring, its recall is lexical, which a vector store never is.

Pick a vector database: when you need semantic search over a large corpus — RAG over documents rather than an agent’s own experience — or scale well beyond 100,000 items, which FluctlightDB has not evaluated.
Pick FluctlightDB: when what you are storing is what an agent did and was told, and you want provenance, salience and crash-safe checkpoints rather than a similarity index.

Longer comparison Chroma, Qdrant, LanceDB on GitHub

FluctlightDB and SQLite with embeddings

sqlite-vec, the extension this row points at, stores and queries vectors inside SQLite and says it is pre-v1. That is a SQL database you query. FluctlightDB is also embedded, and the call is not SQL: experience() writes an engram, activate() recalls from a cue, checkpoint() makes a generation durable.

Pick SQLite with a vector extension: when you want SQL, a vector index you control, and you will write the retrieval yourself.
Pick FluctlightDB: when what you are storing is an agent’s experience, and you want the cue, the source and the checkpoint as the API rather than a query you assemble.

Longer comparison SQLite with embeddings on GitHub

Try it against your own data

The fastest way to judge a memory engine is to feed it what your agent actually sees and try to break the recall. It installs in one line and needs no server:

pip install "fluctlightdb[native]"

Then read your first brain, the one limit worth knowing first, or try recall in the browser. The questions page covers durability, integrations and what is not production-ready yet.