🤝 Materi 7: Analisis Kasus - Friend Suggestion System

🎯 Pendahuluan

Pernahkah kamu bertanya-tanya bagaimana Facebook, Instagram, atau LinkedIn bisa tahu siapa teman yang mungkin kamu kenal? Sistem "People You May Know" atau "Suggested Friends" adalah salah satu implementasi paling sukses dari sistem rekomendasi dalam media sosial.

Pada materi ini, kita akan membedah bagaimana sistem rekomendasi pertemanan bekerja, dengan fokus pada algoritma Mutual Friends — yaitu merekomendasikan orang berdasarkan teman bersama.

📊 Problem Statement

Masalah: Bagaimana cara merekomendasikan teman baru yang relevan kepada user di platform media sosial?

Tantangan:

• Platform punya jutaan user — tidak mungkin bandingkan semua orang
• Harus cepat (real-time) — user tidak mau tunggu lama
• Harus relevan — rekomendasi yang buruk akan diabaikan
• Privacy — tidak boleh terlalu "creepy" (misal: stalker yang tidak kenal sama sekali)

Solusi: Friend Suggestion System

Gunakan algoritma berbasis Graph/Network Analysis untuk cari kandidat terbaik berdasarkan:

1. Mutual Friends: Jumlah teman bersama (paling penting!)
2. Common Interests: Kesamaan minat/hobi
3. Location: Lokasi geografis yang sama
4. Network Distance: Seberapa dekat dalam graph pertemanan

🔗 Konsep Graph dalam Social Network

Social network bisa direpresentasikan sebagai Graph:

• Node: Setiap user adalah node/vertex
• Edge: Pertemanan adalah edge yang menghubungkan 2 node

    Ali ---- Budi ---- Cici
     |        |        |
     |        |        |
    Dedi --- Eka ---- Fani

Pertemanan:
- Ali: berteman dengan Budi, Dedi
- Budi: berteman dengan Ali, Cici, Eka
- Cici: berteman dengan Budi, Fani
- Dedi: berteman dengan Ali, Eka
- Eka: berteman dengan Budi, Dedi, Fani
- Fani: berteman dengan Cici, Eka
                

🧮 Algoritma: Mutual Friends Recommendation

Step 1: Identifikasi Kandidat

Untuk user target (misal: Ali), cari semua "Friends of Friends" (FoF) yang belum berteman dengan Ali.

Step 2: Hitung Mutual Friends Score

Untuk setiap kandidat, hitung berapa banyak teman bersama dengan Ali.

Step 3: Ranking & Filter

Urutkan kandidat berdasarkan score dari tertinggi ke terendah:

1. Eka (2 mutual friends) → Rekomendasi tertinggi!
2. Cici (1 mutual friend)
3. Fani (0 mutual friends) → Tidak direkomendasikan

💻 Implementasi Code

			
// Data struktur pertemanan (adjacency list)
const friendships = {
    Ali: ['Budi', 'Dedi'],
    Budi: ['Ali', 'Cici', 'Eka'],
    Cici: ['Budi', 'Fani'],
    Dedi: ['Ali', 'Eka'],
    Eka: ['Budi', 'Dedi', 'Fani'],
    Fani: ['Cici', 'Eka']
};

// Fungsi untuk mendapatkan rekomendasi teman
function getFriendSuggestions(user, friendships, topN = 5) {
    const userFriends = new Set(friendships[user]);
    const candidates = {};
    
    // Step 1: Cari Friends of Friends (FoF)
    for (let friend of userFriends) {
        const friendsOfFriend = friendships[friend];
        
        for (let candidate of friendsOfFriend) {
            // Skip jika kandidat adalah user sendiri
            if (candidate === user) continue;
            
            // Skip jika sudah berteman
            if (userFriends.has(candidate)) continue;
            
            // Hitung mutual friends
            if (!candidates[candidate]) {
                candidates[candidate] = {
                    mutualFriends: [],
                    score: 0
                };
            }
            
            candidates[candidate].mutualFriends.push(friend);
            candidates[candidate].score++;
        }
    }
    
    // Step 2: Ranking berdasarkan score
    const recommendations = Object.entries(candidates)
        .map(([name, data]) => ({
            name: name,
            mutualFriends: data.mutualFriends,
            score: data.score
        }))
        .sort((a, b) => b.score - a.score)
        .slice(0, topN);
    
    return recommendations;
}

// Test sistem
console.log("Rekomendasi teman untuk Ali:");
const suggestions = getFriendSuggestions('Ali', friendships);
console.log(suggestions);

/* Output:
[
    { 
        name: 'Eka', 
        mutualFriends: ['Budi', 'Dedi'], 
        score: 2 
    },
    { 
        name: 'Cici', 
        mutualFriends: ['Budi'], 
        score: 1 
    }
]
*/

⚡ Optimasi untuk Skala Besar

Algoritma sederhana di atas bagus untuk demo, tapi untuk platform dengan jutaan user (seperti Facebook), perlu optimasi:

1. Batasi Kandidat dengan Heuristics

• Hanya proses FoF sampai 2-3 hop (tidak semua graph)
• Filter berdasarkan lokasi dulu (hanya user 1 kota)
• Batasi jumlah kandidat maksimal (misal: 1000 kandidat)

2. Pre-computation & Caching

• Hitung rekomendasi secara batch (malam hari)
• Cache hasil di database/Redis
• Update incremental saat ada pertemanan baru

3. Indexing & Database Optimization

• Gunakan Graph Database (Neo4j, Amazon Neptune)
• Index untuk query pertemanan yang cepat
• Shard data berdasarkan geografis/cluster

🎯 Fitur Tambahan: Scoring yang Lebih Kompleks

Sistem real-world tidak hanya pakai mutual friends. Mereka kombinasikan multiple signals:

function calculateFriendScore(candidate, user) {
    let score = 0;
    
    // 1. Mutual Friends (bobot tertinggi: 40%)
    score += candidate.mutualFriends * 4;
    
    // 2. Common Groups/Communities (30%)
    score += candidate.commonGroups * 3;
    
    // 3. Same Location (15%)
    if (candidate.location === user.location) {
        score += 1.5;
    }
    
    // 4. Common Interests (10%)
    const commonInterests = getCommonInterests(candidate, user);
    score += commonInterests.length * 0.5;
    
    // 5. Recent Interactions (5%)
    if (candidate.recentInteraction) {
        score += 0.5;
    }
    
    return score;
}

📊 Evaluasi & Metrik

Bagaimana tahu sistem rekomendasi pertemanan berhasil?

🔒 Pertimbangan Privacy & Ethics

🎓 Kesimpulan