cozo-memory 1.1.4 → 1.1.6

package/dist/adaptive-query-fusion.js

@@ -0,0 +1,397 @@
+"use strict";
+/**
+ * Adaptive Query Fusion with Dynamic Weights
+ *
+ * Based on 2026 SOTA Research:
+ * - Meilisearch Adaptive RAG (2025)
+ * - FEEG Framework: Finder, Evaluator, Explainer, Generator (Samuel et al., 2026)
+ * - ORCAS-I Intent Classifier (Alexander et al., 2022)
+ * - Query Intent Classification Research (2025)
+ *
+ * Combines:
+ * 1. Heuristic keyword-based classification (fast, reliable)
+ * 2. LLM-based classification (accurate, semantic understanding)
+ * 3. Adaptive weight selection based on query type
+ * 4. Fallback mechanisms for robustness
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdaptiveQueryFusion = exports.QueryComplexity = exports.QueryIntent = void 0;
+// Query Intent Types (FEEG Framework)
+var QueryIntent;
+(function (QueryIntent) {
+    QueryIntent["FINDER"] = "finder";
+    QueryIntent["EVALUATOR"] = "evaluator";
+    QueryIntent["EXPLAINER"] = "explainer";
+    QueryIntent["GENERATOR"] = "generator"; // Generate new content (G)
+})(QueryIntent || (exports.QueryIntent = QueryIntent = {}));
+// Query Complexity Levels
+var QueryComplexity;
+(function (QueryComplexity) {
+    QueryComplexity["SIMPLE"] = "simple";
+    QueryComplexity["MODERATE"] = "moderate";
+    QueryComplexity["COMPLEX"] = "complex";
+    QueryComplexity["EXPLORATORY"] = "exploratory"; // Open-ended, broad search
+})(QueryComplexity || (exports.QueryComplexity = QueryComplexity = {}));
+/**
+ * Adaptive Query Fusion Engine
+ *
+ * Classifies queries and selects optimal search weights dynamically
+ */
+class AdaptiveQueryFusion {
+    db;
+    embeddingService;
+    config;
+    classificationCache;
+    // Keyword patterns for heuristic classification
+    FINDER_KEYWORDS = [
+        'what', 'when', 'where', 'who', 'how many', 'specific',
+        'find', 'search', 'look for', 'get', 'retrieve',
+        'latest', 'recent', 'current', 'today', 'news'
+    ];
+    EVALUATOR_KEYWORDS = [
+        'compare', 'difference', 'versus', 'vs', 'better',
+        'evaluate', 'assess', 'analyze', 'review', 'rate',
+        'pros', 'cons', 'advantages', 'disadvantages'
+    ];
+    EXPLAINER_KEYWORDS = [
+        'why', 'how', 'explain', 'understand', 'about',
+        'describe', 'tell me', 'what is', 'concept',
+        'meaning', 'definition', 'work', 'process'
+    ];
+    GENERATOR_KEYWORDS = [
+        'create', 'generate', 'write', 'make', 'build',
+        'suggest', 'recommend', 'example', 'template',
+        'code', 'script', 'plan', 'strategy'
+    ];
+    // Predefined weight configurations for each intent
+    WEIGHT_CONFIGS = {
+        [QueryIntent.FINDER]: {
+            [QueryComplexity.SIMPLE]: {
+                vector: 0.4,
+                sparse: 0.5, // High keyword matching for factual queries
+                fts: 0.1,
+                graph: 0.0
+            },
+            [QueryComplexity.MODERATE]: {
+                vector: 0.45,
+                sparse: 0.35,
+                fts: 0.15,
+                graph: 0.05
+            },
+            [QueryComplexity.COMPLEX]: {
+                vector: 0.5,
+                sparse: 0.25,
+                fts: 0.15,
+                graph: 0.1
+            },
+            [QueryComplexity.EXPLORATORY]: {
+                vector: 0.4,
+                sparse: 0.2,
+                fts: 0.2,
+                graph: 0.2
+            }
+        },
+        [QueryIntent.EVALUATOR]: {
+            [QueryComplexity.SIMPLE]: {
+                vector: 0.5,
+                sparse: 0.3,
+                fts: 0.1,
+                graph: 0.1
+            },
+            [QueryComplexity.MODERATE]: {
+                vector: 0.5,
+                sparse: 0.2,
+                fts: 0.1,
+                graph: 0.2
+            },
+            [QueryComplexity.COMPLEX]: {
+                vector: 0.45,
+                sparse: 0.15,
+                fts: 0.1,
+                graph: 0.3
+            },
+            [QueryComplexity.EXPLORATORY]: {
+                vector: 0.4,
+                sparse: 0.1,
+                fts: 0.1,
+                graph: 0.4
+            }
+        },
+        [QueryIntent.EXPLAINER]: {
+            [QueryComplexity.SIMPLE]: {
+                vector: 0.6,
+                sparse: 0.2,
+                fts: 0.1,
+                graph: 0.1
+            },
+            [QueryComplexity.MODERATE]: {
+                vector: 0.55,
+                sparse: 0.15,
+                fts: 0.1,
+                graph: 0.2
+            },
+            [QueryComplexity.COMPLEX]: {
+                vector: 0.5,
+                sparse: 0.1,
+                fts: 0.1,
+                graph: 0.3
+            },
+            [QueryComplexity.EXPLORATORY]: {
+                vector: 0.45,
+                sparse: 0.1,
+                fts: 0.1,
+                graph: 0.35
+            }
+        },
+        [QueryIntent.GENERATOR]: {
+            [QueryComplexity.SIMPLE]: {
+                vector: 0.5,
+                sparse: 0.3,
+                fts: 0.1,
+                graph: 0.1
+            },
+            [QueryComplexity.MODERATE]: {
+                vector: 0.45,
+                sparse: 0.25,
+                fts: 0.15,
+                graph: 0.15
+            },
+            [QueryComplexity.COMPLEX]: {
+                vector: 0.4,
+                sparse: 0.2,
+                fts: 0.2,
+                graph: 0.2
+            },
+            [QueryComplexity.EXPLORATORY]: {
+                vector: 0.35,
+                sparse: 0.15,
+                fts: 0.2,
+                graph: 0.3
+            }
+        }
+    };
+    constructor(db, embeddingService, config) {
+        this.db = db;
+        this.embeddingService = embeddingService;
+        this.classificationCache = new Map();
+        this.config = {
+            enableLLM: true,
+            llmModel: 'demyagent-4b-i1:Q6_K',
+            heuristicThreshold: 0.7,
+            cacheClassifications: true,
+            maxCacheSize: 1000,
+            ...config
+        };
+    }
+    /**
+     * Classify query using hybrid approach (heuristic + LLM)
+     */
+    async classifyQuery(query) {
+        // Check cache first
+        if (this.config.cacheClassifications) {
+            const cached = this.classificationCache.get(query);
+            if (cached) {
+                console.error(`[AdaptiveQueryFusion] Cache hit for query: "${query}"`);
+                return cached;
+            }
+        }
+        // Step 1: Heuristic classification (fast)
+        const heuristicResult = this.classifyHeuristic(query);
+        console.error(`[AdaptiveQueryFusion] Heuristic result: ${heuristicResult.intent} (confidence: ${heuristicResult.confidence.toFixed(2)})`);
+        // Step 2: If heuristic confidence is high enough, use it
+        if (heuristicResult.confidence >= this.config.heuristicThreshold) {
+            const result = {
+                ...heuristicResult,
+                method: 'heuristic'
+            };
+            this.cacheClassification(query, result);
+            return result;
+        }
+        // Step 3: Try LLM classification if enabled and heuristic confidence is low
+        if (this.config.enableLLM) {
+            try {
+                const llmResult = await this.classifyLLM(query);
+                console.error(`[AdaptiveQueryFusion] LLM result: ${llmResult.intent} (confidence: ${llmResult.confidence.toFixed(2)})`);
+                const result = {
+                    ...llmResult,
+                    method: 'llm'
+                };
+                this.cacheClassification(query, result);
+                return result;
+            }
+            catch (error) {
+                console.error(`[AdaptiveQueryFusion] LLM classification failed, falling back to heuristic:`, error);
+            }
+        }
+        // Step 4: Fallback to heuristic
+        const result = {
+            ...heuristicResult,
+            method: 'hybrid'
+        };
+        this.cacheClassification(query, result);
+        return result;
+    }
+    /**
+     * Heuristic-based query classification using keywords
+     */
+    classifyHeuristic(query) {
+        const queryLower = query.toLowerCase();
+        const words = queryLower.split(/\s+/);
+        // Count keyword matches for each intent
+        const intentScores = {
+            [QueryIntent.FINDER]: this.countMatches(queryLower, this.FINDER_KEYWORDS),
+            [QueryIntent.EVALUATOR]: this.countMatches(queryLower, this.EVALUATOR_KEYWORDS),
+            [QueryIntent.EXPLAINER]: this.countMatches(queryLower, this.EXPLAINER_KEYWORDS),
+            [QueryIntent.GENERATOR]: this.countMatches(queryLower, this.GENERATOR_KEYWORDS)
+        };
+        // Find dominant intent
+        let dominantIntent = QueryIntent.FINDER;
+        let maxScore = 0;
+        for (const [intent, score] of Object.entries(intentScores)) {
+            if (score > maxScore) {
+                maxScore = score;
+                dominantIntent = intent;
+            }
+        }
+        // Calculate confidence (0.0 - 1.0)
+        const totalScore = Object.values(intentScores).reduce((a, b) => a + b, 0);
+        const confidence = totalScore > 0 ? maxScore / totalScore : 0.5;
+        // Classify complexity
+        const complexity = this.classifyComplexity(query, words);
+        // Extract keywords
+        const keywords = words.filter(w => w.length > 3);
+        return {
+            intent: dominantIntent,
+            complexity,
+            confidence,
+            keywords,
+            reasoning: `Heuristic classification: ${dominantIntent} (${(confidence * 100).toFixed(0)}% confidence)`
+        };
+    }
+    /**
+     * LLM-based query classification using Ollama
+     */
+    async classifyLLM(query) {
+        try {
+            // Dynamic import to avoid hard dependency
+            const ollamaModule = await import('ollama');
+            const ollama = ollamaModule?.default ?? ollamaModule;
+            const systemPrompt = `You are a query classification expert. Classify the user's query into one of these categories:
+- "finder": Seeking factual information (what, when, where, who, how many)
+- "evaluator": Comparing or evaluating content (compare, difference, better)
+- "explainer": Understanding concepts (why, how, explain)
+- "generator": Creating or generating content (create, write, suggest)
+
+Also classify complexity as: "simple", "moderate", "complex", or "exploratory"
+
+Respond with JSON: {"intent": "...", "complexity": "...", "confidence": 0.0-1.0, "reasoning": "..."}`;
+            const response = await ollama.chat({
+                model: this.config.llmModel,
+                messages: [
+                    { role: 'system', content: systemPrompt },
+                    { role: 'user', content: query }
+                ],
+                format: 'json'
+            });
+            let responseText = response?.message?.content?.trim?.() ?? '';
+            // Clean markdown formatting if present
+            if (responseText.startsWith('```json')) {
+                responseText = responseText.replace(/```json/g, '').replace(/```/g, '').trim();
+            }
+            else if (responseText.startsWith('```')) {
+                responseText = responseText.replace(/```/g, '').trim();
+            }
+            const parsed = JSON.parse(responseText);
+            return {
+                intent: (parsed.intent || QueryIntent.FINDER),
+                complexity: (parsed.complexity || QueryComplexity.MODERATE),
+                confidence: Math.min(1.0, Math.max(0.0, parsed.confidence || 0.8)),
+                keywords: query.split(/\s+/).filter(w => w.length > 3),
+                reasoning: parsed.reasoning || 'LLM classification'
+            };
+        }
+        catch (error) {
+            console.error('[AdaptiveQueryFusion] LLM classification error:', error);
+            throw error;
+        }
+    }
+    /**
+     * Classify query complexity based on heuristics
+     */
+    classifyComplexity(query, words) {
+        const queryLower = query.toLowerCase();
+        // Simple: Short, direct questions
+        if (words.length <= 4 && /^(what|when|where|who|how many)\s/.test(queryLower)) {
+            return QueryComplexity.SIMPLE;
+        }
+        // Exploratory: Open-ended, broad
+        if (/^(all|everything|explore|overview|general|summary|list)\b/.test(queryLower)) {
+            return QueryComplexity.EXPLORATORY;
+        }
+        // Complex: Multiple concepts, reasoning required
+        const complexIndicators = ['and', 'or', 'but', 'however', 'relationship', 'connection', 'impact'];
+        const complexCount = complexIndicators.filter(ind => queryLower.includes(ind)).length;
+        if (complexCount >= 2 || words.length > 15) {
+            return QueryComplexity.COMPLEX;
+        }
+        // Moderate: Default
+        return QueryComplexity.MODERATE;
+    }
+    /**
+     * Count keyword matches in query
+     */
+    countMatches(query, keywords) {
+        return keywords.filter(keyword => query.includes(keyword)).length;
+    }
+    /**
+     * Cache classification result
+     */
+    cacheClassification(query, classification) {
+        if (!this.config.cacheClassifications)
+            return;
+        // Simple LRU: remove oldest if cache is full
+        if (this.classificationCache.size >= this.config.maxCacheSize) {
+            const firstKey = this.classificationCache.keys().next().value;
+            if (firstKey !== undefined) {
+                this.classificationCache.delete(firstKey);
+            }
+        }
+        this.classificationCache.set(query, classification);
+    }
+    /**
+     * Get adaptive search weights for a query
+     */
+    async getAdaptiveWeights(query) {
+        const classification = await this.classifyQuery(query);
+        const weights = this.WEIGHT_CONFIGS[classification.intent][classification.complexity];
+        console.error(`[AdaptiveQueryFusion] Weights for "${query}":`, {
+            intent: classification.intent,
+            complexity: classification.complexity,
+            weights
+        });
+        return weights;
+    }
+    /**
+     * Get classification details for debugging
+     */
+    async getClassificationDetails(query) {
+        return this.classifyQuery(query);
+    }
+    /**
+     * Clear cache
+     */
+    clearCache() {
+        this.classificationCache.clear();
+        console.error('[AdaptiveQueryFusion] Cache cleared');
+    }
+    /**
+     * Get cache statistics
+     */
+    getCacheStats() {
+        return {
+            size: this.classificationCache.size,
+            maxSize: this.config.maxCacheSize
+        };
+    }
+}
+exports.AdaptiveQueryFusion = AdaptiveQueryFusion;

package/dist/dynamic-fusion.js

@@ -14,6 +14,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DynamicFusionSearch = exports.DEFAULT_FUSION_CONFIG = void 0;
+const adaptive_query_fusion_1 = require("./adaptive-query-fusion");
 /**
  * Default fusion configuration
  */
@@ -58,19 +59,33 @@ exports.DEFAULT_FUSION_CONFIG = {
 class DynamicFusionSearch {
     db;
     embeddings;
+    adaptiveQueryFusion;
     constructor(db, embeddings) {
         this.db = db;
         this.embeddings = embeddings;
+        this.adaptiveQueryFusion = new adaptive_query_fusion_1.AdaptiveQueryFusion(db, embeddings, {
+            enableLLM: true,
+            cacheClassifications: true,
+            maxCacheSize: 1000
+        });
     }
     /**
-     * Execute dynamic fusion search
+     * Execute dynamic fusion search with adaptive weights
      */
     async search(query, config = {}) {
         const startTime = Date.now();
-        // Merge with defaults
+        // Get adaptive weights based on query classification
+        const adaptiveWeights = await this.adaptiveQueryFusion.getAdaptiveWeights(query);
+        // Merge config with defaults first, then apply adaptive weights
         const fullConfig = this.mergeConfig(config);
-        console.log('[DynamicFusion] Starting search with config:', {
+        // Override weights with adaptive values
+        fullConfig.vector.weight = adaptiveWeights.vector;
+        fullConfig.sparse.weight = adaptiveWeights.sparse;
+        fullConfig.fts.weight = adaptiveWeights.fts;
+        fullConfig.graph.weight = adaptiveWeights.graph;
+        console.log('[DynamicFusion] Starting search with adaptive weights:', {
             query,
+            weights: adaptiveWeights,
             enabledPaths: this.getEnabledPaths(fullConfig)
         });
         // Execute all enabled paths in parallel
@@ -82,7 +97,8 @@ class DynamicFusionSearch {
         console.log('[DynamicFusion] Search completed:', {
             totalResults: fusedResults.length,
             pathContributions: stats.pathContributions,
-            fusionTime: stats.fusionTime
+            fusionTime: stats.fusionTime,
+            adaptiveWeights
         });
         return { results: fusedResults, stats };
     }
@@ -576,10 +592,31 @@ class DynamicFusionSearch {
      */
     mergeConfig(config) {
         return {
-            vector: { ...exports.DEFAULT_FUSION_CONFIG.vector, ...config.vector },
-            sparse: { ...exports.DEFAULT_FUSION_CONFIG.sparse, ...config.sparse },
-            fts: { ...exports.DEFAULT_FUSION_CONFIG.fts, ...config.fts },
-            graph: { ...exports.DEFAULT_FUSION_CONFIG.graph, ...config.graph },
+            vector: {
+                enabled: config.vector?.enabled ?? exports.DEFAULT_FUSION_CONFIG.vector.enabled,
+                weight: config.vector?.weight ?? exports.DEFAULT_FUSION_CONFIG.vector.weight,
+                topK: config.vector?.topK ?? exports.DEFAULT_FUSION_CONFIG.vector.topK,
+                efSearch: config.vector?.efSearch ?? exports.DEFAULT_FUSION_CONFIG.vector.efSearch
+            },
+            sparse: {
+                enabled: config.sparse?.enabled ?? exports.DEFAULT_FUSION_CONFIG.sparse.enabled,
+                weight: config.sparse?.weight ?? exports.DEFAULT_FUSION_CONFIG.sparse.weight,
+                topK: config.sparse?.topK ?? exports.DEFAULT_FUSION_CONFIG.sparse.topK,
+                minScore: config.sparse?.minScore ?? exports.DEFAULT_FUSION_CONFIG.sparse.minScore
+            },
+            fts: {
+                enabled: config.fts?.enabled ?? exports.DEFAULT_FUSION_CONFIG.fts.enabled,
+                weight: config.fts?.weight ?? exports.DEFAULT_FUSION_CONFIG.fts.weight,
+                topK: config.fts?.topK ?? exports.DEFAULT_FUSION_CONFIG.fts.topK,
+                fuzzy: config.fts?.fuzzy ?? exports.DEFAULT_FUSION_CONFIG.fts.fuzzy
+            },
+            graph: {
+                enabled: config.graph?.enabled ?? exports.DEFAULT_FUSION_CONFIG.graph.enabled,
+                weight: config.graph?.weight ?? exports.DEFAULT_FUSION_CONFIG.graph.weight,
+                maxDepth: config.graph?.maxDepth ?? exports.DEFAULT_FUSION_CONFIG.graph.maxDepth,
+                maxResults: config.graph?.maxResults ?? exports.DEFAULT_FUSION_CONFIG.graph.maxResults,
+                relationTypes: config.graph?.relationTypes ?? exports.DEFAULT_FUSION_CONFIG.graph.relationTypes
+            },
             fusion: { ...exports.DEFAULT_FUSION_CONFIG.fusion, ...config.fusion }
         };
     }
@@ -598,5 +635,23 @@ class DynamicFusionSearch {
             paths.push('graph');
         return paths;
     }
+    /**
+     * Get query classification details (for debugging/transparency)
+     */
+    async getQueryClassification(query) {
+        return this.adaptiveQueryFusion.getClassificationDetails(query);
+    }
+    /**
+     * Clear classification cache
+     */
+    clearClassificationCache() {
+        this.adaptiveQueryFusion.clearCache();
+    }
+    /**
+     * Get cache statistics
+     */
+    getClassificationCacheStats() {
+        return this.adaptiveQueryFusion.getCacheStats();
+    }
 }
 exports.DynamicFusionSearch = DynamicFusionSearch;