LLM इन्फ़रेंस इंजन की व्याख्या: llama.cpp, vLLM, SGLang, mistral.rs, PyTorch और LiteRT-LM

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

आज 12 नवंबर, 2026 है। ओपन मॉडल्स अब पेड AI सर्विसेज के स्तर के करीब पहुँच रहे हैं, और कई टीमें प्राइवेसी, लागत या ऑफ़लाइन उपयोग के लिए उन्हें अपने हार्डवेयर पर चलाना चाहती हैं। तभी उनका सामना कुछ अजीबोगरीब नामों की सूची से होता है: llama.cpp, vLLM, SGLang, mistral.rs, PyTorch, LiteRT-LM। यह पोस्ट बताती है कि टूल्स के इस समूह को क्या कहा जाता है, इनमें से प्रत्येक का क्या औचित्य है, और हमारे उदाहरण इंजीनियर रोहित कब किसका उपयोग करेंगे।

हम इन टूल्स को क्या कहते हैं

इसका सामान्य नाम है LLM इन्फ़रेंस इंजन. आप इन्हें मॉडल रनटाइम, सर्विंग इंजन या सर्विंग फ़्रेमवर्क कहे जाते हुए भी देखेंगे। कुछ त्वरित परिभाषाएँ:

• इन्फ़रेंस का अर्थ है उत्तर तैयार करने के लिए किसी प्रशिक्षित मॉडल का उपयोग करना। ट्रेनिंग मॉडल को सिखाती है; इन्फ़रेंस उससे सवाल पूछना है।
• सर्विंग का अर्थ है किसी मॉडल को एक सर्विस (आमतौर पर एक HTTP API) के रूप में चलाना, ताकि कई यूज़र्स या ऐप्स एक साथ इसे कॉल कर सकें।
• रनटाइम वह लो-लेवल कोड है जो CPU, GPU या फ़ोन चिप पर गणितीय गणनाएँ करता है।

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

इंजन इतना महत्वपूर्ण क्यों है

इंजन के आधार पर वही मॉडल तेज़ या कष्टप्रद रूप से धीमा महसूस हो सकता है। तीन चीज़ें यह तय करती हैं:

1. मेमोरी। किसी मॉडल को RAM या GPU मेमोरी में समाना होता है। कुछ इंजन सपोर्ट करते हैं क्वांटाइज़ेशन, जो संख्याओं को कम बिट्स में स्टोर करता है (उदाहरण के लिए 16 बिट्स के बजाय 4 बिट्स में)। मॉडल लगभग तीन से चार गुना छोटा हो जाता है और गुणवत्ता में मामूली कमी के साथ सस्ते हार्डवेयर पर चलता है।
2. थ्रूपुट। यह दर्शाता है कि इंजन एक साथ कई यूज़र्स के लिए प्रति सेकंड कितने उत्तर तैयार कर सकता है। सर्वर इंजन ऐसी तरकीबों का उपयोग करते हैं जैसे कंटीन्यूअस बैचिंग (नए अनुरोध अपनी बारी का इंतज़ार करने के बजाय चल रहे बैच में शामिल हो जाते हैं) ताकि GPU व्यस्त रहे।
3. लेटेंसी। यह इस बात पर निर्भर करता है कि किसी यूज़र को पहला शब्द कितनी जल्दी दिखाई देता है। चैट के लिए यह रॉ थ्रूपुट से अधिक मायने रखता है।

गलत चुनाव महंगा साबित हो सकता है। रोहित एक महंगा GPU किराए पर ले सकता है और फिर भी केवल कुछ ही यूज़र्स को सर्व कर पाएगा, या फिर ऐसा मॉडल लोड करने की कोशिश कर सकता है जो कभी लैपटॉप में समा ही नहीं सकता।

छह इंजन, एक-एक करके

llama.cpp: लगभग कहीं भी चलता है

llama.cpp एक C और C++ इंजन है जिसे सामान्य हार्डवेयर पर मॉडल चलाने के लिए बनाया गया है। यह अपने स्वयं के फ़ाइल फ़ॉर्मेट का उपयोग करता है, GGUF, जो एक क्वांटाइज़्ड मॉडल को एक ही फ़ाइल में पैक करता है। यह साधारण CPU, Apple Silicon, NVIDIA और AMD GPU आदि पर चलता है। Ollama और LM Studio जैसे लोकप्रिय डेस्कटॉप टूल्स इसी पर बनाए गए हैं।

व्यावहारिक उदाहरण। रोहित एक कंसलटेंट हैं जो क्लाइंट कॉन्ट्रैक्ट्स की समीक्षा करते हैं और उन्हें किसी सार्वजनिक चैटबॉट में पेस्ट नहीं कर सकते। llama.cpp के साथ वह अपने लैपटॉप पर पूरी तरह से ऑफ़लाइन एक छोटा क्वांटाइज़्ड मॉडल चलाते हैं, और मशीन से कोई भी टेक्स्ट बाहर भेजे बिना दस्तावेज़ों का सारांश तैयार करते हैं।

# Start a local OpenAI-compatible server on port 8080
llama-server -m ./models/example-model-Q4_K_M.gguf --port 8080

vLLM: GPU सर्वरों के लिए वर्कहॉर्स

vLLM कई यूज़र्स को एक साथ GPU पर मॉडल सर्व करने के लिए एक Python इंजन है। इसका मुख्य विचार है PagedAttention. उत्तर देते समय, मॉडल पिछले टोकन्स का एक स्क्रैचपैड रखता है जिसे कहते हैं KV cache. vLLM उस स्क्रैचपैड को छोटे पेजों में स्टोर करता है, बिल्कुल वैसे ही जैसे कोई ऑपरेटिंग सिस्टम मेमोरी मैनेज करता है, जिससे बहुत कम GPU मेमोरी बर्बाद होती है और एक ही समय में कहीं अधिक अनुरोध फ़िट हो जाते हैं। कंटीन्यूअस बैचिंग के साथ मिलकर, यह एक ही GPU को कई यूज़र्स को सर्व करने की अनुमति देता है।

व्यावहारिक उदाहरण। रोहित की कंपनी, Acme, 300 कर्मचारियों के लिए एक इंटरनल असिस्टेंट चाहती है। हर सवाल के लिए किसी पेड API को कॉल करना महंगा पड़ रहा है, और कुछ डेटा का इन-हाउस रहना ज़रूरी है। रोहित एक GPU सर्वर पर vLLM सेटअप करते हैं, और चूंकि यह OpenAI-कंपैटिबल API प्रदान करता है, इसलिए मौजूदा चैट ऐप को केवल एक नए बेस URL की आवश्यकता होती है।

vllm serve example-org/example-model --port 8000

SGLang: एजेंट्स और बार-बार दोहराए जाने वाले प्रॉम्प्ट्स के लिए तेज़

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

व्यावहारिक उदाहरण। रोहित एक सपोर्ट-टिकट ट्राइएज एजेंट बनाता है। प्रत्येक टिकट उसी 3,000 शब्दों के पॉलिसी दस्तावेज़ के साथ भेजा जाता है, और मॉडल को category और priority जैसे JSON फ़ील्ड्स के साथ उत्तर देना होता है। SGLang सभी टिकट्स में कैश्ड पॉलिसी वाले हिस्से का पुनः उपयोग करता है और आउटपुट को ऐसे आकार में रखता है जिसे उसका कोड आसानी से पार्स कर सके।

python -m sglang.launch_server --model-path example-org/example-model --port 30000

mistral.rs: Rust उपयोग करने वाली टीमों के लिए एक Rust इंजन

mistral.rs एक कम्युनिटी-निर्मित इन्फ़रेंस इंजन है जिसे Rust में लिखा गया है। नाम के बावजूद, यह Mistral AI कंपनी का आधिकारिक उत्पाद नहीं है, और यह कई मॉडल परिवारों को चलाता है। यह क्वांटाइज़ेशन, OpenAI-कंपैटिबल सर्वर का समर्थन करता है, और इसे Rust प्रोग्राम के भीतर एक लाइब्रेरी के रूप में उपयोग किया जा सकता है। Rust मेमोरी सुरक्षा और बिना किसी Python एनवायरनमेंट को मैनेज किए एक सिंगल कंपाइल बाइनरी प्रदान करता है।

व्यावहारिक उदाहरण। रोहित की टीम के पास Rust में लिखा गया एक लॉग-एनालिसिस टूल है जो लॉकडाउन किए गए सर्वरों पर चलता है जहाँ Python इंस्टॉल करने की अनुमति नहीं है। mistral.rs के साथ वे सीधे उसी बाइनरी में "summarise this incident" फ़ीचर जोड़ देते हैं, जिससे डिप्लॉय या पैच करने के लिए किसी अतिरिक्त सर्विस की आवश्यकता नहीं होती।

प्लेन PyTorch: संदर्भ के लिए, रेस कार नहीं

PyTorch वह फ़्रेमवर्क है जिसमें अधिकांश मॉडल बनाए और प्रशिक्षित किए जाते हैं। प्लेन PyTorch के साथ मॉडल चलाना, अक्सर Hugging Face Transformers लाइब्रेरी और इसके generate() फ़ंक्शन के माध्यम से, इसका उपयोग करने का सबसे सीधा तरीका है। इसमें बदलाव करना और डिबग करना आसान है, और नए मॉडल आमतौर पर सबसे पहले यहीं काम करते हैं। इसे कई यूज़र्स को सर्व करने के लिए ट्यून नहीं किया गया है, इसलिए यह धीमा है और ऊपर बताए गए इंजनों की तुलना में अधिक मेमोरी का उपयोग करता है।

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

Google का LiteRT-LM: फ़ोन पर मॉडल्स

LiteRT, Google का ऑन-डिवाइस रनटाइम है, जो TensorFlow Lite का नया नाम है। LiteRT-LM फ़ोन, ब्राउज़र और छोटे एज डिवाइसेज पर Gemma जैसे लैंग्वेज मॉडल्स को चलाने के लिए इसकी लेयर है। इसे सीमित मेमोरी, बैटरी लाइफ़ और मोबाइल चिप्स के लिए बनाया गया है, और यह किसी ऐप को बिना नेटवर्क कनेक्शन और बिना किसी सर्वर बिल के AI चलाने की सुविधा देता है।

व्यावहारिक उदाहरण। रोहित उन तकनीशियनों के लिए एक फ़ील्ड-इंस्पेक्शन Android ऐप बनाता है जिनके पास अक्सर कोई सिग्नल नहीं होता। फ़ोन पर LiteRT-LM और एक छोटे Gemma मॉडल के साथ, ऐप बोले गए नोट्स को ऑफ़लाइन एक स्पष्ट रिपोर्ट में बदल देता है, और डेटा कभी डिवाइस से बाहर नहीं जाता।

रोहित किसे चुनता है: एक सरल निर्णय गाइड

स्टेप 1: तय करें कि मॉडल कहाँ चलेगा

किसी फ़ोन या छोटे डिवाइस पर, LiteRT-LM से शुरुआत करें। लैपटॉप या केवल-CPU वाले सर्वर पर, llama.cpp से शुरुआत करें। GPU सर्वरों पर, vLLM या SGLang देखें। किसी Rust प्रोग्राम के भीतर, mistral.rs पर विचार करें।

स्टेप 2: यूज़र्स की संख्या गिनें

एक व्यक्ति या कुछ लोग: llama.cpp सरल और पर्याप्त है। एक साथ दर्जनों या सैकड़ों: vLLM या SGLang, क्योंकि बैचिंग ही प्रति उत्तर लागत को कम रखती है।

स्टेप 3: वर्कलोड का स्वरूप देखें

बहुत सारे शेयर्ड प्रॉम्प्ट्स, एजेंट्स या सख्त JSON आउटपुट SGLang की ओर इशारा करते हैं। सामान्य चैट और API ट्रैफ़िक vLLM की ओर इशारा करते हैं। प्रयोग और शोध प्लेन PyTorch की ओर इशारा करते हैं।

स्टेप 4: अपने स्वयं के हार्डवेयर पर परीक्षण करें

प्रकाशित आँकड़े GPU, मॉडल और सेटिंग्स पर निर्भर करते हैं। दो संभावित इंजनों के साथ अपनी मशीन पर अपने स्वयं के प्रॉम्प्ट्स चलाएँ, और निर्णय लेने से पहले पहले शब्द का समय (time to first word), शब्द प्रति सेकंड और मेमोरी उपयोग को मापें।

निष्कर्ष

llama.cpp, vLLM, SGLang, mistral.rs, PyTorch और LiteRT-LM सभी एक ही बुनियादी काम करते हैं: वे एक प्रशिक्षित मॉडल को चलाते हैं और इनपुट को उत्तरों में बदलते हैं। उस समूह को LLM इन्फ़रेंस इंजन कहा जाता है। उन्हें जो अलग करता है वह यह है कि वे कहाँ चलते हैं और किन्हें सेवा देते हैं: लैपटॉप और छोटे सर्वरों के लिए llama.cpp, व्यस्त GPU सर्वरों के लिए vLLM और SGLang, Rust-नेटिव ऐप्स के लिए mistral.rs, प्रयोगों के लिए PyTorch, और फ़ोन व एज डिवाइसेज के लिए LiteRT-LM। इंजन का चुनाव भी मॉडल की तरह ही सावधानी से करें।

लाभ

• ओपन मॉडल्स को स्वयं चलाने से संवेदनशील डेटा इन-हाउस रहता है और यह पूरी तरह से ऑफ़लाइन काम कर सकता है।
• llama.cpp और mistral.rs में क्वांटाइज़ेशन सक्षम मॉडल्स को सामान्य लैपटॉप पर चलने की अनुमति देता है।
• vLLM और SGLang एक ही GPU से कई यूज़र्स को सेवा देते हैं, जिससे प्रति उत्तर लागत कम हो जाती है।
• OpenAI-कंपैटिबल APIs किसी पेड सर्विस से स्विच करने को केवल एक छोटे कोड परिवर्तन तक सीमित कर देते हैं।
• LiteRT-LM बिना किसी सर्वर बिल और बिना नेटवर्क की आवश्यकता के फ़ोन पर AI फ़ीचर्स लाता है।

कमियां

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

सावधानी

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

अक्सर पूछे जाने वाले प्रश्न

• LLM इन्फ़रेंस इंजन क्या है? — यह वह सॉफ़्टवेयर है जो किसी प्रशिक्षित भाषा मॉडल को लोड करता है और उत्तर तैयार करने के लिए इसे CPU, GPU या फ़ोन चिप पर चलाता है।
• क्या llama.cpp बेहतर है या vLLM? — दोनों में से कोई भी हर जगह बेहतर नहीं है: llama.cpp लैपटॉप और छोटे सर्वरों के लिए सबसे अच्छा है, और vLLM, GPU सर्वरों पर कई यूज़र्स को सर्व करने के लिए सबसे अच्छा है।
• vLLM और SGLang में क्या अंतर है? — दोनों तेज़ GPU सर्विंग इंजन हैं; SGLang विशेष रूप से तब अधिक शक्तिशाली है जब अनुरोध लंबे प्रॉम्प्ट्स साझा करते हैं या उन्हें JSON जैसे स्ट्रक्चर्ड आउटपुट की आवश्यकता होती है।
• क्या मैं GPU के बिना LLM चला सकता हूँ? — हाँ, llama.cpp सामान्य CPUs पर क्वांटाइज़्ड मॉडल्स चलाता है, हालाँकि GPU की तुलना में अधिक धीमी गति से।
• क्या mistral.rs को Mistral AI द्वारा बनाया गया है? — नहीं, यह Rust में लिखा गया एक अलग कम्युनिटी प्रोजेक्ट है जो कई मॉडल परिवारों को चला सकता है।
• प्रोडक्शन में सिर्फ PyTorch का उपयोग क्यों नहीं किया जाता? — प्लेन PyTorch लचीला है लेकिन कई यूज़र्स के लिए ट्यून नहीं किया गया है, इसलिए समर्पित इंजन आमतौर पर उसी हार्डवेयर से कहीं अधिक गति प्रदान करते हैं।
• LiteRT-LM का उपयोग किस लिए किया जाता है? — यह Gemma जैसे भाषा मॉडल्स को सीधे फ़ोन और एज डिवाइसेज पर ऑफ़लाइन चलाने के लिए Google का रनटाइम है।
• क्वांटाइज़ेशन क्या करता है? — यह मॉडल की संख्याओं को कम बिट्स के साथ स्टोर करता है, जिससे मॉडल बहुत कम मेमोरी का उपयोग करता है और गुणवत्ता में मामूली नुकसान के साथ सस्ते हार्डवेयर पर चलता है।

टैग्स

#llm #inferenceengine #llamacpp #vllm #sglang #mistralrs #pytorch #litertlm #selfhostedai #aiengineering