@memorylayerai/vercel-ai 0.2.0

package/dist/index.js

@@ -0,0 +1,280 @@
+// 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
+import { z } from "zod";
+function memoryTool(config) {
+  return {
+    description: "Add a memory to the MemoryLayer system for long-term storage",
+    parameters: z.object({
+      content: z.string().describe("The content to remember"),
+      metadata: z.record(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: z.object({
+      query: z.string().describe("The search query to find relevant memories"),
+      limit: z.number().optional().describe("Maximum number of results to return (default: 10)"),
+      threshold: 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
+import { tool } from "ai";
+import { z as z2 } from "zod";
+function graphTool(config) {
+  return tool({
+    description: "Fetch memory graph data showing nodes (memories, documents, entities) and their relationships",
+    parameters: z2.object({
+      limit: z2.number().optional().describe("Maximum number of nodes to return (default: 100)"),
+      nodeTypes: z2.array(z2.enum(["memory", "document", "entity"])).optional().describe("Filter by node types"),
+      relationshipTypes: z2.array(z2.enum(["extends", "updates", "derives", "similarity"])).optional().describe("Filter by relationship types"),
+      startDate: z2.string().optional().describe("Filter nodes created after this date (ISO 8601)"),
+      endDate: z2.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 tool({
+    description: "Get detailed information about a specific node in the memory graph",
+    parameters: z2.object({
+      nodeId: z2.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 tool({
+    description: "Get edges and connected nodes for a specific node in the memory graph",
+    parameters: z2.object({
+      nodeId: z2.string().describe("The ID of the node to fetch edges for"),
+      edgeTypes: z2.array(z2.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)
+  };
+}
+export {
+  createGraphTools,
+  createMemoryLayerProvider,
+  graphTool,
+  memoryTool,
+  nodeDetailsTool,
+  nodeEdgesTool,
+  searchTool
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@memorylayerai/vercel-ai",
+  "version": "0.2.0",
+  "description": "Vercel AI SDK integration for MemoryLayer",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
+    "lint": "eslint src --ext .ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "memorylayer",
+    "vercel",
+    "ai-sdk",
+    "memory",
+    "ai"
+  ],
+  "author": "MemoryLayer",
+  "license": "MIT",
+  "peerDependencies": {
+    "@memorylayerai/sdk": "^0.3.1",
+    "ai": "^3.0.0",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.30",
+    "ai": "^3.4.33",
+    "fast-check": "^3.17.1",
+    "tsup": "^8.0.2",
+    "typescript": "^5.4.3",
+    "vitest": "^1.4.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}

package/src/graph.ts

@@ -0,0 +1,250 @@
+/**
+ * Graph visualization helpers for Vercel AI SDK integration
+ */
+
+import type { MemoryLayerClient, GraphNode, GraphEdge } from '@memorylayerai/sdk';
+import { tool } from 'ai';
+import { z } from 'zod';
+
+/**
+ * Configuration for graph tools
+ */
+export interface GraphToolConfig {
+  /** MemoryLayer client instance */
+  client: MemoryLayerClient;
+  /** Space/project ID for graph context */
+  spaceId: string;
+}
+
+/**
+ * Create a tool for fetching graph data
+ * 
+ * This tool allows AI models to fetch and visualize memory graph data.
+ * 
+ * @param config - Graph tool configuration
+ * @returns Vercel AI SDK compatible tool
+ * 
+ * @example
+ * ```typescript
+ * import { graphTool } from '@memorylayer/vercel-ai';
+ * import { MemoryLayerClient } from '@memorylayer/sdk';
+ * import { generateText } from 'ai';
+ * 
+ * const client = new MemoryLayerClient({
+ *   apiKey: process.env.MEMORYLAYER_API_KEY!,
+ * });
+ * 
+ * const { text } = await generateText({
+ *   model: openai('gpt-4'),
+ *   prompt: 'Show me the memory graph',
+ *   tools: {
+ *     getGraph: graphTool({ client, spaceId: 'proj_abc123' }),
+ *   },
+ * });
+ * ```
+ * 
+ * Requirements: 6.1
+ */
+export function graphTool(config: GraphToolConfig) {
+  return tool({
+    description: 'Fetch memory graph data showing nodes (memories, documents, entities) and their relationships',
+    parameters: z.object({
+      limit: z.number().optional().describe('Maximum number of nodes to return (default: 100)'),
+      nodeTypes: z.array(z.enum(['memory', 'document', 'entity'])).optional().describe('Filter by node types'),
+      relationshipTypes: z.array(z.enum(['extends', 'updates', 'derives', 'similarity'])).optional().describe('Filter by relationship types'),
+      startDate: z.string().optional().describe('Filter nodes created after this date (ISO 8601)'),
+      endDate: 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: GraphNode) => ({
+          id: n.id,
+          type: n.type,
+          label: n.label,
+          status: n.data.status,
+          createdAt: n.data.createdAt,
+        })),
+        edges: graphData.edges.map((e: GraphEdge) => ({
+          id: e.id,
+          source: e.source,
+          target: e.target,
+          type: e.type,
+          label: e.label,
+        })),
+        metadata: graphData.metadata,
+      };
+    },
+  });
+}
+
+/**
+ * Create a tool for fetching node details
+ * 
+ * This tool allows AI models to get detailed information about a specific node.
+ * 
+ * @param config - Graph tool configuration
+ * @returns Vercel AI SDK compatible tool
+ * 
+ * @example
+ * ```typescript
+ * import { nodeDetailsTool } from '@memorylayer/vercel-ai';
+ * import { MemoryLayerClient } from '@memorylayer/sdk';
+ * import { generateText } from 'ai';
+ * 
+ * const client = new MemoryLayerClient({
+ *   apiKey: process.env.MEMORYLAYER_API_KEY!,
+ * });
+ * 
+ * const { text } = await generateText({
+ *   model: openai('gpt-4'),
+ *   prompt: 'Tell me about memory node-123',
+ *   tools: {
+ *     getNodeDetails: nodeDetailsTool({ client, spaceId: 'proj_abc123' }),
+ *   },
+ * });
+ * ```
+ * 
+ * Requirements: 6.2
+ */
+export function nodeDetailsTool(config: GraphToolConfig) {
+  return tool({
+    description: 'Get detailed information about a specific node in the memory graph',
+    parameters: z.object({
+      nodeId: 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: GraphNode) => ({
+          id: n.id,
+          type: n.type,
+          label: n.label,
+        })),
+        edges: details.edges.map((e: GraphEdge) => ({
+          id: e.id,
+          source: e.source,
+          target: e.target,
+          type: e.type,
+          label: e.label,
+        })),
+      };
+    },
+  });
+}
+
+/**
+ * Create a tool for fetching node edges
+ * 
+ * This tool allows AI models to get edges connected to a specific node.
+ * 
+ * @param config - Graph tool configuration
+ * @returns Vercel AI SDK compatible tool
+ * 
+ * @example
+ * ```typescript
+ * import { nodeEdgesTool } from '@memorylayer/vercel-ai';
+ * import { MemoryLayerClient } from '@memorylayer/sdk';
+ * import { generateText } from 'ai';
+ * 
+ * const client = new MemoryLayerClient({
+ *   apiKey: process.env.MEMORYLAYER_API_KEY!,
+ * });
+ * 
+ * const { text } = await generateText({
+ *   model: openai('gpt-4'),
+ *   prompt: 'What is connected to memory node-123?',
+ *   tools: {
+ *     getNodeEdges: nodeEdgesTool({ client, spaceId: 'proj_abc123' }),
+ *   },
+ * });
+ * ```
+ * 
+ * Requirements: 6.3
+ */
+export function nodeEdgesTool(config: GraphToolConfig) {
+  return tool({
+    description: 'Get edges and connected nodes for a specific node in the memory graph',
+    parameters: z.object({
+      nodeId: z.string().describe('The ID of the node to fetch edges for'),
+      edgeTypes: z.array(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: GraphEdge) => ({
+          id: e.id,
+          source: e.source,
+          target: e.target,
+          type: e.type,
+          label: e.label,
+        })),
+        connectedNodes: result.connectedNodes.map((n: GraphNode) => ({
+          id: n.id,
+          type: n.type,
+          label: n.label,
+        })),
+      };
+    },
+  });
+}
+
+/**
+ * Create all graph tools at once
+ * 
+ * Convenience function to create all graph-related tools.
+ * 
+ * @param config - Graph tool configuration
+ * @returns Object with all graph tools
+ * 
+ * @example
+ * ```typescript
+ * import { createGraphTools } from '@memorylayer/vercel-ai';
+ * import { MemoryLayerClient } from '@memorylayer/sdk';
+ * import { generateText } from 'ai';
+ * 
+ * const client = new MemoryLayerClient({
+ *   apiKey: process.env.MEMORYLAYER_API_KEY!,
+ * });
+ * 
+ * const graphTools = createGraphTools({ client, spaceId: 'proj_abc123' });
+ * 
+ * const { text } = await generateText({
+ *   model: openai('gpt-4'),
+ *   prompt: 'Analyze my memory graph',
+ *   tools: graphTools,
+ * });
+ * ```
+ * 
+ * Requirements: 6.1, 6.2, 6.3
+ */
+export function createGraphTools(config: GraphToolConfig) {
+  return {
+    getGraph: graphTool(config),
+    getNodeDetails: nodeDetailsTool(config),
+    getNodeEdges: nodeEdgesTool(config),
+  };
+}

package/src/index.ts

@@ -0,0 +1,20 @@
+/**
+ * MemoryLayer Vercel AI SDK Integration
+ * 
+ * Provides provider adapter and tool helpers for integrating MemoryLayer
+ * with the Vercel AI SDK.
+ * 
+ * @packageDocumentation
+ */
+
+// Provider adapter
+export { createMemoryLayerProvider } from './provider.js';
+export type { MemoryLayerProviderConfig } from './provider.js';
+
+// Tool helpers
+export { memoryTool, searchTool } from './tools.js';
+export type { MemoryToolConfig } from './tools.js';
+
+// Graph tools
+export { graphTool, nodeDetailsTool, nodeEdgesTool, createGraphTools } from './graph.js';
+export type { GraphToolConfig } from './graph.js';