Using Memobase with the OpenAI API

Diagram of OpenAI API with Memory Integration

Memobase integrates with the OpenAI API, allowing you to add long-term memory to chat completions without altering your existing code. This patch works with the official OpenAI SDK and any other OpenAI-compatible provider.

​

Setup

1. Install SDKs: Ensure both the Memobase and OpenAI Python SDKs are installed.

   Copy

   pip install memobase openai
   

2. Initialize Clients: Create instances of both the OpenAI and Memobase clients.

   Copy

   from openai import OpenAI
   from memobase import MemoBaseClient
   
   client = OpenAI()
   mb_client = MemoBaseClient(
       project_url=YOUR_PROJECT_URL,
       api_key=YOUR_API_KEY,
   )
   

   You can find your project_url and api_key after setting up your backend.

​

Patch Memory

Apply the Memobase memory patch to your OpenAI client instance with a single function call.

from memobase.patch.openai import openai_memory

client = openai_memory(client, mb_client)

​

Usage

1. To enable memory, simply add a user_id to your standard API call. The client will automatically handle the memory context.

   OpenAI (Original)

   OpenAI with Memory

   Copy

   client.chat.completions.create(
       messages=[
           {"role": "user", "content": "My name is Gus"},
       ],
       model="gpt-4o"
   )
   

2. If no user_id is passed, the client functions exactly like the original OpenAI client.

3. By default, memory processing is not immediate. User interactions are collected in a buffer to optimize performance. You can manually trigger processing using the flush method:

   Copy

   client.flush("test_user_123")
   

​

Verifying Memory Retention

Once a user’s information is captured, it can be recalled in subsequent, separate conversations.

# In a new session
response = client.chat.completions.create(
    messages=[
        {"role": "user", "content": "What is my name?"},
    ],
    model="gpt-4o"
)
# Assistant: "I'm sorry, I don't have access to personal information..."

​

How It Works

The openai_memory function wraps the OpenAI client with two key actions:

1. Before Request: It retrieves the user’s memory context from Memobase and injects it into the prompt.
2. After Response: It saves only the latest user query and assistant response to the memory buffer.

For example, if your message history is:

[
    {"role": "user", "content": "My name is Gus"},
    {"role": "assistant", "content": "Hello Gus! How can I help you?"},
    {"role": "user", "content": "What is my name?"}
]

And the final response is Your name is Gus., Memobase will only store the last exchange. This is equivalent to:

u.insert(
    ChatBlob(messages=[
        {"role": "user", "content": "What is my name?"},
        {"role": "assistant", "content": "Your name is Gus."},
    ])
)

This design ensures you can manage short-term conversation history within your API calls as usual, while Memobase prevents duplicate entries in the long-term memory.

The full implementation script is available here.

​

Advanced Usage

​

Custom Parameters

You can pass additional arguments to openai_memory to customize its behavior:

• max_context_size: Controls the maximum token size of the injected memory context. Defaults to 1000.
  Copy

  client = openai_memory(client, mb_client, max_context_size=500)
  

• additional_memory_prompt: Provides a meta-prompt to guide the LLM on how to use the memory.
  Copy

  # Example: Encourage personalization
  prompt = "Always use the user's memory to provide a personalized answer."
  client = openai_memory(client, mb_client, additional_memory_prompt=prompt)
  

​

Patched Methods

The patched client includes new helper methods:

• client.get_memory_prompt("user_id"): Returns the current memory prompt that will be injected for a given user.
• client.flush("user_id"): Immediately processes the memory buffer for a user. Call this if you need to see memory updates reflected instantly.