Cara Mengumpulkan Data YouTube untuk Sistem RAG: Mengambil Subtitle dan Metadata dengan Python

Sistem RAG (Retrieval-Augmented Generation) memerlukan data berkualitas untuk pelatihan. YouTube adalah sumber konten terstruktur yang besar: video dengan subtitle, metadata, dan komentar. Dalam artikel ini, kita akan membahas cara efektif untuk mengumpulkan data YouTube untuk RAG, menghindari pemblokiran dan mematuhi batasan API.

Apa itu RAG dan mengapa data YouTube diperlukan

RAG (Retrieval-Augmented Generation) adalah pendekatan dalam membangun sistem AI, di mana model bahasa dilengkapi dengan basis pengetahuan. Alih-alih hanya bergantung pada data yang digunakan untuk melatih model, RAG mengekstrak informasi relevan dari sumber eksternal dan menggunakannya untuk menghasilkan jawaban.

YouTube memiliki jutaan jam konten dengan subtitle dalam berbagai bahasa. Ini menjadikan platform ini sebagai sumber data yang berharga untuk sistem RAG di berbagai bidang:

• Sistem pendidikan — kuliah, tutorial, kursus dengan cap waktu
• Dokumentasi teknis — video panduan tentang pemrograman, DevOps, pengaturan perangkat lunak
• Basis pengetahuan medis — kuliah dokter, analisis kasus klinis
• Analitik bisnis — wawancara dengan para ahli, studi kasus, tinjauan pasar
• Dukungan produk — ulasan produk, FAQ dalam format video

Keuntungan data YouTube adalah adanya struktur: subtitle dengan cap waktu, metadata (kategori, tag), konteks sosial (komentar, suka). Semua ini membantu sistem RAG memahami tidak hanya isi, tetapi juga konteks informasi.

Jenis data YouTube yang berguna untuk sistem RAG

Untuk bekerja secara efektif dengan sistem RAG, perlu mengumpulkan beberapa jenis data. Setiap jenis memiliki tugasnya sendiri dalam proses ekstraksi dan generasi informasi.

Subtitle (Transkrip)

Sumber utama data tekstual. YouTube menyediakan dua jenis subtitle:

• Otomatis — dihasilkan oleh algoritma pengenalan suara Google. Tersedia untuk sebagian besar video dalam bahasa Inggris dan bahasa populer lainnya. Akurasi 85-95% tergantung pada kualitas suara.
• Manual — diunggah oleh penulis atau komunitas. Lebih akurat, sering kali berisi format dan konteks tambahan.

Subtitle mencakup cap waktu (timestamps), yang memungkinkan menghubungkan teks dengan momen tertentu dalam video. Ini sangat penting untuk membuat tautan yang akurat ke sumber dalam jawaban RAG.

Metadata video

Metadata membantu sistem RAG memahami konteks dan relevansi informasi:

Komentar

Komentar mengandung konteks tambahan: pertanyaan dari penonton, klarifikasi dari penulis, diskusi. Untuk sistem RAG, ini sangat berharga, karena:

• Komentar sering kali berisi FAQ tentang topik video
• Penulis dapat memposting perbaikan dan tambahan
• Diskusi mengungkapkan berbagai sudut pandang tentang masalah

Bekerja dengan YouTube Data API v3: pengaturan dan batasan

YouTube Data API v3 adalah cara resmi untuk mendapatkan data. Ini memberikan akses ke metadata, statistik, komentar. Subtitle diperoleh melalui metode terpisah.

Mendapatkan kunci API

Untuk bekerja dengan API, Anda memerlukan kunci dari Google Cloud Console:

1. Kunjungi console.cloud.google.com
2. Buat proyek baru atau pilih proyek yang sudah ada
3. Aktifkan YouTube Data API v3 di bagian "APIs & Services"
4. Buat kredensial (Credentials) → kunci API
5. Salin kunci — ini akan diperlukan untuk semua permintaan

Batasan dan kuota

YouTube API menggunakan sistem kuota. Setiap permintaan "biaya" sejumlah unit tertentu:

Batas harian default adalah 10.000 unit. Ini sekitar 100 permintaan pencarian atau 10.000 permintaan metadata. Untuk meningkatkan kuota, Anda perlu mengajukan permohonan ke Google.

Contoh dasar bekerja dengan API

import requests

API_KEY = 'kunci_api_anda'
BASE_URL = 'https://www.googleapis.com/youtube/v3'

# Pencarian video berdasarkan kueri
def search_videos(query, max_results=10):
    url = f'{BASE_URL}/search'
    params = {
        'part': 'snippet',
        'q': query,
        'type': 'video',
        'maxResults': max_results,
        'key': API_KEY
    }
    
    response = requests.get(url, params=params)
    return response.json()

# Mendapatkan metadata video
def get_video_details(video_id):
    url = f'{BASE_URL}/videos'
    params = {
        'part': 'snippet,contentDetails,statistics',
        'id': video_id,
        'key': API_KEY
    }
    
    response = requests.get(url, params=params)
    return response.json()

# Contoh penggunaan
results = search_videos('tutorial machine learning', max_results=5)
for item in results.get('items', []):
    video_id = item['id']['videoId']
    title = item['snippet']['title']
    print(f'ID: {video_id}, Judul: {title}')
    
    # Mendapatkan informasi detail
    details = get_video_details(video_id)
    stats = details['items'][0]['statistics']
    print(f"Tampilan: {stats.get('viewCount')}, Suka: {stats.get('likeCount')}")

Parsing subtitle video: otomatis dan manual

YouTube Data API v3 tidak menyediakan akses langsung ke subtitle. Untuk mendapatkannya, digunakan metode alternatif.

Menggunakan pustaka youtube-transcript-api

Cara paling sederhana adalah menggunakan pustaka youtube-transcript-api untuk Python. Ini mengekstrak subtitle secara langsung, tanpa kunci API:

from youtube_transcript_api import YouTubeTranscriptApi

# Mendapatkan subtitle
video_id = 'dQw4w9WgXcQ'

try:
    # Mencoba mendapatkan subtitle dalam bahasa Rusia, jika tidak ada — dalam bahasa Inggris
    transcript = YouTubeTranscriptApi.get_transcript(video_id, languages=['ru', 'en'])
    
    # Menampilkan subtitle dengan cap waktu
    for entry in transcript:
        start_time = entry['start']
        duration = entry['duration']
        text = entry['text']
        print(f"[{start_time:.2f}s] {text}")
        
except Exception as e:
    print(f"Kesalahan saat mendapatkan subtitle: {e}")

# Mendapatkan daftar bahasa yang tersedia
transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
for transcript in transcript_list:
    print(f"Bahasa: {transcript.language}, Otomatis: {transcript.is_generated}")

Pustaka ini secara otomatis menentukan subtitle yang tersedia dan dapat menerjemahkannya ke bahasa lain (jika YouTube menyediakan kemungkinan tersebut).

Pengolahan cap waktu untuk RAG

Untuk sistem RAG, penting untuk menjaga hubungan antara teks dan cap waktu. Ini memungkinkan pembuatan tautan yang akurat ke sumber:

def format_timestamp(seconds):
    """Konversi detik ke format MM:SS"""
    minutes = int(seconds // 60)
    secs = int(seconds % 60)
    return f"{minutes:02d}:{secs:02d}"

def create_chunks_with_timestamps(transcript, chunk_size=500):
    """Pembagian subtitle menjadi chunk dengan menjaga cap waktu"""
    chunks = []
    current_chunk = ""
    chunk_start_time = 0
    
    for i, entry in enumerate(transcript):
        if len(current_chunk) == 0:
            chunk_start_time = entry['start']
        
        current_chunk += entry['text'] + " "
        
        # Jika mencapai ukuran yang diinginkan atau akhir subtitle
        if len(current_chunk) >= chunk_size or i == len(transcript) - 1:
            chunks.append({
                'text': current_chunk.strip(),
                'start_time': chunk_start_time,
                'timestamp': format_timestamp(chunk_start_time),
                'video_id': video_id
            })
            current_chunk = ""
    
    return chunks

# Penggunaan
transcript = YouTubeTranscriptApi.get_transcript(video_id)
chunks = create_chunks_with_timestamps(transcript)

for chunk in chunks[:3]:  # Tiga chunk pertama
    print(f"[{chunk['timestamp']}] {chunk['text'][:100]}...")

Pengumpulan metadata: judul, deskripsi, tag

Metadata memperkaya konteks untuk sistem RAG. Berikut adalah contoh lengkap pengumpulan semua data yang diperlukan:

import requests
from datetime import datetime

def collect_video_metadata(video_id, api_key):
    """Pengumpulan metadata lengkap video"""
    url = f'https://www.googleapis.com/youtube/v3/videos'
    params = {
        'part': 'snippet,contentDetails,statistics,topicDetails',
        'id': video_id,
        'key': api_key
    }
    
    response = requests.get(url, params=params)
    data = response.json()
    
    if 'items' not in data or len(data['items']) == 0:
        return None
    
    item = data['items'][0]
    snippet = item['snippet']
    stats = item.get('statistics', {})
    content = item.get('contentDetails', {})
    
    metadata = {
        'video_id': video_id,
        'title': snippet['title'],
        'description': snippet['description'],
        'channel_title': snippet['channelTitle'],
        'channel_id': snippet['channelId'],
        'published_at': snippet['publishedAt'],
        'tags': snippet.get('tags', []),
        'category_id': snippet.get('categoryId'),
        'duration': content.get('duration'),
        'view_count': int(stats.get('viewCount', 0)),
        'like_count': int(stats.get('likeCount', 0)),
        'comment_count': int(stats.get('commentCount', 0)),
        'topics': item.get('topicDetails', {}).get('topicCategories', [])
    }
    
    return metadata

# Contoh penggunaan
metadata = collect_video_metadata('dQw4w9WgXcQ', API_KEY)
print(f"Judul: {metadata['title']}")
print(f"Saluran: {metadata['channel_title']}")
print(f"Tampilan: {metadata['view_count']:,}")
print(f"Tag: {', '.join(metadata['tags'][:5])}")

Menentukan relevansi konten

Untuk topik teknis, kesegaran informasi sangat penting. Mari kita tambahkan fungsi untuk menilai relevansi:

from datetime import datetime, timedelta

def calculate_content_freshness(published_date_str):
    """Menilai relevansi konten"""
    published_date = datetime.fromisoformat(published_date_str.replace('Z', '+00:00'))
    age_days = (datetime.now(published_date.tzinfo) - published_date).days
    
    if age_days < 30:
        return 'very_fresh'
    elif age_days < 180:
        return 'fresh'
    elif age_days < 365:
        return 'moderate'
    else:
        return 'old'

def calculate_quality_score(metadata):
    """Menghitung skor kualitas sumber"""
    score = 0
    
    # Popularitas
    views = metadata['view_count']
    if views > 100000:
        score += 3
    elif views > 10000:
        score += 2
    elif views > 1000:
        score += 1
    
    # Engagement (suka relatif terhadap tampilan)
    if views > 0:
        like_ratio = metadata['like_count'] / views
        if like_ratio > 0.05:
            score += 2
        elif like_ratio > 0.02:
            score += 1
    
    # Relevansi
    freshness = calculate_content_freshness(metadata['published_at'])
    if freshness == 'very_fresh':
        score += 2
    elif freshness == 'fresh':
        score += 1
    
    return score

# Penggunaan
metadata = collect_video_metadata('dQw4w9WgXcQ', API_KEY)
quality = calculate_quality_score(metadata)
freshness = calculate_content_freshness(metadata['published_at'])
print(f"Skor kualitas: {quality}/7")
print(f"Relevansi: {freshness}")

Parsing komentar untuk analisis konteks

Komentar dapat mengandung informasi berharga: perbaikan kesalahan dalam video, sumber tambahan, pertanyaan umum. Untuk sistem RAG, ini adalah konteks tambahan.

def get_video_comments(video_id, api_key, max_results=100):
    """Mendapatkan komentar untuk video"""
    url = 'https://www.googleapis.com/youtube/v3/commentThreads'
    comments = []
    next_page_token = None
    
    while len(comments) < max_results:
        params = {
            'part': 'snippet',
            'videoId': video_id,
            'maxResults': min(100, max_results - len(comments)),
            'order': 'relevance',  # Pengurutan berdasarkan relevansi
            'key': api_key
        }
        
        if next_page_token:
            params['pageToken'] = next_page_token
        
        response = requests.get(url, params=params)
        data = response.json()
        
        if 'items' not in data:
            break
        
        for item in data['items']:
            top_comment = item['snippet']['topLevelComment']['snippet']
            comments.append({
                'author': top_comment['authorDisplayName'],
                'text': top_comment['textDisplay'],
                'like_count': top_comment['likeCount'],
                'published_at': top_comment['publishedAt'],
                'reply_count': item['snippet']['totalReplyCount']
            })
        
        next_page_token = data.get('nextPageToken')
        if not next_page_token:
            break
    
    return comments

def filter_valuable_comments(comments, min_likes=5):
    """Menyaring komentar berharga"""
    valuable = []
    
    for comment in comments:
        # Kriteria nilai:
        # 1. Banyak suka (popularitas)
        # 2. Ada balasan (memicu diskusi)
        # 3. Teks panjang (komentar detail)
        
        if (comment['like_count'] >= min_likes or 
            comment['reply_count'] > 0 or 
            len(comment['text']) > 200):
            valuable.append(comment)
    
    return valuable

# Penggunaan
comments = get_video_comments('dQw4w9WgXcQ', API_KEY, max_results=50)
valuable_comments = filter_valuable_comments(comments)

print(f"Total komentar: {len(comments)}")
print(f"Komentar berharga: {len(valuable_comments)}")

for comment in valuable_comments[:3]:
    print(f"\n[{comment['like_count']} suka] {comment['author']}:")
    print(comment['text'][:200])

Menggunakan proxy untuk skala pengumpulan data

Saat melakukan pengumpulan data secara besar-besaran, ada dua masalah: batasan YouTube API (10.000 kuota per hari) dan pemblokiran saat parsing subtitle. Proxy membantu menyelesaikan kedua masalah ini.

Kapan proxy diperlukan untuk parsing YouTube

• Melebihi kuota API — dengan menggunakan beberapa kunci API melalui berbagai IP, Anda dapat meningkatkan batas harian
• Parsing subtitle di luar API — pustaka youtube-transcript-api melakukan permintaan langsung yang dapat diblokir pada frekuensi tinggi
• Pengumpulan data dari berbagai wilayah — beberapa video hanya tersedia di negara tertentu
• Pengumpulan paralel — distribusi beban ke beberapa IP untuk mempercepat proses

Memilih jenis proxy

Untuk sebagian besar tugas sistem RAG, proxy residential cocok — mereka memberikan keseimbangan antara biaya dan keandalan saat melakukan parsing secara besar-besaran.

Pengaturan proxy dalam kode

import requests
from youtube_transcript_api import YouTubeTranscriptApi
from youtube_transcript_api._api import TranscriptListFetcher

# Pengaturan proxy
PROXY = {
    'http': 'http://username:password@proxy-server:port',
    'https': 'http://username:password@proxy-server:port'
}

# Untuk bekerja dengan API melalui proxy
def get_video_details_with_proxy(video_id, api_key, proxy):
    url = f'https://www.googleapis.com/youtube/v3/videos'
    params = {
        'part': 'snippet,statistics',
        'id': video_id,
        'key': api_key
    }
    
    response = requests.get(url, params=params, proxies=proxy, timeout=10)
    return response.json()

# Untuk parsing subtitle melalui proxy
class ProxiedTranscriptApi:
    def __init__(self, proxy):
        self.proxy = proxy
    
    def get_transcript(self, video_id, languages=['en']):
        # Membuat sesi kustom dengan proxy
        session = requests.Session()
        session.proxies = self.proxy
        
        # Menggunakan sesi untuk permintaan
        fetcher = TranscriptListFetcher(session)
        transcript_list = fetcher.fetch(video_id)
        
        # Mendapatkan bahasa yang diinginkan
        for lang in languages:
            try:
                transcript = transcript_list.find_transcript([lang])
                return transcript.fetch()
            except:
                continue
        
        raise Exception(f"Subtitle tidak ditemukan untuk bahasa: {languages}")

# Penggunaan
api = ProxiedTranscriptApi(PROXY)
transcript = api.get_transcript('dQw4w9WgXcQ', languages=['ru', 'en'])
print(f"Mendapatkan {len(transcript)} segmen subtitle")

Rotasi proxy untuk skala

Saat mengumpulkan data dari ribuan video, penting untuk mendistribusikan beban di antara beberapa proxy:

import random
import time

class ProxyRotator:
    def __init__(self, proxy_list):
        self.proxies = proxy_list
        self.current_index = 0
    
    def get_next_proxy(self):
        """Rotasi berurutan"""
        proxy = self.proxies[self.current_index]
        self.current_index = (self.current_index + 1) % len(self.proxies)
        return proxy
    
    def get_random_proxy(self):
        """Rotasi acak"""
        return random.choice(self.proxies)

# Daftar proxy
PROXY_LIST = [
    {'http': 'http://user:pass@proxy1:port', 'https': 'http://user:pass@proxy1:port'},
    {'http': 'http://user:pass@proxy2:port', 'https': 'http://user:pass@proxy2:port'},
    {'http': 'http://user:pass@proxy3:port', 'https': 'http://user:pass@proxy3:port'},
]

rotator = ProxyRotator(PROXY_LIST)

def collect_data_with_rotation(video_ids):
    results = []
    
    for video_id in video_ids:
        proxy = rotator.get_next_proxy()
        
        try:
            # Mendapatkan metadata
            metadata = get_video_details_with_proxy(video_id, API_KEY, proxy)
            
            # Mendapatkan subtitle
            api = ProxiedTranscriptApi(proxy)
            transcript = api.get_transcript(video_id)
            
            results.append({
                'video_id': video_id,
                'metadata': metadata,
                'transcript': transcript
            })
            
            # Penundaan antara permintaan
            time.sleep(1)
            
        except Exception as e:
            print(f"Kesalahan untuk {video_id}: {e}")
            continue
    
    return results

# Penggunaan
video_ids = ['video1', 'video2', 'video3', 'video4', 'video5']
data = collect_data_with_rotation(video_ids)
print(f"Data dikumpulkan untuk {len(data)} video")

Pengolahan dan persiapan data untuk RAG

Setelah mengumpulkan data, mereka perlu diproses dan disusun untuk bekerja secara efektif dengan sistem RAG.

Membuat embedding vektor

Sistem RAG menggunakan pencarian vektor untuk menemukan fragmen yang relevan. Teks perlu diubah menjadi embedding:

from sentence_transformers import SentenceTransformer
import numpy as np

# Memuat model untuk membuat embedding
model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')

def create_embeddings_from_transcript(transcript_chunks):
    """Membuat embedding untuk chunk subtitle"""
    embeddings = []
    
    for chunk in transcript_chunks:
        # Menggabungkan teks dengan metadata untuk konteks yang lebih baik
        text_with_context = f"{chunk['title']} | {chunk['text']}"
        
        # Membuat embedding
        embedding = model.encode(text_with_context)
        
        embeddings.append({
            'video_id': chunk['video_id'],
            'timestamp': chunk['timestamp'],
            'text': chunk['text'],
            'embedding': embedding.tolist(),
            'metadata': {
                'title': chunk['title'],
                'channel': chunk['channel'],
                'views': chunk['views']
            }
        })
    
    return embeddings

# Persiapan data
def prepare_rag_data(video_data):
    """Persiapan semua data untuk RAG"""
    all_chunks = []
    
    for video in video_data:
        metadata = video['metadata']
        transcript = video['transcript']
        
        # Memecah subtitle menjadi chunk
        chunks = create_chunks_with_timestamps(transcript)
        
        # Menambahkan metadata ke setiap chunk
        for chunk in chunks:
            chunk['title'] = metadata['title']
            chunk['channel'] = metadata['channel_title']
            chunk['views'] = metadata['view_count']
            all_chunks.append(chunk)
    
    # Membuat embedding
    embeddings = create_embeddings_from_transcript(all_chunks)
    
    return embeddings

# Penggunaan
rag_data = prepare_rag_data(collected_videos)
print(f"Disiapkan {len(rag_data)} fragmen untuk RAG")

Menyimpan dalam basis data vektor

Untuk pencarian yang efektif, embedding disimpan dalam basis data khusus. Pilihan populer: Pinecone, Weaviate, Qdrant, ChromaDB.

import chromadb
from chromadb.config import Settings

# Inisialisasi ChromaDB (basis data vektor lokal)
client = chromadb.Client(Settings(
    chroma_db_impl="duckdb+parquet",
    persist_directory="./youtube_rag_db"
))

# Membuat koleksi
collection = client.create_collection(
    name="youtube_transcripts",
    metadata={"description": "Transkrip video YouTube untuk RAG"}
)

def store_in_vector_db(embeddings_data, collection):
    """Menyimpan embedding dalam basis data vektor"""
    
    ids = []
    embeddings = []
    documents = []
    metadatas = []
    
    for i, item in enumerate(embeddings_data):
        ids.append(f"{item['video_id']}_{i}")
        embeddings.append(item['embedding'])
        documents.append(item['text'])
        metadatas.append({
            'video_id': item['video_id'],
            'timestamp': item['timestamp'],
            'title': item['metadata']['title'],
            'channel': item['metadata']['channel'],
            'views': str(item['metadata']['views']),
            'youtube_url': f"https://youtube.com/watch?v={item['video_id']}&t={int(float(item['timestamp'].split(':')[0])*60 + float(item['timestamp'].split(':')[1]))}s"
        })
    
    # Menambahkan ke koleksi
    collection.add(
        ids=ids,
        embeddings=embeddings,
        documents=documents,
        metadatas=metadatas
    )
    
    print(f"Menyimpan {len(ids)} embedding dalam basis data vektor")

# Penggunaan
store_in_vector_db(rag_data, collection)

Pencarian dan generasi jawaban

Langkah terakhir adalah implementasi pencarian RAG dan generasi jawaban:

def search_youtube_knowledge(query, collection, model, top_k=3):
    """Mencari fragmen relevan dari YouTube"""
    
    # Membuat embedding kueri
    query_embedding = model.encode(query).tolist()
    
    # Pencarian dalam basis data vektor
    results = collection.query(
        query_embeddings=[query_embedding],
        n_results=top_k
    )
    
    # Memformat hasil
    sources = []
    for i in range(len(results['ids'][0])):
        sources.append({
            'text': results['documents'][0][i],
            'metadata': results['metadatas'][0][i],
            'distance': results['distances'][0][i] if 'distances' in results else None
        })
    
    return sources

def generate_rag_answer(query, sources, llm_api_key):
    """Menghasilkan jawaban berdasarkan sumber yang ditemukan"""
    
    # Membentuk konteks dari sumber yang ditemukan
    context = "\n\n".join([
        f"Sumber: {s['metadata']['title']} ({s['metadata']['timestamp']})\n{s['text']}"
        for s in sources
    ])
    
    # Prompt untuk LLM
    prompt = f"""Berdasarkan fragmen berikut dari video YouTube, jawab pertanyaan pengguna.
Pastikan untuk mencantumkan sumber dengan cap waktu.

Konteks:
{context}

Pertanyaan: {query}

Jawaban:"""
    
    # Di sini panggil LLM Anda (OpenAI, Claude, model lokal)
    # Contoh dengan OpenAI:
    # response = openai.ChatCompletion.create(
    #     model="gpt-4",
    #     messages=[{"role": "user", "content": prompt}]
    # )
    # answer = response.choices[0].message.content
    
    # Untuk contoh, kembalikan prompt
    return {
        'answer': 'Ini akan menjadi jawaban LLM',
        'sources': sources
    }

# Penggunaan
query = "Bagaimana cara mengatur proxy di Python?"
sources = search_youtube_knowledge(query, collection, model, top_k=3)

print("Sumber yang ditemukan:")
for source in sources:
    print(f"\n{source['metadata']['title']}")
    print(f"Waktu: {source['metadata']['timestamp']}")
    print(f"Tautan: {source['metadata']['youtube_url']}")
    print(f"Teks: {source['text'][:200]}...")

Optimasi kualitas RAG

Beberapa tips untuk meningkatkan kualitas sistem RAG pada data YouTube:

• Saring konten berkualitas rendah — gunakan metrik tampilan, suka, dan usia publikasi
• Jaga konteks — tambahkan judul video dan saluran ke setiap chunk teks
• Optimalkan ukuran chunk — untuk konten teknis, 300-500 kata adalah yang terbaik
• Gunakan metadata untuk peringkat — konten yang lebih segar dan populer dapat mendapatkan prioritas
• Tambahkan komentar — sering kali mengandung klarifikasi penting dan FAQ
• Periksa ketersediaan video — beberapa video mungkin dihapus atau menjadi privat

Kesimpulan

Pengumpulan data YouTube untuk sistem RAG adalah proses multi-langkah yang mencakup bekerja dengan API, parsing subtitle, pengolahan metadata, dan pembuatan embedding vektor. Poin-poin kunci:

• YouTube Data API v3 menyediakan metadata, statistik, dan komentar dengan batasan 10.000 kuota per hari
• Subtitle diparsing melalui pustaka youtube-transcript-api atau permintaan langsung
• Cap waktu sangat penting untuk membuat tautan yang akurat ke sumber
• Metadata (tampilan, suka, tanggal) membantu menilai kualitas dan relevansi konten
• Komentar menambahkan konteks dan sering kali mengandung FAQ
• Proxy diperlukan untuk skala dan menghindari batasan
• Embedding vektor dan basis data khusus menyediakan pencarian semantik yang cepat

Dengan pengaturan proses yang tepat, Anda dapat mengumpulkan puluhan ribu fragmen konten berkualitas dalam sehari, menciptakan basis pengetahuan yang kuat untuk sistem RAG di bidang apa pun.

Jika Anda berencana untuk melakukan pengumpulan data YouTube secara besar-besaran dengan menghindari batasan dan pemblokiran, kami merekomendasikan untuk menggunakan proxy residential — mereka memberikan stabilitas saat melakukan parsing ribuan video dan meminimalkan risiko pemblokiran dari YouTube.