How to Build a RAG Pipeline with YouTube Transcripts

Obtenez une clé depuis le tableau de bord (100 crédits gratuits, sans carte bancaire) et récupérez la transcription de chaque vidéo par son identifiant. Les crédits sont facturés par requête, pas par minute de vidéo : une conférence de 3 heures coûte donc le même 1 crédit qu'un extrait de 2 minutes - ce qui compte dès que vous indexez tout le catalogue d'une chaîne :

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 et title reviennent avec le texte de la transcription - c'est ce que l'étape 5 utilise pour citer la réponse.

Découpez chaque transcription en fenêtres qui se chevauchent avant de générer les embeddings - un embedding sur la vidéo entière est trop grossier pour retrouver une réponse précise, et aucune bibliothèque n'est nécessaire pour cela :

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,
  }))
);

Une fenêtre de 1 200 caractères avec un chevauchement de 200 caractères est un bon point de départ pour des transcriptions orales - réduisez-la pour des extraits courts et denses, augmentez-la pour un contenu de type conférence où plus de contexte environnant aide.

Générez l'embedding de chaque morceau et conservez l'identifiant et le titre de la vidéo à côté du vecteur, puisque c'est ce qui transforme un morceau récupéré en citation par la suite :

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) }))
);

Cet exemple garde les vecteurs en mémoire par souci de clarté. Au-delà de quelques centaines de morceaux, remplacez le tableau par pgvector, Pinecone ou une autre base vectorielle - l'étape de récupération ci-dessous n'a besoin que d'une fonction renvoyant les k vecteurs les plus proches, pas exactement de cette structure.

Au moment de la requête, générez l'embedding de la question avec le même modèle et classez les morceaux stockés par similarité cosinus :

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 est un bon point de départ - trop peu de morceaux et le modèle n'a pas assez de contexte pour répondre complètement, trop et des morceaux non pertinents commencent à diluer la réponse.

Transmettez les morceaux récupérés au modèle sous forme de contexte numéroté et demandez-lui de répondre uniquement à partir de ce contenu, en citant ses sources - c'est ce qui garde la réponse traçable jusqu'à une vraie vidéo plutôt que jusqu'aux connaissances générales du modèle :

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;
}

Citer par titre de vidéo, plutôt que d'inventer un horodatage, correspond à ce que l'API de transcription renvoie réellement - ne laissez pas le modèle fabriquer un horodatage qu'il n'a jamais reçu.

Pour une chaîne qui continue de publier, vérifiez les nouvelles vidéos selon un planning avec le endpoint gratuit /channel/latest (0 crédit), ignorez les identifiants de vidéo déjà indexés et ne récupérez, découpez et générez les embeddings que pour les nouvelles. Le coût d'ingestion reste ainsi proportionnel au nouveau contenu plutôt qu'une réindexation complète à chaque exécution.

La vidéo est l'un des formats les plus pénibles pour construire de la recherche documentaire dessus - impossible de faire un grep dans une vidéo. Une transcription la retransforme en texte que votre pipeline d'embeddings et de récupération sait déjà traiter, sans exécuter vous-même un job de reconnaissance vocale. Et comme une API facturée à la requête ne mesure pas selon la durée de la vidéo, ingérer un ensemble de contenus longs (podcasts, conférences, streams de plusieurs heures) ne coûte pas systématiquement plus cher que d'ingérer des extraits courts - exactement le type d'archive qu'un pipeline RAG est généralement conçu pour explorer.