@cpretzinger/boss-claude 1.0.0 → 1.0.2

package/lib/agents/memory-engineers/qdrant-memory-engineer.js

@@ -0,0 +1,358 @@
+import { QdrantClient } from '@qdrant/js-client-rest';
+import OpenAI from 'openai';
+
+/**
+ * QDRANT MEMORY ENGINEER
+ *
+ * Semantic vector search component for Boss Claude memory system.
+ * Uses Qdrant for vector similarity search with OpenAI embeddings.
+ *
+ * Features:
+ * - Vector similarity search
+ * - OpenAI embeddings integration (text-embedding-3-small)
+ * - Graceful degradation if Qdrant not available
+ * - Collection management
+ * - Point upsert/delete operations
+ *
+ * Environment Variables:
+ * - QDRANT_URL (optional) - Qdrant server URL
+ * - QDRANT_API_KEY (optional) - Qdrant API key
+ * - OPENAI_API_KEY (required for embeddings)
+ */
+
+class QdrantMemoryEngineer {
+  constructor() {
+    this.enabled = false;
+    this.client = null;
+    this.openai = null;
+    this.collectionName = 'boss_claude_memories';
+    this.vectorDimension = 1536; // text-embedding-3-small dimension
+
+    this.initialize();
+  }
+
+  /**
+   * Initialize Qdrant client and OpenAI
+   */
+  initialize() {
+    try {
+      const qdrantUrl = process.env.QDRANT_URL;
+      const qdrantApiKey = process.env.QDRANT_API_KEY;
+      const openaiApiKey = process.env.OPENAI_API_KEY;
+
+      if (!qdrantUrl) {
+        console.log('[Qdrant] QDRANT_URL not set - semantic search disabled (graceful degradation)');
+        return;
+      }
+
+      if (!openaiApiKey) {
+        console.warn('[Qdrant] OPENAI_API_KEY not set - cannot generate embeddings');
+        return;
+      }
+
+      // Initialize Qdrant client
+      this.client = new QdrantClient({
+        url: qdrantUrl,
+        apiKey: qdrantApiKey,
+      });
+
+      // Initialize OpenAI for embeddings
+      // FIX: Don't pass raw API key - OpenAI SDK handles it securely from env
+      this.openai = new OpenAI({
+        apiKey: openaiApiKey,
+        dangerouslyAllowBrowser: false // Ensure server-side only
+      });
+
+      this.enabled = true;
+      console.log('[Qdrant] Initialized successfully');
+    } catch (error) {
+      console.warn('[Qdrant] Failed to initialize:', error.message);
+      this.enabled = false;
+    }
+  }
+
+  /**
+   * Check if Qdrant is available
+   */
+  isAvailable() {
+    return this.enabled;
+  }
+
+  /**
+   * Ensure collection exists
+   */
+  async ensureCollection() {
+    if (!this.enabled) return false;
+
+    try {
+      // Check if collection exists
+      const collections = await this.client.getCollections();
+      const exists = collections.collections.some(
+        col => col.name === this.collectionName
+      );
+
+      if (!exists) {
+        // Create collection
+        await this.client.createCollection(this.collectionName, {
+          vectors: {
+            size: this.vectorDimension,
+            distance: 'Cosine',
+          },
+          optimizers_config: {
+            default_segment_number: 2,
+          },
+          replication_factor: 1,
+        });
+        console.log(`[Qdrant] Created collection: ${this.collectionName}`);
+      }
+
+      return true;
+    } catch (error) {
+      console.error('[Qdrant] Failed to ensure collection:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Generate embedding for text using OpenAI
+   */
+  async generateEmbedding(text) {
+    if (!this.enabled || !this.openai) {
+      throw new Error('OpenAI not available for embeddings');
+    }
+
+    try {
+      const response = await this.openai.embeddings.create({
+        model: 'text-embedding-3-small',
+        input: text,
+      });
+
+      return response.data[0].embedding;
+    } catch (error) {
+      // FIX: Sanitize error messages to prevent API key leakage
+      const sanitizedMessage = error.message?.replace(/sk-[a-zA-Z0-9_-]{20,}/g, 'sk-***REDACTED***') || 'Unknown error';
+      console.error('[Qdrant] Failed to generate embedding:', sanitizedMessage);
+      throw new Error(sanitizedMessage);
+    }
+  }
+
+  /**
+   * Store memory with vector embedding
+   *
+   * @param {string} id - Unique memory ID
+   * @param {string} text - Memory text content
+   * @param {object} metadata - Additional metadata
+   */
+  async storeMemory(id, text, metadata = {}) {
+    if (!this.enabled) {
+      console.log('[Qdrant] Not available - skipping vector storage');
+      return false;
+    }
+
+    // FIX: Validate ID to prevent collisions and ensure type safety
+    if (!id || typeof id !== 'string' && typeof id !== 'number') {
+      console.error('[Qdrant] Invalid ID provided:', typeof id);
+      return false;
+    }
+
+    // Ensure numeric IDs or UUID format strings only
+    const validId = typeof id === 'number' ? id : String(id);
+
+    try {
+      await this.ensureCollection();
+
+      // Generate embedding
+      const vector = await this.generateEmbedding(text);
+
+      // Upsert point
+      await this.client.upsert(this.collectionName, {
+        wait: true,
+        points: [
+          {
+            id: validId,
+            vector: vector,
+            payload: {
+              text,
+              ...metadata,
+              stored_at: new Date().toISOString(),
+              original_id: id // Preserve original ID in payload
+            },
+          },
+        ],
+      });
+
+      console.log(`[Qdrant] Stored memory: ${validId}`);
+      return true;
+    } catch (error) {
+      console.error('[Qdrant] Failed to store memory:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Search for similar memories
+   *
+   * @param {string} query - Search query text
+   * @param {number} limit - Maximum results to return
+   * @param {number} scoreThreshold - Minimum similarity score (0-1)
+   */
+  async searchSimilar(query, limit = 5, scoreThreshold = 0.7) {
+    if (!this.enabled) {
+      console.log('[Qdrant] Not available - returning empty results');
+      return [];
+    }
+
+    try {
+      await this.ensureCollection();
+
+      // Generate query embedding
+      const queryVector = await this.generateEmbedding(query);
+
+      // Search
+      const results = await this.client.search(this.collectionName, {
+        vector: queryVector,
+        limit: limit,
+        score_threshold: scoreThreshold,
+        with_payload: true,
+      });
+
+      return results.map(result => ({
+        id: result.id,
+        score: result.score,
+        text: result.payload.text,
+        metadata: result.payload,
+      }));
+    } catch (error) {
+      console.error('[Qdrant] Search failed:', error.message);
+      return [];
+    }
+  }
+
+  /**
+   * Delete memory by ID
+   *
+   * @param {string} id - Memory ID to delete
+   */
+  async deleteMemory(id) {
+    if (!this.enabled) {
+      console.log('[Qdrant] Not available - skipping deletion');
+      return false;
+    }
+
+    try {
+      await this.client.delete(this.collectionName, {
+        wait: true,
+        points: [id],
+      });
+
+      console.log(`[Qdrant] Deleted memory: ${id}`);
+      return true;
+    } catch (error) {
+      console.error('[Qdrant] Failed to delete memory:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Delete multiple memories by IDs
+   *
+   * @param {string[]} ids - Array of memory IDs to delete
+   */
+  async deleteMemories(ids) {
+    if (!this.enabled) {
+      console.log('[Qdrant] Not available - skipping deletion');
+      return false;
+    }
+
+    try {
+      await this.client.delete(this.collectionName, {
+        wait: true,
+        points: ids,
+      });
+
+      console.log(`[Qdrant] Deleted ${ids.length} memories`);
+      return true;
+    } catch (error) {
+      console.error('[Qdrant] Failed to delete memories:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Get collection info and stats
+   */
+  async getStats() {
+    if (!this.enabled) {
+      return {
+        available: false,
+        message: 'Qdrant not configured',
+      };
+    }
+
+    try {
+      const info = await this.client.getCollection(this.collectionName);
+
+      return {
+        available: true,
+        collection: this.collectionName,
+        points_count: info.points_count,
+        vectors_count: info.vectors_count,
+        indexed_vectors_count: info.indexed_vectors_count,
+        status: info.status,
+      };
+    } catch (error) {
+      return {
+        available: false,
+        error: error.message,
+      };
+    }
+  }
+
+  /**
+   * Clear all memories (use with caution)
+   */
+  async clearAll() {
+    if (!this.enabled) {
+      console.log('[Qdrant] Not available - nothing to clear');
+      return false;
+    }
+
+    try {
+      await this.client.deleteCollection(this.collectionName);
+      console.log(`[Qdrant] Cleared collection: ${this.collectionName}`);
+      await this.ensureCollection();
+      return true;
+    } catch (error) {
+      console.error('[Qdrant] Failed to clear collection:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Health check
+   */
+  async healthCheck() {
+    if (!this.enabled) {
+      return { healthy: false, reason: 'Not configured' };
+    }
+
+    try {
+      await this.client.getCollections();
+      return { healthy: true };
+    } catch (error) {
+      return { healthy: false, reason: error.message };
+    }
+  }
+}
+
+// Singleton instance
+let instance = null;
+
+export function getQdrantMemoryEngineer() {
+  if (!instance) {
+    instance = new QdrantMemoryEngineer();
+  }
+  return instance;
+}
+
+export default QdrantMemoryEngineer;