cactus-react-native 1.2.1 → 1.5.0

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;
       });
 }

package/cpp/HybridCactusUtil.hpp

@@ -14,7 +14,8 @@ public:
   std::shared_ptr<Promise<std::string>>
   registerApp(const std::string &encryptedData) override;
 
-  std::shared_ptr<Promise<std::optional<std::string>>> getDeviceId() override;
+  std::shared_ptr<Promise<std::optional<std::string>>>
+  getDeviceId(const std::optional<std::string> &token) override;
 
   std::shared_ptr<Promise<void>>
   setAndroidDataDirectory(const std::string &dataDir) override;

package/cpp/cactus_ffi.h

@@ -3,6 +3,7 @@
 
 #include <stddef.h>
 #include <stdint.h>
+#include <stdbool.h>
 
 #if __GNUC__ >= 4
   #define CACTUS_FFI_EXPORT __attribute__ ((visibility ("default")))
@@ -33,6 +34,26 @@ CACTUS_FFI_EXPORT int cactus_complete(
     void* user_data
 );
 
+CACTUS_FFI_EXPORT int cactus_tokenize(
+    cactus_model_t model,
+    const char* text,
+    uint32_t* token_buffer,
+    size_t token_buffer_len,
+    size_t* out_token_len
+);
+
+CACTUS_FFI_EXPORT int cactus_score_window(
+    cactus_model_t model,
+    const uint32_t* tokens,
+    size_t token_len,
+    size_t start,
+    size_t end,
+    size_t context,
+    char* response_buffer,
+    size_t buffer_size
+);
+
+
 CACTUS_FFI_EXPORT int cactus_transcribe(
     cactus_model_t model,
     const char* audio_file_path,
@@ -41,16 +62,43 @@ CACTUS_FFI_EXPORT int cactus_transcribe(
     size_t buffer_size,
     const char* options_json,
     cactus_token_callback callback,
-    void* user_data
+    void* user_data,
+    const uint8_t* pcm_buffer,
+    size_t pcm_buffer_size
 );
 
+typedef void* cactus_stream_transcribe_t;
+
+CACTUS_FFI_EXPORT cactus_stream_transcribe_t cactus_stream_transcribe_init(cactus_model_t model);
+
+CACTUS_FFI_EXPORT int cactus_stream_transcribe_insert(
+    cactus_stream_transcribe_t stream,
+    const uint8_t* pcm_buffer,
+    size_t pcm_buffer_size
+);
+
+CACTUS_FFI_EXPORT int cactus_stream_transcribe_process(
+    cactus_stream_transcribe_t stream,
+    char* response_buffer,
+    size_t buffer_size,
+    const char* options_json
+);
+
+CACTUS_FFI_EXPORT int cactus_stream_transcribe_finalize(
+    cactus_stream_transcribe_t stream,
+    char* response_buffer,
+    size_t buffer_size
+);
+
+CACTUS_FFI_EXPORT void cactus_stream_transcribe_destroy(cactus_stream_transcribe_t stream);
 
 CACTUS_FFI_EXPORT int cactus_embed(
     cactus_model_t model,
     const char* text,
     float* embeddings_buffer,
     size_t buffer_size,
-    size_t* embedding_dim
+    size_t* embedding_dim,
+    bool normalize
 );
 
 CACTUS_FFI_EXPORT int cactus_image_embed(
@@ -75,6 +123,63 @@ CACTUS_FFI_EXPORT void cactus_stop(cactus_model_t model);
 
 CACTUS_FFI_EXPORT void cactus_destroy(cactus_model_t model);
 
+CACTUS_FFI_EXPORT const char* cactus_get_last_error(void);
+
+CACTUS_FFI_EXPORT void cactus_set_telemetry_token(const char* token);
+
+CACTUS_FFI_EXPORT void cactus_set_pro_key(const char* pro_key);
+
+typedef void* cactus_index_t;
+
+CACTUS_FFI_EXPORT cactus_index_t cactus_index_init(
+    const char* index_dir,
+    size_t embedding_dim
+);
+
+CACTUS_FFI_EXPORT int cactus_index_add(
+    cactus_index_t index,
+    const int* ids,
+    const char** documents,
+    const char** metadatas,
+    const float** embeddings,
+    size_t count,
+    size_t embedding_dim
+);
+
+CACTUS_FFI_EXPORT int cactus_index_delete(
+    cactus_index_t index,
+    const int* ids,
+    size_t ids_count
+);
+
+CACTUS_FFI_EXPORT int cactus_index_get(
+    cactus_index_t index,
+    const int* ids,
+    size_t ids_count,
+    char** document_buffers,
+    size_t* document_buffer_sizes,
+    char** metadata_buffers,
+    size_t* metadata_buffer_sizes,
+    float** embedding_buffers,
+    size_t* embedding_buffer_sizes
+);
+
+CACTUS_FFI_EXPORT int cactus_index_query(
+    cactus_index_t index,
+    const float** embeddings,
+    size_t embeddings_count,
+    size_t embedding_dim,
+    const char* options_json,
+    int** id_buffers,
+    size_t* id_buffer_sizes,
+    float** score_buffers,
+    size_t* score_buffer_sizes
+);
+
+CACTUS_FFI_EXPORT int cactus_index_compact(cactus_index_t index);
+
+CACTUS_FFI_EXPORT void cactus_index_destroy(cactus_index_t index);
+
 #ifdef __cplusplus
 }
 #endif

package/cpp/cactus_util.h

@@ -7,7 +7,7 @@ extern "C" {
 
 const char* register_app(const char* encrypted_data);
 
-const char* get_device_id();
+const char* get_device_id(const char* current_token);
 
 // Helper function to free memory allocated by register_app
 void free_string(const char* str);

package/ios/HybridCactusFileSystem.swift

@@ -133,7 +133,11 @@ class HybridCactusFileSystem: HybridCactusFileSystemSpec {
       try FileManager.default.removeItem(at: modelURL)
     }
   }
-  
+
+  func getIndexPath(name: String) throws -> Promise<String> {
+    return Promise.async { try self.indexURL(name: name).path }
+  }
+
   private func cactusURL() throws -> URL {
     let documentsURL = try FileManager.default.url(
       for: .documentDirectory,
@@ -156,7 +160,24 @@ class HybridCactusFileSystem: HybridCactusFileSystemSpec {
   
   private func modelURL(model: String) throws -> URL {
     let cactusURL = try self.cactusURL()
-    return cactusURL.appendingPathComponent("models/\(model)")
+    let modelsURL = cactusURL.appendingPathComponent("models", isDirectory: true)
+
+    if !FileManager.default.fileExists(atPath: modelsURL.path) {
+      try FileManager.default.createDirectory(at: modelsURL, withIntermediateDirectories: true)
+    }
+
+    return modelsURL.appendingPathComponent(model)
+  }
+
+  private func indexURL(name: String) throws -> URL {
+    let cactusURL = try self.cactusURL()
+    let finalURL = cactusURL.appendingPathComponent("indexes/\(name)", isDirectory: true)
+
+    if !FileManager.default.fileExists(atPath: finalURL.path) {
+      try FileManager.default.createDirectory(at: finalURL, withIntermediateDirectories: true)
+    }
+
+    return finalURL
   }
 }
 

package/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/cactus.h

@@ -7,5 +7,7 @@
 #include "engine/engine.h"
 #include "models/model.h"
 #include "ffi/cactus_ffi.h"
+#include "ffi/cactus_telemetry.h"
+#include "npu/npu.h"
 
 #endif // CACTUS_H