@lanonasis/mem-intel-sdk 1.0.0

package/dist/server/index.cjs

@@ -0,0 +1,802 @@
+'use strict';
+
+var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
+var zod = require('zod');
+
+// src/server/mcp-server.ts
+
+// src/core/errors.ts
+var MemoryIntelligenceError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MemoryIntelligenceError";
+  }
+};
+var ConfigurationError = class extends MemoryIntelligenceError {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigurationError";
+  }
+};
+var MemoryNotFoundError = class extends MemoryIntelligenceError {
+  constructor(memoryId) {
+    super(`Memory not found: ${memoryId}`);
+    this.name = "MemoryNotFoundError";
+  }
+};
+var DatabaseError = class extends MemoryIntelligenceError {
+  constructor(message, originalError) {
+    super(message);
+    this.originalError = originalError;
+    this.name = "DatabaseError";
+  }
+};
+var EmbeddingError = class extends MemoryIntelligenceError {
+  constructor(message, originalError) {
+    super(message);
+    this.originalError = originalError;
+    this.name = "EmbeddingError";
+  }
+};
+var ValidationError = class extends MemoryIntelligenceError {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+
+// src/utils/http-client.ts
+var HttpClient = class {
+  apiUrl;
+  apiKey;
+  timeout;
+  headers;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new ConfigurationError("API key is required");
+    }
+    if (!config.apiKey.startsWith("lano_")) {
+      throw new ConfigurationError(
+        "Invalid API key format. API key should start with 'lano_'"
+      );
+    }
+    this.apiUrl = config.apiUrl.replace(/\/$/, "");
+    this.apiKey = config.apiKey;
+    this.timeout = config.timeout || 3e4;
+    this.headers = {
+      "Content-Type": "application/json",
+      "X-API-Key": this.apiKey,
+      ...config.headers
+    };
+  }
+  async request(method, endpoint, data) {
+    const url = `${this.apiUrl}${endpoint}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const options = {
+        method,
+        headers: this.headers,
+        signal: controller.signal
+      };
+      if (data && (method === "POST" || method === "PUT" || method === "PATCH")) {
+        options.body = JSON.stringify(data);
+      }
+      const response = await fetch(url, options);
+      clearTimeout(timeoutId);
+      const responseData = await response.json();
+      if (!response.ok) {
+        return {
+          status: response.status,
+          error: {
+            message: responseData?.message || responseData?.error || "Request failed",
+            code: responseData?.code
+          }
+        };
+      }
+      return {
+        status: response.status,
+        data: responseData
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          return {
+            status: 408,
+            error: {
+              message: `Request timeout after ${this.timeout}ms`,
+              code: "TIMEOUT"
+            }
+          };
+        }
+        return {
+          status: 0,
+          error: {
+            message: error.message,
+            code: "NETWORK_ERROR"
+          }
+        };
+      }
+      return {
+        status: 0,
+        error: {
+          message: "Unknown error occurred",
+          code: "UNKNOWN_ERROR"
+        }
+      };
+    }
+  }
+  async get(endpoint) {
+    return this.request("GET", endpoint);
+  }
+  async post(endpoint, data) {
+    return this.request("POST", endpoint, data);
+  }
+  async put(endpoint, data) {
+    return this.request("PUT", endpoint, data);
+  }
+  async patch(endpoint, data) {
+    return this.request("PATCH", endpoint, data);
+  }
+  async delete(endpoint) {
+    return this.request("DELETE", endpoint);
+  }
+};
+
+// src/core/client.ts
+var DEFAULT_API_URL = "https://api.lanonasis.com/api/v1";
+var MemoryIntelligenceClient = class {
+  httpClient;
+  defaultResponseFormat;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new ConfigurationError(
+        "Missing required configuration: apiKey is required (format: lano_xxxxxxxxxx)"
+      );
+    }
+    this.httpClient = new HttpClient({
+      apiUrl: config.apiUrl || DEFAULT_API_URL,
+      apiKey: config.apiKey,
+      timeout: config.timeout,
+      headers: config.headers
+    });
+    this.defaultResponseFormat = config.responseFormat || "markdown";
+  }
+  /**
+   * Get HTTP client for direct API access
+   */
+  getHttpClient() {
+    return this.httpClient;
+  }
+  /**
+   * Query memories from the API
+   */
+  async queryMemories(userId, options = {}) {
+    const { type, limit = 100, offset = 0 } = options;
+    const params = new URLSearchParams({
+      user_id: userId,
+      limit: limit.toString(),
+      offset: offset.toString()
+    });
+    if (type) {
+      params.append("type", type);
+    }
+    const response = await this.httpClient.get(
+      `/intelligence/memories?${params.toString()}`
+    );
+    if (response.error) {
+      throw new DatabaseError(`Failed to query memories: ${response.error.message}`);
+    }
+    return response.data?.memories || [];
+  }
+  /**
+   * Analyze usage patterns and trends in memory collection
+   */
+  async analyzePatterns(params) {
+    const response = await this.httpClient.post(
+      "/intelligence/analyze-patterns",
+      {
+        ...params,
+        responseFormat: params.responseFormat || this.defaultResponseFormat
+      }
+    );
+    if (response.error) {
+      throw new DatabaseError(`Failed to analyze patterns: ${response.error.message}`);
+    }
+    return response.data;
+  }
+  /**
+   * Get AI-powered tag suggestions for a memory
+   */
+  async suggestTags(params) {
+    const response = await this.httpClient.post(
+      "/intelligence/suggest-tags",
+      {
+        ...params,
+        responseFormat: params.responseFormat || this.defaultResponseFormat
+      }
+    );
+    if (response.error) {
+      throw new DatabaseError(`Failed to suggest tags: ${response.error.message}`);
+    }
+    return response.data;
+  }
+  /**
+   * Find semantically related memories using vector similarity
+   */
+  async findRelated(params) {
+    const response = await this.httpClient.post(
+      "/intelligence/find-related",
+      {
+        ...params,
+        responseFormat: params.responseFormat || this.defaultResponseFormat
+      }
+    );
+    if (response.error) {
+      throw new DatabaseError(`Failed to find related memories: ${response.error.message}`);
+    }
+    return response.data;
+  }
+  /**
+   * Detect potential duplicate memories
+   */
+  async detectDuplicates(params) {
+    const response = await this.httpClient.post(
+      "/intelligence/detect-duplicates",
+      {
+        ...params,
+        responseFormat: params.responseFormat || this.defaultResponseFormat
+      }
+    );
+    if (response.error) {
+      throw new DatabaseError(`Failed to detect duplicates: ${response.error.message}`);
+    }
+    return response.data;
+  }
+  /**
+   * Extract insights and patterns from memories
+   */
+  async extractInsights(params) {
+    const response = await this.httpClient.post(
+      "/intelligence/extract-insights",
+      {
+        ...params,
+        responseFormat: params.responseFormat || this.defaultResponseFormat
+      }
+    );
+    if (response.error) {
+      throw new DatabaseError(`Failed to extract insights: ${response.error.message}`);
+    }
+    return response.data;
+  }
+  /**
+   * Check the health and organization quality of memories
+   */
+  async healthCheck(params) {
+    const response = await this.httpClient.post(
+      "/intelligence/health-check",
+      {
+        ...params,
+        responseFormat: params.responseFormat || this.defaultResponseFormat
+      }
+    );
+    if (response.error) {
+      throw new DatabaseError(`Failed to check health: ${response.error.message}`);
+    }
+    return response.data;
+  }
+};
+var ResponseFormat = {
+  JSON: "json",
+  MARKDOWN: "markdown"
+};
+var MemoryType = zod.z.enum([
+  "context",
+  "project",
+  "knowledge",
+  "reference",
+  "personal",
+  "workflow"
+]);
+
+// src/utils/formatting.ts
+var CHARACTER_LIMIT = 5e4;
+function formatResponse(data, format, markdownFormatter) {
+  if (format === ResponseFormat.JSON) {
+    return JSON.stringify(data, null, 2);
+  }
+  return markdownFormatter(data);
+}
+function truncateIfNeeded(text) {
+  if (text.length > CHARACTER_LIMIT) {
+    return text.substring(0, CHARACTER_LIMIT) + `
+
+... (truncated, ${text.length - CHARACTER_LIMIT} characters omitted)`;
+  }
+  return text;
+}
+
+// src/server/mcp-server.ts
+function createMCPServer(config) {
+  const client = new MemoryIntelligenceClient(config);
+  const server = new mcp_js.McpServer({
+    name: "memory-intelligence-mcp-server",
+    version: "1.0.0"
+  });
+  server.registerTool(
+    "memory_analyze_patterns",
+    {
+      title: "Analyze Memory Patterns",
+      description: `Analyze usage patterns and trends in the user's memory collection.`,
+      inputSchema: zod.z.object({
+        user_id: zod.z.string().uuid(),
+        time_range_days: zod.z.number().int().min(1).max(365).default(30),
+        response_format: zod.z.enum([ResponseFormat.JSON, ResponseFormat.MARKDOWN]).default(ResponseFormat.MARKDOWN)
+      }).strict(),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (rawParams) => {
+      try {
+        const params = {
+          userId: rawParams.user_id,
+          timeRangeDays: rawParams.time_range_days,
+          responseFormat: rawParams.response_format
+        };
+        const analysis = await client.analyzePatterns(params);
+        const responseText = formatResponse(
+          analysis,
+          params.responseFormat || "markdown",
+          (data) => {
+            let md = `# Memory Pattern Analysis
+
+`;
+            md += `**Time Range:** Last ${params.timeRangeDays || 30} days
+`;
+            md += `**Total Memories:** ${data.total_memories}
+
+`;
+            md += `## Distribution by Type
+`;
+            for (const [type, count] of Object.entries(data.memories_by_type)) {
+              const percentage = (count / data.total_memories * 100).toFixed(1);
+              md += `- **${type}**: ${count} (${percentage}%)
+`;
+            }
+            md += `
+## Activity Patterns
+`;
+            md += `- **Peak Hours (UTC):** ${data.peak_creation_hours.join(", ")}
+`;
+            md += `- **Daily Average:** ${data.creation_velocity.daily_average} memories/day
+`;
+            md += `- **Trend:** ${data.creation_velocity.trend}
+`;
+            md += `
+## Top Tags
+`;
+            for (const { tag, count } of data.most_common_tags.slice(0, 5)) {
+              md += `- **${tag}**: ${count} uses
+`;
+            }
+            md += `
+## AI Insights
+`;
+            for (const insight of data.insights) {
+              md += `${insight}
+`;
+            }
+            return md;
+          }
+        );
+        return {
+          content: [{ type: "text", text: truncateIfNeeded(responseText) }]
+        };
+      } catch (error) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "memory_suggest_tags",
+    {
+      title: "Suggest Tags for Memory",
+      description: `AI-powered tag suggestions for a memory.`,
+      inputSchema: zod.z.object({
+        memory_id: zod.z.string().uuid(),
+        user_id: zod.z.string().uuid(),
+        max_suggestions: zod.z.number().int().min(1).max(20).default(5),
+        include_existing_tags: zod.z.boolean().default(true),
+        response_format: zod.z.enum([ResponseFormat.JSON, ResponseFormat.MARKDOWN]).default(ResponseFormat.MARKDOWN)
+      }).strict(),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    async (rawParams) => {
+      try {
+        const params = {
+          memoryId: rawParams.memory_id,
+          userId: rawParams.user_id,
+          maxSuggestions: rawParams.max_suggestions,
+          includeExistingTags: rawParams.include_existing_tags,
+          responseFormat: rawParams.response_format
+        };
+        const result = await client.suggestTags(params);
+        const responseText = formatResponse(
+          result,
+          params.responseFormat || "markdown",
+          (data) => {
+            let md = `# Tag Suggestions
+
+`;
+            md += `**Existing Tags:** ${data.existing_tags.join(", ") || "none"}
+
+`;
+            md += `## Suggested Tags
+`;
+            for (const suggestion of data.suggestions) {
+              md += `
+### \`${suggestion.tag}\`
+`;
+              md += `**Confidence:** ${(suggestion.confidence * 100).toFixed(0)}%
+`;
+              md += `**Reason:** ${suggestion.reasoning}
+`;
+            }
+            return md;
+          }
+        );
+        return {
+          content: [{ type: "text", text: truncateIfNeeded(responseText) }]
+        };
+      } catch (error) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "memory_find_related",
+    {
+      title: "Find Related Memories",
+      description: `Find semantically related memories using vector similarity.`,
+      inputSchema: zod.z.object({
+        memory_id: zod.z.string().uuid(),
+        user_id: zod.z.string().uuid(),
+        limit: zod.z.number().int().min(1).max(50).default(10),
+        similarity_threshold: zod.z.number().min(0).max(1).default(0.7),
+        response_format: zod.z.enum([ResponseFormat.JSON, ResponseFormat.MARKDOWN]).default(ResponseFormat.MARKDOWN)
+      }).strict(),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (rawParams) => {
+      try {
+        const params = {
+          memoryId: rawParams.memory_id,
+          userId: rawParams.user_id,
+          limit: rawParams.limit,
+          similarityThreshold: rawParams.similarity_threshold,
+          responseFormat: rawParams.response_format
+        };
+        const result = await client.findRelated(params);
+        const responseText = formatResponse(
+          result,
+          params.responseFormat || "markdown",
+          (data) => {
+            let md = `# Related Memories
+
+`;
+            md += `**Source:** ${data.source_memory.title}
+`;
+            md += `**Found:** ${data.total_found} related memories
+
+`;
+            for (const mem of data.related_memories) {
+              md += `## ${mem.title}
+`;
+              md += `**Similarity:** ${(mem.similarity_score * 100).toFixed(1)}%
+`;
+              if (mem.shared_tags.length > 0) {
+                md += `**Shared Tags:** ${mem.shared_tags.join(", ")}
+`;
+              }
+              md += `**Preview:** ${mem.content_preview}
+
+`;
+            }
+            return md;
+          }
+        );
+        return {
+          content: [{ type: "text", text: truncateIfNeeded(responseText) }]
+        };
+      } catch (error) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "memory_detect_duplicates",
+    {
+      title: "Detect Duplicate Memories",
+      description: `Find potential duplicate memories.`,
+      inputSchema: zod.z.object({
+        user_id: zod.z.string().uuid(),
+        similarity_threshold: zod.z.number().min(0.8).max(0.99).default(0.9),
+        max_pairs: zod.z.number().int().min(1).max(100).default(20),
+        response_format: zod.z.enum([ResponseFormat.JSON, ResponseFormat.MARKDOWN]).default(ResponseFormat.MARKDOWN)
+      }).strict(),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (rawParams) => {
+      try {
+        const params = {
+          userId: rawParams.user_id,
+          similarityThreshold: rawParams.similarity_threshold,
+          maxPairs: rawParams.max_pairs,
+          responseFormat: rawParams.response_format
+        };
+        const result = await client.detectDuplicates(params);
+        const responseText = formatResponse(
+          result,
+          params.responseFormat || "markdown",
+          (data) => {
+            let md = `# Duplicate Detection
+
+`;
+            md += `**Memories Analyzed:** ${data.total_memories_analyzed}
+`;
+            md += `**Duplicate Pairs Found:** ${data.duplicate_pairs_found}
+`;
+            md += `**Storage Savings:** ${data.estimated_storage_savings}
+
+`;
+            for (const pair of data.duplicate_pairs) {
+              md += `### Similarity: ${(pair.similarity_score * 100).toFixed(1)}%
+`;
+              md += `**Memory 1:** ${pair.memory_1.title}
+`;
+              md += `**Memory 2:** ${pair.memory_2.title}
+`;
+              md += `**Recommendation:** ${pair.recommendation}
+
+`;
+            }
+            return md;
+          }
+        );
+        return {
+          content: [{ type: "text", text: truncateIfNeeded(responseText) }]
+        };
+      } catch (error) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "memory_extract_insights",
+    {
+      title: "Extract Insights from Memories",
+      description: `Extract key insights and patterns from memories.`,
+      inputSchema: zod.z.object({
+        user_id: zod.z.string().uuid(),
+        topic: zod.z.string().optional(),
+        memory_type: zod.z.string().optional(),
+        max_memories: zod.z.number().int().min(5).max(100).default(20),
+        response_format: zod.z.enum([ResponseFormat.JSON, ResponseFormat.MARKDOWN]).default(ResponseFormat.MARKDOWN)
+      }).strict(),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    async (rawParams) => {
+      try {
+        const params = {
+          userId: rawParams.user_id,
+          topic: rawParams.topic,
+          memoryType: rawParams.memory_type,
+          maxMemories: rawParams.max_memories,
+          responseFormat: rawParams.response_format
+        };
+        const result = await client.extractInsights(params);
+        const responseText = formatResponse(
+          result,
+          params.responseFormat || "markdown",
+          (data) => {
+            let md = `# Memory Insights
+
+`;
+            md += `**Memories Analyzed:** ${data.total_memories_analyzed}
+`;
+            if (data.topic_filter) {
+              md += `**Topic:** ${data.topic_filter}
+`;
+            }
+            md += `
+## Summary
+${data.summary}
+
+`;
+            md += `## Insights
+`;
+            for (const insight of data.insights) {
+              const icon = {
+                pattern: "\u{1F504}",
+                learning: "\u{1F4A1}",
+                opportunity: "\u{1F680}",
+                risk: "\u26A0\uFE0F",
+                action_item: "\u2705"
+              }[insight.category] || "\u{1F4CC}";
+              md += `
+### ${icon} ${insight.title}
+`;
+              md += `${insight.description}
+`;
+              md += `**Confidence:** ${(insight.confidence * 100).toFixed(0)}%
+`;
+            }
+            return md;
+          }
+        );
+        return {
+          content: [{ type: "text", text: truncateIfNeeded(responseText) }]
+        };
+      } catch (error) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "memory_health_check",
+    {
+      title: "Memory Health Check",
+      description: `Analyze the health and organization quality of memories.`,
+      inputSchema: zod.z.object({
+        user_id: zod.z.string().uuid(),
+        response_format: zod.z.enum([ResponseFormat.JSON, ResponseFormat.MARKDOWN]).default(ResponseFormat.MARKDOWN)
+      }).strict(),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (rawParams) => {
+      try {
+        const params = {
+          userId: rawParams.user_id,
+          responseFormat: rawParams.response_format
+        };
+        const result = await client.healthCheck(params);
+        const responseText = formatResponse(
+          result,
+          params.responseFormat || "markdown",
+          (data) => {
+            let md = `# Memory Health Check
+
+`;
+            md += `**Health Score:** ${data.health_score}/100
+
+`;
+            md += `## Metrics
+`;
+            md += `- **Total Memories:** ${data.metrics.total_memories}
+`;
+            md += `- **Embedding Coverage:** ${data.metrics.embedding_coverage_percentage}%
+`;
+            md += `- **Tagging Rate:** ${data.metrics.tagging_percentage}%
+`;
+            md += `- **Avg Tags/Memory:** ${data.metrics.average_tags_per_memory}
+
+`;
+            if (data.issues.length > 0) {
+              md += `## Issues
+`;
+              for (const issue of data.issues) {
+                md += `- ${issue}
+`;
+              }
+              md += `
+`;
+            }
+            md += `## Recommendations
+`;
+            for (const rec of data.recommendations) {
+              md += `- ${rec}
+`;
+            }
+            return md;
+          }
+        );
+        return {
+          content: [{ type: "text", text: truncateIfNeeded(responseText) }]
+        };
+      } catch (error) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  return server;
+}
+
+exports.ConfigurationError = ConfigurationError;
+exports.DatabaseError = DatabaseError;
+exports.EmbeddingError = EmbeddingError;
+exports.MemoryIntelligenceError = MemoryIntelligenceError;
+exports.MemoryNotFoundError = MemoryNotFoundError;
+exports.MemoryType = MemoryType;
+exports.ResponseFormat = ResponseFormat;
+exports.ValidationError = ValidationError;
+exports.createMCPServer = createMCPServer;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map