Recommendation Engine

Overview

This skill provides comprehensive implementation of recommendation systems using collaborative filtering, content-based filtering, matrix factorization, and hybrid approaches to predict user preferences and deliver personalized suggestions.

When to Use

• Building personalized product recommendations for e-commerce platforms
• Creating content recommendation systems for streaming services, news platforms, or social media
• Implementing user-user or item-item collaborative filtering based on interaction patterns
• Addressing cold start problems for new users or items with limited interaction history
• Evaluating recommendation quality using precision@k, recall@k, and NDCG metrics
• Scaling recommendation systems to handle millions of users and items efficiently

Recommendation Approaches

• Collaborative Filtering: Using user-item interaction patterns
• Content-Based: Recommending similar items based on features
• Hybrid: Combining multiple approaches
• Matrix Factorization: Decomposing user-item matrix
• Neural Networks: Deep learning for embeddings
• Knowledge-Based: Using domain knowledge and rules

Key Techniques

• User-User Similarity: Finding similar users
• Item-Item Similarity: Finding similar items
• Latent Factors: Hidden patterns in data
• Embeddings: Vector representations of users/items
• Graph-Based: Social networks and item graphs

Python Implementation

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.metrics.pairwise import cosine_similarity, euclidean_distances
from sklearn.decomposition import TruncatedSVD
from sklearn.feature_extraction.text import TfidfVectorizer
from scipy.sparse import csr_matrix
import warnings
warnings.filterwarnings('ignore')

print("=== 1. Collaborative Filtering ===")

# Create sample user-item interaction matrix
np.random.seed(42)
n_users = 50
n_items = 30

# Create sparse interaction matrix (ratings: 0-5)
interaction_matrix = np.random.randint(0, 6, size=(n_users, n_items))
# Make it sparse (many zeros)
interaction_matrix[np.random.random((n_users, n_items)) > 0.3] = 0

print(f"User-Item Matrix Shape: {interaction_matrix.shape}")
print(f"Sparsity: {(interaction_matrix == 0).sum() / interaction_matrix.size:.2%}")

# User-based collaborative filtering
print("\n=== User-Based Collaborative Filtering ===")

# Normalize ratings
user_means = np.nanmean(np.where(interaction_matrix != 0, interaction_matrix, np.nan), axis=1, keepdims=True)
user_means[np.isnan(user_means)] = 0

interaction_normalized = interaction_matrix - user_means

# Convert to sparse matrix
interaction_sparse = csr_matrix(interaction_normalized)

# Compute user-user similarity
user_similarity = cosine_similarity(interaction_sparse)

print(f"User Similarity Matrix Shape: {user_similarity.shape}")
print(f"Sample user similarity [0,1]: {user_similarity[0, 1]:.4f}")

# 2. Item-based collaborative filtering
print("\n=== Item-Based Collaborative Filtering ===")

# Compute item-item similarity
item_similarity = cosine_similarity(interaction_sparse.T)

print(f"Item Similarity Matrix Shape: {item_similarity.shape}")
print(f"Sample item similarity [0,1]: {item_similarity[0, 1]:.4f}")

# 3. Matrix Factorization (SVD)
print("\n=== Matrix Factorization (SVD) ===")

# Apply SVD
svd = TruncatedSVD(n_components=5, random_state=42)
user_factors = svd.fit_transform(interaction_sparse)
item_factors = svd.components_.T

print(f"User Factors Shape: {user_factors.shape}")
print(f"Item Factors Shape: {item_factors.shape}")
print(f"Explained Variance Ratio: {svd.explained_variance_ratio_.sum():.4f}")

# Reconstruct ratings
reconstructed_ratings = user_factors @ item_factors.T + user_means

print(f"Reconstructed Ratings Shape: {reconstructed_ratings.shape}")
print(f"Reconstruction Error: {np.mean((interaction_matrix - reconstructed_ratings) ** 2):.4f}")

# 4. Content-Based Filtering
print("\n=== Content-Based Filtering ===")

# Create item features (e.g., product descriptions)
item_descriptions = [
    "action adventure movie thriller",
    "romantic comedy drama love",
    "sci-fi technology future space",
    "horror scary thriller dark",
    "animation family kids fun",
    "adventure action explosions",
    "documentary educational learning",
    "sports competition championship",
    "musical dance entertainment",
    "historical drama biography"
]

# Expand to 30 items
item_descriptions = (item_descriptions * 4)[:30]

# Create TF-IDF vectors
tfidf = TfidfVectorizer(lowercase=True)
item_features = tfidf.fit_transform(item_descriptions)

# Compute item-item similarity based on content
content_similarity = cosine_similarity(item_features)

print(f"Item Feature Matrix Shape: {item_features.shape}")
print(f"Content-based Item Similarity [0,1]: {content_similarity[0, 1]:.4f}")

# 5. Hybrid Recommendation System
print("\n=== Hybrid Recommendation System ===")

class HybridRecommender:
    def __init__(self, user_similarity, item_similarity, interaction_matrix):
        self.user_similarity = user_similarity
        self.item_similarity = item_similarity
        self.interaction_matrix = interaction_matrix
        self.n_users = interaction_matrix.shape[
how to use recommendation-engine
CursorClaude CodeClineCodexWindsurfGooseGitHub CopilotVS CodeGemini CLIKiloOpencodeKimi CLIRoo ClineAiderContinueZedBolt.newLovablev0Replit AgentSweepSmol DeveloperDevinCavemanAmpAntigravity
How to use recommendation-engine on Cursor
AI-first code editor with Composer
1
Prerequisites
Before installing skills in Cursor, ensure your development environment meets these requirements:
›Cursor installed and configured on your development machine
›Node.js version 16.0+ with npm package manager (verify with node --version)
›Active project directory or workspace where you want to add recommendation-engine
2
Execute installation command
Execute the skills CLI command in your project's root directory to begin installation:
$npx skills add https://github.com/aj-geddes/useful-ai-prompts --skill recommendation-enginecopy
The skills CLI fetches recommendation-engine from GitHub repository aj-geddes/useful-ai-prompts and configures it for Cursor.
3
Select Cursor when prompted
The CLI will show a list of available agents. Use arrow keys to navigate and space to select Cursor:
◆ Which agents do you want to install to?
│
│ ── Universal (.agents/skills) ── always included ────
│   • Amp
│   • Antigravity
│   • Cline
│   • Codex
│ ●Cursor(selected)
│   • Cursor
│   • Windsurf
4
Verify installation
Confirm successful installation by checking the skill directory location:
.cursor/skills/recommendation-engine
Reload or restart Cursor to activate recommendation-engine. Access the skill through slash commands (e.g., /recommendation-engine) or your agent's skill management interface.
⚠
Security & Verification Notice
We perform automated surface-level scans (Gen AI Scanner, Socket, Snyk) during installation. These checks detect common vulnerabilities but do not guarantee complete security. Always review skill source code and verify the publisher's reputation before production use.
Skills execute code in your development environment. Always verify the publisher's identity, review recent commits, and test in isolated environments before production deployment.
Additional Resources
›View source code on GitHub›Skills CLI documentation›Learn more about Cursor›What are agent skills?