LLMs और लोकल AI हार्डवेयर के लिए इन्फरेंस इंजन (2026 संस्करण)

You don't pick an inference engine first. You pick a hardware strategy, a workload shape, and a serving model. The engine follows.

Translate to Hindi:

<p>आप पहले इंफ़रेंस इंजन नहीं चुनते। आप पहले हार्डवेयर रणनीति, वर्कलोड आकार और सर्विंग मॉडल चुनते हैं। इंजन उसके बाद आता है।</p>

Next line: "That is the most useful way to think about LLM inference engines." -> "LLM इंफ़रेंस इंजनों के बारे में सोचने का यह सबसे उपयोगी तरीका है।"

Series note: translate.

Part 1 and Part 2 links: translate link text but keep URLs.

"GPU Memory Math for LLMs (2026 Edition)" -> "LLMs के लिए GPU मेमोरी गणित (2026 संस्करण)"

"Memory Bandwidth for Local AI Hardware (2026 Edition)" -> "स्थानीय AI हार्डवेयर के लिए मेमोरी बैंडविड्थ (2026 संस्करण)"

Those two pieces explain... -> "वे दो टुकड़े हार्डवेयर क्षमता और बैंडविड्थ गणित समझाते हैं।"

This one explains the software layer... -> "यह वाला सॉफ्टवेयर लेयर समझाता है जो उस हार्डवेयर को उपयोगी इंफ़रेंस में बदलता है।"

Heading: ## Engines -> ## इंजन

These tools serve different purposes / occupy different layers -> ये उपकरण अलग-अलग उद्देश्यों की पूर्ति करते हैं / अलग-अलग लेयर पर काम करते हैं

Then bullet list: translate each.

• Local portability -> स्थानीय पोर्टेबिलिटी
• Consumer CUDA -> कंज्यूमर CUDA
• Apple unified-memory workflows -> Apple यूनिफाइड-मेमोरी वर्कफ़्लो
• Quantized inference -> क्वांटाइज़्ड इंफ़रेंस
• Production serving -> प्रोडक्शन सर्विंग
• Distributed orchestration -> वितरित ऑर्केस्ट्रेशन
• Vendor-optimized datacenter execution -> विक्रेता-अनुकूलित डेटासेंटर निष्पादन

A useful mental model: -> एक उपयोगी मानसिक मॉडल:

payload-block tag: keep as is <payload-block id="blk_0" type="upload" />

The inference engine is not "the model." ... -> translate.

"traffic cop, memory manager, kernel dispatcher, scheduler, cache accountant, parallelism planner, API surface, and sometimes the deployment framework." -> "ट्रैफ़िक कॉप, मेमोरी मैनेजर, कर्नल डिस्पैचर, शेड्यूलर, कैश अकाउंटेंट, पैरेललिज़्म प्लानर, API सरफेस और कभी-कभी डिप्लॉयमेंट फ्रेमवर्क।"

The best engine matches... -> "सबसे अच्छा इंजन आपकी मेमोरी हायरार्की, इंटरकनेक्ट, क्वांटाइज़ेशन फॉर्मेट, लेटेंसी और थ्रूपुट लक्ष्य, मॉडल आर्किटेक्चर और ऑपरेशनल मैच्योरिटी से मेल खाता है।"

The one-page decision guide -> ## एक-पेज निर्णय गाइड

payload-block id="blk_1"

Then bullet list of engine choices. Keep engine names as is. Translate the descriptions.

• Laptop / edge / odd hardware → llama.cpp -> लैपटॉप / एज / अजीब हार्डवेयर → llama.cpp
• Mac-first workflows → MLX / MLX-LM -> Mac-प्रथम वर्कफ़्लो → MLX / MLX-LM
• Single RTX local inference → ExLlamaV2 -> एकल RTX स्थानीय इंफ़रेंस → ExLlamaV2
• 2-4+ NVIDIA / CUDA GPUs → ExLlamaV3 -> 2-4+ NVIDIA / CUDA GPU → ExLlamaV3
• General production serving → vLLM -> सामान्य प्रोडक्शन सर्विंग → vLLM
• Long-context / MoE / routing → SGLang -> लंबे-संदर्भ / MoE / रूटिंग → SGLang
• NVIDIA max performance → TensorRT-LLM -> NVIDIA अधिकतम प्रदर्शन → TensorRT-LLM
• Cluster orchestration → NVIDIA Dynamo -> क्लस्टर ऑर्केस्ट्रेशन → NVIDIA Dynamo

The rest of this guide explains why. -> इस गाइड का बाकी हिस्सा क्यों समझाता है।

What an inference engine actually does -> ## इंफ़रेंस इंजन वास्तव में क्या करता है

Translate paragraph: loads weights, tokenizes input, runs forward pass, samples tokens, maintains KV cache, streams results. Also handles batching, scheduling, etc.

The workload has two phases: -> कार्यभार के दो चरण हैं:

Prefill reads the prompt... -> प्रीफ़िल प्रॉम्प्ट पढ़ता है और प्रारंभिक KV कैश बनाता है। यह कंप्यूट-इंटेंसिव है।

Decode generates one token... -> डिकोड एक बार में एक टोकन उत्पन्न करता है, बार-बार वज़न और KV कैश पढ़ता है। यह मेमोरी-बैंडविड्थ-बाउंड है। डिकोड गति पीक कंप्यूट की तुलना में मेमोरी बैंडविड्थ पर अधिक निर्भर करती है।

That distinction explains almost everything: -> यह अंतर लगभग सब कुछ समझाता है:

Then bullet list: Short prompt, long answer, etc. Translate each bullet.

• Short prompt, long answer: decode dominates → memory bandwidth and batching matter. -> छोटा प्रॉम्प्ट, लंबा उत्तर: डिकोड हावी होता है → मेमोरी बैंडविड्थ और बैचिंग मायने रखते हैं।
• Long prompt, short answer: prefill dominates → attention kernels and chunked prefill matter. -> लंबा प्रॉम्प्ट, छोटा उत्तर: प्रीफ़िल हावी होता है → अटेंशन कर्नल और चंक्ड प्रीफ़िल मायने रखते हैं।
• Many users: scheduler quality matters → continuous batching, cache paging, fairness. -> कई उपयोगकर्ता: शेड्यूलर गुणवत्ता मायने रखती है → निरंतर बैचिंग, कैश पेजिंग, निष्पक्षता।
• Long context: KV cache dominates → paged attention, KV quantization, offload. -> लंबा संदर्भ: KV कैश हावी होता है → पेज्ड अटेंशन, KV क्वांटाइज़ेशन, ऑफ़लोड।
• MoE: expert routing dominates → expert parallelism, interconnect, grouped GEMMs. -> MoE: एक्सपर्ट रूटिंग हावी होती है → एक्सपर्ट पैरेललिज़्म, इंटरकनेक्ट, ग्रुप्ड GEMM।
• Multi-node: interconnect dominates → NVLink, RDMA, pipeline parallelism, disaggregation. -> मल्टी-नोड: इंटरकनेक्ट हावी होता है → NVLink, RDMA, पाइपलाइन पैरेललिज़्म, डिसएग्रीगेशन।

Then paragraph about PagedAttention, FlashAttention, speculative decoding. Translate.

PagedAttention tackled KV cache fragmentation. -> PagedAttention ने KV कैश विखंडन को संबोधित किया।

FlashAttention used IO-aware tiling to cut HBM traffic. -> FlashAttention ने HBM ट्रैफ़िक कम करने के लिए IO-जागरूक टाइलिंग का उपयोग किया।

Speculative decoding drafts cheap tokens and verifies them in parallel. -> स्पेक्युलेटिव डिकोडिंग सस्ते टोकन का मसौदा तैयार करता है और उन्हें समानांतर में सत्यापित करता है।

The recurring theme: inference performance is memory movement plus scheduling. -> आवर्ती विषय: इंफ़रेंस प्रदर्शन मेमोरी मूवमेंट प्लस शेड्यूलिंग है।

The real bottlenecks -> ## वास्तविक बाधाएं

payload-block id="blk_2"

Numbered list. Translate.

1. Memory bandwidth, not just VRAM size. ... -> मेमोरी बैंडविड्थ, सिर्फ VRAM आकार नहीं। VRAM फिट निर्धारित करता है। बैंडविड्थ डिकोड गति निर्धारित करता है। Apple का M3 Ultra 819 GB/s तक यूनिफाइड-मेमोरी बैंडविड्थ प्रदान करता है। NVIDIA का H100 SXM 3.35 TB/s GPU मेमोरी बैंडविड्थ सूचीबद्ध करता है। यूनिफाइड मेमोरी आपको उन मॉडलों को फिट करने देता है जो कंज्यूमर VRAM में फिट नहीं होंगे। HBM आपको उन्हें तेज़ी से सर्व करने देता है जब मॉडल फिट हो। फिट गति नहीं है। क्षमता बैंडविड्थ नहीं है।

1. KV cache growth. KV cache grows with batch size and context length. ... -> KV कैश वृद्धि। KV कैश बैच आकार और संदर्भ लंबाई के साथ बढ़ता है। लंबे-संदर्भ वर्कलोड मेमोरी से बाहर हो सकते हैं भले ही वज़न फिट हों। PagedAttention KV कैश को ब्लॉकों में विभाजित करता है, उपयोग बढ़ाता है और बड़े बैचों का समर्थन करता है।

1. Interconnect. The moment a model crosses GPU boundaries (multi-GPUs), you pay communication cost. ... -> इंटरकनेक्ट। जैसे ही कोई मॉडल GPU सीमाओं (मल्टी-GPU) को पार करता है, आप संचार लागत चुकाते हैं। टेंसर पैरेललिज़्म को लगातार ऑल-रिड्यूज कलेक्टिव की आवश्यकता होती है। पाइपलाइन पैरेललिज़्म स्टेज सीमाओं पर संचार करता है। एक्सपर्ट पैरेललिज़्म को MoE के लिए ऑल-टू-ऑल ट्रैफ़िक की आवश्यकता होती है। vLLM के दस्तावेज़ नोट करते हैं कि NVLink के बिना, पाइपलाइन पैरेललिज़्म टेंसर पैरेललिज़्म से बेहतर प्रदर्शन कर सकता है।

1. Scheduler quality. A good scheduler decides which requests enter the batch... -> शेड्यूलर गुणवत्ता। एक अच्छा शेड्यूलर तय करता है कि कौन से अनुरोध बैच में प्रवेश करते हैं, प्रीफ़िल और डिकोड एक्सेलेरेटर को कैसे साझा करते हैं, क्या लंबे प्रॉम्प्ट छोटे डिकोड को ब्लॉक करते हैं, और स्टार्वेशन से कैसे बचें। बैचिंग का समर्थन करना प्रोडक्शन-रेडी शेड्यूलर की तरह व्यवहार करने के समान नहीं है।

1. Runtime overhead. CUDA graphs, kernel fusion, sampling overhead, tokenizer overhead, HTTP overhead, LoRA switching, and structured decoding all matter. ... -> रनटाइम ओवरहेड। CUDA ग्राफ़, कर्नल फ्यूज़न, सैंपलिंग ओवरहेड, टोकनाइज़र ओवरहेड, HTTP ओवरहेड, LoRA स्विचिंग और स्ट्रक्चर्ड डिकोडिंग सभी मायने रखते हैं। उच्च पैमाने पर, कष्टप्रद 2% ओवरहेड एक संघ बनाते हैं और ध्यान देने की मांग करते हैं।

The engine families -> ## इंजन परिवार

payload-block id="blk_3"

There are four broad families: -> चार व्यापक परिवार हैं:

Portable local runtimes: ... -> पोर्टेबल स्थानीय रनटाइम: llama.cpp, MLC LLM, ONNX Runtime GenAI, OpenVINO, Ollama-शैली के उपकरण। ये "इसे यहाँ चलाएँ" के बारे में हैं।

Apple/unified-memory runtimes: MLX and MLX-LM. These care about "use big shared memory and Apple's stack well." -> Apple/यूनिफाइड-मेमोरी रनटाइम: MLX और MLX-LM। ये "बड़ी साझा मेमोरी और Apple के स्टैक का अच्छी तरह से उपयोग करें" के बारे में हैं।

Consumer CUDA quant engines: ExLlamaV2 and ExLlamaV3. These care about "make my 3090/4090/5090 box scream with low-bit weights." -> कंज्यूमर CUDA क्वांट इंजन: ExLlamaV2 और ExLlamaV3। ये "मेरे 3090/4090/5090 बॉक्स को लो-बिट वज़न के साथ चिल्लाने दें" के बारे में हैं।

Production serving engines: vLLM, SGLang, TensorRT-LLM, TGI, LMDeploy. These care about concurrent users, KV cache, batching, parallelism, observability, and cost per token. -> प्रोडक्शन सर्विंग इंजन: vLLM, SGLang, TensorRT-LLM, TGI, LMDeploy। ये समवर्ती उपयोगकर्ताओं, KV कैश, बैचिंग, पैरेललिज़्म, अवलोकनीयता और प्रति टोकन लागत के बारे में हैं।

Then there are orchestration layers like Dynamo... -> फिर ऑर्केस्ट्रेशन लेयर हैं जैसे Dynamo जो इंजनों के ऊपर बैठते हैं और फ्लीट्स, डिसएग्रीगेटेड प्रीफ़िल/डिकोड, रूटिंग और ऑटोस्केलिंग का समन्वय करते हैं।

llama.cpp: the portability king -> ## llama.cpp: पोर्टेबिलिटी का राजा

Translate paragraph.

llama.cpp is the answer when the hardware is weird, constrained, offline, CPU-heavy, edge-oriented, or not a tidy NVIDIA datacenter node. -> llama.cpp उत्तर है जब हार्डवेयर अजीब, सीमित, ऑफ़लाइन, CPU-भारी, एज-उन्मुख या साफ-सुथरा NVIDIA डेटासेंटर नोड नहीं है।

It supports Apple Silicon via ARM NEON, Accelerate, and Metal; x86 via AVX/AVX2/AVX512/AMX; RISC-V; low-bit quantization; CUDA; AMD via HIP; MUSA; Vulkan; SYCL; and CPU+GPU hybrid offload. -> यह ARM NEON, Accelerate और Metal के माध्यम से Apple Silicon का समर्थन करता है; AVX/AVX2/AVX512/AMX के माध्यम से x86; RISC-V; लो-बिट क्वांटाइज़ेशन; CUDA; HIP के माध्यम से AMD; MUSA; Vulkan; SYCL; और CPU+GPU हाइब्रिड ऑफ़लोड।

That is why llama.cpp owns the "just make it run" lane. -> यही कारण है कि llama.cpp "बस इसे चलाएँ" लेन का मालिक है।

The HTTP server is more capable than a "toy local runner". ... -> HTTP सर्वर "टॉय लोकल रनर" से अधिक सक्षम है। llama-server OpenAI-संगत रूट, Anthropic Messages API संगतता, रीरैंकिंग, निरंतर बैचिंग, मल्टीमॉडल समर्थन, JSON स्कीमा बाधाएं, फ़ंक्शन कॉलिंग, स्पेक्युलेटिव डिकोडिंग और एक वेब UI प्रदान करता है।

The critical limitation: ... -> महत्वपूर्ण सीमा: llama.cpp गंभीर मल्टी-नोड प्रोडक्शन सर्विंग के लिए नहीं है। इसका RPC बैकएंड स्पष्ट रूप से प्रूफ-ऑफ-कॉन्सेप्ट, नाजुक और असुरक्षित के रूप में प्रलेखित है।

Verdict: Use llama.cpp when portability, offline operation, GGUF, or hybrid offload matter more than fleet-scale serving. -> निर्णय: llama.cpp का उपयोग करें जब पोर्टेबिलिटी, ऑफ़लाइन संचालन, GGUF या हाइब्रिड ऑफ़लोड फ्लीट-स्केल सर्विंग से अधिक मायने रखते हैं।

DO NOT use with Multi-GPUs -> मल्टी-GPU के साथ उपयोग न करें

MLX and MLX-LM: the Apple Silicon weapon -> ## MLX और MLX-LM: Apple Silicon हथियार

Translate.

MLX is Apple's array framework for Apple Silicon, and MLX-LM is the LLM package built on it. It is a Mac-first ML stack. -> MLX Apple Silicon के लिए Apple का ऐरे फ्रेमवर्क है, और MLX-LM इस पर बनाया गया LLM पैकेज है। यह Mac-प्रथम ML स्टैक है।

The key hardware fact is unified memory. ... -> मुख्य हार्डवेयर तथ्य यूनिफाइड मेमोरी है। Apple Silicon CPU और GPU को समान मेमोरी पूल तक सीधी पहुँच देता है। MLX ऐरे यूनिफाइड मेमोरी में रहते हैं, और आप ऑपरेशन चलाते समय डिवाइस चुनते हैं, न कि अलग-अलग मेमोरी स्पेस के बीच ऐरे को स्थानांतरित करते हैं।

This changes the local inference tradeoff. On a discrete GPU system, the question is "does it fit in VRAM?" On an M-series Mac with large unified memory, the question becomes "does it fit in memory, and can the memory system feed the GPU fast enough?" ... -> यह स्थानीय इंफ़रेंस ट्रेडऑफ़ को बदल देता है। एक अलग GPU सिस्टम पर, प्रश्न है "क्या यह VRAM में फिट होता है?" बड़ी यूनिफाइड मेमोरी वाले M-सीरीज़ Mac पर, प्रश्न बन जाता है "क्या यह मेमोरी में फिट होता है, और क्या मेमोरी सिस्टम GPU को पर्याप्त तेज़ी से फ़ीड कर सकता है?" बड़े क्वांटाइज़्ड मॉडल उन मशीनों पर फिट हो सकते हैं जहां वही मॉडल 24 GB कंज्यूमर GPU पर असंभव होगा।

However, it is also slower. -> हालाँकि, यह धीमा भी है।

MLX-LM adds Hugging Face Hub integration, quantization, LoRA and full fine-tuning, distributed inference, and a large MLX Community model ecosystem. MLX is no longer Mac-only: it offers CUDA and CPU-only packages for Linux. Distributed communication supports MPI, Ring over TCP, JACCL for RDMA over Thunderbolt, and NCCL for CUDA. -> MLX-LM Hugging Face Hub एकीकरण, क्वांटाइज़ेशन, LoRA और पूर्ण फ़ाइन-ट्यूनिंग, वितरित इंफ़रेंस और एक बड़ा MLX Community मॉडल पारिस्थितिकी तंत्र जोड़ता है। MLX अब केवल Mac नहीं है: यह Linux के लिए CUDA और CPU-केवल पैकेज प्रदान करता है। वितरित संचार MPI, TCP पर Ring, Thunderbolt पर RDMA के लिए JACCL और CUDA के लिए NCCL का समर्थन करता है।

MLX-LM's server itself warns that it is not recommended for production... -> MLX-LM का सर्वर स्वयं चेतावनी देता है कि यह प्रोडक्शन के लिए अनुशंसित नहीं है क्योंकि यह केवल बुनियादी सुरक्षा जाँच लागू करता है।

Verdict: Use MLX for Mac-first ML and LLM workflows. For high-concurrency public serving, start with a real serving stack. -> निर्णय: Mac-प्रथम ML और LLM वर्कफ़्लो के लिए MLX का उपयोग करें। उच्च-समवर्ती सार्वजनिक सर्विंग के लिए, वास्तविक सर्विंग स्टैक से शुरू करें।

ExLlamaV2 and V3: consumer CUDA, tuned and fast -> ## ExLlamaV2 और V3: कंज्यूमर CUDA, ट्यून्ड और तेज़

Translate.

ExLlamaV2 is the local CUDA quantization engine for people who want a consumer NVIDIA GPU to punch above its weight. ... -> ExLlamaV2 उन लोगों के लिए स्थानीय CUDA क्वांटाइज़ेशन इंजन है जो चाहते हैं कि कंज्यूमर NVIDIA GPU अपने वज़न से ऊपर पंच करे। यह पेज्ड अटेंशन, डायनेमिक बैचिंग, प्रॉम्प्ट कैशिंग, KV कैश डिडुप्लीकेशन, बैच्ड जनरेशन, स्ट्रीमिंग और स्पेक्युलेटिव डिकोडिंग का समर्थन करता है। याद रखने वाला शब्द है स्थानीय। यह आधुनिक CUDA GPU पर क्वांटाइज़्ड मॉडल को तेज़ बनाता है, विशेषकर कंज्यूमर कार्ड।

Best fits: one RTX 3090/4090/5090 box, local coding assistant, local chat, EXL2 quantized models, and prosumer workstation use. -> सर्वोत्तम फ़िट: एक RTX 3090/4090/5090 बॉक्स, स्थानीय कोडिंग असिस्टेंट, स्थानीय चैट, EXL2 क्वांटाइज़्ड मॉडल और प्रोज़्यूमर वर्कस्टेशन उपयोग।

ExLlamaV3 extends the philosophy toward multi-GPU and MoE-local inference. ... -> ExLlamaV3 दर्शन को मल्टी-GPU और MoE-स्थानीय इंफ़रेंस की ओर विस्तारित करता है। यह QTIP पर आधारित EXL3 क्वांटाइज़ेशन फॉर्मेट, कंज्यूमर हार्डवेयर के लिए लचीला टेंसर-पैरेलल और एक्सपर्ट-पैरेलल इंफ़रेंस, TabbyAPI के माध्यम से OpenAI-संगत सर्वर, निरंतर डायनेमिक बैचिंग और मल्टीमॉडल समर्थन जोड़ता है।

V3 is compelling when you have 2-4+ consumer NVIDIA GPUs or want local MoE. Expect caveats: some models do not support tensor or expert parallelism in ExLlamaV3. -> V3 आकर्षक है जब आपके पास 2-4+ कंज्यूमर NVIDIA GPU हों या स्थानीय MoE चाहते हों। चेतावनियाँ अपेक्षित करें: कुछ मॉडल ExLlamaV3 में टेंसर या एक्सपर्ट पैरेललिज़्म का समर्थन नहीं करते।

Verdict: ExLlamaV2 is the enthusiast's local CUDA engine. ExLlamaV3 is the frontier for multi-GPU (2-4) local setups. Expect rougher edges for better capability. -> निर्णय: ExLlamaV2 उत्साही का स्थानीय CUDA इंजन है। ExLlamaV3 मल्टी-GPU (2-4) स्थानीय सेटअप के लिए सीमा है। बेहतर क्षमता के लिए खुरदरे किनारों की अपेक्षा करें।

vLLM: the default open-source production server -> ## vLLM: डिफ़ॉल्ट ओपन-सोर्स प्रोडक्शन सर्वर

Translate.

vLLM is the first engine most teams should evaluate for serious opensource LLM serving. -> vLLM पहला इंजन है जिसका अधिकांश टीमों को गंभीर ओपनसोर्स LLM सर्विंग के लिए मूल्यांकन करना चाहिए।

It offers PagedAttention-based KV memory management, continuous batching, chunked prefill, prefix caching, CUDA/HIP graphs, extensive quantization (FP8, MXFP8/MXFP4, NVFP4, INT8, INT4, GPTQ, AWQ, GGUF), optimized attention and GEMM/MoE kernels, speculative decoding, torch.compile, and disaggregated prefill/decode/encode. -> यह PagedAttention-आधारित KV मेमोरी प्रबंधन, निरंतर बैचिंग, चंक्ड प्रीफ़िल, प्रीफ़िक्स कैशिंग, CUDA/HIP ग्राफ़, व्यापक क्वांटाइज़ेशन (FP8, MXFP8/MXFP4, NVFP4, INT8, INT4, GPTQ, AWQ, GGUF), अनुकूलित अटेंशन और GEMM/MoE कर्नल, स्पेक्युलेटिव डिकोडिंग, torch.compile और डिसएग्रीगेटेड प्रीफ़िल/डिकोड/एनकोड प्रदान करता है।

It is also flexible: tensor/pipeline/data/expert/context parallelism, streaming, structured outputs, tool calling, OpenAI-compatible and Anthropic Messages APIs, gRPC, multi-LoRA, and support for NVIDIA, AMD, x86/ARM/PowerPC CPUs, plus plugins for TPUs, Gaudi, Ascend, Apple Silicon, and more. -> यह लचीला भी है: टेंसर/पाइपलाइन/डेटा/एक्सपर्ट/संदर्भ पैरेललिज़्म, स्ट्रीमिंग, स्ट्रक्चर्ड आउटपुट, टूल कॉलिंग, OpenAI-संगत और Anthropic Messages API, gRPC, मल्टी-LoRA, और NVIDIA, AMD, x86/ARM/PowerPC CPU के लिए समर्थन, साथ ही TPU, Gaudi, Ascend, Apple Silicon और अधिक के लिए प्लगइन।

vLLM's docs note that multi-node deployments typically use Ray, and without NVLink, pipeline parallelism may beat tensor parallelism. The trap is assuming vLLM removes the need for systems thinking. You still need to tune batching, context length, GPU memory utilization, parallelism layout, and routing. vLLM gives you a very good engine; it still requires good System Design. -> vLLM के दस्तावेज़ नोट करते हैं कि मल्टी-नोड डिप्लॉयमेंट आमतौर पर Ray का उपयोग करते हैं, और NVLink के बिना, पाइपलाइन पैरेललिज़्म टेंसर पैरेललिज़्म से बेहतर हो सकता है। जाल यह मानना है कि vLLM सिस्टम सोच की आवश्यकता को हटा देता है। आपको अभी भी बैचिंग, संदर्भ लंबाई, GPU मेमोरी उपयोग, पैरेललिज़्म लेआउट और रूटिंग को ट्यून करने की आवश्यकता है। vLLM आपको एक बहुत अच्छा इंजन देता है; इसे अभी भी अच्छे सिस्टम डिज़ाइन की आवश्यकता है।

Verdict: If someone says "we need to serve open models in production," vLLM is the default starting point. -> निर्णय: अगर कोई कहता है "हमें प्रोडक्शन में ओपन मॉडल सर्व करने की आवश्यकता है," तो vLLM डिफ़ॉल्ट शुरुआती बिंदु है।

SGLang: vLLM's systems-brained cousin -> ## SGLang: vLLM का सिस्टम-दिमाग वाला चचेरा भाई

Translate.

SGLang is what you reach for when the serving workload is ugly: structured outputs, long context, MoE, disaggregation, and routing. -> SGLang वह है जिसे आप तब लेते हैं जब सर्विंग वर्कलोड बदसूरत हो: स्ट्रक्चर्ड आउटपुट, लंबा संदर्भ, MoE, डिसएग्रीगेशन और रूटिंग।

It offers RadixAttention prefix caching, prefill-decode disaggregation, speculative decoding, continuous batching, paged attention, tensor/pipeline/expert/data parallelism, structured outputs, chunked prefill, and multi-LoRA batching. It supports NVIDIA, AMD, Intel Xeon, Google TPUs, Ascend NPUs, and more. -> यह RadixAttention प्रीफ़िक्स कैशिंग, प्रीफ़िल-डिकोड डिसएग्रीगेशन, स्पेक्युलेटिव डिकोडिंग, निरंतर बैचिंग, पेज्ड अटेंशन, टेंसर/पाइपलाइन/एक्सपर्ट/डेटा पैरेललिज़्म, स्ट्रक्चर्ड आउटपुट, चंक्ड प्रीफ़िल और मल्टी-LoRA बैचिंग प्रदान करता है। यह NVIDIA, AMD, Intel Xeon, Google TPU, Ascend NPU और अधिक का समर्थन करता है।

SGLang's differentiator is serving architecture. Its prefill-decode disaggregation separates compute-intensive prefill from memory-intensive decode into specialized instances, transferring KV cache between them. This prevents long prefill batches from interrupting decode and spiking token latency. -> SGLang का विभेदक सर्विंग आर्किटेक्चर है। इसका प्रीफ़िल-डिकोड डिसएग्रीगेशन कंप्यूट-इंटेंसिव प्रीफ़िल को मेमोरी-इंटेंसिव डिकोड से अलग करके विशेष इंस्टेंस में रखता है, उनके बीच KV कैश स्थानांतरित करता है। यह लंबे प्रीफ़िल बैचों को डिकोड को बाधित करने और टोकन लेटेंसी को बढ़ाने से रोकता है।

Verdict: SGLang is for teams whose bottleneck is no longer "can we run the model?" but "can we run it under hostile traffic without torching latency, memory, and cost?" -> निर्णय: SGLang उन टीमों के लिए है जिनकी बाधा अब "क्या हम मॉडल चला सकते हैं?" नहीं है, बल्कि "क्या हम इसे प्रतिकूल ट्रैफ़िक के तहत लेटेंसी, मेमोरी और लागत को जलाए बिना चला सकते हैं?"

TensorRT-LLM: maximum NVIDIA performance -> ## TensorRT-LLM: अधिकतम NVIDIA प्रदर्शन

Translate.

TensorRT-LLM is the NVIDIA-max-performance stack. It is optimized, specialized, powerful, and not pretending to be portable. -> TensorRT-LLM NVIDIA-अधिकतम-प्रदर्शन स्टैक है। यह अनुकूलित, विशिष्ट, शक्तिशाली है और पोर्टेबल होने का दिखावा नहीं करता।

It provides Python APIs to build TensorRT engines with state-of-the-art optimizations, plus Python and C++ runtimes. It includes custom kernels for attention, GEMMs, and MoE; prefill-decode disaggregation, Wide Expert Parallelism, speculative decoding; and a high-level Python API integrated with NVIDIA Dynamo and Triton Inference Server. -> यह अत्याधुनिक अनुकूलन के साथ TensorRT इंजन बनाने के लिए Python API प्रदान करता है, साथ ही Python और C++ रनटाइम। इसमें अटेंशन, GEMM और MoE के लिए कस्टम कर्नल शामिल हैं; प्रीफ़िल-डिकोड डिसएग्रीगेशन, वाइड एक्सपर्ट पैरेललिज़्म, स्पेक्युलेटिव डिकोडिंग; और NVIDIA Dynamo और Triton Inference Server के साथ एकीकृत उच्च-स्तरीय Python API।

B200 GPUs can load FP4 weights with optimized kernels. H100 and later support FP8 quantization that can double performance and halve memory consumption versus 16-bit with minimal accuracy loss. -> B200 GPU अनुकूलित कर्नल के साथ FP4 वज़न लोड कर सकते हैं। H100 और बाद के FP8 क्वांटाइज़ेशन का समर्थन करते हैं जो 16-बिट की तुलना में प्रदर्शन को दोगुना कर सकता है और न्यूनतम सटीकता हानि के साथ मेमोरी खपत को आधा कर सकता है।

Where it shines: H100/H200/B200/GB200/GB300-class fleets, NVIDIA-only datacenters, FP8/FP4 deployment, multi-node serving, and MoE at scale. Where it is awkward: AMD, Apple, or Intel portability; fast-changing experimental models; small local setups; and teams that need "works on everything." -> यह कहाँ चमकता है: H100/H200/B200/GB200/GB300-श्रेणी के फ्लीट, केवल NVIDIA डेटासेंटर, FP8/FP4 डिप्लॉयमेंट, मल्टी-नोड सर्विंग और पैमाने पर MoE। यह कहाँ अजीब है: AMD, Apple या Intel पोर्टेबिलिटी; तेज़ी से बदलने वाले प्रायोगिक मॉडल; छोटे स्थानीय सेटअप; और टीमें जिन्हें "सब पर काम करता है" की आवश्यकता है।

Verdict: If you are committed to NVIDIA and care about absolute performance, TensorRT-LLM belongs in the bake-off. You trade portability for performance. Tuned specialization but less features. -> निर्णय: यदि आप NVIDIA के प्रति प्रतिबद्ध हैं और पूर्ण प्रदर्शन की परवाह करते हैं, तो TensorRT-LLM प्रतियोगिता में शामिल है। आप प्रदर्शन के लिए पोर्टेबिलिटी का व्यापार करते हैं। ट्यून्ड विशेषज्ञता लेकिन कम सुविधाएँ।

The rest of the field -> ## बाकी क्षेत्र

Translate each entry.

TGI is Hugging Face's production server... -> TGI Hugging Face का प्रोडक्शन सर्वर है जिसमें ट्रेसिंग, मेट्रिक्स, टेंसर पैरेललिज़्म और निरंतर बैचिंग है। इसका उपयोग करें जब HF एकीकरण और सादगी मायने रखती है।

MLC LLM is the compiler-first universal deployment engine... -> MLC LLM कंपाइलर-प्रथम सार्वभौमिक डिप्लॉयमेंट इंजन है जिसमें REST, Python, JavaScript, iOS और Android में OpenAI-संगत API हैं। "LLM को हर जगह भेजें" के लिए सर्वोत्तम, विशेषकर ब्राउज़र, मोबाइल और नेटिव ऐप।

ONNX Runtime GenAI implements the full generative loop... -> ONNX Runtime GenAI ONNX Runtime पर पूर्ण जनरेटिव लूप लागू करता है और Foundry Local, Windows ML और VS Code AI Toolkit को शक्ति प्रदान करता है। यह CPU, CUDA, DirectML, TensorRT-RTX, OpenVINO, QNN, WebGPU और AMD GPU का समर्थन करता है। ऐप डिप्लॉयमेंट और ONNX वर्कफ़्लो के लिए सर्वोत्तम।

OpenVINO GenAI is the Intel-optimized story... -> OpenVINO GenAI Xeon CPU, Arc GPU, Core Ultra और NPU के लिए Intel-अनुकूलित कहानी है। यह निरंतर बैचिंग और पेज्ड अटेंशन के साथ OpenAI-संगत सर्विंग प्रदान करता है। Intel हार्डवेयर के लिए सर्वोत्तम।

LMDeploy is a CUDA-focused toolkit... -> LMDeploy प्रदर्शन के लिए TurboMind और पहुँच के लिए PyTorch के साथ CUDA-केंद्रित टूलकिट है। उन CUDA उपयोगकर्ताओं के लिए सबसे दिलचस्प जो vLLM/SGLang/TensorRT-LLM का विकल्प चाहते हैं।

NVIDIA Dynamo is a distributed orchestration layer... -> NVIDIA Dynamo vLLM, SGLang और TensorRT-LLM जैसे इंजनों के ऊपर एक वितरित ऑर्केस्ट्रेशन लेयर है, जो डिसएग्रीगेशन, इंटेलिजेंट रूटिंग और मल्टी-टियर KV कैशिंग का समर्थन करता है। इसका उपयोग करें जब सिंगल-इंजन सर्विंग पर्याप्त नहीं है।

Note: DO NOT USE Ollama. -> नोट: Ollama का उपयोग न करें।

Hardware strategy recipes -> ## हार्डवेयर रणनीति व्यंजन

payload-block id="blk_4"

Then bullet list of hardware scenarios and recommendations. Translate.

CPU-only server: llama.cpp first. ... -> केवल CPU सर्वर: पहले llama.cpp। Intel Xeon के लिए OpenVINO। ऐप/ONNX डिप्लॉयमेंट के लिए ONNX Runtime GenAI।

MacBook / Mac Studio: MLX / MLX-LM for Mac-native workflows. llama.cpp for GGUF portability. -> MacBook / Mac Studio: Mac-नेटिव वर्कफ़्लो के लिए MLX / MLX-LM। GGUF पोर्टेबिलिटी के लिए llama.cpp।

Single RTX 3090 / 4090 / 5090: ExLlamaV2 for EXL2 local inference. llama.cpp for GGUF or portability. vLLM if serving multiple users. -> एकल RTX 3090 / 4090 / 5090: EXL2 स्थानीय इंफ़रेंस के लिए ExLlamaV2। GGUF या पोर्टेबिलिटी के लिए llama.cpp। यदि कई उपयोगकर्ताओं को सर्व कर रहे हैं तो vLLM।

Dual or quad consumer RTX box: ExLlamaV3 for multi-GPU quantized inference or MoE. vLLM if serving behavior matters. SGLang if testing routing or long-context patterns. -> दोहरा या चौगुना कंज्यूमर RTX बॉक्स: मल्टी-GPU क्वांटाइज़्ड इंफ़रेंस या MoE के लिए ExLlamaV3। यदि सर्विंग व्यवहार मायने रखता है तो vLLM। यदि रूटिंग या लंबे-संदर्भ पैटर्न का परीक्षण कर रहे हैं तो SGLang।

8×H100 / H200 node: Start with vLLM or SGLang. Benchmark TensorRT-LLM if NVIDIA-only and performance justifies tuning. Use Dynamo when multi-node orchestration becomes necessary. -> 8×H100 / H200 नोड: vLLM या SGLang से शुरू करें। यदि केवल NVIDIA और प्रदर्शन ट्यूनिंग को उचित ठहराता है तो TensorRT-LLM का बेंचमार्क करें। जब मल्टी-नोड ऑर्केस्ट्रेशन आवश्यक हो जाए तो Dynamo का उपयोग करें।

B200 / GB200 / GB300-class infrastructure: Benchmark TensorRT-LLM, SGLang, and vLLM. Add Dynamo for fleet-level orchestration, KV-aware routing, and autoscaling. -> B200 / GB200 / GB300-श्रेणी बुनियादी ढाँचा: TensorRT-LLM, SGLang और vLLM का बेंचमार्क करें। फ्लीट-स्तरीय ऑर्केस्ट्रेशन, KV-जागरूक रूटिंग और ऑटोस्केलिंग के लिए Dynamo जोड़ें।

AMD MI300 / MI325 / MI350 / MI355: Start with vLLM or SGLang on ROCm. Avoid assuming NVIDIA benchmarks transfer cleanly. -> AMD MI300 / MI325 / MI350 / MI355: ROCm पर vLLM या SGLang से शुरू करें। यह मानने से बचें कि NVIDIA बेंचमार्क साफ़-साफ़ स्थानांतरित होते हैं।

Intel Xeon / Core Ultra / Arc: OpenVINO GenAI or OpenVINO Model Server. ONNX Runtime GenAI if app embedding matters. -> Intel Xeon / Core Ultra / Arc: OpenVINO GenAI या OpenVINO Model Server। यदि ऐप एम्बेडिंग मायने रखती है तो ONNX Runtime GenAI।

Browser, mobile, app-native: MLC LLM / WebLLM or ONNX Runtime GenAI. -> ब्राउज़र, मोबाइल, ऐप-नेटिव: MLC LLM / WebLLM या ONNX Runtime GenAI।

Benchmarking: what to measure -> ## बेंचमार्किंग: क्या मापें

Bad benchmark: "I got 180 tok/s." -> खराब बेंचमार्क: "मुझे 180 tok/s मिले।"

payload-block id="blk_5"

Good benchmark includes: -> अच्छे बेंचमार्क में शामिल हैं:

Model: exact model, architecture, parameter count, active MoE params. -> मॉडल: सटीक मॉडल, आर्किटेक्चर, पैरामीटर गणना, सक्रिय MoE पैरामीटर।

Weights: dtype, quant format, group size, calibration. -> वज़न: dtype, क्वांट फॉर्मेट, ग्रुप आकार, कैलिब्रेशन।

Engine: version, commit, backend, flags. -> इंजन: संस्करण, कमिट, बैकएंड, फ्लैग।

Hardware: GPU SKU, memory capacity, bandwidth, interconnect, CPU, RAM. -> हार्डवेयर: GPU SKU, मेमोरी क्षमता, बैंडविड्थ, इंटरकनेक्ट, CPU, RAM।

Workload: input/output length distributions, concurrency, streaming, shared prefixes, structured output. -> वर्कलोड: इनपुट/आउटपुट लंबाई वितरण, समवर्ती, स्ट्रीमिंग, साझा प्रीफ़िक्स, स्ट्रक्चर्ड आउटपुट।

Metrics: TTFT, TPOT, end-to-end latency, p50/p95/p99, tokens per second, requests per second, GPU memory usage, KV cache hit rate, prefill throughput, decode throughput, cost per 1M tokens. -> मेट्रिक्स: TTFT, TPOT, एंड-टू-एंड लेटेंसी, p50/p95/p99, टोकन प्रति सेकंड, अनुरोध प्रति सेकंड, GPU मेमोरी उपयोग, KV कैश हिट दर, प्रीफ़िल थ्रूपुट, डिकोड थ्रूपुट, प्रति 1M टोकन लागत।

Benchmarking Rules: -> बेंचमार्किंग नियम:

Numbered list. Translate.

1. Never compare engines using only single-user tokens per second. -> केवल सिंगल-यूज़र टोकन प्रति सेकंड का उपयोग करके इंजनों की तुलना कभी न करें।
2. Test your actual prompt and output distribution. -> अपने वास्तविक प्रॉम्प्ट और आउटपुट वितरण का परीक्षण करें।
3. Test with realistic concurrency. -> यथार्थवादी समवर्ती के साथ परीक्षण करें।
4. Separate prefill from decode. -> प्रीफ़िल को डिकोड से अलग करें।
5. Track p95 and p99, not only averages. -> केवल औसत नहीं, बल्कि p95 और p99 ट्रैक करें।
6. Measure memory headroom at target context length. -> लक्ष्य संदर्भ लंबाई पर मेमोरी हेडरूम मापें।
7. Test cache reuse if your app has repeated prefixes. -> यदि आपके ऐप में दोहराए गए प्रीफ़िक्स हैं तो कैश पुन: उपयोग का परीक्षण करें।
8. Benchmark structured output separately; grammar adds overhead. -> स्ट्रक्चर्ड आउटपुट को अलग से बेंचमार्क करें; व्याकरण ओवरहेड जोड़ता है।
9. Benchmark LoRA and multi-LoRA separately. -> LoRA और मल्टी-LoRA को अलग-अलग बेंचमार्क करें।
10. Re-test after driver, CUDA, ROCm, model, or engine upgrades. -> ड्राइवर, CUDA, ROCm, मॉडल या इंजन अपग्रेड के बाद पुनः परीक्षण करें।

Common mistakes -> ## सामान्य गलतियाँ

Bullet list of mistakes. Translate.

Choosing by VRAM capacity alone. VRAM determines fit. Bandwidth and scheduler determine speed. A large unified-memory machine can fit huge models, but an H100 decodes faster when the model fits due to much higher HBM bandwidth. -> केवल VRAM क्षमता के आधार पर चुनना। VRAM फिट निर्धारित करता है। बैंडविड्थ और शेड्यूलर गति निर्धारित करते हैं। एक बड़ी यूनिफाइड-मेमोरी मशीन विशाल मॉडलों को फिट कर सकती है, लेकिन H100 मॉडल फिट होने पर बहुत अधिक HBM बैंडविड्थ के कारण तेज़ी से डिकोड करता है।

Using tensor parallelism on weak interconnect. Without NVLink or NVSwitch, test pipeline parallelism. vLLM's docs call this out for L40S-like setups. -> कमजोर इंटरकनेक्ट पर टेंसर पैरेललिज़्म का उपयोग करना। NVLink या NVSwitch के बिना, पाइपलाइन पैरेललिज़्म का परीक्षण करें। vLLM के दस्तावेज़ L40S-जैसे सेटअप के लिए इस पर ध्यान देते हैं।

Ignoring KV cache. Long context and concurrency can make KV cache the limiting factor. PagedAttention, prefix caching, KV quantization, and disaggregation are not optional at scale. -> KV कैश को अनदेखा करना। लंबा संदर्भ और समवर्ती KV कैश को सीमित कारक बना सकते हैं। PagedAttention, प्रीफ़िक्स कैशिंग, KV क्वांटाइज़ेशन और डिसएग्रीगेशन पैमाने पर वैकल्पिक नहीं हैं।

Treating local engines as production servers. llama.cpp server is capable. MLX-LM server is convenient. Ollama is pleasant yet SHOULD NOT BE USED. -> स्थानीय इंजनों को प्रोडक्शन सर्वर के रूप में मानना। llama.cpp सर्वर सक्षम है। MLX-LM सर्वर सुविधाजनक है। Ollama सुखद है लेकिन इसका उपयोग नहीं किया जाना चाहिए।

However, production means security, observability, backpressure, routing, autoscaling, and SLA behavior. MLX-LM itself warns that its server is not recommended for production. -> हालाँकि, प्रोडक्शन का अर्थ है सुरक्षा, अवलोकनीयता, बैकप्रेशर, रूटिंग, ऑटोस्केलिंग और SLA व्यवहार। MLX-LM स्वयं चेतावनी देता है कि इसका सर्वर प्रोडक्शन के लिए अनुशंसित नहीं है।

Assuming every quantization format is portable. GGUF, EXL2, EXL3, AWQ, GPTQ, FP8, FP4, MLX formats, and ONNX are not interchangeable. The right format is the one your engine has optimized kernels for. -> यह मानना कि हर क्वांटाइज़ेशन फॉर्मेट पोर्टेबल है। GGUF, EXL2, EXL3, AWQ, GPTQ, FP8, FP4, MLX फॉर्मेट और ONNX विनिमेय नहीं हैं। सही फॉर्मेट वह है जिसके लिए आपके इंजन के पास अनुकूलित कर्नल हैं।

Ignoring model architecture. Dense models, MoE, hybrid attention, multimodal models, and long-context variants stress different parts of the engine. Broad support does not mean every optimization works equally. -> मॉडल आर्किटेक्चर को अनदेखा करना। डेंस मॉडल, MoE, हाइब्रिड अटेंशन, मल्टीमॉडल मॉडल और लंबे-संदर्भ वेरिएंट इंजन के विभिन्न भागों पर दबाव डालते हैं। व्यापक समर्थन का मतलब यह नहीं है कि हर अनुकूलन समान रूप से काम करता है।

Trusting benchmark charts without workload shape. A chart for Llama 3.1 8B at 1K input / 128 output says little about a coding agent with 80K context running on Qwen 3.6 27B / Gemma 4 26B-A4B, or a RAG service with 500 concurrent users. -> वर्कलोड आकार के बिना बेंचमार्क चार्ट पर भरोसा करना। Llama 3.1 8B के लिए 1K इनपुट / 128 आउटपुट पर एक चार्ट Qwen 3.6 27B / Gemma 4 26B-A4B पर चलने वाले 80K संदर्भ वाले कोडिंग एजेंट या 500 समवर्ती उपयोगकर्ताओं वाली RAG सेवा के बारे में बहुत कम कहता है।

The opinionated final map -> ## रायपूर्ण अंतिम मानचित्र

Bullet list. Translate.

Local AI user: LM Studio or Harbor for convenience. llama.cpp for control. MLX on Mac. ExLlamaV2/V3 for CUDA local performance. -> स्थानीय AI उपयोगकर्ता: सुविधा के लिए LM Studio या Harbor। नियंत्रण के लिए llama.cpp। Mac पर MLX। CUDA स्थानीय प्रदर्शन के लिए ExLlamaV2/V3।

Building a local agent: Any should work, but given what most people use; llama.cpp for portability. MLX if users are on Apple Silicon. vLLM if simulating production serving locally. -> स्थानीय एजेंट बनाना: कोई भी काम करना चाहिए, लेकिन देखते हुए कि अधिकांश लोग क्या उपयोग करते हैं; पोर्टेबिलिटी के लिए llama.cpp। यदि उपयोगकर्ता Apple Silicon पर हैं तो MLX। यदि स्थानीय रूप से प्रोडक्शन सर्विंग का अनुकरण कर रहे हैं तो vLLM।

Serving an internal team: Start with vLLM. Use SGLang if structured outputs, long context, multi-LoRA, MoE, or routing matter. -> आंतरिक टीम की सेवा: vLLM से शुरू करें। यदि स्ट्रक्चर्ड आउटपुट, लंबा संदर्भ, मल्टी-LoRA, MoE या रूटिंग मायने रखते हैं तो SGLang का उपयोग करें।

Serving customers at scale: Benchmark vLLM, SGLang, and TensorRT-LLM. If routing and disaggregation matter, SGLang and Dynamo deserve attention. -> पैमाने पर ग्राहकों की सेवा: vLLM, SGLang और TensorRT-LLM का बेंचमार्क करें। यदि रूटिंग और डिसएग्रीगेशन मायने रखते हैं, तो SGLang और Dynamo ध्यान देने योग्य हैं।

NVIDIA datacenter: TensorRT-LLM for max performance. vLLM for flexibility. SGLang for complex serving. Dynamo for fleet orchestration. -> NVIDIA डेटासेंटर: अधिकतम प्रदर्शन के लिए TensorRT-LLM। लचीलेपन के लिए vLLM। जटिल सर्विंग के लिए SGLang। फ्लीट ऑर्केस्ट्रेशन के लिए Dynamo।

Apple Silicon: MLX for native development. llama.cpp for GGUF. Unified memory is a capacity superpower with bandwidth tradeoffs, not HBM. -> Apple Silicon: मूल विकास के लिए MLX। GGUF के लिए llama.cpp। यूनिफाइड मेमोरी बैंडविड्थ ट्रेडऑफ़ के साथ एक क्षमता सुपरपावर है, HBM नहीं।

Edge, app, browser, or Windows-native: llama.cpp, MLC LLM, ONNX Runtime GenAI, or OpenVINO, depending on stack. -> एज, ऐप, ब्राउज़र या Windows-नेटिव: स्टैक के आधार पर llama.cpp, MLC LLM, ONNX Runtime GenAI या OpenVINO।

Final principle -> ## अंतिम सिद्धांत

Inference Engines have consequences. -> इंफ़रेंस इंजनों के परिणाम होते हैं।

Pick the engine after answering these: -> इनका उत्तर देने के बाद इंजन चुनें:

Numbered list of questions. Translate each.

1. What hardware do I actually have? -> मेरे पास वास्तव में कौन सा हार्डवेयर है?
2. Does the model fit in fast memory, or only in system/unified memory? -> क्या मॉडल तेज़ मेमोरी में फिट होता है, या केवल सिस्टम/यूनिफाइड मेमोरी में?
3. Is decode or prefill the bottleneck? -> क्या डिकोड या प्रीफ़िल बाधा है?
4. What context length and concurrency matter? -> कौन सी संदर्भ लंबाई और समवर्ती मायने रखते हैं?
5. Are prompts shared enough for prefix caching? -> क्या प्रीफ़िक्स कैशिंग के लिए प्रॉम्प्ट पर्याप्त रूप से साझा हैं?
6. Is the model dense, MoE, multimodal, or hybrid? -> क्या मॉडल डेंस, MoE, मल्टीमॉडल या हाइब्रिड है?
7. Do I need local convenience, production serving, or fleet orchestration? -> क्या मुझे स्थानीय सुविधा, प्रोडक्शन सर्विंग या फ्लीट ऑर्केस्ट्रेशन की आवश्यकता है?
8. What quantization format has optimized kernels on my target engine? -> मेरे लक्ष्य इंजन पर किस क्वांटाइज़ेशन फॉर्मेट में अनुकूलित कर्नल हैं?
9. Is my interconnect PCIe, NVLink, NVSwitch, Ethernet, RDMA, or Thunderbolt? -> क्या मेरा इंटरकनेक्ट PCIe, NVLink, NVSwitch, Ethernet, RDMA या Thunderbolt है?
10. Am I optimizing latency, throughput, cost, privacy, portability, or developer speed? -> क्या मैं लेटेंसी, थ्रूपुट, लागत, गोपनीयता, पोर्टेबिलिटी या डेवलपर गति का अनुकूलन कर रहा हूँ?

The engine follows the answers. -> इंजन उत्तरों का अनुसरण करता है।

Until next time. -> अगली बार तक।

-Ahmad -> -Ahmad (keep as is)

Now, also note there are code-segment tags in the source? I don't see any in the provided text. The user mentioned handling them, but this text does not contain any <code-segment> tags. So we don't need to worry.

Also payload-block tags: keep exact.

The text has links: we translated link text. For example, the link to the blog post about not using llama.cpp on multi-GPUs: we translated the text "[Multi-GPUs]" to "[मल्टी-GPU]" (keeping brackets). Also the link to Harbor GitHub: we translated the link text? Actually "Harbor" is a project name, keep as is. In "Harbor", we keep "Harbor" as is.

Also note: "DO NOT USE Ollama" -> we translated "Ollama का उपयोग न करें"। But keep "Ollama" as is.

Ensure natural Hindi: use appropriate postpositions, verb forms, etc.

We'll output the full translated text with formatting.

Note: The user asked for Hindi (हिन्दी) translation. We'll write in Devanagari.

Now produce final answer.</think><blockquote>

<p>आप पहले इंफ़रेंस इंजन नहीं चुनते। आप पहले हार्डवेयर रणनीति, वर्कलोड आकार और सर्विंग मॉडल चुनते हैं। इंजन उसके बाद आता है।</p>

</blockquote>

LLM इंफ़रेंस इंजनों के बारे में सोचने का यह सबसे उपयोगी तरीका है।

सीरीज़ नोट: यह मेरी सेल्फ-होस्टेड LLMs / लोकल AI सिखाने वाली सीरीज़ का भाग 3 है।

• भाग 1: LLMs के लिए GPU मेमोरी गणित (2026 संस्करण)
• भाग 2: स्थानीय AI हार्डवेयर के लिए मेमोरी बैंडविड्थ (2026 संस्करण)

वे दो टुकड़े हार्डवेयर क्षमता और बैंडविड्थ गणित समझाते हैं।

यह वाला सॉफ्टवेयर लेयर समझाता है जो उस हार्डवेयर को उपयोगी इंफ़रेंस में बदलता है।

इंजन

ये उपकरण अलग-अलग उद्देश्यों की पूर्ति करते हैं / अलग-अलग लेयर पर काम करते हैं

• स्थानीय पोर्टेबिलिटी
• कंज्यूमर CUDA
• Apple यूनिफाइड-मेमोरी वर्कफ़्लो
• क्वांटाइज़्ड इंफ़रेंस
• प्रोडक्शन सर्विंग
• वितरित ऑर्केस्ट्रेशन
• विक्रेता-अनुकूलित डेटासेंटर निष्पादन

एक उपयोगी मानसिक मॉडल:

इंफ़रेंस इंजन "मॉडल" नहीं है। यह ट्रैफ़िक कॉप, मेमोरी मैनेजर, कर्नल डिस्पैचर, शेड्यूलर, कैश अकाउंटेंट, पैरेललिज़्म प्लानर, API सरफेस और कभी-कभी डिप्लॉयमेंट फ्रेमवर्क है।

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

एक-पेज निर्णय गाइड

• लैपटॉप / एज / अजीब हार्डवेयर → llama.cpp
• Mac-प्रथम वर्कफ़्लो → MLX / MLX-LM
• एकल RTX स्थानीय इंफ़रेंस → ExLlamaV2
• 2-4+ NVIDIA / CUDA GPU → ExLlamaV3
• सामान्य प्रोडक्शन सर्विंग → vLLM
• लंबे-संदर्भ / MoE / रूटिंग → SGLang
• NVIDIA अधिकतम प्रदर्शन → TensorRT-LLM
• क्लस्टर ऑर्केस्ट्रेशन → NVIDIA Dynamo

इस गाइड का बाकी हिस्सा क्यों समझाता है।

इंफ़रेंस इंजन वास्तव में क्या करता है

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

कार्यभार के दो चरण हैं:

प्रीफ़िल प्रॉम्प्ट पढ़ता है और प्रारंभिक KV कैश बनाता है। यह कंप्यूट-इंटेंसिव है।

डिकोड एक बार में एक टोकन उत्पन्न करता है, बार-बार वज़न और KV कैश पढ़ता है। यह मेमोरी-बैंडविड्थ-बाउंड है। डिकोड गति पीक कंप्यूट की तुलना में मेमोरी बैंडविड्थ पर अधिक निर्भर करती है।

यह अंतर लगभग सब कुछ समझाता है:

• छोटा प्रॉम्प्ट, लंबा उत्तर: डिकोड हावी होता है → मेमोरी बैंडविड्थ और बैचिंग मायने रखते हैं।
• लंबा प्रॉम्प्ट, छोटा उत्तर: प्रीफ़िल हावी होता है → अटेंशन कर्नल और चंक्ड प्रीफ़िल मायने रखते हैं।
• कई उपयोगकर्ता: शेड्यूलर गुणवत्ता मायने रखती है → निरंतर बैचिंग, कैश पेजिंग, निष्पक्षता।
• लंबा संदर्भ: KV कैश हावी होता है → पेज्ड अटेंशन, KV क्वांटाइज़ेशन, ऑफ़लोड।
• MoE: एक्सपर्ट रूटिंग हावी होती है → एक्सपर्ट पैरेललिज़्म, इंटरकनेक्ट, ग्रुप्ड GEMM।
• मल्टी-नोड: इंटरकनेक्ट हावी होता है → NVLink, RDMA, पाइपलाइन पैरेललिज़्म, डिसएग्रीगेशन।

PagedAttention ने KV कैश विखंडन को संबोधित किया। FlashAttention ने HBM ट्रैफ़िक कम करने के लिए IO-जागरूक टाइलिंग का उपयोग किया। स्पेक्युलेटिव डिकोडिंग सस्ते टोकन का मसौदा तैयार करता है और उन्हें समानांतर में सत्यापित करता है। आवर्ती विषय: इंफ़रेंस प्रदर्शन मेमोरी मूवमेंट प्लस शेड्यूलिंग है।

वास्तविक बाधाएं

1. मेमोरी बैंडविड्थ, सिर्फ VRAM आकार नहीं। VRAM फिट निर्धारित करता है। बैंडविड्थ डिकोड गति निर्धारित करता है। Apple का M3 Ultra 819 GB/s तक यूनिफाइड-मेमोरी बैंडविड्थ प्रदान करता है। NVIDIA का H100 SXM 3.35 TB/s GPU मेमोरी बैंडविड्थ सूचीबद्ध करता है। यूनिफाइड मेमोरी आपको उन मॉडलों को फिट करने देती है जो कंज्यूमर VRAM में फिट नहीं होंगे। HBM आपको उन्हें तेज़ी से सर्व करने देता है जब मॉडल फिट हो। फिट गति नहीं है। क्षमता बैंडविड्थ नहीं है।

1. KV कैश वृद्धि। KV कैश बैच आकार और संदर्भ लंबाई के साथ बढ़ता है। लंबे-संदर्भ वर्कलोड मेमोरी से बाहर हो सकते हैं भले ही वज़न फिट हों। PagedAttention KV कैश को ब्लॉकों में विभाजित करता है, उपयोग बढ़ाता है और बड़े बैचों का समर्थन करता है।

1. इंटरकनेक्ट। जैसे ही कोई मॉडल GPU सीमाओं (मल्टी-GPU) को पार करता है, आप संचार लागत चुकाते हैं। टेंसर पैरेललिज़्म को लगातार ऑल-रिड्यूज कलेक्टिव की आवश्यकता होती है। पाइपलाइन पैरेललिज़्म स्टेज सीमाओं पर संचार करता है। एक्सपर्ट पैरेललिज़्म को MoE के लिए ऑल-टू-ऑल ट्रैफ़िक की आवश्यकता होती है। vLLM के दस्तावेज़ नोट करते हैं कि NVLink के बिना, पाइपलाइन पैरेललिज़्म टेंसर पैरेललिज़्म से बेहतर प्रदर्शन कर सकता है।

1. शेड्यूलर गुणवत्ता। एक अच्छा शेड्यूलर तय करता है कि कौन से अनुरोध बैच में प्रवेश करते हैं, प्रीफ़िल और डिकोड एक्सेलेरेटर को कैसे साझा करते हैं, क्या लंबे प्रॉम्प्ट छोटे डिकोड को ब्लॉक करते हैं, और स्टार्वेशन से कैसे बचें। बैचिंग का समर्थन करना प्रोडक्शन-रेडी शेड्यूलर की तरह व्यवहार करने के समान नहीं है।

1. रनटाइम ओवरहेड। CUDA ग्राफ़, कर्नल फ्यूज़न, सैंपलिंग ओवरहेड, टोकनाइज़र ओवरहेड, HTTP ओवरहेड, LoRA स्विचिंग और स्ट्रक्चर्ड डिकोडिंग सभी मायने रखते हैं। उच्च पैमाने पर, कष्टप्रद 2% ओवरहेड एक संघ बनाते हैं और ध्यान देने की मांग करते हैं।

इंजन परिवार

चार व्यापक परिवार हैं:

पोर्टेबल स्थानीय रनटाइम: llama.cpp, MLC LLM, ONNX Runtime GenAI, OpenVINO, Ollama-शैली के उपकरण। ये "इसे यहाँ चलाएँ" के बारे में हैं।

Apple/यूनिफाइड-मेमोरी रनटाइम: MLX और MLX-LM। ये "बड़ी साझा मेमोरी और Apple के स्टैक का अच्छी तरह से उपयोग करें" के बारे में हैं।

कंज्यूमर CUDA क्वांट इंजन: ExLlamaV2 और ExLlamaV3। ये "मेरे 3090/4090/5090 बॉक्स को लो-बिट वज़न के साथ चिल्लाने दें" के बारे में हैं।

प्रोडक्शन सर्विंग इंजन: vLLM, SGLang, TensorRT-LLM, TGI, LMDeploy। ये समवर्ती उपयोगकर्ताओं, KV कैश, बैचिंग, पैरेललिज़्म, अवलोकनीयता और प्रति टोकन लागत के बारे में हैं।

फिर ऑर्केस्ट्रेशन लेयर हैं जैसे Dynamo जो इंजनों के ऊपर बैठते हैं और फ्लीट्स, डिसएग्रीगेटेड प्रीफ़िल/डिकोड, रूटिंग और ऑटोस्केलिंग का समन्वय करते हैं।

llama.cpp: पोर्टेबिलिटी का राजा

llama.cpp उत्तर है जब हार्डवेयर अजीब, सीमित, ऑफ़लाइन, CPU-भारी, एज-उन्मुख या साफ-सुथरा NVIDIA डेटासेंटर नोड नहीं है।

यह ARM NEON, Accelerate और Metal के माध्यम से Apple Silicon का समर्थन करता है; AVX/AVX2/AVX512/AMX के माध्यम से x86; RISC-V; लो-बिट क्वांटाइज़ेशन; CUDA; HIP के माध्यम से AMD; MUSA; Vulkan; SYCL; और CPU+GPU हाइब्रिड ऑफ़लोड।

यही कारण है कि llama.cpp "बस इसे चलाएँ" लेन का मालिक है।

HTTP सर्वर "टॉय लोकल रनर" से अधिक सक्षम है। llama-server OpenAI-संगत रूट, Anthropic Messages API संगतता, रीरैंकिंग, निरंतर बैचिंग, मल्टीमॉडल समर्थन, JSON स्कीमा बाधाएं, फ़ंक्शन कॉलिंग, स्पेक्युलेटिव डिकोडिंग और एक वेब UI प्रदान करता है।

महत्वपूर्ण सीमा: llama.cpp गंभीर मल्टी-नोड प्रोडक्शन सर्विंग के लिए नहीं है। इसका RPC बैकएंड स्पष्ट रूप से प्रूफ-ऑफ-कॉन्सेप्ट, नाजुक और असुरक्षित के रूप में प्रलेखित है।

निर्णय: llama.cpp का उपयोग करें जब पोर्टेबिलिटी, ऑफ़लाइन संचालन, GGUF या हाइब्रिड ऑफ़लोड फ्लीट-स्केल सर्विंग से अधिक मायने रखते हैं।

मल्टी-GPU के साथ उपयोग न करें

MLX और MLX-LM: Apple Silicon हथियार

MLX Apple Silicon के लिए Apple का ऐरे फ्रेमवर्क है, और MLX-LM इस पर बनाया गया LLM पैकेज है। यह Mac-प्रथम ML स्टैक है।

मुख्य हार्डवेयर तथ्य यूनिफाइड मेमोरी है। Apple Silicon CPU और GPU को समान मेमोरी पूल तक सीधी पहुँच देता है। MLX ऐरे यूनिफाइड मेमोरी में रहते हैं, और आप ऑपरेशन चलाते समय डिवाइस चुनते हैं, न कि अलग-अलग मेमोरी स्पेस के बीच ऐरे को स्थानांतरित करते हैं।

यह स्थानीय इंफ़रेंस ट्रेडऑफ़ को बदल देता है। एक अलग GPU सिस्टम पर, प्रश्न है "क्या यह VRAM में फिट होता है?" बड़ी यूनिफाइड मेमोरी वाले M-सीरीज़ Mac पर, प्रश्न बन जाता है "क्या यह मेमोरी में फिट होता है, और क्या मेमोरी सिस्टम GPU को पर्याप्त तेज़ी से फ़ीड कर सकता है?" बड़े क्वांटाइज़्ड मॉडल उन मशीनों पर फिट हो सकते हैं जहां वही मॉडल 24 GB कंज्यूमर GPU पर असंभव होगा।

हालाँकि, यह धीमा भी है।

MLX-LM Hugging Face Hub एकीकरण, क्वांटाइज़ेशन, LoRA और पूर्ण फ़ाइन-ट्यूनिंग, वितरित इंफ़रेंस और एक बड़ा MLX Community मॉडल पारिस्थितिकी तंत्र जोड़ता है। MLX अब केवल Mac नहीं है: यह Linux के लिए CUDA और CPU-केवल पैकेज प्रदान करता है। वितरित संचार MPI, TCP पर Ring, Thunderbolt पर RDMA के लिए JACCL और CUDA के लिए NCCL का समर्थन करता है।

MLX-LM का सर्वर स्वयं चेतावनी देता है कि यह प्रोडक्शन के लिए अनुशंसित नहीं है क्योंकि यह केवल बुनियादी सुरक्षा जाँच लागू करता है।

निर्णय: Mac-प्रथम ML और LLM वर्कफ़्लो के लिए MLX का उपयोग करें। उच्च-समवर्ती सार्वजनिक सर्विंग के लिए, वास्तविक सर्विंग स्टैक से शुरू करें।

ExLlamaV2 और V3: कंज्यूमर CUDA, ट्यून्ड और तेज़

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

सर्वोत्तम फ़िट: एक RTX 3090/4090/5090 बॉक्स, स्थानीय कोडिंग असिस्टेंट, स्थानीय चैट, EXL2 क्वांटाइज़्ड मॉडल और प्रोज़्यूमर वर्कस्टेशन उपयोग।

ExLlamaV3 दर्शन को मल्टी-GPU और MoE-स्थानीय इंफ़रेंस की ओर विस्तारित करता है। यह QTIP पर आधारित EXL3 क्वांटाइज़ेशन फॉर्मेट, कंज्यूमर हार्डवेयर के लिए लचीला टेंसर-पैरेलल और एक्सपर्ट-पैरेलल इंफ़रेंस, TabbyAPI के माध्यम से OpenAI-संगत सर्वर, निरंतर डायनेमिक बैचिंग और मल्टीमॉडल समर्थन जोड़ता है।

V3 आकर्षक है जब आपके पास 2-4+ कंज्यूमर NVIDIA GPU हों या स्थानीय MoE चाहते हों। चेतावनियाँ अपेक्षित करें: कुछ मॉडल ExLlamaV3 में टेंसर या एक्सपर्ट पैरेललिज़्म का समर्थन नहीं करते।

निर्णय: ExLlamaV2 उत्साही का स्थानीय CUDA इंजन है। ExLlamaV3 मल्टी-GPU (2-4) स्थानीय सेटअप के लिए सीमा है। बेहतर क्षमता के लिए खुरदरे किनारों की अपेक्षा करें।

vLLM: डिफ़ॉल्ट ओपन-सोर्स प्रोडक्शन सर्वर

vLLM पहला इंजन है जिसका अधिकांश टीमों को गंभीर ओपनसोर्स LLM सर्विंग के लिए मूल्यांकन करना चाहिए।

यह PagedAttention-आधारित KV मेमोरी प्रबंधन, निरंतर बैचिंग, चंक्ड प्रीफ़िल, प्रीफ़िक्स कैशिंग, CUDA/HIP ग्राफ़, व्यापक क्वांटाइज़ेशन (FP8, MXFP8/MXFP4, NVFP4, INT8, INT4, GPTQ, AWQ, GGUF), अनुकूलित अटेंशन और GEMM/MoE कर्नल, स्पेक्युलेटिव डिकोडिंग, torch.compile और डिसएग्रीगेटेड प्रीफ़िल/डिकोड/एनकोड प्रदान करता है।

यह लचीला भी है: टेंसर/पाइपलाइन/डेटा/एक्सपर्ट/संदर्भ पैरेललिज़्म, स्ट्रीमिंग, स्ट्रक्चर्ड आउटपुट, टूल कॉलिंग, OpenAI-संगत और Anthropic Messages API, gRPC, मल्टी-LoRA, और NVIDIA, AMD, x86/ARM/PowerPC CPU के लिए समर्थन, साथ ही TPU, Gaudi, Ascend, Apple Silicon और अधिक के लिए प्लगइन।

vLLM के दस्तावेज़ नोट करते हैं कि मल्टी-नोड डिप्लॉयमेंट आमतौर पर Ray का उपयोग करते हैं, और NVLink के बिना, पाइपलाइन पैरेललिज़्म टेंसर पैरेललिज़्म से बेहतर हो सकता है। जाल यह मानना है कि vLLM सिस्टम सोच की आवश्यकता को हटा देता है। आपको अभी भी बैचिंग, संदर्भ लंबाई, GPU मेमोरी उपयोग, पैरेललिज़्म लेआउट और रूटिंग को ट्यून करने की आवश्यकता है। vLLM आपको एक बहुत अच्छा इंजन देता है; इसे अभी भी अच्छे सिस्टम डिज़ाइन की आवश्यकता है।

निर्णय: अगर कोई कहता है "हमें प्रोडक्शन में ओपन मॉडल सर्व करने की आवश्यकता है," तो vLLM डिफ़ॉल्ट शुरुआती बिंदु है।

SGLang: vLLM का सिस्टम-दिमाग वाला चचेरा भाई

SGLang वह है जिसे आप तब लेते हैं जब सर्विंग वर्कलोड बदसूरत हो: स्ट्रक्चर्ड आउटपुट, लंबा संदर्भ, MoE, डिसएग्रीगेशन और रूटिंग।

यह RadixAttention प्रीफ़िक्स कैशिंग, प्रीफ़िल-डिकोड डिसएग्रीगेशन, स्पेक्युलेटिव डिकोडिंग, निरंतर बैचिंग, पेज्ड अटेंशन, टेंसर/पाइपलाइन/एक्सपर्ट/डेटा पैरेललिज़्म, स्ट्रक्चर्ड आउटपुट, चंक्ड प्रीफ़िल और मल्टी-LoRA बैचिंग प्रदान करता है। यह NVIDIA, AMD, Intel Xeon, Google TPU, Ascend NPU और अधिक का समर्थन करता है।

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

निर्णय: SGLang उन टीमों के लिए है जिनकी बाधा अब "क्या हम मॉडल चला सकते हैं?" नहीं है, बल्कि "क्या हम इसे प्रतिकूल ट्रैफ़िक के तहत लेटेंसी, मेमोरी और लागत को जलाए बिना चला सकते हैं?"

TensorRT-LLM: अधिकतम NVIDIA प्रदर्शन

TensorRT-LLM NVIDIA-अधिकतम-प्रदर्शन स्टैक है। यह अनुकूलित, विशिष्ट, शक्तिशाली है और पोर्टेबल होने का दिखावा नहीं करता।

यह अत्याधुनिक अनुकूलन के साथ TensorRT इंजन बनाने के लिए Python API प्रदान करता है, साथ ही Python और C++ रनटाइम। इसमें अटेंशन, GEMM और MoE के लिए कस्टम कर्नल शामिल हैं; प्रीफ़िल-डिकोड डिसएग्रीगेशन, वाइड एक्सपर्ट पैरेललिज़्म, स्पेक्युलेटिव डिकोडिंग; और NVIDIA Dynamo और Triton Inference Server के साथ एकीकृत उच्च-स्तरीय Python API।

B200 GPU अनुकूलित कर्नल के साथ FP4 वज़न लोड कर सकते हैं। H100 और बाद के FP8 क्वांटाइज़ेशन का समर्थन करते हैं जो 16-बिट की तुलना में प्रदर्शन को दोगुना कर सकता है और न्यूनतम सटीकता हानि के साथ मेमोरी खपत को आधा कर सकता है।

यह कहाँ चमकता है: H100/H200/B200/GB200/GB300-श्रेणी के फ्लीट, केवल NVIDIA डेटासेंटर, FP8/FP4 डिप्लॉयमेंट, मल्टी-नोड सर्विंग और पैमाने पर MoE। यह कहाँ अजीब है: AMD, Apple या Intel पोर्टेबिलिटी; तेज़ी से बदलने वाले प्रायोगिक मॉडल; छोटे स्थानीय सेटअप; और टीमें जिन्हें "सब पर काम करता है" की आवश्यकता है।

निर्णय: यदि आप NVIDIA के प्रति प्रतिबद्ध हैं और पूर्ण प्रदर्शन की परवाह करते हैं, तो TensorRT-LLM प्रतियोगिता में शामिल है। आप प्रदर्शन के लिए पोर्टेबिलिटी का व्यापार करते हैं। ट्यून्ड विशेषज्ञता लेकिन कम सुविधाएँ।

बाकी क्षेत्र

TGI Hugging Face का प्रोडक्शन सर्वर है जिसमें ट्रेसिंग, मेट्रिक्स, टेंसर पैरेललिज़्म और निरंतर बैचिंग है। इसका उपयोग करें जब HF एकीकरण और सादगी मायने रखती है।

MLC LLM कंपाइलर-प्रथम सार्वभौमिक डिप्लॉयमेंट इंजन है जिसमें REST, Python, JavaScript, iOS और Android में OpenAI-संगत API हैं। "LLM को हर जगह भेजें" के लिए सर्वोत्तम, विशेषकर ब्राउज़र, मोबाइल और नेटिव ऐप।

ONNX Runtime GenAI ONNX Runtime पर पूर्ण जनरेटिव लूप लागू करता है और Foundry Local, Windows ML और VS Code AI Toolkit को शक्ति प्रदान करता है। यह CPU, CUDA, DirectML, TensorRT-RTX, OpenVINO, QNN, WebGPU और AMD GPU का समर्थन करता है। ऐप डिप्लॉयमेंट और ONNX वर्कफ़्लो के लिए सर्वोत्तम।

OpenVINO GenAI Xeon CPU, Arc GPU, Core Ultra और NPU के लिए Intel-अनुकूलित कहानी है। यह निरंतर बैचिंग और पेज्ड अटेंशन के साथ OpenAI-संगत सर्विंग प्रदान करता है। Intel हार्डवेयर के लिए सर्वोत्तम।

LMDeploy प्रदर्शन के लिए TurboMind और पहुँच के लिए PyTorch के साथ CUDA-केंद्रित टूलकिट है। उन CUDA उपयोगकर्ताओं के लिए सबसे दिलचस्प जो vLLM/SGLang/TensorRT-LLM का विकल्प चाहते हैं।

NVIDIA Dynamo vLLM, SGLang और TensorRT-LLM जैसे इंजनों के ऊपर एक वितरित ऑर्केस्ट्रेशन लेयर है, जो डिसएग्रीगेशन, इंटेलिजेंट रूटिंग और मल्टी-टियर KV कैशिंग का समर्थन करता है। इसका उपयोग करें जब सिंगल-इंजन सर्विंग पर्याप्त नहीं है।

नोट: Ollama का उपयोग न करें।

हार्डवेयर रणनीति व्यंजन

केवल CPU सर्वर: पहले llama.cpp। Intel Xeon के लिए OpenVINO। ऐप/ONNX डिप्लॉयमेंट के लिए ONNX Runtime GenAI।

MacBook / Mac Studio: Mac-नेटिव वर्कफ़्लो के लिए MLX / MLX-LM। GGUF पोर्टेबिलिटी के लिए llama.cpp।

एकल RTX 3090 / 4090 / 5090: EXL2 स्थानीय इंफ़रेंस के लिए ExLlamaV2। GGUF या पोर्टेबिलिटी के लिए llama.cpp। यदि कई उपयोगकर्ताओं को सर्व कर रहे हैं तो vLLM।

दोहरा या चौगुना कंज्यूमर RTX बॉक्स: मल्टी-GPU क्वांटाइज़्ड इंफ़रेंस या MoE के लिए ExLlamaV3। यदि सर्विंग व्यवहार मायने रखता है तो vLLM। यदि रूटिंग या लंबे-संदर्भ पैटर्न का परीक्षण कर रहे हैं तो SGLang।

8×H100 / H200 नोड: vLLM या SGLang से शुरू करें। यदि केवल NVIDIA और प्रदर्शन ट्यूनिंग को उचित ठहराता है तो TensorRT-LLM का बेंचमार्क करें। जब मल्टी-नोड ऑर्केस्ट्रेशन आवश्यक हो जाए तो Dynamo का उपयोग करें।

B200 / GB200 / GB300-श्रेणी बुनियादी ढाँचा: TensorRT-LLM, SGLang और vLLM का बेंचमार्क करें। फ्लीट-स्तरीय ऑर्केस्ट्रेशन, KV-जागरूक रूटिंग और ऑटोस्केलिंग के लिए Dynamo जोड़ें।

AMD MI300 / MI325 / MI350 / MI355: ROCm पर vLLM या SGLang से शुरू करें। यह मानने से बचें कि NVIDIA बेंचमार्क साफ़-साफ़ स्थानांतरित होते हैं।

Intel Xeon / Core Ultra / Arc: OpenVINO GenAI या OpenVINO Model Server। यदि ऐप एम्बेडिंग मायने रखती है तो ONNX Runtime GenAI।

ब्राउज़र, मोबाइल, ऐप-नेटिव: MLC LLM / WebLLM या ONNX Runtime GenAI।

बेंचमार्किंग: क्या मापें

खराब बेंचमार्क: "मुझे 180 tok/s मिले।"

अच्छे बेंचमार्क में शामिल हैं:

मॉडल: सटीक मॉडल, आर्किटेक्चर, पैरामीटर गणना, सक्रिय MoE पैरामीटर।

वज़न: dtype, क्वांट फॉर्मेट, ग्रुप आकार, कैलिब्रेशन।

इंजन: संस्करण, कमिट, बैकएंड, फ्लैग।

हार्डवेयर: GPU SKU, मेमोरी क्षमता, बैंडविड्थ, इंटरकनेक्ट, CPU, RAM।

वर्कलोड: इनपुट/आउटपुट लंबाई वितरण, समवर्ती, स्ट्रीमिंग, साझा प्रीफ़िक्स, स्ट्रक्चर्ड आउटपुट।

मेट्रिक्स: TTFT, TPOT, एंड-टू-एंड लेटेंसी, p50/p95/p99, टोकन प्रति सेकंड, अनुरोध प्रति सेकंड, GPU मेमोरी उपयोग, KV कैश हिट दर, प्रीफ़िल थ्रूपुट, डिकोड थ्रूपुट, प्रति 1M टोकन लागत।

बेंचमार्किंग नियम:

1. केवल सिंगल-यूज़र टोकन प्रति सेकंड का उपयोग करके इंजनों की तुलना कभी न करें।
2. अपने वास्तविक प्रॉम्प्ट और आउटपुट वितरण का परीक्षण करें।
3. यथार्थवादी समवर्ती के साथ परीक्षण करें।
4. प्रीफ़िल को डिकोड से अलग करें।
5. केवल औसत नहीं, बल्कि p95 और p99 ट्रैक करें।
6. लक्ष्य संदर्भ लंबाई पर मेमोरी हेडरूम मापें।
7. यदि आपके ऐप में दोहराए गए प्रीफ़िक्स हैं तो कैश पुन: उपयोग का परीक्षण करें।
8. स्ट्रक्चर्ड आउटपुट को अलग से बेंचमार्क करें; व्याकरण ओवरहेड जोड़ता है।
9. LoRA और मल्टी-LoRA को अलग-अलग बेंचमार्क करें।
10. ड्राइवर, CUDA, ROCm, मॉडल या इंजन अपग्रेड के बाद पुनः परीक्षण करें।

सामान्य गलतियाँ

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

कमजोर इंटरकनेक्ट पर टेंसर पैरेललिज़्म का उपयोग करना। NVLink या NVSwitch के बिना, पाइपलाइन पैरेललिज़्म का परीक्षण करें। vLLM के दस्तावेज़ L40S-जैसे सेटअप के लिए इस पर ध्यान देते हैं।

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

स्थानीय इंजनों को प्रोडक्शन सर्वर के रूप में मानना। llama.cpp सर्वर सक्षम है। MLX-LM सर्वर सुविधाजनक है। Ollama सुखद है लेकिन इसका उपयोग नहीं किया जाना चाहिए।

हालाँकि, प्रोडक्शन का अर्थ है सुरक्षा, अवलोकनीयता, बैकप्रेशर, रूटिंग, ऑटोस्केलिंग और SLA व्यवहार। MLX-LM स्वयं चेतावनी देता है कि इसका सर्वर प्रोडक्शन के लिए अनुशंसित नहीं है।

यह मानना कि हर क्वांटाइज़ेशन फॉर्मेट पोर्टेबल है। GGUF, EXL2, EXL3, AWQ, GPTQ, FP8, FP4, MLX फॉर्मेट और ONNX विनिमेय नहीं हैं। सही फॉर्मेट वह है जिसके लिए आपके इंजन के पास अनुकूलित कर्नल हैं।

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

वर्कलोड आकार के बिना बेंचमार्क चार्ट पर भरोसा करना। Llama 3.1 8B के लिए 1K इनपुट / 128 आउटपुट पर एक चार्ट Qwen 3.6 27B / Gemma 4 26B-A4B पर चलने वाले 80K संदर्भ वाले कोडिंग एजेंट या 500 समवर्ती उपयोगकर्ताओं वाली RAG सेवा के बारे में बहुत कम कहता है।

रायपूर्ण अंतिम मानचित्र

स्थानीय AI उपयोगकर्ता: सुविधा के लिए LM Studio या Harbor। नियंत्रण के लिए llama.cpp। Mac पर MLX। CUDA स्थानीय प्रदर्शन के लिए ExLlamaV2/V3।

स्थानीय एजेंट बनाना: कोई भी काम करना चाहिए, लेकिन देखते हुए कि अधिकांश लोग क्या उपयोग करते हैं; पोर्टेबिलिटी के लिए llama.cpp। यदि उपयोगकर्ता Apple Silicon पर हैं तो MLX। यदि स्थानीय रूप से प्रोडक्शन सर्विंग का अनुकरण कर रहे हैं तो vLLM।

आंतरिक टीम की सेवा: vLLM से शुरू करें। यदि स्ट्रक्चर्ड आउटपुट, लंबा संदर्भ, मल्टी-LoRA, MoE या रूटिंग मायने रखते हैं तो SGLang का उपयोग करें।

पैमाने पर ग्राहकों की सेवा: vLLM, SGLang और TensorRT-LLM का बेंचमार्क करें। यदि रूटिंग और डिसएग्रीगेशन मायने रखते हैं, तो SGLang और Dynamo ध्यान देने योग्य हैं।

NVIDIA डेटासेंटर: अधिकतम प्रदर्शन के लिए TensorRT-LLM। लचीलेपन के लिए vLLM। जटिल सर्विंग के लिए SGLang। फ्लीट ऑर्केस्ट्रेशन के लिए Dynamo।

Apple Silicon: मूल विकास के लिए MLX। GGUF के लिए llama.cpp। यूनिफाइड मेमोरी बैंडविड्थ ट्रेडऑफ़ के साथ एक क्षमता सुपरपावर है, HBM नहीं।

एज, ऐप, ब्राउज़र या Windows-नेटिव: स्टैक के आधार पर llama.cpp, MLC LLM, ONNX Runtime GenAI या OpenVINO।

अंतिम सिद्धांत

इंफ़रेंस इंजनों के परिणाम होते हैं।

इनका उत्तर देने के बाद इंजन चुनें:

1. मेरे पास वास्तव में कौन सा हार्डवेयर है?
2. क्या मॉडल तेज़ मेमोरी में फिट होता है, या केवल सिस्टम/यूनिफाइड मेमोरी में?
3. क्या डिकोड या प्रीफ़िल बाधा है?
4. कौन सी संदर्भ लंबाई और समवर्ती मायने रखते हैं?
5. क्या प्रीफ़िक्स कैशिंग के लिए प्रॉम्प्ट पर्याप्त रूप से साझा हैं?
6. क्या मॉडल डेंस, MoE, मल्टीमॉडल या हाइब्रिड है?
7. क्या मुझे स्थानीय सुविधा, प्रोडक्शन सर्विंग या फ्लीट ऑर्केस्ट्रेशन की आवश्यकता है?
8. मेरे लक्ष्य इंजन पर किस क्वांटाइज़ेशन फॉर्मेट में अनुकूलित कर्नल हैं?
9. क्या मेरा इंटरकनेक्ट PCIe, NVLink, NVSwitch, Ethernet, RDMA या Thunderbolt है?
10. क्या मैं लेटेंसी, थ्रूपुट, लागत, गोपनीयता, पोर्टेबिलिटी या डेवलपर गति का अनुकूलन कर रहा हूँ?

इंजन उत्तरों का अनुसरण करता है।

अगली बार तक।

-अहमद