Agent Memory for E-commerce Personalization

1. Purchase history (temporal + semantic)
   → Agent knows what customer owns, avoids recommending dupes, identifies gaps

2. Preference facts (keyword)
   → Agent knows favorite brands, price sensitivity, size/color preferences

3. Browsing patterns from this session (temporal)
   → Agent knows what customer is interested in RIGHT NOW, customizes recs accordingly

4. Browsing patterns from past sessions (semantic)
   → Agent identifies seasonal or category interests, predicts next purchase

import { Brain } from "brain-ai";

const memory = new Brain({
  namespace: "ecommerce",
});

// When customer lands or searches:
async function recommendProducts(customerId: string, currentAction: string) {
  // 1. Get purchase history
  const purchases = await memory.retrieve({
    agentId: `customer-${customerId}`,
    query: "What has this customer bought before?",
    topK: 10,
    filters: { type: "purchase_history" },
  });

  // 2. Get preference facts
  const preferences = await memory.retrieve({
    agentId: `customer-${customerId}`,
    query: "favorite brand price range size color preferences",
    topK: 5,
    filters: { type: "preference_fact" },
  });

  // 3. Get current session browsing
  const currentBrowsing = await memory.retrieve({
    agentId: `customer-${customerId}`,
    query: currentAction, // Semantic: what category is customer looking at now?
    topK: 5,
    filters: { type: "browsing_pattern", metadata: { session: "current" } },
  });

  // 4. Get past browsing patterns (seasonal/category trends)
  const pastPatterns = await memory.retrieve({
    agentId: `customer-${customerId}`,
    query: currentAction,
    topK: 5,
    filters: { type: "browsing_pattern", metadata: { session: "past" } },
  });

  // Build recommendation context
  const context = {
    alreadyOwns: purchases.map(p => p.productId),
    preferredBrands: preferences.find(p => p.category === "brand")?.content,
    priceRange: preferences.find(p => p.category === "price_range")?.content,
    currentInterest: currentBrowsing,
    seasonalTrends: pastPatterns,
  };

  // Agent generates personalized recommendations
  const recommendations = await recommendationEngine.generate(context);

  // Log this browsing session
  await memory.store({
    agentId: `customer-${customerId}`,
    content: `Session browsing: ${currentAction}`,
    type: "browsing_pattern",
    metadata: {
      customerId,
      timestamp: new Date().toISOString(),
      session: "current",
      action: currentAction,
      dwell_seconds: getCurrentDwellTime(),
      category: extractCategory(currentAction),
    },
  });

  return recommendations;
}

// When customer completes purchase:
async function logPurchase(customerId: string, orderId: string, items: any[]) {
  // Store purchase
  for (const item of items) {
    await memory.store({
      agentId: `customer-${customerId}`,
      content: `Purchased: ${item.name} ($${item.price})`,
      type: "purchase_history",
      metadata: {
        customerId,
        orderId,
        timestamp: new Date().toISOString(),
        productId: item.id,
        productName: item.name,
        price: item.price,
        category: item.category,
        brand: item.brand,
      },
    });
  }

  // Move session to past
  await memory.store({
    agentId: `customer-${customerId}`,
    content: "Session completed, converted",
    type: "browsing_pattern",
    metadata: {
      customerId,
      timestamp: new Date().toISOString(),
      session: "past",
      converted: true,
    },
  });
}

Customer lands on homepage, browses "winter gear"

Agent Memory Lookup:
1. Purchase history:
   - Air Jordan 1 Low (2026-04-20, $150)
   - Nike Pro shorts (2026-05-01, $60)
   - White crew socks pack (2026-03-15, $15)

2. Preference facts:
   - "Prefers Nike over Adidas"
   - "Price range: $50–$200"
   - "Size: 11 (shoes), Medium (apparel)"
   - "Colors: white, black, grey"

3. Current session:
   - Browsing: winter coats (7 min dwell time)

4. Past patterns:
   - May 2026: Browsed shorts + shoes → bought both
   - March 2026: Browsed socks + boots → bought socks only
   - January 2026: Browsed winter jackets → no purchase
   - Pattern: Customer shops by season, slow adoption of winter items

Agent Recommendation Logic:
"Customer already owns shoes (Air Jordans) and shorts. Currently browsing winter coats—high intent signal (7 min dwell). Prefers Nike. Previous winter browsing in Jan didn't convert, so don't push expensive parkas. Instead:
1. Nike winter running jacket ($120, preferred brand, in price range)
2. Thermal base layer ($40, complements running jacket, hadn't seen before)
3. Winter boots ($180, similar to March browsing when browsed but didn't buy—now shows higher intent)

Avoid: Adidas (brand preference), Expensive puffy parka ($400, outside price range), Shorts (already owns)"

Recommendations shown:
- Nike Therma-FIT Running Jacket ($120) — matches preference, price, intent
- Therma Base Layer top ($40) — complements jacket, new category
- Nike Winter Trail Boots ($180) — price point, fills gap from past interest

interface EcommerceMemory {
  agentId: string; // "customer-{customerId}"
  namespace: "ecommerce";

  // What was stored
  content: string; // The action or fact

  // How to retrieve it
  type: "purchase_history" | "preference_fact" | "browsing_pattern" | "promotion_seen";
  metadata: {
    customerId: string;
    
    // For purchase_history
    productId?: string;
    productName?: string;
    category?: string;
    brand?: string;
    price?: number; // In cents or dollars
    orderId?: string;
    
    // For preference_fact
    category?: string; // "brand", "price_range", "size", "color"
    value?: string; // "Nike", "$50-$200", "size 11"
    strength?: "strong" | "weak"; // Inferred from frequency
    
    // For browsing_pattern
    action?: string; // Category or product page
    dwell_seconds?: number; // How long customer looked
    session?: "current" | "past";
    converted?: boolean; // Did this session lead to purchase?
    
    // For promotion_seen
    promotionCode?: string;
    discountPercent?: number;
    status?: "shown" | "ignored" | "used";
    
    timestamp: string;
  };
}