How to Build a RAG Pipeline with YouTube Transcripts

Lấy một khóa từ trang quản trị (100 tín dụng miễn phí, không cần thẻ) và lấy bản chép lời của từng video theo id. Tín dụng được tính theo mỗi request, không theo phút video, nên một bài giảng dài 3 giờ chỉ tốn 1 tín dụng như một clip 2 phút - điều này quan trọng khi bạn thu thập cả kho video của một kênh:

async function fetchTranscript(videoId: string) {
  const res = await fetch(
    `https://getyoutubetranscript.com/api/v1/transcript?v=${videoId}`,
    { headers: { Authorization: `Bearer ${process.env.GETYOUTUBETRANSCRIPT_API_KEY}` } }
  );
  const json = await res.json();
  if (!json.success) throw new Error(json.message);
  return json.data as { video_id: string; title: string; transcript: string; word_count: number };
}

const videoIds = ['dQw4w9WgXcQ', 'jNQXAC9IVRw' /* ... */];
const videos = await Promise.all(videoIds.map(fetchTranscript));

video_id và title trả về cùng với văn bản chép lời - đó là thứ bước 5 dùng để trích dẫn câu trả lời.

Chia mỗi bản chép lời thành các đoạn có chồng lấn trước khi embed - embed cả video là quá thô để truy xuất một câu trả lời cụ thể, và không cần thư viện nào cho việc này:

function chunkText(text: string, size = 1200, overlap = 200) {
  const chunks: string[] = [];
  let start = 0;
  while (start < text.length) {
    const end = Math.min(start + size, text.length);
    chunks.push(text.slice(start, end));
    start += size - overlap;
  }
  return chunks;
}

const records = videos.flatMap((video) =>
  chunkText(video.transcript).map((text, chunkIndex) => ({
    videoId: video.video_id,
    title: video.title,
    chunkIndex,
    text,
  }))
);

Đoạn 1.200 ký tự với 200 ký tự chồng lấn là mặc định hợp lý cho bản chép lời dạng lời nói - giảm với clip ngắn, súc tích, tăng với nội dung dạng bài giảng dài nơi cần nhiều ngữ cảnh xung quanh hơn.

Embed từng phần và giữ video id cùng title bên cạnh vector, vì đó là thứ biến một phần được truy xuất thành một trích dẫn sau này:

import OpenAI from 'openai';
const openai = new OpenAI();

async function embed(text: string) {
  const res = await openai.embeddings.create({ model: 'text-embedding-3-small', input: text });
  return res.data[0].embedding;
}

const index = await Promise.all(
  records.map(async (r) => ({ ...r, embedding: await embed(r.text) }))
);

Ví dụ này giữ vector trong bộ nhớ để dễ hiểu. Khi vượt quá vài trăm phần, hãy thay mảng này bằng pgvector, Pinecone, hoặc một vector store khác - bước truy xuất bên dưới chỉ cần một hàm trả về top-k vector gần nhất, không cần đúng cấu trúc này.

Tại thời điểm truy vấn, embed câu hỏi bằng cùng model và xếp hạng các phần đã lưu theo cosine similarity:

function cosineSimilarity(a: number[], b: number[]) {
  let dot = 0, normA = 0, normB = 0;
  for (let i = 0; i < a.length; i++) {
    dot += a[i] * b[i];
    normA += a[i] ** 2;
    normB += b[i] ** 2;
  }
  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
}

async function retrieve(query: string, k = 5) {
  const queryEmbedding = await embed(query);
  return index
    .map((r) => ({ ...r, score: cosineSimilarity(r.embedding, queryEmbedding) }))
    .sort((a, b) => b.score - a.score)
    .slice(0, k);
}

k=5 là điểm khởi đầu hợp lý - quá ít phần thì model không đủ ngữ cảnh để trả lời đầy đủ, quá nhiều thì các phần không liên quan bắt đầu làm loãng câu trả lời.

Đưa các phần đã truy xuất cho model dưới dạng ngữ cảnh đánh số và yêu cầu chỉ trả lời dựa trên đó cùng với trích dẫn nguồn - đây chính là điều giữ cho câu trả lời có thể truy vết về một video thật thay vì kiến thức chung của model:

async function answer(query: string) {
  const matches = await retrieve(query);
  const context = matches
    .map((m, i) => `[${i + 1}] From "${m.title}":\n${m.text}`)
    .join('\n\n');

  const completion = await openai.chat.completions.create({
    model: 'gpt-4.1-mini',
    messages: [
      {
        role: 'system',
        content:
          "Answer only using the numbered transcript excerpts below. Cite sources as [1], [2], etc. " +
          "If the excerpts don't contain the answer, say so.",
      },
      { role: 'user', content: `${context}\n\nQuestion: ${query}` },
    ],
  });

  return completion.choices[0].message.content;
}

Trích dẫn theo tiêu đề video, thay vì bịa ra một mốc thời gian, khớp với những gì API chép lời thực sự trả về - đừng để model bịa ra một mốc thời gian mà nó chưa từng được cung cấp.

Với một kênh vẫn đang đăng video mới, hãy kiểm tra video mới theo lịch bằng endpoint miễn phí /channel/latest (0 tín dụng), bỏ qua các video id đã lập chỉ mục, và chỉ lấy, chia nhỏ, embed những video mới. Chi phí thu thập nhờ đó tỷ lệ với nội dung mới thay vì lập chỉ mục lại toàn bộ mỗi lần chạy.

Video là một trong những định dạng khó xây dựng truy xuất nhất - bạn không thể grep một video. Bản chép lời biến nó trở lại thành văn bản mà stack embedding và truy xuất hiện có của bạn đã biết cách xử lý, mà không cần tự chạy một job speech-to-text. Và vì một API tính phí theo request không tính phí theo độ dài video, việc thu thập một kho nội dung dài (podcast, bài giảng, livestream nhiều giờ) không tự nhiên đắt hơn việc thu thập các clip ngắn - đúng loại kho lưu trữ mà một pipeline RAG thường được xây dựng để tìm kiếm.