@prmichaelsen/remember-mcp 0.1.0 → 0.2.1

package/dist/server-factory.js

@@ -630,6 +630,10 @@ var logger = {
   }
 };
 
+// src/server-factory.ts
+init_client();
+init_init();
+
 // src/weaviate/schema.ts
 init_client();
 import weaviate2 from "weaviate-client";
@@ -1612,63 +1616,1165 @@ async function handleDeleteMemory(args, userId) {
   }
 }
 
-// src/server-factory.ts
-function createServer(accessToken, userId, options = {}) {
-  if (!accessToken) {
-    throw new Error("accessToken is required");
+// src/tools/update-memory.ts
+var updateMemoryTool = {
+  name: "remember_update_memory",
+  description: `Update an existing memory with partial updates.
+  
+  Supports updating any field except id, user_id, doc_type, created_at.
+  Version number is automatically incremented and updated_at is set.
+  Only provided fields are updated (partial updates supported).
+  
+  Examples:
+  - "Update that camping note to add more details"
+  - "Change the weight of my recipe memory"
+  - "Add tags to the meeting note from yesterday"
+  `,
+  inputSchema: {
+    type: "object",
+    properties: {
+      memory_id: {
+        type: "string",
+        description: "ID of the memory to update"
+      },
+      content: {
+        type: "string",
+        description: "Updated memory content"
+      },
+      title: {
+        type: "string",
+        description: "Updated title"
+      },
+      type: {
+        type: "string",
+        description: "Updated content type"
+      },
+      weight: {
+        type: "number",
+        description: "Updated significance/priority (0-1)",
+        minimum: 0,
+        maximum: 1
+      },
+      trust: {
+        type: "number",
+        description: "Updated access control level (0-1)",
+        minimum: 0,
+        maximum: 1
+      },
+      tags: {
+        type: "array",
+        items: { type: "string" },
+        description: "Updated tags (replaces existing tags)"
+      },
+      references: {
+        type: "array",
+        items: { type: "string" },
+        description: "Updated source URLs (replaces existing references)"
+      },
+      structured_content: {
+        type: "object",
+        description: "Updated structured content"
+      }
+    },
+    required: ["memory_id"]
   }
-  if (!userId) {
-    throw new Error("userId is required");
+};
+async function handleUpdateMemory(args, userId) {
+  try {
+    logger.info("Updating memory", { userId, memoryId: args.memory_id });
+    const collection = getMemoryCollection(userId);
+    const existingMemory = await collection.query.fetchObjectById(args.memory_id, {
+      returnProperties: ["user_id", "doc_type", "version", "type", "weight", "base_weight"]
+    });
+    if (!existingMemory) {
+      throw new Error(`Memory not found: ${args.memory_id}`);
+    }
+    if (existingMemory.properties.user_id !== userId) {
+      throw new Error("Unauthorized: Cannot update another user's memory");
+    }
+    if (existingMemory.properties.doc_type !== "memory") {
+      throw new Error("Cannot update relationships using this tool. Use remember_update_relationship instead.");
+    }
+    const updates = {};
+    const updatedFields = [];
+    if (args.content !== void 0) {
+      updates.content = args.content;
+      updatedFields.push("content");
+    }
+    if (args.title !== void 0) {
+      updates.title = args.title;
+      updates.summary = args.title;
+      updatedFields.push("title");
+    }
+    if (args.type !== void 0) {
+      if (!isValidContentType(args.type)) {
+        throw new Error(`Invalid content type: ${args.type}`);
+      }
+      updates.type = args.type;
+      updatedFields.push("type");
+    }
+    if (args.weight !== void 0) {
+      if (args.weight < 0 || args.weight > 1) {
+        throw new Error("Weight must be between 0 and 1");
+      }
+      updates.weight = args.weight;
+      updates.base_weight = args.weight;
+      updates.computed_weight = args.weight;
+      updatedFields.push("weight");
+    }
+    if (args.trust !== void 0) {
+      if (args.trust < 0 || args.trust > 1) {
+        throw new Error("Trust must be between 0 and 1");
+      }
+      updates.trust = args.trust;
+      updatedFields.push("trust");
+    }
+    if (args.tags !== void 0) {
+      updates.tags = args.tags;
+      updatedFields.push("tags");
+    }
+    if (args.references !== void 0) {
+      updates.references = args.references;
+      updatedFields.push("references");
+    }
+    if (args.structured_content !== void 0) {
+      updates.structured_content = args.structured_content;
+      updatedFields.push("structured_content");
+    }
+    if (updatedFields.length === 0) {
+      throw new Error("No fields provided for update. At least one field must be specified.");
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    updates.updated_at = now;
+    updates.version = existingMemory.properties.version + 1;
+    await collection.data.update({
+      id: args.memory_id,
+      properties: updates
+    });
+    logger.info("Memory updated successfully", {
+      userId,
+      memoryId: args.memory_id,
+      version: updates.version,
+      updatedFields
+    });
+    const result = {
+      memory_id: args.memory_id,
+      updated_at: now,
+      version: updates.version,
+      updated_fields: updatedFields,
+      message: `Memory updated successfully. Updated fields: ${updatedFields.join(", ")}`
+    };
+    return JSON.stringify(result, null, 2);
+  } catch (error) {
+    logger.error("Failed to update memory:", error);
+    throw new Error(`Failed to update memory: ${error instanceof Error ? error.message : String(error)}`);
   }
-  logger.debug("Creating server instance", { userId });
-  const server = new Server(
-    {
-      name: options.name || "remember-mcp",
-      version: options.version || "0.1.0"
-    },
-    {
-      capabilities: {
-        tools: {}
+}
+
+// src/tools/find-similar.ts
+var findSimilarTool = {
+  name: "remember_find_similar",
+  description: `Find memories similar to a given memory or text using vector similarity.
+  
+  Uses pure semantic similarity (vector distance) to find related memories.
+  This is different from hybrid search - it finds memories with similar meaning,
+  even if they don't share keywords.
+  
+  Examples:
+  - "Find memories similar to this camping trip note"
+  - "Show me memories related to this recipe"
+  - "What other memories are like this meeting note?"
+  `,
+  inputSchema: {
+    type: "object",
+    properties: {
+      memory_id: {
+        type: "string",
+        description: "ID of memory to find similar memories for (provide either memory_id or text)"
+      },
+      text: {
+        type: "string",
+        description: "Text to find similar memories for (provide either memory_id or text)"
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of results. Default: 10",
+        minimum: 1,
+        maximum: 100,
+        default: 10
+      },
+      min_similarity: {
+        type: "number",
+        description: "Minimum similarity score (0-1). Default: 0.7",
+        minimum: 0,
+        maximum: 1,
+        default: 0.7
+      },
+      include_relationships: {
+        type: "boolean",
+        description: "Include relationships in results. Default: false",
+        default: false
       }
     }
-  );
-  registerHandlers(server, userId, accessToken);
-  return server;
+  }
+};
+async function handleFindSimilar(args, userId) {
+  try {
+    logger.info("Finding similar memories", { userId, memoryId: args.memory_id, hasText: !!args.text });
+    if (!args.memory_id && !args.text) {
+      throw new Error("Either memory_id or text must be provided");
+    }
+    if (args.memory_id && args.text) {
+      throw new Error("Provide either memory_id or text, not both");
+    }
+    const collection = getMemoryCollection(userId);
+    const limit = args.limit ?? 10;
+    const minSimilarity = args.min_similarity ?? 0.7;
+    let results;
+    if (args.memory_id) {
+      const memory = await collection.query.fetchObjectById(args.memory_id, {
+        returnProperties: ["user_id", "doc_type", "content"]
+      });
+      if (!memory) {
+        throw new Error(`Memory not found: ${args.memory_id}`);
+      }
+      if (memory.properties.user_id !== userId) {
+        throw new Error("Unauthorized: Cannot access another user's memory");
+      }
+      if (memory.properties.doc_type !== "memory") {
+        throw new Error("Can only find similar memories for memory documents, not relationships");
+      }
+      results = await collection.query.nearObject(args.memory_id, {
+        limit: limit + 1,
+        // +1 to exclude the source memory itself
+        distance: 1 - minSimilarity,
+        // Convert similarity to distance
+        returnMetadata: ["distance"]
+      });
+      results.objects = results.objects.filter((obj) => obj.uuid !== args.memory_id);
+    } else {
+      results = await collection.query.nearText(args.text, {
+        limit,
+        distance: 1 - minSimilarity,
+        returnMetadata: ["distance"]
+      });
+    }
+    if (!args.include_relationships) {
+      results.objects = results.objects.filter(
+        (obj) => obj.properties.doc_type === "memory"
+      );
+    }
+    const similarMemories = results.objects.map((obj) => {
+      const similarity = 1 - (obj.metadata?.distance ?? 0);
+      return {
+        id: obj.uuid,
+        ...obj.properties,
+        similarity: Math.max(0, Math.min(1, similarity))
+        // Clamp to [0, 1]
+      };
+    });
+    similarMemories.sort((a, b) => (b.similarity ?? 0) - (a.similarity ?? 0));
+    const limitedResults = similarMemories.slice(0, limit);
+    logger.info("Similar memories found", {
+      userId,
+      query: args.memory_id || args.text,
+      results: limitedResults.length
+    });
+    const result = {
+      query: {
+        memory_id: args.memory_id,
+        text: args.text
+      },
+      similar_memories: limitedResults,
+      total: limitedResults.length,
+      min_similarity: minSimilarity
+    };
+    return JSON.stringify(result, null, 2);
+  } catch (error) {
+    logger.error("Failed to find similar memories:", error);
+    throw new Error(`Failed to find similar memories: ${error instanceof Error ? error.message : String(error)}`);
+  }
 }
-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: {}
+
+// src/tools/query-memory.ts
+var queryMemoryTool = {
+  name: "remember_query_memory",
+  description: `Query memories using natural language for RAG (Retrieval-Augmented Generation).
+  
+  This tool is optimized for LLM context retrieval. It returns relevant memories
+  with their full content and context, formatted for easy consumption by LLMs.
+  
+  Use this when you need to:
+  - Answer questions based on stored memories
+  - Provide context for conversations
+  - Retrieve information for decision-making
+  - Build responses using past knowledge
+  
+  Examples:
+  - "What do I know about camping?"
+  - "Tell me about the recipes I've saved"
+  - "What meetings did I have last week?"
+  - "What are my project goals?"
+  `,
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "Natural language query"
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of memories to retrieve. Default: 5",
+        minimum: 1,
+        maximum: 50,
+        default: 5
+      },
+      min_relevance: {
+        type: "number",
+        description: "Minimum relevance score (0-1). Default: 0.6",
+        minimum: 0,
+        maximum: 1,
+        default: 0.6
+      },
+      filters: {
+        type: "object",
+        description: "Optional filters to narrow results",
+        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)"
           }
-        },
-        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);
+        }
+      },
+      include_context: {
+        type: "boolean",
+        description: "Include full context metadata. Default: true",
+        default: true
+      },
+      format: {
+        type: "string",
+        description: 'Output format: "detailed" (full objects) or "compact" (text summary). Default: detailed',
+        enum: ["detailed", "compact"],
+        default: "detailed"
+      }
+    },
+    required: ["query"]
+  }
+};
+async function handleQueryMemory(args, userId) {
+  try {
+    logger.info("Querying memories", { userId, query: args.query });
+    const collection = getMemoryCollection(userId);
+    const limit = args.limit ?? 5;
+    const minRelevance = args.min_relevance ?? 0.6;
+    const includeContext = args.include_context ?? true;
+    const format = args.format ?? "detailed";
+    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 = {
+      limit,
+      distance: 1 - minRelevance,
+      // Convert relevance to distance
+      returnMetadata: ["distance"]
+    };
+    if (whereFilters.length > 0) {
+      searchOptions.filters = whereFilters.length > 1 ? {
+        operator: "And",
+        operands: whereFilters
+      } : whereFilters[0];
+    }
+    const results = await collection.query.nearText(args.query, searchOptions);
+    const relevantMemories = results.objects.map((obj) => {
+      const relevance = 1 - (obj.metadata?.distance ?? 0);
+      const memory = {
+        id: obj.uuid,
+        ...obj.properties,
+        relevance: Math.max(0, Math.min(1, relevance))
+        // Clamp to [0, 1]
+      };
+      if (!includeContext) {
+        delete memory.context;
+        delete memory.location;
+      }
+      return memory;
+    });
+    relevantMemories.sort((a, b) => (b.relevance ?? 0) - (a.relevance ?? 0));
+    logger.info("Query completed", {
+      userId,
+      query: args.query,
+      results: relevantMemories.length
+    });
+    let formattedMemories;
+    let contextSummary;
+    if (format === "compact") {
+      const summaryParts = relevantMemories.map((mem, idx) => {
+        const title = mem.title ? `"${mem.title}"` : `Memory ${idx + 1}`;
+        const type = mem.type ? ` [${mem.type}]` : "";
+        const relevancePercent = Math.round((mem.relevance ?? 0) * 100);
+        const content = mem.content || "(no content)";
+        const tags = mem.tags && mem.tags.length > 0 ? `
+Tags: ${mem.tags.join(", ")}` : "";
+        return `${idx + 1}. ${title}${type} (${relevancePercent}% relevant)
+${content}${tags}`;
+      });
+      formattedMemories = summaryParts.join("\n\n---\n\n");
+      contextSummary = `Found ${relevantMemories.length} relevant memories for query: "${args.query}"`;
+    } else {
+      formattedMemories = relevantMemories;
+      contextSummary = `Retrieved ${relevantMemories.length} memories with relevance >= ${Math.round(minRelevance * 100)}%`;
+    }
+    const result = {
+      query: args.query,
+      memories: formattedMemories,
+      total: relevantMemories.length,
+      min_relevance: minRelevance,
+      context_summary: contextSummary
+    };
+    return JSON.stringify(result, null, 2);
+  } catch (error) {
+    logger.error("Failed to query memories:", error);
+    throw new Error(`Failed to query memories: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+// src/tools/create-relationship.ts
+var createRelationshipTool = {
+  name: "remember_create_relationship",
+  description: `Create a relationship connecting 2 or more memories.
+  
+  Relationships describe how memories are connected with free-form types.
+  Each relationship has an observation (description), strength, and confidence.
+  Bidirectional: connected memories are automatically updated with the relationship ID.
+  
+  Examples:
+  - "The Yosemite trip inspired my Sequoia planning"
+  - "My tent purchase was caused by the camping trip"
+  - "This recipe contradicts my previous cooking notes"
+  `,
+  inputSchema: {
+    type: "object",
+    properties: {
+      memory_ids: {
+        type: "array",
+        items: { type: "string" },
+        description: "Array of 2 or more memory IDs to connect",
+        minItems: 2
+      },
+      relationship_type: {
+        type: "string",
+        description: 'Type of relationship (free-form): "inspired_by", "contradicts", "caused_by", "related_to", etc.'
+      },
+      observation: {
+        type: "string",
+        description: "Description of the connection (will be vectorized for semantic search)"
+      },
+      strength: {
+        type: "number",
+        description: "Strength of the relationship (0-1, default: 0.5)",
+        minimum: 0,
+        maximum: 1
+      },
+      confidence: {
+        type: "number",
+        description: "Confidence in this relationship (0-1, default: 0.8)",
+        minimum: 0,
+        maximum: 1
+      },
+      tags: {
+        type: "array",
+        items: { type: "string" },
+        description: "Tags for organization"
+      }
+    },
+    required: ["memory_ids", "relationship_type", "observation"]
+  }
+};
+async function handleCreateRelationship(args, userId, context) {
+  try {
+    logger.info("Creating relationship", {
+      userId,
+      type: args.relationship_type,
+      memoryCount: args.memory_ids.length
+    });
+    if (args.memory_ids.length < 2) {
+      throw new Error("At least 2 memory IDs are required to create a relationship");
+    }
+    await ensureMemoryCollection(userId);
+    const collection = getMemoryCollection(userId);
+    const memoryChecks = await Promise.all(
+      args.memory_ids.map(async (memoryId) => {
+        try {
+          const memory = await collection.query.fetchObjectById(memoryId, {
+            returnProperties: ["user_id", "doc_type", "relationships"]
+          });
+          if (!memory) {
+            return { memoryId, error: "Memory not found" };
+          }
+          if (memory.properties.user_id !== userId) {
+            return { memoryId, error: "Unauthorized: Memory belongs to another user" };
+          }
+          if (memory.properties.doc_type !== "memory") {
+            return { memoryId, error: "Cannot create relationship with non-memory document" };
+          }
+          return {
+            memoryId,
+            memory,
+            relationships: memory.properties.relationships || []
+          };
+        } catch (error) {
+          return { memoryId, error: `Failed to fetch memory: ${error}` };
+        }
+      })
+    );
+    const errors = memoryChecks.filter((check) => check.error);
+    if (errors.length > 0) {
+      const errorMessages = errors.map((e) => `${e.memoryId}: ${e.error}`).join("; ");
+      throw new Error(`Memory validation failed: ${errorMessages}`);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const relationship = {
+      // Core identity
+      user_id: userId,
+      doc_type: "relationship",
+      // Connection
+      memory_ids: args.memory_ids,
+      relationship_type: args.relationship_type,
+      // Observation
+      observation: args.observation,
+      strength: args.strength ?? 0.5,
+      confidence: args.confidence ?? 0.8,
+      // Context
+      context: {
+        timestamp: now,
+        source: {
+          type: "api",
+          platform: "mcp"
+        },
+        summary: context?.summary || "Relationship created via MCP",
+        conversation_id: context?.conversation_id,
+        ...context
+      },
+      // Metadata
+      created_at: now,
+      updated_at: now,
+      version: 1,
+      tags: args.tags || []
+    };
+    const relationshipId = await collection.data.insert(relationship);
+    logger.info("Relationship created, updating connected memories", {
+      relationshipId,
+      userId
+    });
+    const updatePromises = memoryChecks.filter((check) => !check.error && check.memory).map(async (check) => {
+      try {
+        const existingRelationships = check.relationships || [];
+        const updatedRelationships = [...existingRelationships, relationshipId];
+        await collection.data.update({
+          id: check.memoryId,
+          properties: {
+            relationships: updatedRelationships,
+            updated_at: now
+          }
+        });
+        return { memoryId: check.memoryId, success: true };
+      } catch (error) {
+        logger.warn(`Failed to update memory ${check.memoryId} with relationship:`, error);
+        return { memoryId: check.memoryId, success: false, error };
+      }
+    });
+    const updateResults = await Promise.all(updatePromises);
+    const failedUpdates = updateResults.filter((r) => !r.success);
+    if (failedUpdates.length > 0) {
+      logger.warn("Some memory updates failed", { failedUpdates });
+    }
+    logger.info("Relationship created successfully", {
+      relationshipId,
+      userId,
+      updatedMemories: updateResults.filter((r) => r.success).length
+    });
+    const response = {
+      relationship_id: relationshipId,
+      memory_ids: args.memory_ids,
+      relationship_type: args.relationship_type,
+      created_at: now,
+      message: `Relationship created successfully with ID: ${relationshipId}. Connected ${args.memory_ids.length} memories.`
+    };
+    return JSON.stringify(response, null, 2);
+  } catch (error) {
+    logger.error("Failed to create relationship:", error);
+    throw new Error(`Failed to create relationship: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+// src/tools/update-relationship.ts
+var updateRelationshipTool = {
+  name: "remember_update_relationship",
+  description: `Update an existing relationship with partial updates.
+  
+  Supports updating relationship_type, observation, strength, confidence, and tags.
+  Version number is automatically incremented and updated_at is set.
+  Only provided fields are updated (partial updates supported).
+  
+  Examples:
+  - "Update that relationship to increase the strength"
+  - "Change the observation text for the camping relationship"
+  - "Add tags to the inspiration relationship"
+  `,
+  inputSchema: {
+    type: "object",
+    properties: {
+      relationship_id: {
+        type: "string",
+        description: "ID of the relationship to update"
+      },
+      relationship_type: {
+        type: "string",
+        description: "Updated relationship type"
+      },
+      observation: {
+        type: "string",
+        description: "Updated observation/description"
+      },
+      strength: {
+        type: "number",
+        description: "Updated strength (0-1)",
+        minimum: 0,
+        maximum: 1
+      },
+      confidence: {
+        type: "number",
+        description: "Updated confidence (0-1)",
+        minimum: 0,
+        maximum: 1
+      },
+      tags: {
+        type: "array",
+        items: { type: "string" },
+        description: "Updated tags (replaces existing tags)"
+      }
+    },
+    required: ["relationship_id"]
+  }
+};
+async function handleUpdateRelationship(args, userId) {
+  try {
+    logger.info("Updating relationship", { userId, relationshipId: args.relationship_id });
+    const collection = getMemoryCollection(userId);
+    const existingRelationship = await collection.query.fetchObjectById(args.relationship_id, {
+      returnProperties: ["user_id", "doc_type", "version", "relationship_type", "strength", "confidence"]
+    });
+    if (!existingRelationship) {
+      throw new Error(`Relationship not found: ${args.relationship_id}`);
+    }
+    if (existingRelationship.properties.user_id !== userId) {
+      throw new Error("Unauthorized: Cannot update another user's relationship");
+    }
+    if (existingRelationship.properties.doc_type !== "relationship") {
+      throw new Error("Cannot update memories using this tool. Use remember_update_memory instead.");
+    }
+    const updates = {};
+    const updatedFields = [];
+    if (args.relationship_type !== void 0) {
+      updates.relationship_type = args.relationship_type;
+      updatedFields.push("relationship_type");
+    }
+    if (args.observation !== void 0) {
+      updates.observation = args.observation;
+      updatedFields.push("observation");
+    }
+    if (args.strength !== void 0) {
+      if (args.strength < 0 || args.strength > 1) {
+        throw new Error("Strength must be between 0 and 1");
+      }
+      updates.strength = args.strength;
+      updatedFields.push("strength");
+    }
+    if (args.confidence !== void 0) {
+      if (args.confidence < 0 || args.confidence > 1) {
+        throw new Error("Confidence must be between 0 and 1");
+      }
+      updates.confidence = args.confidence;
+      updatedFields.push("confidence");
+    }
+    if (args.tags !== void 0) {
+      updates.tags = args.tags;
+      updatedFields.push("tags");
+    }
+    if (updatedFields.length === 0) {
+      throw new Error("No fields provided for update. At least one field must be specified.");
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    updates.updated_at = now;
+    updates.version = existingRelationship.properties.version + 1;
+    await collection.data.update({
+      id: args.relationship_id,
+      properties: updates
+    });
+    logger.info("Relationship updated successfully", {
+      userId,
+      relationshipId: args.relationship_id,
+      version: updates.version,
+      updatedFields
+    });
+    const result = {
+      relationship_id: args.relationship_id,
+      updated_at: now,
+      version: updates.version,
+      updated_fields: updatedFields,
+      message: `Relationship updated successfully. Updated fields: ${updatedFields.join(", ")}`
+    };
+    return JSON.stringify(result, null, 2);
+  } catch (error) {
+    logger.error("Failed to update relationship:", error);
+    throw new Error(`Failed to update relationship: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+// src/tools/search-relationship.ts
+var searchRelationshipTool = {
+  name: "remember_search_relationship",
+  description: `Search relationships by observation text or relationship type.
+  
+  Uses semantic search on relationship observations to find connections.
+  Can filter by relationship type, strength, and tags.
+  Returns relationships with their connected memory IDs.
+  
+  Examples:
+  - "Find relationships about inspiration"
+  - "Search for contradicting relationships"
+  - "Show me all 'caused_by' relationships"
+  `,
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "Search query (semantic search on observation field)"
+      },
+      relationship_types: {
+        type: "array",
+        items: { type: "string" },
+        description: 'Filter by relationship types (e.g., ["inspired_by", "caused_by"])'
+      },
+      strength_min: {
+        type: "number",
+        description: "Minimum strength (0-1)",
+        minimum: 0,
+        maximum: 1
+      },
+      confidence_min: {
+        type: "number",
+        description: "Minimum confidence (0-1)",
+        minimum: 0,
+        maximum: 1
+      },
+      tags: {
+        type: "array",
+        items: { type: "string" },
+        description: "Filter by tags"
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of results (default: 10)",
+        minimum: 1,
+        maximum: 100
+      },
+      offset: {
+        type: "number",
+        description: "Offset for pagination (default: 0)",
+        minimum: 0
+      }
+    },
+    required: ["query"]
+  }
+};
+async function handleSearchRelationship(args, userId) {
+  try {
+    logger.info("Searching relationships", {
+      userId,
+      query: args.query,
+      types: args.relationship_types
+    });
+    const collection = getMemoryCollection(userId);
+    const limit = args.limit ?? 10;
+    const offset = args.offset ?? 0;
+    const whereFilters = [
+      {
+        path: "doc_type",
+        operator: "Equal",
+        valueText: "relationship"
+      }
+    ];
+    if (args.relationship_types && args.relationship_types.length > 0) {
+      if (args.relationship_types.length === 1) {
+        whereFilters.push({
+          path: "relationship_type",
+          operator: "Equal",
+          valueText: args.relationship_types[0]
+        });
+      } else {
+        whereFilters.push({
+          operator: "Or",
+          operands: args.relationship_types.map((type) => ({
+            path: "relationship_type",
+            operator: "Equal",
+            valueText: type
+          }))
+        });
+      }
+    }
+    if (args.strength_min !== void 0) {
+      whereFilters.push({
+        path: "strength",
+        operator: "GreaterThanEqual",
+        valueNumber: args.strength_min
+      });
+    }
+    if (args.confidence_min !== void 0) {
+      whereFilters.push({
+        path: "confidence",
+        operator: "GreaterThanEqual",
+        valueNumber: args.confidence_min
+      });
+    }
+    if (args.tags && args.tags.length > 0) {
+      whereFilters.push({
+        path: "tags",
+        operator: "ContainsAny",
+        valueTextArray: args.tags
+      });
+    }
+    const searchOptions = {
+      alpha: 1,
+      // Pure semantic search for relationships
+      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, offset + limit);
+    const relationships = paginatedResults.map((obj) => ({
+      id: obj.uuid,
+      user_id: obj.properties.user_id,
+      doc_type: "relationship",
+      memory_ids: obj.properties.memory_ids || [],
+      relationship_type: obj.properties.relationship_type,
+      observation: obj.properties.observation,
+      strength: obj.properties.strength,
+      confidence: obj.properties.confidence,
+      context: obj.properties.context || {
+        timestamp: obj.properties.created_at,
+        source: { type: "api", platform: "mcp" }
+      },
+      created_at: obj.properties.created_at,
+      updated_at: obj.properties.updated_at,
+      version: obj.properties.version,
+      tags: obj.properties.tags || []
+    }));
+    logger.info("Relationship search completed", {
+      userId,
+      found: relationships.length,
+      total: results.objects.length
+    });
+    const result = {
+      relationships,
+      total: results.objects.length,
+      offset,
+      limit,
+      message: `Found ${relationships.length} relationship(s) matching query "${args.query}"`
+    };
+    return JSON.stringify(result, null, 2);
+  } catch (error) {
+    logger.error("Failed to search relationships:", error);
+    throw new Error(`Failed to search relationships: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+// src/tools/delete-relationship.ts
+var deleteRelationshipTool = {
+  name: "remember_delete_relationship",
+  description: `Delete a relationship from your collection.
+  
+  Automatically removes the relationship reference from all connected memories.
+  This action cannot be undone.
+  
+  Examples:
+  - "Delete that inspiration relationship"
+  - "Remove the connection between those memories"
+  `,
+  inputSchema: {
+    type: "object",
+    properties: {
+      relationship_id: {
+        type: "string",
+        description: "ID of the relationship to delete"
+      }
+    },
+    required: ["relationship_id"]
+  }
+};
+async function handleDeleteRelationship(args, userId) {
+  try {
+    logger.info("Deleting relationship", { userId, relationshipId: args.relationship_id });
+    const collection = getMemoryCollection(userId);
+    const relationship = await collection.query.fetchObjectById(args.relationship_id, {
+      returnProperties: ["user_id", "doc_type", "memory_ids", "relationship_type"]
+    });
+    if (!relationship) {
+      throw new Error(`Relationship not found: ${args.relationship_id}`);
+    }
+    if (relationship.properties.user_id !== userId) {
+      throw new Error("Unauthorized: Cannot delete another user's relationship");
+    }
+    if (relationship.properties.doc_type !== "relationship") {
+      throw new Error("Cannot delete memories using this tool. Use remember_delete_memory instead.");
+    }
+    const memoryIds = relationship.properties.memory_ids || [];
+    let memoriesUpdated = 0;
+    if (memoryIds.length > 0) {
+      logger.info("Cleaning up relationship references from connected memories", {
+        relationshipId: args.relationship_id,
+        memoryCount: memoryIds.length
+      });
+      const updatePromises = memoryIds.map(async (memoryId) => {
+        try {
+          const memory = await collection.query.fetchObjectById(memoryId, {
+            returnProperties: ["relationships", "doc_type"]
+          });
+          if (!memory || memory.properties.doc_type !== "memory") {
+            logger.warn(`Memory ${memoryId} not found or not a memory, skipping cleanup`);
+            return { memoryId, success: false };
+          }
+          const currentRelationships = memory.properties.relationships || [];
+          const updatedRelationships = currentRelationships.filter(
+            (relId) => relId !== args.relationship_id
+          );
+          if (updatedRelationships.length !== currentRelationships.length) {
+            await collection.data.update({
+              id: memoryId,
+              properties: {
+                relationships: updatedRelationships,
+                updated_at: (/* @__PURE__ */ new Date()).toISOString()
+              }
+            });
+            return { memoryId, success: true };
+          }
+          return { memoryId, success: false };
+        } catch (error) {
+          logger.warn(`Failed to update memory ${memoryId}:`, error);
+          return { memoryId, success: false, error };
+        }
+      });
+      const updateResults = await Promise.all(updatePromises);
+      memoriesUpdated = updateResults.filter((r) => r.success).length;
+      logger.info("Memory cleanup completed", {
+        relationshipId: args.relationship_id,
+        memoriesUpdated,
+        totalMemories: memoryIds.length
+      });
+    }
+    await collection.data.deleteById(args.relationship_id);
+    logger.info("Relationship deleted successfully", {
+      userId,
+      relationshipId: args.relationship_id,
+      memoriesUpdated
+    });
+    const result = {
+      relationship_id: args.relationship_id,
+      deleted: true,
+      memories_updated: memoriesUpdated,
+      message: `Relationship deleted successfully${memoriesUpdated > 0 ? ` (${memoriesUpdated} memories updated)` : ""}`
+    };
+    return JSON.stringify(result, null, 2);
+  } catch (error) {
+    logger.error("Failed to delete relationship:", error);
+    throw new Error(`Failed to delete relationship: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+// 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");
+  }
+  if (!userId) {
+    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.2.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: {}
+          }
+        },
+        // Memory tools
+        createMemoryTool,
+        searchMemoryTool,
+        deleteMemoryTool,
+        updateMemoryTool,
+        findSimilarTool,
+        queryMemoryTool,
+        // Relationship tools
+        createRelationshipTool,
+        updateRelationshipTool,
+        searchRelationshipTool,
+        deleteRelationshipTool
+      ]
+    };
+  });
+  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;
+        case "remember_update_memory":
+          result = await handleUpdateMemory(args, userId);
+          break;
+        case "remember_find_similar":
+          result = await handleFindSimilar(args, userId);
+          break;
+        case "remember_query_memory":
+          result = await handleQueryMemory(args, userId);
+          break;
+        case "remember_create_relationship":
+          result = await handleCreateRelationship(args, userId);
+          break;
+        case "remember_update_relationship":
+          result = await handleUpdateRelationship(args, userId);
+          break;
+        case "remember_search_relationship":
+          result = await handleSearchRelationship(args, userId);
+          break;
+        case "remember_delete_relationship":
+          result = await handleDeleteRelationship(args, userId);
           break;
         default:
           throw new McpError(