[Transformations] Transformations utils: added extract_subgraph helper (openvinotoolkit#35426)

### Details:
Adds a new transformations utility helper to extract a bounded subgraph
from an existing `ov::Model` into an independent `ov::Model`, primarily
to support debugging/isolated repro workflows.

### Tickets:
 - *N\A*

### AI Assistance:
 - *AI assistance used: yes*
- *AI was used to create a feature based on the PoC branch. The tests
are also written by the LLM*

### Prerequisites:
 - openvinotoolkit#35363

Author: v-Golubev

src/common/transformations/CMakeLists.txt

@@ -15,6 +15,12 @@ file(GLOB_RECURSE PUBLIC_HEADERS ${PUBLIC_HEADERS_DIR}/*.hpp)
 source_group("src" FILES ${LIBRARY_SRC})
 source_group("include" FILES ${PUBLIC_HEADERS})
 
+# Debug capabilities sources - only compiled when ENABLE_DEBUG_CAPS is ON
+if(NOT ENABLE_DEBUG_CAPS)
+    list(REMOVE_ITEM LIBRARY_SRC "${CMAKE_CURRENT_SOURCE_DIR}/src/transformations/utils/extract_subgraph.cpp")
+    list(REMOVE_ITEM PUBLIC_HEADERS "${PUBLIC_HEADERS_DIR}/transformations/utils/extract_subgraph.hpp")
+endif()
+
 # Create library
 add_library(${TARGET_NAME}_obj OBJECT ${LIBRARY_SRC} ${PUBLIC_HEADERS})
 target_compile_definitions(${TARGET_NAME}_obj PRIVATE IMPLEMENT_OPENVINO_API)

src/common/transformations/docs/debug_capabilities/README.md

@@ -20,6 +20,10 @@ They can be activated at runtime and are useful for analyzing transformation beh
   When to use: need to inspect model IR (.xml/.bin) after specific passes — useful for diffing model state before and after a transformation.
   Example: `OV_ENABLE_SERIALIZE_TRACING=true` or `OV_ENABLE_SERIALIZE_TRACING="Pass1,Pass2"`
 
+* [Subgraph extraction](extract_subgraph.md)
+  When to use: working with a large model where full compilation or inference is slow, or where the serialized IR is too large to read or render in graph visualization tools — extract only the relevant subgraph as a standalone `ov::Model`, serialize to IR, and continue investigation on the smaller model independently.
+  Example: `extract_subgraph(model, {{"MatMul_0", 0}}, {{"Softmax_0", 0}})`
+
 ## See also
 
 * [debug-matcher-pass skill](../../../../.claude/skills/debug-matcher-pass/SKILL.md) — automated diagnosis workflow for MatcherPass transformations that are not firing. Collects matcher logs, identifies root cause, and generates a reproducer test.

src/common/transformations/docs/debug_capabilities/extract_subgraph.md

@@ -0,0 +1,31 @@
+# Subgraph extraction
+
+Extracts a subgraph from an `ov::Model` as a standalone `ov::Model`, without modifying the original model.
+
+Useful for inspecting, serializing, or testing a specific portion of a larger model during development or debugging. This is especially valuable when working with large models where full compilation or inference takes a significant amount of time, or where the serialized IR is too large to read or render in graph visualization tools — extracting only the relevant subgraph lets you iterate on it in isolation instead of processing the entire model on each run.
+
+Once extracted, the subgraph can be serialized to IR via `ov::pass::Serialize` and reloaded independently, so subsequent investigation or reproduction work can be done on the smaller model without access to the original.
+
+## Example
+
+```cpp
+#include "transformations/utils/extract_subgraph.hpp"
+
+// Extract the subgraph between two named nodes
+const std::multimap<std::string, size_t> inputs  = {{"MatMul_0", 0}};
+const std::multimap<std::string, size_t> outputs = {{"Softmax_0", 0}};
+
+auto subgraph = ov::op::util::extract_subgraph(model, inputs, outputs);
+
+// The original model is unchanged; subgraph is an independent ov::Model.
+// Serialize it to IR so further investigation can be done on the isolated subgraph
+// without rerunning the full model pipeline.
+ov::pass::Serialize("subgraph.xml", "subgraph.bin").run_on_model(subgraph);
+```
+
+## Behavior
+
+- The original model is **not modified**.
+- The extracted model is a deep clone — changes to it do not affect the source model.
+- Subgraph `Parameter` nodes inherit the element type and partial shape of their corresponding input ports.
+- Node order within the extracted model follows topological order.

src/common/transformations/include/transformations/utils/extract_subgraph.hpp

@@ -0,0 +1,47 @@
+// Copyright (C) 2018-2026 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "openvino/core/model.hpp"
+#include "openvino/core/node.hpp"
+#include "transformations_visibility.hpp"
+
+namespace ov::util {
+
+/**
+ * @brief Extracts a subgraph bounded by the given input and output ports as a standalone model.
+ * The original model is not modified; the extracted model is a deep clone.
+ *
+ * @param subgraph_inputs  Input ports that form the subgraph boundary. Each port is replaced
+ *                         by a new Parameter whose element type and partial shape match the port.
+ * @param subgraph_outputs Output ports that define the subgraph results.
+ * @return A new ov::Model representing the extracted subgraph.
+ */
+TRANSFORMATIONS_API std::shared_ptr<ov::Model> extract_subgraph(const std::vector<ov::Input<ov::Node>>& subgraph_inputs,
+                                                                const ov::OutputVector& subgraph_outputs);
+
+/**
+ * @brief Extracts a subgraph by resolving boundary ports from node friendly names.
+ *
+ * Convenience wrapper over the port-based overload. Each multimap entry maps a node
+ * friendly name to a port index; multiple entries with the same name select different
+ * ports of the same node. Throws ov::Exception if any name is not found in the model.
+ *
+ * @param model             Source model.
+ * @param subgraph_inputs   Map of { friendly_name -> input_port_index } for boundary inputs.
+ * @param subgraph_outputs  Map of { friendly_name -> output_port_index } for boundary outputs.
+ * @return A new ov::Model representing the extracted subgraph.
+ */
+TRANSFORMATIONS_API std::shared_ptr<ov::Model> extract_subgraph(
+    const std::shared_ptr<ov::Model>& model,
+    const std::multimap<std::string, size_t>& subgraph_inputs,
+    const std::multimap<std::string, size_t>& subgraph_outputs);
+
+}  // namespace ov::util

src/common/transformations/tests/CMakeLists.txt

@@ -8,9 +8,16 @@ if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG)
     ov_add_compiler_flags(-Wno-missing-declarations)
 endif()
 
+set(EXCLUDED_PATHS "")
+if(NOT ENABLE_DEBUG_CAPS)
+    list(APPEND EXCLUDED_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/utils/extract_subgraph_test")
+endif()
+
 ov_add_test_target(
     NAME ${TARGET_NAME}
     ROOT ${CMAKE_CURRENT_SOURCE_DIR}
+    EXCLUDED_SOURCE_PATHS
+        ${EXCLUDED_PATHS}
     DEPENDENCIES
     LINK_LIBRARIES
         gmock