diff --git a/src/nvme/NVMeBasicContext.cpp b/src/nvme/NVMeBasicContext.cpp
new file mode 100644
index 0000000..64549a4
--- /dev/null
+++ b/src/nvme/NVMeBasicContext.cpp
@@ -0,0 +1,435 @@
+#include "NVMeBasicContext.hpp"
+
+#include "NVMeContext.hpp"
+#include "NVMeSensor.hpp"
+
+#include <endian.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+
+#include <FileHandle.hpp>
+#include <boost/asio/buffer.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/io_context.hpp>
+#include <boost/asio/read.hpp>
+#include <boost/asio/streambuf.hpp>
+#include <boost/asio/write.hpp>
+
+#include <array>
+#include <cerrno>
+#include <chrono>
+#include <cmath>
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+#include <filesystem>
+#include <ios>
+#include <iostream>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <system_error>
+#include <thread>
+#include <utility>
+#include <vector>
+
+extern "C"
+{
+#include <i2c/smbus.h>
+#include <linux/i2c-dev.h>
+}
+
+/*
+ * NVMe-MI Basic Management Command
+ *
+ * https://nvmexpress.org/wp-content/uploads/NVMe_Management_-_Technical_Note_on_Basic_Management_Command.pdf
+ */
+
+static std::shared_ptr<std::array<uint8_t, 6>>
+    encodeBasicQuery(int bus, uint8_t device, uint8_t offset)
+{
+    if (bus < 0)
+    {
+        throw std::domain_error("Invalid bus argument");
+    }
+
+    /* bus + address + command */
+    uint32_t busle = htole32(static_cast<uint32_t>(bus));
+    auto command =
+        std::make_shared<std::array<uint8_t, sizeof(busle) + 1 + 1>>();
+    memcpy(command->data(), &busle, sizeof(busle));
+    (*command)[sizeof(busle) + 0] = device;
+    (*command)[sizeof(busle) + 1] = offset;
+
+    return command;
+}
+
+static void decodeBasicQuery(const std::array<uint8_t, 6>& req, int& bus,
+                             uint8_t& device, uint8_t& offset)
+{
+    uint32_t busle = 0;
+
+    memcpy(&busle, req.data(), sizeof(busle));
+    bus = le32toh(busle);
+    device = req[sizeof(busle) + 0];
+    offset = req[sizeof(busle) + 1];
+}
+
+static void execBasicQuery(int bus, uint8_t addr, uint8_t cmd,
+                           std::vector<uint8_t>& resp)
+{
+    int32_t size = 0;
+    std::filesystem::path devpath = "/dev/i2c-" + std::to_string(bus);
+
+    try
+    {
+        FileHandle fileHandle(devpath);
+
+        /* Select the target device */
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg)
+        if (::ioctl(fileHandle.handle(), I2C_SLAVE, addr) == -1)
+        {
+            std::cerr << "Failed to configure device address 0x" << std::hex
+                      << (int)addr << " for bus " << std::dec << bus << ": "
+                      << strerror(errno) << "\n";
+            resp.resize(0);
+            return;
+        }
+
+        resp.resize(UINT8_MAX + 1);
+
+        /* Issue the NVMe MI basic command */
+        size = i2c_smbus_read_block_data(fileHandle.handle(), cmd, resp.data());
+        if (size < 0)
+        {
+            std::cerr << "Failed to read block data from device 0x" << std::hex
+                      << (int)addr << " on bus " << std::dec << bus << ": "
+                      << strerror(errno) << "\n";
+            resp.resize(0);
+        }
+        else if (size > UINT8_MAX + 1)
+        {
+            std::cerr << "Unexpected message length from device 0x" << std::hex
+                      << (int)addr << " on bus " << std::dec << bus << ": "
+                      << size << " (" << UINT8_MAX << ")\n";
+            resp.resize(0);
+        }
+        else
+        {
+            resp.resize(size);
+        }
+    }
+    catch (const std::out_of_range& e)
+    {
+        std::cerr << "Failed to create file handle for bus " << std::dec << bus
+                  << ": " << e.what() << "\n";
+        resp.resize(0);
+    }
+}
+
+static ssize_t processBasicQueryStream(FileHandle& in, FileHandle& out)
+{
+    std::vector<uint8_t> resp{};
+    ssize_t rc = 0;
+
+    while (true)
+    {
+        uint8_t device = 0;
+        uint8_t offset = 0;
+        uint8_t len = 0;
+        int bus = 0;
+
+        /* bus + address + command */
+        std::array<uint8_t, sizeof(uint32_t) + 1 + 1> req{};
+
+        /* Read the command parameters */
+        ssize_t rc = ::read(in.handle(), req.data(), req.size());
+        if (rc != static_cast<ssize_t>(req.size()))
+        {
+            std::cerr << "Failed to read request from in descriptor "
+                      << strerror(errno) << "\n";
+            if (rc != 0)
+            {
+                return -errno;
+            }
+            return -EIO;
+        }
+
+        decodeBasicQuery(req, bus, device, offset);
+
+        /* Execute the query */
+        execBasicQuery(bus, device, offset, resp);
+
+        /* Write out the response length */
+        len = resp.size();
+        rc = ::write(out.handle(), &len, sizeof(len));
+        if (rc != sizeof(len))
+        {
+            std::cerr << "Failed to write block (" << std::dec << len
+                      << ") length to out descriptor: "
+                      << strerror(static_cast<int>(-rc)) << "\n";
+            if (rc != 0)
+            {
+                return -errno;
+            }
+            return -EIO;
+        }
+
+        /* Write out the response data */
+        std::vector<uint8_t>::iterator cursor = resp.begin();
+        while (cursor != resp.end())
+        {
+            size_t lenRemaining = std::distance(cursor, resp.end());
+            ssize_t egress = ::write(out.handle(), &(*cursor), lenRemaining);
+            if (egress == -1)
+            {
+                std::cerr << "Failed to write block data of length " << std::dec
+                          << lenRemaining << " to out pipe: " << strerror(errno)
+                          << "\n";
+                if (rc != 0)
+                {
+                    return -errno;
+                }
+                return -EIO;
+            }
+
+            cursor += egress;
+        }
+    }
+
+    return rc;
+}
+
+/* Throws std::error_code on failure */
+/* FIXME: Probably shouldn't do fallible stuff in a constructor */
+NVMeBasicContext::NVMeBasicContext(boost::asio::io_context& io, int rootBus) :
+    NVMeContext::NVMeContext(io, rootBus), io(io), reqStream(io), respStream(io)
+{
+    std::array<int, 2> responsePipe{};
+    std::array<int, 2> requestPipe{};
+
+    /* Set up inter-thread communication */
+    if (::pipe(requestPipe.data()) == -1)
+    {
+        std::cerr << "Failed to create request pipe: " << strerror(errno)
+                  << "\n";
+        throw std::error_code(errno, std::system_category());
+    }
+
+    if (::pipe(responsePipe.data()) == -1)
+    {
+        std::cerr << "Failed to create response pipe: " << strerror(errno)
+                  << "\n";
+
+        if (::close(requestPipe[0]) == -1)
+        {
+            std::cerr << "Failed to close write fd of request pipe: "
+                      << strerror(errno) << "\n";
+        }
+
+        if (::close(requestPipe[1]) == -1)
+        {
+            std::cerr << "Failed to close read fd of request pipe: "
+                      << strerror(errno) << "\n";
+        }
+
+        throw std::error_code(errno, std::system_category());
+    }
+
+    reqStream.assign(requestPipe[1]);
+    FileHandle streamIn(requestPipe[0]);
+    FileHandle streamOut(responsePipe[1]);
+    respStream.assign(responsePipe[0]);
+
+    thread = std::jthread([streamIn{std::move(streamIn)},
+                           streamOut{std::move(streamOut)}]() mutable {
+        ssize_t rc = processBasicQueryStream(streamIn, streamOut);
+
+        if (rc < 0)
+        {
+            std::cerr << "Failure while processing query stream: "
+                      << strerror(static_cast<int>(-rc)) << "\n";
+        }
+
+        std::cerr << "Terminating basic query thread\n";
+    });
+}
+
+void NVMeBasicContext::readAndProcessNVMeSensor()
+{
+    if (pollCursor == sensors.end())
+    {
+        this->pollNVMeDevices();
+        return;
+    }
+
+    std::shared_ptr<NVMeSensor> sensor = *pollCursor++;
+
+    if (!sensor->readingStateGood())
+    {
+        sensor->markAvailable(false);
+        sensor->updateValue(std::numeric_limits<double>::quiet_NaN());
+        readAndProcessNVMeSensor();
+        return;
+    }
+
+    /* Potentially defer sampling the sensor sensor if it is in error */
+    if (!sensor->sample())
+    {
+        readAndProcessNVMeSensor();
+        return;
+    }
+
+    auto command = encodeBasicQuery(sensor->bus, sensor->address, 0x00);
+
+    /* Issue the request */
+    boost::asio::async_write(
+        reqStream, boost::asio::buffer(command->data(), command->size()),
+        [command](boost::system::error_code ec, std::size_t) {
+            if (ec)
+            {
+                std::cerr << "Got error writing basic query: " << ec << "\n";
+            }
+        });
+
+    auto response = std::make_shared<boost::asio::streambuf>();
+    response->prepare(1);
+
+    /* Gather the response and dispatch for parsing */
+    boost::asio::async_read(
+        respStream, *response,
+        [response](const boost::system::error_code& ec, std::size_t n) {
+            if (ec)
+            {
+                std::cerr << "Got error completing basic query: " << ec << "\n";
+                return static_cast<std::size_t>(0);
+            }
+
+            if (n == 0)
+            {
+                return static_cast<std::size_t>(1);
+            }
+
+            std::istream is(response.get());
+            size_t len = static_cast<std::size_t>(is.peek());
+
+            if (n > len + 1)
+            {
+                std::cerr << "Query stream has become unsynchronised: "
+                          << "n: " << n << ", "
+                          << "len: " << len << "\n";
+                return static_cast<std::size_t>(0);
+            }
+
+            if (n == len + 1)
+            {
+                return static_cast<std::size_t>(0);
+            }
+
+            if (n > 1)
+            {
+                return len + 1 - n;
+            }
+
+            response->prepare(len);
+            return len;
+        },
+        [weakSelf{weak_from_this()}, sensor, response](
+            const boost::system::error_code& ec, std::size_t length) mutable {
+            if (ec)
+            {
+                std::cerr << "Got error reading basic query: " << ec << "\n";
+                return;
+            }
+
+            if (length == 0)
+            {
+                std::cerr << "Invalid message length: " << length << "\n";
+                return;
+            }
+
+            if (auto self = weakSelf.lock())
+            {
+                /* Deserialise the response */
+                response->consume(1); /* Drop the length byte */
+                std::istream is(response.get());
+                std::vector<char> data(response->size());
+                is.read(data.data(), response->size());
+
+                /* Update the sensor */
+                self->processResponse(sensor, data.data(), data.size());
+
+                /* Enqueue processing of the next sensor */
+                self->readAndProcessNVMeSensor();
+            }
+        });
+}
+
+void NVMeBasicContext::pollNVMeDevices()
+{
+    pollCursor = sensors.begin();
+
+    scanTimer.expires_after(std::chrono::seconds(1));
+    scanTimer.async_wait([weakSelf{weak_from_this()}](
+                             const boost::system::error_code errorCode) {
+        if (errorCode == boost::asio::error::operation_aborted)
+        {
+            return;
+        }
+
+        if (errorCode)
+        {
+            std::cerr << errorCode.message() << "\n";
+            return;
+        }
+
+        if (auto self = weakSelf.lock())
+        {
+            self->readAndProcessNVMeSensor();
+        }
+    });
+}
+
+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 NVMeBasicContext::processResponse(std::shared_ptr<NVMeSensor>& sensor,
+                                       void* msg, size_t len)
+{
+    if (msg == nullptr || len < 6)
+    {
+        sensor->incrementError();
+        return;
+    }
+
+    uint8_t* messageData = static_cast<uint8_t*>(msg);
+
+    uint8_t status = messageData[0];
+    if (((status & NVME_MI_BASIC_SFLGS_DRIVE_NOT_READY) != 0) ||
+        ((status & NVME_MI_BASIC_SFLGS_DRIVE_FUNCTIONAL) == 0))
+    {
+        sensor->markFunctional(false);
+        return;
+    }
+
+    double value = getTemperatureReading(messageData[2]);
+    if (!std::isfinite(value))
+    {
+        sensor->incrementError();
+        return;
+    }
+
+    sensor->updateValue(value);
+}
diff --git a/src/nvme/NVMeBasicContext.hpp b/src/nvme/NVMeBasicContext.hpp
new file mode 100644
index 0000000..52b6a09
--- /dev/null
+++ b/src/nvme/NVMeBasicContext.hpp
@@ -0,0 +1,48 @@
+#pragma once
+
+#include "NVMeContext.hpp"
+
+#include <boost/asio/io_context.hpp>
+#include <boost/asio/posix/stream_descriptor.hpp>
+
+#include <thread>
+
+class NVMeBasicContext : public NVMeContext
+{
+  public:
+    NVMeBasicContext(boost::asio::io_context& io, int rootBus);
+    ~NVMeBasicContext() override = default;
+    void pollNVMeDevices() override;
+    void readAndProcessNVMeSensor() override;
+    void processResponse(std::shared_ptr<NVMeSensor>& sensor, void* msg,
+                         size_t len) override;
+
+  private:
+    NVMeBasicContext(boost::asio::io_context& io, int rootBus, int cmdOut,
+                     int streamIn, int streamOut, int cmdIn);
+    boost::asio::io_context& io;
+
+    // The IO thread must be destructed after the stream descriptors, so
+    // initialise it first. http://eel.is/c++draft/class.base.init#note-6
+    //
+    // Providing a stop-source to the thread execution function isn't
+    // particularly useful as it will spend most of its time blocked in a system
+    // call - ioctl() for the actual device communication, or read() and write()
+    // on the pipes associated with reqStream and respStream. Rather than trying
+    // to force a stop, rely on read()/write() failures from closed pipes to
+    // coerce it to exit and thus allow completion of the join().
+    std::jthread thread;
+
+    // Destruction of the stream descriptors has the effect of issuing cancel(),
+    // destroying the closure of the callback where we might be carrying
+    // weak_ptrs to `this`.
+    // https://www.boost.org/doc/libs/1_79_0/doc/html/boost_asio/reference/posix__basic_descriptor/_basic_descriptor.html
+    boost::asio::posix::stream_descriptor reqStream;
+    boost::asio::posix::stream_descriptor respStream;
+
+    enum
+    {
+        NVME_MI_BASIC_SFLGS_DRIVE_NOT_READY = 0x40,
+        NVME_MI_BASIC_SFLGS_DRIVE_FUNCTIONAL = 0x20,
+    };
+};
diff --git a/src/nvme/NVMeContext.hpp b/src/nvme/NVMeContext.hpp
new file mode 100644
index 0000000..4eb81e4
--- /dev/null
+++ b/src/nvme/NVMeContext.hpp
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "NVMeSensor.hpp"
+
+#include <boost/asio/io_context.hpp>
+#include <boost/asio/steady_timer.hpp>
+
+#include <memory>
+#include <stdexcept>
+
+class NVMeContext : public std::enable_shared_from_this<NVMeContext>
+{
+  public:
+    NVMeContext(boost::asio::io_context& io, int rootBus) :
+        scanTimer(io), rootBus(rootBus), pollCursor(sensors.end())
+    {
+        if (rootBus < 0)
+        {
+            throw std::invalid_argument(
+                "Invalid root bus: Bus ID must not be negative");
+        }
+    }
+
+    virtual ~NVMeContext()
+    {
+        scanTimer.cancel();
+    }
+
+    void addSensor(const std::shared_ptr<NVMeSensor>& sensor)
+    {
+        sensors.emplace_back(sensor);
+    }
+
+    std::optional<std::shared_ptr<NVMeSensor>>
+        getSensorAtPath(const std::string& path)
+    {
+        for (auto& sensor : sensors)
+        {
+            if (sensor->configurationPath == path)
+            {
+                return sensor;
+            }
+        }
+
+        return std::nullopt;
+    }
+
+    // Post-condition: The sensor list does not contain the provided sensor
+    // Post-condition: pollCursor is a valid iterator for the sensor list
+    void removeSensor(const std::shared_ptr<NVMeSensor>& sensor)
+    {
+        // Locate the sensor that we're removing in the sensor list
+        auto found = std::find(sensors.begin(), sensors.end(), sensor);
+
+        // If we failed to find the sensor in the list the post-condition is
+        // already satisfied
+        if (found == sensors.end())
+        {
+            return;
+        }
+
+        // We've found the sensor in the list
+
+        // If we're not actively polling the sensor list, then remove the sensor
+        if (pollCursor == sensors.end())
+        {
+            sensors.erase(found);
+            return;
+        }
+
+        // We're actively polling the sensor list
+
+        // If we're not polling the specific sensor that has been removed, then
+        // remove the sensor
+        if (*pollCursor != *found)
+        {
+            sensors.erase(found);
+            return;
+        }
+
+        // We're polling the sensor that is being removed
+
+        // Remove the sensor and update the poll cursor so the cursor remains
+        // valid
+        pollCursor = sensors.erase(found);
+    }
+
+    virtual void close()
+    {
+        scanTimer.cancel();
+    }
+
+    virtual void pollNVMeDevices() = 0;
+
+    virtual void readAndProcessNVMeSensor() = 0;
+
+    virtual void processResponse(std::shared_ptr<NVMeSensor>& sensor, void* msg,
+                                 size_t len) = 0;
+
+  protected:
+    boost::asio::steady_timer scanTimer;
+    int rootBus; // Root bus for this drive
+    std::list<std::shared_ptr<NVMeSensor>> sensors;
+    std::list<std::shared_ptr<NVMeSensor>>::iterator pollCursor;
+};
+
+using NVMEMap = boost::container::flat_map<int, std::shared_ptr<NVMeContext>>;
+
+NVMEMap& getNVMEMap();
diff --git a/src/nvme/NVMeSensor.cpp b/src/nvme/NVMeSensor.cpp
new file mode 100644
index 0000000..4c372d6
--- /dev/null
+++ b/src/nvme/NVMeSensor.cpp
@@ -0,0 +1,106 @@
+/*
+// 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 "NVMeSensor.hpp"
+
+#include "SensorPaths.hpp"
+#include "Thresholds.hpp"
+#include "Utils.hpp"
+#include "sensor.hpp"
+
+#include <boost/asio/io_context.hpp>
+#include <sdbusplus/asio/connection.hpp>
+#include <sdbusplus/asio/object_server.hpp>
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+static constexpr double maxReading = 127;
+static constexpr double minReading = 0;
+
+NVMeSensor::NVMeSensor(sdbusplus::asio::object_server& objectServer,
+                       boost::asio::io_context& /*unused*/,
+                       std::shared_ptr<sdbusplus::asio::connection>& conn,
+                       const std::string& sensorName,
+                       std::vector<thresholds::Threshold>&& thresholdsIn,
+                       const std::string& sensorConfiguration,
+                       const int busNumber, const uint8_t slaveAddr) :
+    Sensor(escapeName(sensorName), std::move(thresholdsIn), sensorConfiguration,
+           NVMeSensor::sensorType, false, false, maxReading, minReading, conn,
+           PowerState::on),
+    bus(busNumber), address(slaveAddr), objServer(objectServer)
+{
+    if (bus < 0)
+    {
+        throw std::invalid_argument("Invalid bus: Bus ID must not be negative");
+    }
+
+    sensorInterface = objectServer.add_interface(
+        "/xyz/openbmc_project/sensors/temperature/" + name,
+        "xyz.openbmc_project.Sensor.Value");
+
+    for (const auto& threshold : thresholds)
+    {
+        std::string interface = thresholds::getInterface(threshold.level);
+        thresholdInterfaces[static_cast<size_t>(threshold.level)] =
+            objectServer.add_interface(
+                "/xyz/openbmc_project/sensors/temperature/" + name, interface);
+    }
+    association = objectServer.add_interface(
+        "/xyz/openbmc_project/sensors/temperature/" + name,
+        association::interface);
+
+    setInitialProperties(sensor_paths::unitDegreesC);
+    // Mark as unavailable until the first packet has been received over NVMe
+    // MI.
+    markAvailable(false);
+}
+
+NVMeSensor::~NVMeSensor()
+{
+    // close the input dev to cancel async operations
+    for (const auto& iface : thresholdInterfaces)
+    {
+        objServer.remove_interface(iface);
+    }
+    objServer.remove_interface(sensorInterface);
+    objServer.remove_interface(association);
+}
+
+bool NVMeSensor::sample()
+{
+    if (inError())
+    {
+        if (scanDelay == 0)
+        {
+            scanDelay = scanDelayTicks;
+        }
+
+        scanDelay--;
+    }
+
+    return scanDelay == 0;
+}
+
+void NVMeSensor::checkThresholds()
+{
+    thresholds::checkThresholds(this);
+}
diff --git a/src/nvme/NVMeSensor.hpp b/src/nvme/NVMeSensor.hpp
new file mode 100644
index 0000000..a7cfba1
--- /dev/null
+++ b/src/nvme/NVMeSensor.hpp
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <boost/asio/io_context.hpp>
+#include <sensor.hpp>
+
+class NVMeSensor : public Sensor
+{
+  public:
+    static constexpr const char* sensorType = "NVME1000";
+
+    NVMeSensor(sdbusplus::asio::object_server& objectServer,
+               boost::asio::io_context& io,
+               std::shared_ptr<sdbusplus::asio::connection>& conn,
+               const std::string& sensorName,
+               std::vector<thresholds::Threshold>&& thresholds,
+               const std::string& sensorConfiguration, int busNumber,
+               uint8_t slaveAddr);
+    ~NVMeSensor() override;
+
+    NVMeSensor& operator=(const NVMeSensor& other) = delete;
+
+    bool sample();
+
+    const int bus;
+    const uint8_t address;
+
+  private:
+    const unsigned int scanDelayTicks = 5 * 60;
+    sdbusplus::asio::object_server& objServer;
+    unsigned int scanDelay{0};
+
+    void checkThresholds() override;
+};
diff --git a/src/nvme/NVMeSensorMain.cpp b/src/nvme/NVMeSensorMain.cpp
new file mode 100644
index 0000000..2fe295d
--- /dev/null
+++ b/src/nvme/NVMeSensorMain.cpp
@@ -0,0 +1,320 @@
+/*
+// 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 "NVMeBasicContext.hpp"
+#include "NVMeContext.hpp"
+#include "NVMeSensor.hpp"
+#include "Thresholds.hpp"
+#include "Utils.hpp"
+#include "VariantVisitors.hpp"
+
+#include <boost/asio/error.hpp>
+#include <boost/asio/io_context.hpp>
+#include <boost/asio/post.hpp>
+#include <boost/asio/steady_timer.hpp>
+#include <sdbusplus/asio/connection.hpp>
+#include <sdbusplus/asio/object_server.hpp>
+#include <sdbusplus/bus.hpp>
+#include <sdbusplus/bus/match.hpp>
+#include <sdbusplus/message.hpp>
+#include <sdbusplus/message/native_types.hpp>
+
+#include <algorithm>
+#include <array>
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <filesystem>
+#include <functional>
+#include <iostream>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <variant>
+#include <vector>
+
+static constexpr uint8_t nvmeMiDefaultSlaveAddr = 0x6A;
+
+static NVMEMap nvmeDeviceMap;
+
+NVMEMap& getNVMEMap()
+{
+    return nvmeDeviceMap;
+}
+
+static std::optional<int> extractBusNumber(
+    const std::string& path, const SensorBaseConfigMap& properties)
+{
+    auto findBus = properties.find("Bus");
+    if (findBus == properties.end())
+    {
+        std::cerr << "could not determine bus number for " << path << "\n";
+        return std::nullopt;
+    }
+
+    return std::visit(VariantToIntVisitor(), findBus->second);
+}
+
+static uint8_t extractSlaveAddr(const std::string& path,
+                                const SensorBaseConfigMap& properties)
+{
+    auto findSlaveAddr = properties.find("Address");
+    if (findSlaveAddr == properties.end())
+    {
+        std::cerr << "could not determine slave address for " << path << "\n"
+                  << "using default as specified in nvme-mi"
+                  << "\n";
+        return nvmeMiDefaultSlaveAddr;
+    }
+
+    return std::visit(VariantToUnsignedIntVisitor(), findSlaveAddr->second);
+}
+
+static std::optional<std::string> extractSensorName(
+    const std::string& path, const SensorBaseConfigMap& properties)
+{
+    auto findSensorName = properties.find("Name");
+    if (findSensorName == properties.end())
+    {
+        std::cerr << "could not determine configuration name for " << path
+                  << "\n";
+        return std::nullopt;
+    }
+
+    return std::get<std::string>(findSensorName->second);
+}
+
+static std::filesystem::path deriveRootBusPath(int busNumber)
+{
+    return "/sys/bus/i2c/devices/i2c-" + std::to_string(busNumber) +
+           "/mux_device";
+}
+
+static std::optional<int> deriveRootBus(std::optional<int> busNumber)
+{
+    if (!busNumber)
+    {
+        return std::nullopt;
+    }
+
+    std::filesystem::path muxPath = deriveRootBusPath(*busNumber);
+
+    if (!std::filesystem::is_symlink(muxPath))
+    {
+        return busNumber;
+    }
+
+    std::string rootName = std::filesystem::read_symlink(muxPath).filename();
+    size_t dash = rootName.find('-');
+    if (dash == std::string::npos)
+    {
+        std::cerr << "Error finding root bus for " << rootName << "\n";
+        return std::nullopt;
+    }
+
+    return std::stoi(rootName.substr(0, dash));
+}
+
+static std::shared_ptr<NVMeContext> provideRootBusContext(
+    boost::asio::io_context& io, NVMEMap& map, int rootBus)
+{
+    auto findRoot = map.find(rootBus);
+    if (findRoot != map.end())
+    {
+        return findRoot->second;
+    }
+
+    std::shared_ptr<NVMeContext> context =
+        std::make_shared<NVMeBasicContext>(io, rootBus);
+    map[rootBus] = context;
+
+    return context;
+}
+
+static void handleSensorConfigurations(
+    boost::asio::io_context& io, sdbusplus::asio::object_server& objectServer,
+    std::shared_ptr<sdbusplus::asio::connection>& dbusConnection,
+    const ManagedObjectType& sensorConfigurations)
+{
+    // todo: it'd be better to only update the ones we care about
+    for (const auto& [_, nvmeContextPtr] : nvmeDeviceMap)
+    {
+        if (nvmeContextPtr)
+        {
+            nvmeContextPtr->close();
+        }
+    }
+    nvmeDeviceMap.clear();
+
+    // iterate through all found configurations
+    for (const auto& [interfacePath, sensorData] : sensorConfigurations)
+    {
+        // find base configuration
+        auto sensorBase =
+            sensorData.find(configInterfaceName(NVMeSensor::sensorType));
+        if (sensorBase == sensorData.end())
+        {
+            continue;
+        }
+
+        const SensorBaseConfigMap& sensorConfig = sensorBase->second;
+        std::optional<int> busNumber =
+            extractBusNumber(interfacePath, sensorConfig);
+        std::optional<std::string> sensorName =
+            extractSensorName(interfacePath, sensorConfig);
+        uint8_t slaveAddr = extractSlaveAddr(interfacePath, sensorConfig);
+        std::optional<int> rootBus = deriveRootBus(busNumber);
+
+        if (!(busNumber && sensorName && rootBus))
+        {
+            continue;
+        }
+
+        std::vector<thresholds::Threshold> sensorThresholds;
+        if (!parseThresholdsFromConfig(sensorData, sensorThresholds))
+        {
+            std::cerr << "error populating thresholds for " << *sensorName
+                      << "\n";
+        }
+
+        try
+        {
+            // May throw for an invalid rootBus
+            std::shared_ptr<NVMeContext> context =
+                provideRootBusContext(io, nvmeDeviceMap, *rootBus);
+
+            // Construct the sensor after grabbing the context so we don't
+            // glitch D-Bus May throw for an invalid busNumber
+            std::shared_ptr<NVMeSensor> sensorPtr =
+                std::make_shared<NVMeSensor>(
+                    objectServer, io, dbusConnection, *sensorName,
+                    std::move(sensorThresholds), interfacePath, *busNumber,
+                    slaveAddr);
+
+            context->addSensor(sensorPtr);
+        }
+        catch (const std::invalid_argument& ex)
+        {
+            std::cerr << "Failed to add sensor for "
+                      << std::string(interfacePath) << ": " << ex.what()
+                      << "\n";
+        }
+    }
+    for (const auto& [_, context] : nvmeDeviceMap)
+    {
+        context->pollNVMeDevices();
+    }
+}
+
+void createSensors(boost::asio::io_context& io,
+                   sdbusplus::asio::object_server& objectServer,
+                   std::shared_ptr<sdbusplus::asio::connection>& dbusConnection)
+{
+    auto getter = std::make_shared<GetSensorConfiguration>(
+        dbusConnection, [&io, &objectServer, &dbusConnection](
+                            const ManagedObjectType& sensorConfigurations) {
+            handleSensorConfigurations(io, objectServer, dbusConnection,
+                                       sensorConfigurations);
+        });
+    getter->getConfiguration(std::vector<std::string>{NVMeSensor::sensorType});
+}
+
+static void interfaceRemoved(sdbusplus::message_t& message, NVMEMap& contexts)
+{
+    if (message.is_method_error())
+    {
+        std::cerr << "interfacesRemoved callback method error\n";
+        return;
+    }
+
+    sdbusplus::message::object_path path;
+    std::vector<std::string> interfaces;
+
+    message.read(path, interfaces);
+
+    for (auto& [_, context] : contexts)
+    {
+        std::optional<std::shared_ptr<NVMeSensor>> sensor =
+            context->getSensorAtPath(path);
+        if (!sensor)
+        {
+            continue;
+        }
+
+        auto interface = std::find(interfaces.begin(), interfaces.end(),
+                                   (*sensor)->configInterface);
+        if (interface == interfaces.end())
+        {
+            continue;
+        }
+
+        context->removeSensor(sensor.value());
+    }
+}
+
+int main()
+{
+    boost::asio::io_context io;
+    auto systemBus = std::make_shared<sdbusplus::asio::connection>(io);
+    systemBus->request_name("xyz.openbmc_project.NVMeSensor");
+    sdbusplus::asio::object_server objectServer(systemBus, true);
+    objectServer.add_manager("/xyz/openbmc_project/sensors");
+
+    boost::asio::post(io,
+                      [&]() { createSensors(io, objectServer, systemBus); });
+
+    boost::asio::steady_timer filterTimer(io);
+    std::function<void(sdbusplus::message_t&)> eventHandler =
+        [&filterTimer, &io, &objectServer, &systemBus](sdbusplus::message_t&) {
+            // this implicitly cancels the timer
+            filterTimer.expires_after(std::chrono::seconds(1));
+
+            filterTimer.async_wait([&](const boost::system::error_code& ec) {
+                if (ec == boost::asio::error::operation_aborted)
+                {
+                    return; // we're being canceled
+                }
+
+                if (ec)
+                {
+                    std::cerr << "Error: " << ec.message() << "\n";
+                    return;
+                }
+
+                createSensors(io, objectServer, systemBus);
+            });
+        };
+
+    std::vector<std::unique_ptr<sdbusplus::bus::match_t>> matches =
+        setupPropertiesChangedMatches(
+            *systemBus, std::to_array<const char*>({NVMeSensor::sensorType}),
+            eventHandler);
+
+    // Watch for entity-manager to remove configuration interfaces
+    // so the corresponding sensors can be removed.
+    auto ifaceRemovedMatch = std::make_unique<sdbusplus::bus::match_t>(
+        static_cast<sdbusplus::bus_t&>(*systemBus),
+        "type='signal',member='InterfacesRemoved',arg0path='" +
+            std::string(inventoryPath) + "/'",
+        [](sdbusplus::message_t& msg) {
+            interfaceRemoved(msg, nvmeDeviceMap);
+        });
+
+    setupManufacturingModeMatch(*systemBus);
+    io.run();
+}
diff --git a/src/nvme/meson.build b/src/nvme/meson.build
new file mode 100644
index 0000000..441d3e7
--- /dev/null
+++ b/src/nvme/meson.build
@@ -0,0 +1,13 @@
+nvme_srcs = files('NVMeSensor.cpp', 'NVMeSensorMain.cpp')
+nvme_srcs += files('NVMeBasicContext.cpp')
+
+nvme_deps = [default_deps, i2c, thresholds_dep, utils_dep, threads]
+src_inc = include_directories('..')
+
+executable(
+    'nvmesensor',
+    sources: nvme_srcs,
+    dependencies: nvme_deps,
+    include_directories: src_inc,
+    install: true,
+)
\ No newline at end of file