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.

    pip install memobase openai
    
  2. Initialize Clients: Create instances of both the OpenAI and Memobase clients.

    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.

    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:

    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.
    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.
    # 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.