@monoes/memory 1.0.0 → 1.0.1

package/dist/hybrid-backend.js

@@ -1,22 +1,23 @@
 /**
- * HybridBackend - Combines SQLite (structured queries) + AgentDB (vector search)
+ * HybridBackend - Combines SQLite (structured queries) + LanceDB (vector search)
  *
- * Per ADR-009: "HybridBackend (SQLite + AgentDB) as default"
+ * Per ADR-009: "HybridBackend (SQLite + LanceDB) as default"
  * - SQLite for: Structured queries, ACID transactions, exact matches
- * - AgentDB for: Semantic search, vector similarity, RAG
+ * - LanceDB for: Semantic search, vector similarity, RAG
  *
  * @module v1/memory/hybrid-backend
  */
 import { EventEmitter } from 'node:events';
 import { SQLiteBackend } from './sqlite-backend.js';
-import { AgentDBBackend } from './agentdb-backend.js';
+import { LanceDBBackend } from './lancedb-backend.js';
 import { MemoryGraph } from './memory-graph.js';
 /**
  * Default configuration
  */
 const DEFAULT_CONFIG = {
     sqlite: {},
-    agentdb: {},
+    lancedb: {},
+    semanticBackend: 'lancedb',
     defaultNamespace: 'default',
     embeddingGenerator: undefined,
     routingStrategy: 'auto',
@@ -44,14 +45,14 @@ const INJECTION_PATTERNS = [
 /**
  * HybridBackend Implementation
  *
- * Intelligently routes queries between SQLite and AgentDB:
+ * Intelligently routes queries between SQLite and LanceDB:
  * - Exact matches, prefix queries → SQLite
- * - Semantic search, similarity → AgentDB
+ * - Semantic search, similarity → LanceDB
  * - Complex hybrid queries → Both backends with intelligent merging
  */
 export class HybridBackend extends EventEmitter {
-    sqlite;
-    agentdb;
+    sqlite; // SQLiteBackend normally; same as semantic when lancedb solo
+    semantic; // LanceDBBackend
     config;
     initialized = false;
     /** Lazy MemoryGraph for HippoRAG PPR re-ranking */
@@ -59,34 +60,52 @@ export class HybridBackend extends EventEmitter {
     // Performance tracking
     stats = {
         sqliteQueries: 0,
-        agentdbQueries: 0,
+        semanticQueries: 0,
         hybridQueries: 0,
         totalQueryTime: 0,
     };
     constructor(config = {}) {
         super();
         this.config = { ...DEFAULT_CONFIG, ...config };
-        // Initialize SQLite backend
-        this.sqlite = new SQLiteBackend({
-            ...this.config.sqlite,
-            defaultNamespace: this.config.defaultNamespace,
-            embeddingGenerator: this.config.embeddingGenerator,
-        });
-        // Initialize AgentDB backend
-        this.agentdb = new AgentDBBackend({
-            ...this.config.agentdb,
-            namespace: this.config.defaultNamespace,
-            embeddingGenerator: this.config.embeddingGenerator,
-        });
-        // Forward events from both backends
-        this.sqlite.on('entry:stored', (data) => this.emit('sqlite:stored', data));
-        this.sqlite.on('entry:updated', (data) => this.emit('sqlite:updated', data));
-        this.sqlite.on('entry:deleted', (data) => this.emit('sqlite:deleted', data));
-        this.agentdb.on('entry:stored', (data) => this.emit('agentdb:stored', data));
-        this.agentdb.on('entry:updated', (data) => this.emit('agentdb:updated', data));
-        this.agentdb.on('entry:deleted', (data) => this.emit('agentdb:deleted', data));
-        this.agentdb.on('cache:hit', (data) => this.emit('cache:hit', data));
-        this.agentdb.on('cache:miss', (data) => this.emit('cache:miss', data));
+        // Initialize semantic backend (LanceDB)
+        if (this.config.semanticBackend === 'lancedb') {
+            // Solo LanceDB mode: one backend handles all queries (structured + vector).
+            // Both this.sqlite and this.semantic point to the same instance so all
+            // routing paths (exact/prefix/tag/semantic) transparently use LanceDB.
+            // dualWrite forced off to prevent double-writes to the same instance.
+            const ldb = new LanceDBBackend({
+                ...this.config.lancedb,
+                namespace: this.config.defaultNamespace,
+                embeddingGenerator: this.config.embeddingGenerator,
+            });
+            this.semantic = ldb;
+            this.sqlite = ldb;
+            this.config.dualWrite = false;
+        }
+        else {
+            this.sqlite = new SQLiteBackend({
+                ...this.config.sqlite,
+                defaultNamespace: this.config.defaultNamespace,
+                embeddingGenerator: this.config.embeddingGenerator,
+            });
+            this.semantic = new LanceDBBackend({
+                ...this.config.lancedb,
+                namespace: this.config.defaultNamespace,
+                embeddingGenerator: this.config.embeddingGenerator,
+            });
+        }
+        // Forward events (skip duplicate wiring in solo mode)
+        const em = (b) => b;
+        em(this.sqlite).on?.('entry:stored', (d) => this.emit('sqlite:stored', d));
+        em(this.sqlite).on?.('entry:updated', (d) => this.emit('sqlite:updated', d));
+        em(this.sqlite).on?.('entry:deleted', (d) => this.emit('sqlite:deleted', d));
+        if (this.semantic !== this.sqlite) {
+            em(this.semantic).on?.('entry:stored', (d) => this.emit('semantic:stored', d));
+            em(this.semantic).on?.('entry:updated', (d) => this.emit('semantic:updated', d));
+            em(this.semantic).on?.('entry:deleted', (d) => this.emit('semantic:deleted', d));
+            em(this.semantic).on?.('cache:hit', (d) => this.emit('cache:hit', d));
+            em(this.semantic).on?.('cache:miss', (d) => this.emit('cache:miss', d));
+        }
     }
     /**
      * Initialize both backends
@@ -94,7 +113,10 @@ export class HybridBackend extends EventEmitter {
     async initialize() {
         if (this.initialized)
             return;
-        await Promise.all([this.sqlite.initialize(), this.agentdb.initialize()]);
+        const inits = this.semantic === this.sqlite
+            ? [this.semantic.initialize()]
+            : [this.sqlite.initialize(), this.semantic.initialize()];
+        await Promise.all(inits);
         this.initialized = true;
         this.emit('initialized');
     }
@@ -104,7 +126,10 @@ export class HybridBackend extends EventEmitter {
     async shutdown() {
         if (!this.initialized)
             return;
-        await Promise.all([this.sqlite.shutdown(), this.agentdb.shutdown()]);
+        const shutdowns = this.semantic === this.sqlite
+            ? [this.semantic.shutdown()]
+            : [this.sqlite.shutdown(), this.semantic.shutdown()];
+        await Promise.all(shutdowns);
         this.initialized = false;
         this.emit('shutdown');
     }
@@ -119,11 +144,11 @@ export class HybridBackend extends EventEmitter {
     async store(entry) {
         if (this.config.dualWrite) {
             // Write to both backends in parallel
-            await Promise.all([this.sqlite.store(entry), this.agentdb.store(entry)]);
+            await Promise.all([this.sqlite.store(entry), this.semantic.store(entry)]);
         }
         else {
-            // Write to primary backend only (AgentDB has vector search)
-            await this.agentdb.store(entry);
+            // Write to primary backend only
+            await this.semantic.store(entry);
         }
         this.emit('entry:stored', { id: entry.id });
         // A-MEM: auto-link to top-3 semantic neighbors (non-blocking, best-effort)
@@ -141,7 +166,7 @@ export class HybridBackend extends EventEmitter {
     async aMemAutoLink(newEntry) {
         try {
             const embedding = await this.config.embeddingGenerator(newEntry.content);
-            const neighbors = await this.agentdb.search(embedding, {
+            const neighbors = await this.semantic.search(embedding, {
                 k: 4, // fetch 4 to exclude self
                 threshold: 0.75,
             });
@@ -166,7 +191,7 @@ export class HybridBackend extends EventEmitter {
         }
     }
     /**
-     * Get from AgentDB (has caching enabled).
+     * Get from semantic backend.
      *
      * Collaborative memory promotion: when `agentId` is supplied, also notifies
      * the SQLite backend so it can track the read and promote the entry's
@@ -174,9 +199,10 @@ export class HybridBackend extends EventEmitter {
      * Source: newinnovation.md §2.7 — memory access-level promotion.
      */
     async get(id, agentId) {
-        const entry = await this.agentdb.get(id);
-        // Track the read in SQLite for collaborative promotion (best-effort, non-blocking)
-        if (agentId && entry) {
+        const entry = await this.semantic.get(id);
+        // Track the read in SQLite for collaborative promotion (best-effort, non-blocking).
+        // Skipped in solo-lancedb mode since this.sqlite === this.semantic (already fetched above).
+        if (agentId && entry && this.semantic !== this.sqlite) {
             this.sqlite.get(id, agentId).catch(() => { });
         }
         return entry;
@@ -193,14 +219,14 @@ export class HybridBackend extends EventEmitter {
     async update(id, update) {
         if (this.config.dualWrite) {
             // Update both backends
-            const [sqliteResult, agentdbResult] = await Promise.all([
+            const [sqliteResult, semanticResult] = await Promise.all([
                 this.sqlite.update(id, update),
-                this.agentdb.update(id, update),
+                this.semantic.update(id, update),
             ]);
-            return agentdbResult || sqliteResult;
+            return semanticResult || sqliteResult;
         }
         else {
-            return this.agentdb.update(id, update);
+            return this.semantic.update(id, update);
         }
     }
     /**
@@ -208,18 +234,18 @@ export class HybridBackend extends EventEmitter {
      */
     async delete(id) {
         if (this.config.dualWrite) {
-            const [sqliteResult, agentdbResult] = await Promise.all([
+            const [sqliteResult, semanticResult] = await Promise.all([
                 this.sqlite.delete(id),
-                this.agentdb.delete(id),
+                this.semantic.delete(id),
             ]);
-            return sqliteResult || agentdbResult;
+            return sqliteResult || semanticResult;
         }
         else {
-            return this.agentdb.delete(id);
+            return this.semantic.delete(id);
         }
     }
     /**
-     * Query routing - semantic goes to AgentDB, structured to SQLite
+     * Query routing — semantic goes to LanceDB, structured to SQLite
      */
     async query(query) {
         const startTime = performance.now();
@@ -242,9 +268,9 @@ export class HybridBackend extends EventEmitter {
                 results = await this.sqlite.query(query);
                 break;
             case 'semantic':
-                // AgentDB optimized for semantic search
-                this.stats.agentdbQueries++;
-                results = await this.agentdb.query(query);
+                // LanceDB handles semantic search
+                this.stats.semanticQueries++;
+                results = await this.semantic.query(query);
                 break;
             case 'hybrid':
                 // Use hybrid query combining both backends
@@ -335,7 +361,7 @@ export class HybridBackend extends EventEmitter {
     }
     /**
      * Semantic queries (vector)
-     * Routes to AgentDB for HNSW-based vector search.
+     * Routes to semantic backend for ANN vector search.
      *
      * MemoRAG query rewriting (arXiv:2409.05591): when `memoragRewriter` is configured
      * and `query.content` is present, generates 2-3 reformulated sub-queries, embeds
@@ -343,7 +369,7 @@ export class HybridBackend extends EventEmitter {
      * before HippoRAG PPR re-ranking.
      */
     async querySemantic(query) {
-        this.stats.agentdbQueries++;
+        this.stats.semanticQueries++;
         let searchResults = [];
         // MemoRAG: expand the query into multiple sub-queries for richer recall
         let memoragUsed = false;
@@ -356,7 +382,7 @@ export class HybridBackend extends EventEmitter {
                         if (!this.config.embeddingGenerator)
                             return [];
                         const sqEmbedding = await this.config.embeddingGenerator(sq);
-                        const results = await this.agentdb.search(sqEmbedding, {
+                        const results = await this.semantic.search(sqEmbedding, {
                             k: (query.k || 10) * 2,
                             threshold: query.threshold || this.config.semanticThreshold,
                             filters: query.filters,
@@ -383,7 +409,7 @@ export class HybridBackend extends EventEmitter {
             if (!embedding) {
                 throw new Error('SemanticQuery requires either content or embedding');
             }
-            searchResults = await this.agentdb.search(embedding, {
+            searchResults = await this.semantic.search(embedding, {
                 k: (query.k || 10) * 2, // Over-fetch to account for post-filtering
                 threshold: query.threshold || this.config.semanticThreshold,
                 filters: query.filters,
@@ -427,7 +453,7 @@ export class HybridBackend extends EventEmitter {
                     });
                 }
             }
-            const reranked = await this.memoryGraph.pprRerank(searchResults, this.agentdb);
+            const reranked = await this.memoryGraph.pprRerank(searchResults, this.semantic);
             // Annotate each entry with its community ID and summary from GraphRAG
             entries = reranked.map((r) => {
                 const commSummary = nodeToSummary.get(r.entry.id);
@@ -464,7 +490,7 @@ export class HybridBackend extends EventEmitter {
             }
             entries = safe;
         }
-        // Apply tag/namespace/type filters that AgentDB may not enforce
+        // Apply tag/namespace/type filters
         if (query.filters) {
             const f = query.filters;
             if (f.tags && Array.isArray(f.tags)) {
@@ -508,21 +534,21 @@ export class HybridBackend extends EventEmitter {
         }
     }
     /**
-     * Semantic vector search (routes to AgentDB)
+     * Semantic vector search (routes to LanceDB)
      */
     async search(embedding, options) {
-        this.stats.agentdbQueries++;
-        return this.agentdb.search(embedding, options);
+        this.stats.semanticQueries++;
+        return this.semantic.search(embedding, options);
     }
     /**
      * Bulk insert to both backends
      */
     async bulkInsert(entries) {
         if (this.config.dualWrite) {
-            await Promise.all([this.sqlite.bulkInsert(entries), this.agentdb.bulkInsert(entries)]);
+            await Promise.all([this.sqlite.bulkInsert(entries), this.semantic.bulkInsert(entries)]);
         }
         else {
-            await this.agentdb.bulkInsert(entries);
+            await this.semantic.bulkInsert(entries);
         }
     }
     /**
@@ -530,14 +556,14 @@ export class HybridBackend extends EventEmitter {
      */
     async bulkDelete(ids) {
         if (this.config.dualWrite) {
-            const [sqliteCount, agentdbCount] = await Promise.all([
+            const [sqliteCount, semanticCount] = await Promise.all([
                 this.sqlite.bulkDelete(ids),
-                this.agentdb.bulkDelete(ids),
+                this.semantic.bulkDelete(ids),
             ]);
-            return Math.max(sqliteCount, agentdbCount);
+            return Math.max(sqliteCount, semanticCount);
         }
         else {
-            return this.agentdb.bulkDelete(ids);
+            return this.semantic.bulkDelete(ids);
         }
     }
     /**
@@ -557,77 +583,79 @@ export class HybridBackend extends EventEmitter {
      */
     async clearNamespace(namespace) {
         if (this.config.dualWrite) {
-            const [sqliteCount, agentdbCount] = await Promise.all([
+            const [sqliteCount, semanticCount] = await Promise.all([
                 this.sqlite.clearNamespace(namespace),
-                this.agentdb.clearNamespace(namespace),
+                this.semantic.clearNamespace(namespace),
             ]);
-            return Math.max(sqliteCount, agentdbCount);
+            return Math.max(sqliteCount, semanticCount);
         }
         else {
-            return this.agentdb.clearNamespace(namespace);
+            return this.semantic.clearNamespace(namespace);
         }
     }
     /**
      * Get combined statistics from both backends
      */
     async getStats() {
-        const [sqliteStats, agentdbStats] = await Promise.all([
-            this.sqlite.getStats(),
-            this.agentdb.getStats(),
+        const solo = this.semantic === this.sqlite;
+        const [sqliteStats, semanticStats] = await Promise.all([
+            solo ? Promise.resolve(null) : this.sqlite.getStats(),
+            this.semantic.getStats(),
         ]);
         return {
-            totalEntries: Math.max(sqliteStats.totalEntries, agentdbStats.totalEntries),
-            entriesByNamespace: agentdbStats.entriesByNamespace,
-            entriesByType: agentdbStats.entriesByType,
-            memoryUsage: sqliteStats.memoryUsage + agentdbStats.memoryUsage,
-            hnswStats: agentdbStats.hnswStats ?? {
+            totalEntries: solo ? semanticStats.totalEntries : Math.max(sqliteStats.totalEntries, semanticStats.totalEntries),
+            entriesByNamespace: semanticStats.entriesByNamespace,
+            entriesByType: semanticStats.entriesByType,
+            memoryUsage: solo ? semanticStats.memoryUsage : sqliteStats.memoryUsage + semanticStats.memoryUsage,
+            hnswStats: semanticStats.hnswStats ?? {
                 vectorCount: 0, // 0 = no active HNSW index; do not fabricate from totalEntries
                 memoryUsage: 0,
                 avgSearchTime: 0,
                 buildTime: 0,
                 compressionRatio: 1.0,
             },
-            cacheStats: agentdbStats.cacheStats ?? {
+            cacheStats: semanticStats.cacheStats ?? {
                 hitRate: 0,
                 size: 0,
                 maxSize: 1000,
             },
-            avgQueryTime: this.stats.hybridQueries + this.stats.sqliteQueries + this.stats.agentdbQueries > 0
+            avgQueryTime: this.stats.hybridQueries + this.stats.sqliteQueries + this.stats.semanticQueries > 0
                 ? this.stats.totalQueryTime /
-                    (this.stats.hybridQueries + this.stats.sqliteQueries + this.stats.agentdbQueries)
+                    (this.stats.hybridQueries + this.stats.sqliteQueries + this.stats.semanticQueries)
                 : 0,
-            avgSearchTime: agentdbStats.avgSearchTime,
+            avgSearchTime: semanticStats.avgSearchTime,
         };
     }
     /**
      * Health check for both backends
      */
     async healthCheck() {
-        const [sqliteHealth, agentdbHealth] = await Promise.all([
-            this.sqlite.healthCheck(),
-            this.agentdb.healthCheck(),
+        const solo = this.semantic === this.sqlite;
+        const [sqliteHealth, semanticHealth] = await Promise.all([
+            solo ? Promise.resolve({ status: 'healthy', issues: [], recommendations: [], components: {}, timestamp: Date.now() }) : this.sqlite.healthCheck(),
+            this.semantic.healthCheck(),
         ]);
-        const allIssues = [...sqliteHealth.issues, ...agentdbHealth.issues];
+        const allIssues = [...sqliteHealth.issues, ...semanticHealth.issues];
         const allRecommendations = [
             ...sqliteHealth.recommendations,
-            ...agentdbHealth.recommendations,
+            ...semanticHealth.recommendations,
         ];
         // Determine overall status
         let status = 'healthy';
         if (sqliteHealth.status === 'unhealthy' ||
-            agentdbHealth.status === 'unhealthy') {
+            semanticHealth.status === 'unhealthy') {
             status = 'unhealthy';
         }
         else if (sqliteHealth.status === 'degraded' ||
-            agentdbHealth.status === 'degraded') {
+            semanticHealth.status === 'degraded') {
             status = 'degraded';
         }
         return {
             status,
             components: {
                 storage: sqliteHealth.components.storage,
-                index: agentdbHealth.components.index,
-                cache: agentdbHealth.components.cache,
+                index: semanticHealth.components.index,
+                cache: semanticHealth.components.cache,
             },
             timestamp: Date.now(),
             issues: allIssues,
@@ -639,11 +667,11 @@ export class HybridBackend extends EventEmitter {
      * Auto-route queries based on properties
      */
     async autoRoute(query) {
-        // If has embedding or content, use semantic search (AgentDB)
+        // If has embedding or content, use semantic search (LanceDB)
         const hasEmbeddingGenerator = typeof this.config.embeddingGenerator === 'function';
         if (query.embedding || (query.content && hasEmbeddingGenerator)) {
-            this.stats.agentdbQueries++;
-            return this.agentdb.query(query);
+            this.stats.semanticQueries++;
+            return this.semantic.query(query);
         }
         // If has exact key or prefix, use structured search (SQLite)
         if (query.key || query.keyPrefix) {
@@ -655,14 +683,14 @@ export class HybridBackend extends EventEmitter {
             case 'sqlite-first':
                 this.stats.sqliteQueries++;
                 return this.sqlite.query(query);
-            case 'agentdb-first':
-                this.stats.agentdbQueries++;
-                return this.agentdb.query(query);
+            case 'semantic-first':
+                this.stats.semanticQueries++;
+                return this.semantic.query(query);
             case 'auto':
             default:
-                // Default to AgentDB (has caching)
-                this.stats.agentdbQueries++;
-                return this.agentdb.query(query);
+                // Default to semantic backend (LanceDB)
+                this.stats.semanticQueries++;
+                return this.semantic.query(query);
         }
     }
     /**
@@ -706,7 +734,13 @@ export class HybridBackend extends EventEmitter {
     combineUnion(semanticResults, structuredResults) {
         const seen = new Set();
         const combined = [];
-        for (const entry of [...semanticResults, ...structuredResults]) {
+        for (const entry of semanticResults) {
+            if (!seen.has(entry.id)) {
+                seen.add(entry.id);
+                combined.push(entry);
+            }
+        }
+        for (const entry of structuredResults) {
             if (!seen.has(entry.id)) {
                 seen.add(entry.id);
                 combined.push(entry);
@@ -725,7 +759,9 @@ export class HybridBackend extends EventEmitter {
      * Semantic-first: Prefer semantic results, add structured if not present
      */
     combineSemanticFirst(semanticResults, structuredResults) {
-        const semanticIds = new Set(semanticResults.map((e) => e.id));
+        const semanticIds = new Set();
+        for (const e of semanticResults)
+            semanticIds.add(e.id);
         const additional = structuredResults.filter((e) => !semanticIds.has(e.id));
         return [...semanticResults, ...additional];
     }
@@ -733,60 +769,25 @@ export class HybridBackend extends EventEmitter {
      * Structured-first: Prefer structured results, add semantic if not present
      */
     combineStructuredFirst(semanticResults, structuredResults) {
-        const structuredIds = new Set(structuredResults.map((e) => e.id));
+        const structuredIds = new Set();
+        for (const e of structuredResults)
+            structuredIds.add(e.id);
         const additional = semanticResults.filter((e) => !structuredIds.has(e.id));
         return [...structuredResults, ...additional];
     }
-    // ===== Proxy Methods for AgentDB v1 Controllers (ADR-053 #1212) =====
+    // ===== Proxy Methods — stubs for legacy controller API =====
     /**
      * Record feedback for a memory entry.
-     * Delegates to AgentDB's recordFeedback when available.
-     * Gracefully degrades to a no-op when AgentDB is unavailable.
+     * Delegates to semantic backend's recordFeedback when available.
+     * Gracefully degrades to no-op when unavailable.
      */
-    async recordFeedback(entryId, feedback) {
-        const agentdbInstance = this.agentdb.getAgentDB?.();
-        if (agentdbInstance && typeof agentdbInstance.recordFeedback === 'function') {
-            try {
-                await agentdbInstance.recordFeedback(entryId, feedback);
-                this.emit('feedback:recorded', { entryId, score: feedback.score });
-                return true;
-            }
-            catch {
-                // AgentDB feedback recording failed — degrade silently
-            }
-        }
-        return false;
+    async recordFeedback(_entryId, _feedback) {
+        return false; // monolean: stub — LanceDB has no feedback API
     }
-    /**
-     * Verify a witness chain for a memory entry.
-     * Delegates to AgentDB's verifyWitnessChain when available.
-     */
-    async verifyWitnessChain(entryId) {
-        const agentdbInstance = this.agentdb.getAgentDB?.();
-        if (agentdbInstance && typeof agentdbInstance.verifyWitnessChain === 'function') {
-            try {
-                return await agentdbInstance.verifyWitnessChain(entryId);
-            }
-            catch {
-                // Verification failed — return degraded result
-            }
-        }
-        return { valid: false, chainLength: 0, errors: ['AgentDB not available'] };
+    async verifyWitnessChain(_entryId) {
+        return { valid: false, chainLength: 0, errors: ['not supported by LanceDB backend'] };
     }
-    /**
-     * Get the witness chain for a memory entry.
-     * Delegates to AgentDB's getWitnessChain when available.
-     */
-    async getWitnessChain(entryId) {
-        const agentdbInstance = this.agentdb.getAgentDB?.();
-        if (agentdbInstance && typeof agentdbInstance.getWitnessChain === 'function') {
-            try {
-                return await agentdbInstance.getWitnessChain(entryId);
-            }
-            catch {
-                // Chain retrieval failed
-            }
-        }
+    async getWitnessChain(_entryId) {
         return [];
     }
     // ===== Backend Access =====
@@ -796,8 +797,8 @@ export class HybridBackend extends EventEmitter {
     getSQLiteBackend() {
         return this.sqlite;
     }
-    getAgentDBBackend() {
-        return this.agentdb;
+    getSemanticBackend() {
+        return this.semantic;
     }
 }
 export default HybridBackend;