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

Este tutorial usa la división actual de paquetes de LangChain JS - las primitivas del núcleo, la integración con OpenAI y los text splitters viven cada uno en su propio paquete:

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

Consigue una clave desde el panel (100 créditos gratis, sin tarjeta), y luego llama al endpoint de transcripción desde un route handler de 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 es la transcripción completa en texto plano y word_count es su longitud - útil para decidir si saltarte por completo el paso de fragmentación en un video corto.

Una transcripción larga puede superar fácilmente lo cómodo de enviar a un LLM en un solo prompt, así que divídela primero. RecursiveCharacterTextSplitter intenta cortar por párrafo, luego por oración, luego por palabra, en ese orden, para que los fragmentos sigan siendo legibles en vez de cortar a mitad de una oración:

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 conserva un poco de contexto del final de un fragmento al inicio del siguiente, para que una oración partida en el límite no se pierda en ninguno de los dos.

ChatPromptTemplate + un modelo + StringOutputParser encadenados (el lenguaje de expresión de LangChain, LCEL) es la forma actual y estable de construir una cadena - cada fragmento obtiene su propio resumen corto en 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 }))
);

Ejecutarlos en paralelo con Promise.all importa para la latencia: una transcripción de 10 fragmentos resumida uno por uno tarda 10 veces más que resumir los 10 a la vez.

Los resúmenes de los fragmentos ya son lo bastante cortos para caber juntos en un solo prompt, así que una segunda cadena los combina en el 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 });

Esta estructura de dos pasadas (resumir fragmentos, luego resumir los resúmenes) es lo que hace por dentro el propio patrón map-reduce de LangChain - escrito aquí explícitamente en vez de usar una cadena auxiliar heredada, ya que las APIs de las cadenas de resumen han cambiado entre versiones de LangChain y las primitivas LCEL simples son una base más estable sobre la cual construir.

El paso de obtener la transcripción de arriba es la única parte de este pipeline que se vuelve genuinamente más difícil en producción - las librerías de scraping autoalojadas suelen bloquearse al desplegarse en un servidor en la nube. Una API de Transcripciones de YouTube alojada está construida específicamente para mantener ese paso funcionando, para que el resto de este pipeline no tenga que preocuparse por eso.