diff --git a/common/test/mocked_utils.hpp b/common/test/mocked_utils.hpp
index 71bc6e7..e42677c 100644
--- a/common/test/mocked_utils.hpp
+++ b/common/test/mocked_utils.hpp
@@ -22,6 +22,35 @@
 } // namespace utils
 } // namespace pldm
 
+class GetManagedEmptyObject
+{
+  public:
+    static pldm::utils::ObjectValueTree getManagedObj(const char* /*service*/,
+                                                      const char* /*path*/)
+    {
+        return pldm::utils::ObjectValueTree{};
+    }
+};
+
+class GetManagedObject
+{
+  public:
+    static pldm::utils::ObjectValueTree getManagedObj(const char* /*service*/,
+                                                      const char* /*path*/)
+    {
+        return pldm::utils::ObjectValueTree{
+            {sdbusplus::message::object_path("/foo/bar"),
+             {{"foo.bar",
+               {{"Functional", true},
+                {"Enabled", true},
+                {"PrettyName", "System"},
+                {"Present", true},
+                {"SerialNumber", "abc123z"},
+                {"Model", "1234 - 00Z"},
+                {"SubModel", "S0"}}}}}};
+    }
+};
+
 class MockdBusHandler : public pldm::utils::DBusHandler
 {
   public:
diff --git a/common/test/pldm_utils_test.cpp b/common/test/pldm_utils_test.cpp
index 549e289..93cf335 100644
--- a/common/test/pldm_utils_test.cpp
+++ b/common/test/pldm_utils_test.cpp
@@ -1,4 +1,5 @@
 #include "common/utils.hpp"
+#include "mocked_utils.hpp"
 
 #include <libpldm/platform.h>
 
@@ -6,6 +7,28 @@
 
 using namespace pldm::utils;
 
+TEST(GetInventoryObjects, testForEmptyObject)
+{
+    ObjectValueTree result =
+        DBusHandler::getInventoryObjects<GetManagedEmptyObject>();
+    EXPECT_TRUE(result.empty());
+}
+
+TEST(GetInventoryObjects, testForObject)
+{
+    std::string path = "/foo/bar";
+    std::string service = "foo.bar";
+    auto result = DBusHandler::getInventoryObjects<GetManagedObject>();
+    EXPECT_EQ(result[path].begin()->first, service);
+    auto function =
+        std::get<bool>(result[path][service][std::string("Functional")]);
+    auto model =
+        std::get<std::string>(result[path][service][std::string("Model")]);
+    EXPECT_FALSE(result.empty());
+    EXPECT_TRUE(function);
+    EXPECT_EQ(model, std::string("1234 - 00Z"));
+}
+
 TEST(decodeDate, testGooduintToDate)
 {
     uint64_t data = 20191212115959;
diff --git a/common/utils.cpp b/common/utils.cpp
index 7e43b49..eee9f43 100644
--- a/common/utils.cpp
+++ b/common/utils.cpp
@@ -563,6 +563,16 @@
     return bus.call(method, dbusTimeout).unpack<PropertyValue>();
 }
 
+ObjectValueTree DBusHandler::getManagedObj(const char* service,
+                                           const char* rootPath)
+{
+    auto& bus = DBusHandler::getBus();
+    auto method = bus.new_method_call(service, rootPath,
+                                      "org.freedesktop.DBus.ObjectManager",
+                                      "GetManagedObjects");
+    return bus.call(method).unpack<ObjectValueTree>();
+}
+
 PropertyValue jsonEntryToDbusVal(std::string_view type,
                                  const nlohmann::json& value)
 {
diff --git a/common/utils.hpp b/common/utils.hpp
index e940265..2d3fb7f 100644
--- a/common/utils.hpp
+++ b/common/utils.hpp
@@ -14,6 +14,7 @@
 
 #include <nlohmann/json.hpp>
 #include <sdbusplus/server.hpp>
+#include <xyz/openbmc_project/Inventory/Manager/client.hpp>
 #include <xyz/openbmc_project/Logging/Entry/server.hpp>
 
 #include <deque>
@@ -182,8 +183,12 @@
     return bcd;
 }
 
+using inventoryManager =
+    sdbusplus::client::xyz::openbmc_project::inventory::Manager<>;
+
 constexpr auto dbusProperties = "org.freedesktop.DBus.Properties";
 constexpr auto mapperService = "xyz.openbmc_project.ObjectMapper";
+constexpr auto inventoryPath = "/xyz/openbmc_project/inventory";
 
 struct DBusMapping
 {
@@ -195,7 +200,8 @@
 
 using PropertyValue =
     std::variant<bool, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t,
-                 uint64_t, double, std::string, std::vector<std::string>>;
+                 uint64_t, double, std::string, std::vector<uint8_t>,
+                 std::vector<std::string>>;
 using DbusProp = std::string;
 using DbusChangedProps = std::map<DbusProp, PropertyValue>;
 using DBusInterfaceAdded = std::vector<
@@ -209,6 +215,7 @@
 using GetSubTreeResponse = std::vector<std::pair<ObjectPath, MapperServiceMap>>;
 using PropertyMap = std::map<std::string, PropertyValue>;
 using InterfaceMap = std::map<std::string, PropertyMap>;
+using ObjectValueTree = std::map<sdbusplus::message::object_path, InterfaceMap>;
 
 /**
  * @brief The interface for DBusHandler
@@ -328,6 +335,34 @@
      */
     void setDbusProperty(const DBusMapping& dBusMap,
                          const PropertyValue& value) const override;
+
+    /** @brief This function retrieves the properties of an object managed
+     *         by the specified D-Bus service located at the given object path.
+     *
+     *  @param[in] service - The D-Bus service providing the managed object
+     *  @param[in] value - The object path of the managed object
+     *
+     *  @return A hierarchical structure representing the properties of the
+     *          managed object.
+     *  @throw sdbusplus::exception::exception when it fails
+     */
+    static ObjectValueTree getManagedObj(const char* service, const char* path);
+
+    /** @brief Retrieve the inventory objects managed by a specified class.
+     *         The retrieved inventory objects are cached statically
+     *         and returned upon subsequent calls to this function.
+     *
+     *  @tparam ClassType - The class type that manages the inventory objects.
+     *
+     *  @return A reference to the cached inventory objects.
+     */
+    template <typename ClassType>
+    static auto& getInventoryObjects()
+    {
+        static ObjectValueTree object = ClassType::getManagedObj(
+            inventoryManager::interface, inventoryPath);
+        return object;
+    }
 };
 
 /** @brief Fetch parent D-Bus object based on pathname