1import { ReasoningBank } from 'agentic-flow/reasoningbank';
 2
 3// Initialize ReasoningBank
 4const rb = new ReasoningBank({
 5  persist: true,
 6  learningRate: 0.1,
 7  adapter: 'agentdb' // Use AgentDB for storage
 8});
 9
10// Record task outcome
11await rb.recordExperience({
12  task: 'code_review',
13  approach: 'static_analysis_first',
14  outcome: {
15    success: true,
16    metrics: {
17      bugs_found: 5,
18      time_taken: 120,
19      false_positives: 1
20    }
21  },
22  context: {
23    language: 'typescript',
24    complexity: 'medium'
25  }
26});
27
28// Get optimal strategy
29const strategy = await rb.recommendStrategy('code_review', {
30  language: 'typescript',
31  complexity: 'high'
32});

 1// Learn patterns from data
 2await rb.learnPattern({
 3  pattern: 'api_errors_increase_after_deploy',
 4  triggers: ['deployment', 'traffic_spike'],
 5  actions: ['rollback', 'scale_up'],
 6  confidence: 0.85
 7});
 8
 9// Match patterns
10const matches = await rb.matchPatterns(currentSituation);

 1// Compare strategies
 2const comparison = await rb.compareStrategies('bug_fixing', [
 3  'tdd_approach',
 4  'debug_first',
 5  'reproduce_then_fix'
 6]);
 7
 8// Get best strategy
 9const best = comparison.strategies[0];
10console.log(`Best: ${best.name} (score: ${best.score})`);

1// Enable auto-learning from all tasks
2await rb.enableAutoLearning({
3  threshold: 0.7,        // Only learn from high-confidence outcomes
4  updateFrequency: 100   // Update models every 100 experiences
5});

1// Learn about learning
2await rb.metaLearn({
3  observation: 'parallel_execution_faster_for_independent_tasks',
4  confidence: 0.95,
5  applicability: {
6    task_types: ['batch_processing', 'data_transformation'],
7    conditions: ['tasks_independent', 'io_bound']
8  }
9});

1// Apply knowledge from one domain to another
2await rb.transferKnowledge({
3  from: 'code_review_javascript',
4  to: 'code_review_typescript',
5  similarity: 0.8
6});

 1// Create self-improving agent
 2class AdaptiveAgent {
 3  async execute(task: Task) {
 4    // Get optimal strategy
 5    const strategy = await rb.recommendStrategy(task.type, task.context);
 6
 7    // Execute with strategy
 8    const result = await this.executeWithStrategy(task, strategy);
 9
10    // Learn from outcome
11    await rb.recordExperience({
12      task: task.type,
13      approach: strategy.name,
14      outcome: result,
15      context: task.context
16    });
17
18    return result;
19  }
20}

 1// Persist ReasoningBank data
 2await rb.configure({
 3  storage: {
 4    type: 'agentdb',
 5    options: {
 6      database: './reasoning-bank.db',
 7      enableVectorSearch: true
 8    }
 9  }
10});
11
12// Query learned patterns
13const patterns = await rb.query({
14  category: 'optimization',
15  minConfidence: 0.8,
16  timeRange: { last: '30d' }
17});

1// Track learning effectiveness
2const metrics = await rb.getMetrics();
3console.log(`
4  Total Experiences: ${metrics.totalExperiences}
5  Patterns Learned: ${metrics.patternsLearned}
6  Strategy Success Rate: ${metrics.strategySuccessRate}
7  Improvement Over Time: ${metrics.improvement}
8`);