Method load_from_json

src/memory/context.py:861–955

Load memory configurations with version history from JSON. Loads basic configuration only (instance is not saved, must be created via build()). Only the latest version will be instantiated by default if auto_initialize=True. Args: file_path: File

(self, file_path: Optional[str] = None, auto_initialize: bool = True)

        return contract_text
    
    async def load_from_json(self, file_path: Optional[str] = None, auto_initialize: bool = True) -> bool:
        """Load memory configurations with version history from JSON.
        
        Loads basic configuration only (instance is not saved, must be created via build()).
        Only the latest version will be instantiated by default if auto_initialize=True.
        
        Args:
            file_path: File path to load from
            auto_initialize: Whether to automatically create instance via build() after loading
            
        Returns:
            True if loaded successfully, False otherwise
        """
        
        file_path = file_path if file_path is not None else self.save_path
        
        async with file_lock(file_path):
            if not os.path.exists(file_path):
                logger.warning(f"| ⚠️ Memory file not found: {file_path}")
                return False
            
            try:
                with open(file_path, "r", encoding="utf-8") as f:
                    load_data = json.load(f)
                
                memories_data = load_data.get("memory_systems", {})
                loaded_count = 0
                
                for memory_name, memory_data in memories_data.items():
                    try:
                        # Expected format: multiple versions stored as a dict {version_str: config_dict}
                        versions_data = memory_data.get("versions")
                        if not isinstance(versions_data, dict):
                            logger.warning(f"| ⚠️ Memory {memory_name} has invalid format for 'versions' (expected dict), skipping")
                            continue
                        
                        current_version_str = memory_data.get("current_version")
                        
                        # Load all versions
                        version_configs = []
                        latest_config = None
                        latest_version = None
                        
                        for version_str, config_dict in versions_data.items():
                            # Ensure version field is present
                            if "version" not in config_dict:
                                config_dict["version"] = version_str
                            
                            try:
                                memory_config = MemoryConfig.model_validate(config_dict)
                                version_configs.append(memory_config)
                            except Exception as e:
                                logger.warning(f"| ⚠️ Failed to load memory config for {memory_name}@{version_str}: {e}")
                                continue
                            
                            # Track latest version
                            if latest_config is None or (
                                current_version_str and memory_config.version == current_version_str