@prmichaelsen/remember-mcp 0.1.0

package/dist/server-factory.js

@@ -0,0 +1,1741 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/dotenv/package.json
+var require_package = __commonJS({
+  "node_modules/dotenv/package.json"(exports, module) {
+    module.exports = {
+      name: "dotenv",
+      version: "16.6.1",
+      description: "Loads environment variables from .env file",
+      main: "lib/main.js",
+      types: "lib/main.d.ts",
+      exports: {
+        ".": {
+          types: "./lib/main.d.ts",
+          require: "./lib/main.js",
+          default: "./lib/main.js"
+        },
+        "./config": "./config.js",
+        "./config.js": "./config.js",
+        "./lib/env-options": "./lib/env-options.js",
+        "./lib/env-options.js": "./lib/env-options.js",
+        "./lib/cli-options": "./lib/cli-options.js",
+        "./lib/cli-options.js": "./lib/cli-options.js",
+        "./package.json": "./package.json"
+      },
+      scripts: {
+        "dts-check": "tsc --project tests/types/tsconfig.json",
+        lint: "standard",
+        pretest: "npm run lint && npm run dts-check",
+        test: "tap run --allow-empty-coverage --disable-coverage --timeout=60000",
+        "test:coverage": "tap run --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
+        prerelease: "npm test",
+        release: "standard-version"
+      },
+      repository: {
+        type: "git",
+        url: "git://github.com/motdotla/dotenv.git"
+      },
+      homepage: "https://github.com/motdotla/dotenv#readme",
+      funding: "https://dotenvx.com",
+      keywords: [
+        "dotenv",
+        "env",
+        ".env",
+        "environment",
+        "variables",
+        "config",
+        "settings"
+      ],
+      readmeFilename: "README.md",
+      license: "BSD-2-Clause",
+      devDependencies: {
+        "@types/node": "^18.11.3",
+        decache: "^4.6.2",
+        sinon: "^14.0.1",
+        standard: "^17.0.0",
+        "standard-version": "^9.5.0",
+        tap: "^19.2.0",
+        typescript: "^4.8.4"
+      },
+      engines: {
+        node: ">=12"
+      },
+      browser: {
+        fs: false
+      }
+    };
+  }
+});
+
+// node_modules/dotenv/lib/main.js
+var require_main = __commonJS({
+  "node_modules/dotenv/lib/main.js"(exports, module) {
+    var fs = __require("fs");
+    var path = __require("path");
+    var os = __require("os");
+    var crypto = __require("crypto");
+    var packageJson = require_package();
+    var version = packageJson.version;
+    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+    function parse(src) {
+      const obj = {};
+      let lines = src.toString();
+      lines = lines.replace(/\r\n?/mg, "\n");
+      let match;
+      while ((match = LINE.exec(lines)) != null) {
+        const key = match[1];
+        let value = match[2] || "";
+        value = value.trim();
+        const maybeQuote = value[0];
+        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+        if (maybeQuote === '"') {
+          value = value.replace(/\\n/g, "\n");
+          value = value.replace(/\\r/g, "\r");
+        }
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _parseVault(options) {
+      options = options || {};
+      const vaultPath = _vaultPath(options);
+      options.path = vaultPath;
+      const result = DotenvModule.configDotenv(options);
+      if (!result.parsed) {
+        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+        err.code = "MISSING_DATA";
+        throw err;
+      }
+      const keys = _dotenvKey(options).split(",");
+      const length = keys.length;
+      let decrypted;
+      for (let i = 0; i < length; i++) {
+        try {
+          const key = keys[i].trim();
+          const attrs = _instructions(result, key);
+          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+          break;
+        } catch (error) {
+          if (i + 1 >= length) {
+            throw error;
+          }
+        }
+      }
+      return DotenvModule.parse(decrypted);
+    }
+    function _warn(message) {
+      console.log(`[dotenv@${version}][WARN] ${message}`);
+    }
+    function _debug(message) {
+      console.log(`[dotenv@${version}][DEBUG] ${message}`);
+    }
+    function _log(message) {
+      console.log(`[dotenv@${version}] ${message}`);
+    }
+    function _dotenvKey(options) {
+      if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+        return options.DOTENV_KEY;
+      }
+      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+        return process.env.DOTENV_KEY;
+      }
+      return "";
+    }
+    function _instructions(result, dotenvKey) {
+      let uri;
+      try {
+        uri = new URL(dotenvKey);
+      } catch (error) {
+        if (error.code === "ERR_INVALID_URL") {
+          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        }
+        throw error;
+      }
+      const key = uri.password;
+      if (!key) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environment = uri.searchParams.get("environment");
+      if (!environment) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+      const ciphertext = result.parsed[environmentKey];
+      if (!ciphertext) {
+        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+        throw err;
+      }
+      return { ciphertext, key };
+    }
+    function _vaultPath(options) {
+      let possibleVaultPath = null;
+      if (options && options.path && options.path.length > 0) {
+        if (Array.isArray(options.path)) {
+          for (const filepath of options.path) {
+            if (fs.existsSync(filepath)) {
+              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+            }
+          }
+        } else {
+          possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+        }
+      } else {
+        possibleVaultPath = path.resolve(process.cwd(), ".env.vault");
+      }
+      if (fs.existsSync(possibleVaultPath)) {
+        return possibleVaultPath;
+      }
+      return null;
+    }
+    function _resolveHome(envPath) {
+      return envPath[0] === "~" ? path.join(os.homedir(), envPath.slice(1)) : envPath;
+    }
+    function _configVault(options) {
+      const debug = Boolean(options && options.debug);
+      const quiet = options && "quiet" in options ? options.quiet : true;
+      if (debug || !quiet) {
+        _log("Loading env from encrypted .env.vault");
+      }
+      const parsed = DotenvModule._parseVault(options);
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsed, options);
+      return { parsed };
+    }
+    function configDotenv(options) {
+      const dotenvPath = path.resolve(process.cwd(), ".env");
+      let encoding = "utf8";
+      const debug = Boolean(options && options.debug);
+      const quiet = options && "quiet" in options ? options.quiet : true;
+      if (options && options.encoding) {
+        encoding = options.encoding;
+      } else {
+        if (debug) {
+          _debug("No encoding is specified. UTF-8 is used by default");
+        }
+      }
+      let optionPaths = [dotenvPath];
+      if (options && options.path) {
+        if (!Array.isArray(options.path)) {
+          optionPaths = [_resolveHome(options.path)];
+        } else {
+          optionPaths = [];
+          for (const filepath of options.path) {
+            optionPaths.push(_resolveHome(filepath));
+          }
+        }
+      }
+      let lastError;
+      const parsedAll = {};
+      for (const path2 of optionPaths) {
+        try {
+          const parsed = DotenvModule.parse(fs.readFileSync(path2, { encoding }));
+          DotenvModule.populate(parsedAll, parsed, options);
+        } catch (e) {
+          if (debug) {
+            _debug(`Failed to load ${path2} ${e.message}`);
+          }
+          lastError = e;
+        }
+      }
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsedAll, options);
+      if (debug || !quiet) {
+        const keysCount = Object.keys(parsedAll).length;
+        const shortPaths = [];
+        for (const filePath of optionPaths) {
+          try {
+            const relative = path.relative(process.cwd(), filePath);
+            shortPaths.push(relative);
+          } catch (e) {
+            if (debug) {
+              _debug(`Failed to load ${filePath} ${e.message}`);
+            }
+            lastError = e;
+          }
+        }
+        _log(`injecting env (${keysCount}) from ${shortPaths.join(",")}`);
+      }
+      if (lastError) {
+        return { parsed: parsedAll, error: lastError };
+      } else {
+        return { parsed: parsedAll };
+      }
+    }
+    function config2(options) {
+      if (_dotenvKey(options).length === 0) {
+        return DotenvModule.configDotenv(options);
+      }
+      const vaultPath = _vaultPath(options);
+      if (!vaultPath) {
+        _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+        return DotenvModule.configDotenv(options);
+      }
+      return DotenvModule._configVault(options);
+    }
+    function decrypt(encrypted, keyStr) {
+      const key = Buffer.from(keyStr.slice(-64), "hex");
+      let ciphertext = Buffer.from(encrypted, "base64");
+      const nonce = ciphertext.subarray(0, 12);
+      const authTag = ciphertext.subarray(-16);
+      ciphertext = ciphertext.subarray(12, -16);
+      try {
+        const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+        aesgcm.setAuthTag(authTag);
+        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+      } catch (error) {
+        const isRange = error instanceof RangeError;
+        const invalidKeyLength = error.message === "Invalid key length";
+        const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+        if (isRange || invalidKeyLength) {
+          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        } else if (decryptionFailed) {
+          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+          err.code = "DECRYPTION_FAILED";
+          throw err;
+        } else {
+          throw error;
+        }
+      }
+    }
+    function populate(processEnv, parsed, options = {}) {
+      const debug = Boolean(options && options.debug);
+      const override = Boolean(options && options.override);
+      if (typeof parsed !== "object") {
+        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+        err.code = "OBJECT_REQUIRED";
+        throw err;
+      }
+      for (const key of Object.keys(parsed)) {
+        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+          if (override === true) {
+            processEnv[key] = parsed[key];
+          }
+          if (debug) {
+            if (override === true) {
+              _debug(`"${key}" is already defined and WAS overwritten`);
+            } else {
+              _debug(`"${key}" is already defined and was NOT overwritten`);
+            }
+          }
+        } else {
+          processEnv[key] = parsed[key];
+        }
+      }
+    }
+    var DotenvModule = {
+      configDotenv,
+      _configVault,
+      _parseVault,
+      config: config2,
+      decrypt,
+      parse,
+      populate
+    };
+    module.exports.configDotenv = DotenvModule.configDotenv;
+    module.exports._configVault = DotenvModule._configVault;
+    module.exports._parseVault = DotenvModule._parseVault;
+    module.exports.config = DotenvModule.config;
+    module.exports.decrypt = DotenvModule.decrypt;
+    module.exports.parse = DotenvModule.parse;
+    module.exports.populate = DotenvModule.populate;
+    module.exports = DotenvModule;
+  }
+});
+
+// src/config.ts
+var import_dotenv, config;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    import_dotenv = __toESM(require_main(), 1);
+    import_dotenv.default.config();
+    config = {
+      // Weaviate
+      weaviate: {
+        url: process.env.WEAVIATE_URL || "http://localhost:8080",
+        apiKey: process.env.WEAVIATE_API_KEY || ""
+      },
+      // OpenAI
+      openai: {
+        apiKey: process.env.OPENAI_APIKEY || ""
+      },
+      // Firebase (using firebase-admin-sdk-v8)
+      firebase: {
+        serviceAccount: process.env.FIREBASE_ADMIN_SERVICE_ACCOUNT_KEY || "",
+        projectId: process.env.FIREBASE_PROJECT_ID || ""
+      },
+      // Server
+      server: {
+        port: parseInt(process.env.PORT || "3000", 10),
+        nodeEnv: process.env.NODE_ENV || "development",
+        logLevel: process.env.LOG_LEVEL || "info"
+      },
+      // MCP
+      mcp: {
+        transport: process.env.MCP_TRANSPORT || "sse"
+      }
+    };
+  }
+});
+
+// src/weaviate/client.ts
+var client_exports = {};
+__export(client_exports, {
+  closeWeaviateClient: () => closeWeaviateClient,
+  collectionExists: () => collectionExists,
+  getAuditCollectionName: () => getAuditCollectionName,
+  getMemoryCollectionName: () => getMemoryCollectionName,
+  getTemplateCollectionName: () => getTemplateCollectionName,
+  getWeaviateClient: () => getWeaviateClient,
+  initWeaviateClient: () => initWeaviateClient,
+  sanitizeUserId: () => sanitizeUserId,
+  testWeaviateConnection: () => testWeaviateConnection
+});
+import weaviate from "weaviate-client";
+async function initWeaviateClient() {
+  if (client) {
+    return client;
+  }
+  client = await weaviate.connectToWeaviateCloud(config.weaviate.url, {
+    authCredentials: config.weaviate.apiKey ? new weaviate.ApiKey(config.weaviate.apiKey) : void 0,
+    headers: config.openai.apiKey ? { "X-OpenAI-Api-Key": config.openai.apiKey } : void 0
+  });
+  console.log("[Weaviate] Client initialized");
+  return client;
+}
+function getWeaviateClient() {
+  if (!client) {
+    throw new Error("Weaviate client not initialized. Call initWeaviateClient() first.");
+  }
+  return client;
+}
+async function testWeaviateConnection() {
+  try {
+    const weaviateClient = getWeaviateClient();
+    const isReady = await weaviateClient.isReady();
+    console.log("[Weaviate] Connection successful, ready:", isReady);
+    return isReady;
+  } catch (error) {
+    console.error("[Weaviate] Connection failed:", error);
+    return false;
+  }
+}
+function sanitizeUserId(userId) {
+  let sanitized = userId.replace(/[^a-zA-Z0-9]/g, "_");
+  if (/^[0-9]/.test(sanitized)) {
+    sanitized = "_" + sanitized;
+  }
+  return sanitized.charAt(0).toUpperCase() + sanitized.slice(1);
+}
+function getMemoryCollectionName(userId) {
+  return `Memory_${sanitizeUserId(userId)}`;
+}
+function getTemplateCollectionName(userId) {
+  return `Template_${sanitizeUserId(userId)}`;
+}
+function getAuditCollectionName(userId) {
+  return `Audit_${sanitizeUserId(userId)}`;
+}
+async function collectionExists(collectionName) {
+  try {
+    const weaviateClient = getWeaviateClient();
+    const exists = await weaviateClient.collections.exists(collectionName);
+    return exists;
+  } catch (error) {
+    console.error(`[Weaviate] Error checking collection ${collectionName}:`, error);
+    return false;
+  }
+}
+async function closeWeaviateClient() {
+  if (client) {
+    client = null;
+    console.log("[Weaviate] Client closed");
+  }
+}
+var client;
+var init_client = __esm({
+  "src/weaviate/client.ts"() {
+    "use strict";
+    init_config();
+    client = null;
+  }
+});
+
+// src/firestore/init.ts
+var init_exports = {};
+__export(init_exports, {
+  FieldValue: () => FieldValue,
+  addDocument: () => addDocument,
+  batchWrite: () => batchWrite,
+  deleteDocument: () => deleteDocument,
+  getDocument: () => getDocument,
+  initFirestore: () => initFirestore,
+  isFirestoreInitialized: () => isFirestoreInitialized,
+  queryDocuments: () => queryDocuments,
+  setDocument: () => setDocument,
+  testFirestoreConnection: () => testFirestoreConnection,
+  updateDocument: () => updateDocument,
+  verifyIdToken: () => verifyIdToken
+});
+import { initializeApp } from "@prmichaelsen/firebase-admin-sdk-v8";
+import {
+  getDocument,
+  setDocument,
+  addDocument,
+  updateDocument,
+  deleteDocument,
+  queryDocuments,
+  batchWrite,
+  FieldValue,
+  verifyIdToken
+} from "@prmichaelsen/firebase-admin-sdk-v8";
+function initFirestore() {
+  if (initialized) {
+    return;
+  }
+  try {
+    initializeApp({
+      serviceAccount: JSON.parse(config.firebase.serviceAccount),
+      projectId: config.firebase.projectId
+    });
+    initialized = true;
+    console.log("[Firestore] Initialized");
+  } catch (error) {
+    console.error("[Firestore] Initialization failed:", error);
+    throw error;
+  }
+}
+function isFirestoreInitialized() {
+  return initialized;
+}
+async function testFirestoreConnection() {
+  try {
+    if (!initialized) {
+      throw new Error("Firestore not initialized");
+    }
+    const { getDocument: getDocument2 } = await import("@prmichaelsen/firebase-admin-sdk-v8");
+    await getDocument2("_health_check", "test");
+    console.log("[Firestore] Connection successful");
+    return true;
+  } catch (error) {
+    console.error("[Firestore] Connection test failed:", error);
+    return false;
+  }
+}
+var initialized;
+var init_init = __esm({
+  "src/firestore/init.ts"() {
+    "use strict";
+    init_config();
+    initialized = false;
+  }
+});
+
+// src/server-factory.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ErrorCode,
+  McpError
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/utils/logger.ts
+init_config();
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var currentLevel = LOG_LEVELS[config.server.logLevel] ?? LOG_LEVELS.info;
+function shouldLog(level) {
+  return LOG_LEVELS[level] >= currentLevel;
+}
+var logger = {
+  debug: (message, ...args) => {
+    if (shouldLog("debug")) {
+      console.debug(`[DEBUG] ${message}`, ...args);
+    }
+  },
+  info: (message, ...args) => {
+    if (shouldLog("info")) {
+      console.info(`[INFO] ${message}`, ...args);
+    }
+  },
+  warn: (message, ...args) => {
+    if (shouldLog("warn")) {
+      console.warn(`[WARN] ${message}`, ...args);
+    }
+  },
+  error: (message, ...args) => {
+    if (shouldLog("error")) {
+      console.error(`[ERROR] ${message}`, ...args);
+    }
+  }
+};
+
+// src/weaviate/schema.ts
+init_client();
+import weaviate2 from "weaviate-client";
+async function createMemoryCollection(userId) {
+  const client2 = getWeaviateClient();
+  const collectionName = `Memory_${sanitizeUserId(userId)}`;
+  const exists = await client2.collections.exists(collectionName);
+  if (exists) {
+    console.log(`[Weaviate] Collection ${collectionName} already exists`);
+    return;
+  }
+  console.log(`[Weaviate] Creating collection ${collectionName}...`);
+  await client2.collections.create({
+    name: collectionName,
+    // Vectorizer configuration
+    vectorizers: weaviate2.configure.vectorizer.text2VecOpenAI({
+      model: "text-embedding-3-small",
+      // Vectorize both memory content and relationship observations
+      sourceProperties: ["content", "observation"]
+    }),
+    properties: [
+      // Discriminator
+      {
+        name: "doc_type",
+        dataType: "text",
+        description: 'Document type: "memory" or "relationship"'
+      },
+      // Core identity
+      {
+        name: "user_id",
+        dataType: "text",
+        description: "User who owns this document"
+      },
+      // Memory fields
+      {
+        name: "content",
+        dataType: "text",
+        description: "Main memory content (vectorized)"
+      },
+      {
+        name: "title",
+        dataType: "text",
+        description: "Optional short title"
+      },
+      {
+        name: "summary",
+        dataType: "text",
+        description: "Optional brief summary"
+      },
+      {
+        name: "type",
+        dataType: "text",
+        description: "Content type (note, event, person, etc.)"
+      },
+      // Scoring fields
+      {
+        name: "weight",
+        dataType: "number",
+        description: "Significance/priority (0-1)"
+      },
+      {
+        name: "trust",
+        dataType: "number",
+        description: "Access control level (0-1)"
+      },
+      {
+        name: "confidence",
+        dataType: "number",
+        description: "System confidence in accuracy (0-1)"
+      },
+      // Location fields (flattened for Weaviate)
+      {
+        name: "location_gps_lat",
+        dataType: "number",
+        description: "GPS latitude"
+      },
+      {
+        name: "location_gps_lng",
+        dataType: "number",
+        description: "GPS longitude"
+      },
+      {
+        name: "location_address",
+        dataType: "text",
+        description: "Formatted address"
+      },
+      {
+        name: "location_city",
+        dataType: "text",
+        description: "City name"
+      },
+      {
+        name: "location_country",
+        dataType: "text",
+        description: "Country name"
+      },
+      {
+        name: "location_source",
+        dataType: "text",
+        description: "Location source (gps, ip, manual, etc.)"
+      },
+      // Locale fields
+      {
+        name: "locale_language",
+        dataType: "text",
+        description: "Language code (e.g., en, es, fr)"
+      },
+      {
+        name: "locale_timezone",
+        dataType: "text",
+        description: "Timezone (e.g., America/Los_Angeles)"
+      },
+      // Context fields
+      {
+        name: "context_conversation_id",
+        dataType: "text",
+        description: "Conversation ID"
+      },
+      {
+        name: "context_summary",
+        dataType: "text",
+        description: "Brief context summary"
+      },
+      {
+        name: "context_timestamp",
+        dataType: "date",
+        description: "Context timestamp"
+      },
+      // Relationships
+      {
+        name: "relationships",
+        dataType: "text[]",
+        description: "Array of relationship IDs"
+      },
+      // Access tracking
+      {
+        name: "access_count",
+        dataType: "number",
+        description: "Total times accessed"
+      },
+      {
+        name: "last_accessed_at",
+        dataType: "date",
+        description: "Most recent access timestamp"
+      },
+      // Metadata
+      {
+        name: "tags",
+        dataType: "text[]",
+        description: "Tags for organization"
+      },
+      {
+        name: "references",
+        dataType: "text[]",
+        description: "Source URLs"
+      },
+      {
+        name: "created_at",
+        dataType: "date",
+        description: "Creation timestamp"
+      },
+      {
+        name: "updated_at",
+        dataType: "date",
+        description: "Last update timestamp"
+      },
+      {
+        name: "version",
+        dataType: "number",
+        description: "Version number"
+      },
+      // Template fields
+      {
+        name: "template_id",
+        dataType: "text",
+        description: "Template ID if using template"
+      },
+      // Relationship-specific fields
+      {
+        name: "memory_ids",
+        dataType: "text[]",
+        description: "Connected memory IDs (for relationships)"
+      },
+      {
+        name: "relationship_type",
+        dataType: "text",
+        description: "Relationship type (for relationships)"
+      },
+      {
+        name: "observation",
+        dataType: "text",
+        description: "Relationship observation (vectorized)"
+      },
+      {
+        name: "strength",
+        dataType: "number",
+        description: "Relationship strength (0-1)"
+      },
+      // Computed fields
+      {
+        name: "base_weight",
+        dataType: "number",
+        description: "User-specified weight"
+      },
+      {
+        name: "computed_weight",
+        dataType: "number",
+        description: "Calculated effective weight"
+      }
+    ]
+  });
+  console.log(`[Weaviate] Collection ${collectionName} created successfully`);
+}
+async function ensureMemoryCollection(userId) {
+  const client2 = getWeaviateClient();
+  const collectionName = `Memory_${sanitizeUserId(userId)}`;
+  const exists = await client2.collections.exists(collectionName);
+  if (!exists) {
+    await createMemoryCollection(userId);
+  }
+}
+function getMemoryCollection(userId) {
+  const client2 = getWeaviateClient();
+  const collectionName = `Memory_${sanitizeUserId(userId)}`;
+  return client2.collections.get(collectionName);
+}
+
+// src/constants/content-types.ts
+var CONTENT_TYPES = [
+  // Core types
+  "code",
+  "note",
+  "documentation",
+  "reference",
+  // Task & Planning
+  "todo",
+  "checklist",
+  "project",
+  "goal",
+  "habit",
+  // Communication
+  "email",
+  "conversation",
+  "meeting",
+  "person",
+  // Unified person template (replaces both 'contact' and 'person')
+  // Content & Media
+  "article",
+  "webpage",
+  "social",
+  "image",
+  "video",
+  "audio",
+  "transcript",
+  "presentation",
+  "spreadsheet",
+  "pdf",
+  // Creative
+  "screenplay",
+  "recipe",
+  "idea",
+  "quote",
+  // Personal
+  "journal",
+  "memory",
+  "event",
+  // Organizational
+  "bookmark",
+  "form",
+  "location",
+  // Business
+  "invoice",
+  "contract",
+  // System
+  "system",
+  "action",
+  "audit",
+  "history"
+];
+var CONTENT_TYPE_METADATA = {
+  // Core Types
+  code: {
+    name: "code",
+    category: "core",
+    description: "Source code files and programming content",
+    examples: ["Code snippets", "Functions", "Scripts", "Configuration files"],
+    common_fields: ["language", "framework", "purpose"]
+  },
+  note: {
+    name: "note",
+    category: "core",
+    description: "Personal notes and quick documentation",
+    examples: ["Quick notes", "Reminders", "Observations", "Thoughts"]
+  },
+  documentation: {
+    name: "documentation",
+    category: "core",
+    description: "Technical documentation and guides",
+    examples: ["API docs", "User guides", "Technical specs", "How-to guides"]
+  },
+  reference: {
+    name: "reference",
+    category: "core",
+    description: "Quick reference guides and cheat sheets",
+    examples: ["Command references", "Keyboard shortcuts", "API references", "Cheat sheets"]
+  },
+  // Task & Planning
+  todo: {
+    name: "todo",
+    category: "task",
+    description: "Individual tasks with due dates and priorities",
+    examples: ["Task items", "Action items", "Assignments"],
+    common_fields: ["due_date", "priority", "status", "assignee"]
+  },
+  checklist: {
+    name: "checklist",
+    category: "task",
+    description: "Reusable checklists and sequential steps",
+    examples: ["Grocery lists", "Packing lists", "Process checklists", "Preparation lists"],
+    common_fields: ["items", "completion_percentage"]
+  },
+  project: {
+    name: "project",
+    category: "task",
+    description: "Project plans and overviews",
+    examples: ["Project documentation", "Project plans", "Milestones"],
+    common_fields: ["status", "start_date", "end_date", "stakeholders"]
+  },
+  goal: {
+    name: "goal",
+    category: "task",
+    description: "Goals, objectives, and milestones",
+    examples: ["Personal goals", "Professional objectives", "KPIs"],
+    common_fields: ["target_date", "progress", "milestones"]
+  },
+  habit: {
+    name: "habit",
+    category: "task",
+    description: "Routines and habit tracking",
+    examples: ["Daily habits", "Routines", "Recurring activities"],
+    common_fields: ["frequency", "streak", "trigger"]
+  },
+  // Communication
+  email: {
+    name: "email",
+    category: "communication",
+    description: "Email messages and threads",
+    examples: ["Email messages", "Email threads", "Drafts"],
+    common_fields: ["from", "to", "subject", "date"]
+  },
+  conversation: {
+    name: "conversation",
+    category: "communication",
+    description: "Chat logs and conversations",
+    examples: ["Chat messages", "Conversation logs", "Discussions"],
+    common_fields: ["participants", "platform"]
+  },
+  meeting: {
+    name: "meeting",
+    category: "communication",
+    description: "Meeting notes and action items",
+    examples: ["Meeting notes", "Standup notes", "Conference calls"],
+    common_fields: ["attendees", "agenda", "decisions", "action_items"]
+  },
+  person: {
+    name: "person",
+    category: "communication",
+    description: "Track information about people - personal, professional, or both",
+    examples: ["Friends", "Family", "Colleagues", "Professional contacts", "Business partners"],
+    common_fields: ["name", "relationship", "company", "job_title", "how_we_met", "contact_info", "birthday", "interests"]
+  },
+  // Content & Media
+  article: {
+    name: "article",
+    category: "content",
+    description: "Articles and blog posts",
+    examples: ["Blog posts", "News articles", "Long-form content"],
+    common_fields: ["author", "publication", "url"]
+  },
+  webpage: {
+    name: "webpage",
+    category: "content",
+    description: "Saved web pages and HTML content",
+    examples: ["Web pages", "HTML documents", "Web content"],
+    common_fields: ["url", "domain", "archived_at"]
+  },
+  social: {
+    name: "social",
+    category: "content",
+    description: "Social media posts and updates",
+    examples: ["Tweets", "Posts", "Status updates"],
+    common_fields: ["platform", "author", "url"]
+  },
+  image: {
+    name: "image",
+    category: "media",
+    description: "Image files and visual content",
+    examples: ["Photos", "Screenshots", "Diagrams", "Illustrations"],
+    common_fields: ["file_path", "dimensions", "format"]
+  },
+  video: {
+    name: "video",
+    category: "media",
+    description: "Video files and recordings",
+    examples: ["Videos", "Recordings", "Tutorials"],
+    common_fields: ["duration", "format", "url"]
+  },
+  audio: {
+    name: "audio",
+    category: "media",
+    description: "Audio files and recordings",
+    examples: ["Voice notes", "Podcasts", "Music", "Recordings"],
+    common_fields: ["duration", "format"]
+  },
+  transcript: {
+    name: "transcript",
+    category: "media",
+    description: "Transcriptions of audio or video",
+    examples: ["Meeting transcripts", "Podcast transcripts", "Video captions"],
+    common_fields: ["source_media", "speakers"]
+  },
+  presentation: {
+    name: "presentation",
+    category: "content",
+    description: "Presentation slides and decks",
+    examples: ["Slide decks", "Pitch decks", "Presentations"],
+    common_fields: ["slide_count", "format"]
+  },
+  spreadsheet: {
+    name: "spreadsheet",
+    category: "content",
+    description: "Data tables and spreadsheet content",
+    examples: ["Spreadsheets", "Data tables", "CSV content"],
+    common_fields: ["rows", "columns", "format"]
+  },
+  pdf: {
+    name: "pdf",
+    category: "content",
+    description: "PDF documents and scanned files",
+    examples: ["PDF documents", "Scanned documents", "Reports"],
+    common_fields: ["pages", "file_size"]
+  },
+  // Creative
+  screenplay: {
+    name: "screenplay",
+    category: "creative",
+    description: "Screenplay and script content",
+    examples: ["Screenplays", "Scripts", "Dialogue"],
+    common_fields: ["characters", "scenes"]
+  },
+  recipe: {
+    name: "recipe",
+    category: "creative",
+    description: "Cooking recipes and instructions",
+    examples: ["Recipes", "Cooking instructions", "Meal plans"],
+    common_fields: ["ingredients", "instructions", "servings", "prep_time", "cook_time"]
+  },
+  idea: {
+    name: "idea",
+    category: "creative",
+    description: "Brainstorming and concepts",
+    examples: ["Ideas", "Brainstorms", "Concepts", "Inspiration"],
+    common_fields: ["category", "potential_impact"]
+  },
+  quote: {
+    name: "quote",
+    category: "creative",
+    description: "Memorable quotes and excerpts",
+    examples: ["Quotes", "Excerpts", "Highlights", "Citations"],
+    common_fields: ["author", "source"]
+  },
+  // Personal
+  journal: {
+    name: "journal",
+    category: "personal",
+    description: "Daily journal entries and reflections",
+    examples: ["Journal entries", "Diary entries", "Reflections"],
+    common_fields: ["date", "mood", "highlights"]
+  },
+  memory: {
+    name: "memory",
+    category: "personal",
+    description: "Personal memories and significant moments",
+    examples: ["Life events", "Significant moments", "Memories"],
+    common_fields: ["date", "people_involved", "location"]
+  },
+  event: {
+    name: "event",
+    category: "personal",
+    description: "Calendar events and activities",
+    examples: ["Events", "Activities", "Appointments"],
+    common_fields: ["date", "time", "location", "attendees"]
+  },
+  // Organizational
+  bookmark: {
+    name: "bookmark",
+    category: "organizational",
+    description: "Web bookmarks and resource collections",
+    examples: ["Bookmarks", "Resource links", "Reading lists"],
+    common_fields: ["url", "domain", "read_later"]
+  },
+  form: {
+    name: "form",
+    category: "organizational",
+    description: "Forms and surveys",
+    examples: ["Questionnaires", "Feedback forms", "Surveys"],
+    common_fields: ["fields", "responses"]
+  },
+  location: {
+    name: "location",
+    category: "organizational",
+    description: "Place information and recommendations",
+    examples: ["Places", "Venues", "Destinations", "Locations"],
+    common_fields: ["address", "gps", "rating"]
+  },
+  // Business
+  invoice: {
+    name: "invoice",
+    category: "business",
+    description: "Invoices and receipts",
+    examples: ["Invoices", "Receipts", "Bills"],
+    common_fields: ["amount", "date", "vendor", "items"]
+  },
+  contract: {
+    name: "contract",
+    category: "business",
+    description: "Contracts and agreements",
+    examples: ["Contracts", "Agreements", "Terms of service"],
+    common_fields: ["parties", "effective_date", "terms"]
+  },
+  // System
+  system: {
+    name: "system",
+    category: "system",
+    description: "Agent instructions (reserved for internal use only)",
+    examples: ["System prompts", "Agent instructions", "Configuration"]
+  },
+  action: {
+    name: "action",
+    category: "system",
+    description: "Agent actions and operations",
+    examples: ["Actions taken", "Operations performed", "Commands executed"],
+    common_fields: ["action_type", "status", "result"]
+  },
+  audit: {
+    name: "audit",
+    category: "system",
+    description: "Audit logs and compliance records",
+    examples: ["Audit logs", "Access logs", "Security events"],
+    common_fields: ["event_type", "actor", "target", "result"]
+  },
+  history: {
+    name: "history",
+    category: "system",
+    description: "Change history and version tracking",
+    examples: ["Edit history", "Version history", "Change logs"],
+    common_fields: ["target_id", "change_type", "previous_value", "new_value"]
+  }
+};
+function isValidContentType(type) {
+  return CONTENT_TYPES.includes(type);
+}
+function getContentTypeDescription() {
+  const categoryNames = {
+    core: "Core Types",
+    task: "Task & Planning",
+    communication: "Communication",
+    content: "Content & Media",
+    media: "Content & Media",
+    creative: "Creative",
+    personal: "Personal",
+    organizational: "Organizational",
+    business: "Business",
+    system: "System (Internal Use)"
+  };
+  const lines = ["Type of content:", ""];
+  const categorized = /* @__PURE__ */ new Map();
+  for (const type of CONTENT_TYPES) {
+    const metadata = CONTENT_TYPE_METADATA[type];
+    const categoryKey = metadata.category;
+    if (!categorized.has(categoryKey)) {
+      categorized.set(categoryKey, []);
+    }
+    categorized.get(categoryKey).push(type);
+  }
+  for (const [categoryKey, types] of categorized) {
+    const categoryName = categoryNames[categoryKey] || categoryKey;
+    lines.push(`${categoryName}:`);
+    for (const type of types) {
+      const metadata = CONTENT_TYPE_METADATA[type];
+      lines.push(`  - '${type}': ${metadata.description}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trim();
+}
+var DEFAULT_CONTENT_TYPE = "note";
+
+// src/tools/create-memory.ts
+var createMemoryTool = {
+  name: "remember_create_memory",
+  description: `Create a new memory with optional template.
+  
+  Memories can store any type of information: notes, events, people, recipes, etc.
+  Each memory has a weight (significance 0-1) and trust level (access control 0-1).
+  Location and context are automatically captured from the request.
+  
+  Examples:
+  - "Remember that I met Sarah at the conference"
+  - "Save this recipe for chocolate chip cookies"
+  - "Note that my tent is stored in garage bin A4"
+  `,
+  inputSchema: {
+    type: "object",
+    properties: {
+      content: {
+        type: "string",
+        description: "Memory content (main text)"
+      },
+      title: {
+        type: "string",
+        description: "Optional short title"
+      },
+      type: {
+        type: "string",
+        description: getContentTypeDescription(),
+        default: DEFAULT_CONTENT_TYPE
+      },
+      weight: {
+        type: "number",
+        description: "Significance/priority (0-1, default: 0.5)",
+        minimum: 0,
+        maximum: 1
+      },
+      trust: {
+        type: "number",
+        description: "Access control level (0-1, default: 0.5)",
+        minimum: 0,
+        maximum: 1
+      },
+      tags: {
+        type: "array",
+        items: { type: "string" },
+        description: "Tags for organization"
+      },
+      references: {
+        type: "array",
+        items: { type: "string" },
+        description: "Source URLs"
+      },
+      template_id: {
+        type: "string",
+        description: "Template ID to use (optional)"
+      },
+      skip_template_suggestion: {
+        type: "boolean",
+        description: "Skip automatic template suggestion",
+        default: false
+      }
+    },
+    required: ["content"]
+  }
+};
+async function handleCreateMemory(args, userId, context) {
+  try {
+    logger.info("Creating memory", { userId, type: args.type });
+    await ensureMemoryCollection(userId);
+    const collection = getMemoryCollection(userId);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const memory = {
+      // Core identity
+      user_id: userId,
+      doc_type: "memory",
+      // Content
+      content: args.content,
+      title: args.title,
+      summary: args.title,
+      // Use title as summary for now
+      type: args.type && isValidContentType(args.type) ? args.type : DEFAULT_CONTENT_TYPE,
+      // Scoring
+      weight: args.weight ?? 0.5,
+      trust: args.trust ?? 0.5,
+      confidence: 1,
+      // Location (from context or default)
+      location: {
+        gps: null,
+        address: null,
+        source: "unavailable",
+        confidence: 0,
+        is_approximate: true
+      },
+      // Context
+      context: {
+        timestamp: now,
+        source: {
+          type: "api",
+          platform: "mcp"
+        },
+        summary: context?.summary || "Memory created via MCP",
+        conversation_id: context?.conversation_id,
+        ...context
+      },
+      // Relationships
+      relationships: [],
+      // Access tracking
+      access_count: 0,
+      last_accessed_at: now,
+      access_frequency: 0,
+      // Metadata
+      created_at: now,
+      updated_at: now,
+      version: 1,
+      tags: args.tags || [],
+      references: args.references || [],
+      // Template
+      template_id: args.template_id,
+      structured_content: args.structured_content,
+      // Computed weight
+      base_weight: args.weight ?? 0.5,
+      computed_weight: args.weight ?? 0.5
+    };
+    const result = await collection.data.insert(memory);
+    logger.info("Memory created successfully", { memoryId: result, userId });
+    const response = {
+      memory_id: result,
+      created_at: now,
+      message: `Memory created successfully with ID: ${result}`
+    };
+    return JSON.stringify(response, null, 2);
+  } catch (error) {
+    logger.error("Failed to create memory:", error);
+    throw new Error(`Failed to create memory: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+// src/tools/search-memory.ts
+var searchMemoryTool = {
+  name: "remember_search_memory",
+  description: `Search memories using hybrid semantic and keyword search.
+  
+  Supports:
+  - Semantic search (meaning-based)
+  - Keyword search (exact matches)
+  - Hybrid search (balanced with alpha parameter)
+  - Filtering by type, tags, weight, trust, date range
+  - Location-based search
+  
+  Examples:
+  - "Find memories about camping trips"
+  - "Search for recipes I saved"
+  - "Show me notes from last week"
+  `,
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "Search query"
+      },
+      alpha: {
+        type: "number",
+        description: "Balance between semantic (1.0) and keyword (0.0) search. Default: 0.7",
+        minimum: 0,
+        maximum: 1,
+        default: 0.7
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of results. Default: 10",
+        minimum: 1,
+        maximum: 100,
+        default: 10
+      },
+      offset: {
+        type: "number",
+        description: "Pagination offset. Default: 0",
+        minimum: 0,
+        default: 0
+      },
+      filters: {
+        type: "object",
+        description: "Optional filters",
+        properties: {
+          types: {
+            type: "array",
+            items: { type: "string" },
+            description: "Filter by content types"
+          },
+          tags: {
+            type: "array",
+            items: { type: "string" },
+            description: "Filter by tags"
+          },
+          weight_min: {
+            type: "number",
+            description: "Minimum weight (0-1)"
+          },
+          trust_min: {
+            type: "number",
+            description: "Minimum trust level (0-1)"
+          },
+          date_from: {
+            type: "string",
+            description: "Start date (ISO 8601)"
+          },
+          date_to: {
+            type: "string",
+            description: "End date (ISO 8601)"
+          }
+        }
+      },
+      include_relationships: {
+        type: "boolean",
+        description: "Include relationships in results. Default: false",
+        default: false
+      }
+    },
+    required: ["query"]
+  }
+};
+async function handleSearchMemory(args, userId) {
+  try {
+    logger.info("Searching memories", { userId, query: args.query });
+    const collection = getMemoryCollection(userId);
+    const alpha = args.alpha ?? 0.7;
+    const limit = args.limit ?? 10;
+    const offset = args.offset ?? 0;
+    const whereFilters = [
+      {
+        path: "doc_type",
+        operator: "Equal",
+        valueText: "memory"
+      }
+    ];
+    if (args.filters?.types && args.filters.types.length > 0) {
+      whereFilters.push({
+        path: "type",
+        operator: "ContainsAny",
+        valueTextArray: args.filters.types
+      });
+    }
+    if (args.filters?.weight_min !== void 0) {
+      whereFilters.push({
+        path: "weight",
+        operator: "GreaterThanEqual",
+        valueNumber: args.filters.weight_min
+      });
+    }
+    if (args.filters?.trust_min !== void 0) {
+      whereFilters.push({
+        path: "trust",
+        operator: "GreaterThanEqual",
+        valueNumber: args.filters.trust_min
+      });
+    }
+    if (args.filters?.date_from) {
+      whereFilters.push({
+        path: "created_at",
+        operator: "GreaterThanEqual",
+        valueDate: new Date(args.filters.date_from)
+      });
+    }
+    if (args.filters?.date_to) {
+      whereFilters.push({
+        path: "created_at",
+        operator: "LessThanEqual",
+        valueDate: new Date(args.filters.date_to)
+      });
+    }
+    const searchOptions = {
+      alpha,
+      limit: limit + offset
+      // Get extra for offset
+    };
+    if (whereFilters.length > 0) {
+      searchOptions.filters = whereFilters.length > 1 ? {
+        operator: "And",
+        operands: whereFilters
+      } : whereFilters[0];
+    }
+    const results = await collection.query.hybrid(args.query, searchOptions);
+    const paginatedResults = results.objects.slice(offset);
+    const memories = paginatedResults.map((obj) => ({
+      id: obj.uuid,
+      ...obj.properties
+    }));
+    const searchResult = {
+      memories,
+      total: memories.length,
+      offset,
+      limit
+    };
+    if (args.include_relationships) {
+      searchResult.relationships = [];
+    }
+    logger.info("Search completed", {
+      userId,
+      query: args.query,
+      results: memories.length
+    });
+    return JSON.stringify(searchResult, null, 2);
+  } catch (error) {
+    logger.error("Failed to search memories:", error);
+    throw new Error(`Failed to search memories: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+// src/tools/delete-memory.ts
+var deleteMemoryTool = {
+  name: "remember_delete_memory",
+  description: `Delete a memory from your collection.
+  
+  Optionally delete connected relationships as well.
+  This action cannot be undone.
+  
+  Examples:
+  - "Delete that old camping note"
+  - "Remove the recipe I saved yesterday"
+  `,
+  inputSchema: {
+    type: "object",
+    properties: {
+      memory_id: {
+        type: "string",
+        description: "ID of the memory to delete"
+      },
+      delete_relationships: {
+        type: "boolean",
+        description: "Also delete connected relationships. Default: false",
+        default: false
+      }
+    },
+    required: ["memory_id"]
+  }
+};
+async function handleDeleteMemory(args, userId) {
+  try {
+    logger.info("Deleting memory", { userId, memoryId: args.memory_id });
+    const collection = getMemoryCollection(userId);
+    const memory = await collection.query.fetchObjectById(args.memory_id, {
+      returnProperties: ["user_id", "doc_type", "relationships"]
+    });
+    if (!memory) {
+      throw new Error(`Memory not found: ${args.memory_id}`);
+    }
+    if (memory.properties.user_id !== userId) {
+      throw new Error("Unauthorized: Cannot delete another user's memory");
+    }
+    if (memory.properties.doc_type !== "memory") {
+      throw new Error("Cannot delete relationships using this tool. Use remember_delete_relationship instead.");
+    }
+    let relationshipsDeleted = 0;
+    if (args.delete_relationships && memory.properties.relationships) {
+      const relationshipIds = memory.properties.relationships;
+      for (const relId of relationshipIds) {
+        try {
+          await collection.data.deleteById(relId);
+          relationshipsDeleted++;
+        } catch (error) {
+          logger.warn(`Failed to delete relationship ${relId}:`, error);
+        }
+      }
+    }
+    await collection.data.deleteById(args.memory_id);
+    logger.info("Memory deleted successfully", {
+      userId,
+      memoryId: args.memory_id,
+      relationshipsDeleted
+    });
+    const result = {
+      memory_id: args.memory_id,
+      deleted: true,
+      relationships_deleted: relationshipsDeleted,
+      message: `Memory deleted successfully${relationshipsDeleted > 0 ? ` (${relationshipsDeleted} relationships also deleted)` : ""}`
+    };
+    return JSON.stringify(result, null, 2);
+  } catch (error) {
+    logger.error("Failed to delete memory:", error);
+    throw new Error(`Failed to delete memory: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+// src/server-factory.ts
+function createServer(accessToken, userId, options = {}) {
+  if (!accessToken) {
+    throw new Error("accessToken is required");
+  }
+  if (!userId) {
+    throw new Error("userId is required");
+  }
+  logger.debug("Creating server instance", { userId });
+  const server = new Server(
+    {
+      name: options.name || "remember-mcp",
+      version: options.version || "0.1.0"
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  registerHandlers(server, userId, accessToken);
+  return server;
+}
+function registerHandlers(server, userId, accessToken) {
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: [
+        {
+          name: "health_check",
+          description: "Check server health and database connections",
+          inputSchema: {
+            type: "object",
+            properties: {}
+          }
+        },
+        createMemoryTool,
+        searchMemoryTool,
+        deleteMemoryTool
+      ]
+    };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      let result;
+      switch (name) {
+        case "health_check":
+          result = await handleHealthCheck(userId);
+          break;
+        case "remember_create_memory":
+          result = await handleCreateMemory(args, userId);
+          break;
+        case "remember_search_memory":
+          result = await handleSearchMemory(args, userId);
+          break;
+        case "remember_delete_memory":
+          result = await handleDeleteMemory(args, userId);
+          break;
+        default:
+          throw new McpError(
+            ErrorCode.MethodNotFound,
+            `Unknown tool: ${name}`
+          );
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: result
+          }
+        ]
+      };
+    } catch (error) {
+      if (error instanceof McpError) {
+        throw error;
+      }
+      logger.error(`Tool execution failed for ${name}:`, error);
+      throw new McpError(
+        ErrorCode.InternalError,
+        `Tool execution failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  });
+}
+async function handleHealthCheck(userId) {
+  const health = {
+    status: "healthy",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    userId,
+    server: {
+      name: "remember-mcp",
+      version: "0.1.0"
+    },
+    databases: {
+      weaviate: {
+        connected: false,
+        userCollection: `Memory_${userId}`
+      },
+      firestore: {
+        connected: false,
+        userPath: `users/${userId}`
+      }
+    }
+  };
+  try {
+    const { getWeaviateClient: getWeaviateClient2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+    const weaviateClient = getWeaviateClient2();
+    health.databases.weaviate.connected = await weaviateClient.isReady();
+  } catch (error) {
+    logger.error("Weaviate health check failed:", error);
+    health.databases.weaviate.connected = false;
+  }
+  try {
+    const { testFirestoreConnection: testFirestoreConnection2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+    health.databases.firestore.connected = await testFirestoreConnection2();
+  } catch (error) {
+    logger.error("Firestore health check failed:", error);
+    health.databases.firestore.connected = false;
+  }
+  const allHealthy = health.databases.weaviate.connected && health.databases.firestore.connected;
+  health.status = allHealthy ? "healthy" : "degraded";
+  return JSON.stringify(health, null, 2);
+}
+export {
+  createServer
+};
+//# sourceMappingURL=server-factory.js.map