cactus-react-native 1.2.0 → 1.4.0

package/android/CMakeLists.txt

@@ -6,10 +6,11 @@ set(CMAKE_VERBOSE_MAKEFILE ON)
 set(CMAKE_CXX_STANDARD 20)
 
 # Define C++ library and add all sources
-add_library(${PACKAGE_NAME} SHARED 
+add_library(${PACKAGE_NAME} SHARED
     src/main/cpp/cpp-adapter.cpp
     ../cpp/HybridCactus.cpp
     ../cpp/HybridCactusUtil.cpp
+    ../cpp/HybridCactusIndex.cpp
 )
 
 add_library(libcactus STATIC IMPORTED)
@@ -17,9 +18,9 @@ set_target_properties(libcactus PROPERTIES
     IMPORTED_LOCATION "${CMAKE_CURRENT_LIST_DIR}/src/main/jniLibs/${ANDROID_ABI}/libcactus.a"
 )
 
-add_library(libcactus_util SHARED IMPORTED)
+add_library(libcactus_util STATIC IMPORTED)
 set_target_properties(libcactus_util PROPERTIES
-    IMPORTED_LOCATION "${CMAKE_CURRENT_LIST_DIR}/src/main/jniLibs/${ANDROID_ABI}/libcactus_util.so"
+    IMPORTED_LOCATION "${CMAKE_CURRENT_LIST_DIR}/src/main/jniLibs/${ANDROID_ABI}/libcactus_util.a"
 )
 
 # Add Nitrogen specs :)

package/android/src/main/java/com/margelo/nitro/cactus/HybridCactusFileSystem.kt

@@ -209,10 +209,10 @@ class HybridCactusFileSystem : HybridCactusFileSystemSpec() {
       modelFile.deleteRecursively()
     }
 
+  override fun getIndexPath(name: String): Promise<String> = Promise.async { indexFile(name).absolutePath }
+
   private fun cactusFile(): File {
-    val documentsDir =
-      context.getExternalFilesDir(android.os.Environment.DIRECTORY_DOCUMENTS) ?: context.filesDir
-    val cactusDir = File(documentsDir, "cactus")
+    val cactusDir = File(context.filesDir, "cactus")
 
     if (!cactusDir.exists()) {
       cactusDir.mkdirs()
@@ -223,6 +223,23 @@ class HybridCactusFileSystem : HybridCactusFileSystemSpec() {
 
   private fun modelFile(model: String): File {
     val cactusDir = cactusFile()
-    return File(cactusDir, "models/$model")
+    val modelsDir = File(cactusDir, "models")
+
+    if (!modelsDir.exists()) {
+      modelsDir.mkdirs()
+    }
+
+    return File(modelsDir, model)
+  }
+
+  private fun indexFile(name: String): File {
+    val cactusDir = cactusFile()
+    val finalDir = File(cactusDir, "indexes/$name")
+
+    if (!finalDir.exists()) {
+      finalDir.mkdirs()
+    }
+
+    return finalDir
   }
 }

package/cpp/HybridCactus.cpp

@@ -1,6 +1,7 @@
 #include "HybridCactus.hpp"
 
 namespace margelo::nitro::cactus {
+
 HybridCactus::HybridCactus() : HybridObject(TAG) {}
 
 std::shared_ptr<Promise<void>>
@@ -19,7 +20,8 @@ HybridCactus::init(const std::string &modelPath, double contextSize,
                         corpusDir ? corpusDir->c_str() : nullptr);
 
         if (!model) {
-          throw std::runtime_error("Failed to initialize Cactus model");
+          throw std::runtime_error("Cactus init failed: " +
+                                   std::string(cactus_get_last_error()));
         }
 
         this->_model = model;
@@ -65,7 +67,8 @@ std::shared_ptr<Promise<std::string>> HybridCactus::complete(
                                  cactusTokenCallback, &callbackCtx);
 
     if (result < 0) {
-      throw std::runtime_error("Cactus completion failed");
+      throw std::runtime_error("Cactus complete failed: " +
+                               std::string(cactus_get_last_error()));
     }
 
     // Remove null terminator
@@ -75,12 +78,78 @@ std::shared_ptr<Promise<std::string>> HybridCactus::complete(
   });
 }
 
+std::shared_ptr<Promise<std::vector<double>>>
+HybridCactus::tokenize(const std::string &text) {
+  return Promise<std::vector<double>>::async([this,
+                                              text]() -> std::vector<double> {
+    std::lock_guard<std::mutex> lock(this->_modelMutex);
+
+    if (!this->_model) {
+      throw std::runtime_error("Cactus model is not initialized");
+    }
+
+    std::vector<uint32_t> tokenBuffer(text.length() * 2 + 16);
+    size_t outTokenLen = 0;
+
+    int result = cactus_tokenize(this->_model, text.c_str(), tokenBuffer.data(),
+                                 tokenBuffer.size(), &outTokenLen);
+
+    if (result < 0) {
+      throw std::runtime_error("Cactus tokenize failed: " +
+                               std::string(cactus_get_last_error()));
+    }
+
+    tokenBuffer.resize(outTokenLen);
+
+    return std::vector<double>(tokenBuffer.begin(), tokenBuffer.end());
+  });
+}
+
+std::shared_ptr<Promise<std::string>>
+HybridCactus::scoreWindow(const std::vector<double> &tokens, double start,
+                          double end, double context) {
+  return Promise<std::string>::async(
+      [this, tokens, start, end, context]() -> std::string {
+        std::lock_guard<std::mutex> lock(this->_modelMutex);
+
+        if (!this->_model) {
+          throw std::runtime_error("Cactus model is not initialized");
+        }
+
+        std::vector<uint32_t> tokenBuffer;
+        tokenBuffer.reserve(tokens.size());
+        for (double d : tokens) {
+          tokenBuffer.emplace_back(static_cast<uint32_t>(d));
+        }
+
+        std::string responseBuffer;
+        responseBuffer.resize(1024);
+
+        int result = cactus_score_window(
+            this->_model, tokenBuffer.data(), tokenBuffer.size(),
+            static_cast<size_t>(start), static_cast<size_t>(end),
+            static_cast<size_t>(context), responseBuffer.data(),
+            responseBuffer.size());
+
+        if (result < 0) {
+          throw std::runtime_error("Cactus score window failed: " +
+                                   std::string(cactus_get_last_error()));
+        }
+
+        // Remove null terminator
+        responseBuffer.resize(strlen(responseBuffer.c_str()));
+
+        return responseBuffer;
+      });
+}
+
 std::shared_ptr<Promise<std::string>> HybridCactus::transcribe(
-    const std::string &audioFilePath, const std::string &prompt,
-    double responseBufferSize, const std::optional<std::string> &optionsJson,
+    const std::variant<std::vector<double>, std::string> &audio,
+    const std::string &prompt, double responseBufferSize,
+    const std::optional<std::string> &optionsJson,
     const std::optional<std::function<void(const std::string & /* token */,
                                            double /* tokenId */)>> &callback) {
-  return Promise<std::string>::async([this, audioFilePath, prompt, optionsJson,
+  return Promise<std::string>::async([this, audio, prompt, optionsJson,
                                       callback,
                                       responseBufferSize]() -> std::string {
     std::lock_guard<std::mutex> lock(this->_modelMutex);
@@ -105,14 +174,34 @@ std::shared_ptr<Promise<std::string>> HybridCactus::transcribe(
     std::string responseBuffer;
     responseBuffer.resize(responseBufferSize);
 
-    int result =
-        cactus_transcribe(this->_model, audioFilePath.c_str(), prompt.c_str(),
-                          responseBuffer.data(), responseBufferSize,
-                          optionsJson ? optionsJson->c_str() : nullptr,
-                          cactusTokenCallback, &callbackCtx);
+    int result;
+    if (std::holds_alternative<std::string>(audio)) {
+      result = cactus_transcribe(
+          this->_model, std::get<std::string>(audio).c_str(), prompt.c_str(),
+          responseBuffer.data(), responseBufferSize,
+          optionsJson ? optionsJson->c_str() : nullptr, cactusTokenCallback,
+          &callbackCtx, nullptr, 0);
+    } else {
+      const auto &audioDoubles = std::get<std::vector<double>>(audio);
+
+      std::vector<uint8_t> audioBytes;
+      audioBytes.reserve(audioDoubles.size());
+
+      for (double d : audioDoubles) {
+        d = std::clamp(d, 0.0, 255.0);
+        audioBytes.emplace_back(static_cast<uint8_t>(d));
+      }
+
+      result = cactus_transcribe(this->_model, nullptr, prompt.c_str(),
+                                 responseBuffer.data(), responseBufferSize,
+                                 optionsJson ? optionsJson->c_str() : nullptr,
+                                 cactusTokenCallback, &callbackCtx,
+                                 audioBytes.data(), audioBytes.size());
+    }
 
     if (result < 0) {
-      throw std::runtime_error("Cactus transcription failed");
+      throw std::runtime_error("Cactus transcribe failed: " +
+                               std::string(cactus_get_last_error()));
     }
 
     // Remove null terminator
@@ -123,9 +212,10 @@ std::shared_ptr<Promise<std::string>> HybridCactus::transcribe(
 }
 
 std::shared_ptr<Promise<std::vector<double>>>
-HybridCactus::embed(const std::string &text, double embeddingBufferSize) {
+HybridCactus::embed(const std::string &text, double embeddingBufferSize,
+                    bool normalize) {
   return Promise<std::vector<double>>::async(
-      [this, text, embeddingBufferSize]() -> std::vector<double> {
+      [this, text, embeddingBufferSize, normalize]() -> std::vector<double> {
         std::lock_guard<std::mutex> lock(this->_modelMutex);
 
         if (!this->_model) {
@@ -135,12 +225,13 @@ HybridCactus::embed(const std::string &text, double embeddingBufferSize) {
         std::vector<float> embeddingBuffer(embeddingBufferSize);
         size_t embeddingDim;
 
-        int result =
-            cactus_embed(this->_model, text.c_str(), embeddingBuffer.data(),
-                         embeddingBufferSize * sizeof(float), &embeddingDim);
+        int result = cactus_embed(
+            this->_model, text.c_str(), embeddingBuffer.data(),
+            embeddingBufferSize * sizeof(float), &embeddingDim, normalize);
 
         if (result < 0) {
-          throw std::runtime_error("Cactus embedding failed");
+          throw std::runtime_error("Cactus embed failed: " +
+                                   std::string(cactus_get_last_error()));
         }
 
         embeddingBuffer.resize(embeddingDim);
@@ -169,7 +260,8 @@ HybridCactus::imageEmbed(const std::string &imagePath,
             embeddingBufferSize * sizeof(float), &embeddingDim);
 
         if (result < 0) {
-          throw std::runtime_error("Cactus image embedding failed");
+          throw std::runtime_error("Cactus image embed failed: " +
+                                   std::string(cactus_get_last_error()));
         }
 
         embeddingBuffer.resize(embeddingDim);
@@ -198,7 +290,8 @@ HybridCactus::audioEmbed(const std::string &audioPath,
             embeddingBufferSize * sizeof(float), &embeddingDim);
 
         if (result < 0) {
-          throw std::runtime_error("Cactus audio embedding failed");
+          throw std::runtime_error("Cactus audio embed failed: " +
+                                   std::string(cactus_get_last_error()));
         }
 
         embeddingBuffer.resize(embeddingDim);

package/cpp/HybridCactus.hpp

@@ -23,15 +23,24 @@ public:
                                              double /* tokenId */)>> &callback)
       override;
 
+  std::shared_ptr<Promise<std::vector<double>>>
+  tokenize(const std::string &text) override;
+
+  std::shared_ptr<Promise<std::string>>
+  scoreWindow(const std::vector<double> &tokens, double start, double end,
+              double context) override;
+
   std::shared_ptr<Promise<std::string>> transcribe(
-      const std::string &audioFilePath, const std::string &prompt,
-      double responseBufferSize, const std::optional<std::string> &optionsJson,
+      const std::variant<std::vector<double>, std::string> &audio,
+      const std::string &prompt, double responseBufferSize,
+      const std::optional<std::string> &optionsJson,
       const std::optional<std::function<void(const std::string & /* token */,
                                              double /* tokenId */)>> &callback)
       override;
 
   std::shared_ptr<Promise<std::vector<double>>>
-  embed(const std::string &text, double embeddingBufferSize) override;
+  embed(const std::string &text, double embeddingBufferSize,
+        bool normalize) override;
 
   std::shared_ptr<Promise<std::vector<double>>>
   imageEmbed(const std::string &imagePath, double embeddingBufferSize) override;

package/cpp/HybridCactusIndex.cpp

@@ -0,0 +1,325 @@
+#include "HybridCactusIndex.hpp"
+
+namespace margelo::nitro::cactus {
+
+HybridCactusIndex::HybridCactusIndex() : HybridObject(TAG) {}
+
+std::shared_ptr<Promise<void>>
+HybridCactusIndex::init(const std::string &indexPath, double embeddingDim) {
+  return Promise<void>::async([this, indexPath, embeddingDim]() -> void {
+    std::lock_guard<std::mutex> lock(this->_indexMutex);
+
+    if (this->_index) {
+      throw std::runtime_error("Cactus index is already initialized");
+    }
+
+    const cactus_index_t index =
+        cactus_index_init(indexPath.c_str(), embeddingDim);
+
+    if (!index) {
+      throw std::runtime_error("Cactus index init failed: " +
+                               std::string(cactus_get_last_error()));
+    }
+
+    this->_index = index;
+    this->_embeddingDim = static_cast<size_t>(embeddingDim);
+  });
+}
+
+std::shared_ptr<Promise<void>> HybridCactusIndex::add(
+    const std::vector<double> &ids, const std::vector<std::string> &documents,
+    const std::vector<std::vector<double>> &embeddings,
+    const std::optional<std::vector<std::string>> &metadatas) {
+  return Promise<void>::async([this, ids, documents, embeddings,
+                               metadatas]() -> void {
+    std::lock_guard<std::mutex> lock(this->_indexMutex);
+
+    if (!this->_index) {
+      throw std::runtime_error("Cactus index is not initialized");
+    }
+
+    const size_t count = ids.size();
+    if (documents.size() != count || embeddings.size() != count) {
+      throw std::runtime_error(
+          "ids, documents, and embeddings must have the same length");
+    }
+
+    if (metadatas.has_value() && metadatas->size() != count) {
+      throw std::runtime_error(
+          "metadatas must have the same length as other vectors");
+    }
+
+    std::vector<int> intIds;
+    intIds.reserve(count);
+    for (size_t i = 0; i < count; ++i) {
+      intIds.emplace_back(static_cast<int>(ids[i]));
+    }
+
+    std::vector<const char *> documentPtrs;
+    documentPtrs.reserve(count);
+    for (size_t i = 0; i < count; ++i) {
+      documentPtrs.emplace_back(documents[i].c_str());
+    }
+
+    std::vector<std::vector<float>> embeddingsFloat(count);
+    std::vector<const float *> embeddingPtrs;
+    embeddingPtrs.reserve(count);
+    for (size_t i = 0; i < count; ++i) {
+      embeddingsFloat[i].resize(embeddings[i].size());
+      for (size_t j = 0; j < embeddings[i].size(); ++j) {
+        embeddingsFloat[i][j] = static_cast<float>(embeddings[i][j]);
+      }
+      embeddingPtrs.emplace_back(embeddingsFloat[i].data());
+    }
+
+    int result;
+    if (metadatas.has_value()) {
+      std::vector<const char *> metadataPtrs;
+      metadataPtrs.reserve(count);
+      for (size_t i = 0; i < count; ++i) {
+        metadataPtrs.emplace_back((*metadatas)[i].c_str());
+      }
+      result = cactus_index_add(
+          this->_index, intIds.data(), documentPtrs.data(), metadataPtrs.data(),
+          embeddingPtrs.data(), count, this->_embeddingDim);
+    } else {
+      result = cactus_index_add(
+          this->_index, intIds.data(), documentPtrs.data(), nullptr,
+          embeddingPtrs.data(), count, this->_embeddingDim);
+    }
+
+    if (result < 0) {
+      throw std::runtime_error("Cactus index add failed: " +
+                               std::string(cactus_get_last_error()));
+    }
+  });
+}
+
+std::shared_ptr<Promise<void>>
+HybridCactusIndex::_delete(const std::vector<double> &ids) {
+  return Promise<void>::async([this, ids]() -> void {
+    std::lock_guard<std::mutex> lock(this->_indexMutex);
+
+    if (!this->_index) {
+      throw std::runtime_error("Cactus index is not initialized");
+    }
+
+    std::vector<int> intIds;
+    intIds.reserve(ids.size());
+    for (size_t i = 0; i < ids.size(); ++i) {
+      intIds.emplace_back(static_cast<int>(ids[i]));
+    }
+
+    int result = cactus_index_delete(this->_index, intIds.data(), ids.size());
+
+    if (result < 0) {
+      throw std::runtime_error("Cactus index delete failed: " +
+                               std::string(cactus_get_last_error()));
+    }
+  });
+}
+
+std::shared_ptr<Promise<CactusIndexGetResult>>
+HybridCactusIndex::get(const std::vector<double> &ids) {
+  return Promise<CactusIndexGetResult>::async([this,
+                                               ids]() -> CactusIndexGetResult {
+    std::lock_guard<std::mutex> lock(this->_indexMutex);
+
+    if (!this->_index) {
+      throw std::runtime_error("Cactus index is not initialized");
+    }
+
+    const size_t count = ids.size();
+
+    std::vector<int> intIds;
+    intIds.reserve(count);
+    for (size_t i = 0; i < count; ++i) {
+      intIds.emplace_back(static_cast<int>(ids[i]));
+    }
+
+    std::vector<std::unique_ptr<char[]>> documentBuffers;
+    documentBuffers.reserve(count);
+    std::vector<std::unique_ptr<char[]>> metadataBuffers;
+    metadataBuffers.reserve(count);
+    std::vector<std::unique_ptr<float[]>> embeddingBuffers;
+    embeddingBuffers.reserve(count);
+
+    const size_t maxStringSize = 65535;
+    std::vector<size_t> documentBufferSizes(count, maxStringSize);
+    std::vector<size_t> metadataBufferSizes(count, maxStringSize);
+    std::vector<size_t> embeddingBufferSizes(count, this->_embeddingDim);
+
+    std::vector<char *> documentPtrs;
+    documentPtrs.reserve(count);
+    std::vector<char *> metadataPtrs;
+    metadataPtrs.reserve(count);
+    std::vector<float *> embeddingPtrs;
+    embeddingPtrs.reserve(count);
+
+    for (size_t i = 0; i < count; ++i) {
+      documentBuffers.emplace_back(std::make_unique<char[]>(maxStringSize));
+      documentPtrs.emplace_back(documentBuffers[i].get());
+
+      metadataBuffers.emplace_back(std::make_unique<char[]>(maxStringSize));
+      metadataPtrs.emplace_back(metadataBuffers[i].get());
+
+      embeddingBuffers.emplace_back(
+          std::make_unique<float[]>(this->_embeddingDim));
+      embeddingPtrs.emplace_back(embeddingBuffers[i].get());
+    }
+
+    int result =
+        cactus_index_get(this->_index, intIds.data(), count,
+                         documentPtrs.data(), documentBufferSizes.data(),
+                         metadataPtrs.data(), metadataBufferSizes.data(),
+                         embeddingPtrs.data(), embeddingBufferSizes.data());
+
+    if (result < 0) {
+      throw std::runtime_error("Cactus index get failed: " +
+                               std::string(cactus_get_last_error()));
+    }
+
+    CactusIndexGetResult resultObj;
+    resultObj.documents.reserve(count);
+    resultObj.metadatas.reserve(count);
+    resultObj.embeddings = std::vector<std::vector<double>>(count);
+
+    for (size_t i = 0; i < count; ++i) {
+      resultObj.documents.emplace_back(std::string(documentBuffers[i].get()));
+      resultObj.metadatas.emplace_back(std::string(metadataBuffers[i].get()));
+
+      resultObj.embeddings[i].reserve(this->_embeddingDim);
+      for (size_t j = 0; j < this->_embeddingDim; ++j) {
+        resultObj.embeddings[i].emplace_back(
+            static_cast<double>(embeddingBuffers[i].get()[j]));
+      }
+    }
+
+    return resultObj;
+  });
+}
+
+std::shared_ptr<Promise<CactusIndexQueryResult>>
+HybridCactusIndex::query(const std::vector<std::vector<double>> &embeddings,
+                         const std::optional<std::string> &optionsJson) {
+  return Promise<CactusIndexQueryResult>::async(
+      [this, embeddings, optionsJson]() -> CactusIndexQueryResult {
+        std::lock_guard<std::mutex> lock(this->_indexMutex);
+
+        if (!this->_index) {
+          throw std::runtime_error("Cactus index is not initialized");
+        }
+
+        const size_t count = embeddings.size();
+
+        std::vector<std::vector<float>> embeddingsFloat(count);
+        std::vector<const float *> embeddingPtrs;
+        embeddingPtrs.reserve(count);
+        for (size_t i = 0; i < count; ++i) {
+          embeddingsFloat[i].resize(embeddings[i].size());
+          for (size_t j = 0; j < embeddings[i].size(); ++j) {
+            embeddingsFloat[i][j] = static_cast<float>(embeddings[i][j]);
+          }
+          embeddingPtrs.emplace_back(embeddingsFloat[i].data());
+        }
+
+        size_t maxResults = 10;
+        if (optionsJson.has_value()) {
+          const std::string &json = *optionsJson;
+          size_t pos = json.find("\"top_k\"");
+          if (pos != std::string::npos) {
+            size_t colonPos = json.find(':', pos);
+            if (colonPos != std::string::npos) {
+              size_t numStart = json.find_first_of("0123456789", colonPos);
+              if (numStart != std::string::npos) {
+                size_t numEnd = json.find_first_not_of("0123456789", numStart);
+                std::string numStr = json.substr(numStart, numEnd - numStart);
+                maxResults = std::stoul(numStr);
+              }
+            }
+          }
+        }
+
+        std::vector<size_t> idBufferSizes(count, maxResults);
+        std::vector<size_t> scoreBufferSizes(count, maxResults);
+
+        std::vector<std::unique_ptr<int[]>> idBuffers;
+        idBuffers.reserve(count);
+        std::vector<std::unique_ptr<float[]>> scoreBuffers;
+        scoreBuffers.reserve(count);
+
+        std::vector<int *> idPtrs;
+        idPtrs.reserve(count);
+        std::vector<float *> scorePtrs;
+        scorePtrs.reserve(count);
+
+        for (size_t i = 0; i < count; ++i) {
+          idBuffers.emplace_back(std::make_unique<int[]>(maxResults));
+          idPtrs.emplace_back(idBuffers[i].get());
+
+          scoreBuffers.emplace_back(std::make_unique<float[]>(maxResults));
+          scorePtrs.emplace_back(scoreBuffers[i].get());
+        }
+
+        int result = cactus_index_query(
+            this->_index, embeddingPtrs.data(), count, this->_embeddingDim,
+            optionsJson ? optionsJson->c_str() : nullptr, idPtrs.data(),
+            idBufferSizes.data(), scorePtrs.data(), scoreBufferSizes.data());
+
+        if (result < 0) {
+          throw std::runtime_error("Cactus index query failed: " +
+                                   std::string(cactus_get_last_error()));
+        }
+
+        CactusIndexQueryResult resultObj;
+        resultObj.ids = std::vector<std::vector<double>>(count);
+        resultObj.scores = std::vector<std::vector<double>>(count);
+
+        for (size_t i = 0; i < count; ++i) {
+          const size_t resultCount = idBufferSizes[i];
+          resultObj.ids[i].reserve(resultCount);
+          resultObj.scores[i].reserve(resultCount);
+
+          for (size_t j = 0; j < resultCount; ++j) {
+            resultObj.ids[i].emplace_back(
+                static_cast<double>(idBuffers[i].get()[j]));
+            resultObj.scores[i].emplace_back(
+                static_cast<double>(scoreBuffers[i].get()[j]));
+          }
+        }
+
+        return resultObj;
+      });
+}
+
+std::shared_ptr<Promise<void>> HybridCactusIndex::compact() {
+  return Promise<void>::async([this]() -> void {
+    std::lock_guard<std::mutex> lock(this->_indexMutex);
+
+    if (!this->_index) {
+      throw std::runtime_error("Cactus index is not initialized");
+    }
+
+    int result = cactus_index_compact(this->_index);
+
+    if (result < 0) {
+      throw std::runtime_error("Cactus index compact failed: " +
+                               std::string(cactus_get_last_error()));
+    }
+  });
+}
+
+std::shared_ptr<Promise<void>> HybridCactusIndex::destroy() {
+  return Promise<void>::async([this]() -> void {
+    std::lock_guard<std::mutex> lock(this->_indexMutex);
+
+    if (!this->_index) {
+      throw std::runtime_error("Cactus index is not initialized");
+    }
+
+    cactus_index_destroy(this->_index);
+    this->_index = nullptr;
+  });
+}
+
+} // namespace margelo::nitro::cactus

package/cpp/HybridCactusIndex.hpp

@@ -0,0 +1,43 @@
+#pragma once
+#include "HybridCactusIndexSpec.hpp"
+
+#include "cactus_ffi.h"
+
+#include <mutex>
+
+namespace margelo::nitro::cactus {
+
+class HybridCactusIndex : public HybridCactusIndexSpec {
+public:
+  HybridCactusIndex();
+
+  std::shared_ptr<Promise<void>> init(const std::string &indexPath,
+                                      double embeddingDim) override;
+
+  std::shared_ptr<Promise<void>>
+  add(const std::vector<double> &ids, const std::vector<std::string> &documents,
+      const std::vector<std::vector<double>> &embeddings,
+      const std::optional<std::vector<std::string>> &metadatas) override;
+
+  std::shared_ptr<Promise<void>>
+  _delete(const std::vector<double> &ids) override;
+
+  std::shared_ptr<Promise<CactusIndexGetResult>>
+  get(const std::vector<double> &ids) override;
+
+  std::shared_ptr<Promise<CactusIndexQueryResult>>
+  query(const std::vector<std::vector<double>> &embeddings,
+        const std::optional<std::string> &optionsJson) override;
+
+  std::shared_ptr<Promise<void>> compact() override;
+
+  std::shared_ptr<Promise<void>> destroy() override;
+
+private:
+  cactus_index_t _index = nullptr;
+  size_t _embeddingDim;
+
+  std::mutex _indexMutex;
+};
+
+} // namespace margelo::nitro::cactus

package/cpp/HybridCactusUtil.cpp

@@ -23,12 +23,12 @@ HybridCactusUtil::registerApp(const std::string &encryptedData) {
 }
 
 std::shared_ptr<Promise<std::optional<std::string>>>
-HybridCactusUtil::getDeviceId() {
+HybridCactusUtil::getDeviceId(const std::optional<std::string> &token) {
   return Promise<std::optional<std::string>>::async(
-      [this]() -> std::optional<std::string> {
+      [this, token]() -> std::optional<std::string> {
         std::lock_guard<std::mutex> lock(this->_mutex);
 
-        const char *deviceId = get_device_id();
+        const char *deviceId = get_device_id(token ? token->c_str() : nullptr);
         return deviceId ? std::optional<std::string>(deviceId) : std::nullopt;
       });
 }