@rws-framework/ai-tools 3.3.1 → 3.5.0

package/package.json

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

package/src/models/convo/EmbedLoader.ts

@@ -187,12 +187,15 @@ class EmbedLoader<LLMChat extends BaseChatModel> {
             logConvo(`After the split we have ${splitDocs.length} documents more than the original ${orgDocs.length}.`);
             logConvo(`Average length among ${splitDocs.length} documents (after split) is ${avgCharCountPost} characters.`);
 
-            let i = 0;
-            splitDocs.forEach((doc: Document) => {
+            // Write files asynchronously to prevent blocking
+            await Promise.all(splitDocs.map(async (doc: Document, i: number) => {
                 finalDocs.push(doc);
-                fs.writeFileSync(this.debugSplitFile(i), doc.pageContent);
-                i++;
-            });
+                try {
+                    await fs.promises.writeFile(this.debugSplitFile(i), doc.pageContent, 'utf-8');
+                } catch (error) {
+                    console.warn(`Failed to write debug file ${i}:`, error);
+                }
+            }));
         }else{
             const splitFiles = fs.readdirSync(splitDir);
             

package/src/models/prompts/inc/execution-methods-handler.ts

@@ -22,9 +22,17 @@ export class ExecutionMethodsHandler {
         debugVars: any = {}, 
         tools?: IAITool[]
     ): Promise<void> {
-        promptInstance.setSentInput(promptInstance.getInput());
+        // Create snapshot of current input to prevent race conditions
+        const inputSnapshot = [...promptInstance.getInput()];
+        promptInstance.setSentInput(inputSnapshot);
+        
         const returnedRWS = await executor.promptRequest(promptInstance as any, { intruderPrompt, debugVars, tools });
-        promptInstance.injestOutput(returnedRWS.readOutput());
+        
+        // Safely ingest output
+        const output = returnedRWS.readOutput();
+        if (output !== null && output !== undefined) {
+            promptInstance.injestOutput(output);
+        }
     }
 
     async singleRequestWith(
@@ -34,8 +42,13 @@ export class ExecutionMethodsHandler {
         ensureJson: boolean = false, 
         tools?: IAITool[]
     ): Promise<void> {
+        // Create snapshot of current input to prevent race conditions
+        const inputSnapshot = [...promptInstance.getInput()];
+        
         await executor.singlePromptRequest(promptInstance as any, { intruderPrompt, ensureJson, tools });
-        promptInstance.setSentInput(promptInstance.getInput());
+        
+        // Set the snapshot after execution to maintain consistency
+        promptInstance.setSentInput(inputSnapshot);
     }
 
     async streamWith(

package/src/models/prompts/inc/model-execution-manager.ts

@@ -22,7 +22,7 @@ export class ModelExecutionManager {
     constructor(modelId: string, modelType: string, hyperParameters: IPromptHyperParameters) {
         this.modelId = modelId;
         this.modelType = modelType;
-        this.hyperParameters = hyperParameters;
+        this.hyperParameters = hyperParameters || { temperature: 0.7, max_tokens: 512 };
     }
 
     getModelId(): string {

package/src/models/prompts/inc/tool-manager.ts

@@ -34,14 +34,29 @@ export class ToolManager {
 
     async callTools<T = unknown, O = unknown>(tools: IToolCall[], moduleRef: ModuleRef, aiToolOptions?: O): Promise<T[]> {
         const results: T[] = [];
+        const errors: Error[] = [];
+        
         for (const tool of tools) {
             if (this.toolHandlers.has(tool.function.name)) {
-                const result = await this.callAiTool<T, O>(tool, moduleRef, aiToolOptions);
-                if (result) {
-                    results.push(result);
+                try {
+                    const result = await this.callAiTool<T, O>(tool, moduleRef, aiToolOptions);
+                    if (result) {
+                        results.push(result);
+                    }
+                } catch (error) {
+                    console.error(`Tool execution failed for ${tool.function.name}:`, error);
+                    errors.push(error as Error);
+                    // Continue with other tools instead of failing completely
                 }
+            } else {
+                console.warn(`No handler found for tool: ${tool.function.name}`);
             }
         }
+        
+        // If all tools failed, throw the first error
+        if (results.length === 0 && errors.length > 0) {
+            throw errors[0];
+        }
 
         return results;
     }

package/src/services/LangChainEmbeddingService.ts

@@ -15,6 +15,7 @@ export class LangChainEmbeddingService {
     private chunkConfig: IChunkConfig;
     private isInitialized = false;
     private vectorStore: RWSVectorStore | null = null;
+    private static embeddingsPool = new Map<string, Embeddings>(); // Connection pooling
 
     constructor(private rateLimitingService: OpenAIRateLimitingService) {}
 
@@ -37,6 +38,14 @@ export class LangChainEmbeddingService {
 
 
     private initializeEmbeddings(): void {
+        const poolKey = `${this.config.provider}_${this.config.model}_${this.config.apiKey.slice(-8)}`;
+        
+        // Check connection pool first
+        if (LangChainEmbeddingService.embeddingsPool.has(poolKey)) {
+            this.embeddings = LangChainEmbeddingService.embeddingsPool.get(poolKey)!;
+            return;
+        }
+        
         switch (this.config.provider) {
             case 'cohere':
                 this.embeddings = new CohereEmbeddings({
@@ -58,6 +67,9 @@ export class LangChainEmbeddingService {
             default:
                 throw new Error(`Unsupported embedding provider: ${this.config.provider}`);
         }
+        
+        // Store in connection pool for reuse
+        LangChainEmbeddingService.embeddingsPool.set(poolKey, this.embeddings);
 
         if(this.config.rateLimiting){
             const rateLimitingCfg = {...OpenAIRateLimitingService.DEFAULT_CONFIG, ...this.config.rateLimiting};

package/src/services/LangChainRAGService.ts

@@ -41,8 +41,6 @@ export {
 export class LangChainRAGService {
     private config: ILangChainRAGConfig;
     private isInitialized = false;
-    private queryEmbeddingCache = new Map<string, number[]>();
-    private maxCacheSize = 100;
     private logger?: any; // Optional logger interface
 
     constructor(
@@ -85,11 +83,11 @@ export class LangChainRAGService {
      * Index knowledge content for RAG with optimized per-knowledge vector storage
      */
     async indexKnowledge(
-        knowledgeId: string | number,
+        fileId: string | number,
         content: string,
         metadata: Record<string, any> = {}
     ): Promise<IRAGResponse<{ chunkIds: string[] }>> {
-        this.log('log', `[INDEXING] Starting indexKnowledge for knowledgeId: ${knowledgeId}`);
+        this.log('log', `[INDEXING] Starting indexKnowledge for fileId: ${fileId}`);
         this.log('debug', `[INDEXING] Content length: ${content.length} characters`);
 
         try {
@@ -97,7 +95,7 @@ export class LangChainRAGService {
 
             // Chunk the content using the embedding service
             const chunks = await this.embeddingService.chunkText(content);
-            this.log('debug', `[INDEXING] Split content into ${chunks.length} chunks for knowledge ${knowledgeId}`);
+            this.log('debug', `[INDEXING] Split content into ${chunks.length} chunks for file ${fileId}`);
 
             // Generate embeddings for all chunks at once (batch processing for speed)
             const embeddings = await this.embeddingService.embedTexts(chunks);
@@ -109,17 +107,17 @@ export class LangChainRAGService {
                 embedding: embeddings[index],
                 metadata: {
                     ...metadata,
-                    knowledgeId,
+                    fileId,
                     chunkIndex: index,
-                    id: `knowledge_${knowledgeId}_chunk_${index}`
+                    id: `knowledge_${fileId}_chunk_${index}`
                 }
             }));
 
             // Save to per-knowledge vector file
-            await this.saveKnowledgeVector(knowledgeId, chunksWithEmbeddings);
+            await this.saveKnowledgeVector(fileId, chunksWithEmbeddings);
 
             const chunkIds = chunksWithEmbeddings.map(chunk => chunk.metadata.id);
-            this.log('log', `[INDEXING] Successfully indexed knowledge ${knowledgeId} with ${chunkIds.length} chunks using optimized approach`);
+            this.log('log', `[INDEXING] Successfully indexed file ${fileId} with ${chunkIds.length} chunks using optimized approach`);
 
             return {
                 success: true,
@@ -127,7 +125,7 @@ export class LangChainRAGService {
             };
 
         } catch (error: any) {
-            this.log('error', `[INDEXING] Failed to index knowledge ${knowledgeId}:`, error);
+            this.log('error', `[INDEXING] Failed to index file ${fileId}:`, error);
             return {
                 success: false,
                 data: null,
@@ -146,11 +144,11 @@ export class LangChainRAGService {
         try {
             await this.ensureInitialized();
 
-            const knowledgeIds = request.filter?.knowledgeIds || [];
-            console.log('knowledgeIds', knowledgeIds, 'temporaryDocumentSearch:', request.temporaryDocumentSearch);
+            const fileIds = request.filter?.fileIds || [];
+            console.log('fileIds', fileIds, 'temporaryDocumentSearch:', request.temporaryDocumentSearch);
             
-            if (knowledgeIds.length === 0) {
-                this.log('warn', '[SEARCH] No knowledge IDs provided for search, returning empty results');
+            if (fileIds.length === 0) {
+                this.log('warn', '[SEARCH] No file IDs provided for search, returning empty results');
                 return {
                     success: true,
                     data: { results: [] }
@@ -158,15 +156,15 @@ export class LangChainRAGService {
             }
 
             // Load all knowledge vectors in parallel (including temporary documents)
-            const knowledgeVectorPromises = knowledgeIds.map(async (knowledgeId) => {
+            const knowledgeVectorPromises = fileIds.map(async (fileId) => {
                 try {
-                    const vectorData = await this.loadKnowledgeVectorWithEmbeddings(knowledgeId);
+                    const vectorData = await this.loadKnowledgeVectorWithEmbeddings(fileId);
                     return {
-                        knowledgeId,                    
+                        fileId,                    
                         chunks: vectorData.chunks
                     };
                 } catch (loadError) {
-                    this.log('warn', `[SEARCH] Failed to load knowledge ${knowledgeId}:`, loadError);
+                    this.log('warn', `[SEARCH] Failed to load file ${fileId}:`, loadError);
                     return null;
                 }
             });
@@ -191,10 +189,10 @@ export class LangChainRAGService {
             
             // Convert results to expected format
             const results: ISearchResult[] = searchResponse.results.map(result => ({
-                knowledgeId: result.metadata.knowledgeId,
+                fileId: result.metadata?.fileId,  // Use fileId directly
                 content: result.content,
                 score: result.score,
-                metadata: result.metadata,
+                metadata: result.metadata,  // Pass metadata as-is
                 chunkId: result.chunkId,                
             }));
 
@@ -219,7 +217,7 @@ export class LangChainRAGService {
      * Remove knowledge from index
      */
     async removeKnowledge(fileId: string | number): Promise<boolean> {
-        this.log('log', `[REMOVE] Starting removal of knowledge: ${fileId}`);
+        this.log('log', `[REMOVE] Starting removal of file: ${fileId}`);
 
         try {
             await this.ensureInitialized();
@@ -228,15 +226,15 @@ export class LangChainRAGService {
             const vectorFilePath = this.getKnowledgeVectorPath(fileId);
             if (fs.existsSync(vectorFilePath)) {
                 fs.unlinkSync(vectorFilePath);
-                this.log('log', `[REMOVE] Successfully removed vector file for knowledge ${fileId}`);
+                this.log('log', `[REMOVE] Successfully removed vector file for file ${fileId}`);
                 return true;
             } else {
-                this.log('warn', `[REMOVE] Vector file not found for knowledge ${fileId}`);
+                this.log('warn', `[REMOVE] Vector file not found for file ${fileId}`);
                 return true; // Consider it successful if file doesn't exist
             }
 
         } catch (error: any) {
-            this.log('error', `[REMOVE] Failed to remove knowledge ${fileId}:`, error);
+            this.log('error', `[REMOVE] Failed to remove file ${fileId}:`, error);
             return false;
         }
     }
@@ -320,8 +318,8 @@ export class LangChainRAGService {
     /**
      * Save chunks to knowledge-specific vector file with embeddings
      */
-    private async saveKnowledgeVector(knowledgeId: string | number, chunks: Array<{ content: string; embedding: number[]; metadata: any }>): Promise<void> {
-        const vectorFilePath = this.getKnowledgeVectorPath(knowledgeId);
+    private async saveKnowledgeVector(fileId: string | number, chunks: Array<{ content: string; embedding: number[]; metadata: any }>): Promise<void> {
+        const vectorFilePath = this.getKnowledgeVectorPath(fileId);
         const vectorDir = path.dirname(vectorFilePath);
 
         // Ensure directory exists
@@ -331,16 +329,16 @@ export class LangChainRAGService {
 
         try {
             const vectorData = {
-                knowledgeId,
+                fileId,
                 chunks,
                 timestamp: new Date().toISOString()
             };
 
             fs.writeFileSync(vectorFilePath, JSON.stringify(vectorData, null, 2));
-            this.log('debug', `[SAVE] Successfully saved ${chunks.length} chunks with embeddings for knowledge ${knowledgeId}`);
+            this.log('debug', `[SAVE] Successfully saved ${chunks.length} chunks with embeddings for file ${fileId}`);
 
         } catch (error) {
-            this.log('error', `[SAVE] Failed to save vector data for knowledge ${knowledgeId}:`, error);
+            this.log('error', `[SAVE] Failed to save vector data for file ${fileId}:`, error);
             throw error;
         }
     }
@@ -348,24 +346,24 @@ export class LangChainRAGService {
     /**
      * Load vector data for a specific knowledge item with embeddings
      */
-    private async loadKnowledgeVectorWithEmbeddings(knowledgeId: string | number): Promise<{ knowledgeId?: string | number, chunks: Array<{ content: string; embedding: number[]; metadata: any }> }> {
-        const vectorFilePath = this.getKnowledgeVectorPath(knowledgeId);
+    private async loadKnowledgeVectorWithEmbeddings(fileId: string | number): Promise<{ fileId?: string | number, chunks: Array<{ content: string; embedding: number[]; metadata: any }> }> {
+        const vectorFilePath = this.getKnowledgeVectorPath(fileId);
         
         if (!fs.existsSync(vectorFilePath)) {
-            this.log('debug', `[LOAD] No vector file found for knowledge ${knowledgeId}, skipping...`);
+            this.log('debug', `[LOAD] No vector file found for file ${fileId}, skipping...`);
             return { chunks: [] };
         }
 
         try {
-            this.log('debug', `[LOAD] Loading vector data with embeddings for knowledge ${knowledgeId} from ${vectorFilePath}`);
+            this.log('debug', `[LOAD] Loading vector data with embeddings for file ${fileId} from ${vectorFilePath}`);
             const vectorData = JSON.parse(fs.readFileSync(vectorFilePath, 'utf8'));
             
             return {
                 chunks: vectorData.chunks || [],
-                knowledgeId
+                fileId
             };
         } catch (error) {
-            this.log('error', `[LOAD] Failed to load vector data for knowledge ${knowledgeId}:`, error);
+            this.log('error', `[LOAD] Failed to load vector data for file ${fileId}:`, error);
             return { chunks: [] };
         }
     }
@@ -373,12 +371,12 @@ export class LangChainRAGService {
     /**
      * Get the file path for a specific knowledge's vector data
      */
-    private getKnowledgeVectorPath(knowledgeId: string | number): string {
+    private getKnowledgeVectorPath(fileId: string | number): string {
         const vectorDir = path.join(rwsPath.findRootWorkspacePath(), 'files', 'vectors', 'knowledge');
         if (!fs.existsSync(vectorDir)) {
             fs.mkdirSync(vectorDir, { recursive: true });
         }
-        return path.join(vectorDir, `knowledge_${knowledgeId}.json`);
+        return path.join(vectorDir, `knowledge_${fileId}.json`);
     }
 
     /**

package/src/services/OpenAIRateLimitingService.ts

@@ -7,6 +7,27 @@ import { BlackLogger } from '@rws-framework/server/nest';
 let encoding_for_model: any = null;
 encoding_for_model = tiktoken.encoding_for_model
 
+// Singleton tokenizer factory for performance
+class TokenizerFactory {
+    private static tokenizers = new Map<string, any>();
+    
+    static getTokenizer(model: string): any {
+        if (!this.tokenizers.has(model)) {
+            try {
+                if (encoding_for_model) {
+                    this.tokenizers.set(model, encoding_for_model(model));
+                } else {
+                    this.tokenizers.set(model, null);
+                }
+            } catch (e) {
+                console.warn(`Could not load tokenizer for model ${model}`);
+                this.tokenizers.set(model, null);
+            }
+        }
+        return this.tokenizers.get(model);
+    }
+}
+
 @Injectable()
 export class OpenAIRateLimitingService {
     static readonly DEFAULT_CONFIG: Required<IRateLimitConfig> = {
@@ -37,16 +58,10 @@ export class OpenAIRateLimitingService {
             this.config = { ...this.config, ...config };
         }
 
-        // Initialize tokenizer for precise token counting
-        try {
-            if (encoding_for_model) {
-                this.tokenizer = encoding_for_model(model);
-            } else {
-                this.tokenizer = null;
-            }
-        } catch (e) {
+        // Use singleton tokenizer factory for performance
+        this.tokenizer = TokenizerFactory.getTokenizer(model);
+        if (!this.tokenizer) {
             this.logger.warn(`Could not load tokenizer for model ${model}, using character-based estimation`);
-            this.tokenizer = null;
         }
 
         // Reinitialize queue with new concurrency

package/src/services/OptimizedVectorSearchService.ts

@@ -34,13 +34,18 @@ export class OptimizedVectorSearchService {
         const allCandidates: IOptimizedSearchResult[] = [];
         let totalCandidates = 0;
 
-        // Process all knowledge vectors in parallel
+        // Process all knowledge vectors with early termination optimization
         const searchPromises = knowledgeVectors.map(async (knowledgeVector) => {
             const candidates: IOptimizedSearchResult[] = [];
             const similarities: number[] = [];  // Track all similarities for debugging
+            let processedCount = 0;
             
-            for (const chunk of knowledgeVector.chunks) {
+            // Sort chunks by some heuristic to check best candidates first (optional optimization)
+            const chunks = knowledgeVector.chunks;
+            
+            for (const chunk of chunks) {
                 totalCandidates++;
+                processedCount++;
                 
                 if (!chunk.embedding || !Array.isArray(chunk.embedding)) {
                     continue;
@@ -54,35 +59,42 @@ export class OptimizedVectorSearchService {
                     candidates.push({
                         content: chunk.content,
                         score: similarity,
-                        metadata: chunk.metadata,
-                        knowledgeId: knowledgeVector.knowledgeId,
-                        chunkId: chunk.metadata?.id || `${knowledgeVector.knowledgeId}_chunk_${Date.now()}`
+                        metadata: {
+                            ...chunk.metadata,
+                            fileId: knowledgeVector.fileId  // Use fileId directly
+                        },
+                        fileId: knowledgeVector.fileId,  // Always use the fileId from the knowledgeVector
+                        chunkId: chunk.metadata?.id || `${knowledgeVector.fileId}_chunk_${Date.now()}`
                     });
                 }
             }
             
+            // Sort candidates by score and take top maxResults per source
+            const topCandidates = candidates
+                .sort((a, b) => b.score - a.score)
+                .slice(0, maxResults);
+            
             // Log similarity statistics for debugging
             if (similarities.length > 0) {
                 const maxSim = Math.max(...similarities);
                 const avgSim = similarities.reduce((a, b) => a + b, 0) / similarities.length;
-                console.log(`[VECTOR SEARCH] Knowledge ${knowledgeVector.knowledgeId}: Max similarity: ${maxSim.toFixed(4)}, Avg: ${avgSim.toFixed(4)}, Candidates above ${threshold}: ${candidates.length}`);
+                console.log(`[VECTOR SEARCH] File ${knowledgeVector.fileId}: Max similarity: ${maxSim.toFixed(4)}, Avg: ${avgSim.toFixed(4)}, Candidates above ${threshold}: ${candidates.length}, Top results taken: ${topCandidates.length}`);
             }
             
-            return candidates;
+            return topCandidates;
         });
 
         // Wait for all searches to complete
         const allCandidateArrays = await Promise.all(searchPromises);
         
-        // Flatten results
+        // Flatten results (each source already limited to maxResults)
         for (const candidates of allCandidateArrays) {
             allCandidates.push(...candidates);
         }
 
-        // Sort by similarity score and take top results
+        // Sort by similarity score (no additional limiting since each source is already limited)
         const results = allCandidates
-            .sort((a, b) => b.score - a.score)
-            .slice(0, maxResults);
+            .sort((a, b) => b.score - a.score);
 
         const searchTime = Date.now() - startTime;
 
@@ -122,7 +134,7 @@ export class OptimizedVectorSearchService {
     async batchSearch(
         queries: string[],
         knowledgeVectors: Array<{
-            knowledgeId: string | number;
+            fileId: string | number;
             chunks: Array<{
                 content: string;
                 embedding: number[];
@@ -165,7 +177,7 @@ export class OptimizedVectorSearchService {
     private async searchWithEmbedding(request: {
         queryEmbedding: number[];
         knowledgeVectors: Array<{
-            knowledgeId: string | number;
+            fileId: string | number;
             chunks: Array<{
                 content: string;
                 embedding: number[];
@@ -200,8 +212,8 @@ export class OptimizedVectorSearchService {
                         content: chunk.content,
                         score: similarity,
                         metadata: chunk.metadata,
-                        knowledgeId: knowledgeVector.knowledgeId,
-                        chunkId: chunk.metadata?.id || `${knowledgeVector.knowledgeId}_chunk_${Date.now()}`
+                        fileId: knowledgeVector.fileId,
+                        chunkId: chunk.metadata?.id || `${knowledgeVector.fileId}_chunk_${Date.now()}`
                     });
                 }
             }
@@ -252,7 +264,7 @@ export class OptimizedVectorSearchService {
      * Search similar documents (compatibility method from LangChainVectorStoreService)
      */
     async searchSimilarCompat(request: IVectorSearchRequest, knowledgeVectors: Array<{
-        knowledgeId: string | number;
+        fileId: string | number;
         chunks: Array<{
             content: string;
             embedding: number[];
@@ -271,9 +283,9 @@ export class OptimizedVectorSearchService {
             let filteredVectors = knowledgeVectors;
             if (filter) {
                 filteredVectors = knowledgeVectors.filter(vector => {
-                    // Check knowledge IDs
-                    if (filter.knowledgeIds && filter.knowledgeIds.length > 0) {
-                        return filter.knowledgeIds.includes(String(vector.knowledgeId));
+                    // Check file IDs
+                    if (filter.fileIds && filter.fileIds.length > 0) {
+                        return filter.fileIds.includes(String(vector.fileId));
                     }
                     return true;
                 });
@@ -293,7 +305,7 @@ export class OptimizedVectorSearchService {
                 score: result.score,
                 metadata: result.metadata,
                 chunkId: result.chunkId,
-                knowledgeId: result.knowledgeId
+                fileId: result.fileId
             }));
 
             return {
@@ -313,7 +325,7 @@ export class OptimizedVectorSearchService {
      * Get search statistics
      */
     getStats(knowledgeVectors: Array<{
-        knowledgeId: string | number;
+        fileId: string | number;
         chunks: Array<{ content: string; embedding: number[]; metadata: any; }>;
     }>): { totalChunks: number; totalKnowledge: number } {
         const totalChunks = knowledgeVectors.reduce((total, vector) => total + vector.chunks.length, 0);

package/src/services/TextChunker.ts

@@ -197,8 +197,9 @@ export class TextChunker {
         for (let i = 0; i < chunks.length; i++) {
             const chunk = chunks[i];
             
-            // Check if we can merge this chunk with current chunk
-            const combined = currentChunk ? currentChunk + ' ' + chunk : chunk;
+            // Use array for efficient string building
+            const parts = currentChunk ? [currentChunk, chunk] : [chunk];
+            const combined = parts.join(' ');
             
             if (combined.length <= maxChars) {
                 // Can merge

package/src/types/IPrompt.ts

@@ -53,8 +53,7 @@ interface IAITool {
 
 interface IPromptHyperParameters {
     temperature: number,
-    top_k?: number,
-    top_p?: number,
+    max_tokens: number,
     [key: string]: number
 }
 

package/src/types/rag.types.ts

@@ -26,7 +26,7 @@ export interface IRAGSearchRequest {
     threshold?: number;
     temporaryDocumentSearch?: boolean; // Flag for searching temporary documents (web search)
     filter?: {
-        knowledgeIds?: (string | number)[];
+        fileIds?: (string | number)[];
         documentIds?: (string | number)[];
         [key: string]: any;
     };

package/src/types/search.types.ts

@@ -5,7 +5,7 @@ export interface ISearchResult {
     content: string;
     score: number;
     metadata: any;
-    knowledgeId: string | number;
+    fileId: string | number;
     chunkId: string;
 }
 
@@ -30,7 +30,7 @@ export interface IVectorSearchResponse {
 export interface IOptimizedSearchRequest {
     query: string;
     knowledgeVectors: Array<{
-        knowledgeId: string | number;
+        fileId: string | number;
         chunks: Array<{
             content: string;
             embedding: number[];
@@ -45,7 +45,7 @@ export interface IOptimizedSearchResult {
     content: string;
     score: number;
     metadata: any;
-    knowledgeId: string | number;
+    fileId: string | number;
     chunkId: string;
 }