agentdb 3.0.0-alpha.2 → 3.0.0-alpha.4

package/simulation/scenarios/domain-examples/trading-systems.ts

@@ -0,0 +1,138 @@
+/**
+ * Trading Systems: Ultra-Low Latency Vector Search
+ *
+ * Use Case: High-frequency trading systems need sub-microsecond
+ * similarity search for pattern matching and strategy execution.
+ *
+ * Optimization Priority: LATENCY (quality trade-off acceptable)
+ */
+
+import { UnifiedMetrics } from '../../types';
+
+export const TRADING_ATTENTION_CONFIG = {
+  heads: 4,                        // Fewer heads = faster (vs 8-head optimal)
+  forwardPassTargetUs: 500,        // Sub-millisecond target (500μs)
+  batchSize: 1,                    // Single-query latency critical
+  precision: 'float16' as const,   // Reduced precision for speed
+  cachingStrategy: 'aggressive' as const, // Pre-compute common patterns
+
+  // Dynamic-k optimized for market conditions
+  dynamicK: {
+    min: 3,                        // Minimum candidates (fast fallback)
+    max: 10,                       // Maximum candidates (volatile markets)
+    adaptationStrategy: 'market-volatility' as const
+  },
+
+  // MPC self-healing for 24/7 operation
+  selfHealing: {
+    enabled: true,
+    adaptationIntervalMs: 50,      // 50ms response (vs 100ms general)
+    degradationThreshold: 0.02     // 2% tolerance (vs 5% general)
+  }
+};
+
+// Trading-specific metrics
+export interface TradingMetrics extends UnifiedMetrics {
+  executionLatencyUs: number;      // Order execution latency
+  marketDataLatencyUs: number;     // Market data processing latency
+  strategyMatchAccuracy: number;   // Pattern match accuracy
+  falsePositiveRate: number;       // False signal rate (critical for trading)
+  uptime99_99: number;             // 99.99% uptime requirement
+}
+
+// Trading signal interface
+export interface TradingSignal {
+  strategy: string;
+  confidence: number;
+  executionTimeUs: number;
+}
+
+// Example: Pattern matching for trading strategies
+export async function matchTradingPattern(
+  marketData: Float32Array,
+  strategyDatabase: any, // HNSWGraph type
+  getCurrentVolatility: () => number,
+  applyAttention: (data: Float32Array, config: any) => Promise<Float32Array>,
+  adaptKToVolatility: (volatility: number) => number
+): Promise<TradingSignal[]> {
+  const config = TRADING_ATTENTION_CONFIG;
+
+  // 4-head attention for fast pattern matching
+  const enhanced = await applyAttention(marketData, config);
+
+  // Dynamic-k based on market volatility
+  const k = adaptKToVolatility(getCurrentVolatility());
+
+  // Search for matching strategies
+  const matches = await strategyDatabase.search(enhanced, k);
+
+  return matches.map((m: any) => ({
+    strategy: m.id,
+    confidence: m.score,
+    executionTimeUs: m.latencyUs  // Track latency for each match
+  }));
+}
+
+// Performance targets for trading
+export const TRADING_PERFORMANCE_TARGETS = {
+  p50LatencyUs: 500,               // 500μs median latency
+  p99LatencyUs: 2000,              // 2ms p99 latency
+  throughputQPS: 100000,           // 100K queries/sec
+  accuracy: 0.92,                  // 92% pattern match accuracy (vs 96.8% general)
+  uptimePercent: 99.99             // 99.99% uptime (4 nines)
+};
+
+// Example configuration variations
+export const TRADING_CONFIG_VARIATIONS = {
+  // Ultra-low latency (300μs target)
+  ultraLowLatency: {
+    ...TRADING_ATTENTION_CONFIG,
+    heads: 2,                      // Even fewer heads
+    forwardPassTargetUs: 300,
+    precision: 'int8' as const     // Quantized for speed
+  },
+
+  // Balanced (1ms target, better accuracy)
+  balanced: {
+    ...TRADING_ATTENTION_CONFIG,
+    heads: 6,
+    forwardPassTargetUs: 1000,
+    precision: 'float32' as const
+  },
+
+  // High-frequency scalping (extreme speed)
+  scalping: {
+    ...TRADING_ATTENTION_CONFIG,
+    heads: 2,
+    forwardPassTargetUs: 200,
+    batchSize: 1,
+    precision: 'int8' as const,
+    cachingStrategy: 'precompute' as const
+  }
+};
+
+// Market condition adaptations
+export function adaptConfigToMarket(
+  baseConfig: typeof TRADING_ATTENTION_CONFIG,
+  marketCondition: 'calm' | 'volatile' | 'trending'
+): typeof TRADING_ATTENTION_CONFIG {
+  switch (marketCondition) {
+    case 'calm':
+      return {
+        ...baseConfig,
+        dynamicK: { ...baseConfig.dynamicK, min: 3, max: 7 }
+      };
+    case 'volatile':
+      return {
+        ...baseConfig,
+        dynamicK: { ...baseConfig.dynamicK, min: 5, max: 15 },
+        selfHealing: { ...baseConfig.selfHealing, adaptationIntervalMs: 25 }
+      };
+    case 'trending':
+      return {
+        ...baseConfig,
+        heads: 6, // More heads for pattern recognition
+        dynamicK: { ...baseConfig.dynamicK, min: 7, max: 12 }
+      };
+  }
+}

package/simulation/scenarios/goalie-integration.ts

@@ -0,0 +1,161 @@
+/**
+ * Goalie Integration (Goal-Oriented AI Learning Engine)
+ *
+ * Goal-tracking graph DB with achievement trees
+ * Integration with goalie package
+ *
+ * Features:
+ * - Hierarchical goal decomposition
+ * - Subgoal dependency tracking
+ * - Achievement progress monitoring
+ * - Adaptive goal prioritization
+ */
+
+import { createUnifiedDatabase } from '../../src/db-unified.js';
+import { ReflexionMemory } from '../../src/controllers/ReflexionMemory.js';
+import { CausalMemoryGraph } from '../../src/controllers/CausalMemoryGraph.js';
+import { SkillLibrary } from '../../src/controllers/SkillLibrary.js';
+import { EmbeddingService } from '../../src/controllers/EmbeddingService.js';
+import * as path from 'path';
+
+export default {
+  description: 'Goalie goal-oriented learning with achievement tree tracking',
+
+  async run(config: any) {
+    const { verbosity = 2 } = config;
+
+    if (verbosity >= 2) {
+      console.log('   🎯 Initializing Goalie Integration (Goal-Oriented Learning)');
+    }
+
+    // Initialize goal-tracking graph database
+    const embedder = new EmbeddingService({
+      model: 'Xenova/all-MiniLM-L6-v2',
+      dimension: 384,
+      provider: 'transformers'
+    });
+    await embedder.initialize();
+
+    const db = await createUnifiedDatabase(
+      path.join(process.cwd(), 'simulation', 'data', 'advanced', 'goalie.graph'),
+      embedder,
+      { forceMode: 'graph' }
+    );
+
+    const reflexion = new ReflexionMemory(
+      db.getGraphDatabase() as any,
+      embedder,
+      undefined,
+      undefined,
+      db.getGraphDatabase() as any
+    );
+
+    const causal = new CausalMemoryGraph(
+      db.getGraphDatabase() as any,
+      db.getGraphDatabase() as any
+    );
+
+    const skills = new SkillLibrary(
+      db.getGraphDatabase() as any,
+      embedder,
+      undefined,
+      db.getGraphDatabase() as any
+    );
+
+    const results = {
+      primaryGoals: 0,
+      subgoals: 0,
+      achievements: 0,
+      avgProgress: 0,
+      totalTime: 0
+    };
+
+    const startTime = performance.now();
+
+    // Primary Goals
+    const primaryGoals = [
+      { goal: 'build_production_system', priority: 0.95 },
+      { goal: 'achieve_90_percent_test_coverage', priority: 0.88 },
+      { goal: 'optimize_performance_10x', priority: 0.92 }
+    ];
+
+    const goalIds: number[] = [];
+    for (const goal of primaryGoals) {
+      const id = await reflexion.storeEpisode({
+        sessionId: 'goalie-primary',
+        task: goal.goal,
+        reward: goal.priority,
+        success: false,  // Not yet achieved
+        input: 'goal_definition',
+        output: 'in_progress'
+      });
+      goalIds.push(id);
+      results.primaryGoals++;
+    }
+
+    // Subgoals (decomposition)
+    const subgoalHierarchy = [
+      { parent: 0, subgoals: ['setup_ci_cd', 'implement_logging', 'add_monitoring'] },
+      { parent: 1, subgoals: ['write_unit_tests', 'write_integration_tests', 'add_e2e_tests'] },
+      { parent: 2, subgoals: ['profile_bottlenecks', 'optimize_queries', 'add_caching'] }
+    ];
+
+    for (const hierarchy of subgoalHierarchy) {
+      for (const subgoal of hierarchy.subgoals) {
+        const subgoalId = await reflexion.storeEpisode({
+          sessionId: 'goalie-subgoal',
+          task: subgoal,
+          reward: 0.70,  // Partial progress
+          success: false,
+          input: `parent_goal_${hierarchy.parent}`,
+          output: 'started'
+        });
+
+        // Link subgoal to parent goal
+        await causal.addCausalEdge({
+          fromMemoryId: subgoalId,
+          fromMemoryType: 'episode',
+          toMemoryId: goalIds[hierarchy.parent],
+          toMemoryType: 'episode',
+          similarity: 0.90,
+          uplift: 0.30,  // Completing subgoal improves parent goal
+          confidence: 0.95,
+          sampleSize: 100,
+          mechanism: 'subgoal_contributes_to_parent'
+        });
+
+        results.subgoals++;
+      }
+    }
+
+    // Achievements (completed subgoals)
+    const achievements = ['setup_ci_cd', 'write_unit_tests', 'profile_bottlenecks'];
+    for (const achievement of achievements) {
+      await skills.createSkill({
+        name: achievement,
+        description: 'Completed subgoal',
+        code: `// Achievement unlocked: ${achievement}`,
+        successRate: 1.0  // 100% completed
+      });
+      results.achievements++;
+      results.avgProgress += 1.0;
+    }
+
+    results.avgProgress /= results.subgoals;
+
+    const endTime = performance.now();
+    results.totalTime = endTime - startTime;
+
+    db.close();
+
+    if (verbosity >= 2) {
+      console.log(`      📊 Primary Goals: ${results.primaryGoals}`);
+      console.log(`      📊 Subgoals: ${results.subgoals}`);
+      console.log(`      📊 Achievements: ${results.achievements}`);
+      console.log(`      📊 Avg Progress: ${(results.avgProgress * 100).toFixed(1)}%`);
+      console.log(`      ⏱️  Duration: ${results.totalTime.toFixed(2)}ms`);
+    }
+
+    return results;
+  }
+};

package/simulation/scenarios/graph-traversal.ts

@@ -0,0 +1,129 @@
+/**
+ * Graph Traversal Simulation
+ *
+ * Tests Cypher queries and graph operations
+ */
+
+import { createUnifiedDatabase } from '../../src/db-unified.js';
+import { EmbeddingService } from '../../src/controllers/EmbeddingService.js';
+import * as path from 'path';
+
+export default {
+  description: 'Graph database traversal and Cypher query performance',
+
+  async run(config: any) {
+    const { verbosity = 2 } = config;
+
+    if (verbosity >= 2) {
+      console.log('   📊 Initializing Graph Traversal Simulation');
+    }
+
+    // Initialize AgentDB
+    const embedder = new EmbeddingService({
+      model: 'Xenova/all-MiniLM-L6-v2',
+      dimension: 384,
+      provider: 'transformers'
+    });
+    await embedder.initialize();
+
+    const db = await createUnifiedDatabase(
+      path.join(process.cwd(), 'simulation', 'data', 'graph-traversal.graph'),
+      embedder,
+      { forceMode: 'graph' }
+    );
+
+    // Get GraphDatabaseAdapter (not raw graph database)
+    const graphDb = db.getGraphDatabase()!;
+
+    // Check if we have GraphDatabaseAdapter methods
+    if (!('createNode' in graphDb)) {
+      throw new Error('Graph database does not support GraphDatabaseAdapter API. Use RuVector graph mode.');
+    }
+
+    const results = {
+      nodesCreated: 0,
+      edgesCreated: 0,
+      queriesExecuted: 0,
+      avgQueryTime: 0,
+      totalTime: 0
+    };
+
+    const startTime = performance.now();
+
+    // Create graph nodes using GraphDatabaseAdapter API
+    const nodeIds: string[] = [];
+    for (let i = 0; i < 50; i++) {
+      const embedding = new Float32Array(384).map(() => Math.random());
+
+      // Use GraphDatabaseAdapter.createNode API
+      const id = await (graphDb as any).createNode({
+        id: `test-node-${i}`,
+        embedding,
+        labels: ['TestNode'],
+        properties: {
+          nodeIndex: i.toString(),  // "index" is a reserved keyword in Cypher
+          type: i % 2 === 0 ? 'even' : 'odd'
+        }
+      });
+
+      nodeIds.push(id);
+      results.nodesCreated++;
+    }
+
+    // Create edges using GraphDatabaseAdapter API
+    for (let i = 0; i < 45; i++) {
+      const embedding = new Float32Array(384).map(() => Math.random());
+
+      await (graphDb as any).createEdge({
+        from: nodeIds[i],
+        to: nodeIds[i + 1],
+        description: 'NEXT',
+        embedding,
+        confidence: 0.9
+      });
+
+      results.edgesCreated++;
+    }
+
+    // Execute Cypher queries
+    const queries = [
+      'MATCH (n:TestNode) RETURN n LIMIT 10',
+      'MATCH (n:TestNode) WHERE n.type = "even" RETURN n LIMIT 10',
+      'MATCH (n:TestNode)-[r:NEXT]->(m) RETURN n, r, m LIMIT 10',
+      'MATCH (n:TestNode) RETURN count(n)',
+      'MATCH (n:TestNode) WHERE n.nodeIndex > "20" RETURN n LIMIT 10'  // "index" is a reserved keyword
+    ];
+
+    let totalQueryTime = 0;
+    for (const query of queries) {
+      const queryStart = performance.now();
+      const result = await (graphDb as any).query(query);
+      const queryEnd = performance.now();
+
+      totalQueryTime += (queryEnd - queryStart);
+      results.queriesExecuted++;
+
+      if (verbosity >= 3) {
+        console.log(`      ✅ Query: ${query.substring(0, 50)}... (${(queryEnd - queryStart).toFixed(2)}ms)`);
+        console.log(`         Results: ${result.nodes?.length || 0} nodes`);
+      }
+    }
+
+    results.avgQueryTime = totalQueryTime / queries.length;
+
+    const endTime = performance.now();
+    results.totalTime = endTime - startTime;
+
+    db.close();
+
+    if (verbosity >= 2) {
+      console.log(`      📊 Nodes Created: ${results.nodesCreated}`);
+      console.log(`      📊 Edges Created: ${results.edgesCreated}`);
+      console.log(`      📊 Queries Executed: ${results.queriesExecuted}`);
+      console.log(`      📊 Avg Query Time: ${results.avgQueryTime.toFixed(2)}ms`);
+      console.log(`      ⏱️  Duration: ${results.totalTime.toFixed(2)}ms`);
+    }
+
+    return results;
+  }
+};