Feat: Native AI Connector (#19) - Local/Network Inference

- Added 'NativeAIBridge' class using cpp-httplib and nlohmann/json.
- Implemented OpenAI-compatible /v1/chat/completions Client.
- Integrated into 'Engine' via 'AIGateway' interface.
- Updated 'StrategyInterface' (C ABI) to expose 'query_ai' callback.
- Strategies can now synchronously query local models (Llama.cpp/Ollama/vLLM) directly from C++ logic.
- Configurable via QUANUX_AI_ENDPOINT, QUANUX_AI_KEY, QUANUX_AI_MODEL.

Author: quantDIY

QuanuX-Common/cpp/include/quanux/common/AIGateway.h

@@ -0,0 +1,30 @@
+#pragma once
+#include <functional>
+#include <future>
+#include <string>
+
+namespace quanux::common {
+
+class AIGateway {
+public:
+  virtual ~AIGateway() = default;
+
+  /**
+   * Synchronous query to the AI model.
+   * Warning: This MAY BLOCK for a significant time.
+   * Prefer using this in on_start or separate threads.
+   */
+  virtual std::string query(const std::string &prompt) = 0;
+
+  /**
+   * Asynchronous query. Returns a future to the result.
+   */
+  virtual std::future<std::string> query_async(const std::string &prompt) = 0;
+
+  /**
+   * Status check.
+   */
+  virtual bool is_connected() const = 0;
+};
+
+} // namespace quanux::common

QuanuX-Common/cpp/include/quanux/common/StrategyInterface.h

@@ -50,6 +50,9 @@ struct OrderService {
   void *engine_ctx;
   uint64_t (*submit_order)(void *engine_ctx, const OrderRequest *request);
   void (*cancel_order)(void *engine_ctx, uint64_t order_id);
+  // Returns true if successful, false if buffer too small or error
+  bool (*query_ai)(void *engine_ctx, const char *prompt, char *buffer,
+                   uint32_t buffer_size);
 };
 
 // V-Table for Strategy instance

execution-node/cpp/CMakeLists.txt

@@ -40,20 +40,38 @@ FetchContent_MakeAvailable(duckdb)
 # Include Directories
 include_directories(include)
 include_directories(../../QuanuX-Common/cpp/include)
+include_directories(${CMAKE_BINARY_DIR}/_deps/cpp-httplib-src)
 
 # Indicators Library (Self-Contained Strategy Support)
 # We pull this in so strategies can compute locally without phoning home.
 set(BUILD_PYTHON_BINDINGS OFF CACHE BOOL "" FORCE)
 add_subdirectory(../../server/indicators ${CMAKE_BINARY_DIR}/indicators)
 
+# --- AI Connector Deps ---
+FetchContent_Declare(
+    nlohmann_json
+    GIT_REPOSITORY https://github.com/nlohmann/json.git
+    GIT_TAG v3.11.3
+)
+FetchContent_MakeAvailable(nlohmann_json)
+
+FetchContent_Declare(
+    cpp-httplib
+    GIT_REPOSITORY https://github.com/yhirose/cpp-httplib.git
+    GIT_TAG v0.14.3
+)
+FetchContent_MakeAvailable(cpp-httplib)
+
+
 # Core Library (The Engine)
 add_library(node_core STATIC
     src/engine.cpp
     src/nats_bridge.cpp
     src/market_data_engine.cpp
     src/order_gateway.cpp
+    src/native_ai_bridge.cpp
 )
-target_link_libraries(node_core PUBLIC nats_static pthread dl)
+target_link_libraries(node_core PUBLIC nats_static pthread dl cpp-httplib nlohmann_json::nlohmann_json)
 
 # Main Executable
 add_executable(quanux_node src/main.cpp)

execution-node/cpp/include/engine.h

@@ -1,5 +1,6 @@
 #pragma once
 #include "market_data_engine.h"
+#include "native_ai_bridge.h"
 #include "nats_bridge.h"
 #include "order_gateway.h"
 #include "plugin_loader.h"
@@ -19,6 +20,7 @@ struct LoadedStrategy {
 
 class Engine {
   RingBuffer<MarketUpdate, 1024> ring_buffer_;
+  NativeAIBridge ai_bridge_;
   NatsBridge nats_bridge_;
   MarketDataEngine market_data_engine_;
   OrderGateway order_gateway_;
@@ -27,6 +29,8 @@ class Engine {
   // Static callbacks for Strategy ABI
   static uint64_t static_submit_order(void *ctx, const OrderRequest *request);
   static void static_cancel_order(void *ctx, uint64_t order_id);
+  static bool static_query_ai(void *ctx, const char *prompt, char *buffer,
+                              uint32_t buffer_size);
 
 public:
   Engine();

execution-node/cpp/include/native_ai_bridge.h

@@ -0,0 +1,21 @@
+#pragma once
+#include "quanux/common/AIGateway.h"
+#include <memory>
+#include <string>
+
+class NativeAIBridge : public quanux::common::AIGateway {
+public:
+  // endpoint: e.g. "http://localhost:8080"
+  // model: e.g. "llama-3-8b"
+  NativeAIBridge(const std::string &endpoint, const std::string &api_key,
+                 const std::string &model);
+  ~NativeAIBridge() override;
+
+  std::string query(const std::string &prompt) override;
+  std::future<std::string> query_async(const std::string &prompt) override;
+  bool is_connected() const override;
+
+private:
+  struct Impl;
+  std::shared_ptr<Impl> impl_;
+};

execution-node/cpp/src/engine.cpp

@@ -6,6 +6,13 @@
 
 Engine::Engine()
     : // ring_buffer_ default constructor is used (fixed size)
+      // Retrieve AI Config from Env or Default
+      ai_bridge_(
+          std::getenv("QUANUX_AI_ENDPOINT") ? std::getenv("QUANUX_AI_ENDPOINT")
+                                            : "http://localhost:8080",
+          std::getenv("QUANUX_AI_KEY") ? std::getenv("QUANUX_AI_KEY") : "",
+          std::getenv("QUANUX_AI_MODEL") ? std::getenv("QUANUX_AI_MODEL")
+                                         : "llama3"),
       nats_bridge_("nats://localhost:4222"), // Default NATS URL
       market_data_engine_(&ring_buffer_, &nats_bridge_),
       order_gateway_(&nats_bridge_) {}
@@ -20,8 +27,23 @@ void Engine::static_cancel_order(void *ctx, uint64_t order_id) {
   engine->order_gateway_.cancel_order(order_id);
 }
 
+bool Engine::static_query_ai(void *ctx, const char *prompt, char *buffer,
+                             uint32_t buffer_size) {
+  Engine *engine = static_cast<Engine *>(ctx);
+  // Blocking query
+  std::string response = engine->ai_bridge_.query(prompt);
+  if (response.size() >= buffer_size) {
+    return false; // Buffer too small
+  }
+  std::strcpy(buffer, response.c_str());
+  return true;
+}
+
 void Engine::init(const std::string &config_path) {
   std::cout << "[Engine] Initializing..." << std::endl;
+  std::cout << "[Engine] AI Bridge Connected: "
+            << (ai_bridge_.is_connected() ? "YES" : "NO") << std::endl;
+
   // In a real app, read config.json
 
   // Determine platform-specific extension
@@ -81,7 +103,8 @@ void Engine::load_strategy(const std::string &strategy_path) {
     if (strategy_ptr->on_init) {
       OrderService service = {.engine_ctx = this,
                               .submit_order = static_submit_order,
-                              .cancel_order = static_cancel_order};
+                              .cancel_order = static_cancel_order,
+                              .query_ai = static_query_ai};
       strategy_ptr->on_init(ctx, &service);
     }
 
@@ -113,7 +136,9 @@ void Engine::run() {
         if (p_pos != std::string::npos && s_pos != std::string::npos) {
           double price = std::stod(msg.substr(p_pos + 9));
           double size = std::stod(msg.substr(s_pos + 8));
-          bool is_trade = (msg.find("trade") != std::string::npos);
+          bool is_trade =
+              (msg.find("trade") !=
+               std::string::npos); // Correct logic? msg has "type": "trade"
 
           MarketUpdate update = {
               .timestamp = 0,       // todo

execution-node/cpp/src/native_ai_bridge.cpp

@@ -0,0 +1,85 @@
+#include "native_ai_bridge.h"
+#include <httplib.h>
+#include <iostream>
+#include <nlohmann/json.hpp>
+
+using json = nlohmann::json;
+
+struct NativeAIBridge::Impl {
+  std::string base_url;
+  std::string api_key;
+  std::string model;
+  std::unique_ptr<httplib::Client> client;
+
+  Impl(const std::string &url, const std::string &key, const std::string &mdl)
+      : base_url(url), api_key(key), model(mdl) {
+    // Parse host and port from URL roughly or let httplib handle it
+    // httplib::Client expects "http://host:port"
+    client = std::make_unique<httplib::Client>(base_url.c_str());
+    client->set_connection_timeout(5, 0); // 5s connection timeout
+    client->set_read_timeout(10,
+                             0); // 10s read timeout (fast inference required)
+  }
+};
+
+NativeAIBridge::NativeAIBridge(const std::string &endpoint,
+                               const std::string &api_key,
+                               const std::string &model)
+    : impl_(std::make_shared<Impl>(endpoint, api_key, model)) {}
+
+NativeAIBridge::~NativeAIBridge() {}
+
+std::string NativeAIBridge::query(const std::string &prompt) {
+  json payload = {
+      {"model", impl_->model},
+      {"messages", {{{"role", "user"}, {"content", prompt}}}},
+      {"max_tokens", 100}, // Limit response size for speed
+      {"temperature", 0.0} // Deterministic
+  };
+
+  httplib::Headers headers = {{"Content-Type", "application/json"},
+                              {"Authorization", "Bearer " + impl_->api_key}};
+
+  auto res = impl_->client->Post("/v1/chat/completions", headers,
+                                 payload.dump(), "application/json");
+
+  if (res && res->status == 200) {
+    try {
+      auto response_json = json::parse(res->body);
+      if (response_json.contains("choices") &&
+          !response_json["choices"].empty()) {
+        return response_json["choices"][0]["message"]["content"]
+            .get<std::string>();
+      }
+    } catch (const std::exception &e) {
+      std::cerr << "[AIBridge] JSON Parse Error: " << e.what() << std::endl;
+      return "Error: Parse Failure";
+    }
+  } else {
+    if (res) {
+      std::cerr << "[AIBridge] HTTP Error: " << res->status
+                << " Body: " << res->body << std::endl;
+      return "Error: HTTP " + std::to_string(res->status);
+    } else {
+      std::cerr << "[AIBridge] Connection Failed: " << to_string(res.error())
+                << std::endl;
+      return "Error: Connection Failed";
+    }
+  }
+  return "Error: Unknown";
+}
+
+std::future<std::string>
+NativeAIBridge::query_async(const std::string &prompt) {
+  // Simple std::async wrapper for now.
+  // In production, this should use a thread pool or httplib's async features if
+  // available (httplib is blocking sync usually).
+  return std::async(std::launch::async,
+                    [this, prompt]() { return this->query(prompt); });
+}
+
+bool NativeAIBridge::is_connected() const {
+  // Simple health check
+  auto res = impl_->client->Get("/v1/models");
+  return (res && res->status == 200);
+}