@rws-framework/ai-tools 3.2.1 → 3.2.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rws-framework/ai-tools",
   "private": false,
-  "version": "3.2.1",
+  "version": "3.2.3",
   "description": "",
   "main": "src/index.ts",
   "scripts": {},

package/src/index.ts

@@ -4,11 +4,11 @@ import { ILLMChunk, IRWSPromptRequestExecutor, IRWSSinglePromptRequestExecutor,
 import { EmbedLoader as RWSEmbed, IConvoDebugXMLData, IEmbeddingsHandler, ISplitterParams } from './models/convo/EmbedLoader';
 import RWSVectorStore from './models/convo/VectorStore';
 import { LangChainEmbeddingService } from './services/LangChainEmbeddingService';
-import { OpenAIRateLimitingService, IRateLimitConfig } from './services/OpenAIRateLimitingService';
+import { OpenAIRateLimitingService } from './services/OpenAIRateLimitingService';
 import { LangChainVectorStoreService, IVectorStoreConfig, IDocumentChunk, IVectorSearchRequest, IVectorSearchResponse, ISearchResult } from './services/LangChainVectorStoreService';
 import { LangChainRAGService, ILangChainRAGConfig, IRAGIndexRequest, IRAGSearchRequest, IRAGResponse, IRAGStats } from './services/LangChainRAGService';
 import { IContextToken } from './types/IContextToken';
-import { IEmbeddingConfig, IChunkConfig } from './types';
+import { IEmbeddingConfig, IChunkConfig, IRateLimitConfig } from './types';
 import type { IAiCfg } from './types/IAiCfg';
 import { z as ZOD } from 'zod/v4';
 
@@ -43,7 +43,7 @@ export {
     // Types
     IEmbeddingConfig,
     IChunkConfig,
-    IRateLimitConfig,
+    IRateLimitConfig,    
     IVectorStoreConfig,
     IDocumentChunk,
     IVectorSearchRequest,

package/src/services/LangChainEmbeddingService.ts

@@ -51,23 +51,21 @@ export class LangChainEmbeddingService {
                     apiKey: this.config.apiKey,
                     model: this.config.model || 'text-embedding-3-large',
                     batchSize: 1 // We'll handle batching ourselves
-                });
-                
-                                
-                this.rateLimitingService.initialize(this.config.model || 'text-embedding-3-large', {
-                    rpm: 500,
-                    tpm: 300_000,
-                    concurrency: 4,
-                    maxRetries: 6,
-                    baseBackoffMs: 500,
-                    safetyFactor: 0.75
-                });
+                });                                
+                        
                 break;    
                 
             default:
                 throw new Error(`Unsupported embedding provider: ${this.config.provider}`);
         }
 
+        if(this.config.rateLimiting){
+            const rateLimitingCfg = {...OpenAIRateLimitingService.DEFAULT_CONFIG, ...this.config.rateLimiting};
+
+            this.rateLimitingService.initialize(this.config.model || 'text-embedding-3-large', rateLimitingCfg);
+            console.log('Inintialized rate limiting with config:', rateLimitingCfg);
+        }     
+
         console.log(`Initialized ${this.config.provider} embeddings with model ${this.config.model}`, this.config.apiKey);
     }
 
@@ -82,7 +80,7 @@ export class LangChainEmbeddingService {
     async embedTexts(texts: string[]): Promise<number[][]> {
         this.ensureInitialized();
         
-        if (this.config.provider === 'openai' && this.rateLimitingService) {
+        if (this.config.rateLimiting) {
             return await this.rateLimitingService.executeWithRateLimit(
                 texts,
                 async (batch: string[]) => {
@@ -102,8 +100,8 @@ export class LangChainEmbeddingService {
     async embedText(text: string): Promise<number[]> {
         this.ensureInitialized();
         
-        if (this.config.provider === 'openai' && this.rateLimitingService) {
-            // For single texts with OpenAI, use the rate-controlled batch method
+        if (this.config.rateLimiting) {
+            
             const results = await this.rateLimitingService.executeWithRateLimit(
                 [text],
                 async (batch: string[]) => {
@@ -125,9 +123,11 @@ export class LangChainEmbeddingService {
         
         // Use our custom TextChunker instead of LangChain's splitter
         // Use safe token limits - the TextChunker handles token estimation internally
-        const maxTokens = 450; // Safe token limit for embedding models
+        const maxTokens = this.chunkConfig?.chunkSize || 450; // Safe token limit for embedding models
         const overlap = this.chunkConfig?.chunkOverlap || 50; // Character overlap, not token
         
+        console.log('[LCEmbeddingService] Chunking with:', this.chunkConfig);
+
         return TextChunker.chunkText(text, maxTokens, overlap);
     }
 

package/src/services/LangChainRAGService.ts

@@ -161,7 +161,7 @@ export class LangChainRAGService {
             const knowledgeVectorPromises = knowledgeIds.map(async (knowledgeId) => {
                 const vectorData = await this.loadKnowledgeVectorWithEmbeddings(knowledgeId);
                 return {
-                    knowledgeId,
+                    knowledgeId,                    
                     chunks: vectorData.chunks
                 };
             });
@@ -178,13 +178,14 @@ export class LangChainRAGService {
             
             // Convert results to expected format
             const results: ISearchResult[] = searchResponse.results.map(result => ({
+                knowledgeId: result.metadata.knowledgeId,
                 content: result.content,
                 score: result.score,
                 metadata: result.metadata,
-                chunkId: result.chunkId
+                chunkId: result.chunkId,                
             }));
 
-            this.log('log', `[SEARCH] Found ${results.length} relevant chunks for query: "${request.query}"`);
+            this.log('log', `[SEARCH] Found ${results.length} relevant chunks for query: "${request.query}"\n`);
 
             return {
                 success: true,
@@ -334,7 +335,7 @@ export class LangChainRAGService {
     /**
      * Load vector data for a specific knowledge item with embeddings
      */
-    private async loadKnowledgeVectorWithEmbeddings(knowledgeId: string | number): Promise<{ chunks: Array<{ content: string; embedding: number[]; metadata: any }> }> {
+    private async loadKnowledgeVectorWithEmbeddings(knowledgeId: string | number): Promise<{ knowledgeId?: string | number, chunks: Array<{ content: string; embedding: number[]; metadata: any }> }> {
         const vectorFilePath = this.getKnowledgeVectorPath(knowledgeId);
         
         if (!fs.existsSync(vectorFilePath)) {
@@ -347,7 +348,8 @@ export class LangChainRAGService {
             const vectorData = JSON.parse(fs.readFileSync(vectorFilePath, 'utf8'));
             
             return {
-                chunks: vectorData.chunks || []
+                chunks: vectorData.chunks || [],
+                knowledgeId
             };
         } catch (error) {
             this.log('error', `[LOAD] Failed to load vector data for knowledge ${knowledgeId}:`, error);

package/src/services/OpenAIRateLimitingService.ts

@@ -1,32 +1,14 @@
 import { Injectable } from '@nestjs/common';
 import PQueue from 'p-queue';
+import { IBatchMetadata, IRateLimitConfig } from '../types/rag.types';
+import tiktoken from 'tiktoken';
 
-// Optional tiktoken import
 let encoding_for_model: any = null;
-try {
-    const tiktoken = require('tiktoken');
-    encoding_for_model = tiktoken.encoding_for_model;
-} catch (e) {
-    console.warn('tiktoken not available, using character-based token estimation');
-}
-
-export interface IRateLimitConfig {
-    rpm?: number;           // Requests per minute
-    tpm?: number;           // Tokens per minute  
-    concurrency?: number;   // Parallel requests
-    maxRetries?: number;    // Maximum retry attempts
-    baseBackoffMs?: number; // Base backoff delay
-    safetyFactor?: number;  // Safety factor for limits
-}
-
-export interface IBatchMetadata<T = any> {
-    start: number;
-    batch: T[];
-}
+encoding_for_model = tiktoken.encoding_for_model
 
 @Injectable()
 export class OpenAIRateLimitingService {
-    private static readonly DEFAULT_CONFIG: Required<IRateLimitConfig> = {
+    static readonly DEFAULT_CONFIG: Required<IRateLimitConfig> = {
         rpm: 500,
         tpm: 300_000,
         concurrency: 4,

package/src/services/OptimizedVectorSearchService.ts

@@ -292,7 +292,8 @@ export class OptimizedVectorSearchService {
                 content: result.content,
                 score: result.score,
                 metadata: result.metadata,
-                chunkId: result.chunkId
+                chunkId: result.chunkId,
+                knowledgeId: result.knowledgeId
             }));
 
             return {

package/src/types/embedding.types.ts

@@ -1,3 +1,5 @@
+import { IRateLimitConfig } from "./rag.types";
+
 /**
  * Embedding service configuration interfaces
  */
@@ -6,6 +8,7 @@ export interface IEmbeddingConfig {
     apiKey: string;
     model?: string;
     batchSize?: number;
+    rateLimiting?: IRateLimitConfig
 }
 
 export interface IChunkConfig {

package/src/types/rag.types.ts

@@ -42,3 +42,17 @@ export interface IRAGStats {
     totalDocuments: number;
     knowledgeItems: number;
 }
+
+export interface IRateLimitConfig {
+    rpm?: number;           // Requests per minute
+    tpm?: number;           // Tokens per minute  
+    concurrency?: number;   // Parallel requests
+    maxRetries?: number;    // Maximum retry attempts
+    baseBackoffMs?: number; // Base backoff delay
+    safetyFactor?: number;  // Safety factor for limits
+}
+
+export interface IBatchMetadata<T = any> {
+    start: number;
+    batch: T[];
+}

package/src/types/search.types.ts

@@ -5,6 +5,7 @@ export interface ISearchResult {
     content: string;
     score: number;
     metadata: any;
+    knowledgeId: string | number;
     chunkId: string;
 }
 
@@ -12,8 +13,7 @@ export interface IVectorSearchRequest {
     query: string;
     maxResults?: number;
     similarityThreshold?: number;
-    filter?: {
-        knowledgeIds?: string[];
+    filter?: {        
         documentIds?: string[];
         [key: string]: any;
     };

package/src/services/examples/OpenAICompletionService.example.ts

@@ -1,110 +0,0 @@
-/**
- * Example usage of OpenAIRateLimitingService for other AI operations
- * 
- * This demonstrates how to use the rate limiting service for:
- * - OpenAI completions
- * - Image generation
- * - Any other OpenAI API calls that need rate limiting
- */
-
-import { OpenAIRateLimitingService, IRateLimitConfig } from '../OpenAIRateLimitingService';
-import { OpenAI } from 'openai';
-
-export class OpenAICompletionService {
-    private rateLimitingService: OpenAIRateLimitingService;
-    private openai: OpenAI;
-
-    constructor(apiKey: string, config?: Partial<IRateLimitConfig>) {
-        this.openai = new OpenAI({ apiKey });
-        this.rateLimitingService = new OpenAIRateLimitingService();
-        
-        // Initialize with model-specific limits
-        this.rateLimitingService.initialize('gpt-4', {
-            rpm: 500,        // Adjust based on your OpenAI plan
-            tpm: 30_000,     // Tokens per minute for GPT-4
-            concurrency: 3,  // Lower concurrency for completion models
-            maxRetries: 5,
-            ...config
-        });
-    }
-
-    /**
-     * Generate completions with rate limiting
-     */
-    async generateCompletions(
-        prompts: string[], 
-        model: string = 'gpt-4-turbo'
-    ): Promise<string[]> {
-        return await this.rateLimitingService.executeWithRateLimit(
-            prompts,
-            async (batch: string[]) => {
-                // Execute batch of completion requests
-                const promises = batch.map(prompt => 
-                    this.openai.chat.completions.create({
-                        model,
-                        messages: [{ role: 'user', content: prompt }],
-                        max_tokens: 500
-                    })
-                );
-                
-                const results = await Promise.all(promises);
-                return results.map(result => 
-                    result.choices[0]?.message?.content || ''
-                );
-            },
-            (prompt: string) => prompt // Token extractor for accurate batching
-        );
-    }
-
-    /**
-     * Generate images with rate limiting  
-     */
-    async generateImages(prompts: string[]): Promise<string[]> {
-        return await this.rateLimitingService.executeWithRateLimit(
-            prompts,
-            async (batch: string[]) => {
-                const promises = batch.map(prompt =>
-                    this.openai.images.generate({
-                        model: 'dall-e-3',
-                        prompt,
-                        size: '1024x1024',
-                        quality: 'standard',
-                        n: 1
-                    })
-                );
-                
-                const results = await Promise.all(promises);
-                return results.map(result => 
-                    result.data[0]?.url || ''
-                );
-            },
-            (prompt: string) => prompt
-        );
-    }
-
-    /**
-     * Update rate limiting configuration
-     */
-    updateRateLimits(config: Partial<IRateLimitConfig>): void {
-        this.rateLimitingService.updateConfig(config);
-    }
-}
-
-/**
- * Usage example:
- * 
- * const completionService = new OpenAICompletionService(process.env.OPENAI_API_KEY, {
- *     rpm: 100,     // Lower RPM for your plan
- *     tpm: 10_000,  // Lower TPM 
- *     concurrency: 2
- * });
- * 
- * const prompts = [
- *     "Explain quantum computing",
- *     "Write a haiku about AI", 
- *     "Summarize the history of computing"
- * ];
- * 
- * const completions = await completionService.generateCompletions(prompts);
- * console.log(completions);
- */