LangServe के साथ LLM अनुप्रयोगों की डिप्लॉयमेंट: चरण-दर-चरण मार्गदर्शिका

किसी बड़े भाषा मॉडल (LLM) को प्रोडक्शन में डिप्लॉय करना आपके अनुप्रयोग को बदल सकता है, प्राकृतिक भाषा की समझ और जनरेशन में उन्नत क्षमताएँ प्रदान करते हुए। हालांकि, यह प्रक्रिया चुनौतियों से भरी होती है, जो अनुभवी डेवलपर्स की राह भी कठिन बना सकती हैं।

इस गाइड में, हम LangServe का उपयोग करके LLM अनुप्रयोगों को डिप्लॉय करना सीखेंगे—यह एक ऐसा टूल है जो इस जटिल प्रक्रिया को सरल और सुव्यवस्थित करने के लिए बनाया गया है। इंस्टॉलेशन से लेकर इंटीग्रेशन तक, आप LLM को सफलतापूर्वक लागू करने के आवश्यक चरणों को समझेंगे और उसकी पूरी क्षमता का लाभ उठाएँगे।

LLM-आधारित अनुप्रयोग बनाने में आने वाली चुनौतियाँ

LLM-आधारित अनुप्रयोग बनाना सिर्फ एक API कॉल करने से कहीं अधिक जटिल है। किसी प्रोजेक्ट में LLM को जोड़ना उसकी क्षमताओं को काफी बढ़ा सकता है, लेकिन इसके साथ कुछ विशिष्ट चुनौतियाँ आती हैं, जिनपर सावधानी से विचार करना जरूरी है। नीचे हम उन प्रमुख बाधाओं को तोड़कर समझेंगे जिनका आप सामना कर सकते हैं, और डिप्लॉयमेंट के वे पहलू जिनपर ध्यान देने की आवश्यकता है।

मॉडल का चयन और अनुकूलन

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

संसाधन प्रबंधन

LLMs कंप्यूटेशन-इंटेंसिव होते हैं और बड़े संसाधनों की माँग करते हैं। आपकी इंफ्रास्ट्रक्चर उच्च मेमोरी और प्रोसेसिंग पावर की आवश्यकताओं को संभाल सके, यह सुनिश्चित करना आवश्यक है। इसमें भविष्य की वृद्धि और उपयोग में संभावित बढ़ोतरी को समायोजित करने के लिए स्केलेबिलिटी की योजना बनाना भी शामिल है।

विलंबता और प्रदर्शन

बेहतरीन उपयोगकर्ता अनुभव के लिए कम विलंबता प्राप्त करना महत्वपूर्ण है। भारी लोड के दौरान LLMs अनुरोधों को संसाधित करने में धीमे हो सकते हैं। प्रदर्शन का अनुकूलन मॉडल कम्प्रेशन, कुशल सर्विंग फ्रेमवर्क, और संभवतः कुछ प्रोसेसिंग कार्यों को एज डिवाइसेज़ पर ऑफलोड करने जैसी रणनीतियों से होता है।

निगरानी और मेंटेनेंस

डिप्लॉयमेंट के बाद LLM अनुप्रयोग की सतत निगरानी आवश्यक है। इसमें प्रदर्शन मेट्रिक्स को ट्रैक करना, विषंगतियों का पता लगाना, और मॉडल ड्रिफ्ट को प्रबंधित करना शामिल है। नियमित मेंटेनेंस समय के साथ मॉडल की सटीकता और दक्षता बनाए रखता है, जिसके लिए समय-समय पर अपडेट और नए डेटा के साथ पुनः-प्रशिक्षण जरूरी होता है।

इंटीग्रेशन और संगतता

LLMs को मौजूदा सिस्टम और वर्कफ़्लो के साथ इंटीग्रेट करना चुनौतीपूर्ण हो सकता है। विभिन्न सॉफ़्टवेयर वातावरणों, APIs, और डेटा फ़ॉर्मैट्स के साथ संगतता सुनिश्चित करने के लिए सूक्ष्म योजना और निष्पादन की आवश्यकता होती है। निर्बाध इंटीग्रेशन आपके अनुप्रयोग में LLMs की पूरी क्षमता का लाभ उठाने की कुंजी है।

लागत प्रबंधन

LLMs की उच्च कंप्यूटेशनल माँगें परिचालन लागत को काफी बढ़ा सकती हैं। प्रदर्शन और लागत-दक्षता के बीच संतुलन बनाना एक महत्वपूर्ण विचार है। लागत प्रबंधन के लिए रणनीतियों में संसाधन आवंटन का अनुकूलन, लागत-प्रभावी क्लाउड सेवाओं का उपयोग, और बचत की संभावनाएँ पहचानने के लिए उपयोग पैटर्न की नियमित समीक्षा शामिल हैं।

प्रोडक्शन में LLMs डिप्लॉय करने के बारे में क्या जानना आवश्यक है

किसी LLM को प्रोडक्शन में डिप्लॉय करना कई सिस्टम और घटकों के समन्वय वाली जटिल प्रक्रिया है। यह सिर्फ एक शक्तिशाली भाषा मॉडल को आपके अनुप्रयोग में जोड़ने तक सीमित नहीं है; इसके लिए एक समेकित इंफ्रास्ट्रक्चर चाहिए, जहाँ हर हिस्सा महत्वपूर्ण भूमिका निभाता है।

एक LLM अनुप्रयोग की संरचना

LLM अनुप्रयोगों की डिप्लॉयमेंट की बारीकियों को समझने के लिए इसमें शामिल विभिन्न घटकों और उनकी पारस्परिक क्रियाओं का अध्ययन करना आवश्यक है। नीचे दिया गया आरेख एक आधुनिक LLM अनुप्रयोग की आर्किटेक्चर को दर्शाता है, जो सिस्टम के प्रमुख तत्वों और उनके रिश्तों को रेखांकित करता है।

एक आधुनिक LLM अनुप्रयोग की आर्किटेक्चर दर्शाने वाला आरेख। स्रोत

किसी LLM अनुप्रयोग की आर्किटेक्चर को कई मूलभूत पहलुओं में बाँटा जा सकता है:

वेक्टर डेटाबेस

वेक्टर डेटाबेस LLMs द्वारा उत्पन्न उच्च-आयामी डेटा के प्रबंधन के लिए बुनियादी हैं। ये डेटाबेस वेक्टरों को कुशलतापूर्वक स्टोर और रिट्रीव करते हैं, जिससे तेज और सटीक समानता खोज संभव होती है। ये सेमांटिक सर्च, रिकमेंडेशन सिस्टम, और वैयक्तिकृत उपयोगकर्ता अनुभव जैसे अनुप्रयोगों के लिए अपरिहार्य हैं।

LLMs डिप्लॉय करते समय, प्रदर्शन और प्रत्युत्तर क्षमता बनाए रखने के लिए ऐसे मज़बूत वेक्टर डेटाबेस का चयन करना महत्वपूर्ण है जो आपके अनुप्रयोग के साथ स्केल कर सके।

प्रॉम्प्ट टेम्पलेट्स

प्रॉम्प्ट टेम्पलेट्स पूर्व-परिभाषित संरचनाएँ हैं जो LLM के साथ इंटरेक्शंस को मानकीकृत करने में मदद करती हैं। ये मॉडल द्वारा जनरेट किए गए उत्तरों में निरंतरता और विश्वसनीयता सुनिश्चित करते हैं।

प्रभावी प्रॉम्प्ट टेम्पलेट्स का डिज़ाइन मॉडल की बारीकियों और आपके अनुप्रयोग की विशिष्ट आवश्यकताओं को समझने पर निर्भर करता है। अच्छे से बनाए गए टेम्पलेट्स आउटपुट की गुणवत्ता और प्रासंगिकता को काफी बढ़ा सकते हैं, जिससे उपयोगकर्ता संतुष्टि में वृद्धि होती है।

ऑर्केस्ट्रेशन और वर्कफ़्लो प्रबंधन

एक LLM अनुप्रयोग को डिप्लॉय करना डेटा प्री-प्रोसेसिंग, मॉडल इन्फ़रेंस, और पोस्ट-प्रोसेसिंग जैसे विभिन्न कार्यों के समन्वय को शामिल करता है। वर्कफ़्लो प्रबंधन टूल्स और ऑर्केस्ट्रेशन फ्रेमवर्क (जैसे Apache Airflow या Kubernetes) इन प्रक्रियाओं को स्वचालित और सुव्यवस्थित करने में मदद करते हैं। ये सुनिश्चित करते हैं कि प्रत्येक घटक सुचारू और कुशलता से कार्य करे, जिससे त्रुटियों और डाउनटाइम का जोखिम कम हो।

इंफ्रास्ट्रक्चर और स्केलेबिलिटी

आपके LLM अनुप्रयोग का समर्थन करने वाली इंफ्रास्ट्रक्चर मज़बूत और स्केलेबल होनी चाहिए। इसमें क्लाउड सेवाएँ, हार्डवेयर एक्सीलरेटर (जैसे GPUs या TPUs) और नेटवर्किंग क्षमताएँ शामिल हैं। स्केलेबिलिटी यह सुनिश्चित करती है कि आपका अनुप्रयोग बढ़ते लोड और उपयोगकर्ता माँग को बिना प्रदर्शन से समझौता किए संभाल सके।

ऑटो-स्केलिंग नीतियों और लोड-बैलेंसिंग रणनीतियों का उपयोग संसाधनों का प्रभावी प्रबंधन करने और सेवा गुणवत्ता बनाए रखने में मदद कर सकता है।

निगरानी और लॉगिंग

आपके LLM अनुप्रयोग के स्वास्थ्य और प्रदर्शन को बनाए रखने के लिए सतत निगरानी और लॉगिंग महत्वपूर्ण हैं। मॉनिटरिंग टूल्स सिस्टम प्रदर्शन, उपयोग पैटर्न, और संभावित समस्याओं पर रीयल-टाइम इनसाइट्स प्रदान करते हैं।

लॉगिंग मैकेनिज़्म अनुप्रयोग के संचालन के बारे में विस्तृत जानकारी कैप्चर करते हैं, जो डीबगिंग और ऑप्टिमाइज़ेशन के लिए अनमोल होती है। साथ मिलकर, ये सुनिश्चित करते हैं कि आपका अनुप्रयोग सुचारू रूप से चले और किसी भी बदलाव या विषंगति के लिए तेजी से अनुकूल हो सके।

सुरक्षा और अनुपालन

LLMs को डिप्लॉय करना सुरक्षा और अनुपालन आवश्यकताओं को संबोधित करना भी शामिल करता है। इसमें संवेदनशील डेटा की सुरक्षा, एक्सेस नियंत्रण लागू करना, और GDPR या HIPAA जैसी प्रासंगिक विनियमों के अनुपालन को सुनिश्चित करना शामिल है। सुरक्षा उपायों को डिप्लॉयमेंट प्रक्रिया की हर परत में एकीकृत किया जाना चाहिए ताकि डेटा उल्लंघन और अनधिकृत एक्सेस से बचाव हो सके।

मौजूदा सिस्टम के साथ इंटीग्रेशन

आपका LLM अनुप्रयोग मौजूदा सिस्टम और वर्कफ़्लो के साथ निर्बाध रूप से इंटीग्रेट होना चाहिए। इसमें आपके संगठन में उपयोग होने वाले अन्य सॉफ़्टवेयर टूल्स, APIs, और डेटा फ़ॉर्मैट्स के साथ संगतता सुनिश्चित करना शामिल है।

प्रभावी इंटीग्रेशन आपके अनुप्रयोग की समग्र कार्यक्षमता और दक्षता बढ़ाता है, जिससे वह मौजूदा संसाधनों और इंफ्रास्ट्रक्चर का लाभ उठा सके।

प्रोडक्शन में LLMs डिप्लॉय करने के विभिन्न तरीके

LLMs को प्रोडक्शन में डिप्लॉय करने के कई तरीके हैं, और प्रत्येक के अपने फायदे और चुनौतियाँ हैं।

ऑन-प्रिमाइसेस डिप्लॉयमेंट में LLM को स्थानीय सर्वर या डेटा सेंटर पर होस्ट किया जाता है, जो डेटा और इंफ्रास्ट्रक्चर पर अधिक नियंत्रण देता है, लेकिन हार्डवेयर और मेंटेनेंस में पर्याप्त निवेश की आवश्यकता होती है।

क्लाउड-आधारित डिप्लॉयमेंट में क्लाउड सेवाओं का उपयोग करके LLM होस्ट किया जाता है, जो स्केलेबिलिटी, लचीलापन, और कम अग्रिम लागत प्रदान करता है, हालाँकि यह डेटा गोपनीयता और चल रही परिचालन लागतों के बारे में चिंताएँ पैदा कर सकता है।

हाइब्रिड डिप्लॉयमेंट ऑन-प्रिमाइसेस और क्लाउड संसाधनों को मिलाता है, नियंत्रण और स्केलेबिलिटी के बीच संतुलन प्रदान करता है, और संगठनों को अपनी विशिष्ट आवश्यकताओं के आधार पर प्रदर्शन और लागत का अनुकूलन करने देता है।

प्रत्येक दृष्टिकोण के लाभ-हानि समझना आपके संगठन के लक्ष्यों और संसाधनों के अनुरूप सूचित निर्णय लेने के लिए आवश्यक है।

LLMs को प्रोडक्शन-रेडी बनाने के शीर्ष टूल्स

बड़े भाषा मॉडलों (LLMs) को प्रोडक्शन में डिप्लॉय करने के लिए टूल्स का एक सूट चाहिए जो इंफ्रास्ट्रक्चर प्रबंधन से लेकर मॉनिटरिंग और ऑप्टिमाइज़ेशन तक डिप्लॉयमेंट प्रक्रिया के विभिन्न पहलुओं को संभाल सके। इस खंड में, हम पाँच शीर्ष टूल्स पर चर्चा करते हैं जो LLMs की डिप्लॉयमेंट में व्यापक रूप से उपयोग किए जाते हैं।

प्रत्येक टूल का मूल्यांकन स्केलेबिलिटी, उपयोग में सरलता, इंटीग्रेशन क्षमताओं, और लागत-प्रभावशीलता के आधार पर किया गया है।

LangServe

LangServe विशेष रूप से LLM अनुप्रयोगों की डिप्लॉयमेंट के लिए डिज़ाइन किया गया है। यह इंस्टॉलेशन, इंटीग्रेशन और ऑप्टिमाइज़ेशन के लिए सशक्त टूल्स प्रदान करके डिप्लॉयमेंट प्रक्रिया को सरल बनाता है। LangServe विभिन्न LLMs को सपोर्ट करता है और मौजूदा सिस्टम के साथ निर्बाध इंटीग्रेशन देता है।

स्केलेबिलिटी: उच्च
उपयोग में सरलता: उच्च
इंटीग्रेशन क्षमताएँ: उत्कृष्ट
लागत-प्रभावशीलता: मध्यम

Kubernetes

Kubernetes एक ओपन-सोर्स कंटेनर ऑर्केस्ट्रेशन प्लेटफ़ॉर्म है जो कंटेनराइज़्ड अनुप्रयोगों की डिप्लॉयमेंट, स्केलिंग और प्रबंधन को स्वचालित करता है। यह अत्यंत लचीला है और LLM डिप्लॉयमेंट के लिए आवश्यक इंफ्रास्ट्रक्चर को प्रबंधित करने में इस्तेमाल किया जा सकता है।

स्केलेबिलिटी: उच्च
उपयोग में सरलता: मध्यम
इंटीग्रेशन क्षमताएँ: उत्कृष्ट
लागत-प्रभावशीलता: उच्च (ओपन सोर्स)

TensorFlow Serving

TensorFlow Serving प्रोडक्शन वातावरण के लिए डिज़ाइन किया गया, मशीन लर्निंग मॉडलों के लिए एक लचीला, उच्च-प्रदर्शन सर्विंग सिस्टम है। यह समान सर्वर आर्किटेक्चर और APIs बनाए रखते हुए नए एल्गोरिद्म और प्रयोगों को डिप्लॉय करना आसान बनाता है।

स्केलेबिलिटी: उच्च
उपयोग में सरलता: मध्यम
इंटीग्रेशन क्षमताएँ: उत्कृष्ट
लागत-प्रभावशीलता: उच्च (ओपन सोर्स)

Amazon SageMaker

Amazon SageMaker एक पूर्ण-प्रबंधित सेवा है जो हर डेवलपर और डेटा वैज्ञानिक को मशीन लर्निंग मॉडल तेज़ी से बनाने, ट्रेन करने और डिप्लॉय करने की क्षमता देती है। यह अन्य AWS सेवाओं के साथ इंटीग्रेट होता है, जिससे यह LLM डिप्लॉयमेंट के लिए एक व्यापक टूल बनता है।

स्केलेबिलिटी: उच्च
उपयोग में सरलता: उच्च
इंटीग्रेशन क्षमताएँ: उत्कृष्ट (AWS इकोसिस्टम के साथ)
लागत-प्रभावशीलता: मध्यम से उच्च (उपयोग पर निर्भर)

MLflow

MLflow एक ओपन-सोर्स प्लेटफ़ॉर्म है जो ML जीवनचक्र—एक्सपेरिमेंटेशन, रिप्रोड्यूसिबिलिटी और डिप्लॉयमेंट—का प्रबंधन करता है। यह मॉडलों के लिए एक केंद्रीय रिपॉज़िटरी प्रदान करता है और कई मशीन लर्निंग लाइब्रेरीज़ के साथ इंटीग्रेट किया जा सकता है।

स्केलेबिलिटी: मध्यम से उच्च
उपयोग में सरलता: मध्यम
इंटीग्रेशन क्षमताएँ: उत्कृष्ट
लागत-प्रभावशीलता: उच्च (ओपन सोर्स)

सारांश

टूल	स्केलेबिलिटी	उपयोग में सरलता	इंटीग्रेशन क्षमताएँ	लागत-प्रभावशीलता
LangServe	उच्च	उच्च	उत्कृष्ट	मध्यम
Kubernetes	उच्च	मध्यम	उत्कृष्ट	उच्च (ओपन सोर्स)
TensorFlow Serving	उच्च	मध्यम	उत्कृष्ट	उच्च (ओपन सोर्स)
Amazon SageMaker	उच्च	उच्च	उत्कृष्ट (AWS के साथ)	मध्यम से उच्च
MLflow	मध्यम से उच्च	मध्यम	उत्कृष्ट	उच्च (ओपन सोर्स)

LangServe का उपयोग करके LLM अनुप्रयोग डिप्लॉय करना

LangServe एक विशिष्ट टूल है जो LLM अनुप्रयोगों की डिप्लॉयमेंट प्रक्रिया को सरल बनाने के लिए बनाया गया है। इस खंड में, हम एक टेक्निकल वॉकथ्रू देंगे कि कैसे LangServe का उपयोग करके टेक्स्ट का सारांश बनाने वाला chatGPT अनुप्रयोग डिप्लॉय किया जाए।

1. इंस्टॉलेशन

शुरू करने के लिए, हमें LangServe इंस्टॉल करना होगा। आपकी आवश्यकता के अनुसार आप क्लाइंट और सर्वर दोनों कंपोनेंट्स या केवल किसी एक को इंस्टॉल कर सकते हैं।

pip install "langserve[all]"संचालित द्वारा

वैकल्पिक रूप से, आप कंपोनेंट्स को अलग-अलग भी इंस्टॉल कर सकते हैं:

install "langserve[client]"संचालित द्वारा

install "langserve[server]"संचालित द्वारा

LangChain CLI किसी LangServe प्रोजेक्ट को जल्दी बूटस्ट्रैप करने के लिए उपयोगी टूल है। सुनिश्चित करें कि आपके पास इसका हालिया संस्करण इंस्टॉल हो:

install -U langchain-cliसंचालित द्वारा

2. सेटअप

2.1 नया ऐप बनाएँ

LangChain CLI का उपयोग करके एक नया अनुप्रयोग बनाएँ, और अपना वर्तमान वर्किंग डायरेक्टरी my-app में बदलें:

app new my-appसंचालित द्वारा

my-appसंचालित द्वारा

2.2 Poetry के साथ थर्ड-पार्टी पैकेज जोड़ें

LangServe निर्भरता प्रबंधन के लिए Poetry का उपयोग करता है। यदि आप Poetry से परिचित नहीं हैं, तो अधिक जानकारी के लिए Poetry प्रलेखन देखें।

संबंधित पैकेज जोड़ने के लिए यह कमांड उपयोग करें:

add langchain-openai langchain langchain communityसंचालित द्वारा

यह कमांड हमारे प्रोजेक्ट के लिए सभी आवश्यक निर्भरताओं की उपलब्धता सुनिश्चित करता है।

2.3 वातावरण चर सेट करें

सुनिश्चित करें कि आप हमारे अनुप्रयोग के लिए आवश्यक वातावरण चर सेट करें। इस मामले में, मान्य अनुरोध भेजने के लिए हमें अपना OpenAI API कुंजी सेट करनी होगी:

OPENAI_API_KEY="sk-..."संचालित द्वारा

“sk-...” को अपनी वास्तविक API कुंजी से बदलना न भूलें। आप OpenAI प्लेटफ़ॉर्म पर API कुंजी बना सकते हैं।

3. सर्वर

```server.py``` फ़ाइल पर जाएँ। इसमें हमारे LangServe अनुप्रयोग का मुख्य लॉजिक होगा। नीचे OpenAI के भाषा मॉडल का उपयोग करके टेक्स्ट का सारांश बनाने के लिए एक रूट शामिल करने वाले साधारण LangServe अनुप्रयोग का उदाहरण दिया गया है:

fastapi import FastAPI
from langchain.prompts import ChatPromptTemplate
from langchain.chat_models import ChatOpenAI
from langserve import add_routes
app = FastAPI(
	title="LangChain Server",
	version="1.0",
	description="A simple API server using Langchain's Runnable interfaces",
)
# Define a route for the OpenAI chat model
add_routes(
	app,
	ChatOpenAI(),
	path="/openai",
)
# Define a route with a custom prompt
summarize_prompt = ChatPromptTemplate.from_template("Summarize the following text: {text}")
add_routes(
	app,
	summarize_prompt | ChatOpenAI(),
	path="/summarize",
)
if __name__ == "__main__":
	import uvicorn
	uvicorn.run(app, host="localhost", port=8000)संचालित द्वारा

आइए हमारे बेसिक LangServe अनुप्रयोग के प्रमुख घटकों पर क़रीबी नज़र डालें:

3.1 आवश्यक मॉड्यूल इम्पोर्ट करें

FastAPI वेब सर्वर बनाने के लिए उपयोग होता है।
ChatPromptTemplate और ChatOpenAI प्रॉम्प्ट और मॉडल परिभाषित करने के लिए LangChain से उपयोग होते हैं।
LangServe का add_routes FastAPI ऐप में रूट्स जोड़ने के लिए उपयोग होता है।

3.2 FastAPI ऐप इनिशियलाइज़ करें

FastAPI ऐप को शीर्षक, संस्करण, और विवरण जैसे मेटाडेटा के साथ इनिशियलाइज़ किया जाता है।

3.3 रूट्स जोड़ें

पहला add_routes कॉल /openai रूट जोड़ता है, जो सीधे OpenAI के चैट मॉडल से इंटरफ़ेस करता है।
दूसरा add_routes कॉल कस्टम प्रॉम्प्ट रूट /summarize परिभाषित करता है। यह रूट इनपुट टेक्स्ट लेता है और OpenAI के मॉडल का उपयोग करके टेक्स्ट का संक्षिप्त संस्करण जनरेट करने के लिए एक प्रॉम्प्ट का उपयोग करता है।

4. सर्वर चलाएँ

uvicorn.run फ़ंक्शन का उपयोग localhost पर पोर्ट 8000 के साथ FastAPI सर्वर शुरू करने के लिए किया जाता है।

इस उदाहरण में, हमने /summarize रूट जोड़ा है जो प्रॉम्प्ट का उपयोग करके टेक्स्ट का सारांश बनाता है। आप अतिरिक्त रूट्स और प्रॉम्प्ट्स परिभाषित करके अपने LangServe अनुप्रयोग की कार्यक्षमता बढ़ा सकते हैं। उदाहरण के लिए:

joke_prompt = ChatPromptTemplate.from_template("Tell me a joke about {topic}")
add_routes(
            app,
            joke_prompt | ChatOpenAI(),
            path="/joke",
)
संचालित द्वारा

5. अपने अनुप्रयोग को सर्व करें

अंत में, इच्छित पोर्ट पर अपना अनुप्रयोग सर्व करने के लिए Poetry का उपयोग करें:

run langchain serve --port=8100संचालित द्वारा

यदि सब कुछ सही से सेटअप है, तो आपको अपने टर्मिनल में कुछ इस तरह का आउटपुट दिखाई देगा:

LangServe अनुप्रयोग के सफल स्टार्टअप को दर्शाता टर्मिनल आउटपुट।

अब आप अपने ब्राउज़र में http://127.0.0.1:8100/summarize/playground/ पर जा सकते हैं। यह URL एक यूज़र-फ़्रेंडली इंटरफ़ेस प्रदान करता है जहाँ आप अपने अनुप्रयोग का परीक्षण कर सकते हैं। T

he प्लेग्राउंड आपको अपना रननेबल चलाने, स्ट्रीमिंग आउटपुट देखने, और मध्यवर्ती चरणों का अवलोकन करने में सक्षम बनाता है, जिससे आपके डिप्लॉय किए गए LLM अनुप्रयोग के साथ आसान इंटरेक्शन और डीबगिंग संभव होती है।

LangServe प्लेग्राउंड UI का उदाहरण

इसके अतिरिक्त, आप http://127.0.0.1:8100/docs पर जाकर FastAPI द्वारा प्रदान किया गया स्वचालित रूप से जनरेटेड API प्रलेखन एक्सेस कर सकते हैं।

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

LangServe का उपयोग करके LLM अनुप्रयोग की निगरानी

प्रोडक्शन में किसी बड़े भाषा मॉडल (LLM) अनुप्रयोग की विश्वसनीयता, प्रदर्शन, और सटीकता सुनिश्चित करना अत्यंत महत्वपूर्ण है। हालाँकि LangServe में बिल्ट-इन मॉनिटरिंग फीचर्स नहीं हैं, यह अनुप्रयोग के स्वास्थ्य को ट्रैक और विश्लेषित करने के लिए व्यापक रूप से उपयोग होने वाले टूल्स के साथ सहजता से इंटीग्रेट हो जाता है।

यह खंड बताता है कि इन टूल्स के साथ मिलकर LangServe का उपयोग करके किसी LLM अनुप्रयोग को कैसे बनाए रखें और उसपर निगरानी रखें।

1. लॉगिंग सेटअप करना

लॉगिंग आपके LLM अनुप्रयोग की मॉनिटरिंग का पहला कदम है। यह अनुप्रयोग के व्यवहार को ट्रैक करने और किसी भी विषंगति की पहचान करने में मदद करता है। यहाँ बताया गया है कि LangServe के साथ अपने FastAPI अनुप्रयोग में लॉगिंग कैसे सेट करें:

import logging

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("langchain_server")

app = FastAPI()

# Example of logging within a route
@app.get("/status")
async def status():
	logger.info("Status endpoint was called")
	return {"status": "Running"}
संचालित द्वारा

इस सेटअप के साथ, /status एंडपॉइंट को हर कॉल एक संदेश लॉग करेगी जो दर्शाएगी कि एंडपॉइंट एक्सेस किया गया था। इसे अन्य महत्वपूर्ण घटनाओं और त्रुटियों को लॉग करने के लिए बढ़ाया जा सकता है।

2. मेट्रिक्स के लिए Prometheus इंटीग्रेशन

Prometheus मॉनिटरिंग और अलर्टिंग के लिए एक लोकप्रिय टूल है। इसे FastAPI के साथ इंटीग्रेट करके मेट्रिक्स एकत्र किए जा सकते हैं और अनुप्रयोग के प्रदर्शन में अंतर्दृष्टि मिल सकती है। यहाँ बताया गया है कि LangServe के साथ Prometheus कैसे सेट करें:

2.1 Prometheus क्लाइंट इंस्टॉल करें

install prometheus_clientसंचालित द्वारा

2.2 Prometheus मिडलवेयर शामिल करने के लिए server.py अपडेट करें

import time
from prometheus_client import start_http_server, Summary
from fastapi.middleware import Middleware

# Start Prometheus server
start_http_server(8001)

# Define a Prometheus metric
REQUEST_TIME = Summary('request_processing_seconds', 'Time spent processing request')

app = FastAPI()

# Middleware for tracking request processing time
@app.middleware("http")
async def add_prometheus_middleware(request: Request, call_next):
	start_time = time.time()
	response = await call_next(request)
	duration = time.time() - start_time
	REQUEST_TIME.observe(duration)
	return response
संचालित द्वारा

यह सेटअप पोर्ट 8001 पर एक Prometheus सर्वर शुरू करेगा और प्रत्येक अनुरोध को संसाधित करने में लगे समय को ट्रैक करेगा।

Prometheus और Grafana के साथ अलर्ट्स सेट करना

Prometheus को कुछ शर्तों के आधार पर अलर्ट ट्रिगर करने के लिए कॉन्फ़िगर किया जा सकता है, और Grafana का उपयोग इन मेट्रिक्स को विजुअलाइज़ करने के लिए किया जा सकता है। अलर्ट्स सेट करने के लिए एक संक्षिप्त रूपरेखा यहाँ दी गई है:

3.1 Prometheus अलर्ट नियम कॉन्फ़िगर करें

alert.rules नामक फ़ाइल बनाएँ:

groups:
- name: example
  rules:
  - alert: HighRequestLatency
	expr: request_processing_seconds_bucket{le="0.5"} > 0.5
	for: 5m
	labels:
  	severity: page
	annotations:
  	summary: High request latency
  	description: "Request latency is above 0.5 seconds for more than 5 minutes."संचालित द्वारा

3.2 Prometheus को अलर्ट नियम उपयोग करने के लिए कॉन्फ़िगर करें

अपने Prometheus कॉन्फ़िगरेशन (prometheus.yml) को अपडेट करें:

rule_files:
  - "alert.rules"
संचालित द्वारा

3.2 विज़ुअलाइज़ेशन के लिए Grafana सेटअप करें

Grafana को इंस्टॉल और कॉन्फ़िगर करने के लिए इंस्टॉलेशन और कॉन्फ़िगरेशन प्रलेखन देखें। सेटअप के बाद, आप रिक्वेस्ट लेटेंसी, एरर रेट्स आदि जैसे मेट्रिक्स को विजुअलाइज़ करने के लिए डैशबोर्ड और पैनल बना सकते हैं।

4. हेल्थ चेक्स लागू करना

हेल्थ चेक्स अनुप्रयोग के स्वास्थ्य की मॉनिटरिंग और उसे अपेक्षित रूप से चल रहा सुनिश्चित करने के लिए आवश्यक हैं। यहाँ एक साधारण हेल्थ चेक एंडपॉइंट बनाने का तरीका दिया गया है:

@app.get("/health")
async def health():
	return {"status": "Healthy"}
संचालित द्वारा

इस एंडपॉइंट को मॉनिटरिंग टूल्स द्वारा समय-समय पर कॉल किया जा सकता है ताकि यह सुनिश्चित हो कि अनुप्रयोग स्वस्थ है।

5. त्रुटियों और अपवादों की मॉनिटरिंग

अनुप्रयोग में समस्याओं की पहचान के लिए त्रुटियों और अपवादों को कैप्चर और मॉनिटर करना महत्वपूर्ण है। यहाँ बताया गया है कि अपवादों को कैप्चर करने के लिए लॉगिंग को कैसे बढ़ाया जा सकता है:

from fastapi import Request, HTTPException
from fastapi.responses import JSONResponse

@app.exception_handler(Exception)
async def global_exception_handler(request: Request, exc: Exception):
	logger.error(f"An error occurred: {exc}")
             return JSONResponse(status_code=500, content={"message": "Internal Server Error"})
@app.exception_handler(HTTPException)
async def http_exception_handler(request: Request, exc: HTTPException):
	logger.error(f"HTTP error occurred: {exc.detail}")
	return JSONResponse(status_code=exc.status_code, content={"message": exc.detail})संचालित द्वारा

इस सेटअप के साथ, कोई भी अनहैंडल्ड अपवाद लॉग हो जाएगा, जो संभावित समस्याओं पर अंतर्दृष्टि प्रदान करेगा।

अंतिम विचार

बड़े भाषा मॉडलों (LLMs) को प्रोडक्शन में डिप्लॉय करना आपके अनुप्रयोगों को बदल सकता है, लेकिन इस प्रक्रिया में मॉडल चयन, संसाधन प्रबंधन, और इंटीग्रेशन जैसी जटिलताओं से निपटना शामिल है। LangServe इन चुनौतियों को सरल बनाता है, जिससे डेवलपर्स LLM अनुप्रयोगों को कुशलतापूर्वक डिप्लॉय, मॉनिटर, और मेंटेन कर सकते हैं।

LangServe का उपयोग करके आप डिप्लॉयमेंट को सुव्यवस्थित कर सकते हैं, मज़बूत प्रदर्शन सुनिश्चित कर सकते हैं, और अपने सिस्टम्स के साथ निर्बाध इंटीग्रेशन प्राप्त कर सकते हैं।

LLM अनुप्रयोगों के निर्माण और डिप्लॉयमेंट पर अधिक गहराई से सीखने के लिए, DataCamp पर Developing LLM Applications with LangChain कोर्स एक्सप्लोर करें। यह संसाधन चैटबॉट निर्माण, LangChain Expression Language (LCEL) का उपयोग करके बाहरी डेटा का इंटीग्रेशन, और अन्य आवश्यक विषयों को कवर करता है।

FAQs

क्या LangServe किसी भी LLM के साथ उपयोग किया जा सकता है, या यह विशिष्ट मॉडलों तक सीमित है?

LangServe लचीला होने के लिए डिज़ाइन किया गया है और विभिन्न LLMs को सपोर्ट कर सकता है, खासकर वे जो LangChain के साथ इंटीग्रेटेड हैं। जबकि यह OpenAI के GPT और Anthropic के Claude जैसे लोकप्रिय मॉडलों के लिए आउट-ऑफ-द-बॉक्स सपोर्ट देता है, इसे अन्य मॉडलों तक भी विस्तारित किया जा सकता है।

क्या LangServe गैर-LLM मशीन लर्निंग मॉडलों की डिप्लॉयमेंट के लिए इस्तेमाल किया जा सकता है?

हालाँकि LangServe बड़े भाषा मॉडलों की डिप्लॉयमेंट के लिए अनुकूलित है, इसे अन्य प्रकार के मशीन लर्निंग मॉडलों की डिप्लॉयमेंट के लिए भी अनुकूलित किया जा सकता है। इसकी आर्किटेक्चर की लचीलापन विभिन्न मशीन लर्निंग फ्रेमवर्क्स और मॉडलों के साथ इंटीग्रेशन की अनुमति देता है, जिससे यह अलग-अलग डिप्लॉयमेंट आवश्यकताओं के लिए एक बहुमुखी टूल बनता है।

LangServe का उपयोग करते हुए उच्च-ट्रैफिक अनुप्रयोगों के लिए स्केलेबिलिटी कैसे संभालूँ?

स्केलिंग को स्केलेबल इंफ्रास्ट्रक्चर, जैसे Kubernetes, या AWS, Azure, या GCP जैसे क्लाउड प्लेटफॉर्म्स पर अपना अनुप्रयोग डिप्लॉय करके प्राप्त किया जा सकता है। बढ़ते ट्रैफिक को प्रबंधित करने और उच्च उपलब्धता सुनिश्चित करने के लिए ऑटो-स्केलिंग नीतियाँ और लोड बैलेंसिंग लागू किए जाने चाहिए।

LangServe इंस्टॉल करने के लिए सिस्टम आवश्यकताएँ क्या हैं?

विशिष्ट सिस्टम आवश्यकताएँ आपके द्वारा डिप्लॉय किए जाने वाले LLMs पर निर्भर कर सकती हैं। सामान्यतः, आपको Python के हालिया संस्करण वाला सिस्टम, पर्याप्त मेमोरी और CPU संसाधन, और आदर्श रूप से, कुशल मॉडल इन्फ़रेंस के लिए GPUs की आवश्यकता होगी।

लेखक

Stanislav Karzhev

हाल ही में स्नातकोत्तर (MSc) उत्तीर्ण, विशेषता: कृत्रिम बुद्धिमत्ता

विषय

कृत्रिम बुद्धिमत्ता