Membangun Recommendation Engine Streaming dengan FastAPI & Content-Based Filtering

Salah satu fitur unggulan pada platform ForgeFlix yang membedakannya dari agregator film konvensional adalah baris Rekomendasi Untuk Kamu yang disesuaikan dengan film atau serial yang sedang ditonton pengguna.

Artikel ini membahas bagaimana kami merancang dan mengimplementasikan Content-Based Recommendation Engine menggunakan Python, FastAPI, dan Scikit-Learn.

---

Konsep Dasar Content-Based Filtering

Content-Based Filtering merekomendasikan item berdasarkan kemiripan fitur atribut dari item tersebut (seperti genre, sinopsis, sutradara, aktor, dan kata kunci) terhadap item yang disukai pengguna.

Langkah Alur Kerja Algoritma:

1. Ekstraksi Fitur Metadata: Penggabungan teks sinopsis (overview), daftar genres, nama director, dan jajaran cast menjadi satu string teks terpadu (metadata soup).
2. Vektorisasi Teks (TF-IDF): Mengubah string teks menjadi matriks bobot angka menggunakan Term Frequency-Inverse Document Frequency (TF-IDF).
3. Kalkulasi Cosine Similarity: Menghitung sudut kosinus antara dua vektor data untuk mengukur tingkat kemiripan konten (skala 0.0 hingga 1.0).

---

Implementasi Kode Python

Berikut skrip inti rekomendasi yang dijalankan dalam microservice FastAPI ForgeFlix:

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
import pandas as pd
import numpy as np

class MovieRecommender:
    def __init__(self, media_dataset: pd.DataFrame):
        self.df = media_dataset
        self._prepare_soup()
        self._build_similarity_matrix()

    def _prepare_soup(self):
        # Menggabungkan genre, director, cast, dan overview
        def create_soup(row):
            genres = " ".join(row.get('genres', []))
            director = row.get('director', '')
            overview = row.get('overview', '')
            return f"{genres} {director} {overview}".lower()

        self.df['soup'] = self.df.apply(create_soup, axis=1)

    def _build_similarity_matrix(self):
        # Membentuk matriks TF-IDF
        tfidf = TfidfVectorizer(stop_words='english', max_features=5000)
        tfidf_matrix = tfidf.fit_transform(self.df['soup'])

        # Menghitung matriks Cosine Similarity
        self.similarity_matrix = cosine_similarity(tfidf_matrix, tfidf_matrix)
        self.indices = pd.Series(self.df.index, index=self.df['tmdbId']).drop_duplicates()

    def predict_similar(self, tmdb_id: int, top_n: int = 10):
        if tmdb_id not in self.indices:
            return []

        idx = self.indices[tmdb_id]
        sim_scores = list(enumerate(self.similarity_matrix[idx]))
        sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)
        sim_scores = sim_scores[1:top_n+1]

        movie_indices = [i[0] for i in sim_scores]
        return self.df.iloc[movie_indices].to_dict(orient='records')

---

Mengapa Menggunakan FastAPI?

Memproses perkalian matriks Cosine Similarity pada 1.000+ katalog film memerlukan alokasi CPU yang intensif. Menggunakan Python FastAPI memberikan keuntungan:

1. Latensi Sub-20ms: Dengan memuat (caching) matriks kesamaan di dalam memori RAM saat server FastAPI pertama kali dinyalakan (on startup), query rekomendasi dapat dijawab dalam hitungan milidetik.
2. Endpoint Asinkron: FastAPI mendukung async def, memungkinkan backend NestJS memanggil rekomendasi secara non-blocking.
3. Validasi Tipe Pydantic: Menjamin skema JSON respon sesuai dengan kontrak tipe TypeScript di frontend.

# Model Pydantic untuk Skema Respon API
class RecommendationResponse(BaseModel):
    tmdbId: int
    title: str
    posterUrl: str
    rating: float
    releaseYear: int
    mediaType: str
    similarityScore: float

---

Kesimpulan

Pendekatan Content-Based Filtering menggunakan TF-IDF dan Cosine Similarity terbukti sangat efektif untuk platform streaming media seperti ForgeFlix. Dengan FastAPI, sistem rekomendasi dapat berjalan cepat, efisien, dan mudah diintegrasikan ke dalam arsitektur modern.