feat(MemoryCore): Add Ollama process lifecycle management and cleanup (#9724)

Author: tobiu

ai/mcp/server/memory-core/managers/SQLiteVectorManager.mjs

@@ -379,6 +379,8 @@ class SQLiteVectorManager extends Base {
 
                 const rows = self.db.prepare(sql).all(...queryArgs);
 
+                let returnData = { ids: [[]], metadatas: [[]], documents: [[]], distances: [[]] };
+
                 for (const row of rows) {
                     returnData.ids[0].push(row.id);
                     returnData.metadatas[0].push(JSON.parse(row.metadata));

ai/mcp/server/memory-core/openapi.yaml

@@ -643,9 +643,12 @@ paths:
           content:
             application/json:
               schema:
-                type: array
-                items:
-                  type: object
+                type: object
+                properties:
+                  neighbors:
+                    type: array
+                    items:
+                      type: object
         '500':
           description: Internal server error.
           content:
@@ -676,9 +679,12 @@ paths:
           content:
             application/json:
               schema:
-                type: array
-                items:
-                  type: object
+                type: object
+                properties:
+                  nodes:
+                    type: array
+                    items:
+                      type: object
         '500':
           description: Internal server error.
           content:

ai/mcp/server/memory-core/services/DatabaseLifecycleService.mjs

@@ -34,6 +34,12 @@ class DatabaseLifecycleService extends Base {
          * @protected
          */
         chromaProcess: null,
+        /**
+         * Holds the child process object for the Ollama server.
+         * @member {ChildProcess|null} ollamaProcess=null
+         * @protected
+         */
+        ollamaProcess: null,
         /**
          * @member {Boolean} singleton=true
          * @protected
@@ -63,6 +69,71 @@ class DatabaseLifecycleService extends Base {
         }
     }
 
+    /**
+     * Checks if the Ollama daemon is running.
+     * @returns {Promise<boolean>}
+     */
+    async isOllamaRunning() {
+        try {
+            const {host} = aiConfig.ollama;
+            const res    = await fetch(`${host}/api/version`);
+            return res.ok;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    /**
+     * Starts the Ollama daemon if it is not already running.
+     * @returns {Promise<void>}
+     */
+    async startOllama() {
+        if (await this.isOllamaRunning()) {
+            logger.log('Ollama daemon is already running (Memory Core).');
+            return;
+        }
+
+        logger.error('Starting Ollama daemon (Memory Core)...');
+
+        await new Promise((resolve, reject) => {
+            const spawnedProcess = spawn('ollama', ['serve'], {
+                detached: true,
+                stdio   : 'ignore'
+            });
+
+            spawnedProcess.on('spawn', () => {
+                this.ollamaProcess = spawnedProcess;
+                logger.log(`Ollama daemon started with PID: ${this.ollamaProcess.pid}`);
+
+                if (!this.cleanupHandler) {
+                    this.cleanupHandler = this.cleanup.bind(this);
+                    process.on('exit', this.cleanupHandler);
+                    process.on('SIGINT', this.cleanupHandler);
+                    process.on('SIGTERM', this.cleanupHandler);
+                }
+                resolve();
+            });
+
+            spawnedProcess.on('error', (err) => {
+                logger.error('Failed to start Ollama daemon:', err);
+                this.ollamaProcess = null;
+                reject(err);
+            });
+
+            spawnedProcess.unref();
+        });
+
+        logger.log('Waiting for Ollama heartbeat...');
+        for (let i = 0; i < 30; i++) {
+            if (await this.isOllamaRunning()) {
+                logger.log('Ollama heartbeat detected.');
+                return;
+            }
+            await new Promise(resolve => setTimeout(resolve, 500));
+        }
+        throw new Error('Ollama failed to start (timeout waiting for heartbeat).');
+    }
+
     /**
      * Manages the database lifecycle based on the provided action.
      * @param {Object} params
@@ -85,25 +156,39 @@ class DatabaseLifecycleService extends Base {
      */
     async startDatabase() {
         try {
+            if (aiConfig.engine === 'neo' || aiConfig.engine === 'both') {
+                if (aiConfig.neoEmbeddingProvider === 'ollama') {
+                    await this.startOllama();
+                }
+            }
+
+            if (aiConfig.engine === 'neo') {
+                return {status: 'neo_engine_active', pid: null, detail: 'SQLite-Vec native engine started.'};
+            }
+
             if (this.chromaProcess && !this.chromaProcess.killed) {
-                return {status: 'already_running', pid: this.chromaProcess.pid, detail: 'Server was started by this process.'};
+                return {
+                    status: 'already_running',
+                    pid   : this.chromaProcess.pid,
+                    detail: 'Server was started by this process.'
+                };
             }
 
             if (await this.isDbRunning()) {
                 const result = {status: 'already_running', pid: null, detail: 'Server was started externally.'};
-                this.fire('processActive', { pid: null, managedByService: false, detail: result.detail });
+                this.fire('processActive', {pid: null, managedByService: false, detail: result.detail});
                 return result;
             }
 
             logger.error('Starting ChromaDB (Memory Core) process...');
 
             await new Promise((resolve, reject) => {
                 const {port, path: dbPath} = aiConfig.memoryDb;
-                const args = ['run', '--path', dbPath, '--port', port.toString()];
+                const args                 = ['run', '--path', dbPath, '--port', port.toString()];
 
                 const spawnedProcess = spawn('chroma', args, {
                     detached: true,
-                    stdio: 'ignore'
+                    stdio   : 'ignore'
                 });
 
                 spawnedProcess.on('spawn', () => {
@@ -131,7 +216,11 @@ class DatabaseLifecycleService extends Base {
             await this.waitForHeartbeat();
 
             const result = {status: 'started', pid: this.chromaProcess.pid};
-            this.fire('processActive', {pid: this.chromaProcess.pid, managedByService: true, detail: 'started by service'});
+            this.fire('processActive', {
+                pid             : this.chromaProcess.pid,
+                managedByService: true,
+                detail          : 'started by service'
+            });
             return result;
         } catch (error) {
             logger.error('[DatabaseLifecycleService] Error starting database:', error);
@@ -160,6 +249,15 @@ class DatabaseLifecycleService extends Base {
             }
         }
 
+        if (this.ollamaProcess) {
+            try {
+                process.kill(-this.ollamaProcess.pid, 'SIGTERM');
+                this.ollamaProcess = null;
+            } catch (e) {
+                // Ignore errors
+            }
+        }
+
         // If this was a signal (not a normal exit), we need to exit explicitly
         if (typeof signalOrCode === 'string') {
             process.exit(0);
@@ -188,6 +286,15 @@ class DatabaseLifecycleService extends Base {
      */
     async stopDatabase() {
         try {
+            if (this.ollamaProcess && !this.ollamaProcess.killed) {
+                logger.log(`Ollama process with PID: ${this.ollamaProcess.pid} has been stopped.`);
+                try {
+                    process.kill(-this.ollamaProcess.pid, 'SIGTERM');
+                } catch (e) {
+                }
+                this.ollamaProcess = null;
+            }
+
             if (!this.chromaProcess || this.chromaProcess.killed) {
                 return {status: 'not_running', detail: 'No process was started by this server.'};
             }
@@ -206,8 +313,8 @@ class DatabaseLifecycleService extends Base {
                         this.cleanupHandler = null;
                     }
 
-                    const result = { status: 'stopped' };
-                    this.fire('processStopped', { pid, managedByService: true });
+                    const result = {status: 'stopped'};
+                    this.fire('processStopped', {pid, managedByService: true});
                     resolve(result);
                 });