How to Build a RAG Pipeline with YouTube Transcripts

Consiga uma chave no painel (100 créditos grátis, sem cartão) e busque a transcrição de cada vídeo pelo id. Os créditos são cobrados por requisição, não por minuto de vídeo, então uma palestra de 3 horas custa o mesmo 1 crédito que um clipe de 2 minutos - o que importa quando você está ingerindo todo o catálogo antigo de um 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 e title vêm junto com o texto da transcrição - é a isso que a etapa 5 cita de volta na resposta.

Divida cada transcrição em janelas sobrepostas antes de gerar o embedding - um embedding do vídeo inteiro é grosseiro demais para recuperar uma resposta específica, e nenhuma biblioteca é necessária para isso:

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

Uma janela de 1.200 caracteres com 200 caracteres de sobreposição é um padrão razoável para transcrições faladas - reduza para clipes curtos e densos, aumente para conteúdo longo no estilo palestra, onde mais contexto ao redor ajuda.

Gere o embedding de cada bloco e mantenha o id e o título do vídeo junto com o vetor, já que é isso que transforma um bloco recuperado em uma citação mais tarde:

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

Isso mantém os vetores em memória, por clareza. Passando de algumas centenas de blocos, troque o array por pgvector, Pinecone ou outro vector store - a etapa de recuperação abaixo só precisa de uma função que retorne os top-k vetores mais próximos, não exatamente esse formato.

No momento da consulta, gere o embedding da pergunta com o mesmo modelo e classifique os blocos armazenados por similaridade de cosseno:

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 é um ponto de partida - poucos blocos e o modelo não tem contexto suficiente para responder por completo; muitos, e blocos irrelevantes começam a diluir a resposta.

Passe os blocos recuperados ao modelo como contexto numerado e instrua-o a responder somente com base no que está ali e a citar suas fontes - é isso que mantém a resposta rastreável até um vídeo real, em vez do conhecimento geral do próprio 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 pelo título do vídeo, em vez de inventar um timestamp, corresponde ao que a API de transcrição realmente retorna - não deixe o modelo fabricar um timestamp que nunca recebeu.

Para um canal que continua publicando, verifique novos uploads periodicamente com o endpoint gratuito /channel/latest (0 créditos), pule os ids de vídeo que você já indexou e busque, divida em blocos e gere embeddings apenas dos novos. Assim, o custo de ingestão fica proporcional ao conteúdo novo, em vez de reindexar tudo a cada execução.

Vídeo é um dos formatos mais incômodos para construir recuperação em cima - você não consegue dar grep em um vídeo. Uma transcrição transforma isso de volta em texto, que seu stack de embedding e recuperação já sabe lidar, sem que você precise rodar seu próprio processo de speech-to-text. E como uma API que cobra por requisição não mede pelo tamanho do vídeo, ingerir um backlog de conteúdo longo (podcasts, palestras, streams de várias horas) não fica sistematicamente mais caro do que ingerir clipes curtos - exatamente o tipo de acervo que um pipeline de RAG costuma ser construído para pesquisar.