@memorylayerai/vercel-ai 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 MemoryLayer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,57 @@
+# @memorylayer/vercel-ai
+
+Vercel AI SDK integration for MemoryLayer - Add memory-augmented AI to your applications.
+
+## Installation
+
+```bash
+npm install @memorylayer/vercel-ai @memorylayer/sdk ai zod
+```
+
+## Quick Start
+
+### Provider Adapter
+
+```typescript
+import { createMemoryLayerProvider } from '@memorylayer/vercel-ai';
+import { MemoryLayerClient } from '@memorylayer/sdk';
+import { generateText } from 'ai';
+
+const client = new MemoryLayerClient({
+  apiKey: process.env.MEMORYLAYER_API_KEY!,
+});
+
+const provider = createMemoryLayerProvider({
+  client,
+  projectId: 'proj_abc123',
+});
+
+const { text } = await generateText({
+  model: provider,
+  prompt: 'What are my preferences?',
+});
+```
+
+### Memory Tools
+
+```typescript
+import { memoryTool, searchTool } from '@memorylayer/vercel-ai';
+import { generateText } from 'ai';
+
+const { text } = await generateText({
+  model: provider,
+  prompt: 'Remember that I prefer dark mode',
+  tools: {
+    addMemory: memoryTool({ client, projectId: 'proj_abc123' }),
+    searchMemory: searchTool({ client, projectId: 'proj_abc123' }),
+  },
+});
+```
+
+## Documentation
+
+For full documentation, visit [https://docs.memorylayer.com](https://docs.memorylayer.com)
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,313 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createGraphTools: () => createGraphTools,
+  createMemoryLayerProvider: () => createMemoryLayerProvider,
+  graphTool: () => graphTool,
+  memoryTool: () => memoryTool,
+  nodeDetailsTool: () => nodeDetailsTool,
+  nodeEdgesTool: () => nodeEdgesTool,
+  searchTool: () => searchTool
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/provider.ts
+function createMemoryLayerProvider(config) {
+  return {
+    specificationVersion: "v1",
+    provider: "memorylayer",
+    modelId: config.defaultModel || "default",
+    /**
+     * Generate a completion (non-streaming)
+     */
+    async doGenerate(options) {
+      const messages = options.prompt.map((msg) => ({
+        role: msg.role,
+        content: msg.content
+      }));
+      const response = await config.client.router.complete({
+        messages,
+        projectId: config.projectId,
+        model: options.model || config.defaultModel,
+        temperature: options.temperature,
+        maxTokens: options.maxTokens
+      });
+      return {
+        text: response.choices[0].message.content,
+        finishReason: response.choices[0].finishReason,
+        usage: {
+          promptTokens: response.usage.promptTokens,
+          completionTokens: response.usage.completionTokens
+        },
+        rawCall: {
+          rawPrompt: messages,
+          rawSettings: {
+            model: options.model || config.defaultModel,
+            temperature: options.temperature,
+            maxTokens: options.maxTokens
+          }
+        }
+      };
+    },
+    /**
+     * Generate a streaming completion
+     */
+    async doStream(options) {
+      const messages = options.prompt.map((msg) => ({
+        role: msg.role,
+        content: msg.content
+      }));
+      const stream = config.client.router.stream({
+        messages,
+        projectId: config.projectId,
+        model: options.model || config.defaultModel,
+        temperature: options.temperature,
+        maxTokens: options.maxTokens,
+        stream: true
+      });
+      const convertedStream = convertToVercelStream(stream);
+      return {
+        stream: convertedStream,
+        rawCall: {
+          rawPrompt: messages,
+          rawSettings: {
+            model: options.model || config.defaultModel,
+            temperature: options.temperature,
+            maxTokens: options.maxTokens
+          }
+        }
+      };
+    }
+  };
+}
+async function* convertToVercelStream(stream) {
+  try {
+    for await (const chunk of stream) {
+      yield {
+        type: "text-delta",
+        textDelta: chunk.choices[0]?.delta?.content || ""
+      };
+      if (chunk.choices[0]?.finishReason) {
+        yield {
+          type: "finish",
+          finishReason: chunk.choices[0].finishReason
+        };
+      }
+    }
+  } catch (error) {
+    throw {
+      name: "AI_APICallError",
+      message: error instanceof Error ? error.message : "Unknown error",
+      cause: error
+    };
+  }
+}
+
+// src/tools.ts
+var import_zod = require("zod");
+function memoryTool(config) {
+  return {
+    description: "Add a memory to the MemoryLayer system for long-term storage",
+    parameters: import_zod.z.object({
+      content: import_zod.z.string().describe("The content to remember"),
+      metadata: import_zod.z.record(import_zod.z.any()).optional().describe("Optional metadata to associate with the memory")
+    }),
+    execute: async ({ content, metadata }) => {
+      try {
+        const memory = await config.client.memories.add({
+          content,
+          metadata,
+          projectId: config.projectId
+        });
+        return {
+          success: true,
+          memoryId: memory.id,
+          message: `Memory stored successfully with ID: ${memory.id}`
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  };
+}
+function searchTool(config) {
+  return {
+    description: "Search memories in the MemoryLayer system to retrieve relevant information",
+    parameters: import_zod.z.object({
+      query: import_zod.z.string().describe("The search query to find relevant memories"),
+      limit: import_zod.z.number().optional().describe("Maximum number of results to return (default: 10)"),
+      threshold: import_zod.z.number().optional().describe("Minimum relevance score threshold (0-1)")
+    }),
+    execute: async ({ query, limit, threshold }) => {
+      try {
+        const response = await config.client.search.search({
+          query,
+          projectId: config.projectId,
+          limit,
+          threshold
+        });
+        return {
+          success: true,
+          results: response.results.map((r) => ({
+            content: r.memory.content,
+            score: r.score,
+            metadata: r.memory.metadata,
+            id: r.memory.id
+          })),
+          total: response.total
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  };
+}
+
+// src/graph.ts
+var import_ai = require("ai");
+var import_zod2 = require("zod");
+function graphTool(config) {
+  return (0, import_ai.tool)({
+    description: "Fetch memory graph data showing nodes (memories, documents, entities) and their relationships",
+    parameters: import_zod2.z.object({
+      limit: import_zod2.z.number().optional().describe("Maximum number of nodes to return (default: 100)"),
+      nodeTypes: import_zod2.z.array(import_zod2.z.enum(["memory", "document", "entity"])).optional().describe("Filter by node types"),
+      relationshipTypes: import_zod2.z.array(import_zod2.z.enum(["extends", "updates", "derives", "similarity"])).optional().describe("Filter by relationship types"),
+      startDate: import_zod2.z.string().optional().describe("Filter nodes created after this date (ISO 8601)"),
+      endDate: import_zod2.z.string().optional().describe("Filter nodes created before this date (ISO 8601)")
+    }),
+    execute: async ({ limit, nodeTypes, relationshipTypes, startDate, endDate }) => {
+      const graphData = await config.client.graph.getGraph({
+        spaceId: config.spaceId,
+        limit,
+        nodeTypes,
+        relationshipTypes,
+        startDate,
+        endDate
+      });
+      return {
+        nodes: graphData.nodes.map((n) => ({
+          id: n.id,
+          type: n.type,
+          label: n.label,
+          status: n.data.status,
+          createdAt: n.data.createdAt
+        })),
+        edges: graphData.edges.map((e) => ({
+          id: e.id,
+          source: e.source,
+          target: e.target,
+          type: e.type,
+          label: e.label
+        })),
+        metadata: graphData.metadata
+      };
+    }
+  });
+}
+function nodeDetailsTool(config) {
+  return (0, import_ai.tool)({
+    description: "Get detailed information about a specific node in the memory graph",
+    parameters: import_zod2.z.object({
+      nodeId: import_zod2.z.string().describe("The ID of the node to fetch details for")
+    }),
+    execute: async ({ nodeId }) => {
+      const details = await config.client.graph.getNodeDetails({ nodeId });
+      return {
+        node: {
+          id: details.node.id,
+          type: details.node.type,
+          label: details.node.label,
+          content: details.node.data.content,
+          status: details.node.data.status,
+          createdAt: details.node.data.createdAt,
+          expiresAt: details.node.data.expiresAt,
+          metadata: details.node.data.metadata
+        },
+        connectedNodes: details.connectedNodes.map((n) => ({
+          id: n.id,
+          type: n.type,
+          label: n.label
+        })),
+        edges: details.edges.map((e) => ({
+          id: e.id,
+          source: e.source,
+          target: e.target,
+          type: e.type,
+          label: e.label
+        }))
+      };
+    }
+  });
+}
+function nodeEdgesTool(config) {
+  return (0, import_ai.tool)({
+    description: "Get edges and connected nodes for a specific node in the memory graph",
+    parameters: import_zod2.z.object({
+      nodeId: import_zod2.z.string().describe("The ID of the node to fetch edges for"),
+      edgeTypes: import_zod2.z.array(import_zod2.z.enum(["extends", "updates", "derives", "similarity"])).optional().describe("Filter by edge types")
+    }),
+    execute: async ({ nodeId, edgeTypes }) => {
+      const result = await config.client.graph.getNodeEdges({
+        nodeId,
+        edgeTypes
+      });
+      return {
+        edges: result.edges.map((e) => ({
+          id: e.id,
+          source: e.source,
+          target: e.target,
+          type: e.type,
+          label: e.label
+        })),
+        connectedNodes: result.connectedNodes.map((n) => ({
+          id: n.id,
+          type: n.type,
+          label: n.label
+        }))
+      };
+    }
+  });
+}
+function createGraphTools(config) {
+  return {
+    getGraph: graphTool(config),
+    getNodeDetails: nodeDetailsTool(config),
+    getNodeEdges: nodeEdgesTool(config)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createGraphTools,
+  createMemoryLayerProvider,
+  graphTool,
+  memoryTool,
+  nodeDetailsTool,
+  nodeEdgesTool,
+  searchTool
+});