adaptive-memory-multi-model-router 2.12.5 → 2.13.0

package/tmlpd-pi-extension/src/index.ts

@@ -38,6 +38,8 @@ import { BatchProcessor, executeBatch, BatchItem, BatchResult, BatchOptions, Bat
 import { routeQuery, routeBatch, recommendForTask, extractQueryFeatures, updateModelProfile, MODEL_PROFILES, QueryFeatures, ModelProfile, RouteDecision } from "./routing/advancedRouter";
 import { PrefixCache, createWarmedCache, PrefixCacheStats } from "./cache/prefixCache";
 import { SpeculativeDecoder, speculativeBatch, estimateSpeedupPotential, MedusaPredictor, EagleSpeculative, SpeculativeConfig, SpeculativeResult } from "./utils/speculativeDecoding";
+import { executeEnsemble, mergeComplementary, recordFeedback, EnsembleResult, EnsembleConfig } from "./routing/ensembleVoting";
+import { createPresetRouter, getPresetForQuery, DEFAULT_PRESETS, QueryPreset, PresetRouter } from "./routing/queryTypePresets";
 
 // Re-exports
 export { createTMLPD, TMLPDTools, TMLPDConfig, ExecuteResult, ParallelResult, StreamingConfig };
@@ -64,6 +66,12 @@ export { BatchProcessor, executeBatch, BatchItem, BatchResult, BatchOptions, Bat
 // Advanced routing (RouteLLM-style)
 export { routeQuery, routeBatch, recommendForTask, extractQueryFeatures, updateModelProfile, MODEL_PROFILES, QueryFeatures, ModelProfile as ModelProfileType, RouteDecision };
 
+// Ensemble voting (P0) — Core differentiator: parallel multi-LLM execution with confidence merging
+export { executeEnsemble, mergeComplementary, recordFeedback, EnsembleResult, EnsembleConfig };
+
+// Query-type presets (P1) — Configurable provider+temp profiles per query type
+export { createPresetRouter, getPresetForQuery, DEFAULT_PRESETS, QueryPreset, PresetRouter };
+
 // Prefix caching (RadixAttention-style)
 export { PrefixCache, createWarmedCache, PrefixCacheStats };
 

package/tmlpd-pi-extension/src/memory/episodicMemory.ts

@@ -44,10 +44,13 @@ export class EpisodicMemoryStore {
   private entries: EpisodicEntry[] = [];
   private maxEntries: number;
   private keywordIndex: Map<string, string[]>;
+  private persistencePath: string | null;
 
-  constructor(maxEntries = 1000) {
+  constructor(maxEntries = 1000, persistencePath?: string) {
     this.maxEntries = maxEntries;
     this.keywordIndex = new Map();
+    this.persistencePath = persistencePath || null;
+    if (this.persistencePath) this.loadFromDisk();
   }
 
   /**
@@ -62,6 +65,7 @@ export class EpisodicMemoryStore {
     };
 
     this.entries.push(fullEntry);
+    this.autoPersist();
 
     // Index keywords
     if (entry.task.description) {
@@ -162,11 +166,79 @@ export class EpisodicMemoryStore {
   }
 
   /**
-   * Clear all memories
+   * Persist current memory to disk as JSON
+   */
+  saveToDisk(): boolean {
+    if (!this.persistencePath) return false;
+    try {
+      const fs = require('fs');
+      const data = JSON.stringify({ entries: this.entries, maxEntries: this.maxEntries }, null, 2);
+      fs.writeFileSync(this.persistencePath, data, 'utf8');
+      return true;
+    } catch (e) {
+      console.error('❌ Memory persist failed:', (e as Error).message);
+      return false;
+    }
+  }
+
+  /**
+   * Load memory from disk JSON
+   */
+  loadFromDisk(): boolean {
+    if (!this.persistencePath) return false;
+    try {
+      const fs = require('fs');
+      if (!fs.existsSync(this.persistencePath)) return false;
+      const data = JSON.parse(fs.readFileSync(this.persistencePath, 'utf8'));
+      if (data.entries && Array.isArray(data.entries)) {
+        this.entries = data.entries;
+        this.maxEntries = data.maxEntries || this.maxEntries;
+        this.rebuildIndex();
+        return true;
+      }
+      return false;
+    } catch (e) {
+      console.error('❌ Memory load failed:', (e as Error).message);
+      return false;
+    }
+  }
+
+  /**
+   * Rebuild keyword index from loaded entries
+   */
+  private rebuildIndex(): void {
+    this.keywordIndex.clear();
+    for (const entry of this.entries) {
+      const words = (entry.task.description + ' ' + (entry.result.output || '')).toLowerCase().split(/\s+/);
+      for (const word of new Set(words)) {
+        if (word.length < 3) continue;
+        if (!this.keywordIndex.has(word)) this.keywordIndex.set(word, []);
+        this.keywordIndex.get(word)!.push(entry.id);
+      }
+    }
+  }
+
+  /**
+   * Auto-persist after adding new entries (if path configured)
+   */
+  private autoPersist(): void {
+    if (this.persistencePath && this.entries.length % 3 === 0) {
+      this.saveToDisk();
+    }
+  }
+
+  /**
+   * Clear all memories (also removes persisted file)
    */
   clear() {
     this.entries = [];
     this.keywordIndex.clear();
+    if (this.persistencePath) {
+      try {
+        const fs = require('fs');
+        if (fs.existsSync(this.persistencePath)) fs.unlinkSync(this.persistencePath);
+      } catch {}
+    }
   }
 }
 

package/tmlpd-pi-extension/src/routing/ensembleVoting.ts

@@ -0,0 +1,159 @@
+/**
+ * TMLPD - Ensemble Voting (P0)
+ * 
+ * Parallel multi-LLM execution with confidence-weighted result merging.
+ * This is TMLPD's core differentiator: nobody else does parallel ensemble.
+ * 
+ * Runs N providers simultaneously on the same query, scores each result,
+ * and returns the best one with explanation of why it was chosen.
+ */
+
+export interface EnsembleResult {
+  best: string;
+  winner: string;
+  runnerUp: string | null;
+  scores: Record<string, number>;
+  allResults: Record<string, string | null>;
+  reasoning: string;
+  timing: { totalMs: number; perProvider: Record<string, number> };
+}
+
+export interface EnsembleConfig {
+  providers: string[];
+  timeoutMs: number;
+  minProviders: number;        // minimum to proceed (default 2)
+  scoringWeights: {
+    lengthPenalty: number;      // penalize extremely short/long (0-1)
+    recencyBoost: number;       // prefer newer provider patterns
+    historicalAccuracy: number; // weight from past performance
+  };
+}
+
+const DEFAULT_CONFIG: EnsembleConfig = {
+  providers: ['nvidia', 'groq'],
+  timeoutMs: 30000,
+  minProviders: 1,
+  scoringWeights: { lengthPenalty: 0.3, recencyBoost: 0.2, historicalAccuracy: 0.5 }
+};
+
+/**
+ * Execute a query across multiple providers IN PARALLEL and score results.
+ * Returns the best answer with full provenance.
+ */
+export async function executeEnsemble(
+  query: string,
+  systemPrompt: string,
+  context: string,
+  providerExecutors: Record<string, (q: string, sys: string, ctx: string) => Promise<string | null>>,
+  config: Partial<EnsembleConfig> = {}
+): Promise<EnsembleResult> {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  const start = Date.now();
+  const perProvider: Record<string, number> = {};
+
+  // Step 1: Fire ALL providers in parallel
+  const results = await Promise.allSettled(
+    cfg.providers.map(async (name) => {
+      const pStart = Date.now();
+      try {
+        const executor = providerExecutors[name];
+        if (!executor) throw new Error(`No executor for ${name}`);
+        const result = await executor(query, systemPrompt, context);
+        perProvider[name] = Date.now() - pStart;
+        return { provider: name, result };
+      } catch (e) {
+        perProvider[name] = Date.now() - pStart;
+        return { provider: name, result: null };
+      }
+    })
+  );
+
+  const allResults: Record<string, string | null> = {};
+  for (const r of results) {
+    if (r.status === 'fulfilled') {
+      allResults[r.value.provider] = r.value.result;
+    }
+  }
+
+  // Step 2: Score each result
+  const scores: Record<string, number> = {};
+  for (const name of cfg.providers) {
+    const text = allResults[name];
+    if (!text) { scores[name] = 0; continue; }
+
+    let score = 50; // baseline
+
+    // Length score: penalize extremely short (<50 chars) or very long (>5000)
+    if (cfg.scoringWeights.lengthPenalty > 0) {
+      const len = text.length;
+      if (len < 50) score -= 20;
+      else if (len < 100) score -= 5;
+      else if (len > 5000) score -= 10;
+      else if (len > 200) score += cfg.scoringWeights.lengthPenalty * 10;
+    }
+
+    // Specificity score: presence of concrete details
+    const hasNumbers = /\d+/.test(text);
+    const hasTechNames = /[A-Z][a-z]+\.(js|ts|py|json)/.test(text) || /\b(API|SDK|CLI|npm|docker|redis|gcs|faiss)\b/i.test(text);
+    const hasBullets = text.includes('*') || text.includes('-') || text.includes('1.');
+    if (hasNumbers) score += 10;
+    if (hasTechNames) score += 15;
+    if (hasBullets) score += 5;
+
+    // Structure score: well-formatted responses
+    if (text.split('\n').length >= 5) score += 5;
+
+    scores[name] = score;
+  }
+
+  // Step 3: Determine winner and runner-up
+  const sorted = Object.entries(scores).sort((a, b) => b[1] - a[1]);
+  const winner = sorted[0]?.[0] || cfg.providers[0];
+  const runnerUp = sorted[1]?.[0] || null;
+  const best = allResults[winner] || allResults[runnerUp || ''] || '';
+
+  const reasoning = winner === runnerUp
+    ? `Single provider returned results: ${winner}`
+    : `Ensemble merged ${cfg.providers.filter(p => !!allResults[p]).length} providers. ` +
+      `${winner} scored ${scores[winner].toFixed(0)} (${describeScore(scores[winner])}) vs ` +
+      `${runnerUp} at ${runnerUp ? scores[runnerUp]?.toFixed(0) : 'N/A'}.`;
+
+  return {
+    best,
+    winner,
+    runnerUp,
+    scores,
+    allResults,
+    reasoning,
+    timing: { totalMs: Date.now() - start, perProvider }
+  };
+}
+
+function describeScore(score: number): string {
+  if (score >= 80) return 'high confidence';
+  if (score >= 60) return 'moderate confidence';
+  return 'low confidence';
+}
+
+/**
+ * Merge multiple text results into a combined response.
+ * Used when providers give complementary answers.
+ */
+export function mergeComplementary(results: string[], maxLength: number = 4000): string {
+  const sections = results.filter(r => !!r).map((r, i) => `### Provider ${i + 1}\n${r.trim()}`);
+  return sections.join('\n\n---\n\n').slice(0, maxLength);
+}
+
+/**
+ * Update historical accuracy for a provider based on user feedback.
+ */
+export function recordFeedback(
+  winner: string,
+  wasHelpful: boolean,
+  history: Record<string, { good: number; bad: number }>
+): Record<string, { good: number; bad: number }> {
+  if (!history[winner]) history[winner] = { good: 0, bad: 0 };
+  if (wasHelpful) history[winner].good++;
+  else history[winner].bad++;
+  return history;
+}

package/tmlpd-pi-extension/src/routing/queryTypePresets.ts

@@ -0,0 +1,136 @@
+/**
+ * TMLPD - Query-Type Presets (P1)
+ * 
+ * Configurable provider + temperature profiles per query type.
+ * Replaces flat regex patterns with named, adjustable presets.
+ * This productizes what Reddit users do manually: route different
+ * task types to different providers with different settings.
+ */
+
+export interface QueryPreset {
+  name: string;
+  description: string;
+  provider: string;         // primary provider
+  fallbackProvider?: string;
+  temperature: number;
+  maxTokens: number;
+  ensemble: boolean;        // use ensemble voting?
+  ensembleProviders?: string[];
+  timeoutMs: number;
+  systemPrompt?: string;
+}
+
+export interface PresetRouter {
+  presets: Record<string, QueryPreset>;
+  defaultPreset: string;
+  classify: (query: string) => string;
+}
+
+// ============================================================
+// DEFAULT PRESETS
+// ============================================================
+
+export const DEFAULT_PRESETS: Record<string, QueryPreset> = {
+  fast: {
+    name: 'Fast Query',
+    description: 'Quick lookups, simple questions, status checks',
+    provider: 'groq',
+    temperature: 0.3,
+    maxTokens: 500,
+    ensemble: false,
+    timeoutMs: 15000,
+    systemPrompt: 'Answer concisely in 1-2 sentences.',
+  },
+  research: {
+    name: 'Research / Deep Analysis',
+    description: 'Complex multi-step reasoning, comparisons, deep dives',
+    provider: 'nvidia',
+    fallbackProvider: 'groq',
+    temperature: 0.3,
+    maxTokens: 3000,
+    ensemble: true,
+    ensembleProviders: ['nvidia', 'groq'],
+    timeoutMs: 60000,
+    systemPrompt: 'Provide thorough analysis with specific technical details and examples.',
+  },
+  creative: {
+    name: 'Creative / Writing',
+    description: 'Content generation, storytelling, brainstorming',
+    provider: 'nvidia',
+    temperature: 0.7,
+    maxTokens: 2500,
+    ensemble: false,
+    timeoutMs: 45000,
+    systemPrompt: 'Be creative and engaging. Use vivid language.',
+  },
+  code: {
+    name: 'Code / Technical',
+    description: 'Code generation, debugging, architecture, implementation',
+    provider: 'nvidia',
+    fallbackProvider: 'groq',
+    temperature: 0.2,
+    maxTokens: 3000,
+    ensemble: true,
+    ensembleProviders: ['nvidia', 'groq'],
+    timeoutMs: 45000,
+    systemPrompt: 'Be precise. Show code with clear explanations. Prefer working solutions over theoretical ones.',
+  },
+  factual: {
+    name: 'Factual / Q&A',
+    description: 'Direct answers with citations, definitions, explanations',
+    provider: 'groq',
+    temperature: 0.2,
+    maxTokens: 1000,
+    ensemble: false,
+    timeoutMs: 20000,
+    systemPrompt: 'Answer factually. If unsure, say so. Be concise.',
+  },
+};
+
+// ============================================================
+// CLASSIFICATION PATTERNS
+// ============================================================
+
+const PATTERNS: Array<{ rx: RegExp; preset: string }> = [
+  { rx: /\b(debug|error|bug|fix|crash|exception|fail|broken|compile)\b/i, preset: 'code' },
+  { rx: /\b(code|function|api|endpoint|syntax|npm|import|implement|class|algorithm)\b/i, preset: 'code' },
+  { rx: /\b(story|poem|write|create|generate|tweet|post|article|content|draft|compose|creative)\b/i, preset: 'creative' },
+  { rx: /\b(architecture|design|pattern|database|cache|queue|latency|throughput|scal|deploy|optimize|refactor)\b/i, preset: 'research' },
+  { rx: /\b(compare|analyze|evaluate|difference|pros|cons|tradeoff|vs\b|research|deep|comprehensive)\b/i, preset: 'research' },
+  { rx: /\b(what is|define|explain|meaning|definition|describe|how does)\b/i, preset: 'factual' },
+];
+
+// ============================================================
+// PRESET ROUTER
+// ============================================================
+
+export function createPresetRouter(customPresets?: Record<string, QueryPreset>): PresetRouter {
+  const presets = { ...DEFAULT_PRESETS, ...customPresets };
+
+  return {
+    presets,
+    defaultPreset: 'fast',
+
+    classify(query: string): string {
+      for (const p of PATTERNS) {
+        if (p.rx.test(query)) return p.preset;
+      }
+      // Length-based classification
+      const words = query.split(/\s+/).length;
+      if (words > 30) return 'research';
+      if (words > 10) return 'factual';
+      return 'fast';
+    }
+  };
+}
+
+/**
+ * Get preset config for a query, with fallback to default.
+ */
+export function getPresetForQuery(
+  query: string,
+  router: PresetRouter
+): QueryPreset {
+  const presetName = router.classify(query);
+  return router.presets[presetName] || router.presets[router.defaultPreset];
+}