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

यह ट्यूटोरियल LangChain JS के मौजूदा पैकेज विभाजन का उपयोग करता है - कोर प्रिमिटिव्स, OpenAI इंटीग्रेशन, और text splitters हर एक अपने खुद के पैकेज में रहते हैं:

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

डैशबोर्ड से एक की लें (100 मुफ़्त क्रेडिट, बिना कार्ड के), फिर Next.js route handler से ट्रांसक्रिप्ट एंडपॉइंट को कॉल करें:

// 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 पूरा प्लेन-टेक्स्ट ट्रांसक्रिप्ट है और word_count इसकी लंबाई - छोटे वीडियो पर चंकिंग स्टेप को पूरी तरह छोड़ना है या नहीं, यह तय करने के लिए उपयोगी।

एक लंबा ट्रांसक्रिप्ट आसानी से उससे ज़्यादा हो सकता है जो एक ही प्रॉम्प्ट में LLM को भेजना ठीक हो, इसलिए पहले इसे बांटें। RecursiveCharacterTextSplitter पहले पैराग्राफ पर, फिर वाक्य पर, फिर शब्द पर तोड़ने की कोशिश करता है, इसी क्रम में, ताकि टुकड़े पठनीय रहें, वाक्य के बीच में न कटें:

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 एक टुकड़े के अंत का थोड़ा संदर्भ अगले टुकड़े की शुरुआत में रखता है, ताकि सीमा पर बंटा कोई वाक्य दोनों में से किसी में भी न खो जाए।

ChatPromptTemplate + एक मॉडल + StringOutputParser को साथ में पाइप करना (LangChain की expression language, LCEL) एक चेन बनाने का मौजूदा, स्थिर तरीका है - हर टुकड़े को समानांतर में अपना छोटा सारांश मिलता है:

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

Promise.all के साथ इन्हें समानांतर में चलाना लेटेंसी के लिए मायने रखता है: 10 टुकड़ों वाला ट्रांसक्रिप्ट एक-एक करके सारांशित करने में सभी 10 को एक साथ सारांशित करने से 10 गुना ज़्यादा समय लगता है।

टुकड़ों के सारांश अब इतने छोटे हैं कि एक साथ एक ही प्रॉम्प्ट में समा जाएं, इसलिए एक दूसरी चेन उन्हें अंतिम परिणाम में मिला देती है:

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

यह दो-चरण संरचना (पहले टुकड़ों का सारांश, फिर सारांशों का सारांश) वही है जो LangChain का अपना map-reduce पैटर्न अंदर ही अंदर करता है - यहां इसे किसी पुरानी हेल्पर चेन का उपयोग करने के बजाय स्पष्ट रूप से लिखा गया है, क्योंकि summarization-chain हेल्पर APIs LangChain के वर्ज़नों में बदलते रहे हैं, और सादे LCEL प्रिमिटिव्स पर बनाना ज़्यादा स्थिर आधार है।

ऊपर दिया गया ट्रांसक्रिप्ट लेने वाला स्टेप इस पाइपलाइन का वह इकलौता हिस्सा है जो प्रोडक्शन में सचमुच मुश्किल हो जाता है - सेल्फ-होस्टेड स्क्रैपिंग लाइब्रेरीज़ आमतौर पर क्लाउड सर्वर पर डिप्लॉय होते ही ब्लॉक हो जाती हैं। एक होस्टेड YouTube ट्रांसक्रिप्ट API खासतौर पर इसी स्टेप को चालू रखने के लिए बनाई गई है, ताकि बाकी पाइपलाइन को इसकी चिंता ही न करनी पड़े।