diff --git a/src/nvidia-gpu/MctpRequester.cpp b/src/nvidia-gpu/MctpRequester.cpp
index 024f8cc..c238d92 100644
--- a/src/nvidia-gpu/MctpRequester.cpp
+++ b/src/nvidia-gpu/MctpRequester.cpp
@@ -22,6 +22,7 @@
 #include <cstdint>
 #include <cstring>
 #include <functional>
+#include <memory>
 #include <span>
 #include <utility>
 
@@ -30,12 +31,12 @@
 namespace mctp
 {
 
-MctpRequester::MctpRequester(boost::asio::io_context& ctx) :
+Requester::Requester(boost::asio::io_context& ctx) :
     mctpSocket(ctx, boost::asio::generic::datagram_protocol{AF_MCTP, 0}),
     expiryTimer(ctx)
 {}
 
-void MctpRequester::processRecvMsg(
+void Requester::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*/)
@@ -47,7 +48,7 @@
         lg2::error(
             "MctpRequester failed to receive data from the MCTP socket - ErrorCode={EC}, Error={ER}.",
             "EC", ec.value(), "ER", ec.message());
-        completionCallback(EIO);
+        completionCallbacks[eid](EIO);
         return;
     }
 
@@ -58,7 +59,7 @@
     if (respAddr->smctp_type != msgType)
     {
         lg2::error("MctpRequester: Message type mismatch");
-        completionCallback(EPROTO);
+        completionCallbacks[eid](EPROTO);
         return;
     }
 
@@ -69,7 +70,7 @@
         lg2::error(
             "MctpRequester: EID mismatch - expected={EID}, received={REID}",
             "EID", eid, "REID", respEid);
-        completionCallback(EPROTO);
+        completionCallbacks[eid](EPROTO);
         return;
     }
 
@@ -96,15 +97,15 @@
                 "MctpRequester: Instance ID mismatch - request={REQ}, response={RESP}",
                 "REQ", static_cast<int>(reqInstanceId), "RESP",
                 static_cast<int>(respInstanceId));
-            completionCallback(EPROTO);
+            completionCallbacks[eid](EPROTO);
             return;
         }
     }
 
-    completionCallback(0);
+    completionCallbacks[eid](0);
 }
 
-void MctpRequester::handleSendMsgCompletion(
+void Requester::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 */)
@@ -114,28 +115,28 @@
         lg2::error(
             "MctpRequester failed to send data from the MCTP socket - ErrorCode={EC}, Error={ER}.",
             "EC", ec.value(), "ER", ec.message());
-        completionCallback(EIO);
+        completionCallbacks[eid](EIO);
         return;
     }
 
     expiryTimer.expires_after(2s);
 
-    expiryTimer.async_wait([this](const boost::system::error_code& ec) {
+    expiryTimer.async_wait([this, eid](const boost::system::error_code& ec) {
         if (ec != boost::asio::error::operation_aborted)
         {
-            completionCallback(ETIME);
+            completionCallbacks[eid](ETIME);
         }
     });
 
     mctpSocket.async_receive_from(
         boost::asio::mutable_buffer(respMsg), recvEndPoint,
-        std::bind_front(&MctpRequester::processRecvMsg, this, eid, reqMsg,
+        std::bind_front(&Requester::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)
+void Requester::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))
     {
@@ -144,7 +145,7 @@
         return;
     }
 
-    completionCallback = std::move(callback);
+    completionCallbacks[eid] = std::move(callback);
 
     struct sockaddr_mctp addr{};
     addr.smctp_family = AF_MCTP;
@@ -156,7 +157,47 @@
 
     mctpSocket.async_send_to(
         boost::asio::const_buffer(reqMsg), sendEndPoint,
-        std::bind_front(&MctpRequester::handleSendMsgCompletion, this, eid,
-                        reqMsg, respMsg));
+        std::bind_front(&Requester::handleSendMsgCompletion, this, eid, reqMsg,
+                        respMsg));
 }
+
+void QueuingRequester::sendRecvMsg(uint8_t eid, std::span<const uint8_t> reqMsg,
+                                   std::span<uint8_t> respMsg,
+                                   std::move_only_function<void(int)> callback)
+{
+    auto reqCtx =
+        std::make_unique<RequestContext>(reqMsg, respMsg, std::move(callback));
+
+    // Add request to queue
+    auto& queue = requestContextQueues[eid];
+    queue.push(std::move(reqCtx));
+
+    processQueue(eid);
+}
+
+void QueuingRequester::processQueue(uint8_t eid)
+{
+    auto& queue = requestContextQueues[eid];
+    if (queue.empty() || activeRequestContexts.contains(eid))
+    {
+        return;
+    }
+
+    activeRequestContexts[eid] = std::move(queue.front());
+    queue.pop();
+
+    const auto& reqCtx = activeRequestContexts[eid];
+
+    requester.sendRecvMsg(
+        eid, reqCtx->reqMsg, reqCtx->respMsg, [this, eid](int result) {
+            const auto& reqCtx = activeRequestContexts[eid];
+
+            reqCtx->callback(result); // Call the original callback
+
+            activeRequestContexts.erase(eid);
+
+            processQueue(eid);
+        });
+}
+
 } // namespace mctp