AI agents, and the large language models (LLMs) that power them, have short memories. That’s by design. There is only so much conversation that can be encoded into tokens and accessed reliably by the LLM. Retrieval-augmented generation, or RAG, can be used to give agents and LLMs memories larger than their context windows. But how agents use RAG, or other mechanisms for retaining the details of a conversation, can make all the difference.
With the rise of AI agents, there has been a corresponding rise in complementary software tools that give both agents and LLMs expanded memory capabilities. Most of the time, this means giving an agent or model persistent memory across sessions, so that previous context can be restored automatically. But, again, how that’s done can vary tremendously with each tool.
Here are some of the major projects in the AI agent memory space, each with their own particular spins, strengths, and orientations.
Graphiti is billed as “the open-source temporal knowledge graph framework.” The project is available on GitHub, or as the underpinning of the Zep ageny memory service. “Temporal” means information stored in Graphiti is re-evaluated over time to keep its context properly framed, and “graph framework” means the data is stored as a set of graphs. The other solutions profiled here use graph storage as part of their approach, but Graphiti makes that a front-and-center part of its design.
Graphiti supports a range of common LLM providers out of the box: Anthropic, Azure OpenAI, Google Gemini, and Groq. Any Ollama and OpenAI-compatible APIs also work, so Graphiti can be used with locally hosted LLMs as well. Connectors for third-party storage services let you ingest data from places like GitHub, Gmail, and OneDrive, as well as from applications like Notion.
Using Graphiti locally requires you set up or connect to a graph database. Neo4j is the default and most broadly supported of the bunch, but Amazon Neptune, FalkorDB, and KuzuDB will also work. Postgres with pgvector
is not listed as an option.
Hindsight, available as both a cloud service and a locally hostable project, stores details about agent sessions into four types of memory with four types of storage and retrieval strategies. All of these are handled through three programmatic interfaces: retain
for storing content, either a single fact or a whole conversation; `recall`
for retrieving content; and `reflect`
for running an agentic loop over a query that uses previously stored data.
Hindsight comes with a broad range of first-party and third-party integrations with existing LLMs and agent toolkits. For instance, if you’re using the Continue extension with Visual Studio Code to talk to a locally hosted LLM, you can use Hindsight’s Continue integration to add long-term memory to your interactions. You can use the @hindsight
keyword in your query to inject relevant memory into the agent’s context, or use auto-injection rules (which can be edited) to do most of that heavy lifting automatically.
Mem0 is a little like Hindsight in that it has four basic kinds of memory, although they are labeled and organized differently. For instance, Mem0 has a separate type of memory called organizational memory that’s intended to store data to be shared between multiple agents or different teams, something that is not normally done by default. Each memory added is passed through a distillation process and stored in a different way (vector DB, graph DB, SQL DB) depending on how it will be used. Older data, instead of being overwritten, gets deprecated rather than deleted, as a strategy for preserving larger long-term context. (Hindsight does this as well.)
Mem0 supports a smaller range of LLMs than Hindsight, but all the major options are available: Anthropic, Google Gemini, OpenAI, and self-hosted options like LangChain, LiteLLM, LM Studio, and Ollama. If you intend to use Mem0 locally rather than as a service, you’ll need to provide a Python instance and your own vector database. For the latter, Postgres with the pgvector
extension is a common and simple choice; it can even be installed inside a Python venv.
Supermemory ingests data from many common sources—supporting plaintext, structured data, common document file formats like PDF and Microsoft Office, video and audio, images—and uses them to build a context graph to inform agent conversations. Among its most promoted features is its content-extraction tools.
Supermemory is available as a cloud service or as open-source software you can run locally. The open-source edition lacks the scaling services and third-party service connectors (Gmail, Google Drive, Notion, etc.) provided with the enterprise edition, but it has one big advantage: it consists of a single, self-contained binary, so it can be deployed on one’s own hardware with very little effort. No external databases need to be provisioned for Supermemory, either, so it’s well-suited to quick experimentation.