Allow server backend selection

Author: 0xShug0

README.md

@@ -505,6 +505,7 @@ cat > server.json <<'JSON'
 {
   "host": "127.0.0.1",
   "port": 8080,
+  "backend": "cuda",
   "device": 0,
   "threads": 1,
   "lazy_load": true,
@@ -536,6 +537,8 @@ JSON
 
 Set `"lazy_load": true` to register configured model ids at startup while loading each model only on first use. Use per-model `"lazy": true` or `"lazy": false` to override that default.
 
+Set top-level `"backend"` to `"cuda"`, `"cpu"`, `"vulkan"`, or `"metal"`. CUDA is the optimized path for audio.cpp; CPU, Vulkan, and Metal are intended for portability and testing when the binary is built with that backend, but performance and model coverage may be lower.
+
 > [!WARNING]
 > Lazy loading does not unload models after a request. Once a model is first used, the server keeps that model and session in memory for reuse until the server exits.
 

app/server/README.md

@@ -1,6 +1,6 @@
 # audio.cpp Server
 
-`audiocpp_server` is a CUDA-only HTTP adapter over the framework runtime registry. It keeps one loaded model and one offline task session per active model id, so repeated HTTP requests reuse the same framework session and model-owned graph/cache state.
+`audiocpp_server` is an HTTP adapter over the framework runtime registry. It keeps one loaded model and one offline task session per active model id, so repeated HTTP requests reuse the same framework session and model-owned graph/cache state.
 
 ## Build
 
@@ -9,13 +9,16 @@ cmake -S . -B build -DENGINE_ENABLE_CUDA=ON
 cmake --build build --parallel --target audiocpp_server
 ```
 
+Enable the backend you plan to run: `ENGINE_ENABLE_CUDA=ON` for CUDA, `ENGINE_ENABLE_VULKAN=ON` for Vulkan, or `ENGINE_ENABLE_METAL=ON` for Metal. CPU support is always available.
+
 ## Config
 
 ```bash
 cat > server.json <<'JSON'
 {
   "host": "127.0.0.1",
   "port": 8080,
+  "backend": "cuda",
   "device": 0,
   "threads": 1,
   "lazy_load": true,
@@ -47,6 +50,8 @@ JSON
 
 The server resolves model paths from this JSON exactly as written, so use paths that match your machine. Request-time audio paths are also user-provided paths.
 
+Set top-level `"backend"` to `"cuda"`, `"cpu"`, `"vulkan"`, or `"metal"`. CUDA is the optimized path for audio.cpp; CPU, Vulkan, and Metal are intended for portability and testing when the binary is built with that backend, but performance and model coverage may be lower. The server prints this expectation-setting message when a non-CUDA backend is selected.
+
 Set top-level `"lazy_load": true` to register all configured model ids at startup but defer each model's framework load and session creation until its first request. A model can override the default with `"lazy": true` or `"lazy": false`.
 
 > [!WARNING]
@@ -58,6 +63,12 @@ Set top-level `"lazy_load": true` to register all configured model ids at startu
 build/bin/audiocpp_server --config server.json
 ```
 
+You can override the configured backend at startup:
+
+```bash
+build/bin/audiocpp_server --config server.json --backend vulkan
+```
+
 ## Endpoints
 
 ### `GET /health`

app/server/config.cpp

@@ -1,5 +1,6 @@
 #include "config.h"
 
+#include "../cli/args.h"
 #include "../cli/request.h"
 
 #include "engine/framework/io/json.h"
@@ -20,12 +21,21 @@ std::unordered_map<std::string, std::string> options_from_object(const engine::i
 
 }  // namespace
 
+engine::core::BackendType parse_server_backend(const std::string & value) {
+    auto backend = minitts::cli::parse_backend(value);
+    if (backend == engine::core::BackendType::BestAvailable) {
+        throw std::runtime_error("unsupported server backend: " + value);
+    }
+    return backend;
+}
+
 ServerConfig load_server_config(const std::filesystem::path & path) {
     const auto root = engine::io::json::parse_file(path);
     const auto base = path.parent_path();
     ServerConfig config;
     config.host = engine::io::json::optional_string(root, "host", config.host);
     config.port = engine::io::json::optional_i32(root, "port", config.port);
+    config.backend = parse_server_backend(engine::io::json::optional_string(root, "backend", "cuda"));
     config.device = engine::io::json::optional_i32(root, "device", config.device);
     config.threads = engine::io::json::optional_i32(root, "threads", config.threads);
     config.lazy_load = engine::io::json::optional_bool(root, "lazy_load", config.lazy_load);

app/server/config.h

@@ -6,6 +6,8 @@
 #include <unordered_map>
 #include <vector>
 
+#include "engine/framework/core/backend.h"
+
 namespace minitts::server {
 
 struct ServerModelConfig {
@@ -24,12 +26,14 @@ struct ServerModelConfig {
 struct ServerConfig {
     std::string host = "127.0.0.1";
     int port = 8080;
+    engine::core::BackendType backend = engine::core::BackendType::Cuda;
     int device = 0;
     int threads = 1;
     bool lazy_load = false;
     std::vector<ServerModelConfig> models;
 };
 
+engine::core::BackendType parse_server_backend(const std::string & value);
 ServerConfig load_server_config(const std::filesystem::path & path);
 
 }  // namespace minitts::server

app/server/example.json

@@ -1,6 +1,7 @@
 {
   "host": "127.0.0.1",
   "port": 8080,
+  "backend": "cuda",
   "device": 0,
   "threads": 1,
   "lazy_load": true,

app/server/main.cpp

@@ -32,8 +32,10 @@ bool has_arg(int argc, char ** argv, const std::string & name) {
 
 void print_help() {
     std::cout
-        << "audiocpp_server --config <server.json> [--host <ip>] [--port <port>] [--device <id>] [--threads <n>]\n"
+        << "audiocpp_server --config <server.json> [--host <ip>] [--port <port>] [--backend <backend>]\n"
+        << "                [--device <id>] [--threads <n>]\n"
         << "                [--log] [--log-file <path>]\n"
+        << "  --backend cpu|cuda|vulkan|metal  default cuda\n"
         << "\n"
         << "Endpoints:\n"
         << "  GET  /health\n"
@@ -68,6 +70,9 @@ int main(int argc, char ** argv) {
         if (const auto port = arg_value(argc, argv, "--port")) {
             config.port = std::stoi(*port);
         }
+        if (const auto backend = arg_value(argc, argv, "--backend")) {
+            config.backend = minitts::server::parse_server_backend(*backend);
+        }
         if (const auto device = arg_value(argc, argv, "--device")) {
             config.device = std::stoi(*device);
         }

app/server/runtime.cpp

@@ -9,6 +9,7 @@
 #include <chrono>
 #include <cmath>
 #include <cstdint>
+#include <iostream>
 #include <sstream>
 #include <stdexcept>
 #include <unordered_map>
@@ -29,6 +30,22 @@ std::filesystem::path resolve_path(const std::filesystem::path & base, const std
     return path.is_absolute() ? path : base / path;
 }
 
+const char * backend_name(engine::core::BackendType type) {
+    switch (type) {
+        case engine::core::BackendType::Cpu:
+            return "cpu";
+        case engine::core::BackendType::Cuda:
+            return "cuda";
+        case engine::core::BackendType::Vulkan:
+            return "vulkan";
+        case engine::core::BackendType::Metal:
+            return "metal";
+        case engine::core::BackendType::BestAvailable:
+            return "best";
+    }
+    return "unknown";
+}
+
 std::unordered_map<std::string, std::string> options_from_object(const Value * value) {
     return minitts::cli::json_options_map(value);
 }
@@ -336,12 +353,23 @@ engine::runtime::TaskRequest build_openai_transcription_request(const Value & bo
 ServerState::ServerState(ServerConfig config, std::filesystem::path request_base)
     : config_(std::move(config)),
       request_base_(std::move(request_base)) {
+    if (config_.backend != engine::core::BackendType::Cuda) {
+        std::cerr
+            << "audio.cpp is optimized for CUDA. The "
+            << backend_name(config_.backend)
+            << " server backend is intended for portability and testing, but performance and model coverage may be lower than CUDA.\n";
+    }
     load_models();
 }
 
 HttpResponse ServerState::handle(const HttpRequest & request) {
     if (request.method == "GET" && request.path == "/health") {
-        return json_response("{\"status\":\"ok\",\"backend\":\"cuda\",\"models\":" + std::to_string(models_.size()) + "}");
+        return json_response(
+            "{\"status\":\"ok\",\"backend\":\"" +
+            std::string(backend_name(config_.backend)) +
+            "\",\"models\":" +
+            std::to_string(models_.size()) +
+            "}");
     }
     if (request.method == "GET" && request.path == "/v1/models") {
         return json_response(models_json());
@@ -393,7 +421,7 @@ void ServerState::ensure_model_loaded_locked(LoadedModel & model) {
     load_request.options = model.config.load_options;
 
     engine::runtime::SessionOptions session_options;
-    session_options.backend.type = engine::core::BackendType::Cuda;
+    session_options.backend.type = config_.backend;
     session_options.backend.device = config_.device;
     session_options.backend.threads = config_.threads;
     session_options.options = model.config.session_options;