fix：ci code

Author: fridayL

examples/mem_os/multi_user_memos_example.py

@@ -2,15 +2,11 @@
 Example demonstrating how to use MOSProduct for multi-user scenarios.
 """
 
-from memos.configs.mem_os import MOSConfig
-from memos.configs.llm import LLMConfigFactory
-from memos.configs.mem_reader import MemReaderConfigFactory
 from memos.configs.mem_cube import GeneralMemCubeConfig
-from memos.mem_os.product import MOSProduct
+from memos.configs.mem_os import MOSConfig
 from memos.mem_cube.general import GeneralMemCube
-from memos.configs.mem_cube import GeneralMemCubeConfig
-from memos.configs.memory import MemoryConfigFactory
-from memos.memories.factory import MemoryFactory
+from memos.mem_os.product import MOSProduct
+
 
 def get_config(user_name):
     openapi_config = {
@@ -23,25 +19,13 @@ def get_config(user_name):
         "api_key": "your-api-key-here",
         "api_base": "https://api.openai.com/v1",
     }
-    huggingface_config = {
-        "model_name_or_path": "Qwen/Qwen3-1.7B",
-        "temperature": 0.1,
-        "remove_think_prefix": True,
-        "max_tokens": 4096,
-        "top_p": 0.9,
-        "top_k": 50,
-        "add_generation_prompt": True,
-    }
     # Create a default configuration
     default_config = MOSConfig(
         user_id="root",
-        chat_model={
-            "backend":"openai",
-            "config":openapi_config
-        },
+        chat_model={"backend": "openai", "config": openapi_config},
         mem_reader={
-            "backend":"naive",
-            "config":{
+            "backend": "naive",
+            "config": {
                 "llm": {
                     "backend": "openai",
                     "config": openapi_config,
@@ -52,104 +36,90 @@ def get_config(user_name):
                         "model_name_or_path": "nomic-embed-text:latest",
                     },
                 },
-            }
+            },
         },
         enable_textual_memory=True,
         enable_activation_memory=False,
         top_k=5,
-        max_turns_window=20
+        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
+    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,
                         },
-                "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",
                         },
-                "embedder": {
-                            "backend": "ollama",
-                            "config": {
-                                "model_name_or_path": "nomic-embed-text:latest",
-                            },
                     },
-            }
-        },
-        "act_mem": {},
-        "para_mem": {},
-    })
+                },
+            },
+            "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
+        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"
-    ):
+    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"]
+        mem_cube_id=result1["default_cube_id"],
     )
-    
+
     # Search memories for Alice
-    search_result = mos_product.search(
-        query="conference",
-        user_id="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"
-    )
+    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() 
+    main()

examples/mem_os/persistent_memos_example.py

@@ -7,7 +7,6 @@
 
 import os
 import tempfile
-from pathlib import Path
 
 from memos.configs.mem_os import MOSConfig
 from memos.mem_os.product import MOSProduct
@@ -24,7 +23,7 @@ def create_sample_config(user_id: str) -> MOSConfig:
                 "model_name_or_path": "gpt-3.5-turbo",
                 "api_key": "your-api-key-here",
                 "temperature": 0.7,
-            }
+            },
         },
         mem_reader={
             "backend": "naive",
@@ -34,52 +33,52 @@ def create_sample_config(user_id: str) -> MOSConfig:
                     "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
+        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}"
+            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:
@@ -90,12 +89,12 @@ def demonstrate_persistence():
                 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:
@@ -104,17 +103,17 @@ def demonstrate_persistence():
                 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"
@@ -124,26 +123,28 @@ def demonstrate_persistence():
             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(
+                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
@@ -160,18 +161,18 @@ def demonstrate_api_usage():
     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
        {
@@ -180,12 +181,12 @@ def demonstrate_api_usage():
          "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() 
+    demonstrate_api_usage()