@retrivora-ai/rag-engine 1.9.0 → 1.9.2

package/src/core/QueryProcessor.ts

@@ -12,10 +12,17 @@ export interface QueryFieldHint {
   value: string;
 }
 
+export interface NumericPredicate {
+  field?: string;
+  operator: 'gt' | 'gte' | 'lt' | 'lte' | 'eq';
+  value: number;
+}
+
 export interface QueryFilter {
   metadata?: Record<string, string>;
   keywords?: string[];
   queryText?: string;
+  __numericPredicates?: NumericPredicate[];
   [key: string]: unknown;
 }
 
@@ -149,6 +156,7 @@ export class QueryProcessor {
       new RegExp(`\\b${fieldPattern}\\s*(?:=|:)\\s*["']?${valuePattern}["']?(?=[?.!,]|$)`, 'gi'),
       new RegExp(`\\b${fieldPattern}\\s+(?:is|are|was|were|equals?|equal to|named|called)\\s+["']?${valuePattern}["']?(?=[?.!,]|$)`, 'gi'),
       new RegExp(`\\bwith\\s+${fieldPattern}\\s+["']?${valuePattern}["']?(?=[?.!,]|$)`, 'gi'),
+      new RegExp(`\\b(?:under|in|for|from|of)\\s+${fieldPattern}\\s+["']?${valuePattern}["']?(?=[?.!,]|$)`, 'gi'),
     ];
 
     for (const pattern of fieldValuePatterns) {
@@ -172,6 +180,92 @@ export class QueryProcessor {
     return [...hints.values()];
   }
 
+  static extractNumericPredicates(question: string, validFields: string[] = []): NumericPredicate[] {
+    const predicates: NumericPredicate[] = [];
+    const seen = new Set<string>();
+    const comparatorPattern = [
+      'greater than or equal to',
+      'more than or equal to',
+      'less than or equal to',
+      'greater than',
+      'more than',
+      'less than',
+      'equal to',
+      'at least',
+      'at most',
+      'above',
+      'over',
+      'below',
+      'under',
+      'equals?',
+      '>=',
+      '<=',
+      '>',
+      '<',
+      '=',
+    ].join('|');
+
+    const addPredicate = (rawField: string | undefined, rawOperator: string, rawValue: string) => {
+      const value = Number(rawValue.replace(/,/g, ''));
+      if (!Number.isFinite(value)) return;
+
+      const operator = this.normalizeNumericOperator(rawOperator);
+      const field = rawField ? this.normalizePredicateField(rawField, validFields) : undefined;
+      const key = `${field ?? '*'}::${operator}::${value}`;
+      if (seen.has(key)) return;
+      seen.add(key);
+      predicates.push({ ...(field ? { field } : {}), operator, value });
+    };
+
+    const scopedPatterns = [
+      new RegExp(`\\b(?:whose|with|having|where|that\\s+have|which\\s+have)\\s+([a-zA-Z][a-zA-Z0-9_\\s\\-/]{1,80}?)\\s+(?:is|are|was|were)?\\s*(?:${comparatorPattern})\\s+([\\d,]+(?:\\.\\d+)?)`, 'gi'),
+      new RegExp(`\\b([a-zA-Z][a-zA-Z0-9_\\s\\-/]{1,80}?)\\s+(?:is|are|was|were)?\\s*(?:${comparatorPattern})\\s+([\\d,]+(?:\\.\\d+)?)`, 'gi'),
+    ];
+
+    for (const pattern of scopedPatterns) {
+      for (const match of question.matchAll(pattern)) {
+        const full = match[0];
+        const operatorMatch = full.match(new RegExp(`(${comparatorPattern})`, 'i'));
+        if (!operatorMatch) continue;
+        addPredicate(match[1], operatorMatch[1], match[2]);
+      }
+    }
+
+    for (const match of question.matchAll(/\b([a-zA-Z][a-zA-Z0-9_\s\-/]{1,80}?)\s*(>=|<=|>|<|=)\s*([\d,]+(?:\.\d+)?)/g)) {
+      addPredicate(match[1], match[2], match[3]);
+    }
+
+    return predicates;
+  }
+
+  private static normalizeNumericOperator(operator: string): NumericPredicate['operator'] {
+    const op = operator.toLowerCase().trim();
+    if (op === '>' || /\b(greater than|more than|above|over)\b/.test(op)) return 'gt';
+    if (op === '>=' || /\b(greater than or equal to|more than or equal to|at least)\b/.test(op)) return 'gte';
+    if (op === '<' || /\b(less than|below|under)\b/.test(op)) return 'lt';
+    if (op === '<=' || /\b(less than or equal to|at most)\b/.test(op)) return 'lte';
+    return 'eq';
+  }
+
+  private static normalizePredicateField(field: string, validFields: string[]): string {
+    const cleaned = this.normalizeHintValue(field)
+      .replace(/\b(?:provide|show|get|give|list|all|the|a|an|of|organizations?|companies?|records?|items?|whose|with|having|where|that|which|have|has|is|are|was|were)\b/gi, ' ')
+      .replace(/\s+/g, ' ')
+      .trim();
+
+    if (validFields.length === 0) return cleaned;
+    const comparable = (value: string) => value.toLowerCase().replace(/[^a-z0-9]/g, '');
+    const cleanedComparable = comparable(cleaned);
+    const matchedField = validFields.find(fieldName => {
+      const candidate = comparable(fieldName);
+      return candidate === cleanedComparable ||
+        candidate.includes(cleanedComparable) ||
+        cleanedComparable.includes(candidate);
+    });
+
+    return matchedField ?? cleaned;
+  }
+
   /**
    * Constructs a QueryFilter object from extracted hints.
    *
@@ -196,6 +290,11 @@ export class QueryProcessor {
     if (Object.keys(filter.metadata || {}).length === 0) delete filter.metadata;
     if (filter.keywords && filter.keywords.length === 0) delete filter.keywords;
 
+    const numericPredicates = this.extractNumericPredicates(question);
+    if (numericPredicates.length > 0) {
+      filter.__numericPredicates = numericPredicates;
+    }
+
     return filter;
   }
 
@@ -203,12 +302,12 @@ export class QueryProcessor {
    * Determines the retrieval strategy based on the query content.
    */
   static async determineRetrievalStrategy(
-    query: string, 
+    query: string,
     llm?: import('../llm/ILLMProvider').ILLMProvider,
     customGraphKeywords?: string[],
     customVectorKeywords?: string[]
   ): Promise<'vector' | 'graph' | 'both'> {
-    
+
     if (llm) {
       try {
         const prompt = `You are a routing expert in a RAG system.
@@ -238,29 +337,29 @@ Return ONLY 'vector', 'graph', or 'both'. No explanation.`;
 
     // Fallback to keywords
     const normalized = query.toLowerCase();
-    
+
     // Graph keywords
     const graphKeywords = customGraphKeywords || [
-      'relationship', 'connect', 'link', 'network', 'friend', 'colleague', 
+      'relationship', 'connect', 'link', 'network', 'friend', 'colleague',
       'manager', 'hierarchy', 'multi-hop', 'shortest path', 'between',
       'related to', 'associated with', 'belongs to', 'part of'
     ];
-    
+
     const hasGraphKeyword = graphKeywords.some(kw => normalized.includes(kw));
-    
+
     // Vector keywords (usually generic search or content specific)
     const vectorKeywords = customVectorKeywords || [
       'find', 'search', 'tell me about', 'what is', 'how to', 'documents about'
     ];
-    
+
     const hasVectorKeyword = vectorKeywords.some(kw => normalized.includes(kw));
-    
+
     if (hasGraphKeyword && !hasVectorKeyword) {
       return 'graph';
     } else if (hasGraphKeyword && hasVectorKeyword) {
       return 'both';
     }
-    
+
     return 'vector';
   }
 }

package/src/handlers/index.ts

@@ -142,15 +142,24 @@ export function createStreamHandler(configOrPlugin?: Partial<RagConfig> | Vector
     }
 
     const encoder = new TextEncoder();
+    let isActive = true;
 
     const stream = new ReadableStream({
       async start(controller) {
-        const enqueue = (text: string) => controller.enqueue(encoder.encode(text));
+        const enqueue = (text: string) => {
+          if (!isActive) return;
+          try {
+            controller.enqueue(encoder.encode(text));
+          } catch (err) {
+            console.warn('[createStreamHandler] Failed to enqueue (stream already closed):', err);
+          }
+        };
 
         try {
           const pipelineStream = plugin.chatStream(message, history, namespace);
 
           for await (const chunk of pipelineStream) {
+            if (!isActive) break;
             if (typeof chunk === 'string') {
               enqueue(sseTextFrame(chunk));
             } else {
@@ -168,11 +177,12 @@ export function createStreamHandler(configOrPlugin?: Partial<RagConfig> | Vector
 
               if (sources.length > 0) {
                 try {
-                  const llmProvider = plugin.getLLMProvider?.();
-                  const uiTransformation = responseChunk?.ui_transformation ??
-                    (llmProvider
-                      ? await UITransformer.analyzeAndDecide(message, sources, llmProvider)
-                      : UITransformer.transform(message, sources, plugin.getConfig()));
+                  // The pipeline already computed ui_transformation inside askStream().
+                  // We ONLY fall back to the cheap heuristic transform (no LLM call) when
+                  // the pipeline didn't produce one — never call analyzeAndDecide() here.
+                  const uiTransformation =
+                    responseChunk?.ui_transformation ??
+                    UITransformer.transform(message, sources, plugin.getConfig());
 
                   if (uiTransformation) {
                     enqueue(sseUIFrame(uiTransformation));
@@ -188,14 +198,28 @@ export function createStreamHandler(configOrPlugin?: Partial<RagConfig> | Vector
             }
           }
         } catch (streamError) {
-          const errorMessage =
-            streamError instanceof Error ? streamError.message : String(streamError);
-          console.error('[createStreamHandler] Stream error:', streamError);
-          enqueue(sseErrorFrame(errorMessage));
+          // Do not log or enqueue errors if the client intentionally cancelled/aborted
+          if (isActive) {
+            const errorMessage =
+              streamError instanceof Error ? streamError.message : String(streamError);
+            console.error('[createStreamHandler] Stream error:', streamError);
+            try {
+              enqueue(sseErrorFrame(errorMessage));
+            } catch { /* silent */ }
+          }
         } finally {
-          controller.close();
+          if (isActive) {
+            isActive = false;
+            try {
+              controller.close();
+            } catch { /* silent */ }
+          }
         }
       },
+      cancel(reason) {
+        isActive = false;
+        console.log('[createStreamHandler] Stream connection closed by client:', reason);
+      }
     });
 
     return new Response(stream, { headers: SSE_HEADERS });
@@ -289,6 +313,7 @@ export function createUploadHandler(configOrPlugin?: Partial<RagConfig> | Vector
           if (parsed.data && parsed.data.length > 0) {
             let i = 0;
             let lastRowData: Record<string, string> | null = null;
+            const csvCols = Object.keys(parsed.data[0] as Record<string, string>);
             
             for (const row of parsed.data) {
               i++;
@@ -325,6 +350,7 @@ export function createUploadHandler(configOrPlugin?: Partial<RagConfig> | Vector
                   fileType: file.type,
                   uploadedAt: new Date().toISOString(),
                   ...(dimension ? { dimension } : {}),
+                  csvHeaders: csvCols,
                   ...rowData
                 }
               });

package/src/hooks/useRagChat.ts

@@ -74,6 +74,7 @@ export function useRagChat(
   const [error, setError] = useState<string | null>(null);
   const lastInputRef = useRef<string>('');
   const messagesRef = useRef<RagMessage[]>(messages);
+  const abortControllerRef = useRef<AbortController | null>(null);
 
   useEffect(() => {
     messagesRef.current = messages;
@@ -100,12 +101,21 @@ export function useRagChat(
       setError(null);
       setIsLoading(true);
 
+      // Abort any existing call
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+
+      const controller = new AbortController();
+      abortControllerRef.current = controller;
+
       try {
         const history = messagesRef.current.map(({ role, content }) => ({ role, content }));
 
         const response = await fetch(apiUrl, {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
+          signal: controller.signal,
           body: JSON.stringify({
             message: trimmed,
             history,
@@ -128,10 +138,36 @@ export function useRagChat(
         let sources: VectorMatch[] = [];
         let uiTransformation: unknown = null;
         let trace: ObservabilityTrace | undefined;
-        // Buffer for partial SSE frames that arrive split across reads
         let buffer = '';
 
-        // Add a placeholder assistant message that we will update incrementally
+        // ── RAF-based render batching ─────────────────────────────────────
+        // Accumulate text chunks in a ref and flush to React state at ~60fps
+        // instead of calling setMessages on every SSE frame. This eliminates
+        // O(N) ReactMarkdown re-parses where N = number of token chunks.
+        let pendingFlush = false;
+        const pendingContentRef = { current: '' };
+
+        const flushTextUpdate = (msgId: string) => {
+          pendingFlush = false;
+          const snapshot = pendingContentRef.current;
+          setMessages((prev) =>
+            prev.map((msg) =>
+              msg.id === msgId
+                ? { ...msg, content: snapshot }
+                : msg
+            )
+          );
+        };
+
+        const scheduleFlush = (msgId: string) => {
+          if (!pendingFlush) {
+            pendingFlush = true;
+            requestAnimationFrame(() => flushTextUpdate(msgId));
+          }
+        };
+        // ─────────────────────────────────────────────────────────────────
+
+        // Add a placeholder assistant message
         const assistantMessageId = `assistant_${Date.now()}`;
         setMessages((prev) => [
           ...prev,
@@ -149,40 +185,50 @@ export function useRagChat(
 
           buffer += decoder.decode(value, { stream: true });
 
-          // Only process complete frames (ending with \n\n)
           const lastBoundary = buffer.lastIndexOf('\n\n');
-          if (lastBoundary === -1) continue; // Wait for more data
+          if (lastBoundary === -1) continue;
 
           const complete = buffer.slice(0, lastBoundary + 2);
           buffer = buffer.slice(lastBoundary + 2);
 
+          let hasNonTextFrame = false;
+
           for (const frame of parseSseChunk(complete)) {
             if (frame.type === 'text' && frame.text) {
               assistantContent += frame.text;
+              pendingContentRef.current = assistantContent;
+              // Schedule a batched RAF flush instead of immediate setMessages
+              scheduleFlush(assistantMessageId);
             } else if (frame.type === 'metadata') {
               sources = frame.sources ?? [];
+              hasNonTextFrame = true;
             } else if (frame.type === 'ui_transformation') {
               uiTransformation = frame.data;
+              hasNonTextFrame = true;
             } else if (frame.type === 'observability') {
               trace = (frame as SseObservabilityFrame).data;
+              hasNonTextFrame = true;
             } else if (frame.type === 'error') {
               setError(frame.error || 'Stream error');
             }
           }
 
-          // Update the assistant message with accumulated content
-          setMessages((prev) =>
-            prev.map((msg) =>
-              msg.id === assistantMessageId
-                ? { 
-                    ...msg, 
-                    content: assistantContent, 
-                    sources: sources.length > 0 ? sources : msg.sources,
-                    uiTransformation: uiTransformation || (msg as RagMessage).uiTransformation
-                  }
-                : msg
-            )
-          );
+          // Flush non-text metadata immediately (sources, UI transform, trace)
+          if (hasNonTextFrame) {
+            pendingFlush = false; // cancel pending text flush — we'll do a full update
+            setMessages((prev) =>
+              prev.map((msg) =>
+                msg.id === assistantMessageId
+                  ? {
+                      ...msg,
+                      content: assistantContent,
+                      sources: sources.length > 0 ? sources : msg.sources,
+                      uiTransformation: uiTransformation || (msg as RagMessage).uiTransformation,
+                    }
+                  : msg
+              )
+            );
+          }
         }
 
         // Process any remaining buffered data
@@ -209,11 +255,16 @@ export function useRagChat(
         );
         onReply?.(finalMsg);
       } catch (err) {
+        if (err instanceof Error && err.name === 'AbortError') {
+          console.log('[useRagChat] Streaming stopped by user.');
+          return;
+        }
         const msg = err instanceof Error ? err.message : 'Something went wrong. Please try again.';
         setError(msg);
         onError?.(msg);
       } finally {
         setIsLoading(false);
+        abortControllerRef.current = null;
       }
     },
     [apiUrl, isLoading, namespace, onError, onReply, projectId, setMessages]
@@ -234,6 +285,14 @@ export function useRagChat(
     }
   }, [sendMessage]);
 
+  const stop = useCallback(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+    }
+    setIsLoading(false);
+  }, []);
+
   return {
     messages,
     isLoading,
@@ -242,5 +301,6 @@ export function useRagChat(
     clear,
     retry,
     setMessages,
+    stop,
   };
 }

package/src/llm/providers/UniversalLLMAdapter.ts

@@ -25,6 +25,9 @@ export class UniversalLLMAdapter implements ILLMProvider {
   private readonly systemPrompt: string;
   private readonly maxTokens: number;
   private readonly temperature: number;
+  private readonly baseUrl: string;
+  private readonly apiKey?: string;
+  private readonly resolvedHeaders: Record<string, string>;
 
   constructor(config: LLMConfig | EmbeddingConfig) {
     this.model = config.model;
@@ -46,19 +49,22 @@ export class UniversalLLMAdapter implements ILLMProvider {
     this.systemPrompt = llmConfig.systemPrompt ?? 'You are a helpful AI assistant. Use the provided context to answer the user.';
     this.maxTokens = llmConfig.maxTokens ?? 1024;
     this.temperature = llmConfig.temperature ?? 0;
+    this.apiKey = config.apiKey;
 
-    const baseUrl = llmConfig.baseUrl ?? this.opts.baseUrl;
-    if (!baseUrl) {
+    this.baseUrl = llmConfig.baseUrl ?? this.opts.baseUrl ?? '';
+    if (!this.baseUrl) {
       throw new Error('[UniversalLLMAdapter] baseUrl is required in config or config.options');
     }
 
+    this.resolvedHeaders = {
+      'Content-Type': 'application/json',
+      ...(config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {}),
+      ...(this.opts.headers || {}),
+    };
+
     this.http = axios.create({
-      baseURL: baseUrl,
-      headers: {
-        'Content-Type': 'application/json',
-        ...(config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {}),
-        ...(this.opts.headers || {}),
-      },
+      baseURL: this.baseUrl,
+      headers: this.resolvedHeaders,
       timeout: this.opts.timeout ?? 60_000,
     });
   }
@@ -73,7 +79,6 @@ export class UniversalLLMAdapter implements ILLMProvider {
 
     let payload: unknown;
     if (this.opts.chatPayloadTemplate) {
-      // The user wants to map messages and parameters to their unique JSON shape
       payload = buildPayload(this.opts.chatPayloadTemplate, {
         model: this.model,
         messages: formattedMessages,
@@ -81,7 +86,6 @@ export class UniversalLLMAdapter implements ILLMProvider {
         temperature: this.temperature,
       });
     } else {
-      // Fallback to OpenAI standard which covers 90% of open-source models (vLLM, LMStudio, Ollama, etc.)
       payload = {
         model: this.model,
         messages: formattedMessages,
@@ -102,6 +106,102 @@ export class UniversalLLMAdapter implements ILLMProvider {
     return String(result);
   }
 
+  /**
+   * Streaming chat using native fetch + ReadableStream.
+   * Parses OpenAI-compatible SSE frames: `data: {...}\n\n`
+   * Works with vLLM, LMStudio, Together AI, Fireworks, and any OpenAI-compatible API.
+   */
+  async *chatStream(messages: ChatMessage[], context?: string): AsyncIterable<string> {
+    const path = this.opts.chatPath ?? '/chat/completions';
+    const url = `${this.baseUrl.replace(/\/$/, '')}${path}`;
+    // Delta extract path — same root as chat but with delta instead of message
+    const extractPath = (this.opts.responseExtractPath ?? 'choices[0].message.content')
+      .replace('message.content', 'delta.content');
+
+    const formattedMessages = [
+      { role: 'system', content: `${this.systemPrompt}\n\nContext:\n${context ?? 'None'}` },
+      ...messages,
+    ];
+
+    let payload: unknown;
+    if (this.opts.chatPayloadTemplate) {
+      payload = buildPayload(this.opts.chatPayloadTemplate, {
+        model: this.model,
+        messages: formattedMessages,
+        maxTokens: this.maxTokens,
+        temperature: this.temperature,
+      });
+      // Inject stream: true into the payload if it's an object
+      if (typeof payload === 'object' && payload !== null) {
+        (payload as Record<string, unknown>).stream = true;
+      }
+    } else {
+      payload = {
+        model: this.model,
+        messages: formattedMessages,
+        max_tokens: this.maxTokens,
+        temperature: this.temperature,
+        stream: true,
+      };
+    }
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: this.resolvedHeaders,
+      body: JSON.stringify(payload),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => response.statusText);
+      throw new Error(`[UniversalLLMAdapter] Streaming request failed (${response.status}): ${errorText}`);
+    }
+
+    if (!response.body) {
+      throw new Error('[UniversalLLMAdapter] Response body is null — server did not send a streaming response.');
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder('utf-8');
+    let buffer = '';
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() ?? '';
+
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed === 'data: [DONE]') continue;
+          if (!trimmed.startsWith('data:')) continue;
+
+          try {
+            const json = JSON.parse(trimmed.slice(5).trim());
+            const text = resolvePath(json, extractPath);
+            if (text && typeof text === 'string') yield text;
+          } catch {
+            // Malformed SSE line — skip
+          }
+        }
+      }
+
+      // Flush remaining buffer
+      if (buffer.trim() && buffer.trim() !== 'data: [DONE]') {
+        const jsonStr = buffer.replace(/^data:\s*/, '').trim();
+        try {
+          const json = JSON.parse(jsonStr);
+          const text = resolvePath(json, extractPath);
+          if (text && typeof text === 'string') yield text;
+        } catch { /* ignore final partial line */ }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+
   async embed(text: string): Promise<number[]> {
     const path = this.opts.embedPath ?? '/embeddings';
 
@@ -112,7 +212,6 @@ export class UniversalLLMAdapter implements ILLMProvider {
         input: text,
       });
     } else {
-      // OpenAI standard fallback
       payload = {
         model: this.model,
         input: text,
@@ -133,8 +232,6 @@ export class UniversalLLMAdapter implements ILLMProvider {
 
   async batchEmbed(texts: string[]): Promise<number[][]> {
     const vectors: number[][] = [];
-    // Sequential fallback if the provider doesn't have a specific batch template
-    // In production, we should add a batchEmbedPayloadTemplate to UniversalLLMOptions
     for (const text of texts) {
       vectors.push(await this.embed(text));
     }

package/src/providers/vectordb/ChromaDBProvider.ts

@@ -70,12 +70,23 @@ export class ChromaDBProvider extends BaseVectorProvider {
     await this.http.post(`/api/v1/collections/${this.collectionId}/add`, payload);
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async query(vector: number[], topK: number, namespace?: string, _filter?: Record<string, unknown>): Promise<VectorMatch[]> {
+    const sanitizedFilter = this.sanitizeFilter(_filter);
+    const whereClauses: Record<string, unknown>[] = [];
+    if (namespace) whereClauses.push({ namespace: { $eq: namespace } });
+    Object.entries(sanitizedFilter).forEach(([key, value]) => {
+      if (key === 'namespace') return;
+      if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        whereClauses.push({ [key]: { $eq: value } });
+      }
+    });
+
     const payload = {
       query_embeddings: [vector],
       n_results: topK,
-      where: namespace ? { namespace: { $eq: namespace } } : undefined,
+      where: whereClauses.length > 1
+        ? { $and: whereClauses }
+        : whereClauses[0],
     };
     const { data } = await this.http.post(`/api/v1/collections/${this.collectionId}/query`, payload);
 

package/src/providers/vectordb/MilvusProvider.ts

@@ -68,13 +68,29 @@ export class MilvusProvider extends BaseVectorProvider {
     await this.http.post('/v1/vector/upsert', payload);
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async query(vector: number[], topK: number, namespace?: string, _filter?: Record<string, unknown>): Promise<VectorMatch[]> {
+    const sanitizedFilter = this.sanitizeFilter(_filter);
+
+    // Build Milvus boolean expression from filter fields.
+    // Namespace filtering is expressed as a field equality check.
+    const filterParts: string[] = [];
+    if (namespace) {
+      filterParts.push(`namespace == "${namespace}"`);
+    }
+    for (const [key, value] of Object.entries(sanitizedFilter)) {
+      if (key === 'queryText' || key === 'keywords') continue;
+      if (typeof value === 'string') {
+        filterParts.push(`metadata["${key}"] == "${value.replace(/"/g, '\\"')}"`);
+      } else if (typeof value === 'number') {
+        filterParts.push(`metadata["${key}"] == ${value}`);
+      }
+    }
+
     const payload = {
       collectionName: this.indexName,
       vector: vector,
       limit: topK,
-      filter: namespace ? `namespace == "${namespace}"` : undefined,
+      filter: filterParts.length > 0 ? filterParts.join(' && ') : undefined,
       outputFields: ['content', 'metadata'],
       searchParams: {
         nprobe: (this.config.options.nprobe as number) || 16,