अपना खुद का RAG ऐप बनाएं: ओलमा, पायथन और क्रोमाडीबी का उपयोग करके स्थानीय रूप से LLM सेटअप करने के लिए चरण-दर-चरण मार्गदर्शिका

ऐसे युग में जहाँ डेटा गोपनीयता सर्वोपरि है, अपना खुद का स्थानीय भाषा मॉडल (LLM) स्थापित करना कंपनियों और व्यक्तियों दोनों के लिए एक महत्वपूर्ण समाधान प्रदान करता है। यह ट्यूटोरियल आपको Ollama , Python 3 और ChromaDB का उपयोग करके एक कस्टम चैटबॉट बनाने की प्रक्रिया के माध्यम से मार्गदर्शन करने के लिए डिज़ाइन किया गया है, जो आपके सिस्टम पर स्थानीय रूप से होस्ट किए गए हैं। यहाँ मुख्य कारण दिए गए हैं कि आपको इस ट्यूटोरियल की आवश्यकता क्यों है:

• पूर्ण अनुकूलन: अपने स्वयं के रिट्रीवल-ऑगमेंटेड जेनरेशन (RAG) एप्लिकेशन को स्थानीय रूप से होस्ट करने का मतलब है कि आपके पास सेटअप और अनुकूलन पर पूर्ण नियंत्रण है। आप बाहरी सेवाओं पर निर्भर हुए बिना अपनी विशिष्ट आवश्यकताओं के अनुरूप मॉडल को ठीक कर सकते हैं।
• बढ़ी हुई गोपनीयता: अपने LLM मॉडल को स्थानीय रूप से सेट करके, आप इंटरनेट पर संवेदनशील डेटा भेजने से जुड़े जोखिमों से बचते हैं। यह उन कंपनियों के लिए विशेष रूप से महत्वपूर्ण है जो गोपनीय जानकारी संभालती हैं। अपने मॉडल को स्थानीय रूप से निजी डेटा के साथ प्रशिक्षित करना सुनिश्चित करता है कि आपका डेटा आपके नियंत्रण में रहे।
• डेटा सुरक्षा: तीसरे पक्ष के LLM मॉडल का उपयोग करने से आपका डेटा संभावित उल्लंघनों और दुरुपयोग के लिए उजागर हो सकता है। स्थानीय परिनियोजन आपके प्रशिक्षण डेटा, जैसे कि PDF दस्तावेज़ों को आपके सुरक्षित वातावरण में रखकर इन जोखिमों को कम करता है।
• डेटा प्रोसेसिंग पर नियंत्रण: जब आप अपना खुद का LLM होस्ट करते हैं, तो आपके पास अपने डेटा को ठीक उसी तरह प्रबंधित और प्रोसेस करने की क्षमता होती है, जैसा आप चाहते हैं। इसमें आपके निजी डेटा को आपके ChromaDB वेक्टर स्टोर में एम्बेड करना शामिल है, यह सुनिश्चित करना कि आपका डेटा प्रोसेसिंग आपके मानकों और आवश्यकताओं को पूरा करता है।
• इंटरनेट कनेक्टिविटी से स्वतंत्रता: अपने चैटबॉट को स्थानीय रूप से चलाने का मतलब है कि आप इंटरनेट कनेक्शन पर निर्भर नहीं हैं। यह ऑफ़लाइन परिदृश्यों में भी आपके चैटबॉट तक निर्बाध सेवा और पहुँच की गारंटी देता है।

यह ट्यूटोरियल आपको गोपनीयता या नियंत्रण से समझौता किए बिना, आपकी आवश्यकताओं के अनुरूप एक मजबूत और सुरक्षित स्थानीय चैटबॉट बनाने में सक्षम बनाएगा।

पुनर्प्राप्ति-संवर्धित पीढ़ी (आरएजी)

रिट्रीवल-ऑगमेंटेड जेनरेशन (RAG) एक उन्नत तकनीक है जो सूचना पुनर्प्राप्ति और पाठ निर्माण की शक्तियों को जोड़ती है ताकि अधिक सटीक और प्रासंगिक प्रतिक्रियाएँ बनाई जा सकें। यहाँ बताया गया है कि RAG कैसे काम करता है और यह क्यों फायदेमंद है:

आरएजी क्या है?

RAG एक हाइब्रिड मॉडल है जो बाहरी ज्ञान आधार या दस्तावेज़ भंडार को शामिल करके भाषा मॉडल की क्षमताओं को बढ़ाता है। इस प्रक्रिया में दो मुख्य घटक शामिल हैं:

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

आरएजी कैसे काम करता है?

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

आरएजी के लाभ

• बढ़ी हुई सटीकता: बाहरी डेटा का लाभ उठाकर, RAG मॉडल अधिक सटीक और विस्तृत उत्तर प्रदान कर सकते हैं, विशेष रूप से डोमेन-विशिष्ट प्रश्नों के लिए।
• प्रासंगिक प्रासंगिकता: पुनर्प्राप्ति घटक यह सुनिश्चित करता है कि उत्पन्न प्रतिक्रिया प्रासंगिक और अद्यतन जानकारी पर आधारित हो, जिससे प्रतिक्रिया की समग्र गुणवत्ता में सुधार होता है।
• मापनीयता: RAG प्रणालियों को बड़ी मात्रा में डेटा को शामिल करने के लिए आसानी से बढ़ाया जा सकता है, जिससे वे व्यापक श्रेणी के प्रश्नों और विषयों को संभालने में सक्षम हो जाते हैं।
• लचीलापन: इन मॉडलों को बाह्य ज्ञान आधार को अद्यतन या विस्तारित करके विभिन्न डोमेन के लिए अनुकूलित किया जा सकता है, जिससे वे अत्यधिक बहुमुखी बन जाते हैं।

स्थानीय स्तर पर RAG का उपयोग क्यों करें?

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

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

जीपीयू

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

GPU क्या है?

GPU एक विशेष प्रोसेसर है जिसे छवियों और वीडियो के रेंडरिंग को तेज़ करने के लिए डिज़ाइन किया गया है। सेंट्रल प्रोसेसिंग यूनिट्स (CPU) के विपरीत, जो अनुक्रमिक प्रसंस्करण कार्यों के लिए अनुकूलित हैं, GPU समानांतर प्रसंस्करण में उत्कृष्ट हैं। यह उन्हें मशीन लर्निंग और डीप लर्निंग मॉडल द्वारा आवश्यक जटिल गणितीय गणनाओं के लिए विशेष रूप से उपयुक्त बनाता है।

एलएलएम के लिए जीपीयू क्यों महत्वपूर्ण है

• समानांतर प्रसंस्करण शक्ति: GPU एक साथ हजारों ऑपरेशन संभाल सकता है, जिससे LLM में प्रशिक्षण और अनुमान जैसे कार्यों में काफी तेजी आती है। यह समानांतरता बड़े डेटासेट को प्रोसेस करने और वास्तविक समय में प्रतिक्रियाएँ उत्पन्न करने से जुड़े भारी कम्प्यूटेशनल लोड के लिए महत्वपूर्ण है।
• बड़े मॉडलों को संभालने में दक्षता: RAG में उपयोग किए जाने वाले LLM को पर्याप्त मेमोरी और कम्प्यूटेशनल संसाधनों की आवश्यकता होती है। GPU उच्च-बैंडविड्थ मेमोरी (HBM) और कई कोर से लैस होते हैं, जिससे वे इन मॉडलों द्वारा आवश्यक बड़े पैमाने पर मैट्रिक्स गुणन और टेंसर संचालन को प्रबंधित करने में सक्षम होते हैं।
• तेज़ डेटा एम्बेडिंग और पुनर्प्राप्ति: स्थानीय RAG सेटअप में, ChromaDB जैसे वेक्टर स्टोर में डेटा एम्बेड करना और प्रासंगिक दस्तावेज़ों को तेज़ी से पुनर्प्राप्त करना प्रदर्शन के लिए आवश्यक है। उच्च-प्रदर्शन वाले GPU इन प्रक्रियाओं को तेज़ कर सकते हैं, यह सुनिश्चित करते हुए कि आपका चैटबॉट तुरंत और सटीक रूप से प्रतिक्रिया करता है।
• बेहतर प्रशिक्षण समय: LLM को प्रशिक्षित करने में लाखों (या अरबों) मापदंडों को समायोजित करना शामिल है। GPU, CPU की तुलना में इस प्रशिक्षण चरण के लिए आवश्यक समय को काफी कम कर सकते हैं, जिससे आपके मॉडल में अधिक लगातार अपडेट और परिशोधन संभव हो जाता है।

सही GPU चुनना

स्थानीय LLM सेट अप करते समय, GPU का चयन प्रदर्शन को महत्वपूर्ण रूप से प्रभावित कर सकता है। यहाँ कुछ कारक दिए गए हैं जिन पर विचार करना चाहिए:

• मेमोरी क्षमता: बड़े मॉडल के लिए ज़्यादा GPU मेमोरी की ज़रूरत होती है। व्यापक डेटासेट और मॉडल पैरामीटर को समायोजित करने के लिए ज़्यादा VRAM (वीडियो RAM) वाले GPU की तलाश करें।
• कंप्यूट क्षमता: GPU में जितने ज़्यादा CUDA कोर होंगे, वह समानांतर प्रोसेसिंग कार्यों को उतने ही बेहतर तरीके से संभाल सकता है। उच्च कंप्यूट क्षमता वाले GPU डीप लर्निंग कार्यों के लिए ज़्यादा कुशल होते हैं।
• बैंडविड्थ: उच्च मेमोरी बैंडविड्थ GPU और इसकी मेमोरी के बीच तेजी से डेटा स्थानांतरण की अनुमति देता है, जिससे समग्र प्रसंस्करण गति में सुधार होता है।

एलएलएम के लिए उच्च-प्रदर्शन जीपीयू के उदाहरण

• NVIDIA RTX 3090: अपने उच्च VRAM (24 GB) और शक्तिशाली CUDA कोर के लिए जाना जाता है, यह गहन शिक्षण कार्यों के लिए एक लोकप्रिय विकल्प है।
• NVIDIA A100: विशेष रूप से AI और मशीन लर्निंग के लिए डिज़ाइन किया गया, यह बड़ी मेमोरी क्षमता और उच्च कंप्यूट पावर के साथ असाधारण प्रदर्शन प्रदान करता है।
• AMD Radeon Pro VII: उच्च मेमोरी बैंडविड्थ और कुशल प्रसंस्करण क्षमताओं के साथ एक और मजबूत दावेदार।

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

आवश्यक शर्तें

सेटअप में उतरने से पहले, सुनिश्चित करें कि आपके पास निम्नलिखित पूर्वापेक्षाएँ मौजूद हैं:

• पायथन 3: पायथन एक बहुमुखी प्रोग्रामिंग भाषा है जिसका उपयोग आप अपने RAG ऐप के लिए कोड लिखने के लिए करेंगे।
• क्रोमाडीबी: एक वेक्टर डेटाबेस जो हमारे डेटा के एम्बेडिंग को संग्रहीत और प्रबंधित करेगा।
• ओलामा: हमारे स्थानीय मशीन में कस्टम एलएलएम डाउनलोड और प्रस्तुत करना।

चरण 1: पायथन 3 स्थापित करें और अपना वातावरण सेटअप करें

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

 $ python3 --version # Python 3.11.7

अपने प्रोजेक्ट के लिए एक फ़ोल्डर बनाएँ, उदाहरण के लिए, local-rag :

 $ mkdir local-rag $ cd local-rag

venv नामक एक वर्चुअल वातावरण बनाएं:

 $ python3 -m venv venv

वर्चुअल वातावरण सक्रिय करें:

 $ source venv/bin/activate # Windows # venv\Scripts\activate

चरण 2: ChromaDB और अन्य निर्भरताएँ स्थापित करें

पाइप का उपयोग करके ChromaDB स्थापित करें:

 $ pip install --q chromadb

अपने मॉडल के साथ सहजता से काम करने के लिए लैंगचेन टूल इंस्टॉल करें:

 $ pip install --q unstructured langchain langchain-text-splitters $ pip install --q "unstructured[all-docs]"

अपने ऐप को HTTP सेवा के रूप में प्रस्तुत करने के लिए फ्लास्क स्थापित करें:

 $ pip install --q flask

चरण 3: ओलामा स्थापित करें

ओलामा को इंस्टॉल करने के लिए, इन चरणों का पालन करें: ओलामा डाउनलोड पेज पर जाएं, और अपने ऑपरेटिंग सिस्टम के लिए इंस्टॉलर डाउनलोड करें। अपना ओलामा इंस्टॉलेशन चलाकर सत्यापित करें:

 $ ollama --version # ollama version is 0.1.47

आपको जिस LLM मॉडल की आवश्यकता है उसे खींचें। उदाहरण के लिए, मिस्ट्रल मॉडल का उपयोग करने के लिए:

 $ ollama pull mistral

टेक्स्ट एम्बेडिंग मॉडल खींचें। उदाहरण के लिए, नोमिक एम्बेड टेक्स्ट मॉडल का उपयोग करने के लिए:

 $ ollama pull nomic-embed-text

फिर अपने ओलामा मॉडल चलाएं:

 $ ollama serve

RAG ऐप बनाएं

अब जब आपने Python, Ollama, ChromaDB और अन्य निर्भरताओं के साथ अपना परिवेश सेट कर लिया है, तो अब अपना कस्टम स्थानीय RAG ऐप बनाने का समय आ गया है। इस अनुभाग में, हम व्यावहारिक Python कोड के माध्यम से चलेंगे और आपके एप्लिकेशन को संरचित करने के तरीके का अवलोकन प्रदान करेंगे।

app.py

यह मुख्य फ्लास्क एप्लीकेशन फ़ाइल है। यह वेक्टर डेटाबेस में फ़ाइलों को एम्बेड करने और मॉडल से प्रतिक्रिया प्राप्त करने के लिए रूट परिभाषित करता है।

 import os from dotenv import load_dotenv load_dotenv() from flask import Flask, request, jsonify from embed import embed from query import query from get_vector_db import get_vector_db TEMP_FOLDER = os.getenv('TEMP_FOLDER', './_temp') os.makedirs(TEMP_FOLDER, exist_ok=True) app = Flask(__name__) @app.route('/embed', methods=['POST']) def route_embed(): if 'file' not in request.files: return jsonify({"error": "No file part"}), 400 file = request.files['file'] if file.filename == '': return jsonify({"error": "No selected file"}), 400 embedded = embed(file) if embedded: return jsonify({"message": "File embedded successfully"}), 200 return jsonify({"error": "File embedded unsuccessfully"}), 400 @app.route('/query', methods=['POST']) def route_query(): data = request.get_json() response = query(data.get('query')) if response: return jsonify({"message": response}), 200 return jsonify({"error": "Something went wrong"}), 400 if __name__ == '__main__': app.run(host="0.0.0.0", port=8080, debug=True)

embed.py

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

 import os from datetime import datetime from werkzeug.utils import secure_filename from langchain_community.document_loaders import UnstructuredPDFLoader from langchain_text_splitters import RecursiveCharacterTextSplitter from get_vector_db import get_vector_db TEMP_FOLDER = os.getenv('TEMP_FOLDER', './_temp') # Function to check if the uploaded file is allowed (only PDF files) def allowed_file(filename): return '.' in filename and filename.rsplit('.', 1)[1].lower() in {'pdf'} # Function to save the uploaded file to the temporary folder def save_file(file): # Save the uploaded file with a secure filename and return the file path ct = datetime.now() ts = ct.timestamp() filename = str(ts) + "_" + secure_filename(file.filename) file_path = os.path.join(TEMP_FOLDER, filename) file.save(file_path) return file_path # Function to load and split the data from the PDF file def load_and_split_data(file_path): # Load the PDF file and split the data into chunks loader = UnstructuredPDFLoader(file_path=file_path) data = loader.load() text_splitter = RecursiveCharacterTextSplitter(chunk_size=7500, chunk_overlap=100) chunks = text_splitter.split_documents(data) return chunks # Main function to handle the embedding process def embed(file): # Check if the file is valid, save it, load and split the data, add to the database, and remove the temporary file if file.filename != '' and file and allowed_file(file.filename): file_path = save_file(file) chunks = load_and_split_data(file_path) db = get_vector_db() db.add_documents(chunks) db.persist() os.remove(file_path) return True return False

query.py

यह मॉड्यूल उपयोगकर्ता की क्वेरी को संसाधित करके, क्वेरी के कई संस्करण तैयार करके, प्रासंगिक दस्तावेजों को पुनः प्राप्त करके, तथा संदर्भ के आधार पर उत्तर प्रदान करता है।

 import os from langchain_community.chat_models import ChatOllama from langchain.prompts import ChatPromptTemplate, PromptTemplate from langchain_core.output_parsers import StrOutputParser from langchain_core.runnables import RunnablePassthrough from langchain.retrievers.multi_query import MultiQueryRetriever from get_vector_db import get_vector_db LLM_MODEL = os.getenv('LLM_MODEL', 'mistral') # Function to get the prompt templates for generating alternative questions and answering based on context def get_prompt(): QUERY_PROMPT = PromptTemplate( input_variables=["question"], template="""You are an AI language model assistant. Your task is to generate five different versions of the given user question to retrieve relevant documents from a vector database. By generating multiple perspectives on the user question, your goal is to help the user overcome some of the limitations of the distance-based similarity search. Provide these alternative questions separated by newlines. Original question: {question}""", ) template = """Answer the question based ONLY on the following context: {context} Question: {question} """ prompt = ChatPromptTemplate.from_template(template) return QUERY_PROMPT, prompt # Main function to handle the query process def query(input): if input: # Initialize the language model with the specified model name llm = ChatOllama(model=LLM_MODEL) # Get the vector database instance db = get_vector_db() # Get the prompt templates QUERY_PROMPT, prompt = get_prompt() # Set up the retriever to generate multiple queries using the language model and the query prompt retriever = MultiQueryRetriever.from_llm( db.as_retriever(), llm, prompt=QUERY_PROMPT ) # Define the processing chain to retrieve context, generate the answer, and parse the output chain = ( {"context": retriever, "question": RunnablePassthrough()} | prompt | llm | StrOutputParser() ) response = chain.invoke(input) return response return None

get_vector_db.py

यह मॉड्यूल दस्तावेज़ एम्बेडिंग को संग्रहीत करने और पुनर्प्राप्त करने के लिए उपयोग किए जाने वाले वेक्टर डेटाबेस इंस्टेंस को आरंभ करता है और लौटाता है।

 import os from langchain_community.embeddings import OllamaEmbeddings from langchain_community.vectorstores.chroma import Chroma CHROMA_PATH = os.getenv('CHROMA_PATH', 'chroma') COLLECTION_NAME = os.getenv('COLLECTION_NAME', 'local-rag') TEXT_EMBEDDING_MODEL = os.getenv('TEXT_EMBEDDING_MODEL', 'nomic-embed-text') def get_vector_db(): embedding = OllamaEmbeddings(model=TEXT_EMBEDDING_MODEL,show_progress=True) db = Chroma( collection_name=COLLECTION_NAME, persist_directory=CHROMA_PATH, embedding_function=embedding ) return db

अपना ऐप चलाएँ!

अपने पर्यावरण चरों को संग्रहीत करने के लिए .env फ़ाइल बनाएँ:

 TEMP_FOLDER = './_temp' CHROMA_PATH = 'chroma' COLLECTION_NAME = 'local-rag' LLM_MODEL = 'mistral' TEXT_EMBEDDING_MODEL = 'nomic-embed-text'

अपना ऐप सर्वर शुरू करने के लिए app.py फ़ाइल चलाएँ:

 $ python3 app.py

एक बार सर्वर चालू हो जाने पर, आप निम्नलिखित समापन बिंदुओं पर अनुरोध करना शुरू कर सकते हैं:

• पीडीएफ फाइल (जैसे, resume.pdf) एम्बेड करने के लिए उदाहरण कमांड:

 $ curl --request POST \ --url http://localhost:8080/embed \ --header 'Content-Type: multipart/form-data' \ --form file=@/Users/nassermaronie/Documents/Nasser-resume.pdf # Response { "message": "File embedded successfully" }

• अपने मॉडल से प्रश्न पूछने के लिए उदाहरण आदेश:

 $ curl --request POST \ --url http://localhost:8080/query \ --header 'Content-Type: application/json' \ --data '{ "query": "Who is Nasser?" }' # Response { "message": "Nasser Maronie is a Full Stack Developer with experience in web and mobile app development. He has worked as a Lead Full Stack Engineer at Ulventech, a Senior Full Stack Engineer at Speedoc, a Senior Frontend Engineer at Irvins, and a Software Engineer at Tokopedia. His tech stacks include Typescript, ReactJS, VueJS, React Native, NodeJS, PHP, Golang, Python, MySQL, PostgresQL, MongoDB, Redis, AWS, Firebase, and Supabase. He has a Bachelor's degree in Information System from Universitas Amikom Yogyakarta." }

निष्कर्ष

इन निर्देशों का पालन करके, आप अपनी ज़रूरतों के हिसाब से Python, Ollama और ChromaDB का उपयोग करके अपने कस्टम लोकल RAG ऐप को प्रभावी ढंग से चला सकते हैं और उससे इंटरैक्ट कर सकते हैं। अपने एप्लिकेशन की क्षमताओं को बढ़ाने के लिए आवश्यकतानुसार कार्यक्षमता को समायोजित और विस्तारित करें।

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

इस रिपो में स्रोत कोड की जाँच करें:

https://github.com/firstpersoncode/local-rag

हैप्पी कोडिंग!