diff --git a/README.md b/README.md
index 1d1c69f..17b8b42 100644
--- a/README.md
+++ b/README.md
@@ -298,6 +298,82 @@ const App = () => {
 };
 ```
 
+### Tokenization
+
+Convert text into tokens using the model's tokenizer.
+
+#### Class
+
+```typescript
+import { CactusLM } from 'cactus-react-native';
+
+const cactusLM = new CactusLM();
+
+const result = await cactusLM.tokenize({ text: 'Hello, World!' });
+console.log('Token IDs:', result.tokens);
+```
+
+#### Hook
+
+```tsx
+import { useCactusLM } from 'cactus-react-native';
+
+const App = () => {
+  const cactusLM = useCactusLM();
+
+  const handleTokenize = async () => {
+    const result = await cactusLM.tokenize({ text: 'Hello, World!' });
+    console.log('Token IDs:', result.tokens);
+  };
+
+  return <Button title="Tokenize" onPress={handleTokenize} />;
+};
+```
+
+### Score Window
+
+Calculate perplexity scores for a window of tokens within a sequence.
+
+#### Class
+
+```typescript
+import { CactusLM } from 'cactus-react-native';
+
+const cactusLM = new CactusLM();
+
+const tokens = [123, 456, 789, 101, 112];
+const result = await cactusLM.scoreWindow({
+  tokens,
+  start: 1,
+  end: 3,
+  context: 2
+});
+console.log('Score:', result.score);
+```
+
+#### Hook
+
+```tsx
+import { useCactusLM } from 'cactus-react-native';
+
+const App = () => {
+  const cactusLM = useCactusLM();
+
+  const handleScoreWindow = async () => {
+    const tokens = [123, 456, 789, 101, 112];
+    const result = await cactusLM.scoreWindow({
+      tokens,
+      start: 1,
+      end: 3,
+      context: 2
+    });
+    console.log('Score:', result.score);
+  };
+
+  return <Button title="Score Window" onPress={handleScoreWindow} />;
+};
+```
+
 ### Embedding
 
 Convert text and images into numerical vector representations that capture semantic meaning, useful for similarity search and semantic understanding.
@@ -423,7 +499,7 @@ The `CactusSTT` class provides audio transcription and audio embedding capabilit
 
 ### Transcription
 
-Transcribe audio files to text with streaming support.
+Transcribe audio to text with streaming support. Accepts either a file path or raw PCM audio samples.
 
 #### Class
 
@@ -434,12 +510,22 @@ const cactusSTT = new CactusSTT({ model: 'whisper-small' });
 
 await cactusSTT.init();
 
+// Transcribe from file path
 const result = await cactusSTT.transcribe({
-  audioFilePath: 'path/to/audio.wav',
+  audio: 'path/to/audio.wav',
   onToken: (token) => console.log('Token:', token)
 });
 
 console.log('Transcription:', result.response);
+
+// Or transcribe from raw PCM samples
+const pcmSamples: number[] = [/* ... */];
+const result2 = await cactusSTT.transcribe({
+  audio: pcmSamples,
+  onToken: (token) => console.log('Token:', token)
+});
+
+console.log('Transcription:', result2.response);
 ```
 
 #### Hook
@@ -451,10 +537,17 @@ const App = () => {
   const cactusSTT = useCactusSTT({ model: 'whisper-small' });
 
   const handleTranscribe = async () => {
+    // Transcribe from file path
     const result = await cactusSTT.transcribe({
-      audioFilePath: 'path/to/audio.wav',
+      audio: 'path/to/audio.wav',
     });
     console.log('Transcription:', result.response);
+
+    const pcmSamples: number[] = [/* ... */];
+    const result2 = await cactusSTT.transcribe({
+      audio: pcmSamples,
+    });
+    console.log('Transcription:', result2.response);
   };
 
   return (
@@ -507,6 +600,251 @@ const App = () => {
 };
 ```
 
+## Vector Index
+
+The `CactusIndex` class provides a vector database for storing and querying embeddings with metadata. Enabling similarity search and retrieval.
+
+### Creating and Initializing an Index
+
+#### Class
+
+```typescript
+import { CactusIndex } from 'cactus-react-native';
+
+const cactusIndex = new CactusIndex('my-index', 1024);
+await cactusIndex.init();
+```
+
+#### Hook
+
+```tsx
+import { useCactusIndex } from 'cactus-react-native';
+
+const App = () => {
+  const cactusIndex = useCactusIndex({
+    name: 'my-index',
+    embeddingDim: 1024
+  });
+
+  const handleInit = async () => {
+    await cactusIndex.init();
+  };
+
+  return <Button title="Initialize Index" onPress={handleInit} />
+};
+```
+
+### Adding Documents
+
+Add documents with their embeddings and metadata to the index.
+
+#### Class
+
+```typescript
+import { CactusIndex } from 'cactus-react-native';
+
+const cactusIndex = new CactusIndex('my-index', 1024);
+await cactusIndex.init();
+
+await cactusIndex.add({
+  ids: [1, 2, 3],
+  documents: ['First document', 'Second document', 'Third document'],
+  embeddings: [
+    [0.1, 0.2, ...],
+    [0.3, 0.4, ...],
+    [0.5, 0.6, ...]
+  ],
+  metadatas: ['metadata1', 'metadata2', 'metadata3']
+});
+```
+
+#### Hook
+
+```tsx
+import { useCactusIndex } from 'cactus-react-native';
+
+const App = () => {
+  const cactusIndex = useCactusIndex({
+    name: 'my-index',
+    embeddingDim: 1024
+  });
+
+  const handleAdd = async () => {
+    await cactusIndex.add({
+      ids: [1, 2, 3],
+      documents: ['First document', 'Second document', 'Third document'],
+      embeddings: [
+        [0.1, 0.2, ...],
+        [0.3, 0.4, ...],
+        [0.5, 0.6, ...]
+      ],
+      metadatas: ['metadata1', 'metadata2', 'metadata3']
+    });
+  };
+
+  return <Button title="Add Documents" onPress={handleAdd} />;
+};
+```
+
+### Querying the Index
+
+Search for similar documents using embedding vectors.
+
+#### Class
+
+```typescript
+import { CactusIndex } from 'cactus-react-native';
+
+const cactusIndex = new CactusIndex('my-index', 1024);
+await cactusIndex.init();
+
+const result = await cactusIndex.query({
+  embeddings: [[0.1, 0.2, ...]],
+  options: {
+    topK: 5,
+    scoreThreshold: 0.7
+  }
+});
+
+console.log('IDs:', result.ids);
+console.log('Scores:', result.scores);
+```
+
+#### Hook
+
+```tsx
+import { useCactusIndex } from 'cactus-react-native';
+
+const App = () => {
+  const cactusIndex = useCactusIndex({
+    name: 'my-index',
+    embeddingDim: 1024
+  });
+
+  const handleQuery = async () => {
+    const result = await cactusIndex.query({
+      embeddings: [[0.1, 0.2, ...]],
+      options: {
+        topK: 5,
+        scoreThreshold: 0.7
+      }
+    });
+    console.log('IDs:', result.ids);
+    console.log('Scores:', result.scores);
+  };
+
+  return <Button title="Query Index" onPress={handleQuery} />;
+};
+```
+
+### Retrieving Documents
+
+Get documents by their IDs.
+
+#### Class
+
+```typescript
+import { CactusIndex } from 'cactus-react-native';
+
+const cactusIndex = new CactusIndex('my-index', 1024);
+await cactusIndex.init();
+
+const result = await cactusIndex.get({ ids: [1, 2, 3] });
+console.log('Documents:', result.documents);
+console.log('Metadatas:', result.metadatas);
+console.log('Embeddings:', result.embeddings);
+```
+
+#### Hook
+
+```tsx
+import { useCactusIndex } from 'cactus-react-native';
+
+const App = () => {
+  const cactusIndex = useCactusIndex({
+    name: 'my-index',
+    embeddingDim: 1024
+  });
+
+  const handleGet = async () => {
+    const result = await cactusIndex.get({ ids: [1, 2, 3] });
+    console.log('Documents:', result.documents);
+    console.log('Metadatas:', result.metadatas);
+    console.log('Embeddings:', result.embeddings);
+  };
+
+  return <Button title="Get Documents" onPress={handleGet} />;
+};
+```
+
+### Deleting Documents
+
+Mark documents as deleted by their IDs.
+
+#### Class
+
+```typescript
+import { CactusIndex } from 'cactus-react-native';
+
+const cactusIndex = new CactusIndex('my-index', 1024);
+await cactusIndex.init();
+
+await cactusIndex.delete({ ids: [1, 2, 3] });
+```
+
+#### Hook
+
+```tsx
+import { useCactusIndex } from 'cactus-react-native';
+
+const App = () => {
+  const cactusIndex = useCactusIndex({
+    name: 'my-index',
+    embeddingDim: 1024
+  });
+
+  const handleDelete = async () => {
+    await cactusIndex.delete({ ids: [1, 2, 3] });
+  };
+
+  return <Button title="Delete Documents" onPress={handleDelete} />;
+};
+```
+
+### Compacting the Index
+
+Optimize the index by removing deleted documents and reorganizing data.
+
+#### Class
+
+```typescript
+import { CactusIndex } from 'cactus-react-native';
+
+const cactusIndex = new CactusIndex('my-index', 1024);
+await cactusIndex.init();
+
+await cactusIndex.compact();
+```
+
+#### Hook
+
+```tsx
+import { useCactusIndex } from 'cactus-react-native';
+
+const App = () => {
+  const cactusIndex = useCactusIndex({
+    name: 'my-index',
+    embeddingDim: 1024
+  });
+
+  const handleCompact = async () => {
+    await cactusIndex.compact();
+  };
+
+  return <Button title="Compact Index" onPress={handleCompact} />;
+};
+```
+
 ## API Reference
 
 ### CactusLM Class
@@ -516,7 +854,7 @@ const App = () => {
 **`new CactusLM(params?: CactusLMParams)`**
 
 **Parameters:**
-- `model` - Model slug (default: `'qwen3-0.6'`).
+- `model` - Model slug or absolute path to Cactus model (default: `'qwen3-0.6'`).
 - `contextSize` - Context window size (default: `2048`).
 - `corpusDir` - Directory containing text files for RAG (default: `undefined`).
 
@@ -545,16 +883,35 @@ Performs text completion with optional streaming and tool support. Automatically
   - `topK` - Top-K sampling limit (default: model-optimized).
   - `maxTokens` - Maximum number of tokens to generate (default: `512`).
   - `stopSequences` - Array of strings to stop generation (default: `undefined`).
+  - `forceTools` - Force the model to call one of the provided tools (default: `false`).
 - `tools` - Array of `Tool` objects for function calling (default: `undefined`).
 - `onToken` - Callback for streaming tokens.
 - `mode` - Completion mode: `'local'` | `'hybrid'` (default: `'local'`)
 
+**`tokenize(params: CactusLMTokenizeParams): Promise<CactusLMTokenizeResult>`**
+
+Converts text into tokens using the model's tokenizer.
+
+**Parameters:**
+- `text` - Text to tokenize.
+
+**`scoreWindow(params: CactusLMScoreWindowParams): Promise<CactusLMScoreWindowResult>`**
+
+Calculates perplexity scores for a window of tokens within a sequence.
+
+**Parameters:**
+- `tokens` - Array of token IDs.
+- `start` - Start index of the window.
+- `end` - End index of the window.
+- `context` - Number of context tokens before the window.
+
 **`embed(params: CactusLMEmbedParams): Promise<CactusLMEmbedResult>`**
 
 Generates embeddings for the given text. Automatically calls `init()` if not already initialized. Throws an error if a generation (completion or embedding) is already in progress.
 
 **Parameters:**
 - `text` - Text to embed.
+- `normalize` - Whether to normalize the embedding vector (default: `false`).
 
 **`imageEmbed(params: CactusLMImageEmbedParams): Promise<CactusLMImageEmbedResult>`**
 
@@ -598,6 +955,8 @@ The `useCactusLM` hook manages a `CactusLM` instance with reactive state. When m
 - `download(params?: CactusLMDownloadParams): Promise<void>` - Downloads the model. Updates `isDownloading` and `downloadProgress` state during download. Sets `isDownloaded` to `true` on success.
 - `init(): Promise<void>` - Initializes the model for inference. Sets `isInitializing` to `true` during initialization.
 - `complete(params: CactusLMCompleteParams): Promise<CactusLMCompleteResult>` - Generates text completions. Automatically accumulates tokens in the `completion` state during streaming. Sets `isGenerating` to `true` while generating. Clears `completion` before starting.
+- `tokenize(params: CactusLMTokenizeParams): Promise<CactusLMTokenizeResult>` - Converts text into tokens. Sets `isGenerating` to `true` during operation.
+- `scoreWindow(params: CactusLMScoreWindowParams): Promise<CactusLMScoreWindowResult>` - Calculates perplexity scores for a window of tokens. Sets `isGenerating` to `true` during operation.
 - `embed(params: CactusLMEmbedParams): Promise<CactusLMEmbedResult>` - Generates embeddings for the given text. Sets `isGenerating` to `true` during operation.
 - `imageEmbed(params: CactusLMImageEmbedParams): Promise<CactusLMImageEmbedResult>` - Generates embeddings for the given image. Sets `isGenerating` to `true` while generating.
 - `stop(): Promise<void>` - Stops ongoing generation. Clears any errors.
@@ -612,7 +971,7 @@ The `useCactusLM` hook manages a `CactusLM` instance with reactive state. When m
 **`new CactusSTT(params?: CactusSTTParams)`**
 
 **Parameters:**
-- `model` - Model slug (default: `'whisper-small'`).
+- `model` - Model slug or absolute path to Cactus model (default: `'qwen3-0.6'`).
 - `contextSize` - Context window size (default: `2048`).
 
 #### Methods
@@ -630,10 +989,10 @@ Initializes the model and prepares it for inference. Safe to call multiple times
 
 **`transcribe(params: CactusSTTTranscribeParams): Promise<CactusSTTTranscribeResult>`**
 
-Transcribes audio to text with optional streaming support. Automatically calls `init()` if not already initialized. Throws an error if a generation is already in progress.
+Transcribes audio to text with optional streaming support. Accepts either a file path or raw PCM audio samples. Automatically calls `init()` if not already initialized. Throws an error if a generation is already in progress.
 
 **Parameters:**
-- `audioFilePath` - Path to the audio file.
+- `audio` - Path to the audio file or raw PCM samples.
 - `prompt` - Optional prompt to guide transcription (default: `'<|startoftranscript|><|en|><|transcribe|><|notimestamps|>'`).
 - `options` - Transcription options:
   - `temperature` - Sampling temperature (default: model-optimized).
@@ -691,6 +1050,84 @@ The `useCactusSTT` hook manages a `CactusSTT` instance with reactive state. When
 - `destroy(): Promise<void>` - Releases all resources associated with the model. Clears the `transcription` state. Automatically called when the component unmounts.
 - `getModels(): Promise<CactusSTTModel[]>` - Fetches available STT models from the database and checks their download status.
 
+### CactusIndex Class
+
+#### Constructor
+
+**`new CactusIndex(name: string, embeddingDim: number)`**
+
+**Parameters:**
+- `name` - Name of the index.
+- `embeddingDim` - Dimension of the embedding vectors.
+
+#### Methods
+
+**`init(): Promise<void>`**
+
+Initializes the index and prepares it for operations. Must be called before using any other methods.
+
+**`add(params: CactusIndexAddParams): Promise<void>`**
+
+Adds documents with their embeddings and metadata to the index.
+
+**Parameters:**
+- `ids` - Array of document IDs.
+- `documents` - Array of document texts.
+- `embeddings` - Array of embedding vectors (each vector must match `embeddingDim`).
+- `metadatas` - Optional array of metadata strings.
+
+**`query(params: CactusIndexQueryParams): Promise<CactusIndexQueryResult>`**
+
+Searches for similar documents using embedding vectors.
+
+**Parameters:**
+- `embeddings` - Array of query embedding vectors.
+- `options` - Query options:
+  - `topK` - Number of top results to return (default: 10).
+  - `scoreThreshold` - Minimum similarity score threshold (default: -1.0).
+
+**`get(params: CactusIndexGetParams): Promise<CactusIndexGetResult>`**
+
+Retrieves documents by their IDs.
+
+**Parameters:**
+- `ids` - Array of document IDs to retrieve.
+
+**`delete(params: CactusIndexDeleteParams): Promise<void>`**
+
+Deletes documents from the index by their IDs.
+
+**Parameters:**
+- `ids` - Array of document IDs to delete.
+
+**`compact(): Promise<void>`**
+
+Optimizes the index by removing deleted documents and reorganizing data for better performance. Call after a series of deletions.
+
+**`destroy(): Promise<void>`**
+
+Releases all resources associated with the index from memory.
+
+### useCactusIndex Hook
+
+The `useCactusIndex` hook manages a `CactusIndex` instance with reactive state. When index parameters (`name` or `embeddingDim`) change, the hook creates a new instance and resets all state. The hook automatically cleans up resources when the component unmounts.
+
+#### State
+
+- `isInitializing: boolean` - Whether the index is initializing.
+- `isProcessing: boolean` - Whether the index is processing an operation (add, query, get, delete, or compact).
+- `error: string | null` - Last error message from any operation, or `null` if there is no error. Cleared before starting new operations.
+
+#### Methods
+
+- `init(): Promise<void>` - Initializes the index. Sets `isInitializing` to `true` during initialization.
+- `add(params: CactusIndexAddParams): Promise<void>` - Adds documents to the index. Sets `isProcessing` to `true` during operation.
+- `query(params: CactusIndexQueryParams): Promise<CactusIndexQueryResult>` - Searches for similar documents. Sets `isProcessing` to `true` during operation.
+- `get(params: CactusIndexGetParams): Promise<CactusIndexGetResult>` - Retrieves documents by IDs. Sets `isProcessing` to `true` during operation.
+- `delete(params: CactusIndexDeleteParams): Promise<void>` - Deletes documents. Sets `isProcessing` to `true` during operation.
+- `compact(): Promise<void>` - Optimizes the index. Sets `isProcessing` to `true` during operation.
+- `destroy(): Promise<void>` - Releases all resources. Automatically called when the component unmounts.
+
 ## Type Definitions
 
 ### CactusLMParams
@@ -730,6 +1167,7 @@ interface CompleteOptions {
   topK?: number;
   maxTokens?: number;
   stopSequences?: string[];
+  forceTools?: boolean;
 }
 ```
 
@@ -783,11 +1221,47 @@ interface CactusLMCompleteResult {
 }
 ```
 
+### CactusLMTokenizeParams
+
+```typescript
+interface CactusLMTokenizeParams {
+  text: string;
+}
+```
+
+### CactusLMTokenizeResult
+
+```typescript
+interface CactusLMTokenizeResult {
+  tokens: number[];
+}
+```
+
+### CactusLMScoreWindowParams
+
+```typescript
+interface CactusLMScoreWindowParams {
+  tokens: number[];
+  start: number;
+  end: number;
+  context: number;
+}
+```
+
+### CactusLMScoreWindowResult
+
+```typescript
+interface CactusLMScoreWindowResult {
+  score: number;
+}
+```
+
 ### CactusLMEmbedParams
 
 ```typescript
 interface CactusLMEmbedParams {
   text: string;
+  normalize?: boolean;
 }
 ```
 
@@ -878,7 +1352,7 @@ interface TranscribeOptions {
 
 ```typescript
 interface CactusSTTTranscribeParams {
-  audioFilePath: string;
+  audio: string | number[];
   prompt?: string;
   options?: TranscribeOptions;
   onToken?: (token: string) => void;
@@ -917,6 +1391,79 @@ interface CactusSTTAudioEmbedResult {
 }
 ```
 
+### CactusIndexParams
+
+```typescript
+interface CactusIndexParams {
+  name: string;
+  embeddingDim: number;
+}
+```
+
+### CactusIndexAddParams
+
+```typescript
+interface CactusIndexAddParams {
+  ids: number[];
+  documents: string[];
+  embeddings: number[][];
+  metadatas?: string[];
+}
+```
+
+### CactusIndexGetParams
+
+```typescript
+interface CactusIndexGetParams {
+  ids: number[];
+}
+```
+
+### CactusIndexGetResult
+
+```typescript
+interface CactusIndexGetResult {
+  documents: string[];
+  metadatas: string[];
+  embeddings: number[][];
+}
+```
+
+### IndexQueryOptions
+
+```typescript
+interface IndexQueryOptions {
+  topK?: number;
+  scoreThreshold?: number;
+}
+```
+
+### CactusIndexQueryParams
+
+```typescript
+interface CactusIndexQueryParams {
+  embeddings: number[][];
+  options?: IndexQueryOptions;
+}
+```
+
+### CactusIndexQueryResult
+
+```typescript
+interface CactusIndexQueryResult {
+  ids: number[][];
+  scores: number[][];
+}
+```
+
+### CactusIndexDeleteParams
+
+```typescript
+interface CactusIndexDeleteParams {
+  ids: number[];
+}
+```
+
 ## Configuration
 
 ### Telemetry
diff --git a/android/CMakeLists.txt b/android/CMakeLists.txt
index eaf9916..22b1cee 100644
--- a/android/CMakeLists.txt
+++ b/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 :)
diff --git a/android/src/main/java/com/margelo/nitro/cactus/HybridCactusFileSystem.kt b/android/src/main/java/com/margelo/nitro/cactus/HybridCactusFileSystem.kt
index 3d7ae77..70b1d09 100644
--- a/android/src/main/java/com/margelo/nitro/cactus/HybridCactusFileSystem.kt
+++ b/android/src/main/java/com/margelo/nitro/cactus/HybridCactusFileSystem.kt
@@ -209,6 +209,8 @@ class HybridCactusFileSystem : HybridCactusFileSystemSpec() {
       modelFile.deleteRecursively()
     }
 
+  override fun getIndexPath(name: String): Promise<String> = Promise.async { indexFile(name).absolutePath }
+
   private fun cactusFile(): File {
     val cactusDir = File(context.filesDir, "cactus")
 
@@ -221,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
   }
 }
diff --git a/android/src/main/jniLibs/arm64-v8a/libcactus.a b/android/src/main/jniLibs/arm64-v8a/libcactus.a
index 60bf48f..0a72e9d 100644
Binary files a/android/src/main/jniLibs/arm64-v8a/libcactus.a and b/android/src/main/jniLibs/arm64-v8a/libcactus.a differ
diff --git a/android/src/main/jniLibs/arm64-v8a/libcactus_util.a b/android/src/main/jniLibs/arm64-v8a/libcactus_util.a
new file mode 100644
index 0000000..5db9dbe
Binary files /dev/null and b/android/src/main/jniLibs/arm64-v8a/libcactus_util.a differ
diff --git a/android/src/main/jniLibs/arm64-v8a/libcactus_util.so b/android/src/main/jniLibs/arm64-v8a/libcactus_util.so
deleted file mode 100755
index 9a5cad1..0000000
Binary files a/android/src/main/jniLibs/arm64-v8a/libcactus_util.so and /dev/null differ
diff --git a/cpp/HybridCactus.cpp b/cpp/HybridCactus.cpp
index ea9d913..7cce17a 100644
--- a/cpp/HybridCactus.cpp
+++ b/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);
diff --git a/cpp/HybridCactus.hpp b/cpp/HybridCactus.hpp
index 575294d..fd49a1e 100644
--- a/cpp/HybridCactus.hpp
+++ b/cpp/HybridCactus.hpp
@@ -23,15 +23,24 @@ class HybridCactus : public HybridCactusSpec {
                                              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;
diff --git a/cpp/HybridCactusIndex.cpp b/cpp/HybridCactusIndex.cpp
new file mode 100644
index 0000000..b2da9ac
--- /dev/null
+++ b/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
diff --git a/cpp/HybridCactusIndex.hpp b/cpp/HybridCactusIndex.hpp
new file mode 100644
index 0000000..c423d32
--- /dev/null
+++ b/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
diff --git a/cpp/HybridCactusUtil.cpp b/cpp/HybridCactusUtil.cpp
index a2da907..7ebc083 100644
--- a/cpp/HybridCactusUtil.cpp
+++ b/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;
       });
 }
diff --git a/cpp/HybridCactusUtil.hpp b/cpp/HybridCactusUtil.hpp
index 6f72fa4..f84b8f2 100644
--- a/cpp/HybridCactusUtil.hpp
+++ b/cpp/HybridCactusUtil.hpp
@@ -14,7 +14,8 @@ class HybridCactusUtil : public HybridCactusUtilSpec {
   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;
diff --git a/cpp/cactus_ffi.h b/cpp/cactus_ffi.h
index 6bb3f27..e00b391 100644
--- a/cpp/cactus_ffi.h
+++ b/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,7 +62,9 @@ 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
 );
 
 
@@ -50,7 +73,8 @@ CACTUS_FFI_EXPORT int cactus_embed(
     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 +99,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
diff --git a/cpp/cactus_util.h b/cpp/cactus_util.h
index 8ee154a..aa19ef0 100644
--- a/cpp/cactus_util.h
+++ b/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);
diff --git a/example/Gemfile.lock b/example/Gemfile.lock
index d3116fb..ce4f4a3 100644
--- a/example/Gemfile.lock
+++ b/example/Gemfile.lock
@@ -1,25 +1,21 @@
 GEM
   remote: https://rubygems.org/
   specs:
-    CFPropertyList (3.0.7)
-      base64
-      nkf
-      rexml
+    CFPropertyList (3.0.9)
     activesupport (6.1.7.10)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
       tzinfo (~> 2.0)
       zeitwerk (~> 2.3)
-    addressable (2.8.7)
-      public_suffix (>= 2.0.2, < 7.0)
+    addressable (2.8.8)
+      public_suffix (>= 2.0.2, < 8.0)
     algoliasearch (1.27.5)
       httpclient (~> 2.8, >= 2.8.3)
       json (>= 1.5.1)
     atomos (0.1.3)
-    base64 (0.3.0)
     benchmark (0.5.0)
-    bigdecimal (3.3.1)
+    bigdecimal (4.0.1)
     claide (1.1.0)
     cocoapods (1.15.2)
       addressable (~> 2.8)
@@ -69,7 +65,7 @@ GEM
     gh_inspector (1.1.3)
     httpclient (2.9.0)
       mutex_m
-    i18n (1.14.7)
+    i18n (1.14.8)
       concurrent-ruby (~> 1.0)
     json (2.7.6)
     logger (1.7.0)
@@ -79,7 +75,6 @@ GEM
     nanaimo (0.3.0)
     nap (1.1.0)
     netrc (0.11.0)
-    nkf (0.2.0)
     public_suffix (4.0.7)
     rexml (3.4.4)
     ruby-macho (2.5.1)
@@ -113,4 +108,4 @@ RUBY VERSION
    ruby 2.6.10p210
 
 BUNDLED WITH
-   1.17.2
+   2.4.22
diff --git a/example/ios/Podfile.lock b/example/ios/Podfile.lock
index f900f1d..f1bbe42 100644
--- a/example/ios/Podfile.lock
+++ b/example/ios/Podfile.lock
@@ -1,6 +1,6 @@
 PODS:
   - boost (1.84.0)
-  - Cactus (1.2.1):
+  - Cactus (1.4.0):
     - boost
     - DoubleConversion
     - fast_float
@@ -2643,7 +2643,7 @@ EXTERNAL SOURCES:
 
 SPEC CHECKSUMS:
   boost: 7e761d76ca2ce687f7cc98e698152abd03a18f90
-  Cactus: 9eae9838fd1c7be78375534369f7b07123ae645c
+  Cactus: 83c36f3d76eb2102a79020b41201a3aae8b71956
   DoubleConversion: cb417026b2400c8f53ae97020b2be961b59470cb
   fast_float: b32c788ed9c6a8c584d114d0047beda9664e7cc6
   FBLazyVector: b8f1312d48447cca7b4abc21ed155db14742bd03
diff --git a/example/src/App.tsx b/example/src/App.tsx
index 63e6ea2..0033107 100644
--- a/example/src/App.tsx
+++ b/example/src/App.tsx
@@ -13,7 +13,7 @@ import ToolCallingScreen from './ToolCallingScreen';
 import RAGScreen from './RAGScreen';
 import STTScreen from './STTScreen';
 import ChatScreen from './ChatScreen';
-import PerformanceScreen from './PerformanceScreen';
+import IndexScreen from './IndexScreen';
 
 type Screen =
   | 'Home'
@@ -23,7 +23,7 @@ type Screen =
   | 'RAG'
   | 'STT'
   | 'Chat'
-  | 'Performance';
+  | 'Index';
 
 const App = () => {
   const [selectedScreen, setSelectedScreen] = useState<Screen>('Home');
@@ -56,8 +56,8 @@ const App = () => {
     setSelectedScreen('Chat');
   };
 
-  const handleGoToPerformance = () => {
-    setSelectedScreen('Performance');
+  const handleGoToIndex = () => {
+    setSelectedScreen('Index');
   };
 
   const renderScreen = () => {
@@ -74,8 +74,8 @@ const App = () => {
         return <STTScreen />;
       case 'Chat':
         return <ChatScreen />;
-      case 'Performance':
-        return <PerformanceScreen />;
+      case 'Index':
+        return <IndexScreen />;
       default:
         return null;
     }
@@ -149,13 +149,10 @@ const App = () => {
             </Text>
           </TouchableOpacity>
 
-          <TouchableOpacity
-            style={styles.menuButton}
-            onPress={handleGoToPerformance}
-          >
-            <Text style={styles.menuButtonTitle}>Performance</Text>
+          <TouchableOpacity style={styles.menuButton} onPress={handleGoToIndex}>
+            <Text style={styles.menuButtonTitle}>Vector Index</Text>
             <Text style={styles.menuButtonDescription}>
-              Direct CactusLM class usage
+              CactusIndex with embeddings
             </Text>
           </TouchableOpacity>
         </ScrollView>
diff --git a/example/src/IndexScreen.tsx b/example/src/IndexScreen.tsx
new file mode 100644
index 0000000..e10af8e
--- /dev/null
+++ b/example/src/IndexScreen.tsx
@@ -0,0 +1,384 @@
+import { useEffect, useState } from 'react';
+import {
+  View,
+  Text,
+  TextInput,
+  TouchableOpacity,
+  ScrollView,
+  StyleSheet,
+  ActivityIndicator,
+} from 'react-native';
+import {
+  useCactusLM,
+  useCactusIndex,
+  type CactusIndexQueryResult,
+  type CactusIndexGetResult,
+} from 'cactus-react-native';
+
+const SAMPLE_DOCUMENTS = [
+  'The capital of France is Paris.',
+  'The largest planet in our solar system is Jupiter.',
+  'The chemical symbol for water is H2O.',
+];
+
+const IndexScreen = () => {
+  const cactusLM = useCactusLM({
+    model: 'lfm2-350m',
+  });
+  const cactusIndex = useCactusIndex({
+    name: 'example_index',
+    embeddingDim: 1024,
+  });
+
+  // State for adding new document
+  const [newId, setNewId] = useState<string>('');
+  const [newDoc, setNewDoc] = useState<string>('');
+  const [newMetadata, setNewMetadata] = useState<string>('');
+
+  // State for querying
+  const [query, setQuery] = useState<string>('What is the capital of France?');
+  const [queryResults, setQueryResults] =
+    useState<CactusIndexQueryResult | null>(null);
+  const [getResults, setGetResults] = useState<CactusIndexGetResult | null>(
+    null
+  );
+
+  useEffect(() => {
+    cactusLM.download();
+
+    // Cleanup on unmount
+    return () => {
+      cactusLM.destroy();
+      cactusIndex.destroy();
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  useEffect(() => {
+    if (!cactusLM.isDownloaded) {
+      return;
+    }
+
+    const setupIndex = async () => {
+      try {
+        // Initialize model and index
+        await cactusLM.init();
+        await cactusIndex.init();
+      } catch (e) {
+        console.error('Error during index setup:', e);
+        return;
+      }
+
+      try {
+        // Check if index is already populated
+        const existing = await cactusIndex.get({ ids: [0] });
+        if (existing.documents.length > 0) {
+          console.log('Index already populated, skipping setup.');
+          return;
+        }
+      } catch {}
+
+      const ids = [];
+      const documents = [];
+      const embeddings = [];
+      const metadatas = [];
+
+      for (const [i, doc] of SAMPLE_DOCUMENTS.entries()) {
+        ids.push(i);
+        documents.push(doc);
+        metadatas.push(JSON.stringify({ source: `Sample Document ${i}` }));
+        const embedding = await cactusLM.embed({ text: doc });
+        console.log(
+          `Generated embedding for document: "${doc}" with embedding length: ${embedding.embedding.length}`
+        );
+        embeddings.push(embedding.embedding);
+      }
+
+      try {
+        await cactusIndex.add({ ids, documents, embeddings, metadatas });
+      } catch (e) {
+        console.error('Error adding documents to index:', e);
+      }
+    };
+    setupIndex();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [cactusLM.isDownloaded]);
+
+  const indexAdd = async () => {
+    if (!newId || !newDoc) {
+      console.warn('Please provide both an ID and a document to add.');
+      return;
+    }
+
+    try {
+      const embedding = await cactusLM.embed({ text: newDoc });
+      await cactusIndex.add({
+        ids: [parseInt(newId, 10)],
+        documents: [newDoc],
+        embeddings: [embedding.embedding],
+        metadatas: [newMetadata],
+      });
+      console.log('Document added successfully');
+      setNewId('');
+      setNewDoc('');
+      setNewMetadata('');
+    } catch (e) {
+      console.error('Error adding document to index:', e);
+    }
+  };
+
+  const indexQuery = async () => {
+    if (!query) {
+      console.warn('Please provide a query string.');
+      return;
+    }
+
+    try {
+      const queryEmbedding = await cactusLM.embed({ text: query });
+      const queryResult = await cactusIndex.query({
+        embeddings: [queryEmbedding.embedding],
+        options: { topK: 3, scoreThreshold: 0.1 },
+      });
+
+      console.log('Query results:', queryResult);
+      setQueryResults(queryResult);
+
+      if (!queryResult.ids[0]) {
+        console.log('No results found for the query.');
+        return;
+      }
+
+      setGetResults(await cactusIndex.get({ ids: queryResult.ids[0] }));
+    } catch (e) {
+      console.error('Error querying index:', e);
+      return;
+    }
+  };
+
+  if (cactusLM.isDownloading) {
+    return (
+      <View style={styles.centerContainer}>
+        <ActivityIndicator size="large" />
+        <Text style={styles.progressText}>
+          Downloading model: {Math.round(cactusLM.downloadProgress * 100)}%
+        </Text>
+      </View>
+    );
+  }
+
+  return (
+    <ScrollView style={styles.container} contentContainerStyle={styles.content}>
+      <View style={styles.infoBox}>
+        <Text style={styles.infoTitle}>Vector Index Demo</Text>
+        <Text style={styles.infoText}>
+          Sample documents have been indexed. Query them or add new documents.
+        </Text>
+      </View>
+
+      <View style={styles.section}>
+        <Text style={styles.sectionTitle}>Add Document</Text>
+        <TextInput
+          style={styles.input}
+          value={newId}
+          onChangeText={setNewId}
+          placeholder="Document ID (number)"
+          placeholderTextColor="#666"
+          keyboardType="numeric"
+        />
+        <TextInput
+          style={[styles.input, styles.multilineInput]}
+          value={newDoc}
+          onChangeText={setNewDoc}
+          placeholder="Document text..."
+          placeholderTextColor="#666"
+          multiline
+        />
+        <TextInput
+          style={styles.input}
+          value={newMetadata}
+          onChangeText={setNewMetadata}
+          placeholder="Metadata (optional, JSON string)"
+          placeholderTextColor="#666"
+        />
+        <TouchableOpacity
+          style={styles.button}
+          onPress={indexAdd}
+          disabled={cactusLM.isGenerating}
+        >
+          <Text style={styles.buttonText}>Add to Index</Text>
+        </TouchableOpacity>
+      </View>
+
+      <View style={styles.section}>
+        <Text style={styles.sectionTitle}>Query Index</Text>
+        <TextInput
+          style={[styles.input, styles.multilineInput]}
+          value={query}
+          onChangeText={setQuery}
+          placeholder="Enter your query..."
+          placeholderTextColor="#666"
+          multiline
+        />
+        <TouchableOpacity
+          style={styles.button}
+          onPress={indexQuery}
+          disabled={cactusLM.isGenerating}
+        >
+          <Text style={styles.buttonText}>
+            {cactusLM.isGenerating ? 'Querying...' : 'Query'}
+          </Text>
+        </TouchableOpacity>
+      </View>
+
+      {getResults && queryResults && (
+        <View style={styles.resultContainer}>
+          <Text style={styles.resultLabel}>Results</Text>
+          {getResults.documents.map((doc, index) => (
+            <View key={index} style={styles.resultBox}>
+              <View style={styles.resultHeader}>
+                <Text style={styles.resultScore}>
+                  {queryResults.scores[0]?.[index]?.toFixed(3) || 'N/A'}
+                </Text>
+              </View>
+              <Text style={styles.resultText}>{doc}</Text>
+              {getResults.metadatas[index] && (
+                <Text style={styles.resultMetadata}>
+                  {getResults.metadatas[index]}
+                </Text>
+              )}
+            </View>
+          ))}
+        </View>
+      )}
+
+      {cactusLM.error && (
+        <View style={styles.errorContainer}>
+          <Text style={styles.errorText}>{cactusLM.error}</Text>
+        </View>
+      )}
+    </ScrollView>
+  );
+};
+
+export default IndexScreen;
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    backgroundColor: '#fff',
+  },
+  content: {
+    padding: 20,
+  },
+  centerContainer: {
+    flex: 1,
+    justifyContent: 'center',
+    alignItems: 'center',
+    padding: 20,
+  },
+  progressText: {
+    marginTop: 16,
+    fontSize: 16,
+    color: '#000',
+  },
+  infoBox: {
+    backgroundColor: '#f3f3f3',
+    padding: 12,
+    borderRadius: 8,
+    marginBottom: 16,
+  },
+  infoTitle: {
+    fontSize: 14,
+    fontWeight: '600',
+    marginBottom: 4,
+    color: '#000',
+  },
+  infoText: {
+    fontSize: 14,
+    color: '#666',
+  },
+  section: {
+    marginBottom: 24,
+  },
+  sectionTitle: {
+    fontSize: 16,
+    fontWeight: '600',
+    marginBottom: 12,
+    color: '#000',
+  },
+  input: {
+    borderWidth: 1,
+    borderColor: '#ddd',
+    borderRadius: 8,
+    padding: 12,
+    fontSize: 16,
+    marginBottom: 12,
+    color: '#000',
+  },
+  multilineInput: {
+    textAlignVertical: 'top',
+    minHeight: 80,
+  },
+  buttonContainer: {
+    flexDirection: 'row',
+    flexWrap: 'wrap',
+    gap: 8,
+    marginTop: 16,
+  },
+  button: {
+    backgroundColor: '#000',
+    paddingVertical: 12,
+    paddingHorizontal: 16,
+    borderRadius: 8,
+    alignItems: 'center',
+  },
+  buttonText: {
+    color: '#fff',
+    fontSize: 16,
+    fontWeight: '600',
+  },
+  resultContainer: {
+    marginTop: 16,
+    marginBottom: 16,
+  },
+  resultLabel: {
+    fontSize: 16,
+    fontWeight: '600',
+    marginBottom: 8,
+    color: '#000',
+  },
+  resultBox: {
+    backgroundColor: '#f3f3f3',
+    padding: 12,
+    borderRadius: 8,
+    marginBottom: 12,
+  },
+  resultHeader: {
+    marginBottom: 8,
+  },
+  resultScore: {
+    fontSize: 14,
+    fontWeight: '600',
+    color: '#000',
+  },
+  resultText: {
+    fontSize: 14,
+    color: '#000',
+    lineHeight: 20,
+  },
+  resultMetadata: {
+    fontSize: 12,
+    color: '#666',
+    marginTop: 8,
+  },
+  errorContainer: {
+    backgroundColor: '#000',
+    padding: 12,
+    borderRadius: 8,
+    marginTop: 16,
+  },
+  errorText: {
+    color: '#fff',
+    fontSize: 14,
+  },
+});
diff --git a/example/src/PerformanceScreen.tsx b/example/src/PerformanceScreen.tsx
deleted file mode 100644
index 4fc9384..0000000
--- a/example/src/PerformanceScreen.tsx
+++ /dev/null
@@ -1,313 +0,0 @@
-import { useState, useEffect } from 'react';
-import {
-  View,
-  Text,
-  TextInput,
-  TouchableOpacity,
-  ScrollView,
-  StyleSheet,
-  ActivityIndicator,
-} from 'react-native';
-import {
-  CactusLM,
-  type Message,
-  type CactusLMCompleteResult,
-} from 'cactus-react-native';
-
-const cactusLM = new CactusLM({ model: 'lfm2-350m' });
-
-const PerformanceScreen = () => {
-  const [input, setInput] = useState('What is the capital of France?');
-  const [result, setResult] = useState<CactusLMCompleteResult | null>(null);
-  const [isDownloading, setIsDownloading] = useState(false);
-  const [downloadProgress, setDownloadProgress] = useState(0);
-  const [isGenerating, setIsGenerating] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-
-  useEffect(() => {
-    const downloadModel = async () => {
-      try {
-        setIsDownloading(true);
-        await cactusLM.download({
-          onProgress: (progress) => {
-            setDownloadProgress(progress);
-          },
-        });
-      } catch (err) {
-        setError(err instanceof Error ? err.message : 'Download failed');
-      } finally {
-        setIsDownloading(false);
-      }
-    };
-
-    downloadModel();
-
-    // Cleanup on unmount
-    return () => {
-      cactusLM.destroy();
-    };
-  }, []);
-
-  const handleInit = async () => {
-    try {
-      setError(null);
-      await cactusLM.init();
-    } catch (err) {
-      setError(err instanceof Error ? err.message : 'Init failed');
-    }
-  };
-
-  const handleComplete = async () => {
-    try {
-      setError(null);
-      setIsGenerating(true);
-      const messages: Message[] = [
-        { role: 'system', content: 'You are a helpful assistant.' },
-        { role: 'user', content: input },
-      ];
-      const completionResult = await cactusLM.complete({ messages });
-      setResult(completionResult);
-    } catch (err) {
-      setError(err instanceof Error ? err.message : 'Complete failed');
-    } finally {
-      setIsGenerating(false);
-    }
-  };
-
-  const handleStop = async () => {
-    try {
-      setError(null);
-      await cactusLM.stop();
-    } catch (err) {
-      setError(err instanceof Error ? err.message : 'Stop failed');
-    }
-  };
-
-  const handleReset = async () => {
-    try {
-      setError(null);
-      await cactusLM.reset();
-      setResult(null);
-    } catch (err) {
-      setError(err instanceof Error ? err.message : 'Reset failed');
-    }
-  };
-
-  const handleDestroy = async () => {
-    try {
-      setError(null);
-      await cactusLM.destroy();
-      setResult(null);
-    } catch (err) {
-      setError(err instanceof Error ? err.message : 'Destroy failed');
-    }
-  };
-
-  if (isDownloading) {
-    return (
-      <View style={styles.centerContainer}>
-        <ActivityIndicator size="large" />
-        <Text style={styles.progressText}>
-          Downloading model: {Math.round(downloadProgress * 100)}%
-        </Text>
-      </View>
-    );
-  }
-
-  return (
-    <ScrollView style={styles.container} contentContainerStyle={styles.content}>
-      <TextInput
-        style={styles.input}
-        value={input}
-        onChangeText={setInput}
-        placeholder="Type your message..."
-        multiline
-      />
-
-      <View style={styles.buttonContainer}>
-        <TouchableOpacity style={styles.button} onPress={handleInit}>
-          <Text style={styles.buttonText}>Init</Text>
-        </TouchableOpacity>
-
-        <TouchableOpacity
-          style={styles.button}
-          onPress={handleComplete}
-          disabled={isGenerating}
-        >
-          <Text style={styles.buttonText}>
-            {isGenerating ? 'Completing...' : 'Complete'}
-          </Text>
-        </TouchableOpacity>
-
-        <TouchableOpacity style={styles.button} onPress={handleStop}>
-          <Text style={styles.buttonText}>Stop</Text>
-        </TouchableOpacity>
-
-        <TouchableOpacity style={styles.button} onPress={handleReset}>
-          <Text style={styles.buttonText}>Reset</Text>
-        </TouchableOpacity>
-
-        <TouchableOpacity style={styles.button} onPress={handleDestroy}>
-          <Text style={styles.buttonText}>Destroy</Text>
-        </TouchableOpacity>
-      </View>
-
-      {result && (
-        <View style={styles.resultContainer}>
-          <Text style={styles.resultLabel}>CactusLMCompleteResult:</Text>
-          <View style={styles.resultBox}>
-            <Text style={styles.resultFieldLabel}>success:</Text>
-            <Text style={styles.resultFieldValue}>
-              {result.success.toString()}
-            </Text>
-
-            <Text style={[styles.resultFieldLabel, styles.marginTop]}>
-              response:
-            </Text>
-            <Text style={styles.resultFieldValue}>{result.response}</Text>
-
-            <Text style={[styles.resultFieldLabel, styles.marginTop]}>
-              functionCalls:
-            </Text>
-            <Text style={styles.resultFieldValue}>
-              {result.functionCalls
-                ? JSON.stringify(result.functionCalls, null, 2)
-                : 'undefined'}
-            </Text>
-
-            <Text style={[styles.resultFieldLabel, styles.marginTop]}>
-              timeToFirstTokenMs:
-            </Text>
-            <Text style={styles.resultFieldValue}>
-              {result.timeToFirstTokenMs.toFixed(2)}
-            </Text>
-
-            <Text style={[styles.resultFieldLabel, styles.marginTop]}>
-              totalTimeMs:
-            </Text>
-            <Text style={styles.resultFieldValue}>
-              {result.totalTimeMs.toFixed(2)}
-            </Text>
-
-            <Text style={[styles.resultFieldLabel, styles.marginTop]}>
-              tokensPerSecond:
-            </Text>
-            <Text style={styles.resultFieldValue}>
-              {result.tokensPerSecond.toFixed(2)}
-            </Text>
-
-            <Text style={[styles.resultFieldLabel, styles.marginTop]}>
-              prefillTokens:
-            </Text>
-            <Text style={styles.resultFieldValue}>{result.prefillTokens}</Text>
-
-            <Text style={[styles.resultFieldLabel, styles.marginTop]}>
-              decodeTokens:
-            </Text>
-            <Text style={styles.resultFieldValue}>{result.decodeTokens}</Text>
-
-            <Text style={[styles.resultFieldLabel, styles.marginTop]}>
-              totalTokens:
-            </Text>
-            <Text style={styles.resultFieldValue}>{result.totalTokens}</Text>
-          </View>
-        </View>
-      )}
-
-      {error && (
-        <View style={styles.errorContainer}>
-          <Text style={styles.errorText}>{error}</Text>
-        </View>
-      )}
-    </ScrollView>
-  );
-};
-
-export default PerformanceScreen;
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    backgroundColor: '#fff',
-  },
-  content: {
-    padding: 20,
-  },
-  centerContainer: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-    padding: 20,
-  },
-  progressText: {
-    marginTop: 16,
-    fontSize: 16,
-    color: '#000',
-  },
-  input: {
-    borderWidth: 1,
-    borderColor: '#ddd',
-    borderRadius: 8,
-    padding: 12,
-    fontSize: 16,
-    textAlignVertical: 'top',
-    marginBottom: 16,
-    color: '#000',
-  },
-  buttonContainer: {
-    flexDirection: 'row',
-    flexWrap: 'wrap',
-    gap: 8,
-    marginBottom: 16,
-  },
-  button: {
-    backgroundColor: '#000',
-    paddingVertical: 12,
-    paddingHorizontal: 16,
-    borderRadius: 8,
-    alignItems: 'center',
-  },
-  buttonText: {
-    color: '#fff',
-    fontSize: 16,
-    fontWeight: '600',
-  },
-  resultContainer: {
-    marginTop: 16,
-  },
-  resultLabel: {
-    fontSize: 16,
-    fontWeight: '600',
-    marginBottom: 8,
-    color: '#000',
-  },
-  resultBox: {
-    backgroundColor: '#f3f3f3',
-    padding: 12,
-    borderRadius: 8,
-  },
-  resultFieldLabel: {
-    fontSize: 12,
-    fontWeight: '600',
-    color: '#666',
-    marginBottom: 4,
-  },
-  resultFieldValue: {
-    fontSize: 14,
-    color: '#000',
-    lineHeight: 20,
-  },
-  marginTop: {
-    marginTop: 12,
-  },
-  errorContainer: {
-    backgroundColor: '#000',
-    padding: 12,
-    borderRadius: 8,
-    marginTop: 16,
-  },
-  errorText: {
-    color: '#fff',
-    fontSize: 14,
-  },
-});
diff --git a/example/src/STTScreen.tsx b/example/src/STTScreen.tsx
index 898c2e5..9a1bb4a 100644
--- a/example/src/STTScreen.tsx
+++ b/example/src/STTScreen.tsx
@@ -56,7 +56,7 @@ const STTScreen = () => {
       return;
     }
     const transcribeResult = await cactusSTT.transcribe({
-      audioFilePath: audioFile,
+      audio: audioFile,
     });
     setResult(transcribeResult);
   };
diff --git a/example/src/ToolCallingScreen.tsx b/example/src/ToolCallingScreen.tsx
index d74707b..60d5282 100644
--- a/example/src/ToolCallingScreen.tsx
+++ b/example/src/ToolCallingScreen.tsx
@@ -53,7 +53,11 @@ const ToolCallingScreen = () => {
       { role: 'user', content: input },
     ];
 
-    const completionResult = await cactusLM.complete({ messages, tools });
+    const completionResult = await cactusLM.complete({
+      messages,
+      tools,
+      options: { forceTools: true },
+    });
     setResult(completionResult);
   };
 
diff --git a/ios/HybridCactusFileSystem.swift b/ios/HybridCactusFileSystem.swift
index 0685700..dd342cc 100644
--- a/ios/HybridCactusFileSystem.swift
+++ b/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
   }
 }
 
diff --git a/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/cactus.h b/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/cactus.h
index a43d6ef..7278013 100644
--- a/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/cactus.h
+++ b/ios/cactus.xcframework/ios-arm64-simulator/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
\ No newline at end of file
diff --git a/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/cactus_ffi.h b/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/cactus_ffi.h
index 6bb3f27..e00b391 100644
--- a/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/cactus_ffi.h
+++ b/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/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,7 +62,9 @@ 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
 );
 
 
@@ -50,7 +73,8 @@ CACTUS_FFI_EXPORT int cactus_embed(
     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 +99,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
diff --git a/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/cactus_telemetry.h b/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/cactus_telemetry.h
new file mode 100644
index 0000000..a48b6fc
--- /dev/null
+++ b/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/cactus_telemetry.h
@@ -0,0 +1,656 @@
+#ifndef CACTUS_TELEMETRY_H
+#define CACTUS_TELEMETRY_H
+
+#include <string>
+#include <thread>
+#include <sstream>
+#include <iostream>
+#include <chrono>
+#include <mutex>
+#include <map>
+#include <iomanip>
+#include <ctime>
+#include <fstream>
+#include <sys/stat.h>
+#include "cactus_utils.h"
+
+#if defined(__APPLE__)
+#include <TargetConditionals.h>
+#endif
+
+#if defined(__APPLE__) && (!TARGET_OS_IPHONE) && !defined(__ANDROID__)
+#define CACTUS_TELEMETRY_ENABLED
+#include <curl/curl.h>
+#include <sys/utsname.h>
+#include <unistd.h>
+#endif
+
+namespace cactus {
+namespace ffi {
+
+enum class TelemetryEventType {
+    Init,
+    Completion,
+    Embedding,
+    Transcription
+};
+
+struct TelemetryMetrics {
+    TelemetryEventType event_type;
+    std::string model;
+
+    double ttft_ms = 0.0;
+    double tps = 0.0;
+    double response_time_ms = 0.0;
+    int tokens = 0;
+
+    bool success = false;
+    std::string message;
+
+    std::chrono::system_clock::time_point timestamp;
+};
+
+
+class HttpClient {
+public:
+    struct Response {
+        bool success;
+        int status_code;
+        std::string body;
+    };
+
+    static Response postJson(
+        const std::string& url,
+        const std::map<std::string, std::string>& headers,
+        const std::string& json_body
+    );
+
+private:
+    static size_t writeCallback(void* contents, size_t size, size_t nmemb, void* userp);
+};
+
+inline size_t HttpClient::writeCallback(void* contents, size_t size, size_t nmemb, void* userp) {
+    size_t totalSize = size * nmemb;
+    std::string* response = static_cast<std::string*>(userp);
+    response->append(static_cast<char*>(contents), totalSize);
+    return totalSize;
+}
+
+inline HttpClient::Response HttpClient::postJson(
+    [[maybe_unused]] const std::string& url,
+    [[maybe_unused]] const std::map<std::string, std::string>& headers,
+    [[maybe_unused]] const std::string& json_body
+) {
+#ifdef CACTUS_TELEMETRY_ENABLED
+    Response response;
+    response.success = false;
+    response.status_code = 0;
+
+    CURL* curl = curl_easy_init();
+    if (!curl) {
+        return response;
+    }
+
+    curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
+
+    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L);
+    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 2L);
+
+    curl_easy_setopt(curl, CURLOPT_POST, 1L);
+
+    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json_body.c_str());
+    curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, json_body.length());
+
+    struct curl_slist* header_list = nullptr;
+    for (const auto& header : headers) {
+        std::string header_str = header.first + ": " + header.second;
+        header_list = curl_slist_append(header_list, header_str.c_str());
+    }
+    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, header_list);
+
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeCallback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response.body);
+
+    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 5L);
+
+    CURLcode res = curl_easy_perform(curl);
+
+    if (res == CURLE_OK) {
+        long response_code = 0;
+        curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+        response.status_code = static_cast<int>(response_code);
+        response.success = (response_code >= 200 && response_code < 300);
+
+        if (!response.success && !response.body.empty()) {
+            std::cerr << "[Telemetry] Response body: " << response.body << std::endl;
+        }
+    } else {
+        std::cerr << "[Telemetry] HTTP POST failed: " << curl_easy_strerror(res) << std::endl;
+    }
+
+    if (header_list) {
+        curl_slist_free_all(header_list);
+    }
+    curl_easy_cleanup(curl);
+
+    return response;
+#else
+    (void)url;
+    (void)headers;
+    (void)json_body;
+    Response response;
+    response.success = false;
+    response.status_code = 0;
+    return response;
+#endif
+}
+
+class DeviceManager {
+public:
+    static std::string getDeviceId();
+    static std::string getProjectId();
+    static std::map<std::string, std::string> getDeviceMetadata();
+    static std::string registerDevice(const std::string& device_id = "", const std::string& pro_key = "");
+    
+    static void setProKey(const std::string& key);
+    static std::string getProKey();
+
+private:
+    static std::string getConfigPath();
+    static std::map<std::string, std::string> readConfig();
+    static void writeConfig(const std::map<std::string, std::string>& config);
+    
+    static std::string pro_key_;
+};
+
+inline std::string DeviceManager::pro_key_ = "";
+
+inline void DeviceManager::setProKey(const std::string& key) {
+    pro_key_ = key;
+}
+
+inline std::string DeviceManager::getProKey() {
+    return pro_key_;
+}
+
+inline std::string DeviceManager::getConfigPath() {
+    const char* home = getenv("HOME");
+    if (!home) {
+        home = "/tmp";
+    }
+
+    std::string cactus_dir = std::string(home) + "/.cactus";
+
+    mkdir(cactus_dir.c_str(), 0755);
+
+    return cactus_dir + "/telemetry_config.json";
+}
+
+inline std::map<std::string, std::string> DeviceManager::readConfig() {
+    std::map<std::string, std::string> config;
+    std::string path = getConfigPath();
+    std::ifstream file(path);
+
+    if (file.is_open()) {
+        std::stringstream buffer;
+        buffer << file.rdbuf();
+        file.close();
+
+        std::string content = buffer.str();
+
+        const std::string project_id_key = "\"project_id\":\"";
+        size_t project_pos = content.find(project_id_key);
+        if (project_pos != std::string::npos) {
+            size_t start = project_pos + project_id_key.length();
+            size_t end = content.find("\"", start);
+            if (end != std::string::npos) {
+                config["project_id"] = content.substr(start, end - start);
+            }
+        }
+    }
+
+    return config;
+}
+
+inline void DeviceManager::writeConfig(const std::map<std::string, std::string>& config) {
+    std::string path = getConfigPath();
+    std::ofstream file(path);
+
+    if (file.is_open()) {
+        file << "{\n";
+
+        auto device_it = config.find("device_id");
+        if (device_it != config.end()) {
+            file << "  \"device_id\":\"" << device_it->second << "\"";
+        }
+
+        auto project_it = config.find("project_id");
+        if (project_it != config.end()) {
+            if (device_it != config.end()) {
+                file << ",\n";
+            }
+            file << "  \"project_id\":\"" << project_it->second << "\"";
+        }
+
+        file << "\n}\n";
+        file.close();
+    }
+}
+
+inline std::string DeviceManager::getDeviceId() {
+    auto config = readConfig();
+    std::string pro_key = getProKey();
+
+    std::string project_id = config["project_id"];
+    if (project_id.empty()) {
+        project_id = generateUUID();
+    }
+
+    config["project_id"] = project_id;
+    writeConfig(config);
+
+    const char* device_id_cstr = get_device_id(pro_key.c_str());
+    if (device_id_cstr != nullptr) {
+        std::string device_id = std::string(device_id_cstr);
+        size_t pipe_pos = device_id.find('|');
+        if (pipe_pos != std::string::npos) {
+            std::string device_part = device_id.substr(0, pipe_pos);
+            std::string pro_key_part = device_id.substr(pipe_pos + 1);
+            setProKey(pro_key_part);
+            return registerDevice(device_part, pro_key_part);
+        }
+        return device_id;
+    }
+    return registerDevice("", pro_key);
+}
+
+inline std::string DeviceManager::getProjectId() {
+    auto config = readConfig();
+    std::string project_id = config["project_id"];
+
+    if (!project_id.empty()) {
+        return project_id;
+    }
+
+    project_id = generateUUID();
+    std::cerr << "[Device Manager] Generated new project ID: " << project_id << std::endl;
+
+    config["project_id"] = project_id;
+    writeConfig(config);
+
+    return project_id;
+}
+
+inline std::string DeviceManager::registerDevice(const std::string& device_id, const std::string& pro_key) {
+#ifdef CACTUS_TELEMETRY_ENABLED
+    static const std::string SUPABASE_URL = "https://vlqqczxwyaodtcdmdmlw.supabase.co";
+    static const std::string SUPABASE_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InZscXFjenh3eWFvZHRjZG1kbWx3Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTE1MTg2MzIsImV4cCI6MjA2NzA5NDYzMn0.nBzqGuK9j6RZ6mOPWU2boAC_5H9XDs-fPpo5P3WZYbI";
+
+    auto metadata = getDeviceMetadata();
+
+    std::ostringstream json;
+    json << "{";
+
+    if (!device_id.empty()) {
+        json << "\"device_id\":\"" << generateUUID() << "\"";
+    } else {
+        json << "\"device_data\":{"
+            << "\"model\":\"" << metadata["model"] << "\",";
+        json << "\"os\":\"" << metadata["os"] << "\",";
+        json << "\"os_version\":\"" << metadata["os_version"] << "\",";
+        json << "\"brand\":\"" << metadata["brand"] << "\"";
+        json << "}";
+    }
+
+    json << ",\"cactus_pro_key\":\"" << pro_key << "\"";
+    json << "}";
+
+    std::string payload = json.str();
+
+    std::map<std::string, std::string> headers;
+    headers["Content-Type"] = "application/json";
+
+    std::string url = SUPABASE_URL + "/functions/v1/device-registration";
+
+    auto response = HttpClient::postJson(url, headers, payload);
+
+    if (response.success && !response.body.empty()) {
+        const char* registered_id_cstr = register_app(response.body.c_str());
+        std::string registered_id = (registered_id_cstr && registered_id_cstr[0] != '\0')
+            ? std::string(registered_id_cstr)
+            : std::string();
+
+        if (!registered_id.empty()) {
+            std::cerr << "[Device Registration] SUCCESS - Device registered!" << std::endl;
+            return registered_id;
+        }
+
+        std::cerr << "[Device Registration] FAILED - Could not parse ID from response" << std::endl;
+        return "";
+    } else {
+        std::cerr << "[Device Registration] FAILED - Direct table insertion unsuccessful" << std::endl;
+        return "";
+    }
+#else
+    return "";
+#endif
+}
+
+inline std::map<std::string, std::string> DeviceManager::getDeviceMetadata() {
+    std::map<std::string, std::string> metadata;
+
+#ifdef CACTUS_TELEMETRY_ENABLED
+    struct utsname system_info;
+    if (uname(&system_info) == 0) {
+        metadata["os"] = "macOS";
+        metadata["os_version"] = system_info.release;
+        metadata["architecture"] = system_info.machine;
+        metadata["model"] = system_info.machine;
+        metadata["brand"] = "apple";
+    }
+#else
+    metadata["os"] = "unknown";
+    metadata["os_version"] = "unknown";
+    metadata["architecture"] = "unknown";
+    metadata["model"] = "unknown";
+    metadata["brand"] = "unknown";
+#endif
+
+    return metadata;
+}
+
+class LogRecord {
+public:
+    static std::string buildJson(
+        const TelemetryMetrics& metrics,
+        const std::string& project_id,
+        const std::string& device_id,
+        const std::string& telemetry_token
+    );
+
+private:
+    static std::string escapeJson(const std::string& input);
+    static std::string formatTimestamp(const std::chrono::system_clock::time_point& timestamp);
+    static std::string eventTypeToString(TelemetryEventType type);
+};
+
+inline std::string LogRecord::escapeJson(const std::string& input) {
+    std::ostringstream output;
+    for (char c : input) {
+        switch (c) {
+            case '"': output << "\\\""; break;
+            case '\\': output << "\\\\"; break;
+            case '\b': output << "\\b"; break;
+            case '\f': output << "\\f"; break;
+            case '\n': output << "\\n"; break;
+            case '\r': output << "\\r"; break;
+            case '\t': output << "\\t"; break;
+            default:
+                if (static_cast<unsigned char>(c) < 0x20) {
+                    output << "\\u" << std::hex << std::setw(4) << std::setfill('0')
+                          << static_cast<int>(c);
+                } else {
+                    output << c;
+                }
+        }
+    }
+    return output.str();
+}
+
+inline std::string LogRecord::formatTimestamp(const std::chrono::system_clock::time_point& timestamp) {
+    auto time_t = std::chrono::system_clock::to_time_t(timestamp);
+    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
+        timestamp.time_since_epoch()) % 1000;
+
+    std::tm tm;
+#ifdef _WIN32
+    gmtime_s(&tm, &time_t);
+#else
+    gmtime_r(&time_t, &tm);
+#endif
+
+    std::ostringstream oss;
+    oss << std::put_time(&tm, "%Y-%m-%dT%H:%M:%S")
+        << '.' << std::setfill('0') << std::setw(3) << ms.count() << 'Z';
+    return oss.str();
+}
+
+inline std::string LogRecord::eventTypeToString(TelemetryEventType type) {
+    switch (type) {
+        case TelemetryEventType::Init:
+            return "init";
+        case TelemetryEventType::Completion:
+            return "completion";
+        case TelemetryEventType::Embedding:
+            return "embedding";
+        case TelemetryEventType::Transcription:
+            return "transcription";
+        default:
+            return "unknown";
+    }
+}
+
+inline std::string LogRecord::buildJson(
+    const TelemetryMetrics& metrics,
+    const std::string& project_id,
+    const std::string& device_id,
+    const std::string& telemetry_token
+) {
+    std::ostringstream json;
+    json << std::fixed << std::setprecision(2);
+
+    json << "{";
+    json << "\"event_type\":\"" << eventTypeToString(metrics.event_type) << "\",";
+    json << "\"model\":\"" << escapeJson(metrics.model) << "\",";
+    json << "\"success\":" << (metrics.success ? "true" : "false") << ",";
+    json << "\"project_id\":\"" << project_id << "\",";
+    json << "\"device_id\":\"" << device_id << "\",";
+    json << "\"telemetry_token\":\"" << telemetry_token << "\",";
+    json << "\"framework\":\"cpp\",";
+    json << "\"framework_version\":\"" << getVersion() << "\"";
+
+    json << ",\"ttft\":" << metrics.ttft_ms;
+    json << ",\"tps\":" << metrics.tps;
+    json << ",\"response_time\":" << metrics.response_time_ms;
+    json << ",\"tokens\":" << metrics.tokens;
+
+    if (!metrics.message.empty()) {
+        json << ",\"message\":\"" << escapeJson(metrics.message) << "\"";
+    }
+
+    json << "}";
+    return json.str();
+}
+
+class CactusTelemetry {
+public:
+    static CactusTelemetry& getInstance();
+
+    void setEnabled(bool enabled);
+    void setTelemetryToken(const std::string& token);
+    void setProjectId(const std::string& project_id);
+    void ensureInitialized();
+
+    void recordEvent(const TelemetryMetrics& metrics);
+
+    void recordInit(const std::string& model, bool success, const std::string& message = "");
+
+    void recordCompletion(const std::string& model, bool success,
+                         double ttft_ms, double tps, double response_time_ms,
+                         int tokens, const std::string& message = "");
+
+    void recordEmbedding(const std::string& model, bool success,
+                        const std::string& message = "");
+
+    void recordTranscription(const std::string& model, bool success,
+                           double ttft_ms, double tps, double response_time_ms,
+                           int tokens, const std::string& message = "");
+
+    bool isEnabled() const;
+
+private:
+    CactusTelemetry();
+    ~CactusTelemetry() = default;
+
+    CactusTelemetry(const CactusTelemetry&) = delete;
+    CactusTelemetry& operator=(const CactusTelemetry&) = delete;
+
+    void sendToSupabase(const TelemetryMetrics& metrics);
+
+    bool enabled_ = false;
+    bool initialized_ = false;
+    std::string telemetry_token_;
+    std::string project_id_;
+    std::string device_id_;
+
+    mutable std::mutex mutex_;
+};
+
+static const std::string SUPABASE_URL = "https://vlqqczxwyaodtcdmdmlw.supabase.co";
+static const std::string SUPABASE_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InZscXFjenh3eWFvZHRjZG1kbWx3Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTE1MTg2MzIsImV4cCI6MjA2NzA5NDYzMn0.nBzqGuK9j6RZ6mOPWU2boAC_5H9XDs-fPpo5P3WZYbI";
+
+inline CactusTelemetry& CactusTelemetry::getInstance() {
+    static CactusTelemetry instance;
+    return instance;
+}
+
+inline CactusTelemetry::CactusTelemetry() {
+    // Device ID and project ID are now initialized lazily
+}
+
+inline void CactusTelemetry::setEnabled(bool enabled) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    enabled_ = enabled;
+}
+
+inline void CactusTelemetry::setTelemetryToken(const std::string& token) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    telemetry_token_ = token;
+}
+
+inline void CactusTelemetry::setProjectId(const std::string& project_id) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    project_id_ = project_id;
+}
+
+inline void CactusTelemetry::ensureInitialized() {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if (!initialized_) {
+        std::string pro_key = DeviceManager::getProKey();
+        if (!pro_key.empty()) {
+            get_device_id(pro_key.c_str());
+        }
+#ifdef CACTUS_TELEMETRY_ENABLED
+        device_id_ = DeviceManager::getDeviceId();
+        project_id_ = DeviceManager::getProjectId();
+#endif
+        initialized_ = true;
+    }
+}
+
+inline bool CactusTelemetry::isEnabled() const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return enabled_ && !telemetry_token_.empty();
+}
+
+inline void CactusTelemetry::sendToSupabase([[maybe_unused]] const TelemetryMetrics& metrics) {
+#ifdef CACTUS_TELEMETRY_ENABLED
+    std::string telemetry_token;
+    std::string project_id;
+    std::string device_id;
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        telemetry_token = telemetry_token_;
+        project_id = project_id_;
+        device_id = device_id_;
+    }
+
+    std::string log_json = LogRecord::buildJson(metrics, project_id, device_id, telemetry_token);
+
+    std::string payload = "[" + log_json + "]";
+
+    std::map<std::string, std::string> headers;
+    headers["apikey"] = SUPABASE_KEY;
+    headers["Authorization"] = "Bearer " + SUPABASE_KEY;
+    headers["Content-Type"] = "application/json";
+    headers["Prefer"] = "return=minimal";
+    headers["Content-Profile"] = "cactus";
+
+    std::string url = SUPABASE_URL + "/rest/v1/logs";
+    HttpClient::postJson(url, headers, payload);
+#else
+    (void)metrics;
+#endif
+}
+
+inline void CactusTelemetry::recordEvent(const TelemetryMetrics& metrics) {
+    if (!isEnabled()) {
+        return;
+    }
+    std::thread([this, metrics]() {
+        sendToSupabase(metrics);
+    }).detach();
+}
+
+inline void CactusTelemetry::recordInit(const std::string& model, bool success,
+                                   const std::string& message) {
+    TelemetryMetrics metrics;
+    metrics.event_type = TelemetryEventType::Init;
+    metrics.model = model;
+    metrics.success = success;
+    metrics.message = message;
+    metrics.timestamp = std::chrono::system_clock::now();
+
+    recordEvent(metrics);
+}
+
+inline void CactusTelemetry::recordCompletion(const std::string& model, bool success,
+                                         double ttft_ms, double tps, double response_time_ms,
+                                         int tokens, const std::string& message) {
+    TelemetryMetrics metrics;
+    metrics.event_type = TelemetryEventType::Completion;
+    metrics.model = model;
+    metrics.success = success;
+    metrics.ttft_ms = ttft_ms;
+    metrics.tps = tps;
+    metrics.response_time_ms = response_time_ms;
+    metrics.tokens = tokens;
+    metrics.message = message;
+    metrics.timestamp = std::chrono::system_clock::now();
+
+    recordEvent(metrics);
+}
+
+inline void CactusTelemetry::recordEmbedding(const std::string& model, bool success,
+                                        const std::string& message) {
+    TelemetryMetrics metrics;
+    metrics.event_type = TelemetryEventType::Embedding;
+    metrics.model = model;
+    metrics.success = success;
+    metrics.message = message;
+    metrics.timestamp = std::chrono::system_clock::now();
+
+    recordEvent(metrics);
+}
+
+inline void CactusTelemetry::recordTranscription(const std::string& model, bool success,
+                            double ttft_ms, double tps, double response_time_ms,
+                            int tokens, const std::string& message) {
+    TelemetryMetrics metrics;
+    metrics.event_type = TelemetryEventType::Transcription;
+    metrics.model = model;
+    metrics.success = success;
+    metrics.response_time_ms = response_time_ms;
+    metrics.ttft_ms = ttft_ms;
+    metrics.tps = tps;
+    metrics.tokens = tokens;
+    metrics.message = message;
+    metrics.timestamp = std::chrono::system_clock::now();
+
+    recordEvent(metrics);
+}
+
+} // namespace ffi
+} // namespace cactus
+
+#endif // CACTUS_TELEMETRY_H
diff --git a/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/ffi_utils.h b/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/cactus_utils.h
similarity index 87%
rename from ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/ffi_utils.h
rename to ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/cactus_utils.h
index 1bbccc4..06dfebe 100644
--- a/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/ffi_utils.h
+++ b/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/cactus_utils.h
@@ -1,5 +1,5 @@
-#ifndef CACTUS_FFI_UTILS_H
-#define CACTUS_FFI_UTILS_H
+#ifndef CACTUS_UTILS_H
+#define CACTUS_UTILS_H
 
 #include "../engine/engine.h"
 #include <string>
@@ -12,10 +12,51 @@
 #include <iostream>
 #include <filesystem>
 #include <cctype>
+#include <memory>
+#include <atomic>
+#include <mutex>
+#include <random>
+
+#ifdef __APPLE__
+#include <uuid/uuid.h>
+#endif
+
+struct CactusModelHandle {
+    std::unique_ptr<cactus::engine::Model> model;
+    std::atomic<bool> should_stop;
+    std::vector<uint32_t> processed_tokens;
+    std::mutex model_mutex;
+    std::string model_name;
+
+    CactusModelHandle() : should_stop(false) {}
+};
+
+extern std::string last_error_message;
+
+bool matches_stop_sequence(const std::vector<uint32_t>& generated_tokens,
+                           const std::vector<std::vector<uint32_t>>& stop_sequences);
 
 namespace cactus {
 namespace ffi {
 
+#ifndef CACTUS_VERSION
+#define CACTUS_VERSION "unknown"
+#endif
+
+inline const char* getVersion() {
+    return CACTUS_VERSION;
+}
+
+inline std::string generateUUID() {
+#ifdef __APPLE__
+    uuid_t uuid;
+    uuid_generate_random(uuid);
+    char uuid_str[37];
+    uuid_unparse_lower(uuid, uuid_str);
+    return std::string(uuid_str);
+#endif
+}
+
 struct ToolFunction {
     std::string name;
     std::string description;
@@ -175,49 +216,58 @@ inline std::vector<ToolFunction> parse_tools_json(const std::string& json) {
     return tools;
 }
 
-inline void parse_options_json(const std::string& json, 
-                               float& temperature, float& top_p, 
+inline void parse_options_json(const std::string& json,
+                               float& temperature, float& top_p,
                                size_t& top_k, size_t& max_tokens,
-                               std::vector<std::string>& stop_sequences) {
+                               std::vector<std::string>& stop_sequences,
+                               bool& force_tools) {
     temperature = 0.0f;
-    top_p = 0.0f;       
-    top_k = 0;           
-    max_tokens = 100;    
+    top_p = 0.0f;
+    top_k = 0;
+    max_tokens = 100;
+    force_tools = false;
     stop_sequences.clear();
-    
+
     if (json.empty()) return;
-    
+
     size_t pos = json.find("\"temperature\"");
     if (pos != std::string::npos) {
         pos = json.find(':', pos) + 1;
         temperature = std::stof(json.substr(pos));
     }
-    
+
     pos = json.find("\"top_p\"");
     if (pos != std::string::npos) {
         pos = json.find(':', pos) + 1;
         top_p = std::stof(json.substr(pos));
     }
-    
+
     pos = json.find("\"top_k\"");
     if (pos != std::string::npos) {
         pos = json.find(':', pos) + 1;
         top_k = std::stoul(json.substr(pos));
     }
-    
+
     pos = json.find("\"max_tokens\"");
     if (pos != std::string::npos) {
         pos = json.find(':', pos) + 1;
         max_tokens = std::stoul(json.substr(pos));
     }
-    
+
+    pos = json.find("\"force_tools\"");
+    if (pos != std::string::npos) {
+        pos = json.find(':', pos) + 1;
+        while (pos < json.length() && std::isspace(json[pos])) pos++;
+        force_tools = (json.substr(pos, 4) == "true");
+    }
+
     pos = json.find("\"stop_sequences\"");
     if (pos != std::string::npos) {
         pos = json.find('[', pos);
         if (pos != std::string::npos) {
             size_t end_pos = json.find(']', pos);
             size_t seq_pos = json.find('"', pos);
-            
+
             while (seq_pos != std::string::npos && seq_pos < end_pos) {
                 size_t seq_start = seq_pos + 1;
                 size_t seq_end = json.find('"', seq_start);
@@ -234,7 +284,7 @@ inline std::string format_tools_for_prompt(const std::vector<ToolFunction>& tool
     if (tools.empty()) return "";
     std::string formatted_tools_json;
     for (size_t i = 0; i < tools.size(); i++) {
-        if (i > 0) formatted_tools_json += ",\n";
+        if (i > 0) formatted_tools_json += "\n";
         formatted_tools_json += "{\"type\":\"function\",\"function\":{\"name\":\""
                               + tools[i].name
                               + "\",\"description\":\""
@@ -398,4 +448,41 @@ inline std::string construct_response_json(const std::string& regular_response,
 } // namespace ffi
 } // namespace cactus
 
-#endif // CACTUS_FFI_UTILS_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+const char* cactus_get_last_error();
+
+__attribute__((weak))
+const char* register_app(const char* encrypted_data);
+
+__attribute__((weak))
+const char* get_device_id(const char* current_token);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+
+__attribute__((weak))
+inline const char* register_app(const char* encrypted_data) {
+    (void)encrypted_data;
+    static thread_local std::string uuid_storage;
+    uuid_storage = cactus::ffi::generateUUID();
+    return uuid_storage.c_str();
+}
+
+__attribute__((weak))
+inline const char* get_device_id(const char* current_token) {
+    (void)current_token;
+    static thread_local std::string uuid_storage;
+    uuid_storage = cactus::ffi::generateUUID();
+    return uuid_storage.c_str();
+}
+}
+#endif
+
+#endif // CACTUS_UTILS_H
diff --git a/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/engine.h b/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/engine.h
index 77594ed..601e818 100644
--- a/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/engine.h
+++ b/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/engine.h
@@ -3,6 +3,7 @@
 #include <vector>
 #include <string>
 #include <unordered_map>
+#include <unordered_set>
 #include <memory>
 #include <cstdint>
 
@@ -32,6 +33,9 @@ extern "C" {
 class CactusGraph;
 
 namespace cactus {
+namespace npu {
+    class NPUPrefill;
+}
 namespace engine {
 
 class Siglip2Preprocessor;
@@ -349,6 +353,13 @@ struct KVCache {
     void update_from_graph(CactusGraph* gb, const std::vector<size_t>& k_nodes,
                           const std::vector<size_t>& v_nodes, size_t seq_len,
                           size_t num_layers, size_t kv_heads, size_t head_dim);
+
+    // Update KV cache from NPU prefill outputs
+    // NPU outputs are in shape [num_tokens, num_kv_heads, head_dim]
+    // This handles transposition to cache format and sliding window
+    void update_from_npu(size_t layer_idx, const __fp16* k_data, const __fp16* v_data,
+                         size_t num_tokens, size_t kv_heads, size_t head_dim);
+
     bool is_empty() const { return current_seq_len == 0; }
     void* get_key_ptr(size_t layer);
     void* get_value_ptr(size_t layer);
@@ -365,6 +376,85 @@ struct KVCache {
     CircularView get_value_view(size_t layer);
 };
 
+class ToolCallConstrainer {
+public:
+    enum class State {
+        START,                  // -> expect {
+        EXPECT_FC_KEY,          // -> expect "function_call"
+        EXPECT_FC_COLON,        // -> expect :
+        EXPECT_FC_OPEN_BRACE,   // -> expect {
+        EXPECT_NAME_KEY,        // -> expect "name"
+        EXPECT_NAME_COLON,      // -> expect :
+        EXPECT_NAME_VALUE,      // -> expect "<function_name>"
+        EXPECT_COMMA,           // -> expect ,
+        EXPECT_ARGS_KEY,        // -> expect "arguments"
+        EXPECT_ARGS_COLON,      // -> expect :
+        IN_ARGUMENTS,           // -> free JSON, track brace depth
+        EXPECT_INNER_CLOSE,     // -> expect } to close inner object
+        EXPECT_OUTER_CLOSE,     // -> expect } to close outer object
+        DONE,                   // complete
+
+        LFM_START,              // -> expect <|tool_call_start|>
+        LFM_EXPECT_BRACKET,     // -> expect [
+        LFM_IN_FUNC_NAME,       // -> expect function name
+        LFM_EXPECT_PAREN,       // -> expect (
+        LFM_IN_ARGUMENTS,       // -> arguments until )
+        LFM_EXPECT_BRACKET_CLOSE, // -> expect ]
+        LFM_EXPECT_END          // -> expect <|tool_call_end|>
+    };
+
+    void init(Config::ModelType model_type,
+              const std::vector<std::string>& function_names,
+              Tokenizer* tokenizer);
+
+    const std::unordered_map<uint32_t, float>& get_bias() const { return current_bias_; }
+
+    void update(uint32_t token_id, const std::string& decoded_text);
+
+    void reset();
+
+    bool is_active() const { return active_; }
+
+private:
+    bool active_ = false;
+    State state_ = State::START;
+    Config::ModelType model_type_ = Config::ModelType::QWEN;
+    Tokenizer* tokenizer_ = nullptr;
+
+    std::vector<std::string> function_names_;
+    std::string generated_text_;
+    int brace_depth_ = 0;  // Track nested braces in arguments
+
+    // Pre-tokenized token sets for each grammar element
+    std::unordered_set<uint32_t> open_brace_tokens_;      // {
+    std::unordered_set<uint32_t> close_brace_tokens_;     // }
+    std::unordered_set<uint32_t> colon_tokens_;           // :
+    std::unordered_set<uint32_t> comma_tokens_;           // ,
+    std::unordered_set<uint32_t> fc_key_tokens_;          // "function_call"
+    std::unordered_set<uint32_t> name_key_tokens_;        // "name"
+    std::unordered_set<uint32_t> args_key_tokens_;        // "arguments"
+    std::unordered_set<uint32_t> quote_tokens_;           // "
+    std::unordered_set<uint32_t> backtick_tokens_;        // ` (to block markdown code fences)
+    std::unordered_set<uint32_t> response_starter_tokens_; // Common response starters to block (I, I'm, Sorry, etc.)
+    std::unordered_set<uint32_t> all_func_name_tokens_;   // All function name tokens combined
+    std::unordered_map<std::string, std::vector<uint32_t>> func_name_sequences_;  // Full token sequence per function
+
+    // LFM2-specific tokens
+    std::unordered_set<uint32_t> tool_start_tokens_;
+    std::unordered_set<uint32_t> tool_end_tokens_;
+    std::unordered_set<uint32_t> bracket_open_tokens_;    // [
+    std::unordered_set<uint32_t> bracket_close_tokens_;   // ]
+    std::unordered_set<uint32_t> paren_open_tokens_;      // (
+    std::unordered_set<uint32_t> paren_close_tokens_;     // )
+    std::unordered_set<uint32_t> equals_tokens_;          // =
+
+    std::unordered_map<uint32_t, float> current_bias_;
+
+    void compute_bias();
+    void tokenize_grammar_elements();
+    void add_tokens_for_string(const std::string& str, std::unordered_set<uint32_t>& token_set);
+};
+
 class Model {
 public:
     struct DebugNode {
@@ -386,26 +476,40 @@ class Model {
     virtual bool init(CactusGraph* external_graph, const std::string& model_folder, size_t context_size,
               const std::string& system_prompt = "", bool do_warmup = true);
 
-    virtual uint32_t generate(const std::vector<uint32_t>& tokens, float temperature = -1.0f, float top_p = -1.0f,
-                      size_t top_k = 0, const std::string& profile_file = "", bool prefill_only = false);
+    virtual uint32_t decode(const std::vector<uint32_t>& tokens, float temperature = -1.0f, float top_p = -1.0f,
+                      size_t top_k = 0, const std::string& profile_file = "");
+
+    virtual void prefill(const std::vector<uint32_t>& tokens, size_t chunk_size = 256, const std::string& profile_file = "");
 
-    virtual uint32_t generate_with_images(const std::vector<uint32_t>& tokens, const std::vector<std::string>& image_paths,
+    virtual uint32_t decode_with_images(const std::vector<uint32_t>& tokens, const std::vector<std::string>& image_paths,
                                           float temperature = -1.0f, float top_p = -1.0f,
                                           size_t top_k = 0, const std::string& profile_file = "");
-    
-    virtual uint32_t generate_with_audio(const std::vector<uint32_t>& tokens, const std::vector<float>& mel_bins, float temperature = 0.0f, float top_p = 0.0f,
+
+    virtual uint32_t decode_with_audio(const std::vector<uint32_t>& tokens, const std::vector<float>& mel_bins, float temperature = 0.0f, float top_p = 0.0f,
                       size_t top_k = 0, const std::string& profile_file = "");
 
-    std::vector<float> get_embeddings(const std::vector<uint32_t>& tokens, bool pooled = true, const std::string& profile_file = "");
+    std::vector<float> get_embeddings(const std::vector<uint32_t>& tokens, bool pooled = true, bool normalize = false, const std::string& profile_file = "");
     
     virtual std::vector<float> get_image_embeddings(const std::string& image_path);
     
     virtual std::vector<float> get_audio_embeddings(const std::vector<float>& mel_bins);
 
     virtual void reset_cache() { kv_cache_.reset(); }
-    
+
+    double score_tokens_window_logprob(const std::vector<uint32_t>& tokens, size_t start, size_t end, size_t context, size_t* tokens_scored);
+
+
+
     void set_cache_window(size_t window_size, size_t sink_size = 4) { kv_cache_.set_window_size(window_size, sink_size); }
 
+    bool load_npu_prefill(const std::string& model_path);
+    bool has_npu_prefill() const;
+    size_t get_prefill_chunk_size() const;
+
+    void set_tool_constraints(const std::vector<std::string>& function_names);
+    void clear_tool_constraints();
+    void update_tool_constraints(uint32_t token_id);
+
     void* graph_handle_;
 
 protected:
@@ -449,6 +553,12 @@ class Model {
     bool init_internal(CactusGraph* gb, const std::string& model_folder, size_t context_size,
                        const std::string& system_prompt, bool do_warmup);
     bool owns_graph_;
+
+    std::unique_ptr<npu::NPUPrefill> npu_prefill_;
+    void prefill_npu(const std::vector<uint32_t>& tokens);
+    virtual std::vector<__fp16> get_token_embeddings(const std::vector<uint32_t>& tokens);
+
+    ToolCallConstrainer tool_constrainer_;
 };
 
 std::unique_ptr<Model> create_model(const std::string& model_folder);
diff --git a/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/graph.h b/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/graph.h
index bc43d1c..35b2808 100644
--- a/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/graph.h
+++ b/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/graph.h
@@ -8,6 +8,88 @@
 #include <cstring>
 #include <stdexcept>
 #include <string>
+#include <mutex>
+#include <sstream>
+#include <iostream>
+
+namespace cactus {
+
+enum class LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3,
+    NONE = 4
+};
+
+class Logger {
+public:
+    static Logger& instance() {
+        static Logger logger;
+        return logger;
+    }
+
+    void set_level(LogLevel level) { min_level_ = level; }
+    LogLevel get_level() const { return min_level_; }
+
+    void set_callback(std::function<void(LogLevel, const std::string&, const std::string&)> cb) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        callback_ = cb;
+    }
+
+    void log(LogLevel level, const std::string& component, const std::string& message) {
+        if (level < min_level_) return;
+
+        std::lock_guard<std::mutex> lock(mutex_);
+
+        if (callback_) {
+            callback_(level, component, message);
+        } else {
+            std::cerr << "[" << level_string(level) << "] [" << component << "] " << message << std::endl;
+        }
+
+        if (level == LogLevel::ERROR) {
+            last_error_ = "[" + component + "] " + message;
+        }
+    }
+
+    const std::string& last_error() const { return last_error_; }
+    void clear_error() { last_error_.clear(); }
+
+private:
+    Logger() : min_level_(LogLevel::WARN) {}
+
+    static const char* level_string(LogLevel level) {
+        switch (level) {
+            case LogLevel::DEBUG: return "DEBUG";
+            case LogLevel::INFO:  return "INFO";
+            case LogLevel::WARN:  return "WARN";
+            case LogLevel::ERROR: return "ERROR";
+            default: return "?";
+        }
+    }
+
+    LogLevel min_level_;
+    std::mutex mutex_;
+    std::string last_error_;
+    std::function<void(LogLevel, const std::string&, const std::string&)> callback_;
+};
+
+} // namespace cactus
+
+#define CACTUS_LOG(level, component, msg) \
+    do { \
+        if (static_cast<int>(level) >= static_cast<int>(cactus::Logger::instance().get_level())) { \
+            std::ostringstream _cactus_log_ss; \
+            _cactus_log_ss << msg; \
+            cactus::Logger::instance().log(level, component, _cactus_log_ss.str()); \
+        } \
+    } while(0)
+
+#define CACTUS_LOG_DEBUG(component, msg) CACTUS_LOG(cactus::LogLevel::DEBUG, component, msg)
+#define CACTUS_LOG_INFO(component, msg)  CACTUS_LOG(cactus::LogLevel::INFO, component, msg)
+#define CACTUS_LOG_WARN(component, msg)  CACTUS_LOG(cactus::LogLevel::WARN, component, msg)
+#define CACTUS_LOG_ERROR(component, msg) CACTUS_LOG(cactus::LogLevel::ERROR, component, msg)
 
 namespace GraphFile {
     class MappedFile;
@@ -144,7 +226,7 @@ struct OpParams {
     size_t slice_start = 0;
     size_t slice_length = 0;
     size_t window_size = 0;
-    bool is_causal = true;  // Default to causal for backward compatibility
+    bool is_causal = true;  
     std::vector<size_t> new_shape;
     std::vector<size_t> permutation;
     Precision output_precision = Precision::INT8;
@@ -158,10 +240,13 @@ struct OpParams {
     size_t top_k = 0;
     size_t random_seed = 0;
     
-    size_t index_value = 0;  // For INDEX operation
-    size_t num_classes = 0;  // For scatter operations
+    size_t index_value = 0;  
+    size_t num_classes = 0; 
     size_t dst_height = 0;
-    size_t dst_width = 0;   
+    size_t dst_width = 0;
+
+    std::vector<float> bias_values;
+    std::vector<uint32_t> bias_indices;
 };
 
 struct GraphNode {
@@ -294,7 +379,8 @@ class CactusGraph {
     size_t conv1d_causal(size_t input, size_t weight, size_t kernel_size, size_t dilation = 1);
     size_t conv1d_k3(size_t input, size_t weight, size_t stride);
     
-    size_t sample(size_t logits, float temperature = 0.6f, float top_p = 0.95f, size_t top_k = 20);
+    size_t sample(size_t logits, float temperature = 0.6f, float top_p = 0.95f, size_t top_k = 20,
+                  const std::unordered_map<uint32_t, float>& logit_bias = {});
     
     size_t concat(size_t input1, size_t input2, int axis = 0);
     size_t scatter_topk(size_t indices, size_t values, size_t num_classes);
diff --git a/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/kernel.h b/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/kernel.h
index 5c1e59d..726cf37 100644
--- a/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/kernel.h
+++ b/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/kernel.h
@@ -102,18 +102,23 @@ void cactus_matmul_f32(const float* a, const float* b_transposed, float* c,
                        size_t M, size_t K, size_t N);
 
 
-void cactus_transpose_2d_int8(const int8_t* source, int8_t* destination, 
+void cactus_transpose_2d_int8(const int8_t* source, int8_t* destination,
                                size_t num_rows, size_t num_cols, size_t start_row, size_t end_row);
-void cactus_transpose_2d_f32(const float* source, float* destination, 
+void cactus_transpose_2d_f16(const __fp16* source, __fp16* destination,
+                             size_t num_rows, size_t num_cols, size_t start_row, size_t end_row);
+void cactus_transpose_2d_f32(const float* source, float* destination,
                              size_t num_rows, size_t num_cols, size_t start_row, size_t end_row);
 
-void cactus_transpose_int8(const int8_t* source, int8_t* destination, const size_t* shape, 
+void cactus_transpose_int8(const int8_t* source, int8_t* destination, const size_t* shape,
                            const size_t* permutation, size_t ndim, size_t start_idx, size_t end_idx);
-void cactus_transpose_f32(const float* source, float* destination, const size_t* shape, 
+void cactus_transpose_f16(const __fp16* source, __fp16* destination, const size_t* shape,
+                          const size_t* permutation, size_t ndim, size_t start_idx, size_t end_idx);
+void cactus_transpose_f32(const float* source, float* destination, const size_t* shape,
                           const size_t* permutation, size_t ndim, size_t start_idx, size_t end_idx);
 
 int64_t cactus_sum_all_int8(const int8_t* data, size_t num_elements);
 void cactus_sum_axis_int8(const int8_t* input, int8_t* output, size_t outer_size, size_t axis_size, size_t inner_size);
+double cactus_sum_all_f16(const __fp16* data, size_t num_elements);
 double cactus_sum_all_f32(const float* data, size_t num_elements);
 void cactus_sum_axis_f32(const float* input, float* output, size_t outer_size, size_t axis_size, size_t inner_size);
 
@@ -278,9 +283,13 @@ void cactus_bilinear_interpolation_fp32(const float* input, float* output, size_
                                         size_t dst_height, size_t dst_width);
 
 void cactus_sample_f32(const float* logits, uint32_t* output, size_t vocab_size,
-                       float temperature, float top_p, size_t top_k, size_t random_seed);
+                       float temperature, float top_p, size_t top_k, size_t random_seed,
+                       const float* bias_values = nullptr, const uint32_t* bias_indices = nullptr,
+                       size_t bias_count = 0);
 void cactus_sample_f16(const __fp16* logits, uint32_t* output, size_t vocab_size,
-                       float temperature, float top_p, size_t top_k, size_t random_seed);
+                       float temperature, float top_p, size_t top_k, size_t random_seed,
+                       const float* bias_values = nullptr, const uint32_t* bias_indices = nullptr,
+                       size_t bias_count = 0);
 
 
 void cactus_concat_f32(const float* input1, const float* input2, float* output,
diff --git a/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Info.plist b/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Info.plist
index cc9ad7f..32b19c0 100644
Binary files a/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Info.plist and b/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Info.plist differ
diff --git a/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/_CodeSignature/CodeResources b/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/_CodeSignature/CodeResources
index ca3bfc4..b48eb36 100644
--- a/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/_CodeSignature/CodeResources
+++ b/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/_CodeSignature/CodeResources
@@ -6,7 +6,7 @@
 	<dict>
 		<key>Info.plist</key>
 		<data>
-		oZrZEx0iJfsyoH1nUXO8hrSVJHs=
+		yMSW0g+AKq/xXqUOrMbK43roF5I=
 		</data>
 	</dict>
 	<key>files2</key>
diff --git a/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/cactus b/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/cactus
index 9ab26fc..330a0ed 100755
Binary files a/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/cactus and b/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/cactus differ
diff --git a/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/cactus.h b/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/cactus.h
index a43d6ef..7278013 100644
--- a/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/cactus.h
+++ b/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
\ No newline at end of file
diff --git a/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/cactus_ffi.h b/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/cactus_ffi.h
index 6bb3f27..e00b391 100644
--- a/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/cactus_ffi.h
+++ b/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/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,7 +62,9 @@ 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
 );
 
 
@@ -50,7 +73,8 @@ CACTUS_FFI_EXPORT int cactus_embed(
     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 +99,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
diff --git a/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/cactus_telemetry.h b/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/cactus_telemetry.h
new file mode 100644
index 0000000..a48b6fc
--- /dev/null
+++ b/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/cactus_telemetry.h
@@ -0,0 +1,656 @@
+#ifndef CACTUS_TELEMETRY_H
+#define CACTUS_TELEMETRY_H
+
+#include <string>
+#include <thread>
+#include <sstream>
+#include <iostream>
+#include <chrono>
+#include <mutex>
+#include <map>
+#include <iomanip>
+#include <ctime>
+#include <fstream>
+#include <sys/stat.h>
+#include "cactus_utils.h"
+
+#if defined(__APPLE__)
+#include <TargetConditionals.h>
+#endif
+
+#if defined(__APPLE__) && (!TARGET_OS_IPHONE) && !defined(__ANDROID__)
+#define CACTUS_TELEMETRY_ENABLED
+#include <curl/curl.h>
+#include <sys/utsname.h>
+#include <unistd.h>
+#endif
+
+namespace cactus {
+namespace ffi {
+
+enum class TelemetryEventType {
+    Init,
+    Completion,
+    Embedding,
+    Transcription
+};
+
+struct TelemetryMetrics {
+    TelemetryEventType event_type;
+    std::string model;
+
+    double ttft_ms = 0.0;
+    double tps = 0.0;
+    double response_time_ms = 0.0;
+    int tokens = 0;
+
+    bool success = false;
+    std::string message;
+
+    std::chrono::system_clock::time_point timestamp;
+};
+
+
+class HttpClient {
+public:
+    struct Response {
+        bool success;
+        int status_code;
+        std::string body;
+    };
+
+    static Response postJson(
+        const std::string& url,
+        const std::map<std::string, std::string>& headers,
+        const std::string& json_body
+    );
+
+private:
+    static size_t writeCallback(void* contents, size_t size, size_t nmemb, void* userp);
+};
+
+inline size_t HttpClient::writeCallback(void* contents, size_t size, size_t nmemb, void* userp) {
+    size_t totalSize = size * nmemb;
+    std::string* response = static_cast<std::string*>(userp);
+    response->append(static_cast<char*>(contents), totalSize);
+    return totalSize;
+}
+
+inline HttpClient::Response HttpClient::postJson(
+    [[maybe_unused]] const std::string& url,
+    [[maybe_unused]] const std::map<std::string, std::string>& headers,
+    [[maybe_unused]] const std::string& json_body
+) {
+#ifdef CACTUS_TELEMETRY_ENABLED
+    Response response;
+    response.success = false;
+    response.status_code = 0;
+
+    CURL* curl = curl_easy_init();
+    if (!curl) {
+        return response;
+    }
+
+    curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
+
+    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L);
+    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 2L);
+
+    curl_easy_setopt(curl, CURLOPT_POST, 1L);
+
+    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json_body.c_str());
+    curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, json_body.length());
+
+    struct curl_slist* header_list = nullptr;
+    for (const auto& header : headers) {
+        std::string header_str = header.first + ": " + header.second;
+        header_list = curl_slist_append(header_list, header_str.c_str());
+    }
+    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, header_list);
+
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeCallback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response.body);
+
+    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 5L);
+
+    CURLcode res = curl_easy_perform(curl);
+
+    if (res == CURLE_OK) {
+        long response_code = 0;
+        curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+        response.status_code = static_cast<int>(response_code);
+        response.success = (response_code >= 200 && response_code < 300);
+
+        if (!response.success && !response.body.empty()) {
+            std::cerr << "[Telemetry] Response body: " << response.body << std::endl;
+        }
+    } else {
+        std::cerr << "[Telemetry] HTTP POST failed: " << curl_easy_strerror(res) << std::endl;
+    }
+
+    if (header_list) {
+        curl_slist_free_all(header_list);
+    }
+    curl_easy_cleanup(curl);
+
+    return response;
+#else
+    (void)url;
+    (void)headers;
+    (void)json_body;
+    Response response;
+    response.success = false;
+    response.status_code = 0;
+    return response;
+#endif
+}
+
+class DeviceManager {
+public:
+    static std::string getDeviceId();
+    static std::string getProjectId();
+    static std::map<std::string, std::string> getDeviceMetadata();
+    static std::string registerDevice(const std::string& device_id = "", const std::string& pro_key = "");
+    
+    static void setProKey(const std::string& key);
+    static std::string getProKey();
+
+private:
+    static std::string getConfigPath();
+    static std::map<std::string, std::string> readConfig();
+    static void writeConfig(const std::map<std::string, std::string>& config);
+    
+    static std::string pro_key_;
+};
+
+inline std::string DeviceManager::pro_key_ = "";
+
+inline void DeviceManager::setProKey(const std::string& key) {
+    pro_key_ = key;
+}
+
+inline std::string DeviceManager::getProKey() {
+    return pro_key_;
+}
+
+inline std::string DeviceManager::getConfigPath() {
+    const char* home = getenv("HOME");
+    if (!home) {
+        home = "/tmp";
+    }
+
+    std::string cactus_dir = std::string(home) + "/.cactus";
+
+    mkdir(cactus_dir.c_str(), 0755);
+
+    return cactus_dir + "/telemetry_config.json";
+}
+
+inline std::map<std::string, std::string> DeviceManager::readConfig() {
+    std::map<std::string, std::string> config;
+    std::string path = getConfigPath();
+    std::ifstream file(path);
+
+    if (file.is_open()) {
+        std::stringstream buffer;
+        buffer << file.rdbuf();
+        file.close();
+
+        std::string content = buffer.str();
+
+        const std::string project_id_key = "\"project_id\":\"";
+        size_t project_pos = content.find(project_id_key);
+        if (project_pos != std::string::npos) {
+            size_t start = project_pos + project_id_key.length();
+            size_t end = content.find("\"", start);
+            if (end != std::string::npos) {
+                config["project_id"] = content.substr(start, end - start);
+            }
+        }
+    }
+
+    return config;
+}
+
+inline void DeviceManager::writeConfig(const std::map<std::string, std::string>& config) {
+    std::string path = getConfigPath();
+    std::ofstream file(path);
+
+    if (file.is_open()) {
+        file << "{\n";
+
+        auto device_it = config.find("device_id");
+        if (device_it != config.end()) {
+            file << "  \"device_id\":\"" << device_it->second << "\"";
+        }
+
+        auto project_it = config.find("project_id");
+        if (project_it != config.end()) {
+            if (device_it != config.end()) {
+                file << ",\n";
+            }
+            file << "  \"project_id\":\"" << project_it->second << "\"";
+        }
+
+        file << "\n}\n";
+        file.close();
+    }
+}
+
+inline std::string DeviceManager::getDeviceId() {
+    auto config = readConfig();
+    std::string pro_key = getProKey();
+
+    std::string project_id = config["project_id"];
+    if (project_id.empty()) {
+        project_id = generateUUID();
+    }
+
+    config["project_id"] = project_id;
+    writeConfig(config);
+
+    const char* device_id_cstr = get_device_id(pro_key.c_str());
+    if (device_id_cstr != nullptr) {
+        std::string device_id = std::string(device_id_cstr);
+        size_t pipe_pos = device_id.find('|');
+        if (pipe_pos != std::string::npos) {
+            std::string device_part = device_id.substr(0, pipe_pos);
+            std::string pro_key_part = device_id.substr(pipe_pos + 1);
+            setProKey(pro_key_part);
+            return registerDevice(device_part, pro_key_part);
+        }
+        return device_id;
+    }
+    return registerDevice("", pro_key);
+}
+
+inline std::string DeviceManager::getProjectId() {
+    auto config = readConfig();
+    std::string project_id = config["project_id"];
+
+    if (!project_id.empty()) {
+        return project_id;
+    }
+
+    project_id = generateUUID();
+    std::cerr << "[Device Manager] Generated new project ID: " << project_id << std::endl;
+
+    config["project_id"] = project_id;
+    writeConfig(config);
+
+    return project_id;
+}
+
+inline std::string DeviceManager::registerDevice(const std::string& device_id, const std::string& pro_key) {
+#ifdef CACTUS_TELEMETRY_ENABLED
+    static const std::string SUPABASE_URL = "https://vlqqczxwyaodtcdmdmlw.supabase.co";
+    static const std::string SUPABASE_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InZscXFjenh3eWFvZHRjZG1kbWx3Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTE1MTg2MzIsImV4cCI6MjA2NzA5NDYzMn0.nBzqGuK9j6RZ6mOPWU2boAC_5H9XDs-fPpo5P3WZYbI";
+
+    auto metadata = getDeviceMetadata();
+
+    std::ostringstream json;
+    json << "{";
+
+    if (!device_id.empty()) {
+        json << "\"device_id\":\"" << generateUUID() << "\"";
+    } else {
+        json << "\"device_data\":{"
+            << "\"model\":\"" << metadata["model"] << "\",";
+        json << "\"os\":\"" << metadata["os"] << "\",";
+        json << "\"os_version\":\"" << metadata["os_version"] << "\",";
+        json << "\"brand\":\"" << metadata["brand"] << "\"";
+        json << "}";
+    }
+
+    json << ",\"cactus_pro_key\":\"" << pro_key << "\"";
+    json << "}";
+
+    std::string payload = json.str();
+
+    std::map<std::string, std::string> headers;
+    headers["Content-Type"] = "application/json";
+
+    std::string url = SUPABASE_URL + "/functions/v1/device-registration";
+
+    auto response = HttpClient::postJson(url, headers, payload);
+
+    if (response.success && !response.body.empty()) {
+        const char* registered_id_cstr = register_app(response.body.c_str());
+        std::string registered_id = (registered_id_cstr && registered_id_cstr[0] != '\0')
+            ? std::string(registered_id_cstr)
+            : std::string();
+
+        if (!registered_id.empty()) {
+            std::cerr << "[Device Registration] SUCCESS - Device registered!" << std::endl;
+            return registered_id;
+        }
+
+        std::cerr << "[Device Registration] FAILED - Could not parse ID from response" << std::endl;
+        return "";
+    } else {
+        std::cerr << "[Device Registration] FAILED - Direct table insertion unsuccessful" << std::endl;
+        return "";
+    }
+#else
+    return "";
+#endif
+}
+
+inline std::map<std::string, std::string> DeviceManager::getDeviceMetadata() {
+    std::map<std::string, std::string> metadata;
+
+#ifdef CACTUS_TELEMETRY_ENABLED
+    struct utsname system_info;
+    if (uname(&system_info) == 0) {
+        metadata["os"] = "macOS";
+        metadata["os_version"] = system_info.release;
+        metadata["architecture"] = system_info.machine;
+        metadata["model"] = system_info.machine;
+        metadata["brand"] = "apple";
+    }
+#else
+    metadata["os"] = "unknown";
+    metadata["os_version"] = "unknown";
+    metadata["architecture"] = "unknown";
+    metadata["model"] = "unknown";
+    metadata["brand"] = "unknown";
+#endif
+
+    return metadata;
+}
+
+class LogRecord {
+public:
+    static std::string buildJson(
+        const TelemetryMetrics& metrics,
+        const std::string& project_id,
+        const std::string& device_id,
+        const std::string& telemetry_token
+    );
+
+private:
+    static std::string escapeJson(const std::string& input);
+    static std::string formatTimestamp(const std::chrono::system_clock::time_point& timestamp);
+    static std::string eventTypeToString(TelemetryEventType type);
+};
+
+inline std::string LogRecord::escapeJson(const std::string& input) {
+    std::ostringstream output;
+    for (char c : input) {
+        switch (c) {
+            case '"': output << "\\\""; break;
+            case '\\': output << "\\\\"; break;
+            case '\b': output << "\\b"; break;
+            case '\f': output << "\\f"; break;
+            case '\n': output << "\\n"; break;
+            case '\r': output << "\\r"; break;
+            case '\t': output << "\\t"; break;
+            default:
+                if (static_cast<unsigned char>(c) < 0x20) {
+                    output << "\\u" << std::hex << std::setw(4) << std::setfill('0')
+                          << static_cast<int>(c);
+                } else {
+                    output << c;
+                }
+        }
+    }
+    return output.str();
+}
+
+inline std::string LogRecord::formatTimestamp(const std::chrono::system_clock::time_point& timestamp) {
+    auto time_t = std::chrono::system_clock::to_time_t(timestamp);
+    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
+        timestamp.time_since_epoch()) % 1000;
+
+    std::tm tm;
+#ifdef _WIN32
+    gmtime_s(&tm, &time_t);
+#else
+    gmtime_r(&time_t, &tm);
+#endif
+
+    std::ostringstream oss;
+    oss << std::put_time(&tm, "%Y-%m-%dT%H:%M:%S")
+        << '.' << std::setfill('0') << std::setw(3) << ms.count() << 'Z';
+    return oss.str();
+}
+
+inline std::string LogRecord::eventTypeToString(TelemetryEventType type) {
+    switch (type) {
+        case TelemetryEventType::Init:
+            return "init";
+        case TelemetryEventType::Completion:
+            return "completion";
+        case TelemetryEventType::Embedding:
+            return "embedding";
+        case TelemetryEventType::Transcription:
+            return "transcription";
+        default:
+            return "unknown";
+    }
+}
+
+inline std::string LogRecord::buildJson(
+    const TelemetryMetrics& metrics,
+    const std::string& project_id,
+    const std::string& device_id,
+    const std::string& telemetry_token
+) {
+    std::ostringstream json;
+    json << std::fixed << std::setprecision(2);
+
+    json << "{";
+    json << "\"event_type\":\"" << eventTypeToString(metrics.event_type) << "\",";
+    json << "\"model\":\"" << escapeJson(metrics.model) << "\",";
+    json << "\"success\":" << (metrics.success ? "true" : "false") << ",";
+    json << "\"project_id\":\"" << project_id << "\",";
+    json << "\"device_id\":\"" << device_id << "\",";
+    json << "\"telemetry_token\":\"" << telemetry_token << "\",";
+    json << "\"framework\":\"cpp\",";
+    json << "\"framework_version\":\"" << getVersion() << "\"";
+
+    json << ",\"ttft\":" << metrics.ttft_ms;
+    json << ",\"tps\":" << metrics.tps;
+    json << ",\"response_time\":" << metrics.response_time_ms;
+    json << ",\"tokens\":" << metrics.tokens;
+
+    if (!metrics.message.empty()) {
+        json << ",\"message\":\"" << escapeJson(metrics.message) << "\"";
+    }
+
+    json << "}";
+    return json.str();
+}
+
+class CactusTelemetry {
+public:
+    static CactusTelemetry& getInstance();
+
+    void setEnabled(bool enabled);
+    void setTelemetryToken(const std::string& token);
+    void setProjectId(const std::string& project_id);
+    void ensureInitialized();
+
+    void recordEvent(const TelemetryMetrics& metrics);
+
+    void recordInit(const std::string& model, bool success, const std::string& message = "");
+
+    void recordCompletion(const std::string& model, bool success,
+                         double ttft_ms, double tps, double response_time_ms,
+                         int tokens, const std::string& message = "");
+
+    void recordEmbedding(const std::string& model, bool success,
+                        const std::string& message = "");
+
+    void recordTranscription(const std::string& model, bool success,
+                           double ttft_ms, double tps, double response_time_ms,
+                           int tokens, const std::string& message = "");
+
+    bool isEnabled() const;
+
+private:
+    CactusTelemetry();
+    ~CactusTelemetry() = default;
+
+    CactusTelemetry(const CactusTelemetry&) = delete;
+    CactusTelemetry& operator=(const CactusTelemetry&) = delete;
+
+    void sendToSupabase(const TelemetryMetrics& metrics);
+
+    bool enabled_ = false;
+    bool initialized_ = false;
+    std::string telemetry_token_;
+    std::string project_id_;
+    std::string device_id_;
+
+    mutable std::mutex mutex_;
+};
+
+static const std::string SUPABASE_URL = "https://vlqqczxwyaodtcdmdmlw.supabase.co";
+static const std::string SUPABASE_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InZscXFjenh3eWFvZHRjZG1kbWx3Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTE1MTg2MzIsImV4cCI6MjA2NzA5NDYzMn0.nBzqGuK9j6RZ6mOPWU2boAC_5H9XDs-fPpo5P3WZYbI";
+
+inline CactusTelemetry& CactusTelemetry::getInstance() {
+    static CactusTelemetry instance;
+    return instance;
+}
+
+inline CactusTelemetry::CactusTelemetry() {
+    // Device ID and project ID are now initialized lazily
+}
+
+inline void CactusTelemetry::setEnabled(bool enabled) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    enabled_ = enabled;
+}
+
+inline void CactusTelemetry::setTelemetryToken(const std::string& token) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    telemetry_token_ = token;
+}
+
+inline void CactusTelemetry::setProjectId(const std::string& project_id) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    project_id_ = project_id;
+}
+
+inline void CactusTelemetry::ensureInitialized() {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if (!initialized_) {
+        std::string pro_key = DeviceManager::getProKey();
+        if (!pro_key.empty()) {
+            get_device_id(pro_key.c_str());
+        }
+#ifdef CACTUS_TELEMETRY_ENABLED
+        device_id_ = DeviceManager::getDeviceId();
+        project_id_ = DeviceManager::getProjectId();
+#endif
+        initialized_ = true;
+    }
+}
+
+inline bool CactusTelemetry::isEnabled() const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return enabled_ && !telemetry_token_.empty();
+}
+
+inline void CactusTelemetry::sendToSupabase([[maybe_unused]] const TelemetryMetrics& metrics) {
+#ifdef CACTUS_TELEMETRY_ENABLED
+    std::string telemetry_token;
+    std::string project_id;
+    std::string device_id;
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        telemetry_token = telemetry_token_;
+        project_id = project_id_;
+        device_id = device_id_;
+    }
+
+    std::string log_json = LogRecord::buildJson(metrics, project_id, device_id, telemetry_token);
+
+    std::string payload = "[" + log_json + "]";
+
+    std::map<std::string, std::string> headers;
+    headers["apikey"] = SUPABASE_KEY;
+    headers["Authorization"] = "Bearer " + SUPABASE_KEY;
+    headers["Content-Type"] = "application/json";
+    headers["Prefer"] = "return=minimal";
+    headers["Content-Profile"] = "cactus";
+
+    std::string url = SUPABASE_URL + "/rest/v1/logs";
+    HttpClient::postJson(url, headers, payload);
+#else
+    (void)metrics;
+#endif
+}
+
+inline void CactusTelemetry::recordEvent(const TelemetryMetrics& metrics) {
+    if (!isEnabled()) {
+        return;
+    }
+    std::thread([this, metrics]() {
+        sendToSupabase(metrics);
+    }).detach();
+}
+
+inline void CactusTelemetry::recordInit(const std::string& model, bool success,
+                                   const std::string& message) {
+    TelemetryMetrics metrics;
+    metrics.event_type = TelemetryEventType::Init;
+    metrics.model = model;
+    metrics.success = success;
+    metrics.message = message;
+    metrics.timestamp = std::chrono::system_clock::now();
+
+    recordEvent(metrics);
+}
+
+inline void CactusTelemetry::recordCompletion(const std::string& model, bool success,
+                                         double ttft_ms, double tps, double response_time_ms,
+                                         int tokens, const std::string& message) {
+    TelemetryMetrics metrics;
+    metrics.event_type = TelemetryEventType::Completion;
+    metrics.model = model;
+    metrics.success = success;
+    metrics.ttft_ms = ttft_ms;
+    metrics.tps = tps;
+    metrics.response_time_ms = response_time_ms;
+    metrics.tokens = tokens;
+    metrics.message = message;
+    metrics.timestamp = std::chrono::system_clock::now();
+
+    recordEvent(metrics);
+}
+
+inline void CactusTelemetry::recordEmbedding(const std::string& model, bool success,
+                                        const std::string& message) {
+    TelemetryMetrics metrics;
+    metrics.event_type = TelemetryEventType::Embedding;
+    metrics.model = model;
+    metrics.success = success;
+    metrics.message = message;
+    metrics.timestamp = std::chrono::system_clock::now();
+
+    recordEvent(metrics);
+}
+
+inline void CactusTelemetry::recordTranscription(const std::string& model, bool success,
+                            double ttft_ms, double tps, double response_time_ms,
+                            int tokens, const std::string& message) {
+    TelemetryMetrics metrics;
+    metrics.event_type = TelemetryEventType::Transcription;
+    metrics.model = model;
+    metrics.success = success;
+    metrics.response_time_ms = response_time_ms;
+    metrics.ttft_ms = ttft_ms;
+    metrics.tps = tps;
+    metrics.tokens = tokens;
+    metrics.message = message;
+    metrics.timestamp = std::chrono::system_clock::now();
+
+    recordEvent(metrics);
+}
+
+} // namespace ffi
+} // namespace cactus
+
+#endif // CACTUS_TELEMETRY_H
diff --git a/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/ffi_utils.h b/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/cactus_utils.h
similarity index 87%
rename from ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/ffi_utils.h
rename to ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/cactus_utils.h
index 1bbccc4..06dfebe 100644
--- a/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/ffi_utils.h
+++ b/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/cactus_utils.h
@@ -1,5 +1,5 @@
-#ifndef CACTUS_FFI_UTILS_H
-#define CACTUS_FFI_UTILS_H
+#ifndef CACTUS_UTILS_H
+#define CACTUS_UTILS_H
 
 #include "../engine/engine.h"
 #include <string>
@@ -12,10 +12,51 @@
 #include <iostream>
 #include <filesystem>
 #include <cctype>
+#include <memory>
+#include <atomic>
+#include <mutex>
+#include <random>
+
+#ifdef __APPLE__
+#include <uuid/uuid.h>
+#endif
+
+struct CactusModelHandle {
+    std::unique_ptr<cactus::engine::Model> model;
+    std::atomic<bool> should_stop;
+    std::vector<uint32_t> processed_tokens;
+    std::mutex model_mutex;
+    std::string model_name;
+
+    CactusModelHandle() : should_stop(false) {}
+};
+
+extern std::string last_error_message;
+
+bool matches_stop_sequence(const std::vector<uint32_t>& generated_tokens,
+                           const std::vector<std::vector<uint32_t>>& stop_sequences);
 
 namespace cactus {
 namespace ffi {
 
+#ifndef CACTUS_VERSION
+#define CACTUS_VERSION "unknown"
+#endif
+
+inline const char* getVersion() {
+    return CACTUS_VERSION;
+}
+
+inline std::string generateUUID() {
+#ifdef __APPLE__
+    uuid_t uuid;
+    uuid_generate_random(uuid);
+    char uuid_str[37];
+    uuid_unparse_lower(uuid, uuid_str);
+    return std::string(uuid_str);
+#endif
+}
+
 struct ToolFunction {
     std::string name;
     std::string description;
@@ -175,49 +216,58 @@ inline std::vector<ToolFunction> parse_tools_json(const std::string& json) {
     return tools;
 }
 
-inline void parse_options_json(const std::string& json, 
-                               float& temperature, float& top_p, 
+inline void parse_options_json(const std::string& json,
+                               float& temperature, float& top_p,
                                size_t& top_k, size_t& max_tokens,
-                               std::vector<std::string>& stop_sequences) {
+                               std::vector<std::string>& stop_sequences,
+                               bool& force_tools) {
     temperature = 0.0f;
-    top_p = 0.0f;       
-    top_k = 0;           
-    max_tokens = 100;    
+    top_p = 0.0f;
+    top_k = 0;
+    max_tokens = 100;
+    force_tools = false;
     stop_sequences.clear();
-    
+
     if (json.empty()) return;
-    
+
     size_t pos = json.find("\"temperature\"");
     if (pos != std::string::npos) {
         pos = json.find(':', pos) + 1;
         temperature = std::stof(json.substr(pos));
     }
-    
+
     pos = json.find("\"top_p\"");
     if (pos != std::string::npos) {
         pos = json.find(':', pos) + 1;
         top_p = std::stof(json.substr(pos));
     }
-    
+
     pos = json.find("\"top_k\"");
     if (pos != std::string::npos) {
         pos = json.find(':', pos) + 1;
         top_k = std::stoul(json.substr(pos));
     }
-    
+
     pos = json.find("\"max_tokens\"");
     if (pos != std::string::npos) {
         pos = json.find(':', pos) + 1;
         max_tokens = std::stoul(json.substr(pos));
     }
-    
+
+    pos = json.find("\"force_tools\"");
+    if (pos != std::string::npos) {
+        pos = json.find(':', pos) + 1;
+        while (pos < json.length() && std::isspace(json[pos])) pos++;
+        force_tools = (json.substr(pos, 4) == "true");
+    }
+
     pos = json.find("\"stop_sequences\"");
     if (pos != std::string::npos) {
         pos = json.find('[', pos);
         if (pos != std::string::npos) {
             size_t end_pos = json.find(']', pos);
             size_t seq_pos = json.find('"', pos);
-            
+
             while (seq_pos != std::string::npos && seq_pos < end_pos) {
                 size_t seq_start = seq_pos + 1;
                 size_t seq_end = json.find('"', seq_start);
@@ -234,7 +284,7 @@ inline std::string format_tools_for_prompt(const std::vector<ToolFunction>& tool
     if (tools.empty()) return "";
     std::string formatted_tools_json;
     for (size_t i = 0; i < tools.size(); i++) {
-        if (i > 0) formatted_tools_json += ",\n";
+        if (i > 0) formatted_tools_json += "\n";
         formatted_tools_json += "{\"type\":\"function\",\"function\":{\"name\":\""
                               + tools[i].name
                               + "\",\"description\":\""
@@ -398,4 +448,41 @@ inline std::string construct_response_json(const std::string& regular_response,
 } // namespace ffi
 } // namespace cactus
 
-#endif // CACTUS_FFI_UTILS_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+const char* cactus_get_last_error();
+
+__attribute__((weak))
+const char* register_app(const char* encrypted_data);
+
+__attribute__((weak))
+const char* get_device_id(const char* current_token);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+
+__attribute__((weak))
+inline const char* register_app(const char* encrypted_data) {
+    (void)encrypted_data;
+    static thread_local std::string uuid_storage;
+    uuid_storage = cactus::ffi::generateUUID();
+    return uuid_storage.c_str();
+}
+
+__attribute__((weak))
+inline const char* get_device_id(const char* current_token) {
+    (void)current_token;
+    static thread_local std::string uuid_storage;
+    uuid_storage = cactus::ffi::generateUUID();
+    return uuid_storage.c_str();
+}
+}
+#endif
+
+#endif // CACTUS_UTILS_H
diff --git a/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/engine.h b/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/engine.h
index 77594ed..601e818 100644
--- a/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/engine.h
+++ b/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/engine.h
@@ -3,6 +3,7 @@
 #include <vector>
 #include <string>
 #include <unordered_map>
+#include <unordered_set>
 #include <memory>
 #include <cstdint>
 
@@ -32,6 +33,9 @@ extern "C" {
 class CactusGraph;
 
 namespace cactus {
+namespace npu {
+    class NPUPrefill;
+}
 namespace engine {
 
 class Siglip2Preprocessor;
@@ -349,6 +353,13 @@ struct KVCache {
     void update_from_graph(CactusGraph* gb, const std::vector<size_t>& k_nodes,
                           const std::vector<size_t>& v_nodes, size_t seq_len,
                           size_t num_layers, size_t kv_heads, size_t head_dim);
+
+    // Update KV cache from NPU prefill outputs
+    // NPU outputs are in shape [num_tokens, num_kv_heads, head_dim]
+    // This handles transposition to cache format and sliding window
+    void update_from_npu(size_t layer_idx, const __fp16* k_data, const __fp16* v_data,
+                         size_t num_tokens, size_t kv_heads, size_t head_dim);
+
     bool is_empty() const { return current_seq_len == 0; }
     void* get_key_ptr(size_t layer);
     void* get_value_ptr(size_t layer);
@@ -365,6 +376,85 @@ struct KVCache {
     CircularView get_value_view(size_t layer);
 };
 
+class ToolCallConstrainer {
+public:
+    enum class State {
+        START,                  // -> expect {
+        EXPECT_FC_KEY,          // -> expect "function_call"
+        EXPECT_FC_COLON,        // -> expect :
+        EXPECT_FC_OPEN_BRACE,   // -> expect {
+        EXPECT_NAME_KEY,        // -> expect "name"
+        EXPECT_NAME_COLON,      // -> expect :
+        EXPECT_NAME_VALUE,      // -> expect "<function_name>"
+        EXPECT_COMMA,           // -> expect ,
+        EXPECT_ARGS_KEY,        // -> expect "arguments"
+        EXPECT_ARGS_COLON,      // -> expect :
+        IN_ARGUMENTS,           // -> free JSON, track brace depth
+        EXPECT_INNER_CLOSE,     // -> expect } to close inner object
+        EXPECT_OUTER_CLOSE,     // -> expect } to close outer object
+        DONE,                   // complete
+
+        LFM_START,              // -> expect <|tool_call_start|>
+        LFM_EXPECT_BRACKET,     // -> expect [
+        LFM_IN_FUNC_NAME,       // -> expect function name
+        LFM_EXPECT_PAREN,       // -> expect (
+        LFM_IN_ARGUMENTS,       // -> arguments until )
+        LFM_EXPECT_BRACKET_CLOSE, // -> expect ]
+        LFM_EXPECT_END          // -> expect <|tool_call_end|>
+    };
+
+    void init(Config::ModelType model_type,
+              const std::vector<std::string>& function_names,
+              Tokenizer* tokenizer);
+
+    const std::unordered_map<uint32_t, float>& get_bias() const { return current_bias_; }
+
+    void update(uint32_t token_id, const std::string& decoded_text);
+
+    void reset();
+
+    bool is_active() const { return active_; }
+
+private:
+    bool active_ = false;
+    State state_ = State::START;
+    Config::ModelType model_type_ = Config::ModelType::QWEN;
+    Tokenizer* tokenizer_ = nullptr;
+
+    std::vector<std::string> function_names_;
+    std::string generated_text_;
+    int brace_depth_ = 0;  // Track nested braces in arguments
+
+    // Pre-tokenized token sets for each grammar element
+    std::unordered_set<uint32_t> open_brace_tokens_;      // {
+    std::unordered_set<uint32_t> close_brace_tokens_;     // }
+    std::unordered_set<uint32_t> colon_tokens_;           // :
+    std::unordered_set<uint32_t> comma_tokens_;           // ,
+    std::unordered_set<uint32_t> fc_key_tokens_;          // "function_call"
+    std::unordered_set<uint32_t> name_key_tokens_;        // "name"
+    std::unordered_set<uint32_t> args_key_tokens_;        // "arguments"
+    std::unordered_set<uint32_t> quote_tokens_;           // "
+    std::unordered_set<uint32_t> backtick_tokens_;        // ` (to block markdown code fences)
+    std::unordered_set<uint32_t> response_starter_tokens_; // Common response starters to block (I, I'm, Sorry, etc.)
+    std::unordered_set<uint32_t> all_func_name_tokens_;   // All function name tokens combined
+    std::unordered_map<std::string, std::vector<uint32_t>> func_name_sequences_;  // Full token sequence per function
+
+    // LFM2-specific tokens
+    std::unordered_set<uint32_t> tool_start_tokens_;
+    std::unordered_set<uint32_t> tool_end_tokens_;
+    std::unordered_set<uint32_t> bracket_open_tokens_;    // [
+    std::unordered_set<uint32_t> bracket_close_tokens_;   // ]
+    std::unordered_set<uint32_t> paren_open_tokens_;      // (
+    std::unordered_set<uint32_t> paren_close_tokens_;     // )
+    std::unordered_set<uint32_t> equals_tokens_;          // =
+
+    std::unordered_map<uint32_t, float> current_bias_;
+
+    void compute_bias();
+    void tokenize_grammar_elements();
+    void add_tokens_for_string(const std::string& str, std::unordered_set<uint32_t>& token_set);
+};
+
 class Model {
 public:
     struct DebugNode {
@@ -386,26 +476,40 @@ class Model {
     virtual bool init(CactusGraph* external_graph, const std::string& model_folder, size_t context_size,
               const std::string& system_prompt = "", bool do_warmup = true);
 
-    virtual uint32_t generate(const std::vector<uint32_t>& tokens, float temperature = -1.0f, float top_p = -1.0f,
-                      size_t top_k = 0, const std::string& profile_file = "", bool prefill_only = false);
+    virtual uint32_t decode(const std::vector<uint32_t>& tokens, float temperature = -1.0f, float top_p = -1.0f,
+                      size_t top_k = 0, const std::string& profile_file = "");
+
+    virtual void prefill(const std::vector<uint32_t>& tokens, size_t chunk_size = 256, const std::string& profile_file = "");
 
-    virtual uint32_t generate_with_images(const std::vector<uint32_t>& tokens, const std::vector<std::string>& image_paths,
+    virtual uint32_t decode_with_images(const std::vector<uint32_t>& tokens, const std::vector<std::string>& image_paths,
                                           float temperature = -1.0f, float top_p = -1.0f,
                                           size_t top_k = 0, const std::string& profile_file = "");
-    
-    virtual uint32_t generate_with_audio(const std::vector<uint32_t>& tokens, const std::vector<float>& mel_bins, float temperature = 0.0f, float top_p = 0.0f,
+
+    virtual uint32_t decode_with_audio(const std::vector<uint32_t>& tokens, const std::vector<float>& mel_bins, float temperature = 0.0f, float top_p = 0.0f,
                       size_t top_k = 0, const std::string& profile_file = "");
 
-    std::vector<float> get_embeddings(const std::vector<uint32_t>& tokens, bool pooled = true, const std::string& profile_file = "");
+    std::vector<float> get_embeddings(const std::vector<uint32_t>& tokens, bool pooled = true, bool normalize = false, const std::string& profile_file = "");
     
     virtual std::vector<float> get_image_embeddings(const std::string& image_path);
     
     virtual std::vector<float> get_audio_embeddings(const std::vector<float>& mel_bins);
 
     virtual void reset_cache() { kv_cache_.reset(); }
-    
+
+    double score_tokens_window_logprob(const std::vector<uint32_t>& tokens, size_t start, size_t end, size_t context, size_t* tokens_scored);
+
+
+
     void set_cache_window(size_t window_size, size_t sink_size = 4) { kv_cache_.set_window_size(window_size, sink_size); }
 
+    bool load_npu_prefill(const std::string& model_path);
+    bool has_npu_prefill() const;
+    size_t get_prefill_chunk_size() const;
+
+    void set_tool_constraints(const std::vector<std::string>& function_names);
+    void clear_tool_constraints();
+    void update_tool_constraints(uint32_t token_id);
+
     void* graph_handle_;
 
 protected:
@@ -449,6 +553,12 @@ class Model {
     bool init_internal(CactusGraph* gb, const std::string& model_folder, size_t context_size,
                        const std::string& system_prompt, bool do_warmup);
     bool owns_graph_;
+
+    std::unique_ptr<npu::NPUPrefill> npu_prefill_;
+    void prefill_npu(const std::vector<uint32_t>& tokens);
+    virtual std::vector<__fp16> get_token_embeddings(const std::vector<uint32_t>& tokens);
+
+    ToolCallConstrainer tool_constrainer_;
 };
 
 std::unique_ptr<Model> create_model(const std::string& model_folder);
diff --git a/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/graph.h b/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/graph.h
index bc43d1c..35b2808 100644
--- a/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/graph.h
+++ b/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/graph.h
@@ -8,6 +8,88 @@
 #include <cstring>
 #include <stdexcept>
 #include <string>
+#include <mutex>
+#include <sstream>
+#include <iostream>
+
+namespace cactus {
+
+enum class LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3,
+    NONE = 4
+};
+
+class Logger {
+public:
+    static Logger& instance() {
+        static Logger logger;
+        return logger;
+    }
+
+    void set_level(LogLevel level) { min_level_ = level; }
+    LogLevel get_level() const { return min_level_; }
+
+    void set_callback(std::function<void(LogLevel, const std::string&, const std::string&)> cb) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        callback_ = cb;
+    }
+
+    void log(LogLevel level, const std::string& component, const std::string& message) {
+        if (level < min_level_) return;
+
+        std::lock_guard<std::mutex> lock(mutex_);
+
+        if (callback_) {
+            callback_(level, component, message);
+        } else {
+            std::cerr << "[" << level_string(level) << "] [" << component << "] " << message << std::endl;
+        }
+
+        if (level == LogLevel::ERROR) {
+            last_error_ = "[" + component + "] " + message;
+        }
+    }
+
+    const std::string& last_error() const { return last_error_; }
+    void clear_error() { last_error_.clear(); }
+
+private:
+    Logger() : min_level_(LogLevel::WARN) {}
+
+    static const char* level_string(LogLevel level) {
+        switch (level) {
+            case LogLevel::DEBUG: return "DEBUG";
+            case LogLevel::INFO:  return "INFO";
+            case LogLevel::WARN:  return "WARN";
+            case LogLevel::ERROR: return "ERROR";
+            default: return "?";
+        }
+    }
+
+    LogLevel min_level_;
+    std::mutex mutex_;
+    std::string last_error_;
+    std::function<void(LogLevel, const std::string&, const std::string&)> callback_;
+};
+
+} // namespace cactus
+
+#define CACTUS_LOG(level, component, msg) \
+    do { \
+        if (static_cast<int>(level) >= static_cast<int>(cactus::Logger::instance().get_level())) { \
+            std::ostringstream _cactus_log_ss; \
+            _cactus_log_ss << msg; \
+            cactus::Logger::instance().log(level, component, _cactus_log_ss.str()); \
+        } \
+    } while(0)
+
+#define CACTUS_LOG_DEBUG(component, msg) CACTUS_LOG(cactus::LogLevel::DEBUG, component, msg)
+#define CACTUS_LOG_INFO(component, msg)  CACTUS_LOG(cactus::LogLevel::INFO, component, msg)
+#define CACTUS_LOG_WARN(component, msg)  CACTUS_LOG(cactus::LogLevel::WARN, component, msg)
+#define CACTUS_LOG_ERROR(component, msg) CACTUS_LOG(cactus::LogLevel::ERROR, component, msg)
 
 namespace GraphFile {
     class MappedFile;
@@ -144,7 +226,7 @@ struct OpParams {
     size_t slice_start = 0;
     size_t slice_length = 0;
     size_t window_size = 0;
-    bool is_causal = true;  // Default to causal for backward compatibility
+    bool is_causal = true;  
     std::vector<size_t> new_shape;
     std::vector<size_t> permutation;
     Precision output_precision = Precision::INT8;
@@ -158,10 +240,13 @@ struct OpParams {
     size_t top_k = 0;
     size_t random_seed = 0;
     
-    size_t index_value = 0;  // For INDEX operation
-    size_t num_classes = 0;  // For scatter operations
+    size_t index_value = 0;  
+    size_t num_classes = 0; 
     size_t dst_height = 0;
-    size_t dst_width = 0;   
+    size_t dst_width = 0;
+
+    std::vector<float> bias_values;
+    std::vector<uint32_t> bias_indices;
 };
 
 struct GraphNode {
@@ -294,7 +379,8 @@ class CactusGraph {
     size_t conv1d_causal(size_t input, size_t weight, size_t kernel_size, size_t dilation = 1);
     size_t conv1d_k3(size_t input, size_t weight, size_t stride);
     
-    size_t sample(size_t logits, float temperature = 0.6f, float top_p = 0.95f, size_t top_k = 20);
+    size_t sample(size_t logits, float temperature = 0.6f, float top_p = 0.95f, size_t top_k = 20,
+                  const std::unordered_map<uint32_t, float>& logit_bias = {});
     
     size_t concat(size_t input1, size_t input2, int axis = 0);
     size_t scatter_topk(size_t indices, size_t values, size_t num_classes);
diff --git a/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/kernel.h b/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/kernel.h
index 5c1e59d..726cf37 100644
--- a/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/kernel.h
+++ b/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/kernel.h
@@ -102,18 +102,23 @@ void cactus_matmul_f32(const float* a, const float* b_transposed, float* c,
                        size_t M, size_t K, size_t N);
 
 
-void cactus_transpose_2d_int8(const int8_t* source, int8_t* destination, 
+void cactus_transpose_2d_int8(const int8_t* source, int8_t* destination,
                                size_t num_rows, size_t num_cols, size_t start_row, size_t end_row);
-void cactus_transpose_2d_f32(const float* source, float* destination, 
+void cactus_transpose_2d_f16(const __fp16* source, __fp16* destination,
+                             size_t num_rows, size_t num_cols, size_t start_row, size_t end_row);
+void cactus_transpose_2d_f32(const float* source, float* destination,
                              size_t num_rows, size_t num_cols, size_t start_row, size_t end_row);
 
-void cactus_transpose_int8(const int8_t* source, int8_t* destination, const size_t* shape, 
+void cactus_transpose_int8(const int8_t* source, int8_t* destination, const size_t* shape,
                            const size_t* permutation, size_t ndim, size_t start_idx, size_t end_idx);
-void cactus_transpose_f32(const float* source, float* destination, const size_t* shape, 
+void cactus_transpose_f16(const __fp16* source, __fp16* destination, const size_t* shape,
+                          const size_t* permutation, size_t ndim, size_t start_idx, size_t end_idx);
+void cactus_transpose_f32(const float* source, float* destination, const size_t* shape,
                           const size_t* permutation, size_t ndim, size_t start_idx, size_t end_idx);
 
 int64_t cactus_sum_all_int8(const int8_t* data, size_t num_elements);
 void cactus_sum_axis_int8(const int8_t* input, int8_t* output, size_t outer_size, size_t axis_size, size_t inner_size);
+double cactus_sum_all_f16(const __fp16* data, size_t num_elements);
 double cactus_sum_all_f32(const float* data, size_t num_elements);
 void cactus_sum_axis_f32(const float* input, float* output, size_t outer_size, size_t axis_size, size_t inner_size);
 
@@ -278,9 +283,13 @@ void cactus_bilinear_interpolation_fp32(const float* input, float* output, size_
                                         size_t dst_height, size_t dst_width);
 
 void cactus_sample_f32(const float* logits, uint32_t* output, size_t vocab_size,
-                       float temperature, float top_p, size_t top_k, size_t random_seed);
+                       float temperature, float top_p, size_t top_k, size_t random_seed,
+                       const float* bias_values = nullptr, const uint32_t* bias_indices = nullptr,
+                       size_t bias_count = 0);
 void cactus_sample_f16(const __fp16* logits, uint32_t* output, size_t vocab_size,
-                       float temperature, float top_p, size_t top_k, size_t random_seed);
+                       float temperature, float top_p, size_t top_k, size_t random_seed,
+                       const float* bias_values = nullptr, const uint32_t* bias_indices = nullptr,
+                       size_t bias_count = 0);
 
 
 void cactus_concat_f32(const float* input1, const float* input2, float* output,
diff --git a/ios/cactus.xcframework/ios-arm64/cactus.framework/Info.plist b/ios/cactus.xcframework/ios-arm64/cactus.framework/Info.plist
index 8889aaa..db7b528 100644
Binary files a/ios/cactus.xcframework/ios-arm64/cactus.framework/Info.plist and b/ios/cactus.xcframework/ios-arm64/cactus.framework/Info.plist differ
diff --git a/ios/cactus.xcframework/ios-arm64/cactus.framework/cactus b/ios/cactus.xcframework/ios-arm64/cactus.framework/cactus
index 1335f38..2de21e3 100755
Binary files a/ios/cactus.xcframework/ios-arm64/cactus.framework/cactus and b/ios/cactus.xcframework/ios-arm64/cactus.framework/cactus differ
diff --git a/ios/cactus_util.xcframework/Info.plist b/ios/cactus_util.xcframework/Info.plist
index ffaf856..d05b060 100644
--- a/ios/cactus_util.xcframework/Info.plist
+++ b/ios/cactus_util.xcframework/Info.plist
@@ -6,7 +6,7 @@
     <array>
         <dict>
             <key>LibraryIdentifier</key>
-            <string>ios-arm64-simulator</string>
+            <string>ios-arm64</string>
             <key>LibraryPath</key>
             <string>cactus_util.framework</string>
             <key>SupportedArchitectures</key>
@@ -15,12 +15,10 @@
             </array>
             <key>SupportedPlatform</key>
             <string>ios</string>
-            <key>SupportedPlatformVariant</key>
-            <string>simulator</string>
         </dict>
         <dict>
             <key>LibraryIdentifier</key>
-            <string>ios-arm64</string>
+            <string>ios-arm64-simulator</string>
             <key>LibraryPath</key>
             <string>cactus_util.framework</string>
             <key>SupportedArchitectures</key>
@@ -29,6 +27,8 @@
             </array>
             <key>SupportedPlatform</key>
             <string>ios</string>
+            <key>SupportedPlatformVariant</key>
+            <string>simulator</string>
         </dict>
     </array>
     <key>CFBundlePackageType</key>
diff --git a/ios/cactus_util.xcframework/ios-arm64-simulator/cactus_util.framework/Headers/cactus_util.h b/ios/cactus_util.xcframework/ios-arm64-simulator/cactus_util.framework/Headers/cactus_util.h
index 8ee154a..aa19ef0 100644
--- a/ios/cactus_util.xcframework/ios-arm64-simulator/cactus_util.framework/Headers/cactus_util.h
+++ b/ios/cactus_util.xcframework/ios-arm64-simulator/cactus_util.framework/Headers/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);
diff --git a/ios/cactus_util.xcframework/ios-arm64-simulator/cactus_util.framework/Headers/database.h b/ios/cactus_util.xcframework/ios-arm64-simulator/cactus_util.framework/Headers/database.h
new file mode 100644
index 0000000..cbb86b4
--- /dev/null
+++ b/ios/cactus_util.xcframework/ios-arm64-simulator/cactus_util.framework/Headers/database.h
@@ -0,0 +1,27 @@
+#ifndef DATABASE_H
+#define DATABASE_H
+
+#include <string>
+struct sqlite3;
+
+class Database {
+private:
+    sqlite3* db;
+    std::string db_path;
+    
+    bool create_tables();
+    
+public:
+    Database(const std::string& path = "cactus.db");
+    ~Database();
+    
+    bool initialize();
+    bool register_app(const std::string& device_id, const std::string& token_expiry_date, const std::string& token);
+    bool get_registration(std::string& device_id, std::string& token_expiry_date, std::string& token);
+    const char* get_device_id();
+    void close();
+    
+    bool is_open() const;
+};
+
+#endif // DATABASE_H
diff --git a/ios/cactus_util.xcframework/ios-arm64-simulator/cactus_util.framework/Info.plist b/ios/cactus_util.xcframework/ios-arm64-simulator/cactus_util.framework/Info.plist
index 20c552d..dfc71c4 100644
Binary files a/ios/cactus_util.xcframework/ios-arm64-simulator/cactus_util.framework/Info.plist and b/ios/cactus_util.xcframework/ios-arm64-simulator/cactus_util.framework/Info.plist differ
diff --git a/ios/cactus_util.xcframework/ios-arm64-simulator/cactus_util.framework/_CodeSignature/CodeResources b/ios/cactus_util.xcframework/ios-arm64-simulator/cactus_util.framework/_CodeSignature/CodeResources
index 0e3932e..40a7afe 100644
--- a/ios/cactus_util.xcframework/ios-arm64-simulator/cactus_util.framework/_CodeSignature/CodeResources
+++ b/ios/cactus_util.xcframework/ios-arm64-simulator/cactus_util.framework/_CodeSignature/CodeResources
@@ -6,7 +6,7 @@
 	<dict>
 		<key>Headers/cactus_util.h</key>
 		<data>
-		7z1Ts4xufXPrnEBuKu+NppO1yKg=
+		5lW8KZ3LQl0aqP6TUxyB+K0vcIE=
 		</data>
 		<key>Headers/ios_utils.h</key>
 		<data>
@@ -18,7 +18,7 @@
 		</data>
 		<key>Info.plist</key>
 		<data>
-		OhVLqBjBr8wHfc8V3KCR4rpni5U=
+		gD92JC49Bf9W6pi0MZWov5LMRb4=
 		</data>
 	</dict>
 	<key>files2</key>
@@ -27,7 +27,7 @@
 		<dict>
 			<key>hash2</key>
 			<data>
-			mIHS5tpbAc2yQnCfoYds/waoVwabQF9bYng+EYTSSrg=
+			Q7DuJEU0UWHgQ8cVdAc50lq592AjV42gMHSiDHx4OQk=
 			</data>
 		</dict>
 		<key>Headers/ios_utils.h</key>
diff --git a/ios/cactus_util.xcframework/ios-arm64-simulator/cactus_util.framework/cactus_util b/ios/cactus_util.xcframework/ios-arm64-simulator/cactus_util.framework/cactus_util
index 421023e..2f060cc 100755
Binary files a/ios/cactus_util.xcframework/ios-arm64-simulator/cactus_util.framework/cactus_util and b/ios/cactus_util.xcframework/ios-arm64-simulator/cactus_util.framework/cactus_util differ
diff --git a/ios/cactus_util.xcframework/ios-arm64/cactus_util.framework/Headers/cactus_util.h b/ios/cactus_util.xcframework/ios-arm64/cactus_util.framework/Headers/cactus_util.h
index 8ee154a..aa19ef0 100644
--- a/ios/cactus_util.xcframework/ios-arm64/cactus_util.framework/Headers/cactus_util.h
+++ b/ios/cactus_util.xcframework/ios-arm64/cactus_util.framework/Headers/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);
diff --git a/ios/cactus_util.xcframework/ios-arm64/cactus_util.framework/Headers/database.h b/ios/cactus_util.xcframework/ios-arm64/cactus_util.framework/Headers/database.h
new file mode 100644
index 0000000..cbb86b4
--- /dev/null
+++ b/ios/cactus_util.xcframework/ios-arm64/cactus_util.framework/Headers/database.h
@@ -0,0 +1,27 @@
+#ifndef DATABASE_H
+#define DATABASE_H
+
+#include <string>
+struct sqlite3;
+
+class Database {
+private:
+    sqlite3* db;
+    std::string db_path;
+    
+    bool create_tables();
+    
+public:
+    Database(const std::string& path = "cactus.db");
+    ~Database();
+    
+    bool initialize();
+    bool register_app(const std::string& device_id, const std::string& token_expiry_date, const std::string& token);
+    bool get_registration(std::string& device_id, std::string& token_expiry_date, std::string& token);
+    const char* get_device_id();
+    void close();
+    
+    bool is_open() const;
+};
+
+#endif // DATABASE_H
diff --git a/ios/cactus_util.xcframework/ios-arm64/cactus_util.framework/Info.plist b/ios/cactus_util.xcframework/ios-arm64/cactus_util.framework/Info.plist
index 08bdae0..3509d66 100644
Binary files a/ios/cactus_util.xcframework/ios-arm64/cactus_util.framework/Info.plist and b/ios/cactus_util.xcframework/ios-arm64/cactus_util.framework/Info.plist differ
diff --git a/ios/cactus_util.xcframework/ios-arm64/cactus_util.framework/cactus_util b/ios/cactus_util.xcframework/ios-arm64/cactus_util.framework/cactus_util
index 05e9747..3c20c4b 100755
Binary files a/ios/cactus_util.xcframework/ios-arm64/cactus_util.framework/cactus_util and b/ios/cactus_util.xcframework/ios-arm64/cactus_util.framework/cactus_util differ
diff --git a/nitro.json b/nitro.json
index cb81173..b9a610b 100644
--- a/nitro.json
+++ b/nitro.json
@@ -11,6 +11,9 @@
     "Cactus": {
       "cpp": "HybridCactus"
     },
+    "CactusIndex": {
+      "cpp": "HybridCactusIndex"
+    },
     "CactusUtil": {
       "cpp": "HybridCactusUtil"
     },
diff --git a/nitrogen/generated/android/c++/JDeviceInfo.hpp b/nitrogen/generated/android/c++/JDeviceInfo.hpp
index eb85aa3..281fd46 100644
--- a/nitrogen/generated/android/c++/JDeviceInfo.hpp
+++ b/nitrogen/generated/android/c++/JDeviceInfo.hpp
@@ -2,7 +2,7 @@
 /// JDeviceInfo.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once
diff --git a/nitrogen/generated/android/c++/JFunc_void_double.hpp b/nitrogen/generated/android/c++/JFunc_void_double.hpp
index d3d40d4..fa15250 100644
--- a/nitrogen/generated/android/c++/JFunc_void_double.hpp
+++ b/nitrogen/generated/android/c++/JFunc_void_double.hpp
@@ -2,7 +2,7 @@
 /// JFunc_void_double.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once
diff --git a/nitrogen/generated/android/c++/JHybridCactusCryptoSpec.cpp b/nitrogen/generated/android/c++/JHybridCactusCryptoSpec.cpp
index 5499d12..63fb5ab 100644
--- a/nitrogen/generated/android/c++/JHybridCactusCryptoSpec.cpp
+++ b/nitrogen/generated/android/c++/JHybridCactusCryptoSpec.cpp
@@ -2,7 +2,7 @@
 /// JHybridCactusCryptoSpec.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #include "JHybridCactusCryptoSpec.hpp"
diff --git a/nitrogen/generated/android/c++/JHybridCactusCryptoSpec.hpp b/nitrogen/generated/android/c++/JHybridCactusCryptoSpec.hpp
index aca9999..528e3ab 100644
--- a/nitrogen/generated/android/c++/JHybridCactusCryptoSpec.hpp
+++ b/nitrogen/generated/android/c++/JHybridCactusCryptoSpec.hpp
@@ -2,7 +2,7 @@
 /// HybridCactusCryptoSpec.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once
diff --git a/nitrogen/generated/android/c++/JHybridCactusDeviceInfoSpec.cpp b/nitrogen/generated/android/c++/JHybridCactusDeviceInfoSpec.cpp
index 89742ef..9b5838c 100644
--- a/nitrogen/generated/android/c++/JHybridCactusDeviceInfoSpec.cpp
+++ b/nitrogen/generated/android/c++/JHybridCactusDeviceInfoSpec.cpp
@@ -2,7 +2,7 @@
 /// JHybridCactusDeviceInfoSpec.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #include "JHybridCactusDeviceInfoSpec.hpp"
diff --git a/nitrogen/generated/android/c++/JHybridCactusDeviceInfoSpec.hpp b/nitrogen/generated/android/c++/JHybridCactusDeviceInfoSpec.hpp
index a4a52a3..0a4fbc3 100644
--- a/nitrogen/generated/android/c++/JHybridCactusDeviceInfoSpec.hpp
+++ b/nitrogen/generated/android/c++/JHybridCactusDeviceInfoSpec.hpp
@@ -2,7 +2,7 @@
 /// HybridCactusDeviceInfoSpec.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once
diff --git a/nitrogen/generated/android/c++/JHybridCactusFileSystemSpec.cpp b/nitrogen/generated/android/c++/JHybridCactusFileSystemSpec.cpp
index 55932c6..938bd3d 100644
--- a/nitrogen/generated/android/c++/JHybridCactusFileSystemSpec.cpp
+++ b/nitrogen/generated/android/c++/JHybridCactusFileSystemSpec.cpp
@@ -2,7 +2,7 @@
 /// JHybridCactusFileSystemSpec.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #include "JHybridCactusFileSystemSpec.hpp"
@@ -188,5 +188,21 @@ namespace margelo::nitro::cactus {
       return __promise;
     }();
   }
+  std::shared_ptr<Promise<std::string>> JHybridCactusFileSystemSpec::getIndexPath(const std::string& name) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* name */)>("getIndexPath");
+    auto __result = method(_javaPart, jni::make_jstring(name));
+    return [&]() {
+      auto __promise = Promise<std::string>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JString>(__boxedResult);
+        __promise->resolve(__result->toStdString());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
 
 } // namespace margelo::nitro::cactus
diff --git a/nitrogen/generated/android/c++/JHybridCactusFileSystemSpec.hpp b/nitrogen/generated/android/c++/JHybridCactusFileSystemSpec.hpp
index 6bcb110..968e3f6 100644
--- a/nitrogen/generated/android/c++/JHybridCactusFileSystemSpec.hpp
+++ b/nitrogen/generated/android/c++/JHybridCactusFileSystemSpec.hpp
@@ -2,7 +2,7 @@
 /// HybridCactusFileSystemSpec.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once
@@ -63,6 +63,7 @@ namespace margelo::nitro::cactus {
     std::shared_ptr<Promise<std::string>> getModelPath(const std::string& model) override;
     std::shared_ptr<Promise<void>> downloadModel(const std::string& model, const std::string& from, const std::optional<std::function<void(double /* progress */)>>& callback) override;
     std::shared_ptr<Promise<void>> deleteModel(const std::string& model) override;
+    std::shared_ptr<Promise<std::string>> getIndexPath(const std::string& name) override;
 
   private:
     friend HybridBase;
diff --git a/nitrogen/generated/android/c++/JHybridCactusImageSpec.cpp b/nitrogen/generated/android/c++/JHybridCactusImageSpec.cpp
index 4c1a3b6..a6d7a33 100644
--- a/nitrogen/generated/android/c++/JHybridCactusImageSpec.cpp
+++ b/nitrogen/generated/android/c++/JHybridCactusImageSpec.cpp
@@ -2,7 +2,7 @@
 /// JHybridCactusImageSpec.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #include "JHybridCactusImageSpec.hpp"
diff --git a/nitrogen/generated/android/c++/JHybridCactusImageSpec.hpp b/nitrogen/generated/android/c++/JHybridCactusImageSpec.hpp
index ac0e5a9..8f46205 100644
--- a/nitrogen/generated/android/c++/JHybridCactusImageSpec.hpp
+++ b/nitrogen/generated/android/c++/JHybridCactusImageSpec.hpp
@@ -2,7 +2,7 @@
 /// HybridCactusImageSpec.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once
diff --git a/nitrogen/generated/android/cactus+autolinking.cmake b/nitrogen/generated/android/cactus+autolinking.cmake
index c116590..f38345c 100644
--- a/nitrogen/generated/android/cactus+autolinking.cmake
+++ b/nitrogen/generated/android/cactus+autolinking.cmake
@@ -2,7 +2,7 @@
 # cactus+autolinking.cmake
 # This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 # https://github.com/mrousavy/nitro
-# Copyright © 2025 Marc Rousavy @ Margelo
+# Copyright © 2026 Marc Rousavy @ Margelo
 #
 
 # This is a CMake file that adds all files generated by Nitrogen
@@ -38,6 +38,7 @@ target_sources(
   ../nitrogen/generated/shared/c++/HybridCactusDeviceInfoSpec.cpp
   ../nitrogen/generated/shared/c++/HybridCactusFileSystemSpec.cpp
   ../nitrogen/generated/shared/c++/HybridCactusImageSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridCactusIndexSpec.cpp
   ../nitrogen/generated/shared/c++/HybridCactusUtilSpec.cpp
   # Android-specific Nitrogen C++ sources
   ../nitrogen/generated/android/c++/JHybridCactusCryptoSpec.cpp
diff --git a/nitrogen/generated/android/cactus+autolinking.gradle b/nitrogen/generated/android/cactus+autolinking.gradle
index 05cb022..a0e59e3 100644
--- a/nitrogen/generated/android/cactus+autolinking.gradle
+++ b/nitrogen/generated/android/cactus+autolinking.gradle
@@ -2,7 +2,7 @@
 /// cactus+autolinking.gradle
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 /// This is a Gradle file that adds all files generated by Nitrogen
diff --git a/nitrogen/generated/android/cactusOnLoad.cpp b/nitrogen/generated/android/cactusOnLoad.cpp
index c336c2c..8896aeb 100644
--- a/nitrogen/generated/android/cactusOnLoad.cpp
+++ b/nitrogen/generated/android/cactusOnLoad.cpp
@@ -2,7 +2,7 @@
 /// cactusOnLoad.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #ifndef BUILDING_CACTUS_WITH_GENERATED_CMAKE_PROJECT
@@ -21,6 +21,7 @@
 #include "JFunc_void_double.hpp"
 #include "JHybridCactusImageSpec.hpp"
 #include "HybridCactus.hpp"
+#include "HybridCactusIndex.hpp"
 #include "HybridCactusUtil.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
 
@@ -49,6 +50,15 @@ int initialize(JavaVM* vm) {
         return std::make_shared<HybridCactus>();
       }
     );
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "CactusIndex",
+      []() -> std::shared_ptr<HybridObject> {
+        static_assert(std::is_default_constructible_v<HybridCactusIndex>,
+                      "The HybridObject \"HybridCactusIndex\" is not default-constructible! "
+                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+        return std::make_shared<HybridCactusIndex>();
+      }
+    );
     HybridObjectRegistry::registerHybridObjectConstructor(
       "CactusUtil",
       []() -> std::shared_ptr<HybridObject> {
diff --git a/nitrogen/generated/android/cactusOnLoad.hpp b/nitrogen/generated/android/cactusOnLoad.hpp
index f89c1b4..79f1023 100644
--- a/nitrogen/generated/android/cactusOnLoad.hpp
+++ b/nitrogen/generated/android/cactusOnLoad.hpp
@@ -2,7 +2,7 @@
 /// cactusOnLoad.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #include <jni.h>
diff --git a/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/DeviceInfo.kt b/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/DeviceInfo.kt
index 2e87c9b..847f799 100644
--- a/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/DeviceInfo.kt
+++ b/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/DeviceInfo.kt
@@ -2,7 +2,7 @@
 /// DeviceInfo.kt
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 package com.margelo.nitro.cactus
diff --git a/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/Func_void_double.kt b/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/Func_void_double.kt
index 8822eaa..79d4e9c 100644
--- a/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/Func_void_double.kt
+++ b/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/Func_void_double.kt
@@ -2,7 +2,7 @@
 /// Func_void_double.kt
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 package com.margelo.nitro.cactus
diff --git a/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/HybridCactusCryptoSpec.kt b/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/HybridCactusCryptoSpec.kt
index 67d7ee9..15f6e1d 100644
--- a/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/HybridCactusCryptoSpec.kt
+++ b/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/HybridCactusCryptoSpec.kt
@@ -2,7 +2,7 @@
 /// HybridCactusCryptoSpec.kt
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 package com.margelo.nitro.cactus
diff --git a/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/HybridCactusDeviceInfoSpec.kt b/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/HybridCactusDeviceInfoSpec.kt
index ec62abd..bd46e9f 100644
--- a/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/HybridCactusDeviceInfoSpec.kt
+++ b/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/HybridCactusDeviceInfoSpec.kt
@@ -2,7 +2,7 @@
 /// HybridCactusDeviceInfoSpec.kt
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 package com.margelo.nitro.cactus
diff --git a/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/HybridCactusFileSystemSpec.kt b/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/HybridCactusFileSystemSpec.kt
index ecf065c..0535e7b 100644
--- a/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/HybridCactusFileSystemSpec.kt
+++ b/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/HybridCactusFileSystemSpec.kt
@@ -2,7 +2,7 @@
 /// HybridCactusFileSystemSpec.kt
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 package com.margelo.nitro.cactus
@@ -86,6 +86,10 @@ abstract class HybridCactusFileSystemSpec: HybridObject() {
   @DoNotStrip
   @Keep
   abstract fun deleteModel(model: String): Promise<Unit>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getIndexPath(name: String): Promise<String>
 
   private external fun initHybrid(): HybridData
 
diff --git a/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/HybridCactusImageSpec.kt b/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/HybridCactusImageSpec.kt
index 8c3c59f..4c3b1b1 100644
--- a/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/HybridCactusImageSpec.kt
+++ b/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/HybridCactusImageSpec.kt
@@ -2,7 +2,7 @@
 /// HybridCactusImageSpec.kt
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 package com.margelo.nitro.cactus
diff --git a/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/cactusOnLoad.kt b/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/cactusOnLoad.kt
index 33407f1..6516167 100644
--- a/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/cactusOnLoad.kt
+++ b/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/cactusOnLoad.kt
@@ -2,7 +2,7 @@
 /// cactusOnLoad.kt
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 package com.margelo.nitro.cactus
diff --git a/nitrogen/generated/ios/Cactus+autolinking.rb b/nitrogen/generated/ios/Cactus+autolinking.rb
index ef5bb65..42c6020 100644
--- a/nitrogen/generated/ios/Cactus+autolinking.rb
+++ b/nitrogen/generated/ios/Cactus+autolinking.rb
@@ -2,7 +2,7 @@
 # Cactus+autolinking.rb
 # This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 # https://github.com/mrousavy/nitro
-# Copyright © 2025 Marc Rousavy @ Margelo
+# Copyright © 2026 Marc Rousavy @ Margelo
 #
 
 # This is a Ruby script that adds all files generated by Nitrogen
diff --git a/nitrogen/generated/ios/Cactus-Swift-Cxx-Bridge.cpp b/nitrogen/generated/ios/Cactus-Swift-Cxx-Bridge.cpp
index d92a84e..cf7f87d 100644
--- a/nitrogen/generated/ios/Cactus-Swift-Cxx-Bridge.cpp
+++ b/nitrogen/generated/ios/Cactus-Swift-Cxx-Bridge.cpp
@@ -2,7 +2,7 @@
 /// Cactus-Swift-Cxx-Bridge.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #include "Cactus-Swift-Cxx-Bridge.hpp"
diff --git a/nitrogen/generated/ios/Cactus-Swift-Cxx-Bridge.hpp b/nitrogen/generated/ios/Cactus-Swift-Cxx-Bridge.hpp
index e8b5528..a1f872d 100644
--- a/nitrogen/generated/ios/Cactus-Swift-Cxx-Bridge.hpp
+++ b/nitrogen/generated/ios/Cactus-Swift-Cxx-Bridge.hpp
@@ -2,7 +2,7 @@
 /// Cactus-Swift-Cxx-Bridge.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once
diff --git a/nitrogen/generated/ios/Cactus-Swift-Cxx-Umbrella.hpp b/nitrogen/generated/ios/Cactus-Swift-Cxx-Umbrella.hpp
index a282f8a..3b52663 100644
--- a/nitrogen/generated/ios/Cactus-Swift-Cxx-Umbrella.hpp
+++ b/nitrogen/generated/ios/Cactus-Swift-Cxx-Umbrella.hpp
@@ -2,7 +2,7 @@
 /// Cactus-Swift-Cxx-Umbrella.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once
diff --git a/nitrogen/generated/ios/CactusAutolinking.mm b/nitrogen/generated/ios/CactusAutolinking.mm
index df85cb1..3755e77 100644
--- a/nitrogen/generated/ios/CactusAutolinking.mm
+++ b/nitrogen/generated/ios/CactusAutolinking.mm
@@ -2,7 +2,7 @@
 /// CactusAutolinking.mm
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #import <Foundation/Foundation.h>
@@ -11,6 +11,7 @@
 #import <type_traits>
 
 #include "HybridCactus.hpp"
+#include "HybridCactusIndex.hpp"
 #include "HybridCactusUtil.hpp"
 #include "HybridCactusFileSystemSpecSwift.hpp"
 #include "HybridCactusCryptoSpecSwift.hpp"
@@ -35,6 +36,15 @@ + (void) load {
       return std::make_shared<HybridCactus>();
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "CactusIndex",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridCactusIndex>,
+                    "The HybridObject \"HybridCactusIndex\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridCactusIndex>();
+    }
+  );
   HybridObjectRegistry::registerHybridObjectConstructor(
     "CactusUtil",
     []() -> std::shared_ptr<HybridObject> {
diff --git a/nitrogen/generated/ios/CactusAutolinking.swift b/nitrogen/generated/ios/CactusAutolinking.swift
index 61bc43b..8529ded 100644
--- a/nitrogen/generated/ios/CactusAutolinking.swift
+++ b/nitrogen/generated/ios/CactusAutolinking.swift
@@ -2,7 +2,7 @@
 /// CactusAutolinking.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 public final class CactusAutolinking {
diff --git a/nitrogen/generated/ios/c++/HybridCactusCryptoSpecSwift.cpp b/nitrogen/generated/ios/c++/HybridCactusCryptoSpecSwift.cpp
index c1fe29e..9c8d33d 100644
--- a/nitrogen/generated/ios/c++/HybridCactusCryptoSpecSwift.cpp
+++ b/nitrogen/generated/ios/c++/HybridCactusCryptoSpecSwift.cpp
@@ -2,7 +2,7 @@
 /// HybridCactusCryptoSpecSwift.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #include "HybridCactusCryptoSpecSwift.hpp"
diff --git a/nitrogen/generated/ios/c++/HybridCactusCryptoSpecSwift.hpp b/nitrogen/generated/ios/c++/HybridCactusCryptoSpecSwift.hpp
index ada8dcf..06bf042 100644
--- a/nitrogen/generated/ios/c++/HybridCactusCryptoSpecSwift.hpp
+++ b/nitrogen/generated/ios/c++/HybridCactusCryptoSpecSwift.hpp
@@ -2,7 +2,7 @@
 /// HybridCactusCryptoSpecSwift.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once
diff --git a/nitrogen/generated/ios/c++/HybridCactusDeviceInfoSpecSwift.cpp b/nitrogen/generated/ios/c++/HybridCactusDeviceInfoSpecSwift.cpp
index d6fbf96..54bd092 100644
--- a/nitrogen/generated/ios/c++/HybridCactusDeviceInfoSpecSwift.cpp
+++ b/nitrogen/generated/ios/c++/HybridCactusDeviceInfoSpecSwift.cpp
@@ -2,7 +2,7 @@
 /// HybridCactusDeviceInfoSpecSwift.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #include "HybridCactusDeviceInfoSpecSwift.hpp"
diff --git a/nitrogen/generated/ios/c++/HybridCactusDeviceInfoSpecSwift.hpp b/nitrogen/generated/ios/c++/HybridCactusDeviceInfoSpecSwift.hpp
index 7726954..fc6479f 100644
--- a/nitrogen/generated/ios/c++/HybridCactusDeviceInfoSpecSwift.hpp
+++ b/nitrogen/generated/ios/c++/HybridCactusDeviceInfoSpecSwift.hpp
@@ -2,7 +2,7 @@
 /// HybridCactusDeviceInfoSpecSwift.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once
diff --git a/nitrogen/generated/ios/c++/HybridCactusFileSystemSpecSwift.cpp b/nitrogen/generated/ios/c++/HybridCactusFileSystemSpecSwift.cpp
index 2b692f9..73f70d2 100644
--- a/nitrogen/generated/ios/c++/HybridCactusFileSystemSpecSwift.cpp
+++ b/nitrogen/generated/ios/c++/HybridCactusFileSystemSpecSwift.cpp
@@ -2,7 +2,7 @@
 /// HybridCactusFileSystemSpecSwift.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #include "HybridCactusFileSystemSpecSwift.hpp"
diff --git a/nitrogen/generated/ios/c++/HybridCactusFileSystemSpecSwift.hpp b/nitrogen/generated/ios/c++/HybridCactusFileSystemSpecSwift.hpp
index 67f2fd6..c82e890 100644
--- a/nitrogen/generated/ios/c++/HybridCactusFileSystemSpecSwift.hpp
+++ b/nitrogen/generated/ios/c++/HybridCactusFileSystemSpecSwift.hpp
@@ -2,7 +2,7 @@
 /// HybridCactusFileSystemSpecSwift.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once
@@ -135,6 +135,14 @@ namespace margelo::nitro::cactus {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<std::string>> getIndexPath(const std::string& name) override {
+      auto __result = _swiftPart.getIndexPath(name);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
     Cactus::HybridCactusFileSystemSpec_cxx _swiftPart;
diff --git a/nitrogen/generated/ios/c++/HybridCactusImageSpecSwift.cpp b/nitrogen/generated/ios/c++/HybridCactusImageSpecSwift.cpp
index 7fab65e..fafd487 100644
--- a/nitrogen/generated/ios/c++/HybridCactusImageSpecSwift.cpp
+++ b/nitrogen/generated/ios/c++/HybridCactusImageSpecSwift.cpp
@@ -2,7 +2,7 @@
 /// HybridCactusImageSpecSwift.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #include "HybridCactusImageSpecSwift.hpp"
diff --git a/nitrogen/generated/ios/c++/HybridCactusImageSpecSwift.hpp b/nitrogen/generated/ios/c++/HybridCactusImageSpecSwift.hpp
index 54165e9..35f073d 100644
--- a/nitrogen/generated/ios/c++/HybridCactusImageSpecSwift.hpp
+++ b/nitrogen/generated/ios/c++/HybridCactusImageSpecSwift.hpp
@@ -2,7 +2,7 @@
 /// HybridCactusImageSpecSwift.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once
diff --git a/nitrogen/generated/ios/swift/DeviceInfo.swift b/nitrogen/generated/ios/swift/DeviceInfo.swift
index 320b3b1..9146b80 100644
--- a/nitrogen/generated/ios/swift/DeviceInfo.swift
+++ b/nitrogen/generated/ios/swift/DeviceInfo.swift
@@ -2,7 +2,7 @@
 /// DeviceInfo.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 import NitroModules
diff --git a/nitrogen/generated/ios/swift/Func_void.swift b/nitrogen/generated/ios/swift/Func_void.swift
index 7ca9920..862b9e4 100644
--- a/nitrogen/generated/ios/swift/Func_void.swift
+++ b/nitrogen/generated/ios/swift/Func_void.swift
@@ -2,7 +2,7 @@
 /// Func_void.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 import NitroModules
diff --git a/nitrogen/generated/ios/swift/Func_void_DeviceInfo.swift b/nitrogen/generated/ios/swift/Func_void_DeviceInfo.swift
index 7c09b7f..cbad44c 100644
--- a/nitrogen/generated/ios/swift/Func_void_DeviceInfo.swift
+++ b/nitrogen/generated/ios/swift/Func_void_DeviceInfo.swift
@@ -2,7 +2,7 @@
 /// Func_void_DeviceInfo.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 import NitroModules
diff --git a/nitrogen/generated/ios/swift/Func_void_bool.swift b/nitrogen/generated/ios/swift/Func_void_bool.swift
index c0f3f98..4b4ad4e 100644
--- a/nitrogen/generated/ios/swift/Func_void_bool.swift
+++ b/nitrogen/generated/ios/swift/Func_void_bool.swift
@@ -2,7 +2,7 @@
 /// Func_void_bool.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 import NitroModules
diff --git a/nitrogen/generated/ios/swift/Func_void_double.swift b/nitrogen/generated/ios/swift/Func_void_double.swift
index 162b575..c2c37a3 100644
--- a/nitrogen/generated/ios/swift/Func_void_double.swift
+++ b/nitrogen/generated/ios/swift/Func_void_double.swift
@@ -2,7 +2,7 @@
 /// Func_void_double.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 import NitroModules
diff --git a/nitrogen/generated/ios/swift/Func_void_std__exception_ptr.swift b/nitrogen/generated/ios/swift/Func_void_std__exception_ptr.swift
index d962273..5a3d463 100644
--- a/nitrogen/generated/ios/swift/Func_void_std__exception_ptr.swift
+++ b/nitrogen/generated/ios/swift/Func_void_std__exception_ptr.swift
@@ -2,7 +2,7 @@
 /// Func_void_std__exception_ptr.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 import NitroModules
diff --git a/nitrogen/generated/ios/swift/Func_void_std__optional_std__string_.swift b/nitrogen/generated/ios/swift/Func_void_std__optional_std__string_.swift
index caa6264..7c9ff4d 100644
--- a/nitrogen/generated/ios/swift/Func_void_std__optional_std__string_.swift
+++ b/nitrogen/generated/ios/swift/Func_void_std__optional_std__string_.swift
@@ -2,7 +2,7 @@
 /// Func_void_std__optional_std__string_.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 import NitroModules
diff --git a/nitrogen/generated/ios/swift/Func_void_std__string.swift b/nitrogen/generated/ios/swift/Func_void_std__string.swift
index e830183..a9ea936 100644
--- a/nitrogen/generated/ios/swift/Func_void_std__string.swift
+++ b/nitrogen/generated/ios/swift/Func_void_std__string.swift
@@ -2,7 +2,7 @@
 /// Func_void_std__string.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 import NitroModules
diff --git a/nitrogen/generated/ios/swift/HybridCactusCryptoSpec.swift b/nitrogen/generated/ios/swift/HybridCactusCryptoSpec.swift
index 5d8483d..cdd1f03 100644
--- a/nitrogen/generated/ios/swift/HybridCactusCryptoSpec.swift
+++ b/nitrogen/generated/ios/swift/HybridCactusCryptoSpec.swift
@@ -2,7 +2,7 @@
 /// HybridCactusCryptoSpec.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 import Foundation
diff --git a/nitrogen/generated/ios/swift/HybridCactusCryptoSpec_cxx.swift b/nitrogen/generated/ios/swift/HybridCactusCryptoSpec_cxx.swift
index 0ac56af..b45729c 100644
--- a/nitrogen/generated/ios/swift/HybridCactusCryptoSpec_cxx.swift
+++ b/nitrogen/generated/ios/swift/HybridCactusCryptoSpec_cxx.swift
@@ -2,7 +2,7 @@
 /// HybridCactusCryptoSpec_cxx.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 import Foundation
diff --git a/nitrogen/generated/ios/swift/HybridCactusDeviceInfoSpec.swift b/nitrogen/generated/ios/swift/HybridCactusDeviceInfoSpec.swift
index 3668c22..1a2e37c 100644
--- a/nitrogen/generated/ios/swift/HybridCactusDeviceInfoSpec.swift
+++ b/nitrogen/generated/ios/swift/HybridCactusDeviceInfoSpec.swift
@@ -2,7 +2,7 @@
 /// HybridCactusDeviceInfoSpec.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 import Foundation
diff --git a/nitrogen/generated/ios/swift/HybridCactusDeviceInfoSpec_cxx.swift b/nitrogen/generated/ios/swift/HybridCactusDeviceInfoSpec_cxx.swift
index d7db34f..da5d4da 100644
--- a/nitrogen/generated/ios/swift/HybridCactusDeviceInfoSpec_cxx.swift
+++ b/nitrogen/generated/ios/swift/HybridCactusDeviceInfoSpec_cxx.swift
@@ -2,7 +2,7 @@
 /// HybridCactusDeviceInfoSpec_cxx.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 import Foundation
diff --git a/nitrogen/generated/ios/swift/HybridCactusFileSystemSpec.swift b/nitrogen/generated/ios/swift/HybridCactusFileSystemSpec.swift
index b50d4fc..d50648f 100644
--- a/nitrogen/generated/ios/swift/HybridCactusFileSystemSpec.swift
+++ b/nitrogen/generated/ios/swift/HybridCactusFileSystemSpec.swift
@@ -2,7 +2,7 @@
 /// HybridCactusFileSystemSpec.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 import Foundation
@@ -24,6 +24,7 @@ public protocol HybridCactusFileSystemSpec_protocol: HybridObject {
   func getModelPath(model: String) throws -> Promise<String>
   func downloadModel(model: String, from: String, callback: ((_ progress: Double) -> Void)?) throws -> Promise<Void>
   func deleteModel(model: String) throws -> Promise<Void>
+  func getIndexPath(name: String) throws -> Promise<String>
 }
 
 public extension HybridCactusFileSystemSpec_protocol {
diff --git a/nitrogen/generated/ios/swift/HybridCactusFileSystemSpec_cxx.swift b/nitrogen/generated/ios/swift/HybridCactusFileSystemSpec_cxx.swift
index ea67672..7945cc7 100644
--- a/nitrogen/generated/ios/swift/HybridCactusFileSystemSpec_cxx.swift
+++ b/nitrogen/generated/ios/swift/HybridCactusFileSystemSpec_cxx.swift
@@ -2,7 +2,7 @@
 /// HybridCactusFileSystemSpec_cxx.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 import Foundation
@@ -300,4 +300,23 @@ open class HybridCactusFileSystemSpec_cxx {
       return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
+  
+  @inline(__always)
+  public final func getIndexPath(name: std.string) -> bridge.Result_std__shared_ptr_Promise_std__string___ {
+    do {
+      let __result = try self.__implementation.getIndexPath(name: String(name))
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__string__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__string__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__string__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(std.string(__result)) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_std__string___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_std__string___(__exceptionPtr)
+    }
+  }
 }
diff --git a/nitrogen/generated/ios/swift/HybridCactusImageSpec.swift b/nitrogen/generated/ios/swift/HybridCactusImageSpec.swift
index fee2d8e..3536078 100644
--- a/nitrogen/generated/ios/swift/HybridCactusImageSpec.swift
+++ b/nitrogen/generated/ios/swift/HybridCactusImageSpec.swift
@@ -2,7 +2,7 @@
 /// HybridCactusImageSpec.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 import Foundation
diff --git a/nitrogen/generated/ios/swift/HybridCactusImageSpec_cxx.swift b/nitrogen/generated/ios/swift/HybridCactusImageSpec_cxx.swift
index 659e6ad..ab56d85 100644
--- a/nitrogen/generated/ios/swift/HybridCactusImageSpec_cxx.swift
+++ b/nitrogen/generated/ios/swift/HybridCactusImageSpec_cxx.swift
@@ -2,7 +2,7 @@
 /// HybridCactusImageSpec_cxx.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 import Foundation
diff --git a/nitrogen/generated/shared/c++/CactusIndexGetResult.hpp b/nitrogen/generated/shared/c++/CactusIndexGetResult.hpp
new file mode 100644
index 0000000..c255807
--- /dev/null
+++ b/nitrogen/generated/shared/c++/CactusIndexGetResult.hpp
@@ -0,0 +1,84 @@
+///
+/// CactusIndexGetResult.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::cactus {
+
+  /**
+   * A struct which can be represented as a JavaScript object (CactusIndexGetResult).
+   */
+  struct CactusIndexGetResult {
+  public:
+    std::vector<std::string> documents     SWIFT_PRIVATE;
+    std::vector<std::string> metadatas     SWIFT_PRIVATE;
+    std::vector<std::vector<double>> embeddings     SWIFT_PRIVATE;
+
+  public:
+    CactusIndexGetResult() = default;
+    explicit CactusIndexGetResult(std::vector<std::string> documents, std::vector<std::string> metadatas, std::vector<std::vector<double>> embeddings): documents(documents), metadatas(metadatas), embeddings(embeddings) {}
+  };
+
+} // namespace margelo::nitro::cactus
+
+namespace margelo::nitro {
+
+  // C++ CactusIndexGetResult <> JS CactusIndexGetResult (object)
+  template <>
+  struct JSIConverter<margelo::nitro::cactus::CactusIndexGetResult> final {
+    static inline margelo::nitro::cactus::CactusIndexGetResult fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::cactus::CactusIndexGetResult(
+        JSIConverter<std::vector<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "documents")),
+        JSIConverter<std::vector<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "metadatas")),
+        JSIConverter<std::vector<std::vector<double>>>::fromJSI(runtime, obj.getProperty(runtime, "embeddings"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::cactus::CactusIndexGetResult& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "documents", JSIConverter<std::vector<std::string>>::toJSI(runtime, arg.documents));
+      obj.setProperty(runtime, "metadatas", JSIConverter<std::vector<std::string>>::toJSI(runtime, arg.metadatas));
+      obj.setProperty(runtime, "embeddings", JSIConverter<std::vector<std::vector<double>>>::toJSI(runtime, arg.embeddings));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::vector<std::string>>::canConvert(runtime, obj.getProperty(runtime, "documents"))) return false;
+      if (!JSIConverter<std::vector<std::string>>::canConvert(runtime, obj.getProperty(runtime, "metadatas"))) return false;
+      if (!JSIConverter<std::vector<std::vector<double>>>::canConvert(runtime, obj.getProperty(runtime, "embeddings"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro
diff --git a/nitrogen/generated/shared/c++/CactusIndexQueryResult.hpp b/nitrogen/generated/shared/c++/CactusIndexQueryResult.hpp
new file mode 100644
index 0000000..5f7246f
--- /dev/null
+++ b/nitrogen/generated/shared/c++/CactusIndexQueryResult.hpp
@@ -0,0 +1,79 @@
+///
+/// CactusIndexQueryResult.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <vector>
+
+namespace margelo::nitro::cactus {
+
+  /**
+   * A struct which can be represented as a JavaScript object (CactusIndexQueryResult).
+   */
+  struct CactusIndexQueryResult {
+  public:
+    std::vector<std::vector<double>> ids     SWIFT_PRIVATE;
+    std::vector<std::vector<double>> scores     SWIFT_PRIVATE;
+
+  public:
+    CactusIndexQueryResult() = default;
+    explicit CactusIndexQueryResult(std::vector<std::vector<double>> ids, std::vector<std::vector<double>> scores): ids(ids), scores(scores) {}
+  };
+
+} // namespace margelo::nitro::cactus
+
+namespace margelo::nitro {
+
+  // C++ CactusIndexQueryResult <> JS CactusIndexQueryResult (object)
+  template <>
+  struct JSIConverter<margelo::nitro::cactus::CactusIndexQueryResult> final {
+    static inline margelo::nitro::cactus::CactusIndexQueryResult fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::cactus::CactusIndexQueryResult(
+        JSIConverter<std::vector<std::vector<double>>>::fromJSI(runtime, obj.getProperty(runtime, "ids")),
+        JSIConverter<std::vector<std::vector<double>>>::fromJSI(runtime, obj.getProperty(runtime, "scores"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::cactus::CactusIndexQueryResult& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "ids", JSIConverter<std::vector<std::vector<double>>>::toJSI(runtime, arg.ids));
+      obj.setProperty(runtime, "scores", JSIConverter<std::vector<std::vector<double>>>::toJSI(runtime, arg.scores));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::vector<std::vector<double>>>::canConvert(runtime, obj.getProperty(runtime, "ids"))) return false;
+      if (!JSIConverter<std::vector<std::vector<double>>>::canConvert(runtime, obj.getProperty(runtime, "scores"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro
diff --git a/nitrogen/generated/shared/c++/DeviceInfo.hpp b/nitrogen/generated/shared/c++/DeviceInfo.hpp
index 9c001a8..5ca1b50 100644
--- a/nitrogen/generated/shared/c++/DeviceInfo.hpp
+++ b/nitrogen/generated/shared/c++/DeviceInfo.hpp
@@ -2,7 +2,7 @@
 /// DeviceInfo.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once
diff --git a/nitrogen/generated/shared/c++/HybridCactusCryptoSpec.cpp b/nitrogen/generated/shared/c++/HybridCactusCryptoSpec.cpp
index 28126be..d31738f 100644
--- a/nitrogen/generated/shared/c++/HybridCactusCryptoSpec.cpp
+++ b/nitrogen/generated/shared/c++/HybridCactusCryptoSpec.cpp
@@ -2,7 +2,7 @@
 /// HybridCactusCryptoSpec.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #include "HybridCactusCryptoSpec.hpp"
diff --git a/nitrogen/generated/shared/c++/HybridCactusCryptoSpec.hpp b/nitrogen/generated/shared/c++/HybridCactusCryptoSpec.hpp
index ba5a711..8251f2d 100644
--- a/nitrogen/generated/shared/c++/HybridCactusCryptoSpec.hpp
+++ b/nitrogen/generated/shared/c++/HybridCactusCryptoSpec.hpp
@@ -2,7 +2,7 @@
 /// HybridCactusCryptoSpec.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once
diff --git a/nitrogen/generated/shared/c++/HybridCactusDeviceInfoSpec.cpp b/nitrogen/generated/shared/c++/HybridCactusDeviceInfoSpec.cpp
index c9d6a38..a6a54a9 100644
--- a/nitrogen/generated/shared/c++/HybridCactusDeviceInfoSpec.cpp
+++ b/nitrogen/generated/shared/c++/HybridCactusDeviceInfoSpec.cpp
@@ -2,7 +2,7 @@
 /// HybridCactusDeviceInfoSpec.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #include "HybridCactusDeviceInfoSpec.hpp"
diff --git a/nitrogen/generated/shared/c++/HybridCactusDeviceInfoSpec.hpp b/nitrogen/generated/shared/c++/HybridCactusDeviceInfoSpec.hpp
index c3f84bc..5d9fb43 100644
--- a/nitrogen/generated/shared/c++/HybridCactusDeviceInfoSpec.hpp
+++ b/nitrogen/generated/shared/c++/HybridCactusDeviceInfoSpec.hpp
@@ -2,7 +2,7 @@
 /// HybridCactusDeviceInfoSpec.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once
diff --git a/nitrogen/generated/shared/c++/HybridCactusFileSystemSpec.cpp b/nitrogen/generated/shared/c++/HybridCactusFileSystemSpec.cpp
index e24a06d..f62c8ad 100644
--- a/nitrogen/generated/shared/c++/HybridCactusFileSystemSpec.cpp
+++ b/nitrogen/generated/shared/c++/HybridCactusFileSystemSpec.cpp
@@ -2,7 +2,7 @@
 /// HybridCactusFileSystemSpec.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #include "HybridCactusFileSystemSpec.hpp"
@@ -23,6 +23,7 @@ namespace margelo::nitro::cactus {
       prototype.registerHybridMethod("getModelPath", &HybridCactusFileSystemSpec::getModelPath);
       prototype.registerHybridMethod("downloadModel", &HybridCactusFileSystemSpec::downloadModel);
       prototype.registerHybridMethod("deleteModel", &HybridCactusFileSystemSpec::deleteModel);
+      prototype.registerHybridMethod("getIndexPath", &HybridCactusFileSystemSpec::getIndexPath);
     });
   }
 
diff --git a/nitrogen/generated/shared/c++/HybridCactusFileSystemSpec.hpp b/nitrogen/generated/shared/c++/HybridCactusFileSystemSpec.hpp
index d390dd6..479138f 100644
--- a/nitrogen/generated/shared/c++/HybridCactusFileSystemSpec.hpp
+++ b/nitrogen/generated/shared/c++/HybridCactusFileSystemSpec.hpp
@@ -2,7 +2,7 @@
 /// HybridCactusFileSystemSpec.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once
@@ -60,6 +60,7 @@ namespace margelo::nitro::cactus {
       virtual std::shared_ptr<Promise<std::string>> getModelPath(const std::string& model) = 0;
       virtual std::shared_ptr<Promise<void>> downloadModel(const std::string& model, const std::string& from, const std::optional<std::function<void(double /* progress */)>>& callback) = 0;
       virtual std::shared_ptr<Promise<void>> deleteModel(const std::string& model) = 0;
+      virtual std::shared_ptr<Promise<std::string>> getIndexPath(const std::string& name) = 0;
 
     protected:
       // Hybrid Setup
diff --git a/nitrogen/generated/shared/c++/HybridCactusImageSpec.cpp b/nitrogen/generated/shared/c++/HybridCactusImageSpec.cpp
index 39c333e..8f02c2d 100644
--- a/nitrogen/generated/shared/c++/HybridCactusImageSpec.cpp
+++ b/nitrogen/generated/shared/c++/HybridCactusImageSpec.cpp
@@ -2,7 +2,7 @@
 /// HybridCactusImageSpec.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #include "HybridCactusImageSpec.hpp"
diff --git a/nitrogen/generated/shared/c++/HybridCactusImageSpec.hpp b/nitrogen/generated/shared/c++/HybridCactusImageSpec.hpp
index c9cbd54..a144967 100644
--- a/nitrogen/generated/shared/c++/HybridCactusImageSpec.hpp
+++ b/nitrogen/generated/shared/c++/HybridCactusImageSpec.hpp
@@ -2,7 +2,7 @@
 /// HybridCactusImageSpec.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once
diff --git a/nitrogen/generated/shared/c++/HybridCactusIndexSpec.cpp b/nitrogen/generated/shared/c++/HybridCactusIndexSpec.cpp
new file mode 100644
index 0000000..0df4e40
--- /dev/null
+++ b/nitrogen/generated/shared/c++/HybridCactusIndexSpec.cpp
@@ -0,0 +1,27 @@
+///
+/// HybridCactusIndexSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridCactusIndexSpec.hpp"
+
+namespace margelo::nitro::cactus {
+
+  void HybridCactusIndexSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("init", &HybridCactusIndexSpec::init);
+      prototype.registerHybridMethod("add", &HybridCactusIndexSpec::add);
+      prototype.registerHybridMethod("_delete", &HybridCactusIndexSpec::_delete);
+      prototype.registerHybridMethod("get", &HybridCactusIndexSpec::get);
+      prototype.registerHybridMethod("query", &HybridCactusIndexSpec::query);
+      prototype.registerHybridMethod("compact", &HybridCactusIndexSpec::compact);
+      prototype.registerHybridMethod("destroy", &HybridCactusIndexSpec::destroy);
+    });
+  }
+
+} // namespace margelo::nitro::cactus
diff --git a/nitrogen/generated/shared/c++/HybridCactusIndexSpec.hpp b/nitrogen/generated/shared/c++/HybridCactusIndexSpec.hpp
new file mode 100644
index 0000000..ee2aa3e
--- /dev/null
+++ b/nitrogen/generated/shared/c++/HybridCactusIndexSpec.hpp
@@ -0,0 +1,76 @@
+///
+/// HybridCactusIndexSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `CactusIndexGetResult` to properly resolve imports.
+namespace margelo::nitro::cactus { struct CactusIndexGetResult; }
+// Forward declaration of `CactusIndexQueryResult` to properly resolve imports.
+namespace margelo::nitro::cactus { struct CactusIndexQueryResult; }
+
+#include <NitroModules/Promise.hpp>
+#include <string>
+#include <vector>
+#include <optional>
+#include "CactusIndexGetResult.hpp"
+#include "CactusIndexQueryResult.hpp"
+
+namespace margelo::nitro::cactus {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `CactusIndex`
+   * Inherit this class to create instances of `HybridCactusIndexSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCactusIndex: public HybridCactusIndexSpec {
+   * public:
+   *   HybridCactusIndex(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCactusIndexSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCactusIndexSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCactusIndexSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<void>> init(const std::string& indexPath, double embeddingDim) = 0;
+      virtual 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) = 0;
+      virtual std::shared_ptr<Promise<void>> _delete(const std::vector<double>& ids) = 0;
+      virtual std::shared_ptr<Promise<CactusIndexGetResult>> get(const std::vector<double>& ids) = 0;
+      virtual std::shared_ptr<Promise<CactusIndexQueryResult>> query(const std::vector<std::vector<double>>& embeddings, const std::optional<std::string>& optionsJson) = 0;
+      virtual std::shared_ptr<Promise<void>> compact() = 0;
+      virtual std::shared_ptr<Promise<void>> destroy() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "CactusIndex";
+  };
+
+} // namespace margelo::nitro::cactus
diff --git a/nitrogen/generated/shared/c++/HybridCactusSpec.cpp b/nitrogen/generated/shared/c++/HybridCactusSpec.cpp
index b164ed2..19f73fc 100644
--- a/nitrogen/generated/shared/c++/HybridCactusSpec.cpp
+++ b/nitrogen/generated/shared/c++/HybridCactusSpec.cpp
@@ -2,7 +2,7 @@
 /// HybridCactusSpec.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #include "HybridCactusSpec.hpp"
@@ -16,6 +16,8 @@ namespace margelo::nitro::cactus {
     registerHybrids(this, [](Prototype& prototype) {
       prototype.registerHybridMethod("init", &HybridCactusSpec::init);
       prototype.registerHybridMethod("complete", &HybridCactusSpec::complete);
+      prototype.registerHybridMethod("tokenize", &HybridCactusSpec::tokenize);
+      prototype.registerHybridMethod("scoreWindow", &HybridCactusSpec::scoreWindow);
       prototype.registerHybridMethod("transcribe", &HybridCactusSpec::transcribe);
       prototype.registerHybridMethod("embed", &HybridCactusSpec::embed);
       prototype.registerHybridMethod("imageEmbed", &HybridCactusSpec::imageEmbed);
diff --git a/nitrogen/generated/shared/c++/HybridCactusSpec.hpp b/nitrogen/generated/shared/c++/HybridCactusSpec.hpp
index 19c8b24..c2bfa1b 100644
--- a/nitrogen/generated/shared/c++/HybridCactusSpec.hpp
+++ b/nitrogen/generated/shared/c++/HybridCactusSpec.hpp
@@ -2,7 +2,7 @@
 /// HybridCactusSpec.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once
@@ -20,6 +20,7 @@
 #include <optional>
 #include <functional>
 #include <vector>
+#include <variant>
 
 namespace margelo::nitro::cactus {
 
@@ -54,8 +55,10 @@ namespace margelo::nitro::cactus {
       // Methods
       virtual std::shared_ptr<Promise<void>> init(const std::string& modelPath, double contextSize, const std::optional<std::string>& corpusDir) = 0;
       virtual std::shared_ptr<Promise<std::string>> complete(const std::string& messagesJson, double responseBufferSize, const std::optional<std::string>& optionsJson, const std::optional<std::string>& toolsJson, const std::optional<std::function<void(const std::string& /* token */, double /* tokenId */)>>& callback) = 0;
-      virtual 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::optional<std::function<void(const std::string& /* token */, double /* tokenId */)>>& callback) = 0;
-      virtual std::shared_ptr<Promise<std::vector<double>>> embed(const std::string& text, double embeddingBufferSize) = 0;
+      virtual std::shared_ptr<Promise<std::vector<double>>> tokenize(const std::string& text) = 0;
+      virtual std::shared_ptr<Promise<std::string>> scoreWindow(const std::vector<double>& tokens, double start, double end, double context) = 0;
+      virtual std::shared_ptr<Promise<std::string>> transcribe(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) = 0;
+      virtual std::shared_ptr<Promise<std::vector<double>>> embed(const std::string& text, double embeddingBufferSize, bool normalize) = 0;
       virtual std::shared_ptr<Promise<std::vector<double>>> imageEmbed(const std::string& imagePath, double embeddingBufferSize) = 0;
       virtual std::shared_ptr<Promise<std::vector<double>>> audioEmbed(const std::string& audioPath, double embeddingBufferSize) = 0;
       virtual std::shared_ptr<Promise<void>> reset() = 0;
diff --git a/nitrogen/generated/shared/c++/HybridCactusUtilSpec.cpp b/nitrogen/generated/shared/c++/HybridCactusUtilSpec.cpp
index f70b3b4..090054f 100644
--- a/nitrogen/generated/shared/c++/HybridCactusUtilSpec.cpp
+++ b/nitrogen/generated/shared/c++/HybridCactusUtilSpec.cpp
@@ -2,7 +2,7 @@
 /// HybridCactusUtilSpec.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #include "HybridCactusUtilSpec.hpp"
diff --git a/nitrogen/generated/shared/c++/HybridCactusUtilSpec.hpp b/nitrogen/generated/shared/c++/HybridCactusUtilSpec.hpp
index 2a8ba30..b10bb91 100644
--- a/nitrogen/generated/shared/c++/HybridCactusUtilSpec.hpp
+++ b/nitrogen/generated/shared/c++/HybridCactusUtilSpec.hpp
@@ -2,7 +2,7 @@
 /// HybridCactusUtilSpec.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
 #pragma once
@@ -51,7 +51,7 @@ namespace margelo::nitro::cactus {
     public:
       // Methods
       virtual std::shared_ptr<Promise<std::string>> registerApp(const std::string& encryptedData) = 0;
-      virtual std::shared_ptr<Promise<std::optional<std::string>>> getDeviceId() = 0;
+      virtual std::shared_ptr<Promise<std::optional<std::string>>> getDeviceId(const std::optional<std::string>& token) = 0;
       virtual std::shared_ptr<Promise<void>> setAndroidDataDirectory(const std::string& dataDir) = 0;
 
     protected:
diff --git a/package.json b/package.json
index ac11c61..bc6f2bf 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "cactus-react-native",
-  "version": "1.2.1",
+  "version": "1.4.0",
   "description": "Run AI models locally on mobile devices",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -83,7 +83,7 @@
     "react": "19.1.0",
     "react-native": "0.81.1",
     "react-native-builder-bob": "^0.40.14",
-    "react-native-nitro-modules": "^0.31.3",
+    "react-native-nitro-modules": "^0.31.10",
     "release-it": "^19.0.4",
     "turbo": "^2.5.6",
     "typescript": "^5.9.2"
diff --git a/src/api/Database.ts b/src/api/Database.ts
index 212f529..4406421 100644
--- a/src/api/Database.ts
+++ b/src/api/Database.ts
@@ -4,6 +4,7 @@ import type { LogRecord } from '../telemetry/Telemetry';
 import { packageVersion } from '../constants/packageVersion';
 import type { CactusModel } from '../types/CactusModel';
 import type { CactusSTTModel } from '../types/CactusSTTModel';
+import { CactusConfig } from '../config/CactusConfig';
 
 interface CactusModelResponse {
   name: string;
@@ -47,12 +48,23 @@ export class Database {
     }
   }
 
-  public static async registerDevice(device_data: DeviceInfo): Promise<string> {
+  public static async registerDevice({
+    deviceData,
+    deviceId,
+  }: {
+    deviceData?: DeviceInfo;
+    deviceId?: string;
+  }): Promise<string> {
     const response = await fetch(
       `${this.url}/functions/v1/device-registration`,
       {
         method: 'POST',
-        body: JSON.stringify({ device_data }),
+        body: JSON.stringify({
+          device_data: deviceData,
+          device_id: deviceId,
+          cactus_pro_key: CactusConfig.cactusProKey,
+        }),
+        headers: { 'Content-Type': 'application/json' },
       }
     );
 
diff --git a/src/classes/CactusIndex.ts b/src/classes/CactusIndex.ts
new file mode 100644
index 0000000..9b93f53
--- /dev/null
+++ b/src/classes/CactusIndex.ts
@@ -0,0 +1,58 @@
+import { CactusIndex as NativeCactusIndex, CactusFileSystem } from '../native';
+import type {
+  CactusIndexAddParams,
+  CactusIndexGetParams,
+  CactusIndexGetResult,
+  CactusIndexQueryParams,
+  CactusIndexQueryResult,
+  CactusIndexDeleteParams,
+} from '../types/CactusIndex';
+
+export class CactusIndex {
+  private readonly cactusIndex = new NativeCactusIndex();
+
+  private readonly name: string;
+  private readonly embeddingDim: number;
+
+  constructor(name: string, embeddingDim: number) {
+    this.name = name;
+    this.embeddingDim = embeddingDim;
+  }
+
+  public async init(): Promise<void> {
+    const indexPath = await CactusFileSystem.getIndexPath(this.name);
+    return this.cactusIndex.init(indexPath, this.embeddingDim);
+  }
+
+  public add({
+    ids,
+    documents,
+    embeddings,
+    metadatas,
+  }: CactusIndexAddParams): Promise<void> {
+    return this.cactusIndex.add(ids, documents, embeddings, metadatas);
+  }
+
+  public delete({ ids }: CactusIndexDeleteParams): Promise<void> {
+    return this.cactusIndex.delete(ids);
+  }
+
+  public get({ ids }: CactusIndexGetParams): Promise<CactusIndexGetResult> {
+    return this.cactusIndex.get(ids);
+  }
+
+  public query({
+    embeddings,
+    options,
+  }: CactusIndexQueryParams): Promise<CactusIndexQueryResult> {
+    return this.cactusIndex.query(embeddings, options);
+  }
+
+  public compact(): Promise<void> {
+    return this.cactusIndex.compact();
+  }
+
+  public destroy(): Promise<void> {
+    return this.cactusIndex.destroy();
+  }
+}
diff --git a/src/classes/CactusLM.ts b/src/classes/CactusLM.ts
index 3b6f604..121acdc 100644
--- a/src/classes/CactusLM.ts
+++ b/src/classes/CactusLM.ts
@@ -3,6 +3,10 @@ import type {
   CactusLMDownloadParams,
   CactusLMCompleteParams,
   CactusLMCompleteResult,
+  CactusLMTokenizeParams,
+  CactusLMTokenizeResult,
+  CactusLMScoreWindowParams,
+  CactusLMScoreWindowResult,
   CactusLMEmbedParams,
   CactusLMEmbedResult,
   CactusLMImageEmbedParams,
@@ -46,6 +50,11 @@ export class CactusLM {
   public async download({
     onProgress,
   }: CactusLMDownloadParams = {}): Promise<void> {
+    if (this.isModelPath(this.model)) {
+      onProgress?.(1.0);
+      return;
+    }
+
     if (this.isDownloading) {
       throw new Error('CactusLM is already downloading');
     }
@@ -73,12 +82,16 @@ export class CactusLM {
       return;
     }
 
-    if (!(await CactusFileSystem.modelExists(this.model))) {
-      throw new Error(`Model "${this.model}" is not downloaded`);
+    let modelPath: string;
+    if (this.isModelPath(this.model)) {
+      modelPath = this.model.replace('file://', '');
+    } else {
+      if (!(await CactusFileSystem.modelExists(this.model))) {
+        throw new Error(`Model "${this.model}" is not downloaded`);
+      }
+      modelPath = await CactusFileSystem.getModelPath(this.model);
     }
 
-    const modelPath = await CactusFileSystem.getModelPath(this.model);
-
     try {
       await this.cactus.init(modelPath, this.contextSize, this.corpusDir);
       Telemetry.logInit(this.model, true);
@@ -153,8 +166,26 @@ export class CactusLM {
     }
   }
 
+  public async tokenize({
+    text,
+  }: CactusLMTokenizeParams): Promise<CactusLMTokenizeResult> {
+    return { tokens: await this.cactus.tokenize(text) };
+  }
+
+  public async scoreWindow({
+    tokens,
+    start,
+    end,
+    context,
+  }: CactusLMScoreWindowParams): Promise<CactusLMScoreWindowResult> {
+    return {
+      score: await this.cactus.scoreWindow(tokens, start, end, context),
+    };
+  }
+
   public async embed({
     text,
+    normalize = false,
   }: CactusLMEmbedParams): Promise<CactusLMEmbedResult> {
     if (this.isGenerating) {
       throw new Error('CactusLM is already generating');
@@ -166,7 +197,8 @@ export class CactusLM {
     try {
       const embedding = await this.cactus.embed(
         text,
-        CactusLM.defaultEmbedBufferSize
+        CactusLM.defaultEmbedBufferSize,
+        normalize
       );
       Telemetry.logEmbedding(this.model, true);
       return { embedding };
@@ -230,4 +262,8 @@ export class CactusLM {
     }
     return models;
   }
+
+  private isModelPath(model: string): boolean {
+    return model.startsWith('file://') || model.startsWith('/');
+  }
 }
diff --git a/src/classes/CactusSTT.ts b/src/classes/CactusSTT.ts
index ed672b2..8dc6328 100644
--- a/src/classes/CactusSTT.ts
+++ b/src/classes/CactusSTT.ts
@@ -42,6 +42,11 @@ export class CactusSTT {
   public async download({
     onProgress,
   }: CactusSTTDownloadParams = {}): Promise<void> {
+    if (this.isModelPath(this.model)) {
+      onProgress?.(1.0);
+      return;
+    }
+
     if (this.isDownloading) {
       throw new Error('CactusSTT is already downloading');
     }
@@ -69,12 +74,16 @@ export class CactusSTT {
       return;
     }
 
-    if (!(await CactusFileSystem.modelExists(this.model))) {
-      throw new Error(`Model "${this.model}" is not downloaded`);
+    let modelPath: string;
+    if (this.isModelPath(this.model)) {
+      modelPath = this.model.replace('file://', '');
+    } else {
+      if (!(await CactusFileSystem.modelExists(this.model))) {
+        throw new Error(`Model "${this.model}" is not downloaded`);
+      }
+      modelPath = await CactusFileSystem.getModelPath(this.model);
     }
 
-    const modelPath = await CactusFileSystem.getModelPath(this.model);
-
     try {
       await this.cactus.init(modelPath, this.contextSize);
       Telemetry.logInit(this.model, true);
@@ -86,7 +95,7 @@ export class CactusSTT {
   }
 
   public async transcribe({
-    audioFilePath,
+    audio,
     prompt,
     options,
     onToken,
@@ -107,7 +116,7 @@ export class CactusSTT {
     this.isGenerating = true;
     try {
       const result = await this.cactus.transcribe(
-        audioFilePath,
+        audio,
         prompt,
         responseBufferSize,
         options,
@@ -180,4 +189,8 @@ export class CactusSTT {
     }
     return models;
   }
+
+  private isModelPath(model: string): boolean {
+    return model.startsWith('file://') || model.startsWith('/');
+  }
 }
diff --git a/src/config/CactusConfig.ts b/src/config/CactusConfig.ts
index aa6bc56..9413705 100644
--- a/src/config/CactusConfig.ts
+++ b/src/config/CactusConfig.ts
@@ -5,4 +5,7 @@ export class CactusConfig {
 
   // Hybrid mode
   public static cactusToken?: string;
+
+  // Pro features
+  public static cactusProKey?: string;
 }
diff --git a/src/constants/packageVersion.ts b/src/constants/packageVersion.ts
index 9652abd..5c5cf97 100644
--- a/src/constants/packageVersion.ts
+++ b/src/constants/packageVersion.ts
@@ -1 +1 @@
-export const packageVersion = '1.2.1';
+export const packageVersion = '1.4.0';
diff --git a/src/hooks/useCactusIndex.ts b/src/hooks/useCactusIndex.ts
new file mode 100644
index 0000000..a0f0a00
--- /dev/null
+++ b/src/hooks/useCactusIndex.ts
@@ -0,0 +1,195 @@
+import { useCallback, useEffect, useState } from 'react';
+import { CactusIndex } from '../classes/CactusIndex';
+import { getErrorMessage } from '../utils/error';
+import type {
+  CactusIndexParams,
+  CactusIndexAddParams,
+  CactusIndexGetParams,
+  CactusIndexGetResult,
+  CactusIndexQueryParams,
+  CactusIndexQueryResult,
+  CactusIndexDeleteParams,
+} from '../types/CactusIndex';
+
+export const useCactusIndex = ({ name, embeddingDim }: CactusIndexParams) => {
+  const [cactusIndex, setCactusIndex] = useState(
+    () => new CactusIndex(name, embeddingDim)
+  );
+
+  // State
+  const [isInitializing, setIsInitializing] = useState(false);
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    setCactusIndex(new CactusIndex(name, embeddingDim));
+
+    setIsInitializing(false);
+    setIsProcessing(false);
+    setError(null);
+  }, [name, embeddingDim]);
+
+  useEffect(() => {
+    return () => {
+      cactusIndex.destroy().catch(() => {});
+    };
+  }, [cactusIndex]);
+
+  const init = useCallback(async () => {
+    if (isInitializing) {
+      const message = 'CactusIndex is already initializing';
+      setError(message);
+      throw new Error(message);
+    }
+
+    setError(null);
+    setIsInitializing(true);
+    try {
+      await cactusIndex.init();
+    } catch (e) {
+      setError(getErrorMessage(e));
+      throw e;
+    } finally {
+      setIsInitializing(false);
+    }
+  }, [cactusIndex, isInitializing]);
+
+  const add = useCallback(
+    async ({
+      ids,
+      documents,
+      metadatas,
+      embeddings,
+    }: CactusIndexAddParams): Promise<void> => {
+      if (isProcessing) {
+        const message = 'CactusIndex is already processing';
+        setError(message);
+        throw new Error(message);
+      }
+
+      setError(null);
+      setIsProcessing(true);
+      try {
+        await cactusIndex.add({ ids, documents, metadatas, embeddings });
+      } catch (e) {
+        setError(getErrorMessage(e));
+        throw e;
+      } finally {
+        setIsProcessing(false);
+      }
+    },
+    [cactusIndex, isProcessing]
+  );
+
+  const _delete = useCallback(
+    async ({ ids }: CactusIndexDeleteParams): Promise<void> => {
+      if (isProcessing) {
+        const message = 'CactusIndex is already processing';
+        setError(message);
+        throw new Error(message);
+      }
+
+      setError(null);
+      setIsProcessing(true);
+      try {
+        await cactusIndex.delete({ ids });
+      } catch (e) {
+        setError(getErrorMessage(e));
+        throw e;
+      } finally {
+        setIsProcessing(false);
+      }
+    },
+    [cactusIndex, isProcessing]
+  );
+
+  const get = useCallback(
+    async ({ ids }: CactusIndexGetParams): Promise<CactusIndexGetResult> => {
+      if (isProcessing) {
+        const message = 'CactusIndex is already processing';
+        setError(message);
+        throw new Error(message);
+      }
+
+      setError(null);
+      setIsProcessing(true);
+      try {
+        return await cactusIndex.get({ ids });
+      } catch (e) {
+        setError(getErrorMessage(e));
+        throw e;
+      } finally {
+        setIsProcessing(false);
+      }
+    },
+    [cactusIndex, isProcessing]
+  );
+
+  const query = useCallback(
+    async ({
+      embeddings,
+      options,
+    }: CactusIndexQueryParams): Promise<CactusIndexQueryResult> => {
+      if (isProcessing) {
+        const message = 'CactusIndex is already processing';
+        setError(message);
+        throw new Error(message);
+      }
+
+      setError(null);
+      setIsProcessing(true);
+      try {
+        return await cactusIndex.query({ embeddings, options });
+      } catch (e) {
+        setError(getErrorMessage(e));
+        throw e;
+      } finally {
+        setIsProcessing(false);
+      }
+    },
+    [cactusIndex, isProcessing]
+  );
+
+  const compact = useCallback(async () => {
+    if (isProcessing) {
+      const message = 'CactusIndex is already processing';
+      setError(message);
+      throw new Error(message);
+    }
+
+    setError(null);
+    setIsProcessing(true);
+    try {
+      await cactusIndex.compact();
+    } catch (e) {
+      setError(getErrorMessage(e));
+      throw e;
+    } finally {
+      setIsProcessing(false);
+    }
+  }, [cactusIndex, isProcessing]);
+
+  const destroy = useCallback(async () => {
+    setError(null);
+    try {
+      await cactusIndex.destroy();
+    } catch (e) {
+      setError(getErrorMessage(e));
+      throw e;
+    }
+  }, [cactusIndex]);
+
+  return {
+    isInitializing,
+    isProcessing,
+    error,
+
+    init,
+    add,
+    delete: _delete,
+    get,
+    query,
+    compact,
+    destroy,
+  };
+};
diff --git a/src/hooks/useCactusLM.ts b/src/hooks/useCactusLM.ts
index 5a7e951..5cc486a 100644
--- a/src/hooks/useCactusLM.ts
+++ b/src/hooks/useCactusLM.ts
@@ -4,12 +4,16 @@ import { CactusFileSystem } from '../native';
 import { getErrorMessage } from '../utils/error';
 import type {
   CactusLMParams,
+  CactusLMCompleteParams,
   CactusLMCompleteResult,
+  CactusLMTokenizeParams,
+  CactusLMTokenizeResult,
+  CactusLMScoreWindowParams,
+  CactusLMScoreWindowResult,
   CactusLMEmbedParams,
   CactusLMEmbedResult,
   CactusLMImageEmbedParams,
   CactusLMImageEmbedResult,
-  CactusLMCompleteParams,
   CactusLMDownloadParams,
 } from '../types/CactusLM';
 import type { CactusModel } from '../types/CactusModel';
@@ -201,8 +205,62 @@ export const useCactusLM = ({
     [cactusLM, isGenerating]
   );
 
+  const tokenize = useCallback(
+    async ({
+      text,
+    }: CactusLMTokenizeParams): Promise<CactusLMTokenizeResult> => {
+      if (isGenerating) {
+        const message = 'CactusLM is already generating';
+        setError(message);
+        throw new Error(message);
+      }
+
+      setError(null);
+      setIsGenerating(true);
+      try {
+        return await cactusLM.tokenize({ text });
+      } catch (e) {
+        setError(getErrorMessage(e));
+        throw e;
+      } finally {
+        setIsGenerating(false);
+      }
+    },
+    [cactusLM, isGenerating]
+  );
+
+  const scoreWindow = useCallback(
+    async ({
+      tokens,
+      start,
+      end,
+      context,
+    }: CactusLMScoreWindowParams): Promise<CactusLMScoreWindowResult> => {
+      if (isGenerating) {
+        const message = 'CactusLM is already generating';
+        setError(message);
+        throw new Error(message);
+      }
+
+      setError(null);
+      setIsGenerating(true);
+      try {
+        return await cactusLM.scoreWindow({ tokens, start, end, context });
+      } catch (e) {
+        setError(getErrorMessage(e));
+        throw e;
+      } finally {
+        setIsGenerating(false);
+      }
+    },
+    [cactusLM, isGenerating]
+  );
+
   const embed = useCallback(
-    async ({ text }: CactusLMEmbedParams): Promise<CactusLMEmbedResult> => {
+    async ({
+      text,
+      normalize = false,
+    }: CactusLMEmbedParams): Promise<CactusLMEmbedResult> => {
       if (isGenerating) {
         const message = 'CactusLM is already generating';
         setError(message);
@@ -212,7 +270,7 @@ export const useCactusLM = ({
       setError(null);
       setIsGenerating(true);
       try {
-        return await cactusLM.embed({ text });
+        return await cactusLM.embed({ text, normalize });
       } catch (e) {
         setError(getErrorMessage(e));
         throw e;
@@ -303,6 +361,8 @@ export const useCactusLM = ({
     download,
     init,
     complete,
+    tokenize,
+    scoreWindow,
     embed,
     imageEmbed,
     reset,
diff --git a/src/hooks/useCactusSTT.ts b/src/hooks/useCactusSTT.ts
index df7dd4b..acb1c4f 100644
--- a/src/hooks/useCactusSTT.ts
+++ b/src/hooks/useCactusSTT.ts
@@ -162,7 +162,7 @@ export const useCactusSTT = ({
 
   const transcribe = useCallback(
     async ({
-      audioFilePath,
+      audio,
       prompt,
       options,
       onToken,
@@ -178,7 +178,7 @@ export const useCactusSTT = ({
       setIsGenerating(true);
       try {
         return await cactusSTT.transcribe({
-          audioFilePath,
+          audio,
           prompt,
           options,
           onToken: (token) => {
diff --git a/src/index.tsx b/src/index.tsx
index fc28c4b..5ed424e 100644
--- a/src/index.tsx
+++ b/src/index.tsx
@@ -1,10 +1,12 @@
 // Classes
 export { CactusLM } from './classes/CactusLM';
 export { CactusSTT } from './classes/CactusSTT';
+export { CactusIndex } from './classes/CactusIndex';
 
 // Hooks
 export { useCactusLM } from './hooks/useCactusLM';
 export { useCactusSTT } from './hooks/useCactusSTT';
+export { useCactusIndex } from './hooks/useCactusIndex';
 
 // Types
 export type { CactusModel } from './types/CactusModel';
@@ -17,6 +19,10 @@ export type {
   Tool,
   CactusLMCompleteParams,
   CactusLMCompleteResult,
+  CactusLMTokenizeParams,
+  CactusLMTokenizeResult,
+  CactusLMScoreWindowParams,
+  CactusLMScoreWindowResult,
   CactusLMEmbedParams,
   CactusLMEmbedResult,
   CactusLMImageEmbedParams,
@@ -31,6 +37,16 @@ export type {
   CactusSTTAudioEmbedParams,
   CactusSTTAudioEmbedResult,
 } from './types/CactusSTT';
+export type {
+  CactusIndexParams,
+  CactusIndexAddParams,
+  CactusIndexGetParams,
+  CactusIndexGetResult,
+  IndexQueryOptions,
+  CactusIndexQueryParams,
+  CactusIndexQueryResult,
+  CactusIndexDeleteParams,
+} from './types/CactusIndex';
 
 // Config
 export { CactusConfig } from './config/CactusConfig';
diff --git a/src/native/Cactus.ts b/src/native/Cactus.ts
index d2e3e10..f75ed35 100644
--- a/src/native/Cactus.ts
+++ b/src/native/Cactus.ts
@@ -32,15 +32,9 @@ export class Cactus {
     callback?: (token: string, tokenId: number) => void
   ): Promise<CactusLMCompleteResult> {
     const messagesInternal: Message[] = [];
-    for (let i = 0; i < messages.length; i++) {
-      const message = messages[i]!;
-      const isLastMessage = i === messages.length - 1;
-
-      if (!message.images || !isLastMessage) {
-        messagesInternal.push({
-          ...message,
-          images: undefined,
-        });
+    for (const message of messages) {
+      if (!message.images) {
+        messagesInternal.push(message);
         continue;
       }
 
@@ -66,6 +60,7 @@ export class Cactus {
           top_k: options.topK,
           max_tokens: options.maxTokens,
           stop_sequences: options.stopSequences,
+          force_tools: options.forceTools,
         })
       : undefined;
     const toolsJson = JSON.stringify(tools);
@@ -97,13 +92,41 @@ export class Cactus {
     }
   }
 
+  public tokenize(text: string): Promise<number[]> {
+    return this.hybridCactus.tokenize(text);
+  }
+
+  public async scoreWindow(
+    tokens: number[],
+    start: number,
+    end: number,
+    context: number
+  ): Promise<number> {
+    const response = await this.hybridCactus.scoreWindow(
+      tokens,
+      start,
+      end,
+      context
+    );
+    try {
+      const parsed = JSON.parse(response);
+      return parsed.logprob;
+    } catch {
+      throw new Error('Unable to parse score window response');
+    }
+  }
+
   public async transcribe(
-    audioFilePath: string,
+    audio: string | number[],
     prompt: string,
     responseBufferSize: number,
     options?: TranscribeOptions,
     callback?: (token: string, tokenId: number) => void
   ): Promise<CactusSTTTranscribeResult> {
+    if (typeof audio === 'string') {
+      audio = audio.replace('file://', '');
+    }
+
     const optionsJson = options
       ? JSON.stringify({
           temperature: options.temperature,
@@ -115,7 +138,7 @@ export class Cactus {
       : undefined;
 
     const response = await this.hybridCactus.transcribe(
-      audioFilePath.replace('file://', ''),
+      audio,
       prompt,
       responseBufferSize,
       optionsJson,
@@ -140,8 +163,12 @@ export class Cactus {
     }
   }
 
-  public embed(text: string, embeddingBufferSize: number): Promise<number[]> {
-    return this.hybridCactus.embed(text, embeddingBufferSize);
+  public embed(
+    text: string,
+    embeddingBufferSize: number,
+    normalize: boolean
+  ): Promise<number[]> {
+    return this.hybridCactus.embed(text, embeddingBufferSize, normalize);
   }
 
   public async imageEmbed(
diff --git a/src/native/CactusFileSystem.ts b/src/native/CactusFileSystem.ts
index 054ef64..0ab4cfd 100644
--- a/src/native/CactusFileSystem.ts
+++ b/src/native/CactusFileSystem.ts
@@ -33,6 +33,10 @@ export class CactusFileSystem {
     return this.hybridCactusFileSystem.getModelPath(model);
   }
 
+  public static getIndexPath(name: string): Promise<string> {
+    return this.hybridCactusFileSystem.getIndexPath(name);
+  }
+
   public static downloadModel(
     model: string,
     url: string,
diff --git a/src/native/CactusIndex.ts b/src/native/CactusIndex.ts
new file mode 100644
index 0000000..da4f39e
--- /dev/null
+++ b/src/native/CactusIndex.ts
@@ -0,0 +1,54 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import type { CactusIndex as CactusIndexSpec } from '../specs/CactusIndex.nitro';
+import type {
+  CactusIndexGetResult,
+  CactusIndexQueryResult,
+  IndexQueryOptions,
+} from '../types/CactusIndex';
+
+export class CactusIndex {
+  private readonly hybridCactusIndex =
+    NitroModules.createHybridObject<CactusIndexSpec>('CactusIndex');
+
+  public init(indexPath: string, embeddingDim: number): Promise<void> {
+    return this.hybridCactusIndex.init(indexPath, embeddingDim);
+  }
+
+  public add(
+    ids: number[],
+    documents: string[],
+    embeddings: number[][],
+    metadatas?: string[]
+  ): Promise<void> {
+    return this.hybridCactusIndex.add(ids, documents, embeddings, metadatas);
+  }
+
+  public delete(ids: number[]): Promise<void> {
+    return this.hybridCactusIndex._delete(ids);
+  }
+
+  public get(ids: number[]): Promise<CactusIndexGetResult> {
+    return this.hybridCactusIndex.get(ids);
+  }
+
+  public query(
+    embeddings: number[][],
+    options?: IndexQueryOptions
+  ): Promise<CactusIndexQueryResult> {
+    const optionsJson = options
+      ? JSON.stringify({
+          top_k: options.topK,
+          score_threshold: options.scoreThreshold,
+        })
+      : undefined;
+    return this.hybridCactusIndex.query(embeddings, optionsJson);
+  }
+
+  public compact(): Promise<void> {
+    return this.hybridCactusIndex.compact();
+  }
+
+  public destroy(): Promise<void> {
+    return this.hybridCactusIndex.destroy();
+  }
+}
diff --git a/src/native/CactusUtil.ts b/src/native/CactusUtil.ts
index a32ebd7..cd0de7d 100644
--- a/src/native/CactusUtil.ts
+++ b/src/native/CactusUtil.ts
@@ -2,6 +2,8 @@ import { NitroModules } from 'react-native-nitro-modules';
 import type { CactusUtil as CactusUtilSpec } from '../specs/CactusUtil.nitro';
 import { Platform } from 'react-native';
 import { CactusFileSystem } from './CactusFileSystem';
+import { CactusConfig } from '../config/CactusConfig';
+import { Database } from '../api/Database';
 
 export class CactusUtil {
   private static readonly hybridCactusUtil =
@@ -10,7 +12,7 @@ export class CactusUtil {
   public static async registerApp(encryptedData: string): Promise<string> {
     if (Platform.OS === 'android') {
       const cactusDirectory = await CactusFileSystem.getCactusDirectory();
-      this.hybridCactusUtil.setAndroidDataDirectory(cactusDirectory);
+      await this.hybridCactusUtil.setAndroidDataDirectory(cactusDirectory);
     }
 
     return this.hybridCactusUtil.registerApp(encryptedData);
@@ -19,9 +21,23 @@ export class CactusUtil {
   public static async getDeviceId(): Promise<string | null> {
     if (Platform.OS === 'android') {
       const cactusDirectory = await CactusFileSystem.getCactusDirectory();
-      this.hybridCactusUtil.setAndroidDataDirectory(cactusDirectory);
+      await this.hybridCactusUtil.setAndroidDataDirectory(cactusDirectory);
     }
 
-    return this.hybridCactusUtil.getDeviceId();
+    const deviceId = await this.hybridCactusUtil.getDeviceId(
+      CactusConfig.cactusProKey
+    );
+
+    if (!deviceId) {
+      return null;
+    }
+
+    if (deviceId?.indexOf('|') !== -1) {
+      const parts = deviceId.split('|');
+      CactusConfig.cactusProKey = parts[1];
+      return await Database.registerDevice({ deviceId: parts[0] });
+    }
+
+    return deviceId;
   }
 }
diff --git a/src/native/index.ts b/src/native/index.ts
index b9b94de..43c946e 100644
--- a/src/native/index.ts
+++ b/src/native/index.ts
@@ -1,4 +1,5 @@
 export { Cactus } from './Cactus';
+export { CactusIndex } from './CactusIndex';
 export { CactusCrypto } from './CactusCrypto';
 export { CactusDeviceInfo } from './CactusDeviceInfo';
 export { CactusFileSystem } from './CactusFileSystem';
diff --git a/src/specs/Cactus.nitro.ts b/src/specs/Cactus.nitro.ts
index 7abd820..a373113 100644
--- a/src/specs/Cactus.nitro.ts
+++ b/src/specs/Cactus.nitro.ts
@@ -13,14 +13,25 @@ export interface Cactus extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
     toolsJson?: string,
     callback?: (token: string, tokenId: number) => void
   ): Promise<string>;
+  tokenize(text: string): Promise<number[]>;
+  scoreWindow(
+    tokens: number[],
+    start: number,
+    end: number,
+    context: number
+  ): Promise<string>;
   transcribe(
-    audioFilePath: string,
+    audio: string | number[],
     prompt: string,
     responseBufferSize: number,
     optionsJson?: string,
     callback?: (token: string, tokenId: number) => void
   ): Promise<string>;
-  embed(text: string, embeddingBufferSize: number): Promise<number[]>;
+  embed(
+    text: string,
+    embeddingBufferSize: number,
+    normalize: boolean
+  ): Promise<number[]>;
   imageEmbed(imagePath: string, embeddingBufferSize: number): Promise<number[]>;
   audioEmbed(audioPath: string, embeddingBufferSize: number): Promise<number[]>;
   reset(): Promise<void>;
diff --git a/src/specs/CactusFileSystem.nitro.ts b/src/specs/CactusFileSystem.nitro.ts
index 6fc988d..b0bdbcc 100644
--- a/src/specs/CactusFileSystem.nitro.ts
+++ b/src/specs/CactusFileSystem.nitro.ts
@@ -18,4 +18,6 @@ export interface CactusFileSystem
     callback?: (progress: number) => void
   ): Promise<void>;
   deleteModel(model: string): Promise<void>;
+  // Index
+  getIndexPath(name: string): Promise<string>;
 }
diff --git a/src/specs/CactusIndex.nitro.ts b/src/specs/CactusIndex.nitro.ts
new file mode 100644
index 0000000..23fa80b
--- /dev/null
+++ b/src/specs/CactusIndex.nitro.ts
@@ -0,0 +1,31 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+interface CactusIndexGetResult {
+  documents: string[];
+  metadatas: string[];
+  embeddings: number[][];
+}
+
+interface CactusIndexQueryResult {
+  ids: number[][];
+  scores: number[][];
+}
+
+export interface CactusIndex
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  init(indexPath: string, embeddingDim: number): Promise<void>;
+  add(
+    ids: number[],
+    documents: string[],
+    embeddings: number[][],
+    metadatas?: string[]
+  ): Promise<void>;
+  _delete(ids: number[]): Promise<void>;
+  get(ids: number[]): Promise<CactusIndexGetResult>;
+  query(
+    embeddings: number[][],
+    optionsJson?: string
+  ): Promise<CactusIndexQueryResult>;
+  compact(): Promise<void>;
+  destroy(): Promise<void>;
+}
diff --git a/src/specs/CactusUtil.nitro.ts b/src/specs/CactusUtil.nitro.ts
index d312ac8..d311fdd 100644
--- a/src/specs/CactusUtil.nitro.ts
+++ b/src/specs/CactusUtil.nitro.ts
@@ -3,6 +3,6 @@ import type { HybridObject } from 'react-native-nitro-modules';
 export interface CactusUtil
   extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
   registerApp(encryptedData: string): Promise<string>;
-  getDeviceId(): Promise<string | null>;
+  getDeviceId(token?: string): Promise<string | null>;
   setAndroidDataDirectory(dataDir: string): Promise<void>;
 }
diff --git a/src/telemetry/Telemetry.ts b/src/telemetry/Telemetry.ts
index 273886c..270a7a4 100644
--- a/src/telemetry/Telemetry.ts
+++ b/src/telemetry/Telemetry.ts
@@ -110,7 +110,7 @@ export class Telemetry {
     try {
       this.deviceId =
         (await CactusUtil.getDeviceId()) ??
-        (await Database.registerDevice(deviceInfo));
+        (await Database.registerDevice({ deviceData: deviceInfo }));
     } catch (error) {
       console.log(error);
     }
diff --git a/src/types/CactusIndex.ts b/src/types/CactusIndex.ts
new file mode 100644
index 0000000..4198313
--- /dev/null
+++ b/src/types/CactusIndex.ts
@@ -0,0 +1,40 @@
+export interface CactusIndexParams {
+  name: string;
+  embeddingDim: number;
+}
+
+export interface CactusIndexAddParams {
+  ids: number[];
+  documents: string[];
+  embeddings: number[][];
+  metadatas?: string[];
+}
+
+export interface CactusIndexGetParams {
+  ids: number[];
+}
+
+export interface CactusIndexGetResult {
+  documents: string[];
+  metadatas: string[];
+  embeddings: number[][];
+}
+
+export interface IndexQueryOptions {
+  topK?: number;
+  scoreThreshold?: number;
+}
+
+export interface CactusIndexQueryParams {
+  embeddings: number[][];
+  options?: IndexQueryOptions;
+}
+
+export interface CactusIndexQueryResult {
+  ids: number[][];
+  scores: number[][];
+}
+
+export interface CactusIndexDeleteParams {
+  ids: number[];
+}
diff --git a/src/types/CactusLM.ts b/src/types/CactusLM.ts
index bb4eab5..6d59fc8 100644
--- a/src/types/CactusLM.ts
+++ b/src/types/CactusLM.ts
@@ -20,6 +20,7 @@ export interface CompleteOptions {
   topK?: number;
   maxTokens?: number;
   stopSequences?: string[];
+  forceTools?: boolean;
 }
 
 export interface Tool {
@@ -60,8 +61,28 @@ export interface CactusLMCompleteResult {
   totalTokens: number;
 }
 
+export interface CactusLMTokenizeParams {
+  text: string;
+}
+
+export interface CactusLMTokenizeResult {
+  tokens: number[];
+}
+
+export interface CactusLMScoreWindowParams {
+  tokens: number[];
+  start: number;
+  end: number;
+  context: number;
+}
+
+export interface CactusLMScoreWindowResult {
+  score: number;
+}
+
 export interface CactusLMEmbedParams {
   text: string;
+  normalize?: boolean;
 }
 
 export interface CactusLMEmbedResult {
diff --git a/src/types/CactusSTT.ts b/src/types/CactusSTT.ts
index 8ba12d9..9153bfa 100644
--- a/src/types/CactusSTT.ts
+++ b/src/types/CactusSTT.ts
@@ -16,7 +16,7 @@ export interface TranscribeOptions {
 }
 
 export interface CactusSTTTranscribeParams {
-  audioFilePath: string;
+  audio: string | number[];
   prompt?: string;
   options?: TranscribeOptions;
   onToken?: (token: string) => void;
diff --git a/yarn.lock b/yarn.lock
index 7c91d4c..de2f3dc 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -4423,7 +4423,7 @@ __metadata:
     react: 19.1.0
     react-native: 0.81.1
     react-native-builder-bob: ^0.40.14
-    react-native-nitro-modules: ^0.31.3
+    react-native-nitro-modules: ^0.31.10
     release-it: ^19.0.4
     turbo: ^2.5.6
     typescript: ^5.9.2
@@ -10236,6 +10236,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"react-native-nitro-modules@npm:^0.31.10":
+  version: 0.31.10
+  resolution: "react-native-nitro-modules@npm:0.31.10"
+  peerDependencies:
+    react: "*"
+    react-native: "*"
+  checksum: 1c8d2f12ff29b6733c784c5fd0dedcbec4ceec9f82eb49f49e7734f31b9367346938010dcacf69bf695a352e36fec5aa23fd57b8091f6acd78c3d9a61e14ea7f
+  languageName: node
+  linkType: hard
+
 "react-native-nitro-modules@npm:^0.31.3, react-native-nitro-modules@npm:^0.31.4":
   version: 0.31.4
   resolution: "react-native-nitro-modules@npm:0.31.4"