Building AI Companions

Overview

Building AI companions requires more than a simple chat window; an effective companion needs to retain your preferences, personality traits, and history across multiple sessions. By integrating Mem0 into your conversational assistant or framework, your assistant gains persistent long-term memory, semantic recall, and automatic context updates.

This guide covers how to wire memory management into interactive frameworks so that your AI companions remember important details, respect custom memory scopes, and seamlessly adapt to users over time.

Setting Up Persistent Memory for Assistants

Understanding Authentication and Configuration

To wire memory into an interactive conversational assistant, you typically choose a framework integration or plugin and configure your authentication and scoping preferences. Every memory integration requires authentication to connect your assistant to the Mem0 platform or your self-hosted backend. Set your API key in your environment variables:

Copyexport MEM0_API_KEY="your-api-key-here"

If you are running a self-hosted instance rather than the cloud platform, you can configure a custom host URL instead:

Copyexport MEM0_HOST="https://your-self-hosted-mem0-instance.com"

Configuring Memory Scopes

Memories are organized using namespaces to keep data cleanly separated between users, projects, and active runs. The available scope identifiers include:

Step-by-Step: Wiring Memory into Frameworks

Framework Integration Workflow

Depending on your conversational framework, you can hook Mem0 directly into the message loop for automatic context injection and conversation extraction.

Step 1: Initialize the Memory Store

Initialize the memory store with your credentials and default scope settings. For example, when using memory stores in backend pipelines, specify your user namespace and enable extraction:

Copyfrom mem0_strands import Mem0MemoryStore
 
# Configure semantic memory with automatic server-side extraction
store = Mem0MemoryStore(user_id="alex", writable=True, extraction=True)

Step 2: Enable Auto-Recall and Auto-Capture

Most companion integrations support automated hooks that perform two key functions:

1. Auto-Recall: Before generating a response, the system searches stored memories for relevant facts based on your latest prompt and injects them into the system prompt.
2. Auto-Capture: After a conversation turn or session ends, the system passes the conversation turns to Mem0 to extract durable facts, preferences, and decisions.

Copy// Example configuration snippet for auto-recall and auto-capture settings
const mem0Config = {
  autoRecall: true,
  autoCapture: true,
  topK: 5,
  searchThreshold: 0.7,
};

Step 3: Use Explicit Memory Tools

If your companion framework supports agent-callable tools, the assistant can proactively search, add, update, or delete memories during conversations.

CopyUser does X (e.g., states a preference) → System extracts durable fact → Memory stored via add_memory tool → Future queries retrieve context via search_memory tool

Available core tool actions typically include:

• Search: Recalls facts ranked by semantic relevance.
• Add: Stores a durable fact verbatim or via extraction.
• Update: Replaces the text of an outdated memory by its unique ID.
• Delete: Removes obsolete or forgotten memories.

Examples & Configuration Options

Below is an example of configuring a chat completion wrapper with Mem0 to automatically manage memory injection and background saving:

Copyfrom mem0 import MemoryClient
 
# Initialize the client
client = MemoryClient(api_key="your-api-key")
 
# Add a conversation turn to memory
client.add(
    [
        {"role": "user", "content": "I prefer vegetarian recipes and live in Seattle."},
        {"role": "assistant", "content": "Got it! I'll keep your dietary preference in mind."}
    ],
    user_id="alex-user"
)
 
# Search relevant memories for future turns
memories = client.search(
    query="What does the user like to eat?",
    filters={"user_id": "alex-user"}
)

Tips and Warnings

Related

• Managing Memories
• Organizing User Memories