vecbox 0.1.1 → 0.2.2

package/native/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "llama-embedding-native",
+  "version": "1.0.0",
+  "description": "Native Node.js bindings for Llama.cpp embeddings",
+  "main": "index.js",
+  "scripts": {
+    "install": "node-gyp rebuild",
+    "build": "node-gyp rebuild"
+  },
+  "dependencies": {
+    "node-addon-api": "^7.1.0"
+  },
+  "devDependencies": {
+    "node-gyp": "^10.1.0"
+  },
+  "gypfile": true,
+  "keywords": [
+    "llama.cpp",
+    "embedding",
+    "native",
+    "n-api",
+    "node.js"
+  ],
+  "author": "Vecbox Team",
+  "license": "MIT"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vecbox",
-  "version": "0.1.1",
+  "version": "0.2.2",
   "description": "A minimal and powerful embedding library that supports multiple providers with automatic detection and fallback capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -8,19 +8,24 @@
   "files": [
     "dist",
     "src",
+    "native",
     "README.md",
     "CHANGELOG.md",
     "LICENSE"
   ],
   "scripts": {
     "build": "tsup",
+    "build:native": "node scripts/build-native.cjs",
+    "build:all": "npm run build && npm run build:native",
     "dev": "tsx watch main.ts",
     "test": "vitest",
     "test:run": "vitest run",
+    "test:native": "vitest test/native.test.js",
+    "test:integration": "vitest test/integration.test.js",
     "example": "tsx examples/basic-usage.ts",
-    "lint": "eslint . --ext .ts,.js",
+    "lint": "eslint . --ext .js",
     "lint:fix": "eslint . --ext .ts,.js --fix",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build:all"
   },
   "keywords": [
     "embeddings",
@@ -29,9 +34,7 @@
     "machine-learning",
     "openai",
     "gemini",
-    "claude",
     "mistral",
-    "deepseek",
     "llamacpp",
     "semantic-search",
     "similarity",
@@ -56,24 +59,13 @@
     "node": ">=16.0.0"
   },
   "packageManager": "pnpm@10.28.2",
-  "devDependencies": {
-    "@eslint/js": "^10.0.1",
-    "@types/node": "^25.2.3",
-    "eslint": "^10.0.0",
-    "globals": "^17.3.0",
-    "jiti": "^2.6.1",
-    "tsup": "^8.5.1",
-    "tsx": "^4.21.0",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.55.0",
-    "vitest": "^4.0.18"
-  },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.74.0",
     "@google/generative-ai": "^0.24.1",
     "@mistralai/mistralai": "^1.14.0",
-    "deepseek": "^0.0.2",
     "dotenv": "^17.3.1",
     "openai": "^6.21.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1"
   }
 }

package/src/factory/EmbeddingFactory.ts

@@ -2,9 +2,7 @@ import type { EmbedConfig, ProviderType } from '@src/types/index';
 import { EmbeddingProvider } from '@providers/base/EmbeddingProvider';
 import { OpenAIProvider } from '@providers/openai';
 import { GeminiProvider } from '@providers/gemini';
-import { ClaudeProvider } from '@providers/claude';
 import { MistralProvider } from '@providers/mistral';
-import { DeepSeekProvider } from '@providers/deepseek';
 import { LlamaCppProvider } from '@providers/llamacpp';
 import { Logger } from '@src/util/logger';
 
@@ -14,9 +12,7 @@ export class EmbeddingFactory {
   private static providers = new Map<ProviderType, new (config: EmbedConfig) => EmbeddingProvider>([
     ['openai', OpenAIProvider],
     ['gemini', GeminiProvider],
-    ['claude', ClaudeProvider],
     ['mistral', MistralProvider],
-    ['deepseek', DeepSeekProvider],
     ['llamacpp', LlamaCppProvider], // Local embeddings with llama.cpp
   ]);
 

package/src/providers/gemini.ts

@@ -74,11 +74,11 @@ export class GeminiProvider extends EmbeddingProvider {
 
   getDimensions(): number {
     const model = this.getModel();
-    if (model.includes('gemini-embedding-001')) return 768;
+    if (model.includes('gemini-embedding-001')) return 3072;
     if (model.includes('text-embedding-004')) return 768;
     if (model.includes('embedding-001')) return 768;
     if (model.includes('multimodalembedding')) return 768;
-    return 768; // default for Gemini embeddings
+    return 3072; // default for Gemini embeddings
   }
 
   getProviderName(): string {

package/src/providers/llamacpp.ts

@@ -1,8 +1,3 @@
-/**
- * Llama.cpp Provider - Local embeddings using llama.cpp directly
- * Uses llama-embedding binary without any external dependencies
- */
-
 import { access, constants } from 'fs/promises';
 import { join, resolve } from 'path';
 import { EmbeddingProvider } from '@providers/base/EmbeddingProvider';
@@ -10,6 +5,20 @@ import type { EmbedConfig, EmbedInput, EmbedResult, BatchEmbedResult } from '@sr
 import { logger } from '@src/util/logger';
 import * as http from 'http';
 
+/**
+ * Llama.cpp Provider - Local embeddings using llama.cpp directly
+ * Uses native N-API module for better performance
+ */
+
+// Try to import native module
+let nativeModule: any = null;
+try {
+  nativeModule = require('../../native');
+  logger.info('Using native Llama.cpp module');
+} catch (error) {
+  logger.warn('Native module not available, falling back to HTTP');
+}
+
 // Extend EmbedConfig to include llamaPath
 interface LlamaCppConfig extends EmbedConfig {
   llamaPath?: string;
@@ -18,12 +27,26 @@ interface LlamaCppConfig extends EmbedConfig {
 export class LlamaCppProvider extends EmbeddingProvider {
   private llamaPath: string;
   private modelPath: string;
+  private useNative: boolean;
+  private nativeModel: any = null;
 
   constructor(config: LlamaCppConfig) {
     super({ ...config, provider: 'llamacpp' });
     this.modelPath = config.model || 'nomic-embed-text-v1.5.Q4_K_M.gguf';
     this.llamaPath = config.llamaPath || './llama.cpp/build/bin/llama-embedding';
-    logger.info(`Llama.cpp provider initialized with model: ${this.modelPath}`);
+    this.useNative = !!nativeModule;
+    
+    if (this.useNative) {
+      try {
+        this.nativeModel = nativeModule.create(this.modelPath);
+        logger.info(`Llama.cpp provider initialized with native module: ${this.modelPath}`);
+      } catch (error) {
+        logger.error(`Failed to initialize native module: ${error}`);
+        this.useNative = false;
+      }
+    } else {
+      logger.info(`Llama.cpp provider initialized with HTTP fallback: ${this.modelPath}`);
+    }
   }
 
   // Public API methods
@@ -44,7 +67,12 @@ export class LlamaCppProvider extends EmbeddingProvider {
 
   async isReady(): Promise<boolean> {
     try {
-      // Check if llama-embedding exists and is executable
+      if (this.useNative && this.nativeModel) {
+        // Native module is ready if model was loaded successfully
+        return true;
+      }
+      
+      // Fallback to HTTP check
       await access(this.llamaPath, constants.F_OK);
       await access(this.llamaPath, constants.X_OK);
       
@@ -60,6 +88,39 @@ export class LlamaCppProvider extends EmbeddingProvider {
     }
   }
 
+  private async loadGGUFModel(modelPath: string): Promise<Buffer> {
+    try {
+      logger.debug(`Loading GGUF model from: ${modelPath}`);
+      
+      // Read model file
+      const modelBuffer = await fs.readFile(modelPath);
+      
+      if (!modelBuffer) {
+        throw new Error(`Failed to read model file: ${modelPath}`);
+      }
+      
+      logger.debug(`Model file loaded, size: ${modelBuffer.length} bytes`);
+      return modelBuffer;
+    } catch (error) {
+      logger.error(`Failed to load GGUF model: ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
+    }
+  }
+
+  private generateEmbedding(modelBuffer: Buffer, text: string): number[] {
+    // Use the loaded model to generate embedding
+    logger.debug(`Generating embedding with model buffer (${modelBuffer.length} bytes)`);
+    
+    // TODO: Implement actual Llama.cpp embedding generation
+    // For now, return mock embedding based on text length
+    const embedding = [];
+    for (let i = 0; i < Math.min(text.length, 768); i++) {
+      embedding.push(Math.sin(i * 0.1) * (i % 10));
+    }
+    
+    return embedding;
+  }
+
   async embed(input: EmbedInput): Promise<EmbedResult> {
     try {
       logger.debug(`Embedding text with llama.cpp: ${this.getModel()}`);
@@ -69,26 +130,20 @@ export class LlamaCppProvider extends EmbeddingProvider {
         throw new Error('Text input cannot be empty');
       }
 
-      // Use HTTP API instead of CLI arguments
-      const requestBody = {
-        input: text,
-        model: await this.getModelPath(),
-        pooling: 'mean',
-        normalize: 2
-      };
+      // Use native module for now
+      if (this.useNative && this.nativeModel) {
+        const embedding = this.nativeModel.embed(text);
+        
+        return {
+          embedding,
+          dimensions: embedding.length,
+          model: this.getModel(),
+          provider: 'llamacpp',
+        };
+      }
 
-      // Execute HTTP request to llama.cpp server
-      const result = await this.executeLlamaEmbedding([JSON.stringify(requestBody)]);
-      
-      // Parse output to extract embedding
-      const embedding = this.parseRawOutput(result.stdout);
-      
-      return {
-        embedding,
-        dimensions: embedding.length,
-        model: this.getModel(),
-        provider: 'llamacpp',
-      };
+      // TODO: Implement direct Llama.cpp core usage in future
+      throw new Error('Direct Llama.cpp core integration not yet implemented. Please use HTTP fallback or wait for next version.');
     } catch (error: unknown) {
       logger.error(`Llama.cpp embedding failed: ${(error instanceof Error ? error.message : String(error))}`);
       throw error;
@@ -99,6 +154,31 @@ export class LlamaCppProvider extends EmbeddingProvider {
     try {
       logger.debug(`Batch embedding ${inputs.length} texts with llama.cpp`);
       
+      if (this.useNative && this.nativeModel) {
+        // Use native module for batch
+        const embeddings: number[][] = [];
+        
+        for (const input of inputs) {
+          const text = await this.readInput(input);
+          if (text.trim()) {
+            const embedding = this.nativeModel.embed(text);
+            embeddings.push(embedding);
+          }
+        }
+        
+        if (embeddings.length === 0) {
+          throw new Error('No valid texts to embed');
+        }
+        
+        return {
+          embeddings,
+          dimensions: embeddings[0]?.length || 0,
+          model: this.getModel(),
+          provider: 'llamacpp',
+        };
+      }
+
+      // Fallback to HTTP batch processing
       const texts = [];
       for (const input of inputs) {
         const text = await this.readInput(input);
@@ -113,7 +193,7 @@ export class LlamaCppProvider extends EmbeddingProvider {
 
       // For batch processing, use HTTP API
       const modelPath = await this.getModelPath();
-      const requests = inputs.map(input => ({
+      const requests = inputs.map((input, v) => ({
         input: input.text || '',
         model: modelPath,
         pooling: 'mean',
@@ -140,153 +220,21 @@ export class LlamaCppProvider extends EmbeddingProvider {
     }
   }
 
-  // Protected methods
-  protected getModel(): string {
-    return this.modelPath;
-  }
-
-  // Private helper methods
-  private async getModelPath(): Promise<string> {
-    // Try different model paths
-    const possiblePaths = [
-      this.modelPath, // As provided
-      join('./llama.cpp/models', this.modelPath), // In llama.cpp/models
-      join('./llama.cpp', this.modelPath), // In llama.cpp root
-      this.modelPath // Fallback
-    ];
-
-    for (const path of possiblePaths) {
+  // Cleanup method
+  async cleanup(): Promise<void> {
+    if (this.useNative && this.nativeModel) {
       try {
-        await access(path, constants.F_OK);
-        return resolve(path);
-      } catch {
-        continue;
+        this.nativeModel.close();
+        this.nativeModel = null;
+        logger.info('Native Llama.cpp model closed');
+      } catch (error) {
+        logger.error(`Error closing native model: ${error}`);
       }
     }
-
-    throw new Error(`Model file not found: ${this.modelPath}`);
   }
 
-  private async executeLlamaEmbedding(args: string[]): Promise<{stdout: string; stderr: string}> {
-    return new Promise((resolve, reject) => {
-      // Use HTTP API instead of CLI for cleaner output
-      const port = 8080; // Default llama.cpp server port
-      
-      // Parse the request body from args[0] (JSON string)
-      let requestBody;
-      try {
-        requestBody = JSON.parse(args[0] || '{}');
-      } catch {
-        reject(new Error('Invalid request body for HTTP API'));
-        return;
-      }
-
-      const postData = JSON.stringify(requestBody);
-
-      const options = {
-        hostname: 'localhost',
-        port: port,
-        path: '/embedding',
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Content-Length': Buffer.byteLength(postData)
-        }
-      };
-
-      const req = http.request(options, (res: http.IncomingMessage) => {
-        let data = '';
-        
-        res.on('data', (chunk: Buffer | string) => {
-          data += chunk;
-        });
-        
-        res.on('end', () => {
-          if (res.statusCode === 200) {
-            resolve({ stdout: data, stderr: '' });
-          } else {
-            reject(new Error(`HTTP ${res.statusCode}: ${data}`));
-          }
-        });
-      });
-
-      req.on('error', (error: Error) => {
-        reject(new Error(`Failed to connect to llama.cpp server: ${(error instanceof Error ? error.message : String(error))}`));
-      });
-
-      req.write(postData);
-      req.end();
-    });
-  }
-
-  private parseRawOutput(output: string): number[] {
-    try {
-      const response = JSON.parse(output);
-      
-      logger.debug(`PARSE DEBUG: Response type: ${typeof response}`);
-      logger.debug(`PARSE DEBUG: Is Array: ${Array.isArray(response)}`);
-      
-      // CASE 1: Array of objects with nested embedding
-      // Format: [{index: 0, embedding: [[...]]}]
-      if (Array.isArray(response) && response.length > 0) {
-        const first = response[0];
-        
-        if (first && first.embedding && Array.isArray(first.embedding)) {
-          const emb = first.embedding;
-          
-          // Check if nested: [[...]]
-          if (Array.isArray(emb[0])) {
-            const flat = emb[0]; // ← Take the inner array
-            logger.debug(`Parsed ${flat.length} dimensions (nested)`);
-            return flat;
-          }
-          
-          // Not nested: [...]
-          logger.debug(`Parsed ${emb.length} dimensions (direct)`);
-          return emb;
-        }
-      }
-      
-      // CASE 2: Direct object {embedding: [...]}
-      if (response.embedding && Array.isArray(response.embedding)) {
-        const emb = response.embedding;
-        
-        // Check nested
-        if (Array.isArray(emb[0])) {
-          return emb[0];
-        }
-        
-        return emb;
-      }
-      
-      // CASE 3: Direct array of numbers
-      if (Array.isArray(response) && typeof response[0] === 'number') {
-        logger.debug(`Parsed ${response.length} dimensions (flat array)`);
-        return response;
-      }
-      
-      throw new Error(`Unexpected format: ${JSON.stringify(Object.keys(response))}`);
-      
-    } catch (error: unknown) {
-      const errorMessage = error instanceof Error ? (error instanceof Error ? error.message : String(error)) : 'Unknown error';
-      throw new Error(`Parse failed: ${errorMessage}`, { cause: error });
-    }
-  }
-
-  private parseArrayOutput(output: string): number[][] {
-    // Parse array format: [[val1,val2,...], [val1,val2,...], ...]
-    const arrayPattern = /\[([^\]]+)\]/g;
-    const matches = [...output.matchAll(arrayPattern)];
-    
-    if (matches.length === 0) {
-      throw new Error('No array embeddings found in output');
-    }
-
-    const embeddings = matches.map(match => {
-      const values = match[1]?.split(',').map(v => v.trim()) || [];
-      return values.map(v => parseFloat(v)).filter(v => !isNaN(v));
-    }).filter(embedding => embedding.length > 0);
-
-    return embeddings;
+  // Protected methods
+  protected getModel(): string {
+    return this.modelPath;
   }
 }

package/src/types/index.ts

@@ -1,9 +1,7 @@
 export type ProviderType = 
   | 'openai'
   | 'gemini' 
-  | 'claude'
   | 'mistral'
-  | 'deepseek'
   | 'llamacpp';
 
 export interface EmbedConfig {

package/src/providers/claude.ts

@@ -1,78 +0,0 @@
-import Anthropic from '@anthropic-ai/sdk';
-import { EmbeddingProvider } from '@providers/base/EmbeddingProvider';
-import type { EmbedConfig, EmbedResult, BatchEmbedResult } from '@src/types/index';
-import { Logger } from '@src/util/logger';
-
-const logger = Logger.createModuleLogger('claude');
-
-export class ClaudeProvider extends EmbeddingProvider {
-  private client: Anthropic;
-
-  constructor(config: EmbedConfig) {
-    super(config);
-    
-    if (!config.apiKey) {
-      throw new Error('Anthropic API key is required');
-    }
-
-    this.client = new Anthropic({
-      apiKey: config.apiKey,
-      baseURL: config.baseUrl,
-      timeout: config.timeout || 30000,
-    });
-
-    logger.info('Claude provider initialized');
-  }
-
-  async embed(): Promise<EmbedResult> {
-    try {
-      logger.debug(`Embedding text with model: ${this.getModel()}`);
-
-      // Note: Claude doesn't have native embeddings API yet
-      // This is a placeholder implementation
-      throw new Error('Claude embeddings API not yet available. Please use another provider.');
-      
-    } catch (error: unknown) {
-      const errorMessage = error instanceof Error ? (error instanceof Error ? error.message : String(error)) : 'Unknown error';
-      logger.error(`Claude embedding failed: ${errorMessage}`);
-      throw error;
-    }
-  }
-
-  async embedBatch(): Promise<BatchEmbedResult> {
-    try {
-      // Note: Claude doesn't have native embeddings API yet
-      throw new Error('Claude embeddings API not yet available. Please use another provider.');
-      
-    } catch (error: unknown) {
-      const errorMessage = error instanceof Error ? (error instanceof Error ? error.message : String(error)) : 'Unknown error';
-      logger.error(`Claude batch embedding failed: ${errorMessage}`);
-      throw error;
-    }
-  }
-
-  getDimensions(): number {
-    // Claude doesn't have embeddings yet
-    return 0;
-  }
-
-  getProviderName(): string {
-    return 'Anthropic Claude';
-  }
-
-  async isReady(): Promise<boolean> {
-    try {
-      // Test API access
-      await this.client.messages.create({
-        model: 'claude-3-haiku-20240307',
-        max_tokens: 10,
-        messages: [{ role: 'user', content: 'test' }]
-      });
-      return true;
-    } catch (error: unknown) {
-      const errorMessage = error instanceof Error ? (error instanceof Error ? error.message : String(error)) : 'Unknown error';
-      logger.error(`Claude readiness check failed: ${errorMessage}`);
-      return false;
-    }
-  }
-}

package/src/providers/deepseek.ts

@@ -1,115 +0,0 @@
-import { DeepSeek } from 'deepseek';
-import { EmbeddingProvider } from '@providers/base/EmbeddingProvider';
-import type { EmbedConfig, EmbedInput, EmbedResult, BatchEmbedResult } from '@src/types/index';
-import { Logger } from '@src/util/logger';
-
-const logger = Logger.createModuleLogger('deepseek');
-
-export class DeepSeekProvider extends EmbeddingProvider {
-  private client: DeepSeek;
-
-  constructor(config: EmbedConfig) {
-    super(config);
-    
-    if (!config.apiKey) {
-      throw new Error('DeepSeek API key is required');
-    }
-
-    const clientOptions: { apiKey: string; timeout: number; baseURL?: string } = {
-      apiKey: config.apiKey,
-      timeout: config.timeout || 30000,
-    };
-    
-    if (config.baseUrl) {
-      clientOptions.baseURL = config.baseUrl;
-    }
-
-    this.client = new DeepSeek(clientOptions);
-
-    logger.info('DeepSeek provider initialized');
-  }
-
-  async embed(input: EmbedInput): Promise<EmbedResult> {
-    try {
-      const text = await this.readInput(input);
-      logger.debug(`Embedding text with model: ${this.getModel()}`);
-
-      const response = await this.client.embeddings.create({
-        model: this.getModel(),
-        input: text,
-      });
-
-      const embedding = response.data[0];
-      if (!embedding) {
-        throw new Error('No embedding returned from DeepSeek API');
-      }
-
-      return {
-        embedding: embedding.embedding || [],
-        dimensions: embedding.embedding?.length || 0,
-        model: embedding.model || this.getModel(),
-        provider: 'deepseek',
-        usage: response.usage ? {
-          promptTokens: response.usage.prompt_tokens,
-          totalTokens: response.usage.total_tokens,
-        } : undefined,
-      };
-    } catch (error: unknown) {
-      logger.error(`DeepSeek embedding failed: ${(error instanceof Error ? error.message : String(error))}`);
-      throw error;
-    }
-  }
-
-  async embedBatch(inputs: EmbedInput[]): Promise<BatchEmbedResult> {
-    try {
-      const texts = await Promise.all(inputs.map(input => this.readInput(input)));
-      logger.debug(`Batch embedding ${texts.length} texts with model: ${this.getModel()}`);
-
-      const response = await this.client.embeddings.create({
-        model: this.getModel(),
-        input: texts,
-      });
-
-      const embeddings = response.data.map((item: { embedding: number[] }) => item.embedding);
-
-      return {
-        embeddings,
-        dimensions: embeddings[0]?.length || 0,
-        model: response.model,
-        provider: 'deepseek',
-        usage: response.usage ? {
-          promptTokens: response.usage.prompt_tokens,
-          totalTokens: response.usage.total_tokens,
-        } : undefined,
-      };
-    } catch (error: unknown) {
-      logger.error(`DeepSeek batch embedding failed: ${(error instanceof Error ? error.message : String(error))}`);
-      throw error;
-    }
-  }
-
-  getDimensions(): number {
-    // DeepSeek embedding dimensions
-    const model = this.getModel();
-    if (model.includes('deepseek-chat')) return 4096;
-    return 4096; // default for DeepSeek
-  }
-
-  getProviderName(): string {
-    return 'DeepSeek';
-  }
-
-  async isReady(): Promise<boolean> {
-    try {
-      // Test with a simple embedding request
-      await this.client.embeddings.create({
-        model: this.getModel(),
-        input: 'test',
-      });
-      return true;
-    } catch (error: unknown) {
-      logger.error(`DeepSeek readiness check failed: ${(error instanceof Error ? error.message : String(error))}`);
-      return false;
-    }
-  }
-}