LangChain, Faiss, और Next.js के साथ कस्टम AI चैटबॉट बनाएं - एक व्यावहारिक गाइड

इस पोस्ट में, मैं बताता हूं कि कैसे मैंने Upstash, Next.js, LangChain और Fly.io के साथ एक ओपन-सोर्स कस्टम कंटेंट AI चैटबॉट बनाया। Upstash ने मुझे मॉडल प्रशिक्षण शेड्यूल करने, उदार रेट लिमिटिंग की पेशकश करने और OpenAI API प्रतिक्रियाओं को कैश करने में मदद की।

हम क्या उपयोग करेंगे

• Next.js (फ्रंट-एंड और बैक-एंड)
• LangChain (भाषा मॉडल द्वारा संचालित एप्लिकेशन विकसित करने के लिए फ्रेमवर्क)
• Upstash (QStash के माध्यम से मॉडल प्रशिक्षण शेड्यूल करना, रेट लिमिटिंग और OpenAI प्रतिक्रियाओं को कैश करना)
• Tailwind CSS (स्टाइलिंग)
• Fly.io (तैनाती)

आपको क्या चाहिए

• Node.js 18
• एक Upstash खाता
• एक OpenAI खाता (OpenAI API Key के लिए)

Upstash Redis सेटअप करना

एक बार जब आप Upstash खाता बना लेते हैं और लॉग इन हो जाते हैं, तो Redis टैब पर जाएं और एक डेटाबेस बनाएं।

अपना डेटाबेस बनाने के बाद, आप फिर Details टैब पर जाएंगे। नीचे स्क्रॉल करें जब तक आपको Connect your database सेक्शन न मिल जाए। सामग्री को कॉपी करें और इसे कहीं सुरक्षित रखें।

साथ ही, नीचे स्क्रॉल करें जब तक आपको REST API सेक्शन न मिल जाए और .env बटन चुनें। सामग्री को कॉपी करें और इसे कहीं सुरक्षित रखें।

Upstash QStash सेटअप करना

एक बार लॉग इन होने पर आप QStash टैब पर जाएंगे और QSTASH_URL, QSTASH_TOKEN, QSTASH_CURRENT_SIGNING_KEY, और QSTASH_NEXT_SIGNING_KEY प्राप्त करेंगे। सामग्री को कॉपी करें और इसे कहीं सुरक्षित रखें।

प्रोजेक्ट सेटअप करना

सेटअप करने के लिए, बस ऐप रेपो क्लोन करें और इस ट्यूटोरियल का पालन करके उसमें मौजूद हर चीज को सीखें। प्रोजेक्ट को फोर्क करने के लिए, चलाएं:

git clone https://github.com/rishi-raj-jain/custom-content-ai-chatbot
cd custom-content-ai-chatbot
npm install

एक बार जब आप रेपो क्लोन कर लेते हैं, तो आप एक .env फाइल बनाने जा रहे हैं। आप ऊपर के अनुभागों से सहेजे गए आइटम जोड़ने जा रहे हैं।

यह कुछ इस तरह दिखना चाहिए:

# .env
# ऊपर के चरणों से प्राप्त
# Upstash Redis सीक्रेट्स
UPSTASH_REDIS_REST_URL="https://....upstash.io"
UPSTASH_REDIS_REST_TOKEN="..."
# Upstash QStash सीक्रेट्स
QSTASH_URL="https://qstash.upstash.io/v1/publish/"
QSTASH_TOKEN="..."
QSTASH_CURRENT_SIGNING_KEY="sig_..."
QSTASH_NEXT_SIGNING_KEY="sig_..."
# OpenAI Key
OPENAI_API_KEY="sk-..."
# एडमिन एक्सेस Key
# एक प्रशिक्षण अनुरोध को सत्यापित करने के लिए उपयोग किया जाता है कि इसे केवल एडमिन द्वारा किया जाए
ADMIN_KEY="..."

इन चरणों के बाद, आप निम्न कमांड का उपयोग करके स्थानीय वातावरण शुरू करने में सक्षम होना चाहिए:

npm run dev

रिपॉजिटरी संरचना

यह प्रोजेक्ट के लिए मुख्य फोल्डर संरचना है। मैंने उन फाइलों को लाल रंग में चिह्नित किया है जिन पर इस पोस्ट में आगे चर्चा की जाएगी जो वेक्टर स्टोर प्रबंधन, अपने कस्टम कंटेंट पर प्रशिक्षित AI के साथ चैट करने के लिए API रूट बनाने (प्रतिक्रियाओं को कैश करने के साथ), और मॉडल प्रशिक्षण प्रक्रिया को शेड्यूल करने से संबंधित है।

उच्च-स्तरीय डेटा फ्लो और संचालन

यह डेटा कैसे प्रवाहित होता है और संचालन जो होते हैं उसका एक उच्च-स्तरीय आरेख है 👇🏻

• जब कोई उपयोगकर्ता चैटबॉट के माध्यम से कोई प्रश्न पूछता है, तो उपयोगकर्ता के IP को रेट लिमिटिंग के विरुद्ध जांचा जाता है, और एक प्रतिक्रिया, यदि Upstash Redis के माध्यम से कैश नहीं की गई है, तो OpenAI API से मांगी जाती है (फिर कैश की जाती है) और उपयोगकर्ता को स्ट्रीम की जाती है
• जब कोई एडमिन दिए गए URL के सेट पर मौजूदा मॉडल के प्रशिक्षण का अनुरोध करता है, तो Upstash के QStash की मदद से एक निर्धारित देरी के बाद सर्वरलेस में एक POST अनुरोध दिया गया URL की सामग्री प्राप्त करने और मॉडल को अपडेट करने के लिए किया जाता है (पृष्ठभूमि में)

Next.js में चैट और ट्रेन API रूट सेटअप करें

इस खंड में, हम बात करते हैं कि हमने रूट: pages/api/chat.js को कैसे सेटअप किया है ताकि क्रॉस ओरिजिन अनुरोधों को सक्षम किया जा सके, चैट API कॉल को रेट लिमिट किया जा सके, प्रतिक्रियाओं को कैश और स्ट्रीम किया जा सके, और विशेष URL पर कंटेंट प्रशिक्षण शेड्यूल करने के लिए एक विधि उजागर की जा सके, और pages/api/train.js केवल दिए गए URL पर प्रशिक्षण करने के लिए लेकिन पृष्ठभूमि में।

1. CORS सक्षम करें

cors पैकेज का उपयोग करके, हमने एप्लिकेशन में CORS सक्षम किया है ताकि चैटबॉट का उपयोग कई स्थानों पर किया जा सके, जैसे आपकी वेबसाइट पर एक बॉट के रूप में। जैसे ही API रूट आरंभ होता है, हम नीचे दिए अनुसार cors सेटअप चलाते हैं 👇🏻

// File: pages/api/chat.js
// cors के लिए संदर्भ फ़ंक्शन आयात करें
import { runMiddleware } from '@/lib/cors'
export default async function (req, res) {
  try {
    // मिडलवेयर चलाएं
    await runMiddleware(req, res)
    // ...
  catch (e) {
    console.log(e.message || e.toString())
  }
  return res.end()
}
// Cors फ़ंक्शन
// File: lib/cors.js
import Cors from 'cors'
// cors मिडलवेयर आरंभ करना
// उपलब्ध विकल्पों के बारे में अधिक पढ़ें: https://github.com/expressjs/cors#configuration-options
const cors = Cors({ methods: ['POST', 'OPTIONS', 'HEAD'], })
// मिडलवेयर के निष्पादित होने की प्रतीक्षा करने के लिए हेल्पर मेथड
// और मिडलवेयर में त्रुटि होने पर त्रुटि फेंकने के लिए
export function runMiddleware(req, res, fn = cors) {
  return new Promise((resolve, reject) => {
    fn(req, res, (result) => {
      if (result instanceof Error) return reject(result)
      return resolve(result)
    })
  })
}

2. दिए गए URL पर कंटेंट प्रशिक्षण अनुरोध शेड्यूल करें

Upstash QStash के साथ, कोई ऐसे API बना सकता है जो फायर एंड फॉरगेट की तरह हैं। आपको मुख्य फ़ंक्शन के समाप्त होने की सक्रिय रूप से प्रतीक्षा करने की आवश्यकता नहीं है ताकि प्रतिक्रिया मिल सके बल्कि इसे पृष्ठभूमि में करें (वैकल्पिक रूप से, कुछ दी गई देरी के बाद)। यह क्रॉन-जॉब की तरह है लेकिन जो नियमित अंतराल पर नियमित रूप से नहीं बल्कि प्रत्येक अनुरोध के अनुसार चलता है।

उसी चैट API रूट में, हम एक अनुरोध स्वीकार करते हैं जिसमें admin-key हेडर होता है और यदि वह सर्वर-साइड सीक्रेट (ADMIN_KEY) से मेल खाता है, तो हम अनुरोध बॉडी में पास किए गए URL के सेट पर कुछ देरी (यहां 10s) के बाद कंटेंट प्रशिक्षण शेड्यूल करते हैं। सेट देरी के बाद कंटेंट प्रशिक्षण अनुरोध एक दिए गए एंडपॉइंट (यहां: https://custom-content-ai-chatbot.fly.dev/api/train) पर किया जाता है

// File: pages/api/chat.js
// यदि हेडर में `admin-key` हेडर है
if (req.headers['admin-key'] === process.env.ADMIN_KEY) {
  // यदि बॉडी में `urls` नहीं है, तो `Bad Request` के साथ वापस आएं
  if (!req.body.urls) return res.status(400).send('No urls to train on.')
  // QStash API को हिट करें ताकि इस URL सेट पर 10 सेकंड बाद से प्रशिक्षण हो
  await qstashClient.publishJSON({
    delay: 10,
    body: { urls: req.body.urls },
    url: 'https://custom-content-ai-chatbot.fly.dev/api/train'
  })
  return res.status(200).end()
}

अब, आइए देखें कि ट्रेन API रूट (pages/api/train.js) में क्या है 👇🏻

// File: pages/api/train.js
import train from '@/lib/train'
import * as dotenv from 'dotenv'
import { redis } from '@/lib/redis'
import { runMiddleware } from '@/lib/cors'
import { verifySignature } from '@upstash/qstash/nextjs'
dotenv.process()
// रिक्वेस्ट बॉडी को सीधे JSON में बदलने से अक्षम करना
// अधिक जानकारी के लिए https://nextjs.org/docs/pages/building-your-application/routing/api-routes#custom-config
export const config = { api: { bodyParser: false, }, }
async function handler(req, res) {
  try {
    // मिडलवेयर चलाएं
    await runMiddleware(req, res)
    // यदि मेथड POST नहीं है, तो `Forbidden Access` के साथ वापस आएं
    if (req.method !== 'POST') return res.status(403).send('No other methods allowed.')
    // यदि बॉडी में `urls` नहीं है, तो `Bad Request` के साथ वापस आएं
    if (!req.body.urls) return res.status(400).send('No urls to train on.')
    // विशेष URL पर प्रशिक्षण दें
    await train(req.body.urls)
    // एक बार सहेजे जाने के बाद, Upstash में सभी प्रतिक्रियाएं साफ़ करें
    let allKeys = await redis.keys('*')
    if (allKeys) {
      // रेटलिमिटर से संबंधित कुंजियों को बाहर करने के लिए कुंजियों को फ़िल्टर करें
      allKeys = allKeys.filter((i) => !i.includes('@upstash/ratelimit:'))
      const p = redis.pipeline()
      // सभी कुंजियों को साफ़ करने के लिए एक पाइपलाइन बनाएं
      allKeys.forEach((i) => p.del(i))
      // ट्रांजैक्शन में पाइपलाइन कमांड निष्पादित करें
      await p.exec()
      console.log('Cleaned cached responses in Upstash.')
    }
    return res.status(200).end()
  } catch (e) {
    console.log(e.message || e.toString())
  }
  return res.end()
}
// आने वाले अनुरोध को सत्यापित करें कि यह एक वैध है
// Upstash-Signature के साथ QStash शेड्यूल्ड POST अनुरोध
export default verifySignature(handler)

ऊपर दिए गए कोड में, हम तीन महत्वपूर्ण क्रियाएं कर रहे हैं:

• QStash के verifySignature मेथड का उपयोग करके आने वाले अनुरोध सत्यापन करना। यह नीचे Upstash-Signature हेडर को देखता है और इसे प्राप्त रॉ बॉडी के साथ सत्यापित करता है।
• train फ़ंक्शन को कॉल करना जो URL सामग्री प्राप्त करने और मौजूदा वेक्टर स्टोर में जोड़ने (और इसे सहेजने) का ख्याल रखता है।
• Redis ट्रांजैक्शन के माध्यम से रेट लिमिटिंग के कार्यान्वयन से संबंधित कुंजियों को फ़िल्टर करने के बाद Upstash Redis में कैश की गई प्रतिक्रियाओं को साफ़ करना।

3. रेट लिमिटिंग

रेट-लिमिटिंग लागू करने के लिए, हम Upstash Redis डेटाबेस क्लाइंट और @upstash/ratelimit नामक एक रेट लिमिटर लाइब्रेरी का उपयोग करते हैं।

// File: lib/redis.js
// रेटलिमिटिंग के लिए संदर्भ फ़ंक्शन आयात करें
import * as dotenv from 'dotenv'
import { Redis } from '@upstash/redis'
import { Ratelimit } from '@upstash/ratelimit'
// पर्यावरण चर लोड करें
dotenv.process()
// Upstash Redis आरंभ करें
export const redis = new Redis({
  url: process.env.UPSTASH_REDIS_REST_URL,
  token: process.env.UPSTASH_REDIS_REST_TOKEN,
})
// Upstash रेट लिमिटर आरंभ करें
export const ratelimit = {
  chat: new Ratelimit({
    redis,
    // प्रति IP पते प्रति दिन 30 प्रश्नों तक अनुरोध सीमित करें
    limiter: Ratelimit.slidingWindow(30, '86400s'),
  }),
}

रेट लिमिटिंग का उपयोग करके, मैं सेवा के उपयोग को - पूरी तरह से मुफ्त और सार्वजनिक बनाने में सक्षम था! इसने मुझे सिस्टम के लाभों को प्रदर्शित करने की अनुमति दी यानी चैट प्रतिक्रियाएं। सचमुच कोई भी वेबसाइट के माध्यम से एक दिन में 30 प्रश्न पूछ सकता है। हम IP पते को कुंजी के रूप में आधार पर प्रति दिन 30 प्रश्नों की रेट लिमिट लागू करने में सक्षम हैं।

// File: pages/api/chat.js
import requestIp from 'request-ip'
import { ratelimit } from '@/lib/redis'
// ...
// क्लाइंट IP प्राप्त करें
const detectedIp = requestIp.getClientIp(req)
// यदि कोई IP नहीं मिला, तो `Bad Request` के साथ वापस आएं
if (!detectedIp) return res.status(400).send('Bad request.')
// रेट लिमिट जांचें
const result = await ratelimit.chat.limit(detectedIp)
// यदि रेट लिमिटेड, तो उसी के साथ वापस आएं
if (!result.success) return res.status(400).send('Rate limit exceeded.')
// चैट प्रतिक्रियाएं सर्व करने के साथ जारी रखें

4. सहेजे गए इंडेक्स वेक्टर स्टोर लोड करें और OpenAI से प्रतिक्रियाएं मांगें

सभी जांच हो जाने के बाद, अब हम मुख्य काम पर जा रहे हैं - हमारे कस्टम कंटेंट के साथ OpenAI API को कॉल करना और उपयोगकर्ता को प्रतिक्रिया भेजना। चीजों को सरल बनाने के लिए, हम इसे और भागों में विभाजित करेंगे:

• 3.1: सहेजे गए वेक्टर स्टोर को पुनर्प्राप्त करना

// File: pages/api/chat.js
// loadVectorStore के लिए संदर्भ फ़ंक्शन आयात करें
import { loadVectorStore } from '@/lib/vectorStore'
// प्रशिक्षित मॉडल लोड करें
const vectorStore = await loadVectorStore()
// ...
// वेक्टर स्टोर फ़ंक्शन
// File: lib/vectorStore.js
import { join } from 'path'
import { existsSync } from 'fs'
import { Document } from 'langchain/document'
import { FaissStore } from 'langchain/vectorstores/faiss'
import { OpenAIEmbeddings } from 'langchain/embeddings/openai'
export async function loadVectorStore() {
  const directory = join(process.cwd(), 'loadedVectorStore')
  const docStoreJSON = join(process.cwd(), 'loadedVectorStore', 'docstore.json')
  if (existsSync(docStoreJSON)) {
    // यदि डायरेक्टरी मिली, तो Faiss एकीकरण द्वारा सहेजे गए वेक्टर स्टोर को लोड करें
    return await FaissStore.load(directory, new OpenAIEmbeddings())
  } else {
    // यदि कोई सामग्री नहीं है, तो केवल `Hey` के साथ वेक्टर स्टोर लोड करें शुरुआत के लिए
    return await FaissStore.fromDocuments([new Document({ pageContent: 'Hey' })], new OpenAIEmbeddings())
  }
}

• 3.2: उपयोगकर्ता क्वेरी में प्रॉम्प्ट दिशानिर्देश जोड़ना

LangChain द्वारा PromptTemplate का उपयोग करके, उपयोगकर्ता क्वेरी के साथ हम निर्देश पास करते हैं कि कैसे और किस तरीके से AI को प्रश्न का उत्तर देना चाहिए:

// File: pages/api/chat.js
import { z } from 'zod'
import { PromptTemplate } from 'langchain/prompts'
import { RetrievalQAChain } from 'langchain/chains'
import { OutputFixingParser, StructuredOutputParser } from 'langchain/output_parsers'
// प्रशिक्षित मॉडल लोड करें
// ...
// OpenAI के लिए क्या लिखना है यह निर्दिष्ट करने के लिए एक प्रॉम्प्ट बनाएं
const outputParser = StructuredOutputParser.fromZodSchema(
  z.object({
    answer: z.string().describe('answer to question in HTML friendly format, use all of the tags wherever possible and including reference links'),
  }),
)
// ...
// OpenAI की प्रतिक्रिया को परिष्कृत करने में मदद करने के लिए आउटपुट पार्सर क्लास का एक इंस्टेंस बनाएं
const outputFixingParser = OutputFixingParser.fromLLM(model, outputParser)
// इनपुट पर कैसे प्रोसेस करना है यह निर्दिष्ट करने के लिए OpenAI के लिए एक प्रॉम्प्ट बनाएं
const prompt = new PromptTemplate({
  template: `Answer the user's question as best and be as detailed as possible:\n{format_instructions}\n{query}`,
  inputVariables: ['query'],
  partialVariables: { format_instructions: outputFixingParser.getFormatInstructions(), },
})
// मॉडल के साथ क्वेरी में प्रॉम्प्ट पास करें OpenAI API को
const chain = RetrievalQAChain.fromLLM(model, vectorStore.asRetriever(), prompt)

• 3.3: प्रतिक्रियाओं को स्ट्रीम और कैश करें

Upstash Redis के साथ प्रतिक्रियाओं को कैश करने के लिए, हम LangChain द्वारा UpstashRedisCache कैश लाइब्रेरी का उपयोग करेंगे। हम मौजूदा Redis इंस्टेंस को क्लाइंट के रूप में पास करते हैं, और कैशिंग हैंडलर को ChatOpenAI रैपर को पास करते हैं ताकि प्रतिक्रियाएं वितरित होने के बाद इसे कैश करने के लिए उपयोग किया जा सके:

// File: pages/api/chat.js
import { redis } from '@/lib/redis'
import { ChatOpenAI } from 'langchain/chat_models/openai'
import { UpstashRedisCache } from 'langchain/cache/upstash_redis'
// प्रशिक्षित मॉडल लोड करें
// ...
// Upstash कैशिंग बनाएं
const upstashRedisCache = new UpstashRedisCache({ client: redis })
// एक फ्लैग यह पता लगाने के लिए कि प्रतिक्रिया कैश नहीं थी
let doesToken = false
const model = new ChatOpenAI({
  // उपयोगकर्ता को जितनी जल्दी संभव हो प्रतिक्रिया वापस करने के लिए स्ट्रीमिंग सक्षम करें
  streaming: true,
  // Upstash Redis कैश क्लाइंट का उपयोग करके प्रतिक्रियाओं को कैश करें
  cache: upstashRedisCache,
  callbacks: [
    {
      handleLLMNewToken(token) {
        // यदि हमें OpenAI से स्ट्रीम प्राप्त होता है तो फ्लैग को true पर सेट करें
        doesToken = true
        // टोकन को उपयोगकर्ता को स्ट्रीम करें
        res.write(token)
      },
    },
  ],
})
// LLM QA चेन बनाएं
// ...
// आउटपुट को संग्रहीत करें ताकि कैश होने के मामले में संदर्भित किया जा सके
const chainOutput = await chain.call({ query: req.body.input })
// यदि कोई टोकन प्राप्त नहीं हुआ तो इसका तात्पर्य है कि सामग्री कैश है
// कैश की गई प्रतिक्रिया को वैसे ही वापस करें
if (!doesToken) return res.status(200).send(chainOutput.text)

यह बहुत सीखने वाला था! अब आप पूरा कर चुके हैं।

Fly.io पर तैनात करें

रिपॉजिटरी Fly.io के लिए एक बेक्ड-इन सेटअप के साथ आती है, विशेष रूप से निम्नलिखित से संबंधित:

• Dockerfile
• fly.toml
• .dockerignore

तैनाती के लिए Fly.io पर एक खाते की आवश्यकता होती है। एक बार आपके पास खाता होने पर, आप अपने प्रोजेक्ट के रूट फोल्डर में निम्न कमांड चलाकर Fly.io में एक ऐप बना सकते हैं:

# अपने खाते में बेक्ड-इन कॉन्फिगरेशन के आधार पर एक ऐप बनाएं
# इसका परिणाम केवल मौजूदा fly.toml में ऐप नाम के परिवर्तन में होगा
fly launch

और इसके माध्यम से तैनात करें 👇🏻

# ऊपर बनाई गई कॉन्फिगरेशन के आधार पर ऐप तैनात करें
fly deploy

अब हम तैनाती के साथ हो चुके हैं! हां, बस इतना ही था।

निष्कर्ष

अंत में, इस प्रोजेक्ट ने OpenAI प्रतिक्रिया कैशिंग, रेट लिमिटिंग, और मॉडल को प्रशिक्षित करने के लिए शेड्यूल्ड API अनुरोधों को लागू करने में मूल्यवान अनुभव प्रदान किया है, वह भी एक ऐसी सेवा का उपयोग करते हुए जो आपकी आवश्यकता के साथ स्केल होती है, यानी Upstash।

Next.js, Redis, TailwindCSS, LangChain, Serverless Scheduling