personalization-engine（个性化引擎）

Personalization Engine

Overview

Personalized product recommendations increase average order value and session depth by surfacing the most relevant products for each customer. "Frequently Bought Together", "You Might Also Like", and personalized homepage sections are all forms of recommendation. Every major platform has apps that handle collaborative filtering and recommendation algorithms without custom code. Only build a custom recommendation engine if your catalog size, traffic volume, or recommendation logic exceeds what app-based solutions support.

When to Use This Skill

• When adding "Frequently Bought Together" or "You Might Also Like" carousels to product pages
• When implementing a personalized homepage for returning customers
• When building a recommendation API for a mobile app or headless storefront
• When cold-start recommendations (no history) are returning irrelevant products
• When A/B testing the impact of personalization on AOV and revenue per session

Core Instructions

Step 1: Determine platform and choose the right recommendation tool

Step 2: Platform-specific setup

Shopify

Option A: LimeSpot (recommended — full personalization suite)

1. Install LimeSpot Personalizer from the Shopify App Store
2. LimeSpot automatically analyzes your order history and browsing data to build recommendation models
3. Configure placement for recommendation widgets:

- Go to LimeSpot → Recommendations → Configure placements - Enable: PDP ("Frequently Bought Together"), Cart ("Customers also bought"), Homepage ("Recommended for you")

1. Choose the recommendation algorithm per placement:

- Frequently Bought Together: item-item collaborative filtering (based on order co-occurrence) - Recommended for You: user-item collaborative filtering (based on browsing history) - Similar Products: content-based filtering (same category, similar price, similar attributes)

1. Configure exclusions: always exclude out-of-stock items, recently purchased items

Option B: Frequently Bought Together by Code Black Belt (PDP-focused)

1. Install from the App Store
2. The app analyzes your past orders and automatically identifies which products are most often purchased together
3. Displays a "Frequently Bought Together" section on the PDP with a bundle discount option
4. No manual configuration required — the model refreshes automatically from order data

Testing and measuring:

• In LimeSpot: go to Analytics → A/B Tests to compare recommendation algorithms
• Track click-through rate and add-to-cart rate per recommendation slot
• Run each test for at least 2 weeks with sufficient traffic before concluding

WooCommerce

YITH WooCommerce Frequently Bought Together (free/premium):

1. Install from the WordPress plugin directory
2. Go to YITH → Frequently Bought Together → Settings
3. Choose recommendation method: automatic (from order history) or manual (specify products per item)
4. Configure the display (position on PDP, number of products to show, discount type if any)
5. The free version supports manual product assignment; the premium version uses order history to generate automatic suggestions

LimeSpot for WooCommerce:

1. Install LimeSpot Personalizer for WooCommerce
2. Configuration is the same as the Shopify version — provides full homepage, PDP, and cart recommendations

WooCommerce built-in cross-sells and upsells:

• On any product, go to Linked Products tab
• Manually add upsell products (shown on PDP) and cross-sell products (shown in cart)
• This is manual but effective for small catalogs where you know the relationships well

BigCommerce

LimeSpot for BigCommerce:

1. Install from the BigCommerce App Marketplace
2. Same configuration and capabilities as the Shopify/WooCommerce version

Boost AI Search & Discovery:

1. Install from the App Marketplace
2. Includes recommendation widgets alongside search features
3. Configure "Frequently Bought Together" and "Similar Products" sections

Custom / Headless

For headless storefronts, build a recommendation pipeline with pre-computed similarity matrices for fast responses:

// lib/recommendations.ts

// Step 1: Pre-compute co-purchase matrix nightly (run as a cron job)
// PostgreSQL: count how often each product pair appears in the same order
export const coPurchaseMatrixSQL = `
  INSERT INTO product_co_purchases (product_a_id, product_b_id, co_purchase_count, updated_at)
  SELECT
    a.product_id AS product_a_id,
    b.product_id AS product_b_id,
    COUNT(DISTINCT a.order_id) AS co_purchase_count,
    NOW() AS updated_at
  FROM order_items a
  JOIN order_items b ON a.order_id = b.order_id AND a.product_id < b.product_id
  GROUP BY a.product_id, b.product_id
  HAVING COUNT(DISTINCT a.order_id) >= 3  -- Minimum confidence threshold
  ON CONFLICT (product_a_id, product_b_id)
  DO UPDATE SET co_purchase_count = EXCLUDED.co_purchase_count, updated_at = NOW();
`;

// Step 2: Serve "Frequently Bought Together" from the pre-computed matrix
export async function getFrequentlyBoughtTogether(
  productId: string, limit = 6, excludeProductIds: string[] = []
): Promise<Product[]> {
  const pairs = await db.productCoPurchases.findMany({
    where: {
      OR: [{ productAId: productId }, { productBId: productId }],
      NOT: { OR: [{ productAId: { in: excludeProductIds } }, { productBId: { in: excludeProductIds } }] },
    },
    orderBy: { coPurchaseCount: 'desc' },
    take: limit * 2, // Fetch extra to filter out-of-stock
  });

  const relatedIds = pairs.map(p => p.productAId === productId ? p.productBId : p.productAId);
  const products = await db.products.findMany({ where: { id: { in: relatedIds }, status: 'active', inventoryQuantity: { gt: 0 } } });
  return products.slice(0, limit);
}

// Step 3: Browsing history recommendations using product vectors
function buildProductVector(product: Product, allCategoryIds: string[], allTags: string[]): number[] {
  const categoryEncoding = allCategoryIds.map(id => product.categoryId === id ? 1 : 0);
  const priceNormalized = product.priceInCents / 100000;  // Normalize to 0-1
  const tagEncoding = allTags.map(tag => product.tags.includes(tag) ? 1 : 0);
  return [...categoryEncoding, priceNormalized, ...tagEncoding];
}

export async function getRecommendationsFromBrowsingHistory(
  sessionProductIds: string[], limit = 8
): Promise<Product[]> {
  if (sessionProductIds.length === 0) return getBestSellers(limit);

  const [browsedProducts, allProducts, allCategoryIds, allTags] = await Promise.all([
    db.products.findMany({ where: { id: { in: sessionProductIds } } }),
    db.products.findMany({ where: { status: 'active', inventoryQuantity: { gt: 0 }, id: { notIn: sessionProductIds } }, take: 500 }),
    db.categories.findMany({ select: { id: true } }).then(cats => cats.map(c => c.id)),
    db.productTags.findMany({ distinct: ['tag'] }).then(tags => tags.map(t => t.tag)),
  ]);

  // Build "taste vector" by averaging vectors of browsed products
  const vectors = browsedProducts.map(p => buildProductVector(p, allCategoryIds, allTags));
  const tasteVector = vectors[0].map((_, i) => vectors.reduce((sum, v) => sum + v[i], 0) / vectors.length);

  // Rank all products by cosine similarity to taste vector
  const ranked = allProducts
    .map(p => {
      const vec = buildProductVector(p, allCategoryIds, allTags);
      const dot = tasteVector.reduce((sum, val, i) => sum + val * vec[i], 0);
      const mag = Math.sqrt(tasteVector.reduce((s, v) => s + v * v, 0)) * Math.sqrt(vec.reduce((s, v) => s + v * v, 0));
      return { product: p, score: mag > 0 ? dot / mag : 0 };
    })
    .sort((a, b) => b.score - a.score);

  return ranked.slice(0, limit).map(r => r.product);
}

// Step 4: Unified recommendation API with caching
export async function getRecommendations(context: 'pdp' | 'homepage' | 'cart', productId?: string, sessionProductIds: string[] = []) {
  const cacheKey = `recs:${context}:${productId ?? 'none'}:${sessionProductIds.slice(0, 3).join('-')}`;
  const cached = await redis.get(cacheKey);
  if (cached) return JSON.parse(cached);

  let products: Product[];
  switch (context) {
    case 'pdp':
      products = await getFrequentlyBoughtTogether(productId!, 6, [productId!]);
      if (products.length < 4) {
        const extra = await getRecommendationsFromBrowsingHistory(sessionProductIds, 4 - products.length);
        products = [...products, ...extra];
      }
      break;
    case 'homepage':
      products = sessionProductIds.length > 0
        ? await getRecommendationsFromBrowsingHistory(sessionProductIds, 12)
        : await getBestSellers(12);
      break;
    default:
      products = await getBestSellers(8);
  }

  await redis.setex(cacheKey, 300, JSON.stringify(products));  // 5-minute cache
  return products;
}

For stores with 10k+ customers: Use the BG/NBD + ALS collaborative filtering (Python implicit library) for significantly more accurate user-item recommendations than the cosine similarity approach.

Step 3: Configure recommendation exclusions

Every recommendation engine must exclude:

1. Out-of-stock products — never recommend products customers can't buy
2. The product currently being viewed — excluding the current product from "Related Products" on its own PDP
3. Recently purchased products — showing customers products they bought last week signals a poor experience

In LimeSpot: Configure exclusions under Settings → Exclusions — out-of-stock products are excluded automatically.

In Frequently Bought Together: The app automatically hides out-of-stock variants from the bundle suggestion.

For custom builds: Pass excludeProductIds containing the current product and the customer's recently purchased products to every recommendation function.

Step 4: Measure recommendation performance

Track these weekly:

Best Practices

• Use an app before building from scratch — LimeSpot and Frequently Bought Together are well-calibrated and handle edge cases (cold start, out-of-stock, recently purchased exclusions) that take weeks to build correctly
• Refresh the co-purchase matrix nightly — new orders change which products are frequently bought together; stale data degrades recommendation quality
• Filter out-of-stock products at query time, not at model build time — inventory changes faster than the recommendation model refreshes
• Cap recommendation carousels at 6–8 products — more than 8 creates choice paralysis and lowers click-through rate
• Implement a feedback loop — track click-through and add-to-cart rates per recommendation slot to compare algorithm variants over time

Common Pitfalls

Related Skills

• @customer-segmentation
• @customer-lifetime-value
• @product-reviews-ratings
• @user-generated-content