@agentic-robotics/mcp 0.1.3

package/src/hybrid-memory.ts

@@ -0,0 +1,401 @@
+/**
+ * Hybrid AgentDB Memory Implementation
+ *
+ * Strategy: Direct SQLite for storage (fast), CLI for vector search (until API ready)
+ * Expected: 50-100x faster than pure CLI approach
+ */
+
+import Database from 'better-sqlite3';
+import { promisify } from 'util';
+import { exec } from 'child_process';
+import type { Episode, Memory } from './memory.js';
+
+const execAsync = promisify(exec);
+
+export class HybridAgentDBMemory {
+  private db: Database.Database;
+  private dbPath: string;
+  private initialized: boolean = false;
+  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> {
+    if (this.initialized) return;
+
+    const startTime = Date.now();
+
+    // Open SQLite database with optimizations
+    this.db = new Database(this.dbPath);
+
+    // Enable performance optimizations
+    this.db.pragma('journal_mode = WAL'); // Write-Ahead Logging
+    this.db.pragma('synchronous = NORMAL'); // Balance safety/speed
+    this.db.pragma('cache_size = 10000'); // 10MB cache
+    this.db.pragma('temp_store = MEMORY'); // Temp tables in memory
+    this.db.pragma('mmap_size = 30000000000'); // Memory-mapped I/O
+
+    // Create tables if they don't exist
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS reflexion_episodes (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT NOT NULL,
+        task_name TEXT NOT NULL,
+        confidence REAL NOT NULL,
+        success INTEGER NOT NULL,
+        outcome TEXT,
+        strategy TEXT,
+        metadata TEXT,
+        timestamp INTEGER NOT NULL DEFAULT (strftime('%s', 'now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_task_name ON reflexion_episodes(task_name);
+      CREATE INDEX IF NOT EXISTS idx_success ON reflexion_episodes(success);
+      CREATE INDEX IF NOT EXISTS idx_timestamp ON reflexion_episodes(timestamp);
+    `);
+
+    this.initialized = true;
+    const elapsed = Date.now() - startTime;
+
+    console.error(`✅ Hybrid AgentDB initialized: ${this.dbPath}`);
+    console.error(`⚡ Initialization time: ${elapsed}ms`);
+    console.error(`📊 Mode: Direct SQL storage + CLI vector search`);
+  }
+
+  /**
+   * Store episode using direct SQL (100x faster than CLI)
+   */
+  async storeEpisode(episode: Episode): Promise<void> {
+    const startTime = performance.now();
+
+    const stmt = this.db.prepare(`
+      INSERT INTO reflexion_episodes
+      (session_id, task_name, confidence, success, outcome, strategy, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    stmt.run(
+      episode.sessionId,
+      episode.taskName,
+      episode.confidence,
+      episode.success ? 1 : 0,
+      episode.outcome,
+      episode.strategy || null,
+      episode.metadata ? JSON.stringify(episode.metadata) : null
+    );
+
+    const elapsed = performance.now() - startTime;
+    this.updateStoreMetrics(elapsed);
+
+    if (this.performanceMetrics.storeCount % 100 === 0 && this.performanceMetrics.storeCount > 0) {
+      console.error(`💾 Stored episode: ${episode.taskName} (${elapsed.toFixed(2)}ms)`);
+    }
+  }
+
+  /**
+   * Bulk store episodes (even faster with transactions)
+   */
+  async bulkStoreEpisodes(episodes: Episode[]): Promise<void> {
+    const startTime = performance.now();
+
+    const stmt = this.db.prepare(`
+      INSERT INTO reflexion_episodes
+      (session_id, task_name, confidence, success, outcome, strategy, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    const insertMany = this.db.transaction((episodes: Episode[]) => {
+      for (const episode of episodes) {
+        stmt.run(
+          episode.sessionId,
+          episode.taskName,
+          episode.confidence,
+          episode.success ? 1 : 0,
+          episode.outcome,
+          episode.strategy || null,
+          episode.metadata ? JSON.stringify(episode.metadata) : null
+        );
+      }
+    });
+
+    insertMany(episodes);
+
+    const elapsed = performance.now() - startTime;
+    console.error(`💾 Bulk stored ${episodes.length} episodes (${elapsed.toFixed(2)}ms, ${(elapsed/episodes.length).toFixed(2)}ms avg)`);
+  }
+
+  /**
+   * Retrieve memories using CLI vector search (until API ready)
+   * Falls back to SQL if CLI fails
+   */
+  async retrieveMemories(
+    query: string,
+    k: number = 5,
+    options: {
+      minReward?: number;
+      onlySuccesses?: boolean;
+      onlyFailures?: boolean;
+      synthesizeContext?: boolean;
+    } = {}
+  ): Promise<Memory[]> {
+    const startTime = performance.now();
+
+    // Try CLI vector search first (semantic search)
+    try {
+      let cmd = `npx agentdb reflexion retrieve "${query}" --k ${k}`;
+
+      if (options.minReward !== undefined) {
+        cmd += ` --min-reward ${options.minReward}`;
+      }
+      if (options.onlySuccesses) {
+        cmd += ' --only-successes';
+      }
+      if (options.onlyFailures) {
+        cmd += ' --only-failures';
+      }
+      if (options.synthesizeContext) {
+        cmd += ' --synthesize-context';
+      }
+
+      const { stdout } = await execAsync(`AGENTDB_PATH="${this.dbPath}" ${cmd}`, {
+        timeout: 10000,
+      });
+
+      const lines = stdout.trim().split('\n');
+      const jsonLine = lines.find(line => line.startsWith('[') || line.startsWith('{'));
+
+      if (jsonLine) {
+        const data = JSON.parse(jsonLine);
+        const results = Array.isArray(data) ? data : [data];
+
+        const elapsed = performance.now() - startTime;
+        this.updateRetrieveMetrics(elapsed);
+
+        return results;
+      }
+    } catch (error: any) {
+      console.error('Vector search failed, falling back to SQL:', error.message);
+    }
+
+    // Fallback: Direct SQL query (keyword search)
+    const whereConditions = ['1=1'];
+    const params: any[] = [];
+
+    if (options.onlySuccesses) {
+      whereConditions.push('success = 1');
+    }
+    if (options.onlyFailures) {
+      whereConditions.push('success = 0');
+    }
+
+    // Simple keyword matching
+    whereConditions.push("task_name LIKE ? OR outcome LIKE ?");
+    params.push(`%${query}%`, `%${query}%`);
+
+    const stmt = this.db.prepare(`
+      SELECT
+        task_name as task,
+        confidence,
+        success,
+        outcome,
+        strategy,
+        timestamp
+      FROM reflexion_episodes
+      WHERE ${whereConditions.join(' AND ')}
+      ORDER BY timestamp DESC
+      LIMIT ?
+    `);
+
+    const results = stmt.all(...params, k);
+
+    const elapsed = performance.now() - startTime;
+    this.updateRetrieveMetrics(elapsed);
+
+    return results.map((row: any) => ({
+      task: row.task,
+      confidence: row.confidence,
+      success: row.success === 1,
+      outcome: row.outcome,
+      strategy: row.strategy,
+      timestamp: row.timestamp,
+    }));
+  }
+
+  /**
+   * Query with context (SQL + CLI hybrid)
+   */
+  async queryWithContext(
+    query: string,
+    options: {
+      k?: number;
+      minConfidence?: number;
+      domain?: string;
+    } = {}
+  ): Promise<{ memories: Memory[]; context?: string }> {
+    const { k = 5, minConfidence = 0.0 } = options;
+
+    const memories = await this.retrieveMemories(query, k, {
+      minReward: minConfidence,
+    });
+
+    // Generate simple context from results
+    let context: string | undefined;
+    if (memories.length > 0) {
+      const successRate = memories.filter(m => m.success).length / memories.length;
+      context = `Found ${memories.length} similar experiences (${(successRate * 100).toFixed(0)}% success rate)`;
+    }
+
+    return { memories, context };
+  }
+
+  /**
+   * Consolidate skills (direct SQL analysis)
+   */
+  async consolidateSkills(options: {
+    minAttempts?: number;
+    minReward?: number;
+    timeWindowDays?: number;
+  } = {}): Promise<void> {
+    const {
+      minAttempts = 3,
+      minReward = 0.7,
+      timeWindowDays = 7,
+    } = options;
+
+    const timeWindow = Math.floor(Date.now() / 1000) - (timeWindowDays * 24 * 60 * 60);
+
+    const stmt = this.db.prepare(`
+      SELECT
+        task_name,
+        COUNT(*) as attempts,
+        AVG(confidence) as avg_confidence,
+        SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) * 1.0 / COUNT(*) as success_rate
+      FROM reflexion_episodes
+      WHERE timestamp >= ?
+      GROUP BY task_name
+      HAVING attempts >= ? AND avg_confidence >= ?
+      ORDER BY success_rate DESC, attempts DESC
+    `);
+
+    const skills = stmt.all(timeWindow, minAttempts, minReward);
+    console.error(`🎯 Consolidated ${skills.length} skills from successful episodes`);
+  }
+
+  /**
+   * Search skills (direct SQL)
+   */
+  async searchSkills(
+    query: string,
+    options: {
+      k?: number;
+      minSuccessRate?: number;
+      sortBy?: 'success_rate' | 'avg_reward' | 'attempts';
+    } = {}
+  ): Promise<any[]> {
+    const { k = 5, minSuccessRate = 0.0, sortBy = 'success_rate' } = options;
+
+    const orderByMap = {
+      'success_rate': 'success_rate DESC',
+      'avg_reward': 'avg_confidence DESC',
+      'attempts': 'attempts DESC',
+    };
+
+    const stmt = this.db.prepare(`
+      SELECT
+        task_name as name,
+        outcome as description,
+        SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) * 1.0 / COUNT(*) as success_rate,
+        AVG(confidence) as avg_reward,
+        COUNT(*) as attempts,
+        MAX(timestamp) as last_used
+      FROM reflexion_episodes
+      WHERE task_name LIKE ? OR outcome LIKE ?
+      GROUP BY task_name
+      HAVING success_rate >= ?
+      ORDER BY ${orderByMap[sortBy]}
+      LIMIT ?
+    `);
+
+    return stmt.all(`%${query}%`, `%${query}%`, minSuccessRate, k);
+  }
+
+  /**
+   * Optimize database
+   */
+  async optimize(): Promise<void> {
+    console.error('🔧 Optimizing database...');
+    this.db.pragma('optimize');
+    this.db.pragma('wal_checkpoint(TRUNCATE)');
+    this.db.exec('VACUUM');
+    this.db.exec('ANALYZE');
+    console.error('✅ Database optimized');
+  }
+
+  /**
+   * Get performance metrics
+   */
+  getMetrics() {
+    return { ...this.performanceMetrics };
+  }
+
+  /**
+   * Get database statistics
+   */
+  async getStats(): Promise<any> {
+    const stats = this.db.prepare(`
+      SELECT
+        COUNT(*) as total_episodes,
+        SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) as successful_episodes,
+        SUM(CASE WHEN success = 0 THEN 1 ELSE 0 END) as failed_episodes,
+        COUNT(DISTINCT task_name) as unique_tasks,
+        AVG(confidence) as avg_confidence
+      FROM reflexion_episodes
+    `).get();
+
+    return {
+      ...stats,
+      performance: this.performanceMetrics,
+      database: {
+        path: this.dbPath,
+        pageSize: this.db.pragma('page_size', { simple: true }),
+        pageCount: this.db.pragma('page_count', { simple: true }),
+        journalMode: this.db.pragma('journal_mode', { simple: true }),
+      },
+    };
+  }
+
+  async close(): Promise<void> {
+    if (this.db) {
+      this.db.close();
+    }
+    this.initialized = false;
+  }
+
+  // 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);
+  }
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+/**
+ * ROS3 MCP Server
+ *
+ * Exposes robotics operations as a simplified server
+ * with AgentDB reflexion memory integration.
+ */
+
+export { ROS3McpServer } from './server.js';
+export { ROS3Interface } from './interface.js';
+export { AgentDBMemory } from './memory.js';

package/src/interface.ts

@@ -0,0 +1,118 @@
+/**
+ * ROS3 Interface - Mock implementation for demonstration
+ * In production, this would interface with the Rust native bindings
+ */
+
+export interface Pose {
+  x: number;
+  y: number;
+  z: number;
+  roll: number;
+  pitch: number;
+  yaw: number;
+}
+
+export interface ObjectDetection {
+  class: string;
+  confidence: number;
+  bbox: [number, number, number, number];
+}
+
+export interface LidarData {
+  points: Array<{ x: number; y: number; z: number }>;
+  intensities: number[];
+  timestamp: number;
+}
+
+export class ROS3Interface {
+  constructor() {
+    // Initialize connection to ROS3 runtime
+    console.error('ROS3Interface initialized');
+  }
+
+  async moveToPose(
+    pose: Pose,
+    speed: number = 0.5,
+    frame: 'base' | 'world' = 'world'
+  ): Promise<void> {
+    console.error(`Moving to pose [${pose.x}, ${pose.y}, ${pose.z}] in ${frame} frame at speed ${speed}`);
+
+    // Simulate movement time
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+
+  async getLidarData(
+    filter: 'all' | 'obstacles' | 'ground' = 'all',
+    maxPoints: number = 10000
+  ): Promise<LidarData> {
+    console.error(`Getting LIDAR data with filter: ${filter}, max points: ${maxPoints}`);
+
+    // Generate mock point cloud
+    const points = [];
+    const intensities = [];
+    const numPoints = Math.min(1000, maxPoints);
+
+    for (let i = 0; i < numPoints; i++) {
+      points.push({
+        x: Math.random() * 10 - 5,
+        y: Math.random() * 10 - 5,
+        z: Math.random() * 3,
+      });
+      intensities.push(Math.random());
+    }
+
+    return {
+      points,
+      intensities,
+      timestamp: Date.now(),
+    };
+  }
+
+  async detectObjects(
+    camera: 'front' | 'left' | 'right' | 'rear',
+    confidenceThreshold: number = 0.5
+  ): Promise<ObjectDetection[]> {
+    console.error(`Detecting objects from ${camera} camera with threshold ${confidenceThreshold}`);
+
+    // Generate mock detections
+    const classes = ['person', 'car', 'bicycle', 'traffic_light', 'stop_sign'];
+    const detections: ObjectDetection[] = [];
+
+    const numDetections = Math.floor(Math.random() * 5);
+    for (let i = 0; i < numDetections; i++) {
+      const confidence = Math.random() * 0.5 + 0.5;
+      if (confidence >= confidenceThreshold) {
+        detections.push({
+          class: classes[Math.floor(Math.random() * classes.length)],
+          confidence,
+          bbox: [
+            Math.random() * 640,
+            Math.random() * 480,
+            Math.random() * 200,
+            Math.random() * 200,
+          ],
+        });
+      }
+    }
+
+    return detections;
+  }
+
+  async getCurrentPose(): Promise<Pose> {
+    return {
+      x: 0,
+      y: 0,
+      z: 0,
+      roll: 0,
+      pitch: 0,
+      yaw: 0,
+    };
+  }
+
+  async getStatus(): Promise<{ status: string; health: string }> {
+    return {
+      status: 'operational',
+      health: 'good',
+    };
+  }
+}