@rws-framework/ai-tools 3.2.2 → 3.2.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rws-framework/ai-tools",
   "private": false,
-  "version": "3.2.2",
+  "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

@@ -185,7 +185,7 @@ export class LangChainRAGService {
                 chunkId: result.chunkId,                
             }));
 
-            this.log('log', `[SEARCH] Found ${results.length} relevant chunks for query: "${request.query}"\n ${JSON.stringify({ results})}`);
+            this.log('log', `[SEARCH] Found ${results.length} relevant chunks for query: "${request.query}"\n`);
 
             return {
                 success: true,

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/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/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);
- */