Memory Configuration

Overview

Digital Employee Core supports user-scoped memory so an agent can remember facts and preferences across multiple calls. Memory is opt-in:

• Enable a memory provider in agent configuration via set_agent_config().

• Pass a stable memory_user_id on every invoke() call.

Key Concepts

What is memory_user_id?

memory_user_id is the user identifier used to scope memory.

• Same memory_user_id + same agent => the agent can recall previously stored facts.

• Different memory_user_id + same agent => isolated memory (no cross-user leakage).

• Same memory_user_id + different agent => isolated memory (each agent maintains its own memory scope).

Memory Provider

Memory is enabled by setting AgentConfigKeys.MEMORY to a provider (e.g. MemoryProvider.MEM0). Currently we utilize GL SDK Memory via AIP Memory.

Minimal Example

1) Create a memory-enabled Digital Employee

import asyncio
from dotenv import load_dotenv
from digital_employee_core import (
    DigitalEmployeeAgentBuilder,
    DigitalEmployeeBuilder,
    DigitalEmployeePipelineBuilder,
)
from digital_employee_core.configuration.agent_configuration import AgentConfigKeys, MemoryProvider

load_dotenv()

# Build digital employee with memory enabled
digital_employee = (
    DigitalEmployeeBuilder()
    .set_name("memory_assistant")
    .set_email("[e-mail]")
    .set_job(
        title="Memory-Enabled Assistant",
        description="A digital employee that can remember user-specific facts across calls",
        instruction=(
            "When the user tells you a personal preference or fact, remember it for future conversation."
        ),
    )
    .set_pipeline(
        DigitalEmployeePipelineBuilder().add_step(
            DigitalEmployeeAgentBuilder()
            .set_agent_config({AgentConfigKeys.MEMORY: MemoryProvider.MEM0})
        )
    )
    .build()
)

2) Call with a stable memory_user_id

memory_user_id = "user-123"

# Store a preference
result_1 = asyncio.run(digital_employee.invoke(
    message="My favorite color is beige. Please remember this for next time.",
    memory_user_id=memory_user_id,
)

# Recall later
result_2 = asyncio.run(digital_employee.invoke(
    message="What is my favorite color?",
    memory_user_id=memory_user_id,
)

Note: After storing a memory, there may be a slight delay from the provider before it becomes available for retrieval, so you may need to wait a moment (manually or via Python's sleep() ) before querying for recently stored information.

3) Different user, different memory

other_user_id = "user-456"

result_3 = asyncio.run(
    digital_employee.invoke(
        message="What is my favorite color?",
        memory_user_id=other_user_id,
    )
)

Local Usage

To use MemoryProvider.MEM0 locally, you must provide MEM0_API_KEY in your environment variables.

export MEM0_API_KEY="<your_api_key>"

If you load environment variables via .env, ensure your entrypoint calls load_dotenv().

Then, run the digital employee with local=True to run it locally.

result = asyncio.run(
    digital_employee.invoke(
        message="What is my favorite color?",
        memory_user_id=memory_user_id,
        local=True,
    )
)

Notes / Best Practices

• memory_user_id is required when memory is enabled; the agent cannot store or recall memories without it.

• Use stable identifiers (e.g., internal user ID) and do not use PII (like emails) unless necessary.

• Write clear instructions in the job prompt indicating what to remember (preferences, long-term facts) vs what not to (secrets).