DC Studio | shutterstock.com
AI agents and the Large Language Models (LLMs) on which they are based have rather short-lived “memory”. This is intentional, after all, only a limited amount of conversation content can be encoded in tokens and reliably accessed by the LLM. Retrieval Augmented Generation (RAG) can be used to equip AI agents and language models with brainpower that extends beyond their context windows. The decisive factor for success is how this mechanism (or another mechanism for storing call data) is actually used.
Another way to equip both AI agents and LLMs with advanced storage capabilities is through third-party software tools. These can provide the AI with persistent memory across sessions. Here too, however, the way in which this is technically implemented varies. The following four projects are particularly recommended when it comes to making AI agents and language models smarter.
1. Graphiti
Graphiti is advertised as “the open source temporal knowledge graph framework.” The project is available on GitHub – or as part of the Zep memory service, for which it provides the basis. “Temporal” in this context means that the information stored in Graphiti is reevaluated over time to correctly embed the context. The term “graph framework”, on the other hand, comes from the fact that the data is stored as a series of graphs. This feature also plays a role in the other solutions presented in this article – but in the case of Graphiti, it is the focus.
Out of the box, the AI memory project supports a whole range of common LLMs, such as those from Anthropic, OpenAI, Google or X. All Ollama and OpenAI-compatible APIs also work with Graphiti – so it can also be used with locally hosted LLMs. Data from sources such as GitHub, Gmail and OneDrive as well as from applications such as Notion can be integrated via connectors.
However, in order to use Graphiti locally, it is necessary to set up a graph database or connect to one. The standard solution for this (with the broadest support) is Neo4j. Apart from that, Amazon Neptune, FalkorDB and KuzuDB also work. Postgres with pgvector is (currently) not an option at Graphiti.
2. Hindsight
The AI memory project Hindsight is available as a cloud service, but can also be hosted locally. This tool stores agent session details in four different memory instances using four different storage and retrieval strategies. These are handled via three programmatic interfaces:
retainto save content (individual facts or complete sessions),recallto retrieve the content, andreflectto initiate an agent loop via a query that uses previously saved data.
When it comes to integrations, Hindsight offers a wide range of first and third party options. For example, if you use the Continue extension with Visual Studio Code to communicate with a locally hosted LLM, you can use the corresponding first-party integration. In this case, just use the keyword @hindsight in the query to expand the agent context with relevant memory. To make your work easier or to automate it, you could also use (customizable) auto-injection rules.
3. Mem0
Like Hindsight, Mem0 uses four basic memory types – although they are named and organized differently. For example, in the case of Mem0, the so-called “organizational memory” is used to store data that is to be shared between different AI agents (teams).
Each form of memory added via Mem0 goes through a “distillation” process and is stored in a different way (vector, graph or SQL database). In Mem0, older data is not deleted, but rather marked as obsolete – a strategy to create a richer, longer-term context.
The project supports fewer LLMs compared to Hindsight, for example, but the important providers (Anthropic, Google, OpenAI) are represented. There are also self-hosting options via LangChain, LiteLLM, LM Studio and Ollama. If you want to use Mem0 locally instead of as a service, it is necessary to provide a Python instance and your own vector database. For the latter, Postgres is available with the pgvector-Extension a common and simple option that can even be installed within a virtual Python environment.
4. Supermemory
Supermemory captures data from many common sources and supports, among other things, plain text, structured data, PDF and Office documents as well as video, audio and image files. The tool uses this information to create a context graph, which then serves as the basis for chatbot conversations. In terms of PR, this project focuses primarily on its context extraction tools.
Supermemory is available either as a cloud service or as open source, locally executable software. The open source version lacks the scaling services and third-party connectors of the enterprise version – but has one decisive advantage: it consists of a single self-contained binary. This means it can be deployed on your own hardware with very manageable effort.
Since no external databases need to be set up for this project, it is particularly suitable for (agile) experiments. (fm)
This article originally appeared at our sister publication Infoworld.com.
