diff --git a/pyproject.toml b/pyproject.toml
index b053fe62..3b34ae74 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -27,6 +27,9 @@ Github = "https://github.com/ad-freiburg/qlever"
 
 [project.scripts]
 "qlever" = "qlever.qlever_main:main"
+"qmdb" = "qlever.qlever_main:main"
+"qoxigraph" = "qlever.qlever_main:main"
+"qlever-old" = "qlever.qlever_old:main"
 
 [tool.setuptools]
 license-files = ["LICENSE"]
diff --git a/src/qmdb/Dockerfile b/src/qmdb/Dockerfile
new file mode 100644
index 00000000..eb515348
--- /dev/null
+++ b/src/qmdb/Dockerfile
@@ -0,0 +1,63 @@
+# Clone the MillenniumDB repository as the first step
+FROM alpine:3.18 AS clone
+WORKDIR /mdb-src
+
+RUN apk --no-cache add git
+RUN git clone --depth 1 https://github.com/MillenniumDB/MillenniumDB.git .
+RUN ls -l /mdb-src
+
+# Build stage
+FROM alpine:3.18 AS build
+WORKDIR /mdb
+
+# Install necessary build tools and dependencies
+RUN apk --no-cache add cmake \
+                       make \
+                       g++ \
+                       openssl-dev \
+                       boost1.82-dev \
+                       ncurses-dev \
+                       icu-dev
+
+# Use files from the cloned repository
+COPY --from=clone /mdb-src/src src
+COPY --from=clone /mdb-src/CMakeLists.txt CMakeLists.txt
+COPY --from=clone /mdb-src/third_party/antlr4-runtime-4.13.1 third_party/antlr4-runtime-4.13.1
+
+# Build MillenniumDB
+RUN cmake -B build -D CMAKE_BUILD_TYPE=Release -D CMAKE_INSTALL_PREFIX=./ && \
+    cmake --build build -j $(($(getconf _NPROCESSORS_ONLN)-1)) --target install
+
+COPY --from=clone /mdb-src/browser browser
+
+# Final minimal stage (to minimize image size)
+FROM alpine:3.18 AS final
+WORKDIR /data
+
+# Install runtime dependencies
+RUN apk --no-cache add libstdc++ \
+                       libgcc \
+                       openssl \
+                       musl-locales \
+                       libncursesw \
+                       less \
+                       bash \
+                       icu-libs
+
+# Copy the binaries and browser from the build stage
+COPY --from=build /mdb/build/bin /usr/bin
+COPY --from=build /mdb/browser /browser
+
+# Set ownership to the user passed by UID and GID
+ARG UID
+ARG GID
+RUN if [ "${UID:-}" != "" ] && [ "${GID:-}" != "" ]; then \
+        chown -R ${UID}:${GID} /data; \
+    fi
+
+# Expose necessary volumes and environment variables
+VOLUME /data
+ENV MDB_BROWSER=/browser
+
+# Default command to run in the container
+CMD ["bash"]
diff --git a/src/qmdb/__init__.py b/src/qmdb/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/qmdb/commands/__init__.py b/src/qmdb/commands/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/qmdb/commands/benchmark_queries.py b/src/qmdb/commands/benchmark_queries.py
new file mode 100644
index 00000000..c3961f37
--- /dev/null
+++ b/src/qmdb/commands/benchmark_queries.py
@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from qlever.commands.benchmark_queries import (
+    BenchmarkQueriesCommand as QleverBenchmarkQueriesCommand,
+)
+
+
+class BenchmarkQueriesCommand(QleverBenchmarkQueriesCommand):
+    """
+    Run benchmark queries against the MillenniumDB SPARQL endpoint.
+    Overrides the default endpoint to use MillenniumDB's /sparql path.
+    """
+
+    def execute(self, args) -> bool:
+        if not args.sparql_endpoint:
+            args.sparql_endpoint = f"{args.host_name}:{args.port}/sparql"
+        return super().execute(args)
diff --git a/src/qmdb/commands/example_queries.py b/src/qmdb/commands/example_queries.py
new file mode 100644
index 00000000..d612b709
--- /dev/null
+++ b/src/qmdb/commands/example_queries.py
@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from qlever.commands.example_queries import (
+    ExampleQueriesCommand as QleverExampleQueriesCommand,
+)
+
+
+class ExampleQueriesCommand(QleverExampleQueriesCommand):
+    def execute(self, args) -> bool:
+        if not args.sparql_endpoint:
+            args.sparql_endpoint = f"{args.host_name}:{args.port}/sparql"
+        return super().execute(args)
diff --git a/src/qmdb/commands/extract_queries.py b/src/qmdb/commands/extract_queries.py
new file mode 120000
index 00000000..5667cc52
--- /dev/null
+++ b/src/qmdb/commands/extract_queries.py
@@ -0,0 +1 @@
+../../qlever/commands/extract_queries.py
\ No newline at end of file
diff --git a/src/qmdb/commands/get_data.py b/src/qmdb/commands/get_data.py
new file mode 120000
index 00000000..4900dbb8
--- /dev/null
+++ b/src/qmdb/commands/get_data.py
@@ -0,0 +1 @@
+../../qlever/commands/get_data.py
\ No newline at end of file
diff --git a/src/qmdb/commands/index.py b/src/qmdb/commands/index.py
new file mode 100644
index 00000000..7db60a03
--- /dev/null
+++ b/src/qmdb/commands/index.py
@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import qlever.util as util
+from qlever.command import QleverCommand
+from qlever.containerize import Containerize
+from qlever.log import log
+from qlever.memory_monitor import MemoryMonitor
+
+
+def wrap_cmd_in_container(args, cmd: str) -> str:
+    """
+    Wrap an indexing command in a container that is automatically
+    removed after the process exits (--rm).
+    """
+    return Containerize().containerize_command(
+        cmd=cmd,
+        container_system=args.system,
+        run_subcommand="run --rm",
+        image_name=args.image,
+        container_name=args.index_container,
+        volumes=[("$(pwd)", "/data")],
+        working_directory="/data",
+    )
+
+
+class IndexCommand(QleverCommand):
+    """
+    Build a MillenniumDB index for an RDF dataset. The indexing workflow is:
+    1. Run `mdb import` to import input files into the index directory.
+    2. For compressed data, pipe input through stdin with --format.
+
+    Supports native and containerized execution. When using containers,
+    the Docker image is built from the MillenniumDB GitHub repository
+    if not already present.
+    """
+
+    def __init__(self):
+        pass
+
+    def description(self) -> str:
+        return "Build the index for a given RDF dataset"
+
+    def should_have_qleverfile(self) -> bool:
+        return True
+
+    def relevant_qleverfile_arguments(self) -> dict[str, list[str]]:
+        return {
+            "data": ["name", "format"],
+            "index": [
+                "input_files",
+                "cat_input_files",
+                "buffer_strings",
+                "buffer_tensors",
+                "btree_permutations",
+                "prefixes",
+                "extra_args",
+            ],
+            "runtime": ["system", "image", "index_container"],
+        }
+
+    def additional_arguments(self, subparser):
+        subparser.add_argument(
+            "--index-binary",
+            type=str,
+            default="mdb",
+            help=(
+                "The binary for building the index (default: mdb) "
+                "(this requires that you have Millennium DB built from source "
+                "on your machine)"
+            ),
+        )
+        subparser.add_argument(
+            "--rebuild-image",
+            action="store_true",
+            default=False,
+            help="Rebuild the Docker image to get the latest updates",
+        )
+
+    def execute(self, args) -> bool:
+        system = args.system
+        input_files = args.input_files
+
+        # For compressed data, pipe the data from stdin with mandatory
+        # --format so MillenniumDB knows the RDF serialization.
+        if args.cat_input_files:
+            index_cmd = (
+                f"{args.cat_input_files} | {args.index_binary} import "
+                f"{args.name}_index --format {args.format}"
+            )
+        else:
+            index_cmd = (
+                f"{args.index_binary} import {input_files} {args.name}_index"
+            )
+
+        # Append MillenniumDB-specific index options (btree permutations,
+        # buffer sizes, prefix compression).
+        index_cmd += f" --btree-permutations {args.btree_permutations}"
+
+        if args.buffer_strings:
+            index_cmd += f" --buffer-strings {args.buffer_strings}B"
+        if args.buffer_tensors:
+            index_cmd += f" --buffer-tensors {args.buffer_tensors}B"
+
+        if args.prefixes:
+            index_cmd += f" --prefixes {args.prefixes}"
+        if args.extra_args:
+            index_cmd += f" {args.extra_args}"
+        index_cmd += f" | tee {args.name}.index-log.txt"
+
+        # For container execution, build the Docker image from the
+        # MillenniumDB repository if it is not already present.
+        image_id = build_cmd = ""
+        if args.system in Containerize.supported_systems():
+            index_cmd = wrap_cmd_in_container(args, index_cmd)
+            dockerfile_url = "https://github.com/MillenniumDB/MillenniumDB.git"
+            build_cmd = f"{system} build {dockerfile_url} -t {args.image}"
+
+            image_id = util.get_container_image_id(system, args.image)
+
+            cmd_to_show = (
+                f"{build_cmd}\n\n{index_cmd}"
+                if not image_id or args.rebuild_image
+                else index_cmd
+            )
+        else:
+            cmd_to_show = index_cmd
+
+        # Show the command line.
+        self.show(cmd_to_show, only_show=args.show)
+        if args.show:
+            return True
+
+        # Check if all of the input files exist.
+        if not util.input_files_exist(input_files):
+            return False
+
+        # Abort if a previous index already exists. Any files in the
+        # index directory indicate an existing store.
+        index_dir = Path(f"{args.name}_index")
+        if index_dir.exists() and any(index_dir.iterdir()):
+            log.error(
+                f"Index files found in {args.name}_index directory "
+                "which shows presence of a previous index\n"
+            )
+            log.info("Aborting the index operation...")
+            return False
+
+        if args.system in Containerize.supported_systems():
+            if Containerize().is_running(args.system, args.index_container):
+                log.info(
+                    f"{args.system} container {args.index_container} is still up, "
+                    "which means that data loading is in progress. Please wait..."
+                )
+                return False
+
+            # Build the docker image if not found on the system
+            if not image_id or args.rebuild_image:
+                build_successful = util.build_image(
+                    build_cmd, system, args.image
+                )
+                if not build_successful:
+                    return False
+            else:
+                log.info(f"{args.image} image present on the system\n")
+        else:
+            # When running natively, check if the binary exists and works.
+            if not util.binary_exists(args.index_binary, "index-binary", args):
+                return False
+
+        # Run the index command.
+        try:
+            with MemoryMonitor(
+                dataset=args.name,
+                cmdline_regex=args.index_binary,
+                container=args.index_container,
+                system=args.system,
+            ):
+                util.run_command(index_cmd, show_output=True)
+        except Exception as e:
+            log.error(f"Building the index failed: {e}")
+            return False
+
+        return True
diff --git a/src/qmdb/commands/index_stats.py b/src/qmdb/commands/index_stats.py
new file mode 100644
index 00000000..ee5b18e6
--- /dev/null
+++ b/src/qmdb/commands/index_stats.py
@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import re
+
+from qlever.commands.index_stats import (
+    IndexStatsCommand as QleverIndexStatsCommand,
+)
+from qlever.commands.index_stats import (
+    get_size_unit,
+    get_size_unit_factor,
+    get_time_unit,
+    get_time_unit_factor,
+)
+from qlever.log import log
+from qlever.util import get_total_file_size
+
+
+class IndexStatsCommand(QleverIndexStatsCommand):
+    """
+    Show index build time and disk space usage for a MillenniumDB dataset.
+    Time is parsed from the "duration:" lines in the index log; space is
+    the total size of all files in the index directory.
+    """
+
+    def execute_time(
+        self, args, log_file_name: str
+    ) -> dict[str, tuple[float | None, str]]:
+        """
+        Parse the MillenniumDB index log to extract build times. Each log
+        line matching "<label> duration: <value> <unit>" produces one entry.
+        The "total import" label is normalized to "TOTAL time".
+        """
+
+        # Read the content of `log_file_name` into a list of lines.
+        try:
+            with open(log_file_name, "r") as log_file:
+                lines = log_file.readlines()
+        except Exception as e:
+            log.error(f"Problem reading index log file {log_file_name}: {e}")
+            return {}
+
+        stats = {}
+        # Pattern: "<label> = <number> seconds"
+        pattern = re.compile(
+            r"^(.*?)\s*duration:\s*([\d.]+)\s*(milliseconds|seconds|minutes|hours)",
+            re.IGNORECASE,
+        )
+
+        unit_to_seconds = {
+            "milliseconds": 1 / 1000,
+            "seconds": 1,
+            "minutes": 60,
+            "hours": 3600,
+        }
+
+        for line in lines:
+            label = raw_value = mdb_time_unit = None
+            match = pattern.search(line)
+            if match:
+                label = match.group(1).strip()
+                if label.lower() == "total import":
+                    label = "TOTAL time"
+                raw_value = match.group(2)
+                mdb_time_unit = match.group(3).lower()
+
+            if raw_value is None or mdb_time_unit is None:
+                continue
+
+            try:
+                value = float(raw_value)
+            except (ValueError, TypeError):
+                continue
+
+            factor = unit_to_seconds.get(mdb_time_unit)
+            if factor is None:
+                continue
+
+            value_s = value * factor
+
+            time_unit = get_time_unit(args.time_unit, value_s)
+            unit_factor = get_time_unit_factor(time_unit)
+
+            normalized_value = value_s / unit_factor
+            stats[label] = (normalized_value, time_unit)
+
+        return stats
+
+    def execute_space(self, args) -> dict[str, tuple[float, str]]:
+        """
+        Return the space used by the index files (all files in the index
+        directory) along with the unit.
+        """
+        index_size = get_total_file_size([f"{args.name}_index/*"])
+
+        size_unit = get_size_unit(args.size_unit, index_size)
+        unit_factor = get_size_unit_factor(size_unit)
+
+        index_size /= unit_factor
+
+        return {"TOTAL size": (index_size, size_unit)}
diff --git a/src/qmdb/commands/log.py b/src/qmdb/commands/log.py
new file mode 120000
index 00000000..90ffabb4
--- /dev/null
+++ b/src/qmdb/commands/log.py
@@ -0,0 +1 @@
+../../qlever/commands/log.py
\ No newline at end of file
diff --git a/src/qmdb/commands/query.py b/src/qmdb/commands/query.py
new file mode 100644
index 00000000..528c3b08
--- /dev/null
+++ b/src/qmdb/commands/query.py
@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from qoxigraph.commands.query import QueryCommand as QoxigraphQueryCommand
+
+
+class QueryCommand(QoxigraphQueryCommand):
+    """
+    Send a SPARQL query to the MillenniumDB server. Extends the base query
+    command with MillenniumDB's /sparql endpoint.
+    """
+
+    def execute(self, args) -> bool:
+        if not args.sparql_endpoint:
+            args.sparql_endpoint = f"{args.host_name}:{args.port}/sparql"
+        super().execute(args)
diff --git a/src/qmdb/commands/setup_config.py b/src/qmdb/commands/setup_config.py
new file mode 100644
index 00000000..68ad6896
--- /dev/null
+++ b/src/qmdb/commands/setup_config.py
@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import math
+
+from qlever.util import add_memory_options
+from qoxigraph.commands.setup_config import (
+    SetupConfigCommand as QoxigraphSetupConfigCommand,
+)
+
+
+class SetupConfigCommand(QoxigraphSetupConfigCommand):
+    """
+    Create a Qleverfile for MillenniumDB from a dataset template. Extends
+    the base setup-config with MillenniumDB-specific memory budget options
+    (--total-index-memory, --total-server-memory) that auto-generate
+    sensible buffer size defaults for indexing and serving.
+    """
+
+    IMAGE = "adfreiburg/millenniumdb"
+
+    FILTER_CRITERIA = QoxigraphSetupConfigCommand.FILTER_CRITERIA
+    FILTER_CRITERIA["index"].append("CAT_INPUT_FILES")
+
+    @staticmethod
+    def construct_engine_specific_params(args) -> dict[str, dict[str, str]]:
+        """
+        Derive MillenniumDB-specific Qleverfile parameters from the memory
+        budget. Splits index memory evenly between tensor and string buffers.
+        For server memory >4G, allocates versioned, unversioned, and string
+        buffers using a log-based heuristic.
+        """
+        index_memory = int(args.total_index_memory[:-1])
+        server_memory = int(args.total_server_memory[:-1])
+
+        mdb_index_config = {}
+        if index_memory >= 2:
+            buffer_tensors = index_memory // 2
+            mdb_index_config["BUFFER_TENSORS"] = f"{buffer_tensors}G"
+            mdb_index_config["BUFFER_STRINGS"] = (
+                f"{index_memory - buffer_tensors}G"
+            )
+
+        mdb_server_config = {
+            "TIMEOUT": "60s",
+            "THREADS": "2",
+        }
+
+        if server_memory > 4:
+            unversioned_buffer = 1 if server_memory < 32 else 2
+            strings_buffer = max(1, int(math.log2(server_memory)) - 1)
+            versioned_buffer = (
+                server_memory - unversioned_buffer - (2 * strings_buffer)
+            )
+
+            mdb_server_config["VERSIONED_BUFFER"] = f"{versioned_buffer}G"
+            mdb_server_config["UNVERSIONED_BUFFER"] = f"{unversioned_buffer}G"
+            mdb_server_config["STRINGS_STATIC"] = f"{strings_buffer}G"
+            mdb_server_config["STRINGS_DYNAMIC"] = f"{strings_buffer}G"
+
+        final_config = {}
+        if mdb_index_config:
+            final_config["index"] = mdb_index_config
+        final_config["server"] = mdb_server_config
+
+        return final_config
+
+    def additional_arguments(self, subparser) -> None:
+        super().additional_arguments(subparser)
+        add_memory_options(subparser)
diff --git a/src/qmdb/commands/start.py b/src/qmdb/commands/start.py
new file mode 100644
index 00000000..a864fcf5
--- /dev/null
+++ b/src/qmdb/commands/start.py
@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+import time
+from pathlib import Path
+
+import qlever.util as util
+from qlever import script_name
+from qlever.command import QleverCommand
+from qlever.containerize import Containerize
+from qlever.log import log
+from qmdb.commands.stop import StopCommand
+
+MDB_SPECIFIC_SERVER_ARGS = [
+    "strings_dynamic",
+    "strings_static",
+    "tensors_dynamic",
+    "tensors_static",
+    "private_buffer",
+    "versioned_buffer",
+    "unversioned_buffer",
+]
+
+
+def wrap_cmd_in_container(args, cmd: str) -> str:
+    """Wrap the server start command in a container with restart policy."""
+    run_subcommand = "run --restart=unless-stopped"
+    if not args.run_in_foreground:
+        run_subcommand += " -d"
+    return Containerize().containerize_command(
+        cmd=cmd,
+        container_system=args.system,
+        run_subcommand=run_subcommand,
+        image_name=args.image,
+        container_name=args.server_container,
+        volumes=[("$(pwd)", "/data")],
+        working_directory="/data",
+        ports=[(args.port, args.port)],
+    )
+
+
+class StartCommand(QleverCommand):
+    """
+    Start the MillenniumDB SPARQL server for an already-indexed dataset.
+    Supports both native and containerized execution, with an option
+    to run in the foreground. Appends optional memory buffer arguments
+    (strings, tensors, versioned/unversioned) when configured.
+    """
+
+    def __init__(self):
+        pass
+
+    def description(self) -> str:
+        return (
+            "Start the server for MillenniumDB (requires that you have built an "
+            "index before)"
+        )
+
+    def should_have_qleverfile(self) -> bool:
+        return True
+
+    def relevant_qleverfile_arguments(self) -> dict[str, list[str]]:
+        return {
+            "data": ["name"],
+            "server": [
+                "host_name",
+                "server_binary",
+                "timeout",
+                "port",
+                "threads",
+                "extra_args",
+                *MDB_SPECIFIC_SERVER_ARGS,
+            ],
+            "runtime": ["system", "image", "server_container"],
+        }
+
+    def additional_arguments(self, subparser):
+        subparser.add_argument(
+            "--run-in-foreground",
+            action="store_true",
+            default=False,
+            help=(
+                "Run the start command in the foreground "
+                "(default: run in the background)"
+            ),
+        )
+
+    def execute(self, args) -> bool:
+        try:
+            timeout = int(args.timeout[:-1])
+        except ValueError as e:
+            log.error(f"Invalid timeout value {args.timeout}. Error: {e}")
+            return False
+
+        start_cmd = (
+            f"{args.server_binary} server {args.name}_index "
+            f"--port {args.port} --timeout {timeout} "
+        )
+        if args.threads is not None:
+            start_cmd += f"--threads {args.threads} "
+        # Append optional MillenniumDB-specific buffer arguments when set.
+        for arg in MDB_SPECIFIC_SERVER_ARGS:
+            if (arg_value := getattr(args, arg)) is not None and arg_value:
+                start_cmd += f"--{arg.replace('_', '-')} {arg_value}B "
+
+        if args.extra_args:
+            start_cmd += args.extra_args
+
+        start_cmd = f"{start_cmd} > {args.name}.server-log.txt 2>&1"
+        if args.system in Containerize.supported_systems():
+            start_cmd = wrap_cmd_in_container(args, start_cmd)
+        else:
+            if not args.run_in_foreground:
+                start_cmd = f"nohup {start_cmd} &"
+
+        # Show the command line.
+        self.show(start_cmd, only_show=args.show)
+        if args.show:
+            return True
+
+        # When running natively, check if the binary exists and works.
+        if args.system not in Containerize.supported_systems():
+            if not util.binary_exists(args.server_binary, "server-binary", args):
+                return False
+
+        # Check if index files are present in the index directory.
+        index_dir = Path(f"{args.name}_index")
+        if not index_dir.exists() or not any(index_dir.iterdir()):
+            log.error(f"No MillenniumDB index files for {args.name} found!\n")
+            log.info(
+                f"Did you call `{script_name} index`? If you did, check "
+                "if index files are present in the index directory."
+            )
+            return False
+
+        # Check if server already alive at endpoint url from a previous run.
+        endpoint_url = f"http://{args.host_name}:{args.port}"
+        if util.is_server_alive(url=endpoint_url):
+            log.error(
+                f"MillenniumDB server already running on {endpoint_url}/sparql\n"
+            )
+            log.info(
+                f"To kill the existing server, use `{script_name} stop`"
+            )
+            return False
+
+        # Remove old log file so that tail starts clean.
+        log_file = Path(f"{args.name}.server-log.txt")
+        log_file.unlink(missing_ok=True)
+
+        try:
+            process = util.run_command(
+                start_cmd,
+                use_popen=args.run_in_foreground,
+            )
+        except Exception as e:
+            log.error(f"Starting the MillenniumDB server failed ({e})")
+            return False
+
+        # Tail the server log until the server is ready (note that the `exec`
+        # is important to make sure that the tail process is killed and not
+        # just the bash process).
+        if args.run_in_foreground:
+            log.info(
+                "Follow the server logs as long as the server is"
+                " running (Ctrl-C stops the server)"
+            )
+        else:
+            log.info(
+                "Follow the server logs until the server is ready"
+                " (Ctrl-C stops following the log, but NOT the server)"
+            )
+        log.info("")
+        log_proc = util.tail_log_file(log_file)
+        if log_proc is None:
+            return False
+        while not util.is_server_alive(endpoint_url):
+            time.sleep(1)
+
+        log.info(
+            "MillenniumDB server sparql endpoint for queries is "
+            f"{endpoint_url}/sparql"
+        )
+
+        # Kill the log process
+        if not args.run_in_foreground:
+            log_proc.terminate()
+
+        # With `--run-in-foreground`, wait until the server is stopped.
+        # On Ctrl-C, terminate the process and clean up the container.
+        if args.run_in_foreground:
+            try:
+                process.wait()
+            except KeyboardInterrupt:
+                process.terminate()
+                # Remove the container if the user stops the server process
+                if args.system in Containerize.supported_systems():
+                    args.cmdline_regex = StopCommand.DEFAULT_REGEX
+                    StopCommand().execute(args)
+            log_proc.terminate()
+
+        return True
diff --git a/src/qmdb/commands/status.py b/src/qmdb/commands/status.py
new file mode 100644
index 00000000..69c8f867
--- /dev/null
+++ b/src/qmdb/commands/status.py
@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from qoxigraph.commands.status import StatusCommand as QoxigraphStatusCommand
+
+
+class StatusCommand(QoxigraphStatusCommand):
+    """Show running MillenniumDB server processes by matching the process name."""
+
+    DEFAULT_REGEX = "mdb\\s+server"
+
+    def description(self) -> str:
+        return "Show MillenniumDB processes running on this machine"
diff --git a/src/qmdb/commands/stop.py b/src/qmdb/commands/stop.py
new file mode 100644
index 00000000..c5b09618
--- /dev/null
+++ b/src/qmdb/commands/stop.py
@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from qmdb.commands.status import StatusCommand
+from qoxigraph.commands.stop import StopCommand as QoxigraphStopCommand
+
+
+class StopCommand(QoxigraphStopCommand):
+    """
+    Stop a running MillenniumDB server. Matches the mdb server process
+    by its dataset name argument so that only the server for the given
+    dataset is stopped.
+    """
+
+    STATUS_COMMAND = StatusCommand()
+    # %%NAME%% is replaced with args.name at execution time
+    DEFAULT_REGEX = r"mdb\s+server.*%%NAME%%_index"
+
+    def description(self) -> str:
+        return "Stop MillenniumDB server for a given dataset"
diff --git a/src/qmdb/qleverfile.py b/src/qmdb/qleverfile.py
new file mode 100644
index 00000000..d5a4c48f
--- /dev/null
+++ b/src/qmdb/qleverfile.py
@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+
+def qleverfile_args(all_args: dict[str, dict[str, tuple]]) -> None:
+    """
+    Define MillenniumDB-specific Qleverfile parameters for the [data],
+    [index], and [server] sections. These include the mdb binary for
+    indexing with buffer sizes and btree permutations, and the mdb server
+    binary with its thread count, timeout, and memory buffer settings.
+    """
+
+    def arg(*args, **kwargs):
+        return (args, kwargs)
+
+    data_args = all_args["data"]
+    index_args = all_args["index"]
+    server_args = all_args["server"]
+
+    data_args["format"] = arg(
+        "--format",
+        type=str,
+        default="ttl",
+        choices=["ttl", "nt", "n3", "rdf", "gql", "qm"],
+        help="Specify the file format",
+    )
+
+    index_args["index_binary"] = arg(
+        "--index-binary",
+        type=str,
+        default="mdb",
+        help=(
+            "The binary for building the index (default: mdb) "
+            "(this requires that you have MillenniumDB built from source "
+            "on your machine)"
+        ),
+    )
+    index_args["buffer_strings"] = arg(
+        "--buffer-strings",
+        type=str,
+        default=None,
+        help="Size of buffer for strings used during import",
+    )
+    index_args["buffer_tensors"] = arg(
+        "--buffer-tensors",
+        type=str,
+        default=None,
+        help="Size of buffer for tensors used during import",
+    )
+    index_args["prefixes"] = arg(
+        "--prefixes",
+        type=str,
+        default=None,
+        help="Prefixes file path (for IRI compression)",
+    )
+    index_args["btree_permutations"] = arg(
+        "--btree-permutations",
+        type=int,
+        choices=[3, 4, 6],
+        default=4,
+        help="Btree permutations -> 3, 4 or 6",
+    )
+    index_args["extra_args"] = arg(
+        "--extra-args",
+        type=str,
+        default=None,
+        help=(
+            "Additional arguments to pass directly to the mdb import process. "
+            "This allows advanced users to specify options not exposed in "
+            "Qleverfile. The string is appended verbatim to the command."
+        ),
+    )
+
+    server_args["server_binary"] = arg(
+        "--server-binary",
+        type=str,
+        default="mdb",
+        help=(
+            "The binary for starting the server (default: mdb) "
+            "(this requires that you have MillenniumDB built from source "
+            "on your machine)"
+        ),
+    )
+    server_args["timeout"] = arg(
+        "--timeout",
+        type=str,
+        default="60s",
+        help="The maximal time in seconds a query is allowed to run",
+    )
+    server_args["threads"] = arg(
+        "--threads",
+        type=int,
+        default=None,
+        help="Number of worker threads (default = auto)",
+    )
+    server_args["strings_dynamic"] = arg(
+        "--strings-dynamic",
+        type=str,
+        default=None,
+        help="Size for the strings-dynamic-buffer",
+    )
+    server_args["strings_static"] = arg(
+        "--strings-static",
+        type=str,
+        default=None,
+        help="Size for static strings-static-buffer",
+    )
+    server_args["tensors_dynamic"] = arg(
+        "--tensors-dynamic",
+        type=str,
+        default=None,
+        help="Size for the tensors-dynamic-buffer",
+    )
+    server_args["tensors_static"] = arg(
+        "--tensors-static",
+        type=str,
+        default=None,
+        help="Size for static tensors-static-buffer",
+    )
+    server_args["private_buffer"] = arg(
+        "--private-buffer",
+        type=str,
+        default=None,
+        help="Size for the private-buffer",
+    )
+    server_args["versioned_buffer"] = arg(
+        "--versioned-buffer",
+        type=str,
+        default=None,
+        help="Size for the versioned-buffer",
+    )
+    server_args["unversioned_buffer"] = arg(
+        "--unversioned-buffer",
+        type=str,
+        default=None,
+        help="Size for the unversioned-buffer",
+    )
+    server_args["extra_args"] = arg(
+        "--extra-args",
+        type=str,
+        default=None,
+        help=(
+            "Additional arguments to pass directly to the mdb server process. "
+            "This allows advanced users to specify options not exposed in "
+            "Qleverfile. The string is appended verbatim to the command."
+        ),
+    )
diff --git a/src/qoxigraph/__init__.py b/src/qoxigraph/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/qoxigraph/commands/__init__.py b/src/qoxigraph/commands/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/qoxigraph/commands/benchmark_queries.py b/src/qoxigraph/commands/benchmark_queries.py
new file mode 100644
index 00000000..4f285520
--- /dev/null
+++ b/src/qoxigraph/commands/benchmark_queries.py
@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from qlever.commands.benchmark_queries import (
+    BenchmarkQueriesCommand as QleverBenchmarkQueriesCommand,
+)
+
+
+class BenchmarkQueriesCommand(QleverBenchmarkQueriesCommand):
+    """
+    Run benchmark queries against the Oxigraph SPARQL endpoint.
+    Overrides the default endpoint to use Oxigraph's /query path.
+    """
+
+    def execute(self, args) -> bool:
+        if not args.sparql_endpoint:
+            args.sparql_endpoint = f"{args.host_name}:{args.port}/query"
+        return super().execute(args)
diff --git a/src/qoxigraph/commands/example_queries.py b/src/qoxigraph/commands/example_queries.py
new file mode 100644
index 00000000..4ef76c24
--- /dev/null
+++ b/src/qoxigraph/commands/example_queries.py
@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from qlever.commands.example_queries import (
+    ExampleQueriesCommand as QleverExampleQueriesCommand,
+)
+
+
+class ExampleQueriesCommand(QleverExampleQueriesCommand):
+    def execute(self, args) -> bool:
+        if not args.sparql_endpoint:
+            args.sparql_endpoint = f"{args.host_name}:{args.port}/query"
+        return super().execute(args)
diff --git a/src/qoxigraph/commands/extract_queries.py b/src/qoxigraph/commands/extract_queries.py
new file mode 120000
index 00000000..5667cc52
--- /dev/null
+++ b/src/qoxigraph/commands/extract_queries.py
@@ -0,0 +1 @@
+../../qlever/commands/extract_queries.py
\ No newline at end of file
diff --git a/src/qoxigraph/commands/get_data.py b/src/qoxigraph/commands/get_data.py
new file mode 100644
index 00000000..29bba0e2
--- /dev/null
+++ b/src/qoxigraph/commands/get_data.py
@@ -0,0 +1 @@
+from qlever.commands.get_data import GetDataCommand  # noqa
diff --git a/src/qoxigraph/commands/index.py b/src/qoxigraph/commands/index.py
new file mode 100644
index 00000000..ef621db1
--- /dev/null
+++ b/src/qoxigraph/commands/index.py
@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+import shlex
+import time
+from pathlib import Path
+
+import qlever.util as util
+from qlever.command import QleverCommand
+from qlever.containerize import Containerize
+from qlever.log import log
+from qlever.resource_usage.resource_monitor import ResourceMonitor
+
+
+def wrap_cmd_in_container(args, cmd: str, ulimit: int | None = None) -> str:
+    """
+    Wrap an indexing command in a container that is automatically removed
+    after the process exits (`--rm`) Use `use_bash=False` as Oxigraph image
+    doesn't support bash entrypoint.
+    """
+    run_subcommand = "run --rm"
+    if ulimit:
+        run_subcommand += f" --ulimit nofile={ulimit}:{ulimit}"
+    return Containerize().containerize_command(
+        cmd=cmd,
+        container_system=args.system,
+        run_subcommand=run_subcommand,
+        image_name=args.image,
+        container_name=args.index_container,
+        volumes=[("$(pwd)", "/opt")],
+        working_directory="/opt",
+        use_bash=False,
+    )
+
+
+def render_usage_plot(args, plot_only: bool = False) -> Path | None:
+    """Render the resource-usage plot.
+
+    When the plotting libraries are missing, this is an error if the
+    user asked for the plot directly via `plot_only`, otherwise it notes
+    how to get the plot at info level since the index build succeeded.
+    """
+    try:
+        from qoxigraph.resource_usage.usage_plot import UsagePlot
+    except ImportError:
+        if plot_only:
+            log.error(
+                "Resource-usage plot needs matplotlib and numpy "
+                "(`pip install qlever[plot]`). Install them and rerun."
+            )
+        else:
+            log.info(
+                "To plot the resource-usage log, install matplotlib and "
+                "numpy (`pip install qlever[plot]`), then run "
+                "`qoxigraph index --resource-usage-plot-only`."
+            )
+        return None
+    return UsagePlot(
+        args.name, args, plot_max_points=args.resource_usage_plot_max_points
+    ).render()
+
+
+class IndexCommand(QleverCommand):
+    """
+    Build an Oxigraph index for an RDF dataset. The indexing workflow is:
+    1. Run `oxigraph load` to import input files into a RocksDB store.
+    2. Optionally run `oxigraph optimize` to compact storage for read-only use.
+
+    For large datasets (>5 GB), the file descriptor ulimit is raised
+    automatically because RocksDB opens many .sst files concurrently.
+    """
+
+    def __init__(self):
+        pass
+
+    def description(self) -> str:
+        return "Build the index for a given RDF dataset"
+
+    def should_have_qleverfile(self) -> bool:
+        return True
+
+    def relevant_qleverfile_arguments(self) -> dict[str, list[str]]:
+        return {
+            "data": ["name", "format"],
+            "index": [
+                "input_files",
+                "ulimit",
+                "index_binary",
+                "lenient",
+                "extra_args",
+                "resource_usage_interval",
+                "resource_usage_plot_max_points",
+            ],
+            "server": ["read_only"],
+            "runtime": ["system", "image", "index_container"],
+        }
+
+    def additional_arguments(self, subparser) -> None:
+        subparser.add_argument(
+            "--resource-usage-plot-only",
+            action="store_true",
+            default=False,
+            help="Only render the resource-usage plot from the existing "
+            "`<name>.index.resource-usage-log.tsv`; do not build the index. "
+            "Use after installing the plotting libraries, or to re-render "
+            "with a different `--resource-usage-plot-max-points`",
+        )
+
+    def execute(self, args) -> bool:
+        # Render the resource-usage plot from the existing log without
+        # rebuilding the index.
+        if args.resource_usage_plot_only:
+            plot_path = render_usage_plot(args, plot_only=True)
+            if plot_path is None:
+                return False
+            log.info(f"Resource-usage plot saved to `{plot_path.name}`")
+            return True
+
+        cmds_to_execute = []
+        index_cmd = (
+            f"load {'--lenient ' if args.lenient == 'yes' else ''}"
+            f"--location {args.name}_index/ --file {args.input_files} "
+            f"{args.extra_args} |& tee {args.name}.index-log.txt"
+        )
+
+        ulimit = args.ulimit
+        # RocksDB opens many .sst files concurrently. For datasets larger
+        # than 5 GB, raise the file descriptor limit so the process does
+        # not hit the default OS soft limit.
+        total_file_size = util.get_total_file_size(
+            shlex.split(args.input_files)
+        )
+        if not ulimit and total_file_size > 5e9:
+            ulimit = 500_000
+        if args.system in Containerize.supported_systems():
+            index_cmd = wrap_cmd_in_container(args, index_cmd, ulimit)
+        else:
+            index_cmd = f"{args.index_binary} {index_cmd}"
+            if ulimit:
+                index_cmd = f"ulimit -Sn {ulimit} && {index_cmd}"
+
+        cmds_to_execute.append(index_cmd)
+
+        # Compact the RocksDB storage for read-only serving. This reduces
+        # disk usage and speeds up queries but makes the index immutable.
+        optimize_cmd = None
+        if args.read_only == "yes":
+            optimize_cmd = f"optimize -l {args.name}_index/"
+            if args.system in Containerize.supported_systems():
+                optimize_cmd = wrap_cmd_in_container(args, optimize_cmd)
+            else:
+                optimize_cmd = f"{args.index_binary} {optimize_cmd}"
+            cmds_to_execute.append(optimize_cmd)
+
+        # Show the command line.
+        self.show("\n".join(cmds_to_execute), only_show=args.show)
+        if args.show:
+            return True
+
+        if not util.input_files_exist(args.input_files):
+            return False
+
+        # When running natively, check if the binary exists and works.
+        if args.system in Containerize.supported_systems():
+            if Containerize().is_running(args.system, args.index_container):
+                log.info(
+                    f"{args.system} container {args.index_container} is still up, "
+                    "which means that data loading is in progress. Please wait..."
+                )
+                return False
+        else:
+            if not util.binary_exists(args.index_binary, "index-binary", args):
+                return False
+
+        # Abort if a previous index already exists. RocksDB .sst files in
+        # the index directory indicate an existing store.
+        if (
+            len([p.name for p in Path(f"{args.name}_index").glob("*.sst")])
+            != 0
+        ):
+            log.error(
+                f"Index files (*.sst) found in {args.name}_index directory "
+                "which shows presence of a previous index"
+            )
+            log.info("")
+            log.info("Aborting the index operation...")
+            return False
+
+        # Run the index command and record the elapsed time in the log
+        # file. Oxigraph's progress output is unreliable (may not print a
+        # final summary line when loading multiple files), so we measure
+        # the time externally.
+        #
+        log_file_name = f"{args.name}.index-log.txt"
+        with ResourceMonitor(
+            dataset=args.name,
+            binary=args.index_binary,
+            container=args.index_container,
+            system=args.system,
+            interval=args.resource_usage_interval,
+        ):
+            try:
+                load_start = time.time()
+                util.run_command(index_cmd, show_output=True, show_stderr=True)
+                load_s = time.time() - load_start
+            except Exception as e:
+                log.error(f"Building the index failed: {e}")
+                return False
+
+            optimize_s = 0.0
+            if optimize_cmd:
+                try:
+                    log.info("")
+                    log.info("Optimizing read-only database storage:")
+                    self.show(optimize_cmd)
+                    optimize_start = time.time()
+                    util.run_command(
+                        optimize_cmd, show_output=True, show_stderr=True
+                    )
+                    optimize_s = time.time() - optimize_start
+                except Exception as e:
+                    log.error(f"Optimizing the database storage failed: {e}")
+                    log.info(
+                        f"Please run manually: "
+                        f"{args.index_binary} optimize -l {args.name}_index/"
+                    )
+
+        with open(log_file_name, "a") as f:
+            f.write(f"Load time: {load_s:.0f}s\n")
+            if optimize_cmd:
+                f.write(f"Optimize time: {optimize_s:.0f}s\n")
+            f.write(f"TOTAL time: {load_s + optimize_s:.0f}s\n")
+
+        plot_path = render_usage_plot(args)
+        if plot_path is not None:
+            log.info(f"Resource-usage plot saved to `{plot_path.name}`")
+
+        return True
diff --git a/src/qoxigraph/commands/index_stats.py b/src/qoxigraph/commands/index_stats.py
new file mode 100644
index 00000000..bdfdbe39
--- /dev/null
+++ b/src/qoxigraph/commands/index_stats.py
@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import qlever.util as util
+from qlever.commands.index_stats import (
+    IndexStatsCommand as QleverIndexStatsCommand,
+)
+from qlever.commands.index_stats import (
+    get_size_unit,
+    get_size_unit_factor,
+    get_time_unit,
+    get_time_unit_factor,
+)
+from qlever.log import log
+from qoxigraph.resource_usage.usage_plot import parse_logged_seconds
+
+
+class IndexStatsCommand(QleverIndexStatsCommand):
+    """
+    Show index build time and disk space usage for an Oxigraph dataset.
+    Time is read from the "TOTAL time" line appended to the index log
+    by the index command; space is the sum of all .sst files.
+    """
+
+    def execute_time(
+        self, args, log_file_name: str
+    ) -> dict[str, tuple[float | None, str]]:
+        """Parse index build times from the index log file."""
+        try:
+            # Read the last few lines of the log file (the times are
+            # always near the end).
+            log_text = util.run_command(
+                f"tail {log_file_name}", return_output=True
+            )
+        except Exception as e:
+            log.error(f"Problem reading index log file {log_file_name}: {e}")
+            return {}
+
+        phases = ["Load time", "Optimize time", "TOTAL time"]
+
+        raw_seconds = {}
+        for name in phases:
+            seconds = parse_logged_seconds(log_text, f"{name}:")
+            if seconds is not None:
+                raw_seconds[name] = seconds
+
+        if not raw_seconds:
+            return {}
+
+        # Pick a time unit based on the total time.
+        total_s = raw_seconds.get("TOTAL time")
+        time_unit = get_time_unit(args.time_unit, total_s)
+        unit_factor = get_time_unit_factor(time_unit)
+
+        stats = {}
+        for name in phases:
+            if name in raw_seconds:
+                stats[name] = (raw_seconds[name] / unit_factor, time_unit)
+
+        # If there was no optimize step, Load and TOTAL are identical
+        if "Optimize time" not in stats:
+            stats.pop("Load time", None)
+
+        return stats
+
+    def execute_space(self, args) -> dict[str, tuple[float, str]]:
+        """
+        Return the space used by the index files (*.sst) along with the unit.
+        """
+        index_size = util.get_total_file_size([f"{args.name}_index/*.sst"])
+
+        size_unit = get_size_unit(args.size_unit, index_size)
+        unit_factor = get_size_unit_factor(size_unit)
+
+        index_size /= unit_factor
+
+        return {"TOTAL size": (index_size, size_unit)}
diff --git a/src/qoxigraph/commands/log.py b/src/qoxigraph/commands/log.py
new file mode 100644
index 00000000..401d2148
--- /dev/null
+++ b/src/qoxigraph/commands/log.py
@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from qlever import script_name
+from qlever.commands.log import LogCommand as QleverLogCommand
+from qlever.containerize import Containerize
+from qlever.log import log
+from qlever.util import run_command
+
+
+class LogCommand(QleverLogCommand):
+    """
+    Show server logs for Oxigraph. For native execution, tails the log
+    file as usual. For containers, uses `docker/podman logs` as it is
+    not possible to redirect oxigraph logs to a log file.
+    """
+
+    def __init__(self):
+        pass
+
+    def relevant_qleverfile_arguments(self) -> dict[str, list[str]]:
+        return {
+            "data": ["name"],
+            "runtime": [
+                "system",
+                "image",
+                "server_container",
+            ],
+        }
+
+    def execute(self, args) -> bool:
+        if args.system not in Containerize.supported_systems():
+            return super().execute(args)
+
+        # Handle container logging using docker/podman logs command instead of tail
+        # This is because we don't have <args.name>.server-log.txt for
+        # containerized execution
+        log_cmd = f"{args.system} logs "
+
+        if not args.from_beginning:
+            log_cmd += f"-n {args.tail_num_lines} "
+        if not args.no_follow:
+            log_cmd += "-f "
+
+        log_cmd += args.server_container
+
+        # Show the command line.
+        self.show(log_cmd, only_show=args.show)
+        if args.show:
+            return True
+
+        if not Containerize().is_running(args.system, args.server_container):
+            log.error(f"No server container {args.server_container} found!\n")
+            log.info(f"Are you sure you called `{script_name} start`?")
+            return False
+
+        try:
+            run_command(log_cmd, show_output=True, show_stderr=True)
+        except Exception as e:
+            log.error(f"Cannot display container logs - {e}")
+        return True
diff --git a/src/qoxigraph/commands/query.py b/src/qoxigraph/commands/query.py
new file mode 100644
index 00000000..bc3fb35c
--- /dev/null
+++ b/src/qoxigraph/commands/query.py
@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from qlever.commands.query import QueryCommand as QleverQueryCommand
+
+
+class QueryCommand(QleverQueryCommand):
+    """
+    Send a SPARQL query to the Oxigraph server. Extends the base query
+    command with Oxigraph's /query endpoint and supported result formats.
+    This class is used as the base QueryCommand by all the other new engines.
+    """
+
+    def additional_arguments(self, subparser) -> None:
+        subparser.add_argument(
+            "query",
+            type=str,
+            nargs="?",
+            default="SELECT * WHERE { ?s ?p ?o } LIMIT 10",
+            help="SPARQL query to send",
+        )
+        subparser.add_argument(
+            "--predefined-query",
+            type=str,
+            choices=self.predefined_queries.keys(),
+            help="Use a predefined query",
+        )
+        subparser.add_argument(
+            "--sparql-endpoint", type=str, help="URL of the SPARQL endpoint"
+        )
+        subparser.add_argument(
+            "--accept",
+            type=str,
+            choices=[
+                "text/tab-separated-values",
+                "text/csv",
+                "application/sparql-results+json",
+                "application/sparql-results+xml",
+            ],
+            default="text/tab-separated-values",
+            help="Accept header for the SPARQL query",
+        )
+        subparser.add_argument(
+            "--get",
+            action="store_true",
+            default=False,
+            help="Use GET request instead of POST",
+        )
+        subparser.add_argument(
+            "--no-time",
+            action="store_true",
+            default=False,
+            help="Do not print the (end-to-end) time taken",
+        )
+
+    def execute(self, args) -> bool:
+        # Oxigraph's SPARQL endpoint is at /query.
+        if not args.sparql_endpoint:
+            args.sparql_endpoint = f"{args.host_name}:{args.port}/query"
+        # These QLever-specific options are not supported by Oxigraph.
+        args.pin_to_cache = None
+        args.access_token = None
+        return super().execute(args)
diff --git a/src/qoxigraph/commands/setup_config.py b/src/qoxigraph/commands/setup_config.py
new file mode 100644
index 00000000..ed286269
--- /dev/null
+++ b/src/qoxigraph/commands/setup_config.py
@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from configparser import RawConfigParser
+from pathlib import Path
+
+from qlever.commands.setup_config import (
+    SetupConfigCommand as QleverSetupConfigCommand,
+)
+from qlever.log import log
+from qlever.qleverfile import Qleverfile
+
+
+class SetupConfigCommand(QleverSetupConfigCommand):
+    """
+    Create a Qleverfile for Oxigraph from a dataset template from `src/qlever/Qleverfiles`.
+    Filters the template to keep only the relevant sections and adds Oxigraph-specific
+    defaults (read-only mode, query timeout).
+    This class is used as the base SetupConfigCommand by all the other new engines.
+    """
+
+    IMAGE = "ghcr.io/oxigraph/oxigraph"
+
+    # Sections and keys to retain when filtering a Qleverfile template.
+    FILTER_CRITERIA = {
+        "data": [],
+        "index": ["INPUT_FILES"],
+        "server": ["PORT"],
+        "runtime": ["SYSTEM", "IMAGE"],
+        "ui": ["UI_CONFIG"],
+    }
+
+    @staticmethod
+    def construct_engine_specific_params(args) -> dict[str, dict[str, str]]:
+        """Return Oxigraph-specific defaults to inject into the Qleverfile."""
+        return {"server": {"READ_ONLY": "yes", "TIMEOUT": "60s"}}
+
+    @staticmethod
+    def add_engine_specific_option_values(
+        qleverfile_parser: RawConfigParser,
+        engine_specific_params: dict[str, dict[str, str]],
+    ) -> None:
+        """Merge engine-specific parameters into the Qleverfile parser."""
+        for section, option_dict in engine_specific_params.items():
+            if qleverfile_parser.has_section(section):
+                for option, value in option_dict.items():
+                    qleverfile_parser.set(section, option, value)
+
+    def execute(self, args) -> bool:
+        # Construct the command line and show it.
+        template_path = (
+            self.qleverfiles_path / f"Qleverfile.{args.config_name}"
+        )
+        setup_config_show = (
+            f"Qleverfile for {args.config_name} will be created using "
+            f"Qleverfile.{args.config_name} file in {template_path}"
+        )
+        self.show(setup_config_show, only_show=args.show)
+        if args.show:
+            return True
+
+        # If there is already a Qleverfile in the current directory, exit.
+        if self.check_qleverfile_exists():
+            return False
+
+        qleverfile_path = Path("Qleverfile")
+
+        try:
+            qleverfile_parser = Qleverfile.filter(
+                template_path, self.FILTER_CRITERIA
+            )
+            qleverfile_parser.set("runtime", "IMAGE", self.IMAGE)
+            params = self.construct_engine_specific_params(args)
+            self.add_engine_specific_option_values(qleverfile_parser, params)
+            for section, arg_name in self.override_args:
+                if arg_value := getattr(args, arg_name, None):
+                    qleverfile_parser.set(
+                        section, arg_name.upper(), str(arg_value)
+                    )
+            with qleverfile_path.open("w") as f:
+                qleverfile_parser.write(f)
+
+            log.info(
+                f'Created Qleverfile for config "{args.config_name}"'
+                f" in current directory"
+            )
+            return True
+        except Exception as e:
+            log.error(
+                f'Could not copy "{qleverfile_path}" to current directory: {e}'
+            )
+            return False
diff --git a/src/qoxigraph/commands/start.py b/src/qoxigraph/commands/start.py
new file mode 100644
index 00000000..dd049a70
--- /dev/null
+++ b/src/qoxigraph/commands/start.py
@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+import subprocess
+import time
+from pathlib import Path
+
+from qlever import script_name
+from qlever.command import QleverCommand
+from qlever.containerize import Containerize
+from qlever.log import log
+from qlever.util import (
+    binary_exists,
+    is_server_alive,
+    run_command,
+    tail_log_file,
+)
+from qoxigraph.commands.stop import StopCommand
+
+
+def timeout_supported(args, serve_ps: str) -> bool:
+    """Check whether the oxigraph server binary supports query timeouts."""
+    help_cmd = f"{serve_ps} --help"
+    if args.system in Containerize.supported_systems():
+        help_cmd = f"{args.system} run --rm {args.image} {help_cmd}"
+    else:
+        help_cmd = f"{args.server_binary} {help_cmd}"
+    try:
+        help_output = run_command(help_cmd, return_output=True)
+        return "timeout-s" in help_output
+    except Exception as e:
+        log.warning(
+            "Could not determine if query timeouts are supported by this version "
+            f"of Oxigraph! Falling back to no timeouts. Error: {e}",
+        )
+        return False
+
+
+def wrap_cmd_in_container(args, cmd: str) -> str:
+    """Wrap the server start command in a container with restart policy."""
+    run_subcommand = "run --restart=unless-stopped"
+    if not args.run_in_foreground:
+        run_subcommand += " -d"
+    return Containerize().containerize_command(
+        cmd=cmd,
+        container_system=args.system,
+        run_subcommand=run_subcommand,
+        image_name=args.image,
+        container_name=args.server_container,
+        volumes=[("$(pwd)", "/opt")],
+        ports=[(args.port, args.port)],
+        working_directory="/opt",
+        use_bash=False,
+    )
+
+
+class StartCommand(QleverCommand):
+    """
+    Start the Oxigraph SPARQL server for an already-indexed dataset.
+    Supports both native and containerized execution, with an option
+    to run in the foreground. Uses `serve-read-only` or `serve`
+    depending on the read_only setting.
+    """
+
+    def __init__(self):
+        pass
+
+    def description(self) -> str:
+        return (
+            "Start the server for Oxigraph (requires that you have built an "
+            "index before)"
+        )
+
+    def should_have_qleverfile(self) -> bool:
+        return True
+
+    def relevant_qleverfile_arguments(self) -> dict[str, list[str]]:
+        return {
+            "data": ["name"],
+            "server": [
+                "host_name",
+                "port",
+                "read_only",
+                "server_binary",
+                "timeout",
+                "extra_args",
+            ],
+            "runtime": ["system", "image", "server_container"],
+        }
+
+    def additional_arguments(self, subparser):
+        subparser.add_argument(
+            "--run-in-foreground",
+            action="store_true",
+            default=False,
+            help=(
+                "Run the start command in the foreground "
+                "(default: run in the background)"
+            ),
+        )
+
+    def execute(self, args) -> bool:
+        # Inside a container, bind to 0.0.0.0 so the port mapping is
+        # reachable from the host; natively, bind to the configured host.
+        bind = (
+            f"0.0.0.0:{args.port}"
+            if args.system in Containerize.supported_systems()
+            else f"{args.host_name}:{args.port}"
+        )
+        process = "serve-read-only" if args.read_only == "yes" else "serve"
+        timeout_str = ""
+        if timeout_supported(args, process):
+            try:
+                timeout_s = int(args.timeout[:-1])
+            except ValueError as e:
+                log.warning(
+                    f"Invalid timeout value {args.timeout}. Error: {e}"
+                )
+                log.info("Setting timeout to 60s!")
+                timeout_s = 60
+            timeout_str = f"--timeout-s {timeout_s}"
+        else:
+            log.info(
+                f"Ignoring the set timeout value of {args.timeout} as your "
+                "version of Oxigraph doesn't currently support query timeouts!"
+            )
+
+        start_cmd = (
+            f"{process} --location {args.name}_index/ {args.extra_args} "
+            f"{timeout_str} --bind={bind}"
+        )
+
+        if args.system in Containerize.supported_systems():
+            start_cmd = wrap_cmd_in_container(args, start_cmd)
+        else:
+            start_cmd = f"{args.server_binary} {start_cmd} > {args.name}.server-log.txt 2>&1"
+            if not args.run_in_foreground:
+                start_cmd = f"nohup {start_cmd} &"
+
+        # Show the command line.
+        self.show(start_cmd, only_show=args.show)
+        if args.show:
+            return True
+
+        endpoint_url = f"http://{args.host_name}:{args.port}/query"
+
+        # When running natively, check if the binary exists and works.
+        if args.system not in Containerize.supported_systems():
+            if not binary_exists(args.server_binary, "server-binary", args):
+                return False
+
+        # Check if index files (*.sst) present in index directory
+        if (
+            len([p.name for p in Path(f"{args.name}_index/").glob("*.sst")])
+            == 0
+        ):
+            log.error(f"No Oxigraph index files for {args.name} found!\n")
+            log.info(
+                f"Did you call `{script_name} index`? If you did, check "
+                "if .sst index files are present in index directory."
+            )
+            return False
+
+        # Check if server already alive at endpoint url from a previous run
+        if is_server_alive(url=endpoint_url):
+            log.error(f"Oxigraph server already running on {endpoint_url}\n")
+            log.info(f"To kill the existing server, use `{script_name} stop`")
+            return False
+
+        # Remove old log file so that tail starts clean.
+        log_file = Path(f"{args.name}.server-log.txt")
+        log_file.unlink(missing_ok=True)
+
+        try:
+            process = run_command(
+                start_cmd,
+                use_popen=args.run_in_foreground,
+            )
+        except Exception as e:
+            log.error(f"Starting the Oxigraph server failed ({e})")
+            return False
+
+        # Tail the server log until the server is ready (note that the `exec`
+        # is important to make sure that the tail process is killed and not
+        # just the bash process).
+        if args.run_in_foreground:
+            log.info(
+                "Follow the server logs as long as the server is"
+                " running (Ctrl-C stops the server)"
+            )
+        else:
+            log.info(
+                "Follow the server logs until the server is ready"
+                " (Ctrl-C stops following the log, but NOT the server)"
+            )
+        log.info("")
+        # For containers, use `docker/podman logs -f` as Oxigraph doesn't
+        # support redirecting logs to a log file. A short delay ensures
+        # the container is up before attaching.
+        if args.system in Containerize.supported_systems():
+            time.sleep(2)
+            log_cmd = f"exec {args.system} logs -f {args.server_container}"
+            log_proc = subprocess.Popen(log_cmd, shell=True)
+        else:
+            log_proc = tail_log_file(log_file)
+            if log_proc is None:
+                return False
+        while not is_server_alive(endpoint_url):
+            time.sleep(1)
+
+        log.info(
+            f"Oxigraph server webapp for {args.name} will be available at "
+            f"http://{args.host_name}:{args.port} and the sparql endpoint for "
+            f"queries is {endpoint_url} when the server is ready"
+        )
+
+        # Kill the log process
+        if not args.run_in_foreground:
+            log_proc.terminate()
+
+        # With `--run-in-foreground`, wait until the server is stopped.
+        # On Ctrl-C, terminate the process and clean up the container.
+        if args.run_in_foreground:
+            try:
+                process.wait()
+            except KeyboardInterrupt:
+                process.terminate()
+                if args.system in Containerize.supported_systems():
+                    args.cmdline_regex = StopCommand.DEFAULT_REGEX
+                    StopCommand().execute(args)
+            log_proc.terminate()
+
+        return True
diff --git a/src/qoxigraph/commands/status.py b/src/qoxigraph/commands/status.py
new file mode 100644
index 00000000..d73548dc
--- /dev/null
+++ b/src/qoxigraph/commands/status.py
@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from qlever.commands.status import StatusCommand as QleverStatusCommand
+
+
+class StatusCommand(QleverStatusCommand):
+    """Show Oxigraph server processes running on this machine."""
+
+    DEFAULT_REGEX = "oxigraph\\s+serve"
+
+    def description(self) -> str:
+        return "Show Oxigraph processes running on this machine"
+
+    def additional_arguments(self, subparser) -> None:
+        subparser.add_argument(
+            "--cmdline-regex",
+            default=self.DEFAULT_REGEX,
+            help=(
+                "Show only processes where the command line matches this regex"
+            ),
+        )
diff --git a/src/qoxigraph/commands/stop.py b/src/qoxigraph/commands/stop.py
new file mode 100644
index 00000000..47308284
--- /dev/null
+++ b/src/qoxigraph/commands/stop.py
@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from qlever.command import QleverCommand
+from qlever.commands import stop as qlever_stop
+from qlever.containerize import Containerize
+from qlever.log import log
+from qlever.util import stop_process_with_regex
+from qoxigraph.commands.status import StatusCommand
+
+
+class StopCommand(QleverCommand):
+    """
+    Stop the Oxigraph server for a given dataset. For native execution,
+    finds and kills processes matching the dataset-name regex. For
+    containers, stops and removes the server container.
+    """
+
+    # Override this with StatusCommand from child class for execute
+    # method to work as intended
+    STATUS_COMMAND = StatusCommand()
+    # %%NAME%% is replaced at runtime with the dataset name from the Qleverfile
+    DEFAULT_REGEX = "oxigraph\\s+serve.*%%NAME%%_index"
+
+    def __init__(self):
+        pass
+
+    def description(self) -> str:
+        return "Stop Oxigraph server for a given dataset"
+
+    def should_have_qleverfile(self) -> bool:
+        return True
+
+    def relevant_qleverfile_arguments(self) -> dict[str, list[str]]:
+        return {
+            "data": ["name"],
+            "runtime": ["system", "server_container"],
+        }
+
+    def additional_arguments(self, subparser) -> None:
+        subparser.add_argument(
+            "--cmdline-regex",
+            default=self.DEFAULT_REGEX,
+            help="Show only processes where the command "
+            "line matches this regex",
+        )
+
+    def execute(self, args) -> bool:
+        # Substitute the dataset name into the regex template so we only
+        # match the server running for this dataset.
+        cmdline_regex = args.cmdline_regex
+        if "%%NAME%%" in args.cmdline_regex and hasattr(args, "name"):
+            cmdline_regex = args.cmdline_regex.replace(
+                "%%NAME%%", str(args.name)
+            )
+        description = (
+            f"Checking for container with name {args.server_container}"
+            if args.system in Containerize.supported_systems()
+            else f'Checking for processes matching "{cmdline_regex}"'
+        )
+
+        self.show(description, only_show=args.show)
+        if args.show:
+            return True
+
+        if args.system not in Containerize.supported_systems():
+            stop_process_results = stop_process_with_regex(cmdline_regex)
+            if stop_process_results is None:
+                return False
+            if len(stop_process_results) > 0:
+                return all(stop_process_results)
+
+            # If no matching process found, show a message and the output of the
+            # status command.
+            log.error("No matching process found")
+            args.cmdline_regex = self.STATUS_COMMAND.DEFAULT_REGEX
+            log.info("")
+            StatusCommand().execute(args)
+            return True
+
+        # First check if container is running and if yes, stop and remove it
+        return qlever_stop.stop_container(args.server_container)
diff --git a/src/qoxigraph/qleverfile.py b/src/qoxigraph/qleverfile.py
new file mode 100644
index 00000000..467b77fa
--- /dev/null
+++ b/src/qoxigraph/qleverfile.py
@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+
+def qleverfile_args(all_args: dict[str, dict[str, tuple]]) -> None:
+    """Define additional oxigraph specific Qleverfile parameters"""
+
+    def arg(*args, **kwargs):
+        return (args, kwargs)
+
+    index_args = all_args["index"]
+    server_args = all_args["server"]
+
+    index_args["index_binary"] = arg(
+        "--index-binary",
+        type=str,
+        default="oxigraph",
+        help=(
+            "The binary for building the index (default: oxigraph) "
+            "(this requires that you have oxigraph-cli installed "
+            "on your machine)"
+        ),
+    )
+    index_args["lenient"] = arg(
+        "--lenient",
+        type=str,
+        choices=["yes", "no"],
+        default="no",
+        help="Attempt to keep loading even if the data file is invalid",
+    )
+    index_args["extra_args"] = arg(
+        "--extra-args",
+        type=str,
+        default="",
+        help=(
+            "Additional arguments to pass directly to the oxigraph load process. "
+            "This allows advanced users to specify options not exposed in "
+            "Qleverfile. The string is appended verbatim to the command."
+        ),
+    )
+
+    server_args["server_binary"] = arg(
+        "--server-binary",
+        type=str,
+        default="oxigraph",
+        help=(
+            "The binary for starting the server (default: oxigraph) "
+            "(this requires that you have oxigraph-cli installed "
+            "on your machine)"
+        ),
+    )
+    server_args["read_only"] = arg(
+        "--read-only",
+        type=str,
+        choices=["yes", "no"],
+        default="yes",
+        help=(
+            "The HTTP server will not permit mutation operations in "
+            "read-only mode"
+        ),
+    )
+    server_args["timeout"] = arg(
+        "--timeout",
+        type=str,
+        default="60s",
+        help="The maximal time in seconds a query is allowed to run",
+    )
+    server_args["extra_args"] = arg(
+        "--extra-args",
+        type=str,
+        default="",
+        help=(
+            "Additional arguments to pass directly to the oxigraph "
+            "serve/serve-read-only. This allows advanced users to specify "
+            "options not exposed in Qleverfile. The string is appended "
+            "verbatim to the command."
+        ),
+    )
diff --git a/src/qoxigraph/resource_usage/__init__.py b/src/qoxigraph/resource_usage/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/qoxigraph/resource_usage/usage_plot.py b/src/qoxigraph/resource_usage/usage_plot.py
new file mode 100644
index 00000000..cfd3ae2d
--- /dev/null
+++ b/src/qoxigraph/resource_usage/usage_plot.py
@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import re
+
+from qlever.containerize import Containerize
+from qlever.resource_usage.usage_plot import UsagePlot as BaseUsagePlot
+from qlever.util import run_command
+
+
+def parse_logged_seconds(text: str, label: str) -> float | None:
+    """Return the integer seconds logged after `label`, or None."""
+    match = re.search(rf"{re.escape(label)}\s*(\d+)s", text)
+    return float(match.group(1)) if match else None
+
+
+class UsagePlot(BaseUsagePlot):
+    """Resource-usage plot for an Oxigraph index build."""
+
+    def overlay(self) -> list[tuple[str, float, float]]:
+        """Shade the load and optimize phases; empty if no optimize step."""
+        try:
+            text = self.log_path.read_text()
+        except OSError:
+            return []
+        load_s = parse_logged_seconds(text, "Load time:")
+        optimize_s = parse_logged_seconds(text, "Optimize time:")
+        if load_s is None or optimize_s is None:
+            return []
+        return [
+            ("Load", 0.0, load_s),
+            ("Optimize", load_s, load_s + optimize_s),
+        ]
+
+    def subtitle(self) -> str | None:
+        """Assemble a 'version | read-only' line from the index args."""
+        if self.args.system in Containerize.supported_systems():
+            version_cmd = (
+                f"{self.args.system} run --rm {self.args.image} --version"
+            )
+        else:
+            version_cmd = f"{self.args.index_binary} --version"
+        try:
+            version = run_command(version_cmd, return_output=True).strip()
+        except Exception:
+            version = ""
+        parts = []
+        if version:
+            parts.append(version)
+        parts.append(f"read-only = {self.args.read_only}")
+        return "   |   ".join(parts)