How to Build a RAG Pipeline with YouTube Transcripts

Consigue una clave desde el panel (100 créditos gratis, sin tarjeta) y obtén la transcripción de cada video por su id. Los créditos se cobran por solicitud, no por minuto de video, así que una conferencia de 3 horas cuesta el mismo 1 crédito que un clip de 2 minutos - algo que importa en cuanto empiezas a indexar todo el catálogo de un canal:

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 y title llegan junto con el texto de la transcripción - eso es lo que el paso 5 usa para citar la respuesta.

Divide cada transcripción en ventanas superpuestas antes de incrustarla - incrustar un video entero es demasiado impreciso para recuperar una respuesta concreta, y no hace falta ninguna librería para esto:

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

Una ventana de 1.200 caracteres con 200 de superposición es un valor por defecto razonable para transcripciones habladas - redúcela para clips cortos y densos, auméntala para contenido tipo conferencia donde más contexto alrededor ayuda.

Incrusta cada fragmento y guarda el id y el título del video junto al vector, ya que eso es lo que convierte un fragmento recuperado en una cita más adelante:

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

Esto guarda los vectores en memoria por claridad. Pasadas unas pocas centenas de fragmentos, cambia el array por pgvector, Pinecone u otro almacén de vectores - el paso de recuperación de abajo solo necesita una función que devuelva los k vectores más cercanos, no exactamente esta forma.

En el momento de la consulta, incrusta la pregunta con el mismo modelo y ordena los fragmentos guardados por similitud coseno:

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 es un punto de partida - con muy pocos fragmentos el modelo no tiene suficiente contexto para responder del todo, y con demasiados los fragmentos irrelevantes empiezan a diluir la respuesta.

Pasa los fragmentos recuperados al modelo como contexto numerado e indícale que responda solo con lo que hay ahí y que cite sus fuentes - esto es lo que mantiene la respuesta trazable hasta un video real en lugar del conocimiento general del propio modelo:

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

Citar por título del video, en lugar de inventar una marca de tiempo, coincide con lo que la API de transcripción realmente devuelve - no dejes que el modelo invente una marca de tiempo que nunca se le dio.

Para un canal que sigue publicando, revisa si hay subidas nuevas con regularidad usando el endpoint gratuito /channel/latest (0 créditos), omite los ids de video que ya tienes indexados, y obtén, divide e incrusta solo los nuevos. Así el costo de ingesta se mantiene proporcional al contenido nuevo, en lugar de reindexar todo en cada ejecución.

El video es uno de los formatos más incómodos para construir recuperación sobre él - no puedes hacer grep de un video. Una transcripción lo convierte de nuevo en texto, algo que tu stack de embeddings y recuperación ya sabe manejar, sin que tengas que correr tu propio proceso de reconocimiento de voz. Y como una API que cobra por solicitud no mide por duración del video, ingerir un archivo de contenido largo (podcasts, conferencias, streams de varias horas) no se vuelve sistemáticamente más caro que ingerir clips cortos - que es exactamente el tipo de archivo para el que suele construirse un pipeline de RAG.