diff --git a/src/nvidia-gpu/MctpRequester.cpp b/src/nvidia-gpu/MctpRequester.cpp
new file mode 100644
index 0000000..024f8cc
--- /dev/null
+++ b/src/nvidia-gpu/MctpRequester.cpp
@@ -0,0 +1,162 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION &
+ * AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "MctpRequester.hpp"
+
+#include <linux/mctp.h>
+#include <sys/socket.h>
+
+#include <OcpMctpVdm.hpp>
+#include <boost/asio/buffer.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/generic/datagram_protocol.hpp>
+#include <boost/asio/io_context.hpp>
+#include <boost/asio/steady_timer.hpp>
+#include <phosphor-logging/lg2.hpp>
+
+#include <cerrno>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <functional>
+#include <span>
+#include <utility>
+
+using namespace std::literals;
+
+namespace mctp
+{
+
+MctpRequester::MctpRequester(boost::asio::io_context& ctx) :
+    mctpSocket(ctx, boost::asio::generic::datagram_protocol{AF_MCTP, 0}),
+    expiryTimer(ctx)
+{}
+
+void MctpRequester::processRecvMsg(
+    uint8_t eid, const std::span<const uint8_t> reqMsg,
+    const std::span<uint8_t> respMsg, const boost::system::error_code& ec,
+    const size_t /*length*/)
+{
+    expiryTimer.cancel();
+
+    if (ec)
+    {
+        lg2::error(
+            "MctpRequester failed to receive data from the MCTP socket - ErrorCode={EC}, Error={ER}.",
+            "EC", ec.value(), "ER", ec.message());
+        completionCallback(EIO);
+        return;
+    }
+
+    const auto* respAddr =
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
+        reinterpret_cast<const struct sockaddr_mctp*>(recvEndPoint.data());
+
+    if (respAddr->smctp_type != msgType)
+    {
+        lg2::error("MctpRequester: Message type mismatch");
+        completionCallback(EPROTO);
+        return;
+    }
+
+    uint8_t respEid = respAddr->smctp_addr.s_addr;
+
+    if (respEid != eid)
+    {
+        lg2::error(
+            "MctpRequester: EID mismatch - expected={EID}, received={REID}",
+            "EID", eid, "REID", respEid);
+        completionCallback(EPROTO);
+        return;
+    }
+
+    if (respMsg.size() > sizeof(ocp::accelerator_management::BindingPciVid))
+    {
+        const auto* reqHdr =
+            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
+            reinterpret_cast<const ocp::accelerator_management::BindingPciVid*>(
+                reqMsg.data());
+
+        uint8_t reqInstanceId = reqHdr->instance_id &
+                                ocp::accelerator_management::instanceIdBitMask;
+        const auto* respHdr =
+            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
+            reinterpret_cast<const ocp::accelerator_management::BindingPciVid*>(
+                respMsg.data());
+
+        uint8_t respInstanceId = respHdr->instance_id &
+                                 ocp::accelerator_management::instanceIdBitMask;
+
+        if (reqInstanceId != respInstanceId)
+        {
+            lg2::error(
+                "MctpRequester: Instance ID mismatch - request={REQ}, response={RESP}",
+                "REQ", static_cast<int>(reqInstanceId), "RESP",
+                static_cast<int>(respInstanceId));
+            completionCallback(EPROTO);
+            return;
+        }
+    }
+
+    completionCallback(0);
+}
+
+void MctpRequester::handleSendMsgCompletion(
+    uint8_t eid, const std::span<const uint8_t> reqMsg,
+    std::span<uint8_t> respMsg, const boost::system::error_code& ec,
+    size_t /* length */)
+{
+    if (ec)
+    {
+        lg2::error(
+            "MctpRequester failed to send data from the MCTP socket - ErrorCode={EC}, Error={ER}.",
+            "EC", ec.value(), "ER", ec.message());
+        completionCallback(EIO);
+        return;
+    }
+
+    expiryTimer.expires_after(2s);
+
+    expiryTimer.async_wait([this](const boost::system::error_code& ec) {
+        if (ec != boost::asio::error::operation_aborted)
+        {
+            completionCallback(ETIME);
+        }
+    });
+
+    mctpSocket.async_receive_from(
+        boost::asio::mutable_buffer(respMsg), recvEndPoint,
+        std::bind_front(&MctpRequester::processRecvMsg, this, eid, reqMsg,
+                        respMsg));
+}
+
+void MctpRequester::sendRecvMsg(
+    uint8_t eid, const std::span<const uint8_t> reqMsg,
+    std::span<uint8_t> respMsg, std::move_only_function<void(int)> callback)
+{
+    if (reqMsg.size() < sizeof(ocp::accelerator_management::BindingPciVid))
+    {
+        lg2::error("MctpRequester: Message too small");
+        callback(EPROTO);
+        return;
+    }
+
+    completionCallback = std::move(callback);
+
+    struct sockaddr_mctp addr{};
+    addr.smctp_family = AF_MCTP;
+    addr.smctp_addr.s_addr = eid;
+    addr.smctp_type = msgType;
+    addr.smctp_tag = MCTP_TAG_OWNER;
+
+    sendEndPoint = {&addr, sizeof(addr)};
+
+    mctpSocket.async_send_to(
+        boost::asio::const_buffer(reqMsg), sendEndPoint,
+        std::bind_front(&MctpRequester::handleSendMsgCompletion, this, eid,
+                        reqMsg, respMsg));
+}
+} // namespace mctp
diff --git a/src/nvidia-gpu/MctpRequester.hpp b/src/nvidia-gpu/MctpRequester.hpp
new file mode 100644
index 0000000..289e800
--- /dev/null
+++ b/src/nvidia-gpu/MctpRequester.hpp
@@ -0,0 +1,64 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION &
+ * AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <OcpMctpVdm.hpp>
+#include <boost/asio/generic/datagram_protocol.hpp>
+#include <boost/asio/io_context.hpp>
+#include <boost/asio/steady_timer.hpp>
+
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <span>
+
+namespace mctp
+{
+class MctpRequester
+{
+  public:
+    MctpRequester() = delete;
+
+    MctpRequester(const MctpRequester&) = delete;
+
+    MctpRequester(MctpRequester&&) = delete;
+
+    MctpRequester& operator=(const MctpRequester&) = delete;
+
+    MctpRequester& operator=(MctpRequester&&) = delete;
+
+    explicit MctpRequester(boost::asio::io_context& ctx);
+
+    void sendRecvMsg(uint8_t eid, std::span<const uint8_t> reqMsg,
+                     std::span<uint8_t> respMsg,
+                     std::move_only_function<void(int)> callback);
+
+  private:
+    void processRecvMsg(uint8_t eid, std::span<const uint8_t> reqMsg,
+                        std::span<uint8_t> respMsg,
+                        const boost::system::error_code& ec, size_t length);
+
+    void handleSendMsgCompletion(uint8_t eid, std::span<const uint8_t> reqMsg,
+                                 std::span<uint8_t> respMsg,
+                                 const boost::system::error_code& ec,
+                                 size_t length);
+
+    boost::asio::generic::datagram_protocol::socket mctpSocket;
+
+    static constexpr size_t maxMessageSize = 65536 + 256;
+
+    boost::asio::generic::datagram_protocol::endpoint sendEndPoint;
+
+    boost::asio::generic::datagram_protocol::endpoint recvEndPoint;
+
+    boost::asio::steady_timer expiryTimer;
+
+    std::move_only_function<void(int)> completionCallback;
+
+    static constexpr uint8_t msgType = ocp::accelerator_management::messageType;
+};
+} // namespace mctp
diff --git a/src/nvidia-gpu/NvidiaGpuMctpVdm.cpp b/src/nvidia-gpu/NvidiaGpuMctpVdm.cpp
new file mode 100644
index 0000000..17f71e0
--- /dev/null
+++ b/src/nvidia-gpu/NvidiaGpuMctpVdm.cpp
@@ -0,0 +1,156 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION &
+ * AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "NvidiaGpuMctpVdm.hpp"
+
+#include "OcpMctpVdm.hpp"
+
+#include <endian.h>
+
+#include <cerrno>
+#include <cstdint>
+#include <cstring>
+#include <span>
+
+namespace gpu
+{
+// These functions encode/decode data communicated over the network
+// The use of reinterpret_cast enables direct memory access to raw byte buffers
+// without doing unnecessary data copying
+// NOLINTBEGIN(cppcoreguidelines-pro-type-reinterpret-cast)
+int packHeader(const ocp::accelerator_management::BindingPciVidInfo& hdr,
+               ocp::accelerator_management::BindingPciVid& msg)
+{
+    return ocp::accelerator_management::packHeader(nvidiaPciVendorId, hdr, msg);
+}
+
+int encodeQueryDeviceIdentificationRequest(uint8_t instanceId,
+                                           const std::span<uint8_t> buf)
+{
+    if (buf.size() < sizeof(QueryDeviceIdentificationRequest))
+    {
+        return EINVAL;
+    }
+
+    auto* msg = reinterpret_cast<QueryDeviceIdentificationRequest*>(buf.data());
+
+    ocp::accelerator_management::BindingPciVidInfo header{};
+
+    header.ocp_accelerator_management_msg_type =
+        static_cast<uint8_t>(ocp::accelerator_management::MessageType::REQUEST);
+    header.instance_id = instanceId &
+                         ocp::accelerator_management::instanceIdBitMask;
+    header.msg_type =
+        static_cast<uint8_t>(MessageType::DEVICE_CAPABILITY_DISCOVERY);
+
+    auto rc = packHeader(header, msg->hdr.msgHdr.hdr);
+
+    if (rc != 0)
+    {
+        return rc;
+    }
+
+    msg->hdr.command = static_cast<uint8_t>(
+        DeviceCapabilityDiscoveryCommands::QUERY_DEVICE_IDENTIFICATION);
+    msg->hdr.data_size = 0;
+
+    return 0;
+}
+
+int decodeQueryDeviceIdentificationResponse(
+    const std::span<const uint8_t> buf,
+    ocp::accelerator_management::CompletionCode& cc, uint16_t& reasonCode,
+    uint8_t& deviceIdentification, uint8_t& deviceInstance)
+{
+    auto rc =
+        ocp::accelerator_management::decodeReasonCodeAndCC(buf, cc, reasonCode);
+
+    if (rc != 0 || cc != ocp::accelerator_management::CompletionCode::SUCCESS)
+    {
+        return rc;
+    }
+
+    if (buf.size() < sizeof(QueryDeviceIdentificationResponse))
+    {
+        return EINVAL;
+    }
+
+    const auto* response =
+        reinterpret_cast<const QueryDeviceIdentificationResponse*>(buf.data());
+
+    deviceIdentification = response->device_identification;
+    deviceInstance = response->instance_id;
+
+    return 0;
+}
+
+int encodeGetTemperatureReadingRequest(uint8_t instanceId, uint8_t sensorId,
+                                       std::span<uint8_t> buf)
+{
+    if (buf.size() < sizeof(GetTemperatureReadingRequest))
+    {
+        return EINVAL;
+    }
+
+    auto* msg = reinterpret_cast<GetTemperatureReadingRequest*>(buf.data());
+
+    ocp::accelerator_management::BindingPciVidInfo header{};
+    header.ocp_accelerator_management_msg_type =
+        static_cast<uint8_t>(ocp::accelerator_management::MessageType::REQUEST);
+    header.instance_id = instanceId &
+                         ocp::accelerator_management::instanceIdBitMask;
+    header.msg_type = static_cast<uint8_t>(MessageType::PLATFORM_ENVIRONMENTAL);
+
+    auto rc = packHeader(header, msg->hdr.msgHdr.hdr);
+
+    if (rc != 0)
+    {
+        return rc;
+    }
+
+    msg->hdr.command = static_cast<uint8_t>(
+        PlatformEnvironmentalCommands::GET_TEMPERATURE_READING);
+    msg->hdr.data_size = sizeof(sensorId);
+    msg->sensor_id = sensorId;
+
+    return 0;
+}
+
+int decodeGetTemperatureReadingResponse(
+    const std::span<const uint8_t> buf,
+    ocp::accelerator_management::CompletionCode& cc, uint16_t& reasonCode,
+    double& temperatureReading)
+{
+    auto rc =
+        ocp::accelerator_management::decodeReasonCodeAndCC(buf, cc, reasonCode);
+
+    if (rc != 0 || cc != ocp::accelerator_management::CompletionCode::SUCCESS)
+    {
+        return rc;
+    }
+
+    if (buf.size() < sizeof(GetTemperatureReadingResponse))
+    {
+        return EINVAL;
+    }
+
+    const auto* response =
+        reinterpret_cast<const GetTemperatureReadingResponse*>(buf.data());
+
+    uint16_t dataSize = le16toh(response->hdr.data_size);
+
+    if (dataSize != sizeof(int32_t))
+    {
+        return EINVAL;
+    }
+
+    int32_t reading = le32toh(response->reading);
+    temperatureReading = reading / static_cast<double>(1 << 8);
+
+    return 0;
+}
+// NOLINTEND(cppcoreguidelines-pro-type-reinterpret-cast)
+} // namespace gpu
diff --git a/src/nvidia-gpu/NvidiaGpuMctpVdm.hpp b/src/nvidia-gpu/NvidiaGpuMctpVdm.hpp
new file mode 100644
index 0000000..ce3b393
--- /dev/null
+++ b/src/nvidia-gpu/NvidiaGpuMctpVdm.hpp
@@ -0,0 +1,85 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION &
+ * AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <OcpMctpVdm.hpp>
+
+#include <cstdint>
+#include <span>
+
+namespace gpu
+{
+
+constexpr uint16_t nvidiaPciVendorId = 0x10de;
+
+enum class MessageType : uint8_t
+{
+    DEVICE_CAPABILITY_DISCOVERY = 0,
+    PLATFORM_ENVIRONMENTAL = 3
+};
+
+enum class DeviceCapabilityDiscoveryCommands : uint8_t
+{
+    QUERY_DEVICE_IDENTIFICATION = 0x09,
+};
+
+enum class PlatformEnvironmentalCommands : uint8_t
+{
+    GET_TEMPERATURE_READING = 0x00,
+};
+
+enum class DeviceIdentification : uint8_t
+{
+    DEVICE_GPU = 0
+};
+
+struct QueryDeviceIdentificationRequest
+{
+    ocp::accelerator_management::CommonRequest hdr;
+} __attribute__((packed));
+
+struct QueryDeviceIdentificationResponse
+{
+    ocp::accelerator_management::CommonResponse hdr;
+    uint8_t device_identification;
+    uint8_t instance_id;
+} __attribute__((packed));
+
+struct GetNumericSensorReadingRequest
+{
+    ocp::accelerator_management::CommonRequest hdr;
+    uint8_t sensor_id;
+} __attribute__((packed));
+
+using GetTemperatureReadingRequest = GetNumericSensorReadingRequest;
+
+struct GetTemperatureReadingResponse
+{
+    ocp::accelerator_management::CommonResponse hdr;
+    int32_t reading;
+} __attribute__((packed));
+
+int packHeader(const ocp::accelerator_management::BindingPciVidInfo& hdr,
+               ocp::accelerator_management::BindingPciVid& msg);
+
+int encodeQueryDeviceIdentificationRequest(uint8_t instanceId,
+                                           std::span<uint8_t> buf);
+
+int decodeQueryDeviceIdentificationResponse(
+    std::span<const uint8_t> buf,
+    ocp::accelerator_management::CompletionCode& cc, uint16_t& reasonCode,
+    uint8_t& deviceIdentification, uint8_t& deviceInstance);
+
+int encodeGetTemperatureReadingRequest(uint8_t instanceId, uint8_t sensorId,
+                                       std::span<uint8_t> buf);
+
+int decodeGetTemperatureReadingResponse(
+    std::span<const uint8_t> buf,
+    ocp::accelerator_management::CompletionCode& cc, uint16_t& reasonCode,
+    double& temperatureReading);
+
+} // namespace gpu
diff --git a/src/nvidia-gpu/NvidiaGpuSensor.cpp b/src/nvidia-gpu/NvidiaGpuSensor.cpp
index 3594c29..86b356b 100644
--- a/src/nvidia-gpu/NvidiaGpuSensor.cpp
+++ b/src/nvidia-gpu/NvidiaGpuSensor.cpp
@@ -1,16 +1,21 @@
 /*
  * SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION &
- * AFFILIATES. All rights reserved. SPDX-License-Identifier: Apache-2.0
+ * AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
  */
 
 #include "NvidiaGpuSensor.hpp"
 
+#include "SensorPaths.hpp"
 #include "Thresholds.hpp"
 #include "Utils.hpp"
 #include "sensor.hpp"
 
 #include <bits/basic_string.h>
 
+#include <MctpRequester.hpp>
+#include <NvidiaGpuMctpVdm.hpp>
+#include <OcpMctpVdm.hpp>
 #include <boost/asio/io_context.hpp>
 #include <boost/container/flat_map.hpp>
 #include <phosphor-logging/lg2.hpp>
@@ -23,6 +28,7 @@
 #include <chrono>
 #include <cstddef>
 #include <cstdint>
+#include <functional>
 #include <memory>
 #include <string>
 #include <utility>
@@ -31,20 +37,23 @@
 
 using namespace std::literals;
 
+constexpr uint8_t gpuTempSensorId{0};
 static constexpr double gpuTempSensorMaxReading = 127;
 static constexpr double gpuTempSensorMinReading = -128;
 
 GpuTempSensor::GpuTempSensor(
     std::shared_ptr<sdbusplus::asio::connection>& conn,
-    boost::asio::io_context& io, const std::string& name,
-    const std::string& sensorConfiguration,
+    boost::asio::io_context& io, mctp::MctpRequester& mctpRequester,
+    const std::string& name, const std::string& sensorConfiguration,
     sdbusplus::asio::object_server& objectServer,
-    std::vector<thresholds::Threshold>&& thresholdData) :
+    std::vector<thresholds::Threshold>&& thresholdData,
+    std::chrono::milliseconds pollRate) :
     Sensor(escapeName(name), std::move(thresholdData), sensorConfiguration,
            "temperature", false, true, gpuTempSensorMaxReading,
            gpuTempSensorMinReading, conn),
-    waitTimer(io, std::chrono::steady_clock::duration(0)), conn(conn),
-    objectServer(objectServer)
+    sensorId{gpuTempSensorId}, sensorPollMs(pollRate),
+    waitTimer(io, std::chrono::steady_clock::duration(0)),
+    mctpRequester(mctpRequester), conn(conn), objectServer(objectServer)
 {
     std::string dbusPath =
         sensorPathPrefix + "temperature/"s + escapeName(name);
@@ -115,6 +124,129 @@
     }
 }
 
+void GpuTempSensor::read()
+{
+    update();
+
+    waitTimer.expires_after(std::chrono::milliseconds(sensorPollMs));
+    waitTimer.async_wait(
+        [weakPtrToThis = std::weak_ptr<GpuTempSensor>{shared_from_this()}](
+            const boost::system::error_code& ec) {
+            if (ec)
+            {
+                return;
+            }
+            if (auto ptr = weakPtrToThis.lock())
+            {
+                ptr->read();
+            }
+        });
+}
+
+void GpuTempSensor::processResponse(int sendRecvMsgResult)
+{
+    if (sendRecvMsgResult != 0)
+    {
+        lg2::error(
+            "Error updating Temperature Sensor: sending message over MCTP failed, rc={RC}",
+            "RC", sendRecvMsgResult);
+        return;
+    }
+
+    ocp::accelerator_management::CompletionCode cc{};
+    uint16_t reasonCode = 0;
+    double tempValue = 0;
+
+    auto rc = gpu::decodeGetTemperatureReadingResponse(
+        getTemperatureReadingResponse, cc, reasonCode, tempValue);
+
+    if (rc != 0 || cc != ocp::accelerator_management::CompletionCode::SUCCESS)
+    {
+        lg2::error(
+            "Error updating Temperature Sensor: decode failed, rc={RC}, cc={CC}, reasonCode={RESC}",
+            "RC", rc, "CC", cc, "RESC", reasonCode);
+        return;
+    }
+
+    updateValue(tempValue);
+}
+
+void GpuTempSensor::update()
+{
+    auto rc = gpu::encodeGetTemperatureReadingRequest(
+        0, sensorId, getTemperatureReadingRequest);
+    if (rc != 0)
+    {
+        lg2::error("Error updating Temperature Sensor: encode failed, rc={RC}",
+                   "RC", rc);
+        return;
+    }
+
+    mctpRequester.sendRecvMsg(
+        eid, getTemperatureReadingRequest, getTemperatureReadingResponse,
+        [this](int sendRecvMsgResult) { processResponse(sendRecvMsgResult); });
+}
+
+void GpuTempSensor::processQueryDeviceIdResponse(uint8_t eid,
+                                                 int sendRecvMsgResult)
+{
+    if (sendRecvMsgResult != 0)
+    {
+        lg2::error(
+            "Error processing GPU endpoint: sending message over MCTP failed, rc={RC}",
+            "RC", sendRecvMsgResult);
+        return;
+    }
+
+    ocp::accelerator_management::CompletionCode cc{};
+    uint16_t reasonCode = 0;
+    uint8_t responseDeviceType = 0;
+    uint8_t responseInstanceId = 0;
+
+    auto rc = gpu::decodeQueryDeviceIdentificationResponse(
+        queryDeviceIdentificationResponse, cc, reasonCode, responseDeviceType,
+        responseInstanceId);
+
+    if (rc != 0 || cc != ocp::accelerator_management::CompletionCode::SUCCESS)
+    {
+        lg2::error(
+            "Error processing GPU endpoint: decode failed, rc={RC}, cc={CC}, reasonCode={RESC}",
+            "RC", rc, "CC", cc, "RESC", reasonCode);
+        return;
+    }
+
+    if (responseDeviceType ==
+        static_cast<uint8_t>(gpu::DeviceIdentification::DEVICE_GPU))
+    {
+        lg2::info(
+            "Found the GPU with EID {EID}, DeviceType {DEVTYPE}, InstanceId {IID}.",
+            "EID", eid, "DEVTYPE", responseDeviceType, "IID",
+            responseInstanceId);
+
+        this->eid = eid;
+        setInitialProperties(sensor_paths::unitDegreesC);
+        read();
+    }
+}
+
+void GpuTempSensor::processGpuEndpoint(uint8_t eid)
+{
+    auto rc = gpu::encodeQueryDeviceIdentificationRequest(
+        0, queryDeviceIdentificationRequest);
+    if (rc != 0)
+    {
+        lg2::error("Error processing GPU endpoint: encode failed, rc={RC}",
+                   "RC", rc);
+        return;
+    }
+
+    mctpRequester.sendRecvMsg(
+        eid, queryDeviceIdentificationRequest,
+        queryDeviceIdentificationResponse, [this, eid](int sendRecvMsgResult) {
+            processQueryDeviceIdResponse(eid, sendRecvMsgResult);
+        });
+}
+
 void GpuTempSensor::processEndpoint(const boost::system::error_code& ec,
                                     const SensorBaseConfigMap& endpoint)
 {
@@ -125,7 +257,7 @@
         return;
     }
 
-    [[maybe_unused]] uint8_t eid{};
+    uint8_t eid{};
     std::vector<uint8_t> mctpTypes{};
 
     auto hasEid = endpoint.find("EID");
@@ -173,9 +305,14 @@
         return;
     }
 
-    // if the OCP MCTP VDM Message type (0x7E) is found in mctpTypes
-    // process the endpoint further.
-    (void)this;
+    if (std::find(mctpTypes.begin(), mctpTypes.end(),
+                  ocp::accelerator_management::messageType) != mctpTypes.end())
+    {
+        lg2::info(
+            "GpuTempSensor::discoverGpus(): Found OCP MCTP VDM Endpoint with ID {EID}",
+            "EID", eid);
+        this->processGpuEndpoint(eid);
+    }
 }
 
 void GpuTempSensor::discoverGpus()
@@ -198,7 +335,7 @@
     boost::container::flat_map<std::string, std::shared_ptr<GpuTempSensor>>&
         sensors,
     std::shared_ptr<sdbusplus::asio::connection>& dbusConnection,
-    const ManagedObjectType& resp)
+    mctp::MctpRequester& mctpRequester, const ManagedObjectType& resp)
 {
     for (const auto& [path, interfaces] : resp)
     {
@@ -211,9 +348,12 @@
 
             std::string name = loadVariant<std::string>(cfg, "Name");
 
+            uint64_t pollRate = loadVariant<uint64_t>(cfg, "PollRate");
+
             sensors[name] = std::make_shared<GpuTempSensor>(
-                dbusConnection, io, name, path, objectServer,
-                std::vector<thresholds::Threshold>{});
+                dbusConnection, io, mctpRequester, name, path, objectServer,
+                std::vector<thresholds::Threshold>{},
+                std::chrono::milliseconds{pollRate});
 
             lg2::info(
                 "Added GPU Temperature Sensor {NAME} with chassis path: {PATH}.",
@@ -226,7 +366,8 @@
     boost::asio::io_context& io, sdbusplus::asio::object_server& objectServer,
     boost::container::flat_map<std::string, std::shared_ptr<GpuTempSensor>>&
         sensors,
-    std::shared_ptr<sdbusplus::asio::connection>& dbusConnection)
+    std::shared_ptr<sdbusplus::asio::connection>& dbusConnection,
+    mctp::MctpRequester& mctpRequester)
 {
     if (!dbusConnection)
     {
@@ -234,7 +375,7 @@
         return;
     }
     dbusConnection->async_method_call(
-        [&sensors, &dbusConnection, &io,
+        [&sensors, &mctpRequester, &dbusConnection, &io,
          &objectServer](const boost::system::error_code& ec,
                         const ManagedObjectType& resp) {
             if (ec)
@@ -244,7 +385,7 @@
             }
 
             processSensorConfigs(io, objectServer, sensors, dbusConnection,
-                                 resp);
+                                 mctpRequester, resp);
         },
         entityManagerName, "/xyz/openbmc_project/inventory",
         "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
diff --git a/src/nvidia-gpu/NvidiaGpuSensor.hpp b/src/nvidia-gpu/NvidiaGpuSensor.hpp
index 14627fc..158dc41 100644
--- a/src/nvidia-gpu/NvidiaGpuSensor.hpp
+++ b/src/nvidia-gpu/NvidiaGpuSensor.hpp
@@ -1,14 +1,18 @@
 /*
  * SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION &
- * AFFILIATES. All rights reserved. SPDX-License-Identifier: Apache-2.0
+ * AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
  */
 
 #pragma once
 
+#include "MctpRequester.hpp"
 #include "Thresholds.hpp"
 #include "Utils.hpp"
 #include "sensor.hpp"
 
+#include <NvidiaGpuMctpVdm.hpp>
+#include <OcpMctpVdm.hpp>
 #include <boost/asio/io_context.hpp>
 #include <boost/asio/steady_timer.hpp>
 #include <boost/container/flat_map.hpp>
@@ -16,6 +20,9 @@
 #include <sdbusplus/asio/object_server.hpp>
 #include <sdbusplus/message.hpp>
 
+#include <array>
+#include <chrono>
+#include <cstdint>
 #include <memory>
 #include <string>
 #include <vector>
@@ -28,95 +35,74 @@
     public std::enable_shared_from_this<GpuTempSensor>
 {
   public:
-    /**
-     * @brief Constructor for GpuTempSensor
-     * @param conn D-Bus connection
-     * @param io Boost ASIO I/O context for asynchronous operations
-     * @param mctpRequester MCTP protocol requester for GPU communication
-     * @param name Name of the sensor
-     * @param sensorConfiguration Configuration string for the sensor
-     * @param objectServer D-Bus object server
-     * @param thresholdData Vector of threshold configurations
-     * @param pollRate How often to poll for new readings
-     * @param deviceInfo Information about the GPU device
-     * @param verbose Whether to enable verbose logging
-     */
     GpuTempSensor(std::shared_ptr<sdbusplus::asio::connection>& conn,
-                  boost::asio::io_context& io, const std::string& name,
+                  boost::asio::io_context& io,
+                  mctp::MctpRequester& mctpRequester, const std::string& name,
                   const std::string& sensorConfiguration,
                   sdbusplus::asio::object_server& objectServer,
-                  std::vector<thresholds::Threshold>&& thresholdData);
+                  std::vector<thresholds::Threshold>&& thresholdData,
+                  std::chrono::milliseconds pollRate);
 
-    /**
-     * @brief Destructor
-     */
     ~GpuTempSensor() override;
 
-    /**
-     * @brief Check if any thresholds have been crossed
-     * @details Overrides the base class method to implement GPU-specific
-     * threshold checking
-     */
     void checkThresholds() override;
 
   private:
-    /**
-     * @brief Discover available GPUs on the system
-     */
+    void read();
+
+    void update();
+
     void discoverGpus();
 
-    /**
-     * @brief Process MCTP endpoints discovered on the system
-     *
-     * @param[in] ec Error code from the D-Bus method call
-     * @param[in] ret Object tree results containing MCTP endpoint information
-     */
+    void processResponse(int sendRecvMsgResult);
+
+    void processQueryDeviceIdResponse(uint8_t eid, int sendRecvMsgResult);
+
     void queryEndpoints(const boost::system::error_code& ec,
                         const GetSubTreeType& ret);
 
-    /**
-     * @brief Process configuration properties for MCTP endpoints
-     *
-     * @param[in] ec Error code from the D-Bus properties method call
-     * @param[in] configs Map of configuration properties for the endpoint
-     */
     void processEndpoint(const boost::system::error_code& ec,
                          const SensorBaseConfigMap& endpoint);
+    void processGpuEndpoint(uint8_t eid);
 
-    /**
-     * @brief Timer for scheduling sensor reads
-     */
+    uint8_t eid{};
+
+    uint8_t sensorId;
+
+    std::chrono::milliseconds sensorPollMs;
+
     boost::asio::steady_timer waitTimer;
 
-    /**
-     * @brief D-Bus connection
-     */
+    mctp::MctpRequester& mctpRequester;
+
     std::shared_ptr<sdbusplus::asio::connection> conn;
 
-    /**
-     * @brief D-Bus object server
-     */
     sdbusplus::asio::object_server& objectServer;
+
+    std::array<uint8_t, sizeof(ocp::accelerator_management::Message) +
+                            sizeof(gpu::GetTemperatureReadingRequest)>
+        getTemperatureReadingRequest{};
+
+    std::array<uint8_t, sizeof(ocp::accelerator_management::Message) +
+                            sizeof(gpu::GetTemperatureReadingResponse)>
+        getTemperatureReadingResponse{};
+
+    std::array<uint8_t, sizeof(ocp::accelerator_management::Message) +
+                            sizeof(gpu::QueryDeviceIdentificationRequest)>
+        queryDeviceIdentificationRequest{};
+
+    std::array<uint8_t, sizeof(ocp::accelerator_management::Message) +
+                            sizeof(gpu::QueryDeviceIdentificationResponse)>
+        queryDeviceIdentificationResponse{};
 };
 
-/**
- * @brief Create GPU temperature sensors
- * @param io Boost ASIO I/O context
- * @param objectServer D-Bus object server
- * @param sensors Map to store created sensors
- * @param dbusConnection D-Bus connection
- */
 void createSensors(
     boost::asio::io_context& io, sdbusplus::asio::object_server& objectServer,
     boost::container::flat_map<std::string, std::shared_ptr<GpuTempSensor>>&
         sensors,
-    std::shared_ptr<sdbusplus::asio::connection>& dbusConnection);
+    std::shared_ptr<sdbusplus::asio::connection>& dbusConnection,
+    mctp::MctpRequester& mctpRequester);
 
-/**
- * @brief Handle D-Bus interface removal events
- * @param message D-Bus message containing interface removal information
- * @param sensors Map of GPU temperature sensors to check for removal
- */
 void interfaceRemoved(
     sdbusplus::message_t& message,
     boost::container::flat_map<std::string, std::shared_ptr<GpuTempSensor>>&
diff --git a/src/nvidia-gpu/NvidiaGpuSensorMain.cpp b/src/nvidia-gpu/NvidiaGpuSensorMain.cpp
index 9879c2c..cf764d3 100644
--- a/src/nvidia-gpu/NvidiaGpuSensorMain.cpp
+++ b/src/nvidia-gpu/NvidiaGpuSensorMain.cpp
@@ -1,8 +1,10 @@
 /*
  * SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION &
- * AFFILIATES. All rights reserved. SPDX-License-Identifier: Apache-2.0
+ * AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
  */
 
+#include "MctpRequester.hpp"
 #include "NvidiaGpuSensor.hpp"
 #include "Utils.hpp"
 
@@ -30,13 +32,13 @@
 void configTimerExpiryCallback(
     boost::asio::io_context& io, sdbusplus::asio::object_server& objectServer,
     std::shared_ptr<sdbusplus::asio::connection>& dbusConnection,
-    const boost::system::error_code& ec)
+    mctp::MctpRequester& mctpRequester, const boost::system::error_code& ec)
 {
     if (ec == boost::asio::error::operation_aborted)
     {
         return; // we're being canceled
     }
-    createSensors(io, objectServer, sensors, dbusConnection);
+    createSensors(io, objectServer, sensors, dbusConnection, mctpRequester);
     if (sensors.empty())
     {
         lg2::info("Configuration not detected");
@@ -51,19 +53,22 @@
     objectServer.add_manager("/xyz/openbmc_project/sensors");
     systemBus->request_name("xyz.openbmc_project.GpuSensor");
 
+    mctp::MctpRequester mctpRequester(io);
+
     boost::asio::post(io, [&]() {
-        createSensors(io, objectServer, sensors, systemBus);
+        createSensors(io, objectServer, sensors, systemBus, mctpRequester);
     });
 
     boost::asio::steady_timer configTimer(io);
 
     std::function<void(sdbusplus::message_t&)> eventHandler =
-        [&configTimer, &io, &objectServer, &systemBus](sdbusplus::message_t&) {
+        [&configTimer, &io, &objectServer, &systemBus,
+         &mctpRequester](sdbusplus::message_t&) {
             configTimer.expires_after(std::chrono::seconds(1));
             // create a timer because normally multiple properties change
-            configTimer.async_wait(
-                std::bind_front(configTimerExpiryCallback, std::ref(io),
-                                std::ref(objectServer), std::ref(systemBus)));
+            configTimer.async_wait(std::bind_front(
+                configTimerExpiryCallback, std::ref(io), std::ref(objectServer),
+                std::ref(systemBus), std::ref(mctpRequester)));
         };
 
     std::vector<std::unique_ptr<sdbusplus::bus::match_t>> matches =
diff --git a/src/nvidia-gpu/OcpMctpVdm.cpp b/src/nvidia-gpu/OcpMctpVdm.cpp
new file mode 100644
index 0000000..6497621
--- /dev/null
+++ b/src/nvidia-gpu/OcpMctpVdm.cpp
@@ -0,0 +1,88 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION &
+ * AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "OcpMctpVdm.hpp"
+
+#include <endian.h>
+
+#include <cerrno>
+#include <cstdint>
+#include <cstring>
+#include <span>
+
+namespace ocp
+{
+namespace accelerator_management
+{
+
+int packHeader(uint16_t pciVendorId, const BindingPciVidInfo& hdr,
+               BindingPciVid& msg)
+{
+    if (hdr.ocp_accelerator_management_msg_type !=
+            static_cast<uint8_t>(MessageType::RESPONSE) &&
+        hdr.ocp_accelerator_management_msg_type !=
+            static_cast<uint8_t>(MessageType::REQUEST))
+    {
+        return EINVAL;
+    }
+
+    if (hdr.instance_id > instanceMax)
+    {
+        return EINVAL;
+    }
+
+    msg.instance_id = hdr.instance_id & instanceIdBitMask;
+
+    if (hdr.ocp_accelerator_management_msg_type ==
+        static_cast<uint8_t>(MessageType::REQUEST))
+    {
+        msg.instance_id |= requestBitMask;
+    }
+    else
+    {
+        msg.instance_id &= ~requestBitMask;
+    }
+
+    msg.pci_vendor_id = htobe16(pciVendorId);
+    msg.instance_id &= ~instanceIdReservedBitMask;
+    msg.ocp_version = ocpVersion & ocpVersionBitMask;
+    msg.ocp_version |= (ocpType << ocpTypeBitOffset) & ocpTypeBitMask;
+    msg.ocp_accelerator_management_msg_type = hdr.msg_type;
+
+    return 0;
+}
+
+int decodeReasonCodeAndCC(const std::span<const uint8_t> buf,
+                          CompletionCode& cc, uint16_t& reasonCode)
+{
+    if (buf.size() <
+        sizeof(ocp::accelerator_management::CommonNonSuccessResponse))
+    {
+        return EINVAL;
+    }
+
+    // These expression decodes data communicated over the network
+    // The use of reinterpret_cast enables direct memory access to raw byte
+    // buffers without doing unnecessary data copying
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
+    const auto* response = reinterpret_cast<
+        const ocp::accelerator_management::CommonNonSuccessResponse*>(
+        buf.data());
+
+    cc = static_cast<CompletionCode>(response->completion_code);
+    if (cc == CompletionCode::SUCCESS)
+    {
+        reasonCode = 0;
+        return 0;
+    }
+
+    // reason code is expected to be present if CC != SUCCESS
+    reasonCode = le16toh(response->reason_code);
+
+    return 0;
+}
+} // namespace accelerator_management
+} // namespace ocp
diff --git a/src/nvidia-gpu/OcpMctpVdm.hpp b/src/nvidia-gpu/OcpMctpVdm.hpp
new file mode 100644
index 0000000..735d0a5
--- /dev/null
+++ b/src/nvidia-gpu/OcpMctpVdm.hpp
@@ -0,0 +1,107 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION &
+ * AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <span>
+
+namespace ocp
+{
+namespace accelerator_management
+{
+
+constexpr uint8_t messageType = 0x7E;
+
+constexpr uint8_t ocpType = 8;
+constexpr uint8_t ocpVersion = 9;
+constexpr uint8_t ocpTypeBitOffset = 4;
+constexpr uint8_t ocpTypeBitMask = 0b11110000;
+constexpr uint8_t ocpVersionBitMask = 0b00001111;
+constexpr uint8_t instanceIdBitMask = 0b00011111;
+constexpr uint8_t instanceIdReservedBitMask = 0b00100000;
+constexpr uint8_t datagramBitMask = 0b01000000;
+constexpr uint8_t requestBitMask = 0b10000000;
+
+constexpr uint8_t instanceMin = 0;
+constexpr uint8_t instanceMax = 31;
+
+enum class CompletionCode : uint8_t
+{
+    SUCCESS = 0x00,
+    ERROR = 0x01,
+    ERR_INVALID_DATA = 0x02,
+    ERR_INVALID_DATA_LENGTH = 0x03,
+    ERR_NOT_READY = 0x04,
+    ERR_UNSUPPORTED_COMMAND_CODE = 0x05,
+    ERR_UNSUPPORTED_MSG_TYPE = 0x06,
+    ERR_BUS_ACCESS = 0x7f,
+    ERR_NULL = 0x80,
+};
+
+enum class ReasonCode : uint16_t
+{
+    REASON_NONE = 0x00,
+};
+
+enum class MessageType : uint8_t
+{
+    RESPONSE = 0, //!< OCP MCTP VDM response message
+    REQUEST = 2,  //!< OCP MCTP VDM request message
+};
+
+struct BindingPciVid
+{
+    uint16_t pci_vendor_id;                      //!< PCI defined vendor ID
+    uint8_t instance_id;                         //!< Instance ID
+    uint8_t ocp_version;                         //!< OCP version
+    uint8_t ocp_accelerator_management_msg_type; //!< Message Type
+} __attribute__((packed));
+
+struct Message
+{
+    BindingPciVid hdr; //!< OCP MCTP VDM message header
+} __attribute__((packed));
+
+struct BindingPciVidInfo
+{
+    uint8_t ocp_accelerator_management_msg_type;
+    uint8_t instance_id;
+    uint8_t msg_type;
+};
+
+struct CommonRequest
+{
+    Message msgHdr;
+    uint8_t command;
+    uint8_t data_size;
+} __attribute__((packed));
+
+struct CommonResponse
+{
+    Message msgHdr;
+    uint8_t command;
+    uint8_t completion_code;
+    uint16_t reserved;
+    uint16_t data_size;
+} __attribute__((packed));
+
+struct CommonNonSuccessResponse
+{
+    Message msgHdr;
+    uint8_t command;
+    uint8_t completion_code;
+    uint16_t reason_code;
+} __attribute__((packed));
+
+int packHeader(uint16_t pciVendorId, const BindingPciVidInfo& hdr,
+               BindingPciVid& msg);
+
+int decodeReasonCodeAndCC(std::span<const uint8_t> buf, CompletionCode& cc,
+                          uint16_t& reasonCode);
+
+} // namespace accelerator_management
+} // namespace ocp
diff --git a/src/nvidia-gpu/meson.build b/src/nvidia-gpu/meson.build
index 9918435..97b6da5 100644
--- a/src/nvidia-gpu/meson.build
+++ b/src/nvidia-gpu/meson.build
@@ -1,4 +1,10 @@
-gpusensor_sources = files('NvidiaGpuSensor.cpp', 'NvidiaGpuSensorMain.cpp')
+gpusensor_sources = files(
+    'MctpRequester.cpp',
+    'NvidiaGpuMctpVdm.cpp',
+    'NvidiaGpuSensor.cpp',
+    'NvidiaGpuSensorMain.cpp',
+    'OcpMctpVdm.cpp',
+)
 
 gpusensor_include_dir = include_directories('.', is_system: true)
 sensor_include_dir = include_directories('../..')
@@ -11,3 +17,7 @@
     dependencies: [thresholds_dep, utils_dep],
     install: true,
 )
+
+if get_option('tests').enabled()
+    subdir('tests')
+endif
diff --git a/src/nvidia-gpu/tests/NvidiaGpuSensorTest.cpp b/src/nvidia-gpu/tests/NvidiaGpuSensorTest.cpp
new file mode 100644
index 0000000..c630ffa
--- /dev/null
+++ b/src/nvidia-gpu/tests/NvidiaGpuSensorTest.cpp
@@ -0,0 +1,500 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION &
+ * AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "NvidiaGpuMctpVdm.hpp"
+#include "OcpMctpVdm.hpp"
+
+#include <endian.h>
+
+#include <array>
+#include <cerrno>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+namespace ocp_mctp_tests
+{
+
+class OcpMctpVdmTests : public ::testing::Test
+{
+  protected:
+    void SetUp() override
+    {
+        // Initialize common test data here
+    }
+};
+
+// Tests for OcpMctpVdm::packHeader function
+TEST_F(OcpMctpVdmTests, PackHeaderRequestSuccess)
+{
+    const uint16_t pciVendorId = 0x1234;
+    ocp::accelerator_management::BindingPciVidInfo hdr{};
+    ocp::accelerator_management::BindingPciVid msg{};
+
+    hdr.ocp_accelerator_management_msg_type =
+        static_cast<uint8_t>(ocp::accelerator_management::MessageType::REQUEST);
+    hdr.instance_id = 5;
+    hdr.msg_type = 0x7E;
+
+    int result = ocp::accelerator_management::packHeader(pciVendorId, hdr, msg);
+
+    EXPECT_EQ(result, 0);
+    EXPECT_EQ(msg.pci_vendor_id, htobe16(pciVendorId));
+    EXPECT_EQ(msg.instance_id & ocp::accelerator_management::instanceIdBitMask,
+              5);
+    EXPECT_NE(msg.instance_id & ocp::accelerator_management::requestBitMask, 0);
+    EXPECT_EQ(msg.ocp_version & 0x0F, ocp::accelerator_management::ocpVersion);
+    EXPECT_EQ((msg.ocp_version & 0xF0) >>
+                  ocp::accelerator_management::ocpTypeBitOffset,
+              ocp::accelerator_management::ocpType);
+    EXPECT_EQ(msg.ocp_accelerator_management_msg_type, 0x7E);
+}
+
+TEST_F(OcpMctpVdmTests, PackHeaderResponseSuccess)
+{
+    const uint16_t pciVendorId = 0x1234;
+    ocp::accelerator_management::BindingPciVidInfo hdr{};
+    ocp::accelerator_management::BindingPciVid msg{};
+
+    hdr.ocp_accelerator_management_msg_type = static_cast<uint8_t>(
+        ocp::accelerator_management::MessageType::RESPONSE);
+    hdr.instance_id = 10;
+    hdr.msg_type = 0x7E;
+
+    int result = ocp::accelerator_management::packHeader(pciVendorId, hdr, msg);
+
+    EXPECT_EQ(result, 0);
+    EXPECT_EQ(msg.pci_vendor_id, htobe16(pciVendorId));
+    EXPECT_EQ(msg.instance_id & ocp::accelerator_management::instanceIdBitMask,
+              10);
+    EXPECT_EQ(msg.instance_id & ocp::accelerator_management::requestBitMask, 0);
+    EXPECT_EQ(msg.ocp_version & 0x0F, ocp::accelerator_management::ocpVersion);
+    EXPECT_EQ((msg.ocp_version & 0xF0) >>
+                  ocp::accelerator_management::ocpTypeBitOffset,
+              ocp::accelerator_management::ocpType);
+    EXPECT_EQ(msg.ocp_accelerator_management_msg_type, 0x7E);
+}
+
+TEST_F(OcpMctpVdmTests, PackHeaderInvalidMessageType)
+{
+    const uint16_t pciVendorId = 0x1234;
+    ocp::accelerator_management::BindingPciVidInfo hdr{};
+    ocp::accelerator_management::BindingPciVid msg{};
+
+    hdr.ocp_accelerator_management_msg_type = 3; // Invalid message type
+    hdr.instance_id = 5;
+    hdr.msg_type = 0x7E;
+
+    int result = ocp::accelerator_management::packHeader(pciVendorId, hdr, msg);
+
+    EXPECT_EQ(result, EINVAL);
+}
+
+TEST_F(OcpMctpVdmTests, PackHeaderInvalidInstanceId)
+{
+    const uint16_t pciVendorId = 0x1234;
+    ocp::accelerator_management::BindingPciVidInfo hdr{};
+    ocp::accelerator_management::BindingPciVid msg{};
+
+    hdr.ocp_accelerator_management_msg_type =
+        static_cast<uint8_t>(ocp::accelerator_management::MessageType::REQUEST);
+    hdr.instance_id = 32; // Out of range (0-31 valid)
+    hdr.msg_type = 0x7E;
+
+    int result = ocp::accelerator_management::packHeader(pciVendorId, hdr, msg);
+
+    EXPECT_EQ(result, EINVAL);
+}
+
+// Tests for OcpMctpVdm::decodeReasonCodeAndCC function
+TEST_F(OcpMctpVdmTests, DecodeReasonCodeAndCCSuccessCase)
+{
+    ocp::accelerator_management::CommonNonSuccessResponse response{};
+    response.command = 0x42;
+    response.completion_code = static_cast<uint8_t>(
+        ocp::accelerator_management::CompletionCode::SUCCESS);
+    response.reason_code = htole16(0x1234);
+
+    ocp::accelerator_management::CompletionCode cc{};
+    uint16_t reasonCode{};
+
+    std::array<uint8_t, sizeof(response)> buf{};
+    std::memcpy(buf.data(), &response, sizeof(response));
+
+    int result =
+        ocp::accelerator_management::decodeReasonCodeAndCC(buf, cc, reasonCode);
+
+    EXPECT_EQ(result, 0);
+    EXPECT_EQ(cc, ocp::accelerator_management::CompletionCode::SUCCESS);
+    EXPECT_EQ(reasonCode, 0); // Should be 0 for SUCCESS
+}
+
+TEST_F(OcpMctpVdmTests, DecodeReasonCodeAndCCErrorCase)
+{
+    ocp::accelerator_management::CommonNonSuccessResponse response{};
+    response.command = 0x42;
+    response.completion_code = static_cast<uint8_t>(
+        ocp::accelerator_management::CompletionCode::ERROR);
+    response.reason_code = htole16(0x5678);
+
+    ocp::accelerator_management::CompletionCode cc{};
+    uint16_t reasonCode{};
+
+    std::array<uint8_t, sizeof(response)> buf{};
+    std::memcpy(buf.data(), &response, sizeof(response));
+
+    int result =
+        ocp::accelerator_management::decodeReasonCodeAndCC(buf, cc, reasonCode);
+
+    EXPECT_EQ(result, 0);
+    EXPECT_EQ(cc, ocp::accelerator_management::CompletionCode::ERROR);
+    EXPECT_EQ(reasonCode, 0x5678);
+}
+
+} // namespace ocp_mctp_tests
+
+namespace gpu_mctp_tests
+{
+
+class GpuMctpVdmTests : public ::testing::Test
+{
+  protected:
+    void SetUp() override
+    {
+        // Initialize common test data here
+    }
+};
+
+// Tests for GpuMctpVdm::packHeader function
+TEST_F(GpuMctpVdmTests, PackHeaderSuccess)
+{
+    ocp::accelerator_management::BindingPciVidInfo hdr{};
+    ocp::accelerator_management::BindingPciVid msg{};
+
+    hdr.ocp_accelerator_management_msg_type =
+        static_cast<uint8_t>(ocp::accelerator_management::MessageType::REQUEST);
+    hdr.instance_id = 5;
+    hdr.msg_type = 0x7E;
+
+    int result = gpu::packHeader(hdr, msg);
+
+    EXPECT_EQ(result, 0);
+    EXPECT_EQ(msg.pci_vendor_id, htobe16(gpu::nvidiaPciVendorId));
+    EXPECT_EQ(msg.instance_id & ocp::accelerator_management::instanceIdBitMask,
+              5);
+    EXPECT_NE(msg.instance_id & ocp::accelerator_management::requestBitMask, 0);
+    EXPECT_EQ(msg.ocp_version & 0x0F, ocp::accelerator_management::ocpVersion);
+    EXPECT_EQ((msg.ocp_version & 0xF0) >>
+                  ocp::accelerator_management::ocpTypeBitOffset,
+              ocp::accelerator_management::ocpType);
+    EXPECT_EQ(msg.ocp_accelerator_management_msg_type, 0x7E);
+}
+
+// Tests for GpuMctpVdm::encodeQueryDeviceIdentificationRequest function
+TEST_F(GpuMctpVdmTests, EncodeQueryDeviceIdentificationRequestSuccess)
+{
+    const uint8_t instanceId = 3;
+    std::vector<uint8_t> buf(256);
+
+    int result = gpu::encodeQueryDeviceIdentificationRequest(instanceId, buf);
+
+    EXPECT_EQ(result, 0);
+
+    gpu::QueryDeviceIdentificationRequest request{};
+    std::memcpy(&request, buf.data(), sizeof(request));
+
+    EXPECT_EQ(request.hdr.msgHdr.hdr.pci_vendor_id,
+              htobe16(gpu::nvidiaPciVendorId));
+    EXPECT_EQ(request.hdr.msgHdr.hdr.instance_id &
+                  ocp::accelerator_management::instanceIdBitMask,
+              instanceId & ocp::accelerator_management::instanceIdBitMask);
+    EXPECT_NE(request.hdr.msgHdr.hdr.instance_id &
+                  ocp::accelerator_management::requestBitMask,
+              0);
+
+    EXPECT_EQ(request.hdr.command,
+              static_cast<uint8_t>(gpu::DeviceCapabilityDiscoveryCommands::
+                                       QUERY_DEVICE_IDENTIFICATION));
+    EXPECT_EQ(request.hdr.data_size, 0);
+}
+
+// Tests for GpuMctpVdm::decodeQueryDeviceIdentificationResponse function
+TEST_F(GpuMctpVdmTests, DecodeQueryDeviceIdentificationResponseSuccess)
+{
+    // Create a mock successful response
+    std::vector<uint8_t> buf(sizeof(gpu::QueryDeviceIdentificationResponse));
+
+    gpu::QueryDeviceIdentificationResponse response{};
+    ocp::accelerator_management::BindingPciVidInfo headerInfo{};
+    headerInfo.ocp_accelerator_management_msg_type = static_cast<uint8_t>(
+        ocp::accelerator_management::MessageType::RESPONSE);
+    headerInfo.instance_id = 3;
+    headerInfo.msg_type =
+        static_cast<uint8_t>(gpu::MessageType::DEVICE_CAPABILITY_DISCOVERY);
+
+    gpu::packHeader(headerInfo, response.hdr.msgHdr.hdr);
+
+    // Populate response data
+    response.hdr.command = static_cast<uint8_t>(
+        gpu::DeviceCapabilityDiscoveryCommands::QUERY_DEVICE_IDENTIFICATION);
+    response.hdr.completion_code = static_cast<uint8_t>(
+        ocp::accelerator_management::CompletionCode::SUCCESS);
+    response.hdr.reserved = 0;
+    response.hdr.data_size =
+        htole16(2); // Size of device_identification + instance_id
+    response.device_identification =
+        static_cast<uint8_t>(gpu::DeviceIdentification::DEVICE_GPU);
+    response.instance_id = 7;
+
+    std::memcpy(buf.data(), &response, sizeof(response));
+
+    // Test decoding
+    ocp::accelerator_management::CompletionCode cc{};
+    uint16_t reasonCode{};
+    uint8_t deviceIdentification{};
+    uint8_t deviceInstance{};
+
+    int result = gpu::decodeQueryDeviceIdentificationResponse(
+        buf, cc, reasonCode, deviceIdentification, deviceInstance);
+
+    EXPECT_EQ(result, 0);
+    EXPECT_EQ(cc, ocp::accelerator_management::CompletionCode::SUCCESS);
+    EXPECT_EQ(reasonCode, 0);
+    EXPECT_EQ(deviceIdentification,
+              static_cast<uint8_t>(gpu::DeviceIdentification::DEVICE_GPU));
+    EXPECT_EQ(deviceInstance, 7);
+}
+
+TEST_F(GpuMctpVdmTests, DecodeQueryDeviceIdentificationResponseError)
+{
+    // Create a mock successful response
+    std::vector<uint8_t> buf(
+        sizeof(ocp::accelerator_management::CommonNonSuccessResponse));
+
+    ocp::accelerator_management::CommonNonSuccessResponse response{};
+    ocp::accelerator_management::BindingPciVidInfo headerInfo{};
+    headerInfo.ocp_accelerator_management_msg_type = static_cast<uint8_t>(
+        ocp::accelerator_management::MessageType::RESPONSE);
+    headerInfo.instance_id = 3;
+    headerInfo.msg_type =
+        static_cast<uint8_t>(gpu::MessageType::DEVICE_CAPABILITY_DISCOVERY);
+
+    gpu::packHeader(headerInfo, response.msgHdr.hdr);
+
+    // Populate response data
+    response.command = static_cast<uint8_t>(
+        gpu::DeviceCapabilityDiscoveryCommands::QUERY_DEVICE_IDENTIFICATION);
+    response.command = static_cast<uint8_t>(
+        gpu::DeviceCapabilityDiscoveryCommands::QUERY_DEVICE_IDENTIFICATION);
+    response.completion_code = static_cast<uint8_t>(
+        ocp::accelerator_management::CompletionCode::ERROR);
+    response.reason_code = htole16(0x1234);
+
+    std::memcpy(buf.data(), &response, sizeof(response));
+
+    // Test decoding
+    ocp::accelerator_management::CompletionCode cc{};
+    uint16_t reasonCode{};
+    uint8_t deviceIdentification{};
+    uint8_t deviceInstance{};
+
+    int result = gpu::decodeQueryDeviceIdentificationResponse(
+        buf, cc, reasonCode, deviceIdentification, deviceInstance);
+
+    EXPECT_EQ(result, 0);
+    EXPECT_EQ(cc, ocp::accelerator_management::CompletionCode::ERROR);
+    EXPECT_EQ(reasonCode, 0x1234);
+}
+
+TEST_F(GpuMctpVdmTests, DecodeQueryDeviceIdentificationResponseInvalidSize)
+{
+    // Create a too-small buffer
+    std::vector<uint8_t> buf(
+        sizeof(ocp::accelerator_management::Message) + 2); // Too small
+
+    // Populate Message header only
+    ocp::accelerator_management::Message msg{};
+    ocp::accelerator_management::BindingPciVidInfo headerInfo{};
+    headerInfo.ocp_accelerator_management_msg_type = static_cast<uint8_t>(
+        ocp::accelerator_management::MessageType::RESPONSE);
+    headerInfo.instance_id = 3;
+    headerInfo.msg_type =
+        static_cast<uint8_t>(gpu::MessageType::DEVICE_CAPABILITY_DISCOVERY);
+
+    gpu::packHeader(headerInfo, msg.hdr);
+    std::memcpy(buf.data(), &msg, sizeof(msg));
+
+    // Test decoding with insufficient data
+    ocp::accelerator_management::CompletionCode cc{};
+    uint16_t reasonCode{};
+    uint8_t deviceIdentification{};
+    uint8_t deviceInstance{};
+
+    int result = gpu::decodeQueryDeviceIdentificationResponse(
+        buf, cc, reasonCode, deviceIdentification, deviceInstance);
+
+    EXPECT_EQ(result, EINVAL); // Should indicate error for invalid size
+}
+
+// Tests for GpuMctpVdm::encodeGetTemperatureReadingRequest function
+TEST_F(GpuMctpVdmTests, EncodeGetTemperatureReadingRequestSuccess)
+{
+    const uint8_t instanceId = 4;
+    const uint8_t sensorId = 0;
+    std::vector<uint8_t> buf(256);
+
+    int result =
+        gpu::encodeGetTemperatureReadingRequest(instanceId, sensorId, buf);
+
+    EXPECT_EQ(result, 0);
+
+    gpu::GetTemperatureReadingRequest request{};
+    std::memcpy(&request, buf.data(), sizeof(request));
+
+    EXPECT_EQ(request.hdr.msgHdr.hdr.pci_vendor_id,
+              htobe16(gpu::nvidiaPciVendorId));
+    EXPECT_EQ(request.hdr.msgHdr.hdr.instance_id &
+                  ocp::accelerator_management::instanceIdBitMask,
+              instanceId & ocp::accelerator_management::instanceIdBitMask);
+    EXPECT_NE(request.hdr.msgHdr.hdr.instance_id &
+                  ocp::accelerator_management::requestBitMask,
+              0);
+    EXPECT_EQ(request.hdr.msgHdr.hdr.ocp_accelerator_management_msg_type,
+              static_cast<uint8_t>(gpu::MessageType::PLATFORM_ENVIRONMENTAL));
+
+    // Verify request data
+    EXPECT_EQ(request.hdr.command,
+              static_cast<uint8_t>(
+                  gpu::PlatformEnvironmentalCommands::GET_TEMPERATURE_READING));
+    EXPECT_EQ(request.hdr.data_size, sizeof(sensorId));
+    EXPECT_EQ(request.sensor_id, sensorId);
+}
+
+// Tests for GpuMctpVdm::decodeGetTemperatureReadingResponse function
+TEST_F(GpuMctpVdmTests, DecodeGetTemperatureReadingResponseSuccess)
+{
+    // Create a mock successful response
+    std::vector<uint8_t> buf(sizeof(gpu::GetTemperatureReadingResponse));
+
+    gpu::GetTemperatureReadingResponse response{};
+    ocp::accelerator_management::BindingPciVidInfo headerInfo{};
+    headerInfo.ocp_accelerator_management_msg_type = static_cast<uint8_t>(
+        ocp::accelerator_management::MessageType::RESPONSE);
+    headerInfo.instance_id = 4;
+    headerInfo.msg_type =
+        static_cast<uint8_t>(gpu::MessageType::PLATFORM_ENVIRONMENTAL);
+
+    gpu::packHeader(headerInfo, response.hdr.msgHdr.hdr);
+
+    // Populate response data
+    response.hdr.command = static_cast<uint8_t>(
+        gpu::PlatformEnvironmentalCommands::GET_TEMPERATURE_READING);
+    response.hdr.completion_code = static_cast<uint8_t>(
+        ocp::accelerator_management::CompletionCode::SUCCESS);
+    response.hdr.reserved = 0;
+    response.hdr.data_size = htole16(sizeof(int32_t));
+
+    // Set a temperature value of 75.5°C (75.5 * 256 = 19328)
+    response.reading = htole32(19328);
+
+    std::memcpy(buf.data(), &response, sizeof(response));
+
+    // Test decoding
+    ocp::accelerator_management::CompletionCode cc{};
+    uint16_t reasonCode{};
+    double temperatureReading{};
+
+    int result = gpu::decodeGetTemperatureReadingResponse(
+        buf, cc, reasonCode, temperatureReading);
+
+    EXPECT_EQ(result, 0);
+    EXPECT_EQ(cc, ocp::accelerator_management::CompletionCode::SUCCESS);
+    EXPECT_EQ(reasonCode, 0);
+    EXPECT_NEAR(temperatureReading, 75.5, 0.01);
+}
+
+TEST_F(GpuMctpVdmTests, DecodeGetTemperatureReadingResponseError)
+{
+    std::vector<uint8_t> buf(
+        sizeof(ocp::accelerator_management::CommonNonSuccessResponse));
+
+    // Populate error response data
+    ocp::accelerator_management::CommonNonSuccessResponse errorResponse{};
+    ocp::accelerator_management::BindingPciVidInfo headerInfo{};
+    headerInfo.ocp_accelerator_management_msg_type = static_cast<uint8_t>(
+        ocp::accelerator_management::MessageType::RESPONSE);
+    headerInfo.instance_id = 3;
+    headerInfo.msg_type =
+        static_cast<uint8_t>(gpu::MessageType::DEVICE_CAPABILITY_DISCOVERY);
+
+    gpu::packHeader(headerInfo, errorResponse.msgHdr.hdr);
+
+    errorResponse.command = static_cast<uint8_t>(
+        gpu::PlatformEnvironmentalCommands::GET_TEMPERATURE_READING);
+    errorResponse.completion_code = static_cast<uint8_t>(
+        ocp::accelerator_management::CompletionCode::ERR_NOT_READY);
+    errorResponse.reason_code = htole16(0x4321);
+
+    std::memcpy(buf.data(), &errorResponse, sizeof(errorResponse));
+
+    // Test decoding
+    ocp::accelerator_management::CompletionCode cc{};
+    uint16_t reasonCode{};
+    double temperatureReading{};
+
+    int result = gpu::decodeGetTemperatureReadingResponse(
+        buf, cc, reasonCode, temperatureReading);
+
+    EXPECT_EQ(result, 0);
+    EXPECT_EQ(cc, ocp::accelerator_management::CompletionCode::ERR_NOT_READY);
+    EXPECT_EQ(reasonCode, 0x4321);
+}
+
+TEST_F(GpuMctpVdmTests, DecodeGetTemperatureReadingResponseInvalidSize)
+{
+    // Create a mock response with invalid data_size
+    std::vector<uint8_t> buf(sizeof(gpu::GetTemperatureReadingResponse));
+
+    gpu::GetTemperatureReadingResponse response{};
+    ocp::accelerator_management::BindingPciVidInfo headerInfo{};
+    headerInfo.ocp_accelerator_management_msg_type = static_cast<uint8_t>(
+        ocp::accelerator_management::MessageType::RESPONSE);
+    headerInfo.instance_id = 4;
+    headerInfo.msg_type =
+        static_cast<uint8_t>(gpu::MessageType::PLATFORM_ENVIRONMENTAL);
+
+    gpu::packHeader(headerInfo, response.hdr.msgHdr.hdr);
+
+    response.hdr.command = static_cast<uint8_t>(
+        gpu::PlatformEnvironmentalCommands::GET_TEMPERATURE_READING);
+    response.hdr.completion_code = static_cast<uint8_t>(
+        ocp::accelerator_management::CompletionCode::SUCCESS);
+    response.hdr.reserved = 0;
+    response.hdr.data_size = htole16(1); // Invalid - should be sizeof(int32_t)
+    response.reading = htole32(19328);
+
+    std::memcpy(buf.data(), &response, sizeof(response));
+
+    // Test decoding
+    ocp::accelerator_management::CompletionCode cc{};
+    uint16_t reasonCode{};
+    double temperatureReading{};
+
+    int result = gpu::decodeGetTemperatureReadingResponse(
+        buf, cc, reasonCode, temperatureReading);
+
+    EXPECT_EQ(result, EINVAL); // Should indicate error for invalid data size
+}
+
+} // namespace gpu_mctp_tests
+
+int main(int argc, char** argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
diff --git a/src/nvidia-gpu/tests/meson.build b/src/nvidia-gpu/tests/meson.build
new file mode 100644
index 0000000..4923868
--- /dev/null
+++ b/src/nvidia-gpu/tests/meson.build
@@ -0,0 +1,29 @@
+gtest_dep = dependency('gtest', main: true, disabler: true, required: false)
+gmock_dep = dependency('gmock', disabler: true, required: false)
+if not gtest_dep.found() or not gmock_dep.found()
+    gtest_proj = import('cmake').subproject('googletest', required: true)
+    gtest_dep = declare_dependency(
+        dependencies: [
+            dependency('threads'),
+            gtest_proj.dependency('gtest'),
+            gtest_proj.dependency('gtest_main'),
+        ],
+    )
+    gmock_dep = gtest_proj.dependency('gmock')
+endif
+
+gpusensor_test_include_dirs = [gpusensor_include_dir]
+
+test(
+    'nvidiagpusensor_test',
+    executable(
+        'nvidiagpusensor_test',
+        'NvidiaGpuSensorTest.cpp',
+        '../OcpMctpVdm.cpp',
+        '../NvidiaGpuMctpVdm.cpp',
+        implicit_include_directories: false,
+        include_directories: gpusensor_test_include_dirs,
+        dependencies: [gtest_dep, gmock_dep],
+    ),
+    workdir: meson.current_source_dir(),
+)