@retrivora-ai/rag-engine 1.8.2 → 1.8.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@retrivora-ai/rag-engine",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "description": "Retrivora AI is a plug-and-play AI engine for RAG chat experiences — generic vector DB + LLM provider, embeddable or standalone.",
   "author": "Abhinav Alkuchi",
   "license": "MIT",
@@ -36,6 +36,7 @@
       "require": "./dist/index.js",
       "import": "./dist/index.mjs"
     },
+    "./style.css": "./dist/index.css",
     "./handlers": {
       "types": "./dist/handlers/index.d.ts",
       "require": "./dist/handlers/index.js",
@@ -73,25 +74,24 @@
   "scripts": {
     "dev": "next dev",
     "build": "next build",
-    "build:pkg": "tsup src/index.ts src/handlers/index.ts src/server.ts --format cjs,esm --dts --clean --tsconfig tsconfig.build.json --external react,react-dom,next,mongodb,pg,openai,@anthropic-ai/sdk,@pinecone-database/pinecone,axios,lucide-react,mammoth,pdf-parse,react-markdown,remark-gfm,next-themes,langchain,@langchain/core,@langchain/openai,llamaindex",
+    "build:pkg": "tsup src/index.ts src/handlers/index.ts src/server.ts --format cjs,esm --dts --clean --no-splitting --tsconfig tsconfig.build.json --external react,react-dom,next,mongodb,pg,openai,@anthropic-ai/sdk,@pinecone-database/pinecone,axios,lucide-react,mammoth,pdf-parse,react-markdown,remark-gfm,next-themes,langchain,@langchain/core,@langchain/openai,llamaindex && npx @tailwindcss/cli -i src/tailwind.css -o dist/index.css",
     "start": "next start",
     "lint": "eslint",
     "prepublishOnly": "npm run build:pkg"
   },
   "peerDependencies": {
-    "next": ">=14.0.0",
     "react": ">=18.0.0",
     "react-dom": ">=18.0.0"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.90.0",
+    "@anthropic-ai/sdk": "^0.95.1",
     "@google/genai": "^0.8.0",
     "@google/generative-ai": "^0.24.1",
     "@pinecone-database/pinecone": "^7.2.0",
     "@types/papaparse": "^5.5.2",
     "axios": "^1.15.0",
     "lucide-react": "^1.8.0",
-    "next": ">=14.0.0",
+    "next": "^16.2.6",
     "next-themes": "^0.4.6",
     "openai": "^6.34.0",
     "papaparse": "^5.5.3",
@@ -106,14 +106,16 @@
     "@langchain/core": "^1.1.42",
     "@langchain/openai": "^1.4.5",
     "langchain": "^1.3.5",
-    "llamaindex": "^0.12.1",
+    "llamaindex": "^0.11.9",
     "mammoth": "^1.8.0",
     "mongodb": "^7.1.1",
     "pdf-parse": "^1.1.1",
     "pg": "^8.20.0"
   },
   "devDependencies": {
+    "@tailwindcss/cli": "^4",
     "@tailwindcss/postcss": "^4",
+    "@types/estree": "^1.0.9",
     "@types/node": "^20",
     "@types/pdf-parse": "^1.1.5",
     "@types/pg": "^8.20.0",

package/src/app/globals.css

@@ -7,15 +7,20 @@
 /* ─── Design Tokens ─────────────────────────────────────────── */
 :root {
   --font-inter: 'Inter', sans-serif;
-  
+
   /* Light Mode (Default) */
-  --bg-base: #f8fafc; /* slate-50 */
+  --bg-base: #f8fafc;
+  /* slate-50 */
   --bg-surface: #ffffff;
-  --bg-elevated: #f1f5f9; /* slate-100 */
+  --bg-elevated: #f1f5f9;
+  /* slate-100 */
   --border: rgba(0, 0, 0, 0.08);
-  --text-primary: #0f172a; /* slate-900 */
-  --text-secondary: #475569; /* slate-600 */
-  --text-muted: #94a3b8; /* slate-400 */
+  --text-primary: #0f172a;
+  /* slate-900 */
+  --text-secondary: #475569;
+  /* slate-600 */
+  --text-muted: #94a3b8;
+  /* slate-400 */
 }
 
 .dark {
@@ -54,13 +59,16 @@ body {
   width: 4px;
   height: 4px;
 }
+
 ::-webkit-scrollbar-track {
   background: transparent;
 }
+
 ::-webkit-scrollbar-thumb {
   background: rgba(255, 255, 255, 0.12);
   border-radius: 999px;
 }
+
 ::-webkit-scrollbar-thumb:hover {
   background: rgba(255, 255, 255, 0.2);
 }
@@ -93,13 +101,21 @@ body {
   margin: 0.5em 0;
 }
 
-.prose ul, .prose ol {
+.prose ul,
+.prose ol {
   padding-left: 1.5em;
   margin: 0.5em 0;
 }
 
 .prose li {
   margin: 0.25em 0;
+  list-style-type: none;
+}
+
+.prose li::before {
+  content: "\27A4";
+  /* Unicode for a right-pointing arrow */
+  padding-right: 8px;
 }
 
 .prose table {
@@ -109,7 +125,8 @@ body {
   font-size: 0.8rem;
 }
 
-.prose th, .prose td {
+.prose th,
+.prose td {
   border: 1px solid var(--border);
   padding: 0.5rem;
   text-align: left;
@@ -175,6 +192,7 @@ body {
     opacity: 0;
     transform: translateY(8px);
   }
+
   to {
     opacity: 1;
     transform: translateY(0);
@@ -186,6 +204,7 @@ body {
     opacity: 0;
     transform: translateY(16px) scale(0.98);
   }
+
   to {
     opacity: 1;
     transform: translateY(0) scale(1);
@@ -193,8 +212,13 @@ body {
 }
 
 @keyframes shimmer {
-  0% { background-position: -200% 0; }
-  100% { background-position: 200% 0; }
+  0% {
+    background-position: -200% 0;
+  }
+
+  100% {
+    background-position: 200% 0;
+  }
 }
 
 .animate-fade-in-up {
@@ -218,4 +242,4 @@ body {
   -webkit-background-clip: text;
   -webkit-text-fill-color: transparent;
   background-clip: text;
-}
+}

package/src/components/ChatWidget.tsx

@@ -30,7 +30,6 @@ export function ChatWidget({ position = 'bottom-right', onAddToCart }: ChatWidge
       : 'bottom-20 right-6';
 
   const handleOpen = () => {
-    console.log('ChatWidget: Opening...');
     setIsOpen(true);
     setHasUnread(false);
   };

package/src/components/MarkdownComponents.tsx

@@ -20,6 +20,9 @@ export function createMarkdownComponents({
   viewportSize,
 }: MarkdownComponentsProps): Components {
   return {
+    p: ({ ...props }: React.HTMLAttributes<HTMLParagraphElement>) => (
+      <p className="whitespace-pre-line" {...props} />
+    ),
     table: ({ ...props }: React.HTMLAttributes<HTMLTableElement>) => {
       // Fix: intercept table rendering during streaming instead of using sentinel
       if (isStreaming) {

package/src/components/MessageBubble.tsx

@@ -78,9 +78,10 @@ export function MessageBubble({
       message.content,
       structuredContent.text,
       payloadCandidates,
-      productsFromSources
+      productsFromSources,
+      isStreaming
     );
-  }, [message.content, isUser, structuredContent, productsFromSources]);
+  }, [message.content, isUser, structuredContent, productsFromSources, isStreaming]);
 
   const allProducts = React.useMemo<Product[]>(() => {
     return deduplicateProducts(productsFromSources, productsFromContent, message.content);

package/src/components/ObservabilityPanel.tsx

@@ -323,7 +323,7 @@ export function ObservabilityPanel({ trace, primaryColor = '#6366f1' }: Observab
   const [activeTab, setActiveTab] = React.useState<TabId>('retrieval');
 
   return (
-    <div className="mt-2 w-full rounded-xl border border-slate-200 dark:border-white/8 bg-white dark:bg-slate-900/60 shadow-sm overflow-hidden text-[12px]">
+    <div className="mt-2 w-[500px] max-w-full rounded-xl border border-slate-200 dark:border-white/8 bg-white dark:bg-slate-900/60 shadow-sm overflow-hidden text-[12px]">
       {/* Header */}
       <div
         className="flex items-center gap-2 px-3 py-2 border-b border-slate-100 dark:border-white/8"

package/src/components/UIDispatcher.tsx

@@ -264,9 +264,6 @@ export function UIDispatcher({ rawContent, primaryColor, accentColor, isStreamin
   const hasInsights = Array.isArray(config.insights) && config.insights.length > 0;
   const hasDescription = typeof config.description === 'string' && config.description.trim().length > 0;
 
-  console.log("🚀 ~ UIDispatcher ~ description:", config.description);
-  console.log("🚀 ~ UIDispatcher ~ hasDescription:", hasDescription);
-
   switch (config.view) {
     case 'chart':
       return (

package/src/config/ConfigBuilder.ts

@@ -32,6 +32,8 @@ import {
   VectorDBProvider,
   LLMProvider,
   EmbeddingProvider,
+  GraphDBConfig,
+  GraphDBProvider,
 } from './RagConfig';
 
 export class ConfigBuilder {
@@ -41,6 +43,7 @@ export class ConfigBuilder {
   private _embedding?: EmbeddingConfig;
   private _ui?: UIConfig;
   private _rag?: RAGConfig;
+  private _graphDb?: GraphDBConfig;
 
   /**
    * Set the project/application ID for namespacing
@@ -118,6 +121,24 @@ export class ConfigBuilder {
     return this;
   }
 
+  /**
+   * Configure the graph database provider
+   */
+  graphDb(
+    provider: string | 'auto',
+    options?: Record<string, unknown>
+  ): this {
+    if (provider === 'auto') {
+      this._graphDb = this._autoDetectGraphDb();
+    } else {
+      this._graphDb = {
+        provider: provider as GraphDBProvider,
+        options: options ?? {},
+      };
+    }
+    return this;
+  }
+
   /**
    * Set RAG-specific pipeline parameters
    */
@@ -152,13 +173,19 @@ export class ConfigBuilder {
       );
     }
 
+    const ragConfig = this._rag ?? { chunkSize: 1000, chunkOverlap: 200, topK: 5 };
+    if (process.env.RAG_USE_GRAPH_RETRIEVAL === 'true') {
+      ragConfig.useGraphRetrieval = true;
+    }
+
     return {
       projectId:  this._projectId!,
       vectorDb:   this._vectorDb!,
       llm:        this._llm!,
       embedding:  this._embedding!,
       ui:         this._rag ? this._ui : undefined,
-      rag:        this._rag ?? { chunkSize: 1000, chunkOverlap: 200, topK: 5 },
+      rag:        ragConfig,
+      graphDb:    this._graphDb,
       ...(this._ui ? { ui: this._ui } : {}),
     };
   }
@@ -212,6 +239,16 @@ export class ConfigBuilder {
     }
     return { provider: 'openai', model: 'text-embedding-3-small', apiKey: process.env.OPENAI_API_KEY };
   }
+
+  private _autoDetectGraphDb(): GraphDBConfig | undefined {
+    if (process.env.GRAPH_DB_PROVIDER) {
+      return {
+        provider: process.env.GRAPH_DB_PROVIDER as GraphDBProvider,
+        options: {},
+      };
+    }
+    return undefined;
+  }
 }
 
 /**

package/src/core/LangChainAgent.ts

@@ -25,7 +25,7 @@ export class LangChainAgent {
    */
   async initialize(chatModel: unknown) {
     try {
-      const [{ DynamicTool }, { HumanMessage }, { createAgent }] = await Promise.all([
+      const [{ DynamicTool }, , { createAgent }] = await Promise.all([
         import('@langchain/core/tools'),
         import('@langchain/core/messages'),
         import('langchain'),
@@ -80,9 +80,6 @@ export class LangChainAgent {
         tools: [searchTool],
         systemPrompt: finalSystemPrompt,
       });
-
-      // Suppress unused import warning — HumanMessage is used in run()
-      void HumanMessage;
     } catch (error) {
       const isMissing =
         error instanceof Error && error.message.includes('Cannot find module');

package/src/core/Pipeline.ts

@@ -76,14 +76,14 @@ function estimateTokens(text: string): number {
  * Used for estimating cost when providers don't return billing data.
  */
 const MODEL_COST_PER_1K: Record<string, { input: number; output: number }> = {
-  'gpt-4o':               { input: 0.0025, output: 0.010  },
-  'gpt-4o-mini':          { input: 0.00015, output: 0.0006 },
-  'gpt-4-turbo':          { input: 0.01,   output: 0.03   },
-  'gpt-3.5-turbo':        { input: 0.0005, output: 0.0015 },
-  'claude-3-5-sonnet':    { input: 0.003,  output: 0.015  },
-  'claude-3-haiku':       { input: 0.00025, output: 0.00125 },
-  'gemini-1.5-flash':     { input: 0.000075, output: 0.0003 },
-  'gemini-1.5-pro':       { input: 0.00125, output: 0.005 },
+  'gpt-4o': { input: 0.0025, output: 0.010 },
+  'gpt-4o-mini': { input: 0.00015, output: 0.0006 },
+  'gpt-4-turbo': { input: 0.01, output: 0.03 },
+  'gpt-3.5-turbo': { input: 0.0005, output: 0.0015 },
+  'claude-3-5-sonnet': { input: 0.003, output: 0.015 },
+  'claude-3-haiku': { input: 0.00025, output: 0.00125 },
+  'gemini-1.5-flash': { input: 0.000075, output: 0.0003 },
+  'gemini-1.5-pro': { input: 0.00125, output: 0.005 },
 };
 
 function estimateCostUsd(
@@ -434,6 +434,8 @@ You are a helpful product assistant. Use the provided context to answer question
       const rerankStart = performance.now();
       let sources = rawSources.filter((m) => m.score >= scoreThreshold);
       if (this.config.rag?.useReranking) {
+        // We do not pass llmProvider here to opt into the fast, deterministic keyword-based re-ranking in production.
+        // Pass this.llmProvider as the 4th argument if you want high-accuracy LLM-based re-ranking.
         sources = await this.reranker.rerank(sources, question, topK);
       } else {
         sources = sources.slice(0, topK);
@@ -446,6 +448,7 @@ You are a helpful product assistant. Use the provided context to answer question
         : 'No relevant context found.';
 
       if (graphData && graphData.nodes.length > 0) {
+        console.log(`[Graph Retrieval] Found ${graphData.nodes.length} relevant entities.`);
         const graphContext = graphData.nodes.map(n =>
           `Entity: ${n.label} (${n.id})${n.properties ? ' - ' + JSON.stringify(n.properties) : ''}`
         ).join('\n');
@@ -513,7 +516,7 @@ You are a helpful product assistant. Use the provided context to answer question
 
       // 8. Automated UI transformation
       const trainedSchema = await trainingPromise;
-      const uiTransformation = await this.generateUiTransformation(question, sources, context, trainedSchema);
+      const uiTransformation = await this.generateUiTransformation(question, sources, trainedSchema);
 
       // 9. Build observability trace
       const trace: ObservabilityTrace = {
@@ -557,7 +560,6 @@ You are a helpful product assistant. Use the provided context to answer question
   private async generateUiTransformation(
     question: string,
     sources: VectorMatch[],
-    _context: string,
     trainedSchema?: SchemaMap
   ): Promise<unknown> {
     if (!sources || sources.length === 0) {
@@ -579,19 +581,30 @@ You are a helpful product assistant. Use the provided context to answer question
     const cacheKey = `${ns}::${query}`;
     let queryVector = this.embeddingCache.get(cacheKey);
 
+    // Determine strategy
+    const strategy = await QueryProcessor.determineRetrievalStrategy(query, this.llmProvider);
+    console.debug(`[Pipeline] Determined retrieval strategy: ${strategy}`);
+
     const [retrievedVector, graphData] = await Promise.all([
-      queryVector ? Promise.resolve(queryVector) : this.embeddingProvider.embed(query, { taskType: 'query' }),
-      this.graphDB && this.config.rag?.useGraphRetrieval
+      // Only embed if we need vector search (strategy is 'vector' or 'both')
+      (strategy === 'vector' || strategy === 'both')
+        ? (queryVector ? Promise.resolve(queryVector) : this.embeddingProvider.embed(query, { taskType: 'query' }))
+        : Promise.resolve([]),
+
+      // Only query graph if we need graph search (strategy is 'graph' or 'both')
+      (strategy === 'graph' || strategy === 'both') && this.graphDB && this.config.rag?.useGraphRetrieval
         ? this.graphDB.query(query)
         : Promise.resolve(undefined)
     ]);
 
-    if (!queryVector) {
+    if ((strategy === 'vector' || strategy === 'both') && !queryVector && retrievedVector && retrievedVector.length > 0) {
       this.embeddingCache.set(cacheKey, retrievedVector);
       queryVector = retrievedVector;
     }
 
-    const sources = await this.vectorDB.query(queryVector, topK, ns, options.filter);
+    const sources = (strategy === 'vector' || strategy === 'both') && queryVector && queryVector.length > 0
+      ? await this.vectorDB.query(queryVector, topK, ns, options.filter)
+      : [];
 
     return { sources, graphData };
   }
@@ -627,14 +640,14 @@ Optimized Search Query:`;
     const ns = namespace ?? this.config.projectId;
 
     try {
-      const { sources } = await this.retrieve(query, { namespace: ns, topK: 3 });
+      const { sources } = await this.retrieve(query, { namespace: ns, topK: 5 });
       if (sources.length === 0) return [];
 
       const context = sources.map((s) => s.content).join('\n\n---\n\n');
-      const prompt = `Based on the following snippets from a document, what are 3 short, relevant questions a user might ask? 
+      const prompt = `Based on the following snippets from a document, what are at least 5 short, relevant questions a user might ask? 
 Focus on questions that can be answered by the context.
 Keep each question under 10 words and make them very specific to the content.
-Return ONLY a JSON array of strings like ["Question 1", "Question 2", "Question 3"].
+Return ONLY a JSON array of strings like ["Question 1", "Question 2", "Question 3", "Question 4", "Question 5"].
 
 Context:
 ${context}
@@ -653,7 +666,7 @@ Suggestions:`;
       if (match) {
         const suggestions = JSON.parse(match[0]);
         if (Array.isArray(suggestions)) {
-          return suggestions.map(s => String(s)).slice(0, 3);
+          return suggestions.map(s => String(s)).slice(0, 5);
         }
       }
     } catch (error) {

package/src/core/QueryProcessor.ts

@@ -198,4 +198,69 @@ export class QueryProcessor {
 
     return filter;
   }
+
+  /**
+   * Determines the retrieval strategy based on the query content.
+   */
+  static async determineRetrievalStrategy(
+    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.
+Given the user query, determine which retrieval mechanism is needed:
+- 'vector': For semantic search, finding specific documents or content based on similarity.
+- 'graph': For finding relationships between entities, multi-hop questions, or network structures.
+- 'both': If the query requires both specific content and relationship/structural analysis.
+
+Query: "${query}"
+
+Return ONLY 'vector', 'graph', or 'both'. No explanation.`;
+
+        const response = await llm.chat(
+          [{ role: 'user', content: prompt }],
+          '',
+          { temperature: 0, maxTokens: 10 }
+        );
+
+        const cleanResponse = response.trim().toLowerCase();
+        if (cleanResponse.includes('vector')) return 'vector';
+        if (cleanResponse.includes('graph')) return 'graph';
+        if (cleanResponse.includes('both')) return 'both';
+      } catch (error) {
+        console.warn('[QueryProcessor] LLM strategy classification failed, falling back to keywords:', error);
+      }
+    }
+
+    // Fallback to keywords
+    const normalized = query.toLowerCase();
+    
+    // Graph keywords
+    const graphKeywords = customGraphKeywords || [
+      '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/rag/Reranker.ts

@@ -1,18 +1,111 @@
 import { VectorMatch } from '../types';
+import { ILLMProvider } from '../llm/ILLMProvider';
 
 export class Reranker {
   /**
-   * Re-ranks matches based on a secondary relevance score.
-   * In a production environment, this would call a Cross-Encoder model.
-   * Here we implement a placeholder that filters by score and limits count.
+   * Re-ranks matches based on a secondary relevance score using an LLM.
    */
   async rerank(
     matches: VectorMatch[], 
     query: string, 
-    limit: number = 5
+    limit: number = 5,
+    llm?: ILLMProvider
   ): Promise<VectorMatch[]> {
-    // Current implementation: sort by original score and apply a strict threshold
-    // and semantic match filtering (placeholder)
+    if (!llm || matches.length <= 1) {
+      // Fallback to deterministic keyword-based re-ranking for production speed
+      const keywords = query.toLowerCase()
+        .replace(/[^\w\s]/g, '')
+        .split(/\s+/)
+        .filter(w => w.length > 2); // Filter out short words/stop words
+
+      if (keywords.length === 0) {
+        return matches
+          .sort((a, b) => b.score - a.score)
+          .slice(0, limit);
+      }
+
+      const scoredMatches = matches.map(match => {
+        const contentLower = match.content.toLowerCase();
+        let keywordScore = 0;
+        
+        keywords.forEach(keyword => {
+          if (contentLower.includes(keyword)) {
+            keywordScore += 1;
+          }
+        });
+
+        // Normalize keyword score (fraction of keywords found)
+        const normalizedKeywordScore = keywordScore / keywords.length;
+
+        // Combine scores: Vector score (usually 0-1) + Keyword score weighted
+        // We give a significant weight to keyword matches to surface specific results
+        const combinedScore = match.score + (normalizedKeywordScore * 0.5);
+
+        return {
+          ...match,
+          score: combinedScore
+        };
+      });
+
+      return scoredMatches
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit);
+    }
+
+    try {
+      // Take top 10 matches to avoid large context and high latency
+      const topN = matches.slice(0, 10);
+      
+      const prompt = `You are a relevance ranking expert.
+Given the following user query and a list of retrieved document chunks, rank the chunks by relevance to the query.
+Return the result as a comma-separated list of document indices in order of relevance, from most relevant to least relevant.
+Use the indices provided in brackets like [0], [1], etc.
+Only return the indices (e.g., "2,0,1"), nothing else. Do not include brackets in the output.
+
+Query: "${query}"
+
+Documents:
+${topN.map((m, i) => `[${i}] ${m.content.replace(/\n/g, ' ')}`).join('\n')}`;
+
+      const response = await llm.chat(
+        [{ role: 'user', content: prompt }],
+        '',
+        { temperature: 0, maxTokens: 50 }
+      );
+
+      const cleanedResponse = response.trim().replace(/[\[\]\s]/g, '');
+      const rankedIndices = cleanedResponse.split(',').map(Number).filter(n => !isNaN(n));
+
+      if (rankedIndices.length > 0) {
+        const rankedMatches: VectorMatch[] = [];
+        const usedIndices = new Set<number>();
+
+        // Add matches in the order specified by the LLM
+        for (const index of rankedIndices) {
+          if (index >= 0 && index < topN.length && !usedIndices.has(index)) {
+            rankedMatches.push(topN[index]);
+            usedIndices.add(index);
+          }
+        }
+
+        // Add any remaining matches that the LLM might have missed
+        for (let i = 0; i < topN.length; i++) {
+          if (!usedIndices.has(i)) {
+            rankedMatches.push(topN[i]);
+          }
+        }
+
+        // Add back the rest of the matches that weren't in the top N
+        const rest = matches.slice(10);
+        rankedMatches.push(...rest);
+
+        return rankedMatches.slice(0, limit);
+      }
+    } catch (error) {
+      console.warn('[Reranker] LLM re-ranking failed, falling back to score-based sorting:', error);
+    }
+
+    // Fallback if LLM fails or returns invalid response
     return matches
       .sort((a, b) => b.score - a.score)
       .slice(0, limit);

package/src/tailwind.css

@@ -0,0 +1,2 @@
+@import "tailwindcss";
+@source "./**/*.{ts,tsx,js,jsx}";

package/src/utils/ProductExtractor.ts

@@ -211,7 +211,6 @@ export function extractProductsFromSources(sources: VectorMatch[] | undefined, i
       const brand = resolveMetadataValue(m, 'brand') as string;
       const price = resolveMetadataValue(m, 'price') as string | number;
       const description = resolveMetadataValue(m, 'description') as string;
-      console.log("🚀 ~ extractProductsFromSources ~ description:", s)
 
       return {
         id: s.id,
@@ -229,7 +228,8 @@ export function extractProductsFromContent(
   content: string,
   payloadText: string,
   payloadCandidates: string[],
-  productsFromSources: Product[]
+  productsFromSources: Product[],
+  isStreaming: boolean = false
 ): { productsFromContent: Product[]; cleanContent: string } {
   const jsonRegex = /```(?:json|ui)?\s*([\s\S]*?)\s*```/g;
   const products: Product[] = [];
@@ -284,7 +284,7 @@ export function extractProductsFromContent(
   const bulletRegex = /^[ \t]*(?:[•*-]|\d+\.)\s+(?:\*\*)?([^\n\-\$–—\(]+?)(?:\*\*)?(?:\s*\(?Price\s*[:\-–—]?\s*)?(?:\s*[:\-–—]\s*|\s+)\$?([\d,.]+)(?:\s*USD)?/gim;
   const matches = Array.from(cleanContent.matchAll(bulletRegex));
 
-  if (matches.length >= 2) {
+  if (!isStreaming && matches.length >= 2) {
     const normalize = (s: string) => s.toLowerCase().replace(/[^a-z0-9]/g, '');
 
     for (const match of matches) {

package/dist/ChromaDBProvider-MIDOR4FW.mjs

@@ -1,8 +0,0 @@
-import {
-  ChromaDBProvider
-} from "./chunk-CFVEZTBJ.mjs";
-import "./chunk-IMP6FUCY.mjs";
-import "./chunk-X4TOT24V.mjs";
-export {
-  ChromaDBProvider
-};