Skip to content
How to Implement Longer ChatGPT Memory with These Tools

How to Implement Longer ChatGPT Memory with These Tools

In the realm of artificial intelligence, the ability to remember and learn from past interactions is a game-changer. This is particularly true for AI chatbots like ChatGPT, where memory plays a pivotal role in shaping the quality of interactions. The introduction of long-term memory into ChatGPT's framework has not only expanded its conversational capabilities but also transformed the way it engages with users. This new feature, often referred to as "ChatGPT memory," has opened up a world of possibilities, enabling the AI to provide more personalized, context-aware, and meaningful responses.

ChatGPT memory is a testament to the power of combining advanced language models with innovative memory management techniques. It's about taking the already impressive capabilities of ChatGPT and pushing them to new heights. By leveraging long-term memory, ChatGPT can now remember details from past conversations, adapt to user preferences, and provide responses that are not just relevant but also contextually accurate. This breakthrough has significant implications for the future of AI chatbots, setting the stage for more intelligent, engaging, and human-like interactions.

Without further adieu, let's get started with What is ChatGPT Memory:

What is ChatGPT Memory and Why Do You Need It?

The context length, or the amount of information from a previous conversation that a language model can use to understand and respond to, is a crucial aspect of creating powerful LLM-based applications. It's akin to the number of books that an advisor has read and can draw upon to offer practical advice. However, even if the library is extensive, it is not infinite.

Optimizing the use of the available context length of the model is essential, especially considering factors such as cost, latency, and model reliability, which are influenced by the amount of text sent and received to an LLM API such as OpenAI’s.

Context Length, External Memory: How Can They Assist ChatGPT

To circumvent the limitations of context length in AI models like ChatGPT and GPT-4, an external source of memory can be attached for the model to utilize. This significantly enhances the model’s effective context length, a critical factor for advanced applications powered by transformer-based LLM models.

The chatgpt-memory project (opens in a new tab) provides an excellent example of this approach. It employs Redis' vector database to create an intelligent memory management method, allowing ChatGPT to cache historical user interactions per session and providing an adaptive prompt creation mechanism based on the current context.

With the advent of GPT-4, ChatGPT’s context length increased from 4,096 tokens to 32,768 tokens. The costs for using OpenAI’s APIs for ChatGPT or GPT-4 are calculated based on the number of tokens used in conversations. Hence, there is a tradeoff between using more tokens to process longer documents and using relatively smaller prompts to minimize cost.

However, truly powerful applications require a large amount of context length. That's what the following solutions come in:

Create Memory for ChatGPT with MemoryGPT

MemoryGPT, a project with the goal of creating a ChatGPT with long-term memory, aims to remember the things you say and personalize your conversation based on that. This approach is more adaptive than the current default behavior because it only retrieves the previous k messages relevant to the current message from the entire history. We can add more relevant context to the prompt and never run out of token length. MemoryGPT provides adaptive memory, which overcomes the token limit constraints of heuristic buffer memory types.

Implementing ChatGPT Memory with Redis and MemoryGPT

The chatgpt-memory project (opens in a new tab) on GitHub provides a detailed guide on how to implement long-term memory for ChatGPT using Redis. Here's a simplified version of the steps:

  1. Set up your environment: You'll need to get your OpenAI API key and set up a Redis datastore. You can create a free Redis datastore here (opens in a new tab).

  2. Install dependencies: The project uses the poetry package manager. You can install the necessary dependencies with poetry install.

  3. Start the FastAPI webserver: You can start the webserver with poetry run uvicorn rest_api:app --host --port 8000.

  4. Run the UI: You can start the UI with poetry run streamlit run

  5. Use with Terminal: The library is highly modular, and you can use each component separately. You can find a detailed guide on how to use each component in the project's README (opens in a new tab).

Here's a simplified version of the code you'll use to set up the chatbot:

# Import necessary modules
from chatgpt_memory.environment import OPENAI_API_KEY, REDIS_HOST, REDIS_PASSWORD, REDIS_PORT
from chatgpt_memory.datastore import RedisDataStoreConfig, RedisDataStore
from chatgpt_memory.llm_client import ChatGPTClient, ChatGPTConfig, EmbeddingConfig, EmbeddingClient
from chatgpt_memory.memory import MemoryManager
# Instantiate an EmbeddingConfig object with the OpenAI API key
embedding_config = EmbeddingConfig(api_key=OPENAI_API_KEY)
# Instantiate an EmbeddingClient object with the EmbeddingConfig object
embed_client = EmbeddingClient(config=embedding_config)
# Instantiate a RedisDataStoreConfig object with the Redis connection details
redis_datastore_config = RedisDataStoreConfig(
# Instantiate a RedisDataStore object with the RedisDataStoreConfig object
redis_datastore = RedisDataStore(config=redis_datastore_config)
# Instantiate a MemoryManager object with the RedisDataStore object and EmbeddingClient object
memory_manager = MemoryManager(datastore=redis_datastore, embed_client=embed_client, topk=1)
# Instantiate a ChatGPTConfig object with the OpenAI API key and verbose set to True
chat_gpt_config = ChatGPTConfig(api_key=OPENAI_API_KEY, verbose=True)
# Instantiate a ChatGPTClient object with the ChatGPTConfig object and MemoryManager object
chat_gpt_client = ChatGPTClient(
# Initialize conversation_id to None
conversation_id = None
# Start the chatbot loop
while True:
 # Prompt the user for input
 user_message = input("\n Please enter your message: ")
 # Use the Chat
GPTClient object to generate a response
 response = chat_gpt_client.converse(message=user_message, conversation_id=conversation_id)
 # Update the conversation_id with the conversation_id from the response
 conversation_id = response.conversation_id
 # Print the response generated by the chatbot

This code will allow you to talk to the AI assistant and extend its memory by using an external Redis datastore.

MemoryGPT in Action

MemoryGPT (opens in a new tab) is a practical application of the long-term memory concept in ChatGPT. It's designed to recall details from past conversations and adjust its behavior to your preferences. MemoryGPT is particularly useful for coaching agents, as a friend for advice and support, for productivity, and for curious minds who enjoy playing around with the newest tech and want to push it to the limit.


How does long-term memory enhance the capabilities of ChatGPT?

Long-term memory allows ChatGPT to remember the context of previous conversations, enabling it to provide more personalized and relevant responses. It overcomes the limitations of context length in AI models, making conversations more engaging and meaningful.

What is the role of Redis in implementing long-term memory for ChatGPT?

Redis is used as a vector database to store the historical user interactions per session. It provides an intelligent memory management method that allows ChatGPT to cache these interactions and create adaptive prompts based on the current context.

How does vectorizing conversation history help in providing context to ChatGPT?

Vectorizing conversation history converts the text data into a format that the AI model can understand. These vectors represent the semantic meaning of the conversation history and can be used to provide relevant context to the model, enhancing its ability to generate appropriate responses.