diff --git a/requester/mctp_endpoint_discovery.cpp b/requester/mctp_endpoint_discovery.cpp
index 6833684..ac1277f 100644
--- a/requester/mctp_endpoint_discovery.cpp
+++ b/requester/mctp_endpoint_discovery.cpp
@@ -83,9 +83,11 @@
             if (std::find(types.begin(), types.end(), mctpTypePLDM) !=
                 types.end())
             {
-                mctpInfoMap[MctpInfo(std::get<eid>(epProps), uuid, "",
-                                     std::get<NetworkId>(epProps))] =
-                    availability;
+                auto mctpInfo =
+                    MctpInfo(std::get<eid>(epProps), uuid, "",
+                             std::get<NetworkId>(epProps), std::nullopt);
+                searchConfigurationFor(pldm::utils::DBusHandler(), mctpInfo);
+                mctpInfoMap[std::move(mctpInfo)] = availability;
             }
         }
     }
@@ -231,7 +233,11 @@
                     info(
                         "Adding Endpoint networkId '{NETWORK}' and EID '{EID}' UUID '{UUID}'",
                         "NETWORK", networkId, "EID", eid, "UUID", uuid);
-                    mctpInfos.emplace_back(MctpInfo(eid, uuid, "", networkId));
+                    auto mctpInfo =
+                        MctpInfo(eid, uuid, "", networkId, std::nullopt);
+                    searchConfigurationFor(pldm::utils::DBusHandler(),
+                                           mctpInfo);
+                    mctpInfos.emplace_back(std::move(mctpInfo));
                 }
             }
         }
@@ -316,7 +322,8 @@
             const UUID& uuid = getEndpointUUIDProp(service, objPath);
 
             MctpInfo mctpInfo(std::get<eid>(epProps), uuid, "",
-                              std::get<NetworkId>(epProps));
+                              std::get<NetworkId>(epProps), std::nullopt);
+            searchConfigurationFor(pldm::utils::DBusHandler(), mctpInfo);
             if (!std::ranges::contains(existingMctpInfos, mctpInfo))
             {
                 if (availability)
@@ -360,6 +367,7 @@
     }
     removeFromExistingMctpInfos(mctpInfos, removedInfos);
     handleRemovedMctpEndpoints(removedInfos);
+    removeConfigs(removedInfos);
 }
 
 void MctpDiscovery::handleMctpEndpoints(const MctpInfos& mctpInfos)
@@ -368,6 +376,7 @@
     {
         if (handler)
         {
+            handler->handleConfigurations(configurations);
             handler->handleMctpEndpoints(mctpInfos);
         }
     }
@@ -396,4 +405,105 @@
     }
 }
 
+std::string MctpDiscovery::getNameFromProperties(
+    const utils::PropertyMap& properties)
+{
+    if (!properties.contains("Name"))
+    {
+        error("Missing name property");
+        return "";
+    }
+    return std::get<std::string>(properties.at("Name"));
+}
+
+std::string MctpDiscovery::constructMctpReactorObjectPath(
+    const MctpInfo& mctpInfo)
+{
+    const auto networkId = std::get<NetworkId>(mctpInfo);
+    const auto eid = std::get<pldm::eid>(mctpInfo);
+    return std::string{MCTPPath} + "/networks/" + std::to_string(networkId) +
+           "/endpoints/" + std::to_string(eid) + "/configured_by";
+}
+
+void MctpDiscovery::searchConfigurationFor(
+    const pldm::utils::DBusHandler& handler, MctpInfo& mctpInfo)
+{
+    const auto mctpReactorObjectPath = constructMctpReactorObjectPath(mctpInfo);
+    try
+    {
+        std::string associatedObjPath;
+        std::string associatedService;
+        std::string associatedInterface;
+        sdbusplus::message::object_path inventorySubtreePath(
+            inventorySubtreePathStr);
+
+        //"/{board or chassis type}/{board or chassis}/{device}"
+        auto constexpr subTreeDepth = 3;
+        auto response = handler.getAssociatedSubTree(
+            mctpReactorObjectPath, inventorySubtreePath, subTreeDepth,
+            interfaceFilter);
+        if (response.empty())
+        {
+            warning("No associated subtree found for path {PATH}", "PATH",
+                    mctpReactorObjectPath);
+            return;
+        }
+        // Assume the first entry is the one we want
+        auto subTree = response.begin();
+        associatedObjPath = subTree->first;
+        auto associatedServiceProp = subTree->second;
+        if (associatedServiceProp.empty())
+        {
+            warning("No associated service found for path {PATH}", "PATH",
+                    mctpReactorObjectPath);
+            return;
+        }
+        // Assume the first entry is the one we want
+        auto entry = associatedServiceProp.begin();
+        associatedService = entry->first;
+        auto dBusIntfList = entry->second;
+        auto associatedInterfaceItr = std::find_if(
+            dBusIntfList.begin(), dBusIntfList.end(), [](const auto& intf) {
+                return std::find(interfaceFilter.begin(), interfaceFilter.end(),
+                                 intf) != interfaceFilter.end();
+            });
+        if (associatedInterfaceItr == dBusIntfList.end())
+        {
+            error("No associated interface found for path {PATH}", "PATH",
+                  mctpReactorObjectPath);
+            return;
+        }
+        associatedInterface = *associatedInterfaceItr;
+        auto mctpTargetProperties = handler.getDbusPropertiesVariant(
+            associatedService.c_str(), associatedObjPath.c_str(),
+            associatedInterface.c_str());
+        auto name = getNameFromProperties(mctpTargetProperties);
+        if (!name.empty())
+        {
+            std::get<std::optional<std::string>>(mctpInfo) = name;
+        }
+        configurations.emplace(associatedObjPath, mctpInfo);
+    }
+    catch (const std::exception& e)
+    {
+        error(
+            "Error getting associated subtree for path {PATH}, error - {ERROR}",
+            "PATH", mctpReactorObjectPath, "ERROR", e);
+        return;
+    }
+}
+
+void MctpDiscovery::removeConfigs(const MctpInfos& removedInfos)
+{
+    for (const auto& mctpInfo : removedInfos)
+    {
+        auto eidToRemove = std::get<eid>(mctpInfo);
+        std::erase_if(configurations, [eidToRemove](const auto& config) {
+            auto& [__, mctpInfo] = config;
+            auto eidValue = std::get<eid>(mctpInfo);
+            return eidValue == eidToRemove;
+        });
+    }
+}
+
 } // namespace pldm
diff --git a/requester/mctp_endpoint_discovery.hpp b/requester/mctp_endpoint_discovery.hpp
index 026e155..7692849 100644
--- a/requester/mctp_endpoint_discovery.hpp
+++ b/requester/mctp_endpoint_discovery.hpp
@@ -11,6 +11,8 @@
 #include <initializer_list>
 #include <vector>
 
+class TestMctpDiscovery;
+
 namespace pldm
 {
 
@@ -21,6 +23,12 @@
 constexpr const char* MCTPPath = "/au/com/codeconstruct/mctp1";
 constexpr const char* MCTPInterfaceCC = "au.com.codeconstruct.MCTP.Endpoint1";
 constexpr const char* MCTPConnectivityProp = "Connectivity";
+constexpr const char* inventorySubtreePathStr =
+    "/xyz/openbmc_project/inventory/system";
+
+const std::vector<std::string> interfaceFilter = {
+    "xyz.openbmc_project.Configuration.MCTPI2CTarget",
+    "xyz.openbmc_project.Configuration.MCTPI3CTarget"};
 
 /** @class MctpDiscoveryHandlerIntf
  *
@@ -42,6 +50,8 @@
     virtual std::optional<mctp_eid_t> getActiveEidByName(
         const std::string& terminusName) = 0;
 
+    virtual void handleConfigurations(const Configurations& /*configurations*/)
+    {}
     virtual ~MctpDiscoveryHandlerIntf() {}
 };
 
@@ -156,6 +166,8 @@
     void removeFromExistingMctpInfos(MctpInfos& mctpInfos,
                                      MctpInfos& removedInfos);
 
+    friend class ::TestMctpDiscovery;
+
   private:
     /** @brief Get MCTP Endpoint D-Bus Properties in the
      *         `xyz.openbmc_project.MCTP.Endpoint` D-Bus interface
@@ -190,6 +202,39 @@
     Availability getEndpointConnectivityProp(const std::string& path);
 
     static constexpr uint8_t mctpTypePLDM = 1;
+
+    /** @brief Construct the MCTP reactor object path
+     *
+     *  @param[in] mctpInfo - information of discovered MCTP endpoint
+     *
+     *  @return the MCTP reactor object path
+     */
+    std::string constructMctpReactorObjectPath(const MctpInfo& mctpInfo);
+
+    /** @brief Search for associated configuration for the MctpInfo.
+     *
+     *  @param[in] mctpInfo - information of discovered MCTP endpoint
+     */
+    void searchConfigurationFor(const pldm::utils::DBusHandler& handler,
+                                MctpInfo& mctpInfo);
+
+    /** @brief Remove configuration associated with the removed MCTP endpoint.
+     *
+     *  @param[in] removedInfos - the removed MCTP endpoints
+     */
+    void removeConfigs(const MctpInfos& removedInfos);
+
+    /** @brief An internal helper function to get the name property from the
+     * properties
+     * @param[in] properties - the properties of the D-Bus object
+     * @return the name property
+     */
+    std::string getNameFromProperties(const utils::PropertyMap& properties);
+
+    /** @brief The configuration contains D-Bus path and the MCTP endpoint
+     * information.
+     */
+    Configurations configurations;
 };
 
 } // namespace pldm
diff --git a/requester/test/mctp_endpoint_discovery_test.cpp b/requester/test/mctp_endpoint_discovery_test.cpp
index 01e5eb0..3647d11 100644
--- a/requester/test/mctp_endpoint_discovery_test.cpp
+++ b/requester/test/mctp_endpoint_discovery_test.cpp
@@ -1,5 +1,6 @@
 #include "config.h"
 
+#include "common/test/mocked_utils.hpp"
 #include "common/types.hpp"
 #include "common/utils.hpp"
 #include "requester/test/mock_mctp_discovery_handler_intf.hpp"
@@ -9,6 +10,22 @@
 
 using ::testing::_;
 
+class TestMctpDiscovery : public ::testing::Test
+{
+  public:
+    static const pldm::Configurations& getConfigurations(
+        const pldm::MctpDiscovery& mctpDiscovery)
+    {
+        return mctpDiscovery.configurations;
+    }
+    static void searchConfigurationFor(pldm::MctpDiscovery& mctpDiscovery,
+                                       pldm::utils::DBusHandler& handler,
+                                       pldm::MctpInfo& mctpInfo)
+    {
+        mctpDiscovery.searchConfigurationFor(handler, mctpInfo);
+    }
+};
+
 TEST(MctpEndpointDiscoveryTest, SingleHandleMctpEndpoint)
 {
     auto& bus = pldm::utils::DBusHandler::getBus();
@@ -53,8 +70,8 @@
     auto& bus = pldm::utils::DBusHandler::getBus();
     pldm::MockManager manager;
     const pldm::MctpInfos& mctpInfos = {
-        pldm::MctpInfo(11, pldm::emptyUUID, "", 1),
-        pldm::MctpInfo(12, pldm::emptyUUID, "abc", 1)};
+        pldm::MctpInfo(11, pldm::emptyUUID, "", 1, std::nullopt),
+        pldm::MctpInfo(12, pldm::emptyUUID, "abc", 1, std::nullopt)};
 
     auto mctpDiscoveryHandler = std::make_unique<pldm::MctpDiscovery>(
         bus, std::initializer_list<pldm::MctpDiscoveryHandlerIntf*>{&manager});
@@ -71,7 +88,7 @@
     auto& bus = pldm::utils::DBusHandler::getBus();
     pldm::MockManager manager;
     const pldm::MctpInfos& mctpInfos = {
-        pldm::MctpInfo(11, pldm::emptyUUID, "", 1)};
+        pldm::MctpInfo(11, pldm::emptyUUID, "", 1, std::nullopt)};
 
     auto mctpDiscoveryHandler = std::make_unique<pldm::MctpDiscovery>(
         bus, std::initializer_list<pldm::MctpDiscoveryHandlerIntf*>{&manager});
@@ -84,8 +101,8 @@
     auto& bus = pldm::utils::DBusHandler::getBus();
     pldm::MockManager manager;
     const pldm::MctpInfos& mctpInfos = {
-        pldm::MctpInfo(11, pldm::emptyUUID, "def", 2),
-        pldm::MctpInfo(12, pldm::emptyUUID, "abc", 1)};
+        pldm::MctpInfo(11, pldm::emptyUUID, "def", 2, std::nullopt),
+        pldm::MctpInfo(12, pldm::emptyUUID, "abc", 1, std::nullopt)};
 
     auto mctpDiscoveryHandler = std::make_unique<pldm::MctpDiscovery>(
         bus, std::initializer_list<pldm::MctpDiscoveryHandlerIntf*>{&manager});
@@ -97,7 +114,8 @@
     EXPECT_EQ(std::get<3>(mctpInfo), 1);
     pldm::MctpInfos removedInfos;
     pldm::MctpInfos remainMctpInfos;
-    remainMctpInfos.emplace_back(pldm::MctpInfo(12, pldm::emptyUUID, "abc", 1));
+    remainMctpInfos.emplace_back(
+        pldm::MctpInfo(12, pldm::emptyUUID, "abc", 1, std::nullopt));
 
     mctpDiscoveryHandler->removeFromExistingMctpInfos(remainMctpInfos,
                                                       removedInfos);
@@ -118,8 +136,8 @@
     auto& bus = pldm::utils::DBusHandler::getBus();
     pldm::MockManager manager;
     const pldm::MctpInfos& mctpInfos = {
-        pldm::MctpInfo(11, pldm::emptyUUID, "def", 2),
-        pldm::MctpInfo(12, pldm::emptyUUID, "abc", 1)};
+        pldm::MctpInfo(11, pldm::emptyUUID, "def", 2, std::nullopt),
+        pldm::MctpInfo(12, pldm::emptyUUID, "abc", 1, std::nullopt)};
 
     auto mctpDiscoveryHandler = std::make_unique<pldm::MctpDiscovery>(
         bus, std::initializer_list<pldm::MctpDiscoveryHandlerIntf*>{&manager});
@@ -136,3 +154,90 @@
     mctpDiscoveryHandler->removeEndpoints(msg);
     EXPECT_EQ(mctpDiscoveryHandler->existingMctpInfos.size(), 0);
 }
+
+TEST(MctpEndpointDiscoveryTest, goodSearchConfigurationFor)
+{
+    MockdBusHandler mockedDbusHandler;
+    auto& bus = mockedDbusHandler.getBus();
+    pldm::MockManager manager;
+    const pldm::MctpInfos& mctpInfos = {
+        pldm::MctpInfo(10, pldm::emptyUUID, "abc", 1, std::nullopt)};
+
+    constexpr auto mockedDbusPath =
+        "/xyz/openbmc_project/inventory/system/board/Mocked_Board_Slot_1/MockedDevice";
+    constexpr auto mockedService = "xyz.openbmc_project.EntityManager";
+    std::vector<std::string> mockedInterfaces{
+        "xyz.openbmc_project.Configuration.MCTPI2CTarget",
+        "xyz.openbmc_project.Configuration.MCTPI3CTarget"};
+
+    pldm::utils::GetAssociatedSubTreeResponse
+        mockedGetAssociatedSubTreeResponse{
+            {mockedDbusPath, {{mockedService, mockedInterfaces}}}};
+
+    EXPECT_CALL(mockedDbusHandler, getAssociatedSubTree(_, _, _, _))
+        .WillOnce(testing::Return(mockedGetAssociatedSubTreeResponse));
+
+    pldm::utils::PropertyMap mockGetI2CTargetPropertiesResponse{
+        {"Address", uint64_t(0x1)},
+        {"Bus", uint64_t(0)},
+        {"Name", std::string("MockedDevice")}};
+
+    EXPECT_CALL(mockedDbusHandler, getDbusPropertiesVariant(_, _, _))
+        .WillOnce(testing::Return(mockGetI2CTargetPropertiesResponse));
+
+    auto mctpDiscoveryHandler = std::make_unique<pldm::MctpDiscovery>(
+        bus, std::initializer_list<pldm::MctpDiscoveryHandlerIntf*>{&manager});
+    mctpDiscoveryHandler->addToExistingMctpInfos(mctpInfos);
+    EXPECT_EQ(mctpDiscoveryHandler->existingMctpInfos.size(), 1);
+    pldm::MctpInfo mctpInfo = mctpDiscoveryHandler->existingMctpInfos.back();
+    EXPECT_EQ(std::get<0>(mctpInfo), 10);
+    EXPECT_EQ(std::get<2>(mctpInfo), "abc");
+    EXPECT_EQ(std::get<3>(mctpInfo), 1);
+    TestMctpDiscovery::searchConfigurationFor(*mctpDiscoveryHandler,
+                                              mockedDbusHandler, mctpInfo);
+    EXPECT_EQ(std::get<4>(mctpInfo),
+              std::optional<std::string>("MockedDevice"));
+    auto configuration =
+        TestMctpDiscovery::getConfigurations(*mctpDiscoveryHandler);
+    EXPECT_EQ(configuration.size(), 1);
+}
+
+TEST(MctpEndpointDiscoveryTest, badSearchConfigurationFor)
+{
+    MockdBusHandler mockedDbusHandler;
+    auto& bus = mockedDbusHandler.getBus();
+    pldm::MockManager manager;
+    const pldm::MctpInfos& mctpInfos = {
+        pldm::MctpInfo(10, pldm::emptyUUID, "abc", 1, std::nullopt)};
+
+    constexpr auto mockedDbusPath =
+        "/xyz/openbmc_project/inventory/system/board/Mocked_Board_Slot_1/MockedDevice";
+    constexpr auto mockedService = "xyz.openbmc_project.EntityManager";
+    std::vector<std::string> mockedInterfaces{
+        "xyz.openbmc_project.Configuration.MCTPPCIETarget",
+        "xyz.openbmc_project.Configuration.MCTPUSBTarget"};
+
+    pldm::utils::GetAssociatedSubTreeResponse
+        mockedGetAssociatedSubTreeResponse{
+            {mockedDbusPath, {{mockedService, mockedInterfaces}}}};
+
+    EXPECT_CALL(mockedDbusHandler, getAssociatedSubTree(_, _, _, _))
+        .WillOnce(testing::Return(mockedGetAssociatedSubTreeResponse));
+
+    pldm::utils::PropertyMap mockGetI2CTargetPropertiesResponse{
+        {"Address", uint64_t(0x1)}, {"Bus", uint64_t(0)}};
+
+    auto mctpDiscoveryHandler = std::make_unique<pldm::MctpDiscovery>(
+        bus, std::initializer_list<pldm::MctpDiscoveryHandlerIntf*>{&manager});
+    mctpDiscoveryHandler->addToExistingMctpInfos(mctpInfos);
+    EXPECT_EQ(mctpDiscoveryHandler->existingMctpInfos.size(), 1);
+    pldm::MctpInfo mctpInfo = mctpDiscoveryHandler->existingMctpInfos.back();
+    EXPECT_EQ(std::get<0>(mctpInfo), 10);
+    EXPECT_EQ(std::get<2>(mctpInfo), "abc");
+    EXPECT_EQ(std::get<3>(mctpInfo), 1);
+    TestMctpDiscovery::searchConfigurationFor(*mctpDiscoveryHandler,
+                                              mockedDbusHandler, mctpInfo);
+    auto configuration =
+        TestMctpDiscovery::getConfigurations(*mctpDiscoveryHandler);
+    EXPECT_EQ(configuration.size(), 0);
+}