:Long-term memory

Use cases

• Remember user preferences: Remember user settings, such as language preferences, and automatically apply them in future conversations.

• Review interaction history: Retrieve past conversation content across sessions to avoid repetitive questions.

• Personalized recommendations: Provide tailored recommendations and suggestions based on a user's historical behavior and preferences.

Prerequisites

• You have created a memory storage instance. For more information, see Create and manage memory storage.

• Long-term memory requires a configured large language model (LLM) and a vector model (embedder), meaning both llmConfig and embedderConfig must not be empty.

Limitations

Add a memory

1. Go to the details page of the memory storage instance and select the Long-Term Memory tab.

2. Click Add Memory to open the Add User Memory form.

3. Enter the memory information:

   Field	Description	Example
   User ID	Required. The identifier for the user who owns the memory.	test-user-001
   Memory Content	Required. The specific content of the memory.	Lives in Hangzhou
   Metadata	Optional. Custom key-value pairs. Click Add Metadata to add more.	{"category": "food"}

4. Click Save and wait for the memory to be created.

After a memory is successfully created, it appears in the memory list, displaying information such as the User ID, creation time, and memory content. Each memory card includes View Details, Edit, View History, and Delete buttons.

Memory list

The memory list displays up to 200 memories by default. Each memory card contains the following information:

• First line: The User ID in bold. In search mode, a similarity score tag is also displayed.

• Second line: The original memory content.

• Third line: Metadata in the format {Agent ID} · {Run ID} · {Date}. The Agent ID and Run ID are optional and are omitted if not set.

You can select multiple memory entries using the checkboxes. When one or more items are selected, a Batch Delete button appears in the upper-right corner of the list.

Search and filter memories

If you have more than 200 memories, use the search feature to find specific entries. When searching, you must provide both keywords and at least one ID (User ID, Agent ID, or Run ID).

1. Enter keywords in the search box at the top of the memory list page.

2. Expand the Advanced Filter panel and specify at least one filter condition (User ID, Agent ID, or Run ID).

3. The search results are sorted by vector similarity from highest to lowest. A similarity score is displayed for each result.

Memory details

1. In the memory list, click the view icon (an eye) on the right side of a memory card.

2. The details drawer displays the following information:

   • Memory ID, User ID, Agent ID (a hyphen '-' is displayed if empty), Run ID (a hyphen '-' is displayed if empty), and creation time.

   • The Memory Content area, which preserves the original line breaks.

   • The Metadata area (if available), displayed in JSON format.

   • The Tags area (if metadata.tags exists), displayed as blue rounded-corner tags.

Edit memory

1. In the memory list, click the edit icon on the right side of the target memory.

2. In the edit form, modify the Memory Content field.

3. Click Save Changes.

Read-only information such as the User ID, Agent ID, Run ID, creation time, and update time is displayed at the bottom of the edit form.

Delete memory

Memory history

A memory's version history tracks all changes from add, update, and delete operations.

1. In the memory details drawer, click the View History button.

2. The history list is sorted in reverse chronological order. Each record includes:

   • Version information: Version number + "Current Version" tag (for the latest version) + event type (ADD/UPDATE/DELETE).

   • Timestamp: In YYYY/MM/DD HH:mm:ss format.

   • Actor: actor_id + role (if available).

   • Memory Content: The memory text for that version.

   • Change details (if applicable): A comparison between the old value (red background) and the new value (green background).

MCP integration

Integrate memory capabilities into an Agent through the MCP (Model Context Protocol) service. On the MCP integration tab, you can start or stop the MCP service, get the service URL, view the dynamic configuration, and connect the service to an Agent.

Code Integration

Integrate the memory storage feature using the AgentRun SDK. The following example retrieves memory storage metadata using MemoryCollection and converts it into a mem0 Memory client for memory operations.

from agentrun.memory_collection import MemoryCollection

# Get the memory storage metadata
memory_collection = MemoryCollection.get_by_name("mem-OGzJ")
print(f"Successfully retrieved: {memory_collection}")

# Convert to a mem0_memory client
memory = MemoryCollection.to_mem0_memory("mem-OGzJ")

# Use the mem0ai Memory client to perform operations
user_id = "user123"

# Add a memory
result = memory.add(
    "I like to eat apples and bananas",
    user_id=user_id,
    metadata={"category": "food"},
)
for idx, res in enumerate(result.get("results", []), 1):
    print(f" {idx}. ID: {res.get('id')}, Event: {res.get('event')}")

# Search memories
search_results = memory.search("What fruit does the user like to eat?", user_id=user_id)
for idx, result in enumerate(search_results.get("results", []), 1):
    print(
        f" {idx}. Content: {result.get('memory')}, Similarity: {result.get('score', 0):.4f}"
    )

Ecosystem Integration

Memory storage integrates with open-source Agent development frameworks like LangChain to build memory-based conversational systems. The following example integrates memory storage into a LangChain conversational chain to deliver personalized responses based on historical memory.

from typing import List, Dict
from langchain_core.messages import SystemMessage, HumanMessage
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from agentrun.integration.langchain import model
from agentrun.memory_collection import MemoryCollection

# Create from model name
llm = model("qwen3-max")
# Create from memory storage name
mem0 = MemoryCollection.to_mem0_memory("mem-OGzJ")


prompt = ChatPromptTemplate.from_messages([
    SystemMessage(content="""You are a helpful travel agent AI. Use the provided context to personalize your responses and remember user preferences and past interactions.
    Provide travel recommendations, itinerary suggestions, and answer questions about destinations.
    If you don't have specific information, you can make general suggestions based on common travel knowledge."""),
    MessagesPlaceholder(variable_name="context"),
    HumanMessage(content="{input}")
])

def retrieve_context(query: str, user_id: str) -> List[Dict]:
    """Retrieve relevant context from Mem0"""
    try:
        memories = mem0.search(query, user_id=user_id)
        memory_list = memories['results']
        print(f"Memory search successfully: {memory_list}")
        serialized_memories = ' '.join([mem["memory"] for mem in memory_list])
        context = [
            {
                "role": "system",
                "content": f"Relevant information: {serialized_memories}"
            },
            {
                "role": "user",
                "content": query
            }
        ]
        return context
    except Exception as e:
        print(f"Error retrieving memories: {e}")
        # Return empty context if there's an error
        return [{"role": "user", "content": query}]

def generate_response(input: str, context: List[Dict]) -> str:
    """Generate a response using the language model"""
    chain = prompt | llm
    response = chain.invoke({
        "context": context,
        "input": input
    })
    return response.content

def save_interaction(user_id: str, user_input: str, assistant_response: str):
    """Save the interaction to Mem0"""
    try:
        interaction = [
            {
              "role": "user",
              "content": user_input
            },
            {
                "role": "assistant",
                "content": assistant_response
            }
        ]
        result = mem0.add(interaction, user_id=user_id)
        print(f"Memory saved successfully: {len(result.get('results', []))} memories added")
    except Exception as e:
        print(f"Error saving interaction: {e}")

def chat_turn(user_input: str, user_id: str) -> str:
    # Retrieve context
    context = retrieve_context(user_input, user_id)

    # Generate response
    response = generate_response(user_input, context)

    # Save interaction
    save_interaction(user_id, user_input, response)

    return response

if __name__ == "__main__":
    print("Welcome to your personal Travel Agent Planner! How can I assist you with your travel plans today?")
    user_id = "alice"

    while True:
        user_input = input("You: ")
        if user_input.lower() in ['quit', 'exit', 'bye']:
            print("Travel Agent: Thank you for using our travel planning service. Have a great trip!")
            break

        response = chat_turn(user_input, user_id)
        print(f"Travel Agent: {response}")

Failed to enable long-term memory

MCP service failed to start

Failed to add a memory

Failed to search memories