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

Ce tutoriel utilise la répartition actuelle des paquets LangChain JS - les primitives du cœur, l'intégration OpenAI et les text splitters vivent chacun dans leur propre paquet :

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

Obtenez une clé depuis le tableau de bord (100 crédits gratuits, sans carte), puis appelez le endpoint de transcription depuis un route handler 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 est la transcription complète en texte brut et word_count sa longueur - utile pour décider si l'étape de découpage est même nécessaire sur une vidéo courte.

Une longue transcription peut facilement dépasser ce qu'il est confortable d'envoyer à un LLM en un seul prompt, découpez-la donc d'abord. RecursiveCharacterTextSplitter essaie de couper au niveau du paragraphe, puis de la phrase, puis du mot, dans cet ordre, pour que les morceaux restent lisibles plutôt que coupés en plein milieu d'une phrase :

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 conserve un peu de contexte de la fin d'un morceau au début du suivant, pour qu'une phrase coupée à la frontière ne soit perdue ni pour l'un ni pour l'autre.

ChatPromptTemplate + un modèle + StringOutputParser enchaînés (le langage d'expression de LangChain, LCEL) est la façon actuelle et stable de construire une chaîne - chaque morceau reçoit son propre résumé court, en parallèle :

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

Les exécuter en parallèle avec Promise.all compte pour la latence : une transcription de 10 morceaux résumée un par un prend 10 fois plus de temps que de les résumer tous en même temps.

Les résumés des morceaux sont maintenant assez courts pour tenir ensemble dans un seul prompt, donc une seconde chaîne les combine dans le résultat 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 });

Cette structure en deux passes (résumer les morceaux, puis résumer les résumés) est exactement ce que fait en coulisses le propre schéma map-reduce de LangChain - écrit ici explicitement plutôt que d'utiliser une chaîne utilitaire historique, car les API des chaînes de résumé ont changé d'une version de LangChain à l'autre, et les primitives LCEL simples sont une base plus stable sur laquelle construire.

L'étape de récupération de la transcription ci-dessus est la seule partie de ce pipeline qui devient vraiment plus difficile en production - les bibliothèques de scraping auto-hébergées se font souvent bloquer une fois déployées sur un serveur cloud. Une API de Transcriptions YouTube hébergée est conçue spécifiquement pour que cette étape continue de fonctionner, sans que le reste du pipeline ait à s'en soucier.