diff --git a/include/NVMeDevice.hpp b/include/NVMeDevice.hpp
deleted file mode 100644
index 5ebb0b3..0000000
--- a/include/NVMeDevice.hpp
+++ /dev/null
@@ -1,99 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-#include <stdlib.h>
-
-// NVM Express Management Interface 1.0 section 3.2.1
-const uint8_t NVME_MI_MESSAGE_TYPE = 0x04;
-
-const uint8_t NVME_MI_MESSAGE_TYPE_MASK = 0x7F;
-
-// Indicates this is covered by an MCTP integrity check
-const uint8_t NVME_MI_MCTP_INTEGRITY_CHECK = (1 << 7);
-
-// Indicates whether this is a request or response
-const uint8_t NVME_MI_HDR_FLAG_ROR = (1 << 7);
-
-const uint8_t NVME_MI_HDR_FLAG_MSG_TYPE_MASK = 0x0F;
-const uint8_t NVME_MI_HDR_FLAG_MSG_TYPE_SHIFT = 3;
-
-const uint16_t NVME_MI_MSG_BUFFER_SIZE = 256;
-
-// Minimum length of health status poll response
-// NMH + Status + NVMe-MI Command Response Message (NCRESP)
-const uint8_t NVME_MI_HEALTH_STATUS_POLL_MSG_MIN = 8;
-
-enum NVME_MI_HDR_MESSAGE_TYPE
-{
-    NVME_MI_HDR_MESSAGE_TYPE_CONTROL_PRIMITIVE = 0x00,
-    NVME_MI_HDR_MESSAGE_TYPE_MI_COMMAND = 0x01,
-    NVME_MI_HDR_MESSAGE_TYPE_MI_ADMIN_COMMAND = 0x02,
-    NVME_MI_HDR_MESSAGE_TYPE_PCIE_COMMAND = 0x04,
-};
-
-enum NVME_MI_HDR_COMMAND_SLOT
-{
-    NVME_MI_HDR_COMMAND_SLOT_0 = 0x00,
-    NVME_MI_HDR_COMMAND_SLOT_1 = 0x01,
-};
-
-enum NVME_MI_HDR_STATUS
-{
-    NVME_MI_HDR_STATUS_SUCCESS = 0x00,
-    NVME_MI_HDR_STATUS_MORE_PROCESSING_REQUIRED = 0x01,
-    NVME_MI_HDR_STATUS_INTERNAL_ERROR = 0x02,
-    NVME_MI_HDR_STATUS_INVALID_COMMAND_OPCODE = 0x03,
-    NVME_MI_HDR_STATUS_INVALID_PARAMETER = 0x04,
-    NVME_MI_HDR_STATUS_INVALID_COMMAND_SIZE = 0x05,
-    NVME_MI_HDR_STATUS_INVALID_COMMAND_INPUT_DATA_SIZE = 0x06,
-    NVME_MI_HDR_STATUS_ACCESS_DENIED = 0x07,
-    NVME_MI_HDR_STATUS_VPD_UPDATES_EXCEEDED = 0x20,
-    NVME_MI_HDR_STATUS_PCIE_INACCESSIBLE = 0x21,
-};
-
-enum NVME_MI_OPCODE
-{
-    NVME_MI_OPCODE_READ_MI_DATA = 0x00,
-    NVME_MI_OPCODE_HEALTH_STATUS_POLL = 0x01,
-    NVME_MI_OPCODE_CONTROLLER_HEALTH_STATUS_POLL = 0x02,
-    NVME_MI_OPCODE_CONFIGURATION_GET = 0x03,
-    NVME_MI_OPCODE_CONFIGURATION_SET = 0x04,
-    NVME_MI_OPCODE_VPD_READ = 0x05,
-    NVME_MI_OPCODE_VPD_WRITE = 0x06,
-    NVME_MI_OPCODE_RESET = 0x07,
-};
-
-const uint8_t NVME_MI_MSG_REQUEST_HEADER_SIZE = 16;
-struct nvme_mi_msg_request_header
-{
-    uint8_t message_type;
-    uint8_t flags;
-    uint8_t opcode;
-    uint32_t dword0;
-    uint32_t dword1;
-};
-
-struct nvme_mi_msg_request
-{
-    struct nvme_mi_msg_request_header header;
-    uint8_t request_data[128];
-    size_t request_data_len;
-};
-
-const uint8_t NVME_MI_MSG_RESPONSE_HEADER_SIZE = 5;
-struct nvme_mi_msg_response_header
-{
-    uint8_t message_type;
-    uint8_t flags;
-    // Reserved bytes 2:3
-    uint8_t status;
-};
-
-struct nvme_mi_controller_health
-{
-    uint8_t nvm_subsystem_status;
-    uint8_t smart_warnings;
-    uint8_t composite_temperature;
-    uint8_t percent_used;
-    uint16_t composite_controller_status;
-};
\ No newline at end of file
diff --git a/include/NVMeMCTPContext.hpp b/include/NVMeMCTPContext.hpp
deleted file mode 100644
index 8af3e8d..0000000
--- a/include/NVMeMCTPContext.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#pragma once
-
-#include "NVMeContext.hpp"
-
-#include <boost/asio/ip/tcp.hpp>
-
-class NVMeMCTPContext : public NVMeContext
-{
-  public:
-    NVMeMCTPContext(boost::asio::io_service& io, int rootBus);
-
-    ~NVMeMCTPContext() override;
-
-    void pollNVMeDevices() override;
-    void close() override;
-    void readAndProcessNVMeSensor() override;
-    void processResponse(void* msg, size_t len) override;
-
-  private:
-    boost::asio::ip::tcp::socket nvmeSlaveSocket;
-    boost::asio::deadline_timer mctpResponseTimer;
-
-    void readResponse();
-};
-
-namespace nvme_mctp
-{
-void init(void);
-}
diff --git a/meson_options.txt b/meson_options.txt
index ea0302d..f9d25e7 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -7,7 +7,6 @@
 option('ipmb', type: 'feature', value: 'enabled', description: 'Enable IPMB sensor.',)
 option('mcu', type: 'feature', value: 'enabled', description: 'Enable MCU sensor.',)
 option('nvme', type: 'feature', value: 'enabled', description: 'Enable NVMe sensor.',)
-option('nvme-mi-mctp', type: 'feature', value: 'disabled', description: 'Manage NVMe devices via MCTP')
 option('psu', type: 'feature', value: 'enabled', description: 'Enable PSU sensor.',)
 option('external', type: 'feature', value: 'enabled', description: 'Enable External sensor.',)
 option('tests', type: 'feature', value: 'enabled', description: 'Build tests.',)
diff --git a/src/NVMeMCTPContext.cpp b/src/NVMeMCTPContext.cpp
deleted file mode 100644
index 40bb8ac..0000000
--- a/src/NVMeMCTPContext.cpp
+++ /dev/null
@@ -1,432 +0,0 @@
-/*
-// Copyright (c) 2019 Intel Corporation
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-*/
-
-#include "NVMeMCTPContext.hpp"
-
-#include "NVMeDevice.hpp"
-
-#include <crc32c.h>
-#include <libmctp-smbus.h>
-#include <libmctp.h>
-
-#include <boost/container/flat_map.hpp>
-
-static constexpr bool debug = false;
-
-static void rxMessage(uint8_t eid, void* data, void* msg, size_t len);
-
-namespace nvmeMCTP
-{
-struct mctp_binding_smbus* smbus = mctp_smbus_init();
-struct mctp* mctp = mctp_init();
-
-static boost::container::flat_map<int, int> inFds;
-static boost::container::flat_map<int, int> outFds;
-
-int getInFd(int rootBus)
-{
-    auto findBus = inFds.find(rootBus);
-    if (findBus != inFds.end())
-    {
-        return findBus->second;
-    }
-    int fd = mctp_smbus_open_in_bus(smbus, rootBus);
-    if (fd < 0)
-    {
-        std::cerr << "Error opening IN Bus " << rootBus << "\n";
-    }
-    inFds[rootBus] = fd;
-    return fd;
-}
-
-int getOutFd(int bus)
-{
-    auto findBus = outFds.find(bus);
-    if (findBus != outFds.end())
-    {
-        return findBus->second;
-    }
-    int fd = mctp_smbus_open_out_bus(smbus, bus);
-    if (fd < 0)
-    {
-        std::cerr << "Error opening Out Bus " << bus << "\n";
-    }
-    outFds[bus] = fd;
-    return fd;
-}
-
-// we don't close the outFd as multiple sensors could be sharing the fd, we need
-// to close the inFd as it can only be used on 1 socket at a time
-void closeInFd(int rootBus)
-{
-    auto findFd = inFds.find(rootBus);
-    if (findFd == inFds.end())
-    {
-        return;
-    }
-    close(findFd->second);
-    inFds.erase(rootBus);
-}
-
-int getRootBus(int inFd)
-{
-    // we assume that we won't have too many FDs, so looping is OK
-    for (const auto [root, fd] : inFds)
-    {
-        if (fd == inFd)
-        {
-            return root;
-        }
-    }
-
-    return -1;
-}
-
-void init()
-{
-    if (mctp == nullptr || smbus == nullptr)
-    {
-        throw std::runtime_error("Unable to init mctp");
-    }
-    mctp_smbus_register_bus(smbus, nvmeMCTP::mctp, 0);
-    mctp_set_rx_all(mctp, rxMessage, nullptr);
-}
-
-} // namespace nvmeMCTP
-
-static void rxMessage(uint8_t eid, void*, void* msg, size_t len)
-{
-    int inFd = mctp_smbus_get_in_fd(nvmeMCTP::smbus);
-    int rootBus = nvmeMCTP::getRootBus(inFd);
-
-    NVMEMap& nvmeMap = getNVMEMap();
-    auto findMap = nvmeMap.find(rootBus);
-    if (findMap == nvmeMap.end())
-    {
-        std::cerr << "Unable to lookup root bus " << rootBus << "\n";
-        return;
-    }
-
-    if (debug)
-    {
-        std::cout << "Eid from the received messaged: " << eid << "\n";
-    }
-
-    findMap->second->processResponse(msg, len);
-}
-
-static int verifyIntegrity(uint8_t* msg, size_t len)
-{
-    uint32_t msgIntegrity = {0};
-    if (len < NVME_MI_MSG_RESPONSE_HEADER_SIZE + sizeof(msgIntegrity))
-    {
-        std::cerr << "Not enough bytes for nvme header and trailer\n";
-        return -1;
-    }
-
-    msgIntegrity = (msg[len - 4]) + (msg[len - 3] << 8) + (msg[len - 2] << 16) +
-                   (msg[len - 1] << 24);
-
-    uint32_t calculateIntegrity = crc32c(msg, len - sizeof(msgIntegrity));
-    if (msgIntegrity != calculateIntegrity)
-    {
-        std::cerr << "CRC mismatch. Got=" << msgIntegrity
-                  << " Expected=" << calculateIntegrity << "\n";
-        return -1;
-    }
-    return 0;
-}
-
-static double getTemperatureReading(int8_t reading)
-{
-
-    if (reading == static_cast<int8_t>(0x80) ||
-        reading == static_cast<int8_t>(0x81))
-    {
-        // 0x80 = No temperature data or temperature data is more the 5 s
-        // old 0x81 = Temperature sensor failure
-        return std::numeric_limits<double>::quiet_NaN();
-    }
-
-    return reading;
-}
-
-void NVMeMCTPContext::processResponse(void* msg, size_t len)
-{
-    struct nvme_mi_msg_response_header header
-    {};
-
-    if (msg == nullptr)
-    {
-        std::cerr << "Bad message received\n";
-        return;
-    }
-
-    if (len <= 0)
-    {
-        std::cerr << "Received message not long enough\n";
-        return;
-    }
-
-    uint8_t* messageData = static_cast<uint8_t*>(msg);
-
-    if ((*messageData & NVME_MI_MESSAGE_TYPE_MASK) != NVME_MI_MESSAGE_TYPE)
-    {
-        std::cerr << "Got unknown type message_type="
-                  << (*messageData & NVME_MI_MESSAGE_TYPE_MASK) << "\n";
-        return;
-    }
-
-    if (len < NVME_MI_MSG_RESPONSE_HEADER_SIZE + sizeof(uint32_t))
-    {
-        std::cerr << "Not enough bytes for NVMe header and trailer\n";
-        return;
-    }
-
-    if (verifyIntegrity(messageData, len) != 0)
-    {
-        std::cerr << "Verification of message integrity failed\n";
-        return;
-    }
-
-    header.message_type = messageData[0];
-    header.flags = messageData[1];
-    header.status = messageData[4];
-
-    if (header.status == NVME_MI_HDR_STATUS_MORE_PROCESSING_REQUIRED)
-    {
-        return;
-    }
-
-    if (header.status != NVME_MI_HDR_STATUS_SUCCESS)
-    {
-        std::cerr << "Command failed with status= " << header.status << "\n";
-        return;
-    }
-
-    messageData += NVME_MI_MSG_RESPONSE_HEADER_SIZE;
-    size_t messageLength =
-        len - NVME_MI_MSG_RESPONSE_HEADER_SIZE - sizeof(uint32_t);
-    if (((header.flags >> NVME_MI_HDR_FLAG_MSG_TYPE_SHIFT) &
-         NVME_MI_HDR_FLAG_MSG_TYPE_MASK) != NVME_MI_HDR_MESSAGE_TYPE_MI_COMMAND)
-    {
-        std::cerr << "Not MI type comamnd\n";
-        return;
-    }
-
-    if (messageLength < NVME_MI_HEALTH_STATUS_POLL_MSG_MIN)
-    {
-        std::cerr << "Got improperly sized health status poll\n";
-        return;
-    }
-
-    std::shared_ptr<NVMeSensor> sensorInfo = sensors.front();
-    if (debug)
-    {
-        std::cout << "Temperature Reading: "
-                  << getTemperatureReading(messageData[5])
-                  << " Celsius for device " << sensorInfo->name << "\n";
-    }
-
-    double value = getTemperatureReading(messageData[5]);
-    if (!std::isfinite(value))
-    {
-        sensorInfo->markAvailable(false);
-        sensorInfo->incrementError();
-    }
-    else
-    {
-        sensorInfo->updateValue(value);
-    }
-
-    if (debug)
-    {
-        std::cout << "Cancelling the timer now\n";
-    }
-
-    // move to back of scan queue
-    sensors.pop_front();
-    sensors.emplace_back(sensorInfo);
-
-    mctpResponseTimer.cancel();
-}
-
-static int nvmeMessageTransmit(mctp& mctp, nvme_mi_msg_request& req)
-{
-    std::array<uint8_t, NVME_MI_MSG_BUFFER_SIZE> messageBuf = {};
-
-    req.header.flags |= NVME_MI_HDR_MESSAGE_TYPE_MI_COMMAND
-                        << NVME_MI_HDR_FLAG_MSG_TYPE_SHIFT;
-    req.header.message_type =
-        NVME_MI_MESSAGE_TYPE | NVME_MI_MCTP_INTEGRITY_CHECK;
-
-    uint32_t integrity = 0;
-    size_t msgSize = NVME_MI_MSG_REQUEST_HEADER_SIZE + req.request_data_len +
-                     sizeof(integrity);
-
-    if (sizeof(messageBuf) < msgSize)
-    {
-        return EXIT_FAILURE;
-    }
-
-    messageBuf[0] = req.header.message_type;
-    messageBuf[1] = req.header.flags;
-    // Reserved bytes 2-3
-
-    messageBuf[4] = req.header.opcode;
-    // reserved bytes 5-7
-    messageBuf[8] = req.header.dword0 & 0xff;
-    messageBuf[9] = (req.header.dword0 >> 8) & 0xff;
-    messageBuf[10] = (req.header.dword0 >> 16) & 0xff;
-    messageBuf[11] = (req.header.dword0 >> 24) & 0xff;
-
-    messageBuf[12] = req.header.dword1 & 0xff;
-    messageBuf[13] = (req.header.dword1 >> 8) & 0xff;
-    messageBuf[14] = (req.header.dword1 >> 16) & 0xff;
-    messageBuf[15] = (req.header.dword1 >> 24) & 0xff;
-
-    std::copy_n(req.request_data, req.request_data_len,
-                messageBuf.data() +
-                    static_cast<uint8_t>(NVME_MI_MSG_REQUEST_HEADER_SIZE));
-
-    msgSize = NVME_MI_MSG_REQUEST_HEADER_SIZE + req.request_data_len;
-    integrity = crc32c(messageBuf.data(),
-                       NVME_MI_MSG_REQUEST_HEADER_SIZE + req.request_data_len);
-    messageBuf[msgSize] = integrity & 0xff;
-    messageBuf[msgSize + 1] = (integrity >> 8) & 0xff;
-    messageBuf[msgSize + 2] = (integrity >> 16) & 0xff;
-    messageBuf[msgSize + 3] = (integrity >> 24) & 0xff;
-    msgSize += sizeof(integrity);
-
-    return mctp_message_tx(&mctp, 0, messageBuf.data(), msgSize);
-}
-
-void NVMeMCTPContext::readResponse()
-{
-    nvmeSlaveSocket.async_wait(
-        boost::asio::ip::tcp::socket::wait_error,
-        [this](const boost::system::error_code errorCode) {
-            if (errorCode)
-            {
-                return;
-            }
-
-            mctp_smbus_set_in_fd(nvmeMCTP::smbus, nvmeMCTP::getInFd(rootBus));
-
-            // through libmctp this will invoke rxMessage
-            mctp_smbus_read(nvmeMCTP::smbus);
-        });
-}
-
-void NVMeMCTPContext::readAndProcessNVMeSensor()
-{
-    struct nvme_mi_msg_request requestMsg = {};
-    requestMsg.header.opcode = NVME_MI_OPCODE_HEALTH_STATUS_POLL;
-    requestMsg.header.dword0 = 0;
-    requestMsg.header.dword1 = 0;
-
-    int mctpResponseTimeout = 1;
-
-    if (sensors.empty())
-    {
-        return;
-    }
-
-    std::shared_ptr<NVMeSensor>& sensor = sensors.front();
-
-    // setup the timeout timer
-    mctpResponseTimer.expires_from_now(
-        boost::posix_time::seconds(mctpResponseTimeout));
-
-    mctpResponseTimer.async_wait(
-        [sensor, this](const boost::system::error_code errorCode) {
-            if (errorCode)
-            {
-                // timer cancelled successfully
-                return;
-            }
-
-            sensor->incrementError();
-
-            // cycle it back
-            sensors.pop_front();
-            sensors.emplace_back(sensor);
-
-            nvmeSlaveSocket.cancel();
-        });
-
-    readResponse();
-
-    if (debug)
-    {
-        std::cout << "Sending message to read data from Drive on bus: "
-                  << sensor->bus << " , rootBus: " << rootBus
-                  << " device: " << sensor->name << "\n";
-    }
-
-    mctp_smbus_set_out_fd(nvmeMCTP::smbus, nvmeMCTP::getOutFd(sensor->bus));
-    int rc = nvmeMessageTransmit(*nvmeMCTP::mctp, requestMsg);
-
-    if (rc != 0)
-    {
-        std::cerr << "Error sending request message to NVMe device\n";
-    }
-}
-
-NVMeMCTPContext::NVMeMCTPContext(boost::asio::io_service& io, int rootBus) :
-    NVMeContext::NVMeContext(io, rootBus), nvmeSlaveSocket(io),
-    mctpResponseTimer(io)
-{
-    nvmeSlaveSocket.assign(boost::asio::ip::tcp::v4(),
-                           nvmeMCTP::getInFd(rootBus));
-}
-
-void NVMeMCTPContext::pollNVMeDevices()
-{
-    scanTimer.expires_from_now(boost::posix_time::seconds(1));
-    scanTimer.async_wait(
-        [self{shared_from_this()}](const boost::system::error_code errorCode) {
-            if (errorCode == boost::asio::error::operation_aborted)
-            {
-                return; // we're being canceled
-            }
-            else if (errorCode)
-            {
-                std::cerr << "Error:" << errorCode.message() << "\n";
-                return;
-            }
-            else
-            {
-                self->readAndProcessNVMeSensor();
-            }
-
-            self->pollNVMeDevices();
-        });
-}
-
-void NVMeMCTPContext::close()
-{
-    this->NVMeContext::close();
-
-    mctpResponseTimer.cancel();
-    nvmeSlaveSocket.cancel();
-    nvmeMCTP::closeInFd(rootBus);
-}
-
-NVMeMCTPContext::~NVMeMCTPContext()
-{
-    close();
-}
diff --git a/src/NVMeSensorMain.cpp b/src/NVMeSensorMain.cpp
index 7e32815..d5e3026 100644
--- a/src/NVMeSensorMain.cpp
+++ b/src/NVMeSensorMain.cpp
@@ -16,7 +16,6 @@
 
 #include <NVMeBasicContext.hpp>
 #include <NVMeContext.hpp>
-#include <NVMeMCTPContext.hpp>
 #include <NVMeSensor.hpp>
 #include <boost/asio/deadline_timer.hpp>
 
@@ -101,11 +100,7 @@
     }
 
     std::shared_ptr<NVMeContext> context =
-#if HAVE_NVME_MI_MCTP
-        std::make_shared<NVMeMCTPContext>(io, rootBus);
-#else
         std::make_shared<NVMeBasicContext>(io, rootBus);
-#endif
     map[rootBus] = context;
 
     return context;
@@ -235,9 +230,6 @@
     auto systemBus = std::make_shared<sdbusplus::asio::connection>(io);
     systemBus->request_name("xyz.openbmc_project.NVMeSensor");
     sdbusplus::asio::object_server objectServer(systemBus);
-#if HAVE_NVME_MI_MCTP
-    nvmeMCTP::init();
-#endif
 
     io.post([&]() { createSensors(io, objectServer, systemBus); });
 
diff --git a/src/meson.build b/src/meson.build
index d2535e2..0fe5f56 100644
--- a/src/meson.build
+++ b/src/meson.build
@@ -142,14 +142,6 @@
 
     nvme_deps = [ default_deps, i2c, thresholds_dep, utils_dep, threads ]
 
-    mi_mctp = get_option('nvme-mi-mctp')
-    if mi_mctp.enabled()
-        nvme_srcs += files('NVMeMCTPContext.cpp')
-        nvme_deps += meson.get_compiler('cpp').find_library('libmctp')
-        conf_data = configuration_data()
-        conf_data.set('HAVE_NVME_MI_MCTP', true)
-    endif
-
     executable(
         'nvmesensor',
         sources: nvme_srcs,