plan/05-knowledge-based.md

Knowledge-Based Recommendation Plan

Overview

Knowledge-Based Recommendation uses explicit domain knowledge, rules, and user-provided constraints. It requires no historical rating data — ideal for cold-start scenarios.

Method 1: Constraint-Based Filtering

Concept: Filter products based on explicit hard constraints provided by the user.

Constraints:

• Price range: min_price ≤ product_price ≤ max_price
• Category: product_category ∈ selected_categories
• Brand: product_brand ∈ preferred_brands
• Rating threshold: avg_rating ≥ min_rating

Steps:

1. Apply all constraints sequentially (AND logic)
2. Return remaining products
3. Sort by match score (how many constraints satisfied)
4. Recommend top-N

Method 2: Rule-Based Recommendation

Concept: Apply domain-specific if-then rules to generate recommendations.

Rules:

IF user bought a laptop THEN recommend laptop accessories (mouse, bag, charger)
IF user bought a smartphone THEN recommend phone case, screen protector
IF user is looking at a book THEN recommend books by same author
IF user budget < $50 THEN recommend items from "Budget Picks" category
IF user searches "gaming" THEN recommend gaming-related items

Steps:

1. Check user's current interaction (cart, search, browse)
2. Fire matching rules
3. Aggregate and rank results
4. Recommend top-N

Method 3: Utility-Based Recommendation

Concept: Score items based on weighted utility function derived from user preferences.

Utility Function:

U(item, user) = w₁ * price_score + w₂ * category_score + w₃ * brand_score + w₄ * rating_score

Where each score is normalized 0-1 and weights sum to 1.

Steps:

1. User sets preference weights (or use defaults)
2. Compute utility for all items
3. Sort by utility descending
4. Recommend top-N

Implementation (recommender/knowledge_based.py)

class KnowledgeBasedRecommender:
    def __init__(self, products_df):
        self.products = products_df
    
    def constraint_based(self, constraints, n=10): ...
    def rule_based(self, user_context, n=10): ...
    def utility_based(self, preferences, weights, n=10): ...

Explanation Generation

• Constraint: "Recommended because it meets your criteria: budget ${budget}, category: {cat}"
• Rule: "Recommended because you bought a {trigger_item} — {rule_reason}"
• Utility: "Recommended with {score}% match to your preferences"

When Each Performs Best

Method	Best For
Constraint-Based	Users who know exactly what they want
Rule-Based	Users browsing specific categories
Utility-Based	Users who want trade-off recommendations