[DO NOT REVIEW][TEST]Serialize on plugin adapter mlir NOT use copy

src/plugins/intel_npu/src/al/include/intel_npu/config/options.hpp

@@ -842,7 +842,7 @@ struct COMPILER_TYPE final : OptionBase<COMPILER_TYPE, ov::intel_npu::CompilerTy
     }
 
     static ov::intel_npu::CompilerType defaultValue() {
-        return ov::intel_npu::CompilerType::DRIVER;
+        return ov::intel_npu::CompilerType::PLUGIN;
     }
 
     static ov::intel_npu::CompilerType parse(std::string_view val) {

src/plugins/intel_npu/src/common/src/device_helpers.cpp

@@ -39,19 +39,21 @@ std::string utils::getCompilationPlatform(const std::string_view platform,
                                           std::vector<std::string> availableDevicesNames) {
     // Platform parameter has a higher priority than deviceID
     if (platform != ov::intel_npu::Platform::AUTO_DETECT) {
+        std::cout << "   return 1 platform from getCompilationPlatform " << std::endl;
         return std::string(platform);
     }
 
     // Get compilation platform from deviceID
     if (!deviceId.empty()) {
+        std::cout << "   return 2 deviceId from getCompilationPlatform " << std::endl;
         return utils::getPlatformByDeviceName(deviceId);
     }
 
     // Automatic detection of compilation platform
     if (availableDevicesNames.empty()) {
         OPENVINO_THROW("No NPU devices were found.");
     }
-
+    std::cout << "   return 3 availableDevicesNames from getCompilationPlatform, availableDevicesNames.at(0) is " << availableDevicesNames.at(0) << std::endl;
     return utils::getPlatformByDeviceName(availableDevicesNames.at(0));
 }
 

src/plugins/intel_npu/src/compiler_adapter/include/compiler_impl.hpp

@@ -0,0 +1,73 @@
+// Copyright (C) 2018-2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <memory>
+#include <mutex>
+
+#include "compiler.h"
+#include "intel_npu/common/filtered_config.hpp"
+#include "intel_npu/icompiler.hpp"
+#include "openvino/core/except.hpp"
+
+namespace intel_npu {
+
+bool isUseBaseModelSerializer(const FilteredConfig& config);
+std::string supportVclCompiler(int major, int minor);
+class VCLApi;
+
+class VCLCompilerImpl final : public intel_npu::ICompiler {
+public:
+    VCLCompilerImpl();
+    ~VCLCompilerImpl() override;
+
+    static std::shared_ptr<VCLCompilerImpl> getInstance() {
+        static std::mutex mutex;
+        static std::weak_ptr<VCLCompilerImpl> weak_compiler;
+
+        std::lock_guard<std::mutex> lock(mutex);
+        auto compiler = weak_compiler.lock();
+        if (!compiler) {
+            compiler = std::make_shared<VCLCompilerImpl>();
+            weak_compiler = compiler;
+        }
+        return compiler;
+    }
+
+    NetworkDescription compile(const std::shared_ptr<const ov::Model>& model, const Config& config) const override;
+
+    std::vector<std::shared_ptr<NetworkDescription>> compileWsOneShot(const std::shared_ptr<ov::Model>& model,
+                                                                      const Config& config) const override;
+
+    NetworkDescription compileWsIterative(const std::shared_ptr<ov::Model>& model,
+                                          const Config& config,
+                                          size_t callNumber) const override;
+
+    ov::SupportedOpsMap query(const std::shared_ptr<const ov::Model>& model, const Config& config) const override;
+
+    NetworkMetadata parse(const std::vector<uint8_t>& network, const Config& config) const override;
+
+    uint32_t get_version() const override;
+
+    std::vector<ov::ProfilingInfo> process_profiling_output(const std::vector<uint8_t>& profData,
+                                                            const std::vector<uint8_t>& network,
+                                                            const intel_npu::Config& config) const final override;
+
+    bool get_supported_options(std::vector<char>& options) const;
+
+    bool is_option_supported(const std::string& option) const;
+
+    std::shared_ptr<VCLApi> getLinkedLibrary() const;
+
+private:
+    vcl_log_handle_t _logHandle = nullptr;
+    vcl_compiler_handle_t _compilerHandle = nullptr;
+    vcl_compiler_properties_t _compilerProperties;
+    vcl_version_info_t _vclVersion;
+    vcl_version_info_t _vclProfilingVersion;
+    Logger _logger;
+};
+
+}  // namespace intel_npu

src/plugins/intel_npu/src/compiler_adapter/include/weightless_utils.hpp

@@ -0,0 +1,24 @@
+// Copyright (C) 2018-2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include "openvino/core/model.hpp"
+
+namespace intel_npu {
+/**
+ * @brief Stores the information within the "WeightlessCacheAttribute" as runtime fields that persist upon
+ * serialization.
+ * @details Constant nodes (weights) may contain as medatadata the "WeightlessCacheAttribute", that is information
+ * regarding the offset of the weights within the binary file, as well as the original size and precision. This
+ * information is required within the "weights separation" flow, therefore this function is here to store it.
+ * @note Not calling this function in the weights separation flow would lead to this information being lost upon
+ * serialization. The "WeightlessCacheAttribute" information that is populated upon de-serialization would represent
+ * metadata corresponding to the serialized stream, not the original weights file. Therefore the compiler would be
+ * misinformed and lookups of weights offsets could fail.
+ *
+ * @param model Both source and target.
+ */
+void storeWeightlessCacheAttribute(const std::shared_ptr<ov::Model>& model);
+}  // namespace intel_npu

src/plugins/intel_npu/src/compiler_adapter/include/ze_graph_ext_wrappers.hpp

@@ -75,4 +75,7 @@ class ZeGraphExtWrappers {
     Logger _logger;
 };
 
+// Parse the result string of query from format <name_0><name_1><name_2> to unordered_set of string
+std::unordered_set<std::string> parseQueryResult(std::vector<char>& data);
+
 }  // namespace intel_npu