supermemory

izadoesdev · izadoesdev · commit 0cd9ce1cdf7f · 2025-12-06T22:34:32.000+02:00
diff --git a/apps/api/package.json b/apps/api/package.json
@@ -37,6 +37,7 @@
     "@opentelemetry/sdk-trace-node": "^2.2.0",
     "@opentelemetry/semantic-conventions": "^1.38.0",
     "@orpc/server": "^1.11.3",
+    "@supermemory/tools": "^1.3.13",
     "@upstash/redis": "^1.35.6",
     "ai": "^5.0.93",
     "autumn-js": "^0.1.48",
diff --git a/apps/api/src/ai/agents.ts b/apps/api/src/ai/agents.ts
@@ -2,8 +2,10 @@ import { Agent } from "@ai-sdk-tools/agents";
 import {
     extendedMemoryConfig,
     maxMemoryConfig,
+    memoryTools,
     minimalMemoryConfig,
     standardMemoryConfig,
+    withUserProfile,
 } from "./config/memory";
 import { models } from "./config/models";
 import { buildAnalyticsInstructions } from "./prompts/analytics";
@@ -20,49 +22,61 @@ const analyticsTools = {
     get_top_pages: getTopPagesTool,
     execute_sql_query: executeSqlQueryTool,
     web_search: webSearchTool,
+    ...(Object.keys(memoryTools).length > 0 ? memoryTools : {}),
 } as const;
 
 /**
- * Analytics specialist agent.
+ * Tools available to triage agent.
+ */
+const triageTools = {
+    web_search: webSearchTool,
+    ...(Object.keys(memoryTools).length > 0 ? memoryTools : {}),
+} as const;
+
+/**
+ * Creates an analytics specialist agent with user-specific memory.
  * Handles website traffic analysis, user behavior, and performance metrics.
  * Uses standard memory for typical analytical conversations.
  */
-export const analyticsAgent = new Agent({
-    name: "analytics",
-    model: models.analytics,
-    temperature: 0.3,
-    instructions: buildAnalyticsInstructions,
-    tools: analyticsTools,
-    memory: standardMemoryConfig,
-    modelSettings: {
-        failureMode: {
-            maxAttempts: 2,
+export function createAnalyticsAgent(userId: string) {
+    return new Agent({
+        name: "analytics",
+        model: withUserProfile(models.analytics, userId),
+        temperature: 0.3,
+        instructions: buildAnalyticsInstructions,
+        tools: analyticsTools,
+        memory: standardMemoryConfig,
+        modelSettings: {
+            failureMode: {
+                maxAttempts: 2,
+            },
         },
-    },
-    maxTurns: 10,
-});
+        maxTurns: 10,
+    });
+}
 
 /**
- * Reflection orchestrator agent.
+ * Creates a reflection orchestrator agent with user-specific memory.
  * Reviews responses, decides next steps, and handles complex multi-step reasoning.
  * Memory allocation scales with model capability.
  */
 export const createReflectionAgent = (
+    userId: string,
     variant: "standard" | "haiku" | "max" = "standard"
 ) => {
     const config = {
         standard: {
-            model: models.advanced,
+            model: withUserProfile(models.advanced, userId),
             maxTurns: 15,
             memory: extendedMemoryConfig, // 30 messages for Sonnet
         },
         haiku: {
-            model: models.analytics,
+            model: withUserProfile(models.analytics, userId),
             maxTurns: 15,
             memory: standardMemoryConfig, // 20 messages for Haiku
         },
         max: {
-            model: models.advanced,
+            model: withUserProfile(models.advanced, userId),
             maxTurns: 20,
             memory: maxMemoryConfig, // 40 messages for deep investigations
         },
@@ -77,31 +91,35 @@ export const createReflectionAgent = (
                 maxAttempts: 2,
             },
         },
-        handoffs: [analyticsAgent],
+        handoffs: [createAnalyticsAgent(userId)],
         ...config,
     });
 };
 
 /**
- * Triage agent that routes user requests to the appropriate specialist.
+ * Creates a triage agent with user-specific memory.
+ * Routes user requests to the appropriate specialist.
  * This is the main entry point for all agent interactions.
  * Uses minimal memory since it only routes and doesn't need long context.
  */
-export const triageAgent = new Agent({
-    name: "triage",
-    model: models.triage,
-    temperature: 0.1,
-    instructions: buildTriageInstructions,
-    memory: minimalMemoryConfig,
-    modelSettings: {
-        toolChoice: {
-            type: "tool",
-            toolName: "handoff_to_agent",
-        },
-        failureMode: {
-            maxAttempts: 2,
+export function createTriageAgent(userId: string) {
+    return new Agent({
+        name: "triage",
+        model: withUserProfile(models.triage, userId),
+        temperature: 0.1,
+        instructions: buildTriageInstructions,
+        tools: triageTools,
+        memory: minimalMemoryConfig,
+        modelSettings: {
+            toolChoice: {
+                type: "tool",
+                toolName: "handoff_to_agent",
+            },
+            failureMode: {
+                maxAttempts: 2,
+            },
         },
-    },
-    handoffs: [analyticsAgent],
-    maxTurns: 1,
-});
+        handoffs: [createAnalyticsAgent(userId)],
+        maxTurns: 1,
+    });
+}
diff --git a/apps/api/src/ai/config/memory.ts b/apps/api/src/ai/config/memory.ts
@@ -1,5 +1,6 @@
 import { RedisProvider } from "@ai-sdk-tools/memory/redis";
 import { redis } from "@databuddy/redis";
+import { supermemoryTools, withSupermemory } from "@supermemory/tools/ai-sdk";
 import type { RedisClientType } from "redis";
 
 /**
@@ -51,6 +52,27 @@ export const maxMemoryConfig = {
 	},
 } as const;
 
-/** @deprecated Use specific memory configs instead */
-export const defaultMemoryConfig = standardMemoryConfig;
+/**
+ * Supermemory configuration for enhanced memory management.
+ * User Profiles: Automatic personalization with user context
+ * Memory Tools: Agent-based memory operations (search, add, fetch)
+ * Enhanced Analytics: Agents can remember user preferences and analysis patterns
+ */
+export const supermemoryApiKey = process.env.SUPERMEMORY_API_KEY;
 
+/**
+ * Supermemory tools for agent-based memory operations.
+ * Includes search_memory, add_memory, and other memory management tools.
+ */
+export const memoryTools = supermemoryApiKey ? supermemoryTools(supermemoryApiKey) : {};
+
+/**
+ * Wraps a model with user profile context for personalization.
+ * Automatically injects user-specific context into every LLM call.
+ */
+export function withUserProfile(model: any, userId: string) {
+	if (!supermemoryApiKey) {
+		return model;
+	}
+	return withSupermemory(model, userId);
+}
diff --git a/apps/api/src/ai/prompts/analytics.ts b/apps/api/src/ai/prompts/analytics.ts
@@ -18,8 +18,10 @@ const ANALYTICS_RULES = `<agent-specific-rules>
 **Tools Usage:**
 - Use get_top_pages for page analytics
 - Use execute_sql_query for custom analytics queries
+- Use memory tools (search_memory, add_memory) to remember user preferences and past analysis patterns
 - CRITICAL: execute_sql_query must ONLY use SELECT/WITH and parameter placeholders (e.g., {limit:UInt32}) with values passed via params. websiteId is automatically included. Never interpolate strings.
 - Example: execute_sql_query({ websiteId: "<use website_id from context>", sql: "SELECT ... WHERE client_id = {websiteId:String}", params: { limit: 10 } })
+- Example memory: search_memory({ query: "user's preferred metrics" })
 
 **Insights & Recommendations:**
 - Provide 2-3 actionable recommendations based on findings
diff --git a/apps/api/src/routes/agent.ts b/apps/api/src/routes/agent.ts
@@ -1,7 +1,7 @@
 import { auth, websitesApi } from "@databuddy/auth";
 import { smoothStream } from "ai";
 import { Elysia, t } from "elysia";
-import { createReflectionAgent, triageAgent } from "../ai/agents";
+import { createReflectionAgent, createTriageAgent } from "../ai/agents";
 import { buildAppContext } from "../ai/config/context";
 import { record, setAttributes } from "../lib/tracing";
 import { validateWebsite } from "../lib/website-utils";
@@ -146,24 +146,31 @@ export const agent = new Elysia({ prefix: "/v1/agent" })
                     let maxRounds = 5;
                     let maxSteps = 20;
 
+                    if (!user?.id) {
+                        return new Response(JSON.stringify({ error: "User ID required" }), {
+                            status: 401,
+                            headers: { "Content-Type": "application/json" },
+                        });
+                    }
+
                     switch (modelType) {
                         case "basic":
-                            agent = triageAgent;
+                            agent = createTriageAgent(user.id);
                             maxRounds = 1;
                             maxSteps = 5;
                             break;
                         case "agent":
-                            agent = createReflectionAgent("haiku");
+                            agent = createReflectionAgent(user.id, "haiku");
                             maxRounds = 5;
                             maxSteps = 20;
                             break;
                         case "agent-max":
-                            agent = createReflectionAgent("max");
+                            agent = createReflectionAgent(user.id, "max");
                             maxRounds = 10;
                             maxSteps = 40;
                             break;
                         default:
-                            agent = createReflectionAgent("haiku");
+                            agent = createReflectionAgent(user.id, "haiku");
                     }
 
                     return agent.toUIMessageStream({
diff --git a/bun.lock b/bun.lock
