@prmichaelsen/remember-mcp 0.2.0 → 0.2.2

package/dist/server-factory.d.ts

@@ -13,6 +13,8 @@ export interface ServerOptions {
  * This factory function is compatible with mcp-auth wrapping pattern.
  * It creates isolated server instances with no shared state.
  *
+ * Note: Databases (Weaviate + Firestore) are initialized once globally on first call.
+ *
  * @param accessToken - User's access token (reserved for future external APIs)
  * @param userId - User identifier for scoping operations
  * @param options - Optional server configuration

package/dist/server-factory.js

@@ -410,9 +410,9 @@ var init_config = __esm({
         url: process.env.WEAVIATE_URL || "http://localhost:8080",
         apiKey: process.env.WEAVIATE_API_KEY || ""
       },
-      // OpenAI
+      // OpenAI (for embeddings)
       openai: {
-        apiKey: process.env.OPENAI_APIKEY || ""
+        apiKey: process.env.OPENAI_EMBEDDINGS_API_KEY || process.env.OPENAI_APIKEY || ""
       },
       // Firebase (using firebase-admin-sdk-v8)
       firebase: {
@@ -451,11 +451,30 @@ 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");
+  const weaviateUrl = config.weaviate.url;
+  const isLocal = weaviateUrl.includes("localhost") || weaviateUrl.includes("127.0.0.1");
+  if (isLocal) {
+    console.log("[Weaviate] Connecting to local Weaviate:", weaviateUrl);
+    const localConfig = {
+      host: weaviateUrl.replace(/^https?:\/\//, "").split(":")[0],
+      port: weaviateUrl.includes(":") ? parseInt(weaviateUrl.split(":").pop() || "8080") : 8080,
+      scheme: weaviateUrl.startsWith("https") ? "https" : "http"
+    };
+    if (config.weaviate.apiKey) {
+      localConfig.authClientSecret = new weaviate.ApiKey(config.weaviate.apiKey);
+    }
+    if (config.openai.apiKey) {
+      localConfig.headers = { "X-OpenAI-Api-Key": config.openai.apiKey };
+    }
+    client = await weaviate.connectToLocal(localConfig);
+  } else {
+    console.log("[Weaviate] Connecting to remote Weaviate:", weaviateUrl);
+    client = await weaviate.connectToWeaviateCloud(weaviateUrl, {
+      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 successfully");
   return client;
 }
 function getWeaviateClient() {
@@ -630,6 +649,10 @@ var logger = {
   }
 };
 
+// src/server-factory.ts
+init_client();
+init_init();
+
 // src/weaviate/schema.ts
 init_client();
 import weaviate2 from "weaviate-client";
@@ -2657,6 +2680,31 @@ async function handleDeleteRelationship(args, userId) {
 }
 
 // src/server-factory.ts
+var databasesInitialized = false;
+var initializationPromise = null;
+async function ensureDatabasesInitialized() {
+  if (databasesInitialized) {
+    return;
+  }
+  if (initializationPromise) {
+    return initializationPromise;
+  }
+  initializationPromise = (async () => {
+    try {
+      logger.info("Initializing databases...");
+      await initWeaviateClient();
+      initFirestore();
+      databasesInitialized = true;
+      logger.info("Databases initialized successfully");
+    } catch (error) {
+      logger.error("Database initialization failed:", error);
+      throw error;
+    } finally {
+      initializationPromise = null;
+    }
+  })();
+  return initializationPromise;
+}
 function createServer(accessToken, userId, options = {}) {
   if (!accessToken) {
     throw new Error("accessToken is required");
@@ -2665,10 +2713,13 @@ function createServer(accessToken, userId, options = {}) {
     throw new Error("userId is required");
   }
   logger.debug("Creating server instance", { userId });
+  ensureDatabasesInitialized().catch((error) => {
+    logger.error("Failed to initialize databases:", error);
+  });
   const server = new Server(
     {
       name: options.name || "remember-mcp",
-      version: options.version || "0.1.0"
+      version: options.version || "0.2.0"
     },
     {
       capabilities: {

package/dist/server.js

@@ -410,9 +410,9 @@ var config = {
     url: process.env.WEAVIATE_URL || "http://localhost:8080",
     apiKey: process.env.WEAVIATE_API_KEY || ""
   },
-  // OpenAI
+  // OpenAI (for embeddings)
   openai: {
-    apiKey: process.env.OPENAI_APIKEY || ""
+    apiKey: process.env.OPENAI_EMBEDDINGS_API_KEY || process.env.OPENAI_APIKEY || ""
   },
   // Firebase (using firebase-admin-sdk-v8)
   firebase: {
@@ -433,7 +433,7 @@ var config = {
 function validateConfig() {
   const required = [
     { key: "WEAVIATE_URL", value: config.weaviate.url },
-    { key: "OPENAI_APIKEY", value: config.openai.apiKey },
+    { key: "OPENAI_EMBEDDINGS_API_KEY", value: config.openai.apiKey },
     { key: "FIREBASE_ADMIN_SERVICE_ACCOUNT_KEY", value: config.firebase.serviceAccount },
     { key: "FIREBASE_PROJECT_ID", value: config.firebase.projectId }
   ];
@@ -453,11 +453,30 @@ 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");
+  const weaviateUrl = config.weaviate.url;
+  const isLocal = weaviateUrl.includes("localhost") || weaviateUrl.includes("127.0.0.1");
+  if (isLocal) {
+    console.log("[Weaviate] Connecting to local Weaviate:", weaviateUrl);
+    const localConfig = {
+      host: weaviateUrl.replace(/^https?:\/\//, "").split(":")[0],
+      port: weaviateUrl.includes(":") ? parseInt(weaviateUrl.split(":").pop() || "8080") : 8080,
+      scheme: weaviateUrl.startsWith("https") ? "https" : "http"
+    };
+    if (config.weaviate.apiKey) {
+      localConfig.authClientSecret = new weaviate.ApiKey(config.weaviate.apiKey);
+    }
+    if (config.openai.apiKey) {
+      localConfig.headers = { "X-OpenAI-Api-Key": config.openai.apiKey };
+    }
+    client = await weaviate.connectToLocal(localConfig);
+  } else {
+    console.log("[Weaviate] Connecting to remote Weaviate:", weaviateUrl);
+    client = await weaviate.connectToWeaviateCloud(weaviateUrl, {
+      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 successfully");
   return client;
 }
 function getWeaviateClient() {

package/dist/weaviate/client.d.ts

@@ -1,6 +1,9 @@
 import { WeaviateClient } from 'weaviate-client';
 /**
  * Initialize Weaviate client
+ *
+ * Note: connectToWeaviateCloud() works for ANY remote Weaviate (cloud or self-hosted)
+ * Only use connectToLocal() for localhost development
  */
 export declare function initWeaviateClient(): Promise<WeaviateClient>;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prmichaelsen/remember-mcp",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Multi-tenant memory system MCP server with vector search and relationships",
   "main": "dist/server.js",
   "type": "module",

package/src/config.ts

@@ -9,9 +9,9 @@ export const config = {
     apiKey: process.env.WEAVIATE_API_KEY || '',
   },
 
-  // OpenAI
+  // OpenAI (for embeddings)
   openai: {
-    apiKey: process.env.OPENAI_APIKEY || '',
+    apiKey: process.env.OPENAI_EMBEDDINGS_API_KEY || process.env.OPENAI_APIKEY || '',
   },
 
   // Firebase (using firebase-admin-sdk-v8)
@@ -39,7 +39,7 @@ export const config = {
 export function validateConfig(): void {
   const required = [
     { key: 'WEAVIATE_URL', value: config.weaviate.url },
-    { key: 'OPENAI_APIKEY', value: config.openai.apiKey },
+    { key: 'OPENAI_EMBEDDINGS_API_KEY', value: config.openai.apiKey },
     { key: 'FIREBASE_ADMIN_SERVICE_ACCOUNT_KEY', value: config.firebase.serviceAccount },
     { key: 'FIREBASE_PROJECT_ID', value: config.firebase.projectId },
   ];

package/src/server-factory.ts

@@ -11,6 +11,8 @@ import {
   McpError,
 } from '@modelcontextprotocol/sdk/types.js';
 import { logger } from './utils/logger.js';
+import { initWeaviateClient } from './weaviate/client.js';
+import { initFirestore } from './firestore/init.js';
 
 // Import memory tools
 import { createMemoryTool, handleCreateMemory } from './tools/create-memory.js';
@@ -31,24 +33,62 @@ export interface ServerOptions {
   version?: string;
 }
 
+// Global initialization flag to ensure databases are initialized once
+let databasesInitialized = false;
+let initializationPromise: Promise<void> | null = null;
+
+/**
+ * Initialize databases (called once globally)
+ */
+async function ensureDatabasesInitialized(): Promise<void> {
+  if (databasesInitialized) {
+    return;
+  }
+  
+  // If initialization is in progress, wait for it
+  if (initializationPromise) {
+    return initializationPromise;
+  }
+  
+  // Start initialization
+  initializationPromise = (async () => {
+    try {
+      logger.info('Initializing databases...');
+      await initWeaviateClient();
+      initFirestore();
+      databasesInitialized = true;
+      logger.info('Databases initialized successfully');
+    } catch (error) {
+      logger.error('Database initialization failed:', error);
+      throw error;
+    } finally {
+      initializationPromise = null;
+    }
+  })();
+  
+  return initializationPromise;
+}
+
 /**
  * Create a server instance for a specific user/tenant
- * 
+ *
  * This factory function is compatible with mcp-auth wrapping pattern.
  * It creates isolated server instances with no shared state.
- * 
+ *
+ * Note: Databases (Weaviate + Firestore) are initialized once globally on first call.
+ *
  * @param accessToken - User's access token (reserved for future external APIs)
  * @param userId - User identifier for scoping operations
  * @param options - Optional server configuration
  * @returns Configured MCP Server instance (not connected to transport)
- * 
+ *
  * @example
  * ```typescript
  * // Direct usage
  * const server = createServer('token', 'user123');
  * const transport = new StdioServerTransport();
  * await server.connect(transport);
- * 
+ *
  * // With mcp-auth
  * import { wrapServer } from '@prmichaelsen/mcp-auth';
  * const wrapped = wrapServer({
@@ -75,11 +115,18 @@ export function createServer(
   
   logger.debug('Creating server instance', { userId });
   
+  // Ensure databases are initialized (happens once globally)
+  // Note: This is synchronous to match the Server return type
+  // The actual initialization happens on first tool call
+  ensureDatabasesInitialized().catch(error => {
+    logger.error('Failed to initialize databases:', error);
+  });
+  
   // Create MCP server
   const server = new Server(
     {
       name: options.name || 'remember-mcp',
-      version: options.version || '0.1.0',
+      version: options.version || '0.2.0',
     },
     {
       capabilities: {

package/src/weaviate/client.ts

@@ -5,23 +5,56 @@ let client: WeaviateClient | null = null;
 
 /**
  * Initialize Weaviate client
+ *
+ * Note: connectToWeaviateCloud() works for ANY remote Weaviate (cloud or self-hosted)
+ * Only use connectToLocal() for localhost development
  */
 export async function initWeaviateClient(): Promise<WeaviateClient> {
   if (client) {
     return client;
   }
 
-  // Weaviate v3 client initialization
-  client = await weaviate.connectToWeaviateCloud(config.weaviate.url, {
-    authCredentials: config.weaviate.apiKey
-      ? new weaviate.ApiKey(config.weaviate.apiKey)
-      : undefined,
-    headers: config.openai.apiKey
-      ? { 'X-OpenAI-Api-Key': config.openai.apiKey }
-      : undefined,
-  });
+  const weaviateUrl = config.weaviate.url;
+  
+  // Check if this is localhost (use connectToLocal)
+  const isLocal = weaviateUrl.includes('localhost') ||
+                  weaviateUrl.includes('127.0.0.1');
+  
+  // Use appropriate connection method
+  if (isLocal) {
+    console.log('[Weaviate] Connecting to local Weaviate:', weaviateUrl);
+    // connectToLocal() for localhost only
+    const localConfig: any = {
+      host: weaviateUrl.replace(/^https?:\/\//, '').split(':')[0],
+      port: weaviateUrl.includes(':')
+        ? parseInt(weaviateUrl.split(':').pop() || '8080')
+        : 8080,
+      scheme: weaviateUrl.startsWith('https') ? 'https' : 'http',
+    };
+    
+    if (config.weaviate.apiKey) {
+      localConfig.authClientSecret = new weaviate.ApiKey(config.weaviate.apiKey);
+    }
+    
+    if (config.openai.apiKey) {
+      localConfig.headers = { 'X-OpenAI-Api-Key': config.openai.apiKey };
+    }
+    
+    client = await weaviate.connectToLocal(localConfig);
+  } else {
+    // Use connectToWeaviateCloud() for ALL remote instances (cloud or self-hosted)
+    console.log('[Weaviate] Connecting to remote Weaviate:', weaviateUrl);
+    client = await weaviate.connectToWeaviateCloud(weaviateUrl, {
+      authCredentials: config.weaviate.apiKey
+        ? new weaviate.ApiKey(config.weaviate.apiKey)
+        : undefined,
+      headers: config.openai.apiKey
+        ? { 'X-OpenAI-Api-Key': config.openai.apiKey }
+        : undefined,
+    });
+  }
 
-  console.log('[Weaviate] Client initialized');
+  console.log('[Weaviate] Client initialized successfully');
   return client;
 }