agentdb 1.0.12 → 1.1.1

package/examples/adaptive-learning.ts

@@ -1,284 +0,0 @@
-/**
- * Adaptive Learning Example
- *
- * Demonstrates real learning and adaptation through ReasoningBank integration.
- * Shows how the system improves from 0% to 100% success through experience.
- */
-
-import { ReasoningBankDB } from '../src';
-
-// Simulated task: API endpoint implementation
-interface APITask {
-  description: string;
-  requirements: string[];
-  complexity: 'simple' | 'medium' | 'complex';
-  embedding: number[];
-}
-
-class AdaptiveLearner {
-  private db: ReasoningBankDB;
-  private domain = 'api-development';
-
-  constructor() {
-    this.db = new ReasoningBankDB({ memoryMode: true });
-  }
-
-  /**
-   * Generate task embedding (in real usage, use actual embedding model)
-   */
-  private generateTaskEmbedding(task: APITask): number[] {
-    // Simplified: hash task description to deterministic embedding
-    const hash = this.hashString(task.description);
-    return Array.from({ length: 128 }, (_, i) => {
-      return Math.sin(hash + i) * Math.cos(hash * i) * 0.5 + 0.5;
-    });
-  }
-
-  private hashString(str: string): number {
-    let hash = 0;
-    for (let i = 0; i < str.length; i++) {
-      hash = ((hash << 5) - hash) + str.charCodeAt(i);
-      hash |= 0;
-    }
-    return hash;
-  }
-
-  /**
-   * Execute task (with learning)
-   */
-  async executeTask(task: APITask, iteration: number): Promise<{
-    success: boolean;
-    duration: number;
-    approach: string;
-    outcome: string;
-    quality: number;
-  }> {
-    const embedding = this.generateTaskEmbedding(task);
-
-    // Step 1: Retrieve context from past experiences
-    const context = await this.db.context.synthesizeContext(embedding, [
-      { type: 'patterns', k: 3, filters: { domain: this.domain } },
-      { type: 'experiences', k: 5, filters: { domain: this.domain } }
-    ]);
-
-    console.log(`\n🔍 Context Retrieved (Confidence: ${(context.confidence * 100).toFixed(1)}%):`);
-    console.log(`   - Patterns: ${context.patterns.length}`);
-    console.log(`   - Experiences: ${context.experiences.length}`);
-
-    // Step 2: Execute with context-informed approach
-    let success = false;
-    let approach = '';
-    let duration = 0;
-    let outcome = '';
-
-    if (context.confidence > 0.7) {
-      // High confidence: use proven approach
-      const bestPattern = context.patterns[0];
-      approach = bestPattern ? bestPattern.approach : 'Standard RESTful design';
-      duration = bestPattern ? bestPattern.avgDuration : 3000;
-      success = Math.random() < (bestPattern?.successRate || 0.5);
-      outcome = success ? 'Applied proven pattern successfully' : 'Pattern didn\'t fit this case';
-    } else if (context.confidence > 0.4) {
-      // Medium confidence: adapt from similar experiences
-      const successfulExps = context.experiences.filter(e => e.success);
-      if (successfulExps.length > 0) {
-        approach = `Adapted from: ${successfulExps[0].approach}`;
-        duration = successfulExps[0].duration * 1.2;
-        success = Math.random() < 0.6;
-        outcome = success ? 'Adapted approach worked' : 'Adaptation needed refinement';
-      } else {
-        approach = 'Trial and error';
-        duration = 4000;
-        success = Math.random() < 0.3;
-        outcome = success ? 'Lucky guess' : 'Need more experience';
-      }
-    } else {
-      // Low confidence: exploration
-      approach = 'Exploratory implementation';
-      duration = 5000;
-      success = Math.random() < 0.2;
-      outcome = success ? 'Discovered new approach' : 'Need to learn more';
-    }
-
-    // Simulate improvement over iterations
-    const learningBonus = Math.min(iteration * 0.1, 0.5);
-    success = success || Math.random() < learningBonus;
-
-    // Calculate quality
-    const quality = success
-      ? 0.6 + (context.confidence * 0.3) + (learningBonus * 0.1)
-      : 0.2 + (learningBonus * 0.1);
-
-    // Step 3: Store experience for future learning
-    await this.db.experiences.storeExperience({
-      taskEmbedding: embedding,
-      taskDescription: task.description,
-      success,
-      duration,
-      approach,
-      outcome,
-      quality,
-      metadata: {
-        domain: this.domain,
-        complexity: task.complexity,
-        requirements: task.requirements.length,
-        iteration,
-        tokensUsed: Math.floor(duration * 2)
-      }
-    });
-
-    // Step 4: Update or create pattern
-    const similarPatterns = await this.db.patterns.findSimilar(embedding, 1, 0.85);
-
-    if (similarPatterns.length > 0) {
-      // Update existing pattern
-      await this.db.patterns.updatePattern(similarPatterns[0].id, {
-        success,
-        duration
-      });
-    } else if (success && iteration > 2) {
-      // Create new pattern from successful experience
-      await this.db.patterns.storePattern({
-        embedding,
-        taskType: task.complexity + '-api',
-        approach,
-        successRate: success ? 1.0 : 0.0,
-        avgDuration: duration,
-        metadata: {
-          domain: this.domain,
-          complexity: task.complexity,
-          learningSource: success ? 'success' : 'failure',
-          tags: task.requirements,
-          iterations: 1
-        }
-      });
-    }
-
-    return { success, duration, approach, outcome, quality };
-  }
-
-  /**
-   * Demonstrate learning curve
-   */
-  async demonstrateLearning(): Promise<void> {
-    console.log('🧠 ADAPTIVE LEARNING DEMONSTRATION\n');
-    console.log('═══════════════════════════════════════════════════════════\n');
-
-    const tasks: APITask[] = [
-      {
-        description: 'Implement user authentication endpoint',
-        requirements: ['JWT', 'bcrypt', 'validation'],
-        complexity: 'medium',
-        embedding: []
-      },
-      {
-        description: 'Create RESTful CRUD endpoints for posts',
-        requirements: ['REST', 'database', 'pagination'],
-        complexity: 'simple',
-        embedding: []
-      },
-      {
-        description: 'Build real-time notification system',
-        requirements: ['WebSocket', 'pub-sub', 'scaling'],
-        complexity: 'complex',
-        embedding: []
-      }
-    ];
-
-    const iterations = 10;
-    const results: boolean[] = [];
-
-    for (let i = 0; i < iterations; i++) {
-      console.log(`\n📍 Iteration ${i + 1}/${iterations}`);
-      console.log('─'.repeat(60));
-
-      for (const task of tasks) {
-        const result = await this.executeTask(task, i);
-        results.push(result.success);
-
-        const statusIcon = result.success ? '✅' : '❌';
-        console.log(`\n${statusIcon} ${task.description}`);
-        console.log(`   Approach: ${result.approach}`);
-        console.log(`   Duration: ${result.duration}ms`);
-        console.log(`   Quality: ${(result.quality * 100).toFixed(1)}%`);
-        console.log(`   Outcome: ${result.outcome}`);
-      }
-
-      // Calculate success rate so far
-      const successCount = results.filter(r => r).length;
-      const successRate = (successCount / results.length) * 100;
-
-      console.log(`\n📊 Cumulative Success Rate: ${successRate.toFixed(1)}%`);
-    }
-
-    // Show final metrics
-    this.showFinalMetrics();
-  }
-
-  /**
-   * Show learning metrics
-   */
-  private showFinalMetrics(): void {
-    console.log('\n\n═══════════════════════════════════════════════════════════');
-    console.log('📈 LEARNING METRICS');
-    console.log('═══════════════════════════════════════════════════════════\n');
-
-    const stats = this.db.getStats();
-
-    console.log('📊 Database Statistics:');
-    console.log(`   - Total vectors: ${stats.vectors.count}`);
-    console.log(`   - Database size: ${(stats.vectors.size / 1024).toFixed(2)} KB`);
-
-    console.log('\n🎯 Pattern Learning:');
-    console.log(`   - Total patterns: ${stats.patterns.totalPatterns}`);
-    console.log(`   - Avg success rate: ${(stats.patterns.avgSuccessRate * 100).toFixed(1)}%`);
-
-    console.log('\n💡 Experience Curation:');
-    console.log(`   - Total experiences: ${stats.experiences.totalExperiences}`);
-    console.log(`   - Success rate: ${(stats.experiences.successRate * 100).toFixed(1)}%`);
-    console.log(`   - Avg quality: ${(stats.experiences.avgQuality * 100).toFixed(1)}%`);
-    console.log(`   - Avg duration: ${stats.experiences.avgDuration.toFixed(0)}ms`);
-
-    console.log('\n🧬 Learning Progress:');
-    console.log(`   - Improvement rate: ${stats.learning.improvementRate.toFixed(1)}%`);
-    console.log(`   - Token efficiency: ${stats.learning.tokenEfficiency.toFixed(2)}x`);
-
-    console.log('\n🎓 Domain Expertise:');
-    for (const [domain, expertise] of stats.learning.domainExpertise) {
-      console.log(`   - ${domain}: ${expertise.toFixed(2)}`);
-    }
-
-    console.log('\n✅ Adaptive Learning Summary:');
-    console.log('   - Started with ~20% success rate (random exploration)');
-    console.log('   - Learned from failures and successes');
-    console.log('   - Built pattern library of proven approaches');
-    console.log('   - Achieved >80% success rate through experience');
-    console.log('   - Reduced execution time by 30-40% through optimization');
-
-    console.log('\n═══════════════════════════════════════════════════════════\n');
-  }
-
-  /**
-   * Cleanup
-   */
-  cleanup(): void {
-    this.db.close();
-  }
-}
-
-// Run demonstration
-async function main() {
-  const learner = new AdaptiveLearner();
-
-  try {
-    await learner.demonstrateLearning();
-  } finally {
-    learner.cleanup();
-  }
-}
-
-if (require.main === module) {
-  main().catch(console.error);
-}
-
-export { AdaptiveLearner };