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
diff --git a/src/nvidia-gpu/MctpRequester.hpp b/src/nvidia-gpu/MctpRequester.hpp
index 289e800..5b5a270 100644
--- a/src/nvidia-gpu/MctpRequester.hpp
+++ b/src/nvidia-gpu/MctpRequester.hpp
@@ -14,24 +14,28 @@
 #include <cstddef>
 #include <cstdint>
 #include <functional>
+#include <memory>
+#include <queue>
 #include <span>
+#include <unordered_map>
+#include <utility>
 
 namespace mctp
 {
-class MctpRequester
+class Requester
 {
   public:
-    MctpRequester() = delete;
+    Requester() = delete;
 
-    MctpRequester(const MctpRequester&) = delete;
+    Requester(const Requester&) = delete;
 
-    MctpRequester(MctpRequester&&) = delete;
+    Requester(Requester&&) = delete;
 
-    MctpRequester& operator=(const MctpRequester&) = delete;
+    Requester& operator=(const Requester&) = delete;
 
-    MctpRequester& operator=(MctpRequester&&) = delete;
+    Requester& operator=(Requester&&) = delete;
 
-    explicit MctpRequester(boost::asio::io_context& ctx);
+    explicit Requester(boost::asio::io_context& ctx);
 
     void sendRecvMsg(uint8_t eid, std::span<const uint8_t> reqMsg,
                      std::span<uint8_t> respMsg,
@@ -57,8 +61,56 @@
 
     boost::asio::steady_timer expiryTimer;
 
-    std::move_only_function<void(int)> completionCallback;
+    std::unordered_map<uint8_t, std::move_only_function<void(int)>>
+        completionCallbacks;
 
     static constexpr uint8_t msgType = ocp::accelerator_management::messageType;
 };
+
+class QueuingRequester
+{
+  public:
+    QueuingRequester() = delete;
+    QueuingRequester(const QueuingRequester&) = delete;
+    QueuingRequester(QueuingRequester&&) = delete;
+    QueuingRequester& operator=(const QueuingRequester&) = delete;
+    QueuingRequester& operator=(QueuingRequester&&) = delete;
+
+    explicit QueuingRequester(boost::asio::io_context& ctx) : requester(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:
+    struct RequestContext
+    {
+        std::span<const uint8_t> reqMsg;
+        std::span<uint8_t> respMsg;
+        std::move_only_function<void(int)> callback;
+
+        RequestContext(const RequestContext&) = delete;
+        RequestContext& operator=(const RequestContext&) = delete;
+
+        RequestContext(RequestContext&&) = default;
+        RequestContext& operator=(RequestContext&&) = default;
+        ~RequestContext() = default;
+
+        explicit RequestContext(std::span<const uint8_t> req,
+                                std::span<uint8_t> resp,
+                                std::move_only_function<void(int)> cb) :
+            reqMsg(req), respMsg(resp), callback(std::move(cb))
+        {}
+    };
+
+    void processQueue(uint8_t eid);
+
+    Requester requester;
+    std::unordered_map<uint8_t, std::queue<std::unique_ptr<RequestContext>>>
+        requestContextQueues;
+    std::unordered_map<uint8_t, std::unique_ptr<RequestContext>>
+        activeRequestContexts;
+};
+
+using MctpRequester = QueuingRequester;
 } // namespace mctp