feat: update demo and add user manager (#31)

* feat: add product API and related functionality (cleaned sensitive data)

* feat: add singleton for memos and llm

* fix:fix persistent_user_manager

* feat:update prompt and rm readme

* fix：ci code

Author: fridayL

examples/mem_os/multi_user_memos_example.py

@@ -0,0 +1,125 @@
+"""
+Example demonstrating how to use MOSProduct for multi-user scenarios.
+"""
+
+from memos.configs.mem_cube import GeneralMemCubeConfig
+from memos.configs.mem_os import MOSConfig
+from memos.mem_cube.general import GeneralMemCube
+from memos.mem_os.product import MOSProduct
+
+
+def get_config(user_name):
+    openapi_config = {
+        "model_name_or_path": "gpt-4o-mini",
+        "temperature": 0.8,
+        "max_tokens": 1024,
+        "top_p": 0.9,
+        "top_k": 50,
+        "remove_think_prefix": True,
+        "api_key": "your-api-key-here",
+        "api_base": "https://api.openai.com/v1",
+    }
+    # Create a default configuration
+    default_config = MOSConfig(
+        user_id="root",
+        chat_model={"backend": "openai", "config": openapi_config},
+        mem_reader={
+            "backend": "naive",
+            "config": {
+                "llm": {
+                    "backend": "openai",
+                    "config": openapi_config,
+                },
+                "embedder": {
+                    "backend": "ollama",
+                    "config": {
+                        "model_name_or_path": "nomic-embed-text:latest",
+                    },
+                },
+            },
+        },
+        enable_textual_memory=True,
+        enable_activation_memory=False,
+        top_k=5,
+        max_turns_window=20,
+    )
+    default_cube_config = GeneralMemCubeConfig.model_validate(
+        {
+            "user_id": user_name,
+            "cube_id": f"{user_name}_default_cube",
+            "text_mem": {
+                "backend": "tree_text",
+                "config": {
+                    "extractor_llm": {"backend": "openai", "config": openapi_config},
+                    "dispatcher_llm": {"backend": "openai", "config": openapi_config},
+                    "graph_db": {
+                        "backend": "neo4j",
+                        "config": {
+                            "uri": "bolt://localhost:7687",
+                            "user": "neo4j",
+                            "password": "12345678",
+                            "db_name": user_name,
+                            "auto_create": True,
+                        },
+                    },
+                    "embedder": {
+                        "backend": "ollama",
+                        "config": {
+                            "model_name_or_path": "nomic-embed-text:latest",
+                        },
+                    },
+                },
+            },
+            "act_mem": {},
+            "para_mem": {},
+        }
+    )
+    default_mem_cube = GeneralMemCube(default_cube_config)
+    return default_config, default_mem_cube
+
+
+def main():
+    default_config, default_mem_cube = get_config(user_name="alice")
+    # Initialize MOSProduct with default config
+    mos_product = MOSProduct(default_config=default_config)
+
+    # Register first user with default config
+    result1 = mos_product.user_register(
+        user_id="alice",
+        user_name="alice",
+        interests="I'm interested in machine learning and AI research.",
+        default_mem_cube=default_mem_cube,
+    )
+    print(f"User registration result: {result1}")
+
+    # Chat with Alice
+    print("\n=== Chatting with Alice ===")
+    for response_chunk in mos_product.chat(query="What are my interests?", user_id="alice"):
+        print(response_chunk, end="")
+
+    # Add memory for Alice
+    mos_product.add(
+        user_id="alice",
+        memory_content="I attended a machine learning conference last week.",
+        mem_cube_id=result1["default_cube_id"],
+    )
+
+    # Search memories for Alice
+    search_result = mos_product.search(query="conference", user_id="alice")
+    print(f"\nSearch result for Alice: {search_result}")
+
+    # Search memories for Alice
+    search_result = mos_product.get_all(query="conference", user_id="alice", memory_type="text_mem")
+    print(f"\nSearch result for Alice: {search_result}")
+
+    # List all users
+    users = mos_product.list_users()
+    print(f"\nAll registered users: {users}")
+
+    # Get user info
+    alice_info = mos_product.get_user_info("alice")
+    print(f"\nAlice's info: {alice_info}")
+
+
+if __name__ == "__main__":
+    main()

examples/mem_os/persistent_memos_example.py

@@ -0,0 +1,192 @@
+"""
+Example demonstrating persistent user management in MemOS.
+
+This example shows how to use the PersistentUserManager to maintain
+user configurations across service restarts.
+"""
+
+import os
+import tempfile
+
+from memos.configs.mem_os import MOSConfig
+from memos.mem_os.product import MOSProduct
+from memos.mem_user.persistent_user_manager import PersistentUserManager, UserRole
+
+
+def create_sample_config(user_id: str) -> MOSConfig:
+    """Create a sample configuration for a user."""
+    return MOSConfig(
+        user_id=user_id,
+        chat_model={
+            "backend": "openai",
+            "config": {
+                "model_name_or_path": "gpt-3.5-turbo",
+                "api_key": "your-api-key-here",
+                "temperature": 0.7,
+            },
+        },
+        mem_reader={
+            "backend": "naive",
+            "config": {
+                "llm": {
+                    "backend": "openai",
+                    "config": {
+                        "model_name_or_path": "gpt-3.5-turbo",
+                        "api_key": "your-api-key-here",
+                    },
+                },
+                "embedder": {
+                    "backend": "ollama",
+                    "config": {
+                        "model_name_or_path": "nomic-embed-text:latest",
+                    },
+                },
+            },
+        },
+        enable_textual_memory=True,
+        enable_activation_memory=False,
+        top_k=5,
+        max_turns_window=20,
+    )
+
+
+def demonstrate_persistence():
+    """Demonstrate the persistence functionality."""
+    print("=== MemOS Persistent User Management Demo ===\n")
+
+    # Create a temporary database for this demo
+    temp_dir = tempfile.mkdtemp()
+    db_path = os.path.join(temp_dir, "demo_memos.db")
+
+    try:
+        # Step 1: Create a persistent user manager
+        print("1. Creating PersistentUserManager...")
+        user_manager = PersistentUserManager(db_path=db_path)
+        print(f"   Database created at: {db_path}")
+
+        # Step 2: Create some sample configurations
+        print("\n2. Creating sample user configurations...")
+        user_configs = {}
+        for i in range(3):
+            user_id = f"user_{i + 1}"
+            user_name = f"User {i + 1}"
+            config = create_sample_config(user_id)
+            user_configs[user_id] = config
+
+            # Create user with configuration
+            created_id = user_manager.create_user_with_config(
+                user_name, config, UserRole.USER, user_id
+            )
+            print(f"   Created user: {user_name} (ID: {created_id})")
+
+        # Step 3: Verify configurations are saved
+        print("\n3. Verifying configurations are saved...")
+        for user_id in user_configs:
+            config = user_manager.get_user_config(user_id)
+            if config:
+                print(f"   ✓ Configuration found for {user_id}")
+                print(f"     - Textual memory enabled: {config.enable_textual_memory}")
+                print(f"     - Top-k: {config.top_k}")
+            else:
+                print(f"   ✗ Configuration not found for {user_id}")
+
+        # Step 4: Simulate service restart by creating a new manager instance
+        print("\n4. Simulating service restart...")
+        print("   Creating new PersistentUserManager instance...")
+        new_user_manager = PersistentUserManager(db_path=db_path)
+
+        # Step 5: Verify configurations are restored
+        print("\n5. Verifying configurations are restored after restart...")
+        for user_id in user_configs:
+            config = new_user_manager.get_user_config(user_id)
+            if config:
+                print(f"   ✓ Configuration restored for {user_id}")
+            else:
+                print(f"   ✗ Configuration not restored for {user_id}")
+
+        # Step 6: Create MOSProduct and demonstrate restoration
+        print("\n6. Creating MOSProduct with persistent user manager...")
+        default_config = create_sample_config("default_user")
+        mos_product = MOSProduct(default_config=default_config)
+
+        # The MOSProduct should automatically restore user instances
+        print(f"   Active user instances: {len(mos_product.user_instances)}")
+        for user_id in mos_product.user_instances:
+            print(f"   - {user_id}")
+
+        # Step 7: Demonstrate configuration update
+        print("\n7. Demonstrating configuration update...")
+        user_id = "user_1"
+        original_config = user_manager.get_user_config(user_id)
+        if original_config:
+            # Update configuration
+            updated_config = original_config.model_copy(deep=True)
+            updated_config.top_k = 10
+            updated_config.enable_activation_memory = True
+
+            success = user_manager.save_user_config(user_id, updated_config)
+            if success:
+                print(f"   ✓ Updated configuration for {user_id}")
+                print(f"     - New top-k: {updated_config.top_k}")
+                print(f"     - Activation memory: {updated_config.enable_activation_memory}")
+            else:
+                print(f"   ✗ Failed to update configuration for {user_id}")
+
+        # Step 8: List all configurations
+        print("\n8. Listing all user configurations...")
+        all_configs = user_manager.list_user_configs()
+        print(f"   Total configurations: {len(all_configs)}")
+        for user_id, config in all_configs.items():
+            print(
+                f"   - {user_id}: top_k={config.top_k}, textual_memory={config.enable_textual_memory}"
+            )
+
+        print("\n=== Demo completed successfully! ===")
+        print(f"Database file: {db_path}")
+        print("You can inspect this file to see the persistent data.")
+
+    except Exception as e:
+        print(f"Error during demo: {e}")
+        raise
+    finally:
+        # Cleanup
+        if os.path.exists(db_path):
+            os.remove(db_path)
+        if os.path.exists(temp_dir):
+            os.rmdir(temp_dir)
+
+
+def demonstrate_api_usage():
+    """Demonstrate how the API would work with persistence."""
+    print("\n=== API Usage Example ===")
+    print("""
+    With the new persistent system, your API calls would work like this:
+
+    1. Register a user (configuration is automatically saved):
+       POST /product/users/register
+       {
+         "user_id": "john_doe",
+         "user_name": "John Doe",
+         "interests": "AI, machine learning, programming"
+       }
+
+    2. Get user configuration:
+       GET /product/users/john_doe/config
+
+    3. Update user configuration:
+       PUT /product/users/john_doe/config
+       {
+         "user_id": "john_doe",
+         "enable_activation_memory": true,
+         "top_k": 10,
+         ...
+       }
+
+    4. After service restart, all user instances are automatically restored
+       and the user can immediately use the system without re-registration.
+    """)
+
+
+if __name__ == "__main__":
+    demonstrate_persistence()
+    demonstrate_api_usage()