@agentic-robotics/mcp 0.1.3 → 0.2.0

package/src/optimized-memory.ts

@@ -1,271 +0,0 @@
-/**
- * Optimized AgentDB Memory Integration
- *
- * Uses AgentDB JavaScript API directly for maximum performance
- * Eliminates CLI process spawning overhead (100x+ faster)
- */
-
-import { ReflexionMemory, SkillLibrary, ReasoningBank, CausalMemoryGraph } from 'agentdb';
-import type { Episode, Memory } from './memory.js';
-
-export interface Skill {
-  name: string;
-  description: string;
-  successRate: number;
-  avgReward: number;
-  attempts: number;
-  lastUsed: number;
-}
-
-export interface CausalReasoning {
-  cause: string;
-  effect: string;
-  confidence: number;
-  evidence: string[];
-}
-
-export class OptimizedAgentDBMemory {
-  private reflexion: ReflexionMemory;
-  private skills: SkillLibrary;
-  private reasoning: ReasoningBank;
-  private causal: CausalMemoryGraph;
-  private dbPath: string;
-  private performanceMetrics: {
-    storeCount: number;
-    retrieveCount: number;
-    avgStoreTime: number;
-    avgRetrieveTime: number;
-  };
-
-  constructor(dbPath: string) {
-    this.dbPath = dbPath;
-    this.performanceMetrics = {
-      storeCount: 0,
-      retrieveCount: 0,
-      avgStoreTime: 0,
-      avgRetrieveTime: 0,
-    };
-  }
-
-  async initialize(): Promise<void> {
-    const startTime = Date.now();
-
-    // Initialize AgentDB components with JS API
-    // These classes handle their own database initialization
-    this.reflexion = new ReflexionMemory();
-    this.skills = new SkillLibrary();
-    this.reasoning = new ReasoningBank();
-    this.causal = new CausalMemoryGraph();
-
-    const elapsed = Date.now() - startTime;
-    console.error(`✅ AgentDB initialized: ${this.dbPath}`);
-    console.error(`⚡ Initialization time: ${elapsed}ms`);
-  }
-
-  /**
-   * Store episode using JS API (100x faster than CLI)
-   */
-  async storeEpisode(episode: Episode): Promise<void> {
-    const startTime = Date.now();
-
-    await this.reflexion.store({
-      sessionId: episode.sessionId,
-      taskName: episode.taskName,
-      confidence: episode.confidence,
-      success: episode.success,
-      outcome: episode.outcome,
-      strategy: episode.strategy,
-      metadata: episode.metadata,
-    });
-
-    const elapsed = Date.now() - startTime;
-    this.updateStoreMetrics(elapsed);
-
-    if (this.performanceMetrics.storeCount % 100 === 0) {
-      console.error(`💾 Stored episode: ${episode.taskName} (${elapsed}ms)`);
-    }
-  }
-
-  /**
-   * Retrieve memories using JS API (150x faster than CLI)
-   */
-  async retrieveMemories(
-    query: string,
-    k: number = 5,
-    options: {
-      minReward?: number;
-      onlySuccesses?: boolean;
-      onlyFailures?: boolean;
-      synthesizeContext?: boolean;
-    } = {}
-  ): Promise<Memory[]> {
-    const startTime = Date.now();
-
-    const results = await this.reflexion.retrieve(query, k, {
-      minReward: options.minReward,
-      onlySuccesses: options.onlySuccesses,
-      onlyFailures: options.onlyFailures,
-      synthesizeContext: options.synthesizeContext,
-    });
-
-    const elapsed = Date.now() - startTime;
-    this.updateRetrieveMetrics(elapsed);
-
-    return results.map((r: any) => ({
-      task: r.taskName || r.task,
-      confidence: r.confidence,
-      success: r.success,
-      outcome: r.outcome,
-      strategy: r.strategy,
-      timestamp: r.timestamp,
-    }));
-  }
-
-  /**
-   * Query with causal reasoning and context synthesis
-   */
-  async queryWithContext(
-    query: string,
-    options: {
-      k?: number;
-      minConfidence?: number;
-      synthesizeReasoning?: boolean;
-    } = {}
-  ): Promise<{
-    memories: Memory[];
-    context?: string;
-    reasoning?: CausalReasoning[];
-  }> {
-    const { k = 5, minConfidence = 0.0, synthesizeReasoning = false } = options;
-
-    const memories = await this.retrieveMemories(query, k, {
-      minReward: minConfidence,
-    });
-
-    let context: string | undefined;
-    let reasoning: CausalReasoning[] | undefined;
-
-    if (synthesizeReasoning && memories.length > 0) {
-      // Use ReasoningBank to synthesize insights
-      const insights = await this.reasoning.synthesize(
-        memories.map((m) => m.outcome)
-      );
-      context = insights.summary;
-
-      // Extract causal relationships
-      const causalLinks = await this.causal.query(query, { k: 3 });
-      reasoning = causalLinks.map((link: any) => ({
-        cause: link.cause,
-        effect: link.effect,
-        confidence: link.confidence,
-        evidence: link.evidence || [],
-      }));
-    }
-
-    return { memories, context, reasoning };
-  }
-
-  /**
-   * Consolidate skills from successful episodes
-   */
-  async consolidateSkills(options: {
-    minAttempts?: number;
-    minReward?: number;
-    timeWindowDays?: number;
-    enablePruning?: boolean;
-  } = {}): Promise<void> {
-    const {
-      minAttempts = 3,
-      minReward = 0.7,
-      timeWindowDays = 7,
-      enablePruning = true,
-    } = options;
-
-    await this.skills.consolidate({
-      minAttempts,
-      minReward,
-      timeWindow: timeWindowDays * 24 * 60 * 60 * 1000,
-      enablePruning,
-    });
-  }
-
-  /**
-   * Search skill library with semantic search
-   */
-  async searchSkills(
-    query: string,
-    options: {
-      k?: number;
-      minSuccessRate?: number;
-      sortBy?: 'success_rate' | 'avg_reward' | 'attempts';
-    } = {}
-  ): Promise<Skill[]> {
-    const { k = 5, minSuccessRate = 0.0, sortBy = 'success_rate' } = options;
-
-    const results = await this.skills.search(query, k, {
-      minSuccessRate,
-      sortBy,
-    });
-
-    return results.map((skill: any) => ({
-      name: skill.name,
-      description: skill.description,
-      successRate: skill.successRate,
-      avgReward: skill.avgReward,
-      attempts: skill.attempts,
-      lastUsed: skill.lastUsed,
-    }));
-  }
-
-  /**
-   * Optimize database (vacuum, reindex, compact)
-   */
-  async optimize(): Promise<void> {
-    await this.reflexion.vacuum();
-    await this.skills.reindex();
-    console.error('🔧 Database optimized');
-  }
-
-  /**
-   * Get performance metrics
-   */
-  getMetrics() {
-    return { ...this.performanceMetrics };
-  }
-
-  /**
-   * Get database statistics
-   */
-  async getStats(): Promise<any> {
-    const reflexionStats = await this.reflexion.getStats();
-    const skillStats = await this.skills.getStats();
-
-    return {
-      reflexion: reflexionStats,
-      skills: skillStats,
-      performance: this.performanceMetrics,
-    };
-  }
-
-  async close(): Promise<void> {
-    await this.reflexion.close();
-    await this.skills.close();
-    await this.reasoning.close();
-    await this.causal.close();
-  }
-
-  // Private helper methods
-  private updateStoreMetrics(elapsed: number): void {
-    const { storeCount, avgStoreTime } = this.performanceMetrics;
-    this.performanceMetrics.storeCount = storeCount + 1;
-    this.performanceMetrics.avgStoreTime =
-      (avgStoreTime * storeCount + elapsed) / (storeCount + 1);
-  }
-
-  private updateRetrieveMetrics(elapsed: number): void {
-    const { retrieveCount, avgRetrieveTime } = this.performanceMetrics;
-    this.performanceMetrics.retrieveCount = retrieveCount + 1;
-    this.performanceMetrics.avgRetrieveTime =
-      (avgRetrieveTime * retrieveCount + elapsed) / (retrieveCount + 1);
-  }
-}