feat(memory-mcp): add server scaffold

Author: Aki-07

ai/mcp/server/memory/app.mjs

@@ -0,0 +1,32 @@
+import express          from 'express';
+import fs               from 'fs';
+import morgan           from 'morgan';
+import swaggerUi        from 'swagger-ui-express';
+import yaml             from 'js-yaml';
+import healthRouter     from './routes/health.mjs';
+import memoriesRouter   from './routes/memories.mjs';
+import summariesRouter  from './routes/summaries.mjs';
+import errorHandler     from './middleware/errorHandler.mjs';
+import notFoundHandler  from './middleware/notFoundHandler.mjs';
+import serverConfig     from './config.mjs';
+
+const app = express();
+
+// Middleware
+app.use(express.json({limit: serverConfig.requestBodyLimit}));
+app.use(morgan(serverConfig.logFormat));
+
+// Swagger docs
+const openApiDocument = yaml.load(fs.readFileSync(serverConfig.openApiFilePath, 'utf8'));
+app.use('/docs', swaggerUi.serve, swaggerUi.setup(openApiDocument, {explorer: true}));
+
+// Routes
+app.use('/', healthRouter);
+app.use('/', memoriesRouter);
+app.use('/', summariesRouter);
+
+// 404 + Error handlers
+app.use(notFoundHandler);
+app.use(errorHandler);
+
+export default app;

ai/mcp/server/memory/config.mjs

@@ -0,0 +1,20 @@
+import dotenv from 'dotenv';
+import path   from 'path';
+
+const cwd = process.cwd();
+
+// Load environment variables from the project root, but stay silent if the file does not exist.
+dotenv.config({path: path.resolve(cwd, '.env'), quiet: true});
+
+/**
+ * Central configuration for the Memory MCP server.
+ */
+const serverConfig = {
+    host            : process.env.MEMORY_MCP_HOST || '0.0.0.0',
+    port            : parseInt(process.env.MEMORY_MCP_PORT || '8010', 10),
+    logFormat       : process.env.MEMORY_MCP_LOG_FORMAT || 'dev',
+    openApiFilePath : path.resolve(cwd, 'buildScripts/mcp/memory/openapi.yaml'),
+    requestBodyLimit: process.env.MEMORY_MCP_BODY_LIMIT || '1mb'
+};
+
+export default serverConfig;

ai/mcp/server/memory/index.mjs

@@ -0,0 +1,9 @@
+import app          from './app.mjs';
+import serverConfig from './config.mjs';
+
+const {host, port} = serverConfig;
+
+app.listen(port, host, () => {
+    // eslint-disable-next-line no-console
+    console.log(`[Memory MCP] Server listening on http://${host}:${port}`);
+});

ai/mcp/server/memory/middleware/asyncHandler.mjs

@@ -0,0 +1,8 @@
+/**
+ * Wraps async Express route handlers so errors bubble into the error middleware.
+ * @param {Function} fn The async handler to wrap
+ * @returns {Function}
+ */
+const asyncHandler = fn => (req, res, next) => Promise.resolve(fn(req, res, next)).catch(next);
+
+export default asyncHandler;

ai/mcp/server/memory/middleware/errorHandler.mjs

@@ -0,0 +1,27 @@
+/**
+ * Generic error handler that logs the error and sends a structured JSON response.
+ * @param {Error} err
+ * @param {import('express').Request} req
+ * @param {import('express').Response} res
+ * @param {import('express').NextFunction} next
+ */
+function errorHandler(err, req, res, next) {
+    // eslint-disable-next-line no-console
+    console.error('[Memory MCP] Unhandled error:', err);
+
+    if (res.headersSent) {
+        next(err);
+        return;
+    }
+
+    const status = err.status ?? 500;
+
+    res.status(status).json({
+        error: {
+            message: err.message || 'Internal Server Error',
+            code   : err.code || 'internal_error'
+        }
+    });
+}
+
+export default errorHandler;

ai/mcp/server/memory/middleware/notFoundHandler.mjs

@@ -0,0 +1,15 @@
+/**
+ * Express middleware that handles unknown routes with a 404 response.
+ * @param {import('express').Request} req
+ * @param {import('express').Response} res
+ */
+function notFoundHandler(req, res) {
+    res.status(404).json({
+        error: {
+            message: 'Endpoint not found',
+            code   : 'not_found'
+        }
+    });
+}
+
+export default notFoundHandler;

ai/mcp/server/memory/routes/health.mjs

@@ -0,0 +1,13 @@
+import {Router}          from 'express';
+import asyncHandler      from '../middleware/asyncHandler.mjs';
+import {buildHealthResponse} from '../services/healthService.mjs';
+
+const router = Router();
+
+router.get('/healthcheck', asyncHandler(async (req, res) => {
+    const payload = await buildHealthResponse();
+
+    res.status(200).json(payload);
+}));
+
+export default router;

ai/mcp/server/memory/services/chromaManager.mjs

@@ -0,0 +1,68 @@
+import {ChromaClient} from 'chromadb';
+import aiConfig       from '../../../../../buildScripts/ai/aiConfig.mjs';
+
+/**
+ * Simple manager around the Chroma client that lazily caches frequently used collections.
+ */
+class ChromaManager {
+    constructor() {
+        const {host, port} = aiConfig.memory;
+
+        this.client             = new ChromaClient({host, port, ssl: false});
+        this.memoryCollection   = null;
+        this.summaryCollection  = null;
+    }
+
+    /**
+     * Ensures the process can reach the Chroma server and both collections are available.
+     * @returns {Promise<{heartbeat: number, memoryCollection: string, summaryCollection: string}>}
+     */
+    async checkConnectivity() {
+        const heartbeat = await this.client.heartbeat();
+
+        const memory    = await this.getMemoryCollection();
+        const summaries = await this.getSummaryCollection();
+
+        return {
+            heartbeat,
+            memoryCollection  : memory.name,
+            summaryCollection : summaries.name
+        };
+    }
+
+    /**
+     * @returns {Promise<import('chromadb').Collection>}
+     */
+    async getMemoryCollection() {
+        if (!this.memoryCollection) {
+            const {collectionName} = aiConfig.memory;
+
+            this.memoryCollection = await this.client.getCollection({
+                name            : collectionName,
+                embeddingFunction: aiConfig.dummyEmbeddingFunction
+            });
+        }
+
+        return this.memoryCollection;
+    }
+
+    /**
+     * @returns {Promise<import('chromadb').Collection>}
+     */
+    async getSummaryCollection() {
+        if (!this.summaryCollection) {
+            const {collectionName} = aiConfig.sessions;
+
+            this.summaryCollection = await this.client.getOrCreateCollection({
+                name            : collectionName,
+                embeddingFunction: aiConfig.dummyEmbeddingFunction
+            });
+        }
+
+        return this.summaryCollection;
+    }
+}
+
+const chromaManager = new ChromaManager();
+
+export default chromaManager;

ai/mcp/server/memory/services/healthService.mjs

@@ -0,0 +1,25 @@
+import aiConfig      from '../../../../../buildScripts/ai/aiConfig.mjs';
+import chromaManager from './chromaManager.mjs';
+
+/**
+ * Builds the payload returned by GET /healthcheck.
+ * @returns {Promise<Object>}
+ */
+export async function buildHealthResponse() {
+    const {heartbeat, memoryCollection, summaryCollection} = await chromaManager.checkConnectivity();
+
+    return {
+        status   : 'healthy',
+        timestamp: new Date().toISOString(),
+        database : {
+            host       : aiConfig.memory.host,
+            port       : aiConfig.memory.port,
+            heartbeat,
+            collections: {
+                memories : memoryCollection,
+                summaries: summaryCollection
+            }
+        },
+        uptime: process.uptime()
+    };
+}