Build an AI YouTube Video Summarizer with LangChain and Next.js

Este tutorial usa a divisão atual de pacotes do LangChain JS - as primitivas principais, a integração com a OpenAI e os text splitters vivem cada um em seu próprio pacote:

npm install langchain @langchain/core @langchain/openai @langchain/textsplitters

Consiga uma chave no painel (100 créditos grátis, sem cartão), depois chame o endpoint de transcrição a partir de um route handler do Next.js:

// app/api/summarize/route.ts
import { NextResponse } from 'next/server';

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);
  // json.data.transcript is the full plain-text transcript,
  // json.data.word_count is its length in words.
  return json.data as { transcript: string; word_count: number; title: string };
}

transcript é a transcrição completa em texto puro e word_count é o seu tamanho - útil para decidir se você pode pular totalmente a etapa de divisão em um vídeo curto.

Uma transcrição longa pode facilmente ultrapassar o que é confortável enviar a um LLM em um único prompt, então divida-a primeiro. O RecursiveCharacterTextSplitter tenta cortar por parágrafo, depois por frase, depois por palavra, nessa ordem, para que os blocos continuem legíveis em vez de cortar no meio de uma frase:

import { RecursiveCharacterTextSplitter } from '@langchain/textsplitters';

const splitter = new RecursiveCharacterTextSplitter({
  chunkSize: 4000,
  chunkOverlap: 200,
});

const chunks = await splitter.splitText(transcript);
// A 20-minute video is usually 1-2 chunks; a 2-hour one might be 8-10.

chunkOverlap mantém um pouco de contexto do final de um bloco no início do próximo, para que uma frase dividida na fronteira não se perca em nenhum dos dois.

ChatPromptTemplate + um modelo + StringOutputParser encadeados (a linguagem de expressão do LangChain, LCEL) é a forma atual e estável de construir uma cadeia - cada bloco recebe seu próprio resumo curto em paralelo:

import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

const model = new ChatOpenAI({ model: 'gpt-4.1-mini', temperature: 0 });

const chunkPrompt = ChatPromptTemplate.fromTemplate(
  'Summarize this part of a video transcript in 3-4 sentences, keeping any concrete facts, numbers, or names:\n\n{chunk}'
);
const chunkChain = chunkPrompt.pipe(model).pipe(new StringOutputParser());

const chunkSummaries = await Promise.all(
  chunks.map((chunk) => chunkChain.invoke({ chunk }))
);

Rodar isso em paralelo com Promise.all importa para a latência: uma transcrição de 10 blocos resumida um por um leva 10 vezes mais tempo do que resumir os 10 de uma vez.

Os resumos dos blocos agora são curtos o suficiente para caber juntos em um único prompt, então uma segunda cadeia os combina no resultado final:

const finalPrompt = ChatPromptTemplate.fromTemplate(
  'These are summaries of consecutive parts of the same video transcript, titled "{title}".\n' +
  'Combine them into one coherent summary (a short paragraph, then 3-5 key takeaways as bullet points):\n\n{summaries}'
);
const finalChain = finalPrompt.pipe(model).pipe(new StringOutputParser());

const summary = await finalChain.invoke({
  title,
  summaries: chunkSummaries.join('\n\n'),
});

return NextResponse.json({ summary });

Essa estrutura de duas passagens (resumir os blocos, depois resumir os resumos) é o que o próprio padrão map-reduce do LangChain faz por baixo dos panos - escrito aqui explicitamente em vez de usar uma chain auxiliar legada, já que as APIs de chains de resumo mudaram entre versões do LangChain e as primitivas LCEL simples são uma base mais estável para construir em cima.

A etapa de buscar a transcrição acima é a única parte deste pipeline que fica genuinamente mais difícil em produção - bibliotecas de scraping autohospedadas costumam ser bloqueadas assim que implantadas em um servidor na nuvem. Uma API de Transcrições do YouTube hospedada é construída especificamente para manter essa etapa funcionando, para que o resto deste pipeline não precise se preocupar com isso.