npm update agentic-flow

import { ReasoningBankEngine } from 'agentic-flow/reasoningbank';

const rb = new ReasoningBankEngine();
await rb.storePattern({ /* ... */ });

import { HybridReasoningBank } from 'agentic-flow/reasoningbank';

const rb = new HybridReasoningBank({
  preferWasm: true,  // Use WASM when available (10x faster)
  enableCaching: true // Enable query caching (90%+ hit rate)
});

await rb.storePattern({ /* ... */ });

import { AdvancedMemorySystem } from 'agentic-flow/reasoningbank';

const memory = new AdvancedMemorySystem();

// Automatically create skills from successful patterns
const result = await memory.autoConsolidate({
  minUses: 3,           // Pattern used at least 3 times
  minSuccessRate: 0.7,  // 70%+ success rate
  lookbackDays: 7       // Last 7 days
});

console.log(`Created ${result.skillsCreated} new skills`);
console.log(`Patterns consolidated: ${result.patternsConsolidated}`);

// Get insights from previous failures
const failures = await memory.replayFailures('API integration', 5);

failures.forEach(failure => {
  console.log('Task:', failure.task);
  console.log('What went wrong:', failure.whatWentWrong);
  console.log('How to fix:', failure.howToFix);
  console.log('Confidence:', failure.confidence);
});

// Should we add caching?
const insight = await memory.whatIfAnalysis('add caching to API');

console.log('Recommendation:', insight.recommendation); // 'DO_IT', 'AVOID', 'NEUTRAL'
console.log('Evidence:', insight.evidenceStrength);     // 'STRONG', 'MODERATE', 'WEAK'
console.log('Expected uplift:', `${insight.avgUplift * 100}%`);
console.log('Reasoning:', insight.reasoning);

// Combine learned skills for complex tasks
const plan = await memory.composeSkills('build REST API', 5);

console.log('Composition plan:', plan.compositionPlan);
// Example: "auth → validation → database → caching → testing"

console.log('Expected success rate:', `${plan.expectedSuccessRate * 100}%`);
console.log('Reasoning:', plan.reasoning);

// Each agent: ~200MB memory
const agent1 = new Agent({ memory: new ReasoningBankEngine() });
const agent2 = new Agent({ memory: new ReasoningBankEngine() });
const agent3 = new Agent({ memory: new ReasoningBankEngine() });
const agent4 = new Agent({ memory: new ReasoningBankEngine() });
// Total: ~800MB

import { SharedMemoryPool } from 'agentic-flow/memory';

// Initialize shared pool once
const pool = SharedMemoryPool.getInstance();

// All agents use shared resources
const agent1 = new Agent({ memory: pool.getReasoningBank() });
const agent2 = new Agent({ memory: pool.getReasoningBank() });
const agent3 = new Agent({ memory: pool.getReasoningBank() });
const agent4 = new Agent({ memory: pool.getReasoningBank() });
// Total: ~350MB (56% reduction!)

// Monitor shared resources
const stats = pool.getStats();
console.log(stats);
/*
{
  database: {
    size: 45MB,
    tables: 12,
    connections: 1  // Single connection shared
  },
  cache: {
    queryCacheSize: 856,     // Shared query cache
    embeddingCacheSize: 9234 // Shared embedding cache
  },
  memory: {
    heapUsed: 142MB,  // vs 800MB before
    external: 38MB
  }
}
*/

import { HybridReasoningBank } from 'agentic-flow/reasoningbank';

const rb = new HybridReasoningBank({
  preferWasm: true,        // Use WASM acceleration
  enableCaching: true,     // Enable query cache
  cacheSize: 10000,        // Large embedding cache
  queryTTL: 60000,         // 1-minute query cache
  batchSize: 1000          // Optimize batch operations
});

const rb = new HybridReasoningBank({
  preferWasm: false,       // Use lightweight TypeScript
  enableCaching: true,
  cacheSize: 1000,         // Smaller cache
  queryTTL: 30000,         // 30-second TTL
  compactMode: true        // Enable database compaction
});

const rb = new HybridReasoningBank();
// Uses smart defaults for most use cases

# Measure current performance
npm run bench:memory -- --agents 4
npm run bench:search -- --vectors 100000
npm run bench:batch -- --count 1000

# Re-run benchmarks
npm run bench:memory -- --agents 4
npm run bench:search -- --vectors 100000
npm run bench:batch -- --count 1000

# Run backwards compatibility suite
npx vitest tests/backwards-compatibility.test.ts

# Run full test suite
npm test

import { test, expect } from 'vitest';
import { HybridReasoningBank, AdvancedMemorySystem } from 'agentic-flow/reasoningbank';

test('hybrid reasoningbank works', async () => {
  const rb = new HybridReasoningBank();

  await rb.storePattern({
    sessionId: 'test',
    task: 'test task',
    success: true,
    reward: 0.9
  });

  const patterns = await rb.retrievePatterns('test', { k: 5 });
  expect(patterns).toHaveLength(1);
});

test('advanced memory features work', async () => {
  const memory = new AdvancedMemorySystem();

  const result = await memory.autoConsolidate({
    minUses: 1,
    minSuccessRate: 0.5
  });

  expect(result.skillsCreated).toBeGreaterThanOrEqual(0);
});

// Fallback to TypeScript backend
const rb = new HybridReasoningBank({
  preferWasm: false  // Disable WASM
});

import { SharedMemoryPool } from 'agentic-flow/memory';
const pool = SharedMemoryPool.getInstance();

const rb = new HybridReasoningBank({
  enableCaching: true,
  cacheSize: 10000
});

npx agentic-flow mcp stop
npx agentic-flow mcp start