LLM Inference Engines ବ୍ୟାଖ୍ୟା: llama.cpp, vLLM, SGLang, mistral.rs, PyTorch ଏବଂ LiteRT-LM

ଏକ ମଡେଲ୍ ଫାଇଲ୍ ନିଜେ କିଛି କରେ ନାହିଁ। ଏହା ସଂଖ୍ୟାଗୁଡ଼ିକର ଏକ ବିରାଟ ଗଦା, ଏବଂ ଅନ୍ୟ ଏକ ପ୍ରୋଗ୍ରାମକୁ ସେହି ସଂଖ୍ୟାଗୁଡ଼ିକୁ ଲୋଡ୍ କରିବାକୁ, ଟେକ୍ସଟ୍ ପ୍ରବେଶ କରାଇବାକୁ ଏବଂ ଉତ୍ତର ବାହାର କରିବାକୁ ପଡ଼ିଥାଏ। ସେହି ପ୍ରୋଗ୍ରାମକୁ କୁହାଯାଏ ଏକ inference engine, ଏବଂ ଉପଯୁକ୍ତ ଇଞ୍ଜିନ୍ ବାଛିବା ମଡେଲ୍ ବାଛିବା ଭଳି ହିଁ ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ।

ଆଜି ହେଉଛି November 12, 2026। ପେଡ୍ AI ସେବାଗୁଡ଼ିକ ଯାହା କରିପାରନ୍ତି, ଓପନ୍ ମଡେଲ୍‌ଗୁଡ଼ିକ ଏବେ ପ୍ରାୟ ତାହା ନିକଟତର ହୋଇପାରିଛନ୍ତି, ଏବଂ ଅନେକ ଟିମ୍ ଗୋପନୀୟତା, ଖର୍ଚ୍ଚ କିମ୍ବା ଅଫଲାଇନ୍ ବ୍ୟବହାର ପାଇଁ ସେଗୁଡ଼ିକୁ ନିଜ ହାର୍ଡୱେର୍‌ରେ ଚଳାଇବାକୁ ଚାହାଁନ୍ତି। ତା’ପରେ ସେମାନେ କିଛି ଅଦ୍ଭୁତ ନାମର ତାଲିକା ଭେଟନ୍ତି: llama.cpp, vLLM, SGLang, mistral.rs, PyTorch, LiteRT-LM। ଏହି ପୋଷ୍ଟରେ ବୁଝାଯାଇଛି ଯେ ଏହି ଟୁଲ୍ସ ପରିବାରକୁ କ’ଣ କୁହାଯାଏ, ପ୍ରତ୍ୟେକ କାହିଁକି ରହିଛି, ଏବଂ ଆମର ଉଦାହରଣ ଇଞ୍ଜିନିୟର Rohit କେବେ କେଉଁଟି ବ୍ୟବହାର କରିବେ।

ଏହି ଟୁଲ୍ସଗୁଡ଼ିକୁ ଆମେ କ’ଣ କହିଥାଉ

ଏହାର ସାଧାରଣ ନାମ ହେଉଛି LLM inference engines। ଆପଣ ଏଗୁଡ଼ିକୁ model runtimes, serving engines କିମ୍ବା serving frameworks ବୋଲି ମଧ୍ୟ କୁହାଯିବାର ଦେଖିବେ। କିଛି ସଂକ୍ଷିପ୍ତ ସଂଜ୍ଞା:

• Inference ର ଅର୍ଥ ହେଉଛି ଉତ୍ତର ପ୍ରଦାନ କରିବା ପାଇଁ ଏକ ପ୍ରଶିକ୍ଷିତ ମଡେଲ୍ ବ୍ୟବହାର କରିବା। Training ମଡେଲ୍‌କୁ ଶିଖାଏ; inference ହେଉଛି ଏହାକୁ ପ୍ରଶ୍ନ ପଚାରିବା।
• Serving ର ଅର୍ଥ ହେଉଛି ଏକ ସର୍ଭିସ୍ ଭାବରେ ମଡେଲ୍ ଚଳାଇବା, ସାଧାରଣତଃ ଏକ HTTP API ଭାବରେ, ଯାହାଫଳରେ ଅନେକ ଉପଭୋକ୍ତା କିମ୍ବା ଆପ୍ ଏକାସାଙ୍ଗରେ ଏହାକୁ କଲ୍ କରିପାରିବେ।
• Runtime ହେଉଛି ସେହି low-level କୋଡ୍ ଯାହା CPU, GPU କିମ୍ବା ଫୋନ୍ ଚିପ୍‌ରେ ଗାଣିତିକ ହିସାବ କରିଥାଏ।

ତାଲିକାରେ ଥିବା ସମସ୍ତ ଛଅଟି ଟୁଲ୍ ସମାନ model weights ନିଅନ୍ତି ଏବଂ ସେଗୁଡ଼ିକୁ ଉତ୍ତରରେ ପରିଣତ କରନ୍ତି। ସେଗୁଡ଼ିକ କେଉଁଠାରେ ସବୁଠାରୁ ଭଲ ଚାଲନ୍ତି (ଲାପଟପ୍, ବଡ଼ GPU ସର୍ଭର କିମ୍ବା ଫୋନ୍), ଏକାଥରକେ କେତେ ଉପଭୋକ୍ତାଙ୍କୁ ପରିଚାଳନା କରନ୍ତି, ଏବଂ ସେମାନଙ୍କର କେତେ ମେମୋରୀ ଆବଶ୍ୟକ ହୁଏ, ସେଥିରେ ସେମାନଙ୍କ ମଧ୍ୟରେ ପାର୍ଥକ୍ୟ ଥାଏ।

ଇଞ୍ଜିନ୍ କାହିଁକି ଏତେ ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ

ଇଞ୍ଜିନ୍ ଉପରେ ନିର୍ଭର କରି ଗୋଟିଏ ମଡେଲ୍ ବହୁତ ଦ୍ରୁତ କିମ୍ବା କଷ୍ଟଦାୟକ ଭାବରେ ମନ୍ଥର ଅନୁଭୂତ ହୋଇପାରେ। ତିନୋଟି ଜିନିଷ ଏହା ନିର୍ଣ୍ଣୟ କରେ:

1. Memory। ଏକ ମଡେଲ୍‌କୁ RAM କିମ୍ବା GPU memory ରେ ଫିଟ୍ ହେବାକୁ ପଡ଼ିବ। କିଛି ଇଞ୍ଜିନ୍ ସପୋର୍ଟ କରନ୍ତି quantization, ଯାହା ସଂଖ୍ୟାଗୁଡ଼ିକୁ କମ୍ ବିଟ୍‌ରେ ସାଇତି ରଖେ (ଉଦାହରଣ ସ୍ୱରୂପ 16 bits ବଦଳରେ 4 bits)। ମଡେଲ୍ ପ୍ରାୟ ତିନିରୁ ଚାରି ଗୁଣ ଛୋଟ ହୋଇଯାଏ ଏବଂ ଗୁଣବତ୍ତାରେ ସାମାନ୍ୟ କ୍ଷତି ସହିତ ଶସ୍ତା ହାର୍ଡୱେର୍‌ରେ ଚାଲିପାରେ।
2. Throughput। ଏହା ହେଉଛି ଏକାସାଙ୍ଗରେ ଅନେକ ଉପଭୋକ୍ତାଙ୍କ ପାଇଁ ଇଞ୍ଜିନ୍ ପ୍ରତି ସେକେଣ୍ଡରେ କେତେ ଉତ୍ତର ପ୍ରସ୍ତୁତ କରିପାରିବ। ସର୍ଭର ଇଞ୍ଜିନ୍‌ଗୁଡ଼ିକ ଏପରି କୌଶଳ ବ୍ୟବହାର କରନ୍ତି ଯେପରିକି continuous batching (ନୂତନ ରିକ୍ୱେଷ୍ଟଗୁଡ଼ିକ ନିଜ ପାଳିକୁ ଅପେକ୍ଷା କରିବା ବଦଳରେ ଚାଲୁଥିବା ବ୍ୟାଚ୍‌ରେ ଯୋଡ଼ି ହୁଅନ୍ତି) ଯାହାଫଳରେ GPU ସବୁବେଳେ ବ୍ୟସ୍ତ ରୁହେ।
3. Latency। ଜଣେ ଉପଭୋକ୍ତା କେତେ ଶୀଘ୍ର ପ୍ରଥମ ଶବ୍ଦ ଦେଖିପାରନ୍ତି, ଏହା ହେଉଛି ତାହା। ଚାଟ୍ ପାଇଁ ଏହା raw throughput ତୁଳନାରେ ଅଧିକ ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ।

ଏକ ଭୁଲ୍ ଚୟନ ବହୁତ ମହଙ୍ଗା ପଡ଼ିପାରେ। Rohit ଏକ ଦାମୀ GPU ଭଡ଼ାରେ ନେଇ ମଧ୍ୟ କେବଳ କିଛି ଉପଭୋକ୍ତାଙ୍କୁ ସେବା ଦେଇପାରନ୍ତି, କିମ୍ବା ଏପରି ଏକ ମଡେଲ୍ ଲୋଡ୍ କରିବାକୁ ଚେଷ୍ଟା କରିପାରନ୍ତି ଯାହା ଲାପଟପ୍‌ରେ କେବେବି ଫିଟ୍ ହୁଏ ନାହିଁ।

ଛଅଟି ଇଞ୍ଜିନ୍, ଗୋଟିଏ ପରେ ଗୋଟିଏ

llama.cpp: ପ୍ରାୟ ସବୁଠାରେ ଚାଲେ

llama.cpp ହେଉଛି ସାଧାରଣ ହାର୍ଡୱେର୍‌ରେ ମଡେଲ୍ ଚଳାଇବା ପାଇଁ C ଏବଂ C++ ରେ ନିର୍ମିତ ଏକ ଇଞ୍ଜିନ୍। ଏହା ନିଜସ୍ୱ ଫାଇଲ୍ ଫର୍ମାଟ୍ ବ୍ୟବହାର କରେ, GGUF, ଯାହା ଏକ quantized ମଡେଲ୍‌କୁ ଗୋଟିଏ ଫାଇଲ୍‌ରେ ପ୍ୟାକ୍ କରିଥାଏ। ଏହା plain CPUs, Apple Silicon, NVIDIA ଏବଂ AMD GPUs ତଥା ଆହୁରି ଅନେକରେ ଚାଲେ। Ollama ଏବଂ LM Studio ଭଳି ଲୋକପ୍ରିୟ ଡେସ୍କଟପ୍ ଟୁଲ୍ସ ଏହା ଉପରେ ନିର୍ମିତ ହୋଇଛି।

ବ୍ୟବହାରିକ ଉଦାହରଣ। Rohit ଜଣେ ପରାମର୍ଶଦାତା ଯିଏ କ୍ଲାଏଣ୍ଟ କଣ୍ଟ୍ରାକ୍ଟ ସମୀକ୍ଷା କରନ୍ତି ଏବଂ ସେଗୁଡ଼ିକୁ କୌଣସି ପବ୍ଲିକ୍ ଚାଟବଟ୍‌ରେ ପେଷ୍ଟ କରିପାରିବେ ନାହିଁ। llama.cpp ସାହାଯ୍ୟରେ ସେ ନିଜ ଲାପଟପ୍‌ରେ ସମ୍ପୂର୍ଣ୍ଣ ଅଫଲାଇନ୍‌ରେ ଏକ ଛୋଟ quantized ମଡେଲ୍ ଚଳାନ୍ତି, ଏବଂ ମେସିନ୍ ବାହାରକୁ କୌଣସି ଟେକ୍ସଟ୍ ନପଠାଇ ଡକ୍ୟୁମେଣ୍ଟଗୁଡ଼ିକର ସାରାଂଶ ପ୍ରସ୍ତୁତ କରନ୍ତି।

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

vLLM: GPU ସର୍ଭରଗୁଡ଼ିକ ପାଇଁ workhorse

vLLM ହେଉଛି GPU ରେ ଏକାସାଙ୍ଗରେ ଅନେକ ଉପଭୋକ୍ତାଙ୍କୁ ମଡେଲ୍ ସର୍ଭ କରିବା ପାଇଁ ଏକ Python ଇଞ୍ଜିନ୍। ଏହାର ମୁଖ୍ୟ ଧାରଣା ହେଉଛି PagedAttention। ଉତ୍ତର ଦେବା ସମୟରେ, ଏକ ମଡେଲ୍ ପୂର୍ବ ଟୋକେନଗୁଡ଼ିକର ଏକ ସ୍କ୍ରାଚପ୍ୟାଡ୍ ରଖେ ଯାହାକୁ କୁହାଯାଏ KV cache। vLLM ସେହି ସ୍କ୍ରାଚପ୍ୟାଡ୍‌କୁ ଛୋଟ ପୃଷ୍ଠାଗୁଡ଼ିକରେ (pages) ସାଇତି ରଖେ, ଯେପରି ଏକ operating system ମେମୋରୀ ପରିଚାଳନା କରେ, ତେଣୁ ଖୁବ୍ କମ୍ GPU memory ନଷ୍ଟ ହୁଏ ଏବଂ ଏକାସାଙ୍ଗରେ ବହୁତ ଅଧିକ ରିକ୍ୱେଷ୍ଟ ସ୍ଥାନ ପାଇଥାଏ। continuous batching ସହିତ ମିଶି, ଏହା ଗୋଟିଏ GPU କୁ ଅନେକ ଉପଭୋକ୍ତାଙ୍କୁ ସେବା ଦେବାକୁ ସକ୍ଷମ କରେ।

ବ୍ୟବହାରିକ ଉଦାହରଣ। Rohit ଙ୍କ କମ୍ପାନୀ, Acme, 300 କର୍ମଚାରୀଙ୍କ ପାଇଁ ଏକ ଆଭ୍ୟନ୍ତରୀଣ ସହାୟକ ଚାହୁଁଛି। ପ୍ରତ୍ୟେକ ପ୍ରଶ୍ନ ପାଇଁ ଏକ ପେଡ୍ API କଲ୍ କରିବା ମହଙ୍ଗା ହେଉଛି, ଏବଂ କିଛି ଡାଟା in-house ରହିବା ଆବଶ୍ୟକ। Rohit ଗୋଟିଏ GPU ସର୍ଭରରେ vLLM ସ୍ଥାପନ କରନ୍ତି, ଏବଂ ଏହା ଏକ OpenAI-compatible API ପ୍ରଦାନ କରୁଥିବାରୁ, ବିଦ୍ୟମାନ ଚାଟ୍ ଆପ୍ ପାଇଁ କେବଳ ଏକ ନୂତନ base URL ଆବଶ୍ୟକ ହୁଏ।

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

SGLang: ଏଜେଣ୍ଟ ଏବଂ ପୁନରାବୃତ୍ତ ପ୍ରମ୍ପ୍ଟଗୁଡ଼ିକ ପାଇଁ ଦ୍ରୁତ

SGLang ହେଉଛି ଆଉ ଏକ high-performance serving engine। ଯେତେବେଳେ ଅନେକ ରିକ୍ୱେଷ୍ଟ ସମାନ ଆରମ୍ଭ ଅଂଶ ସେୟାର କରନ୍ତି, ଯେପରିକି ଏକ ଦୀର୍ଘ system prompt, ଏକ ସେୟାର୍ଡ ଡକ୍ୟୁମେଣ୍ଟ, କିମ୍ବା ଏକ ଚାଟ୍‌ର ପୂର୍ବ ବାର୍ତ୍ତାଳାପ, ସେତେବେଳେ ଏହା ଉତ୍କୃଷ୍ଟ କାର୍ଯ୍ୟ କରେ। ଏହାର RadixAttention ସେହି ସେୟାର୍ଡ ଅଂଶଗୁଡ଼ିକୁ କ୍ୟାଶ୍ କରି ରଖେ ଏବଂ ସେଗୁଡ଼ିକୁ ପୁନର୍ବାର ଗଣନା କରିବା ପରିବର୍ତ୍ତେ ପୁନଃ ବ୍ୟବହାର କରେ। ଏଥିରେ ଏହା ପାଇଁ ମଧ୍ୟ ଦୃଢ଼ ସମର୍ଥନ ରହିଛି structured output, ଅର୍ଥାତ୍ ଉତ୍ତରଗୁଡ଼ିକୁ ବୈଧ JSON କିମ୍ବା ଏକ ନିର୍ଦ୍ଦିଷ୍ଟ ଫର୍ମାଟ୍‌ରେ ଆସିବାକୁ ବାଧ୍ୟ କରାଯାଏ।

ବ୍ୟବହାରିକ ଉଦାହରଣ। Rohit ଏକ support-ticket triage agent ତିଆରି କରନ୍ତି। ପ୍ରତ୍ୟେକ ଟିକେଟ୍ ସମାନ 3,000-word ପଲିସି ଡକ୍ୟୁମେଣ୍ଟ ସହିତ ପଠାଯାଏ, ଏବଂ ମଡେଲ୍‌କୁ category ଏବଂ priority ଭଳି JSON fields ସହିତ ଉତ୍ତର ଦେବାକୁ ପଡ଼ିବ। SGLang ବିଭିନ୍ନ ଟିକେଟ୍ ମଧ୍ୟରେ cached ପଲିସି ଅଂଶକୁ ପୁନଃ ବ୍ୟବହାର କରେ ଏବଂ ଆଉଟପୁଟ୍‌କୁ ଏପରି ଏକ ଆକାରରେ ରଖେ ଯାହାକୁ ତାଙ୍କ କୋଡ୍ parse କରିପାରିବ।

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

mistral.rs: Rust ବ୍ୟବହାରକାରୀଙ୍କ ପାଇଁ ଏକ Rust ଇଞ୍ଜିନ୍

mistral.rs ହେଉଛି Rust ରେ ଲିଖିତ ଏକ community-built inference engine। ଏହି ନାମ ଥାଇ ମଧ୍ୟ ଏହା Mistral AI କମ୍ପାନୀର କୌଣସି ଅଫିସିଆଲ୍ ଉତ୍ପାଦ ନୁହେଁ, ଏବଂ ଏହା ଅନେକ ମଡେଲ୍ ପରିବାର ଚଳାଇଥାଏ। ଏହା quantization, ଏକ OpenAI-compatible server କୁ ସମର୍ଥନ କରେ, ଏବଂ ଏକ Rust ପ୍ରୋଗ୍ରାମ ଭିତରେ library ଭାବରେ ବ୍ୟବହୃତ ହୋଇପାରିବ। Rust ମେମୋରୀ ସୁରକ୍ଷା (memory safety) ଏବଂ କୌଣସି Python environment ପରିଚାଳନା ନକରି ଏକକ compiled binary ପ୍ରଦାନ କରେ।

ବ୍ୟବହାରିକ ଉଦାହରଣ। Rohit ଙ୍କ ଟିମ୍ ପାଖରେ Rust ରେ ଲିଖିତ ଏକ log-analysis ଟୁଲ୍ ଅଛି ଯାହା locked-down ସର୍ଭରଗୁଡ଼ିକରେ ଚାଲେ ଯେଉଁଠାରେ Python ଇନଷ୍ଟଲ୍ କରିବା ଅନୁମୋଦିତ ନୁହେଁ। mistral.rs ସାହାଯ୍ୟରେ ସେମାନେ ସିଧାସଳଖ ସେହି binary ଭିତରେ ଏକ "summarise this incident" ଫିଚର ଯୋଡ଼ନ୍ତି, ତେଣୁ deploy କିମ୍ବା patch କରିବା ପାଇଁ କୌଣସି ଅତିରିକ୍ତ service ନଥାଏ।

Plain PyTorch: ଏକ ରେଫରେନ୍ସ, ରେସ୍ କାର୍ ନୁହେଁ

PyTorch ହେଉଛି ଏପରି ଏକ framework ଯେଉଁଥିରେ ଅଧିକାଂଶ ମଡେଲ୍ ନିର୍ମିତ ଏବଂ ଟ୍ରେନ୍ ହୋଇଥାଏ। Plain PyTorch ସହିତ ଏକ ମଡେଲ୍ ଚଳାଇବା, ପ୍ରାୟତଃ Hugging Face Transformers library ଏବଂ ଏହାର generate() function ମାଧ୍ୟମରେ, ଏହାକୁ ବ୍ୟବହାର କରିବାର ସବୁଠାରୁ ସିଧାସଳଖ ଉପାୟ ଅଟେ। ଏହାକୁ ପରିବର୍ତ୍ତନ କରିବା ଏବଂ debug କରିବା ସହଜ, ଏବଂ ନୂତନ ମଡେଲ୍‌ଗୁଡ଼ିକ ସାଧାରଣତଃ ପ୍ରଥମେ ସେଠାରେ କାମ କରେ। ଏହା ଅନେକ ଉପଭୋକ୍ତାଙ୍କୁ ସର୍ଭ କରିବା ପାଇଁ tuned ନୁହେଁ, ତେଣୁ ଏହା ଉପରୋକ୍ତ ଇଞ୍ଜିନ୍‌ଗୁଡ଼ିକ ତୁଳନାରେ ମନ୍ଥର ଏବଂ ଅଧିକ ମେମୋରୀ ବ୍ୟବହାର କରେ।

ବ୍ୟବହାରିକ ଉଦାହରଣ। ଏକ fine-tuned ମଡେଲ୍ ପ୍ରକୃତରେ ଭଲ କି ନାହିଁ Rohit ତାହା ପରୀକ୍ଷା କରୁଛନ୍ତି। ସେ ଏହାକୁ plain PyTorch ସହିତ ଏକ notebook ରେ ଲୋଡ୍ କରନ୍ତି, ବିଭିନ୍ନ ପ୍ରମ୍ପ୍ଟ ଚେଷ୍ଟା କରନ୍ତି, କୋଡ୍ ପରିବର୍ତ୍ତନ କରନ୍ତି ଏବଂ ଫଳାଫଳ ତୁଳନା କରନ୍ତି। ଥରେ ସନ୍ତୁଷ୍ଟ ହେବା ପରେ, ସେ production ପାଇଁ ମଡେଲ୍‌କୁ vLLM କିମ୍ବା SGLang କୁ ସ୍ଥାନାନ୍ତର କରନ୍ତି।

Google ର LiteRT-LM: ଫୋନ୍‌ରେ ମଡେଲ୍

LiteRT ହେଉଛି Google ର on-device runtime, ଯାହା TensorFlow Lite ର ନୂତନ ନାମ। LiteRT-LM ହେଉଛି ଫୋନ୍, ବ୍ରାଉଜର୍ ଏବଂ ଛୋଟ edge ଡିଭାଇସ୍‌ରେ Gemma ଭଳି ଭାଷା ମଡେଲ୍ ଚଳାଇବା ପାଇଁ ଏହାର ଏକ layer। ଏହା ସୀମିତ ମେମୋରୀ, ବ୍ୟାଟେରୀ ଲାଇଫ୍ ଏବଂ ମୋବାଇଲ୍ ଚିପ୍ ପାଇଁ ନିର୍ମିତ, ଏବଂ ଏହା କୌଣସି ନେଟୱାର୍କ ସଂଯୋଗ କିମ୍ବା ସର୍ଭର ବିଲ୍ ବିନା ଏକ ଆପ୍‌କୁ AI ଚଳାଇବାକୁ ଦେଇଥାଏ।

ବ୍ୟବହାରିକ ଉଦାହରଣ। Rohit ଟେକ୍ନିସିଆନମାନଙ୍କ ପାଇଁ ଏକ field-inspection Android ଆପ୍ ତିଆରି କରନ୍ତି, ଯେଉଁମାନଙ୍କ ପାଖରେ ପ୍ରାୟତଃ କୌଣସି ସିଗନାଲ୍ ନଥାଏ। ଫୋନ୍‌ରେ LiteRT-LM ଏବଂ ଏକ ଛୋଟ Gemma ମଡେଲ୍ ସହିତ, ଆପ୍ କଥିତ ନୋଟ୍‌ଗୁଡ଼ିକୁ ଅଫଲାଇନ୍‌ରେ ଏକ ପରିଷ୍କାର ରିପୋର୍ଟରେ ପରିଣତ କରେ, ଏବଂ ଡାଟା କଦାପି ଡିଭାଇସ୍ ଛାଡ଼ି ବାହାରକୁ ଯାଏ ନାହିଁ।

Rohit କିପରି ଗୋଟିଏ ବାଛନ୍ତି: ଏକ ସରଳ ନିଷ୍ପତ୍ତି ମାର୍ଗଦର୍ଶିକା

Step 1: ମଡେଲ୍ କେଉଁଠାରେ ଚାଲିବ ତାହା ସ୍ଥିର କରନ୍ତୁ

ଏକ ଫୋନ୍ କିମ୍ବା ଛୋଟ ଡିଭାଇସ୍‌ରେ, LiteRT-LM ରୁ ଆରମ୍ଭ କରନ୍ତୁ। ଏକ ଲାପଟପ୍ କିମ୍ବା CPU-only ସର୍ଭରରେ, llama.cpp ରୁ ଆରମ୍ଭ କରନ୍ତୁ। GPU ସର୍ଭରରେ, vLLM କିମ୍ବା SGLang ଦେଖନ୍ତୁ। ଏକ Rust ପ୍ରୋଗ୍ରାମ ଭିତରେ, mistral.rs ବିଷୟରେ ବିଚାର କରନ୍ତୁ।

Step 2: ଉପଭୋକ୍ତାଙ୍କ ସଂଖ୍ୟା ଗଣନା କରନ୍ତୁ

ଜଣେ କିମ୍ବା କିଛି ବ୍ୟକ୍ତି: llama.cpp ସରଳ ଏବଂ ଯଥେଷ୍ଟ। ଏକାଥରକେ ଡଜନ ଡଜନ କିମ୍ବା ଶହ ଶହ: vLLM କିମ୍ବା SGLang, କାରଣ batching ହିଁ ପ୍ରତି ଉତ୍ତର ପିଛା ଖର୍ଚ୍ଚ କମ୍ ରଖେ।

Step 3: workload shape ଦେଖନ୍ତୁ

ଅନେକ shared prompts, agents କିମ୍ବା strict JSON output ପାଇଁ SGLang ଉପଯୁକ୍ତ। ସାଧାରଣ ଚାଟ୍ ଏବଂ API ଟ୍ରାଫିକ୍ ପାଇଁ vLLM ଉପଯୁକ୍ତ। Experiments ଏବଂ ଗବେଷଣା ପାଇଁ plain PyTorch ଉପଯୁକ୍ତ।

Step 4: ନିଜ ହାର୍ଡୱେର୍‌ରେ ପରୀକ୍ଷା କରନ୍ତୁ

ପ୍ରକାଶିତ ସଂଖ୍ୟାଗୁଡ଼ିକ GPU, ମଡେଲ୍ ଏବଂ ସେଟିଂସ ଉପରେ ନିର୍ଭର କରେ। ନିଜ ମେସିନ୍‌ରେ ଦୁଇଟି ପ୍ରାର୍ଥୀ ଇଞ୍ଜିନ୍ ସହିତ ନିଜ prompts ଚଳାନ୍ତୁ, ଏବଂ ନିଷ୍ପତ୍ତି ନେବା ପୂର୍ବରୁ time to first word, words per second ଏବଂ memory use ମାପନ୍ତୁ।

ନିଷ୍କର୍ଷ

llama.cpp, vLLM, SGLang, mistral.rs, PyTorch ଏବଂ LiteRT-LM ସମସ୍ତେ ସମାନ ମୌଳିକ କାର୍ଯ୍ୟ କରନ୍ତି: ସେମାନେ ଏକ ପ୍ରଶିକ୍ଷିତ ମଡେଲ୍ ଚଳାନ୍ତି ଏବଂ input କୁ ଉତ୍ତରରେ ପରିଣତ କରନ୍ତି। ସେହି ପରିବାରକୁ LLM inference engines କୁହାଯାଏ। ସେମାନଙ୍କୁ ଯାହା ଅଲଗା କରେ ତାହା ହେଉଛି ସେମାନେ କେଉଁଠାରେ ଚାଲନ୍ତି ଏବଂ କାହାକୁ ସେବା ପ୍ରଦାନ କରନ୍ତି: ଲାପଟପ୍ ଏବଂ ଛୋଟ ସର୍ଭର ପାଇଁ llama.cpp, ବ୍ୟସ୍ତବହୁଳ GPU ସର୍ଭର ପାଇଁ vLLM ଏବଂ SGLang, Rust-native apps ପାଇଁ mistral.rs, experiments ପାଇଁ PyTorch, ଏବଂ ଫୋନ୍ ତଥା edge devices ପାଇଁ LiteRT-LM। ମଡେଲ୍ ଭଳି ଇଞ୍ଜିନ୍‌କୁ ମଧ୍ୟ ସେତିକି ଯତ୍ନର ସହ ବାଛନ୍ତୁ।

ସୁବିଧାଗୁଡ଼ିକ

• ନିଜେ open models ଚଳାଇବା ଦ୍ୱାରା ସମ୍ବେଦନଶୀଳ ଡାଟା in-house ରହିଥାଏ ଏବଂ ସମ୍ପୂର୍ଣ୍ଣ ଅଫଲାଇନ୍‌ରେ କାମ କରିପାରେ।
• llama.cpp ଏବଂ mistral.rs ରେ ଥିବା Quantization ଦକ୍ଷ ମଡେଲ୍‌ଗୁଡ଼ିକୁ ସାଧାରଣ ଲାପଟପ୍‌ରେ ଚାଲିବାକୁ ସକ୍ଷମ କରିଥାଏ।
• vLLM ଏବଂ SGLang ଗୋଟିଏ GPU ରୁ ଅନେକ ଉପଭୋକ୍ତାଙ୍କୁ ସେବା ପ୍ରଦାନ କରନ୍ତି, ଯାହା ପ୍ରତି ଉତ୍ତର ପିଛା ଖର୍ଚ୍ଚ କମାଇଥାଏ।
• OpenAI-compatible APIs ଏକ ପେଡ୍ ସର୍ଭିସ୍‌ରୁ switch କରିବାକୁ ଏକ ଛୋଟ code change ରେ ସୀମିତ କରେ।
• LiteRT-LM ବିନା କୌଣସି ସର୍ଭର ବିଲ୍ ଏବଂ ବିନା ନେଟୱାର୍କ ଆବଶ୍ୟକତାରେ ଫୋନ୍‌କୁ AI features ଆଣିଥାଏ।

ଅସୁବିଧାଗୁଡ଼ିକ

• ପ୍ରତ୍ୟେକ ଇଞ୍ଜିନ୍‌ର ଶିଖିବା ପାଇଁ ନିଜସ୍ୱ setup, flags ଏବଂ model formats ରହିଛି।
• ସର୍ଭର ଇଞ୍ଜିନ୍‌ଗୁଡ଼ିକ ପାଇଁ ସକ୍ଷମ GPUs ଆବଶ୍ୟକ, ଯାହା କିଣିବା କିମ୍ବା ଭଡ଼ାରେ ନେବା ବହୁତ ମହଙ୍ଗା।
• Quantized models କିଛି quality ହରାନ୍ତି, ଏବଂ ଏହି କ୍ଷତି ମଡେଲ୍ ତଥା କାର୍ଯ୍ୟ ଅନୁସାରେ ଭିନ୍ନ ହୋଇଥାଏ।
• ପ୍ରତ୍ୟେକ ଇଞ୍ଜିନ୍ ପ୍ରଥମ ଦିନରୁ ପ୍ରତ୍ୟେକ ନୂଆ ମଡେଲ୍‌କୁ ସମର୍ଥନ କରେ ନାହିଁ।
• Self-hosting ର ଅର୍ଥ ହେଉଛି ଆପଣଙ୍କୁ ନିଜେ updates, security patches ଏବଂ monitoring ର ଦାୟିତ୍ୱ ନେବାକୁ ପଡ଼ିବ।

ସତର୍କତା

ଏହି ଲେଖାଟି ଶିକ୍ଷଣୀୟ ଉଦ୍ଦେଶ୍ୟରେ ଲିଖିତ। ଉଦାହରଣଗୁଡ଼ିକରେ ଥିବା model names, ports ଏବଂ paths କେବଳ placeholders ଅଟନ୍ତି ଏବଂ ଏଗୁଡ଼ିକୁ ଆପଣଙ୍କର ନିଜସ୍ୱ ତଥ୍ୟ ସହିତ ବଦଳାଇବା ଆବଶ୍ୟକ। ଏହି ପ୍ରୋଜେକ୍ଟଗୁଡ଼ିକ ଦ୍ରୁତ ଗତିରେ ପରିବର୍ତ୍ତିତ ହୁଏ, ତେଣୁ ଆପଣ ଇନଷ୍ଟଲ୍ କରୁଥିବା version ରେ features, flags ଏବଂ supported hardware ଭିନ୍ନ ହୋଇପାରେ। ଏକ production ନିଷ୍ପତ୍ତି ପାଇଁ ଏଠାରେ ଥିବା କୌଣସି ଦାବି ଉପରେ ନିର୍ଭର କରିବା ପୂର୍ବରୁ ଅଫିସିଆଲ୍ ଡକ୍ୟୁମେଣ୍ଟେସନ୍ ଯାଞ୍ଚ କରନ୍ତୁ ଏବଂ ନିଜ ହାର୍ଡୱେର୍‌ରେ ପରୀକ୍ଷା କରନ୍ତୁ।

ବାରମ୍ବାର ପଚରାଯାଉଥିବା ପ୍ରଶ୍ନ (FAQ)

• ଏକ LLM inference engine କ’ଣ? — ଏହା ହେଉଛି ସେହି ସଫ୍ଟୱେର୍ ଯାହା ଏକ ପ୍ରଶିକ୍ଷିତ language model କୁ ଲୋଡ୍ କରେ ଏବଂ CPU, GPU କିମ୍ବା ଏକ ଫୋନ୍ ଚିପ୍‌ରେ ଉତ୍ତର ପ୍ରଦାନ କରିବା ପାଇଁ ଏହାକୁ ଚଳାଏ।
• llama.cpp ନା vLLM କେଉଁଟି ଉତ୍ତମ? — କୌଣସିଟି ସବୁ ସ୍ଥାନରେ ଉତ୍ତମ ନୁହେଁ: ଲାପଟପ୍ ଏବଂ ଛୋଟ ସର୍ଭର ପାଇଁ llama.cpp ସର୍ବୋତ୍ତମ, ଏବଂ GPU ସର୍ଭରରେ ଅନେକ ଉପଭୋକ୍ତାଙ୍କୁ ସେବା ଦେବା ପାଇଁ vLLM ସର୍ବୋତ୍ତମ।
• vLLM ଏବଂ SGLang ମଧ୍ୟରେ ପାର୍ଥକ୍ୟ କ’ଣ? — ଉଭୟ ଦ୍ରୁତ GPU serving engines; ବିଶେଷ କରି ଯେତେବେଳେ ରିକ୍ୱେଷ୍ଟଗୁଡ଼ିକ ଲମ୍ବା prompts ସେୟାର କରନ୍ତି କିମ୍ବା JSON ଭଳି structured output ଆବଶ୍ୟକ କରନ୍ତି, ସେତେବେଳେ SGLang ବିଶେଷ ଭାବରେ ଶକ୍ତିଶାଳୀ।
• ମୁଁ କ’ଣ GPU ବିନା LLM ଚଳାଇ ପାରିବି? — ହଁ, llama.cpp ସାଧାରଣ CPUs ରେ quantized models ଚଳାଇଥାଏ, ଯଦିଓ ଏହା GPU ତୁଳନାରେ ମନ୍ଥର।
• mistral.rs କ’ଣ Mistral AI ଦ୍ୱାରା ନିର୍ମିତ? — ନା, ଏହା Rust ରେ ଲିଖିତ ଏକ ପୃଥକ community project ଯାହା ଅନେକ model families ଚଳାଇପାରେ।
• Production ରେ କେବଳ PyTorch କାହିଁକି ବ୍ୟବହାର କରାଯାଏ ନାହିଁ? — Plain PyTorch ନମନୀୟ କିନ୍ତୁ ଅନେକ ଉପଭୋକ୍ତାଙ୍କ ପାଇଁ tuned ନୁହେଁ, ତେଣୁ dedicated engines ସାଧାରଣତଃ ସମାନ ହାର୍ଡୱେର୍‌ରୁ ବହୁତ ଅଧିକ ଗତି ପ୍ରଦାନ କରନ୍ତି।
• LiteRT-LM କେଉଁଥିପାଇଁ ବ୍ୟବହୃତ ହୁଏ? — ଏହା ସିଧାସଳଖ ଫୋନ୍ ଏବଂ edge devices ରେ ଅଫଲାଇନ୍‌ରେ Gemma ଭଳି language models ଚଳାଇବା ପାଇଁ Google ର runtime ଅଟେ।
• Quantization କ’ଣ କରେ? — ଏହା କମ୍ bits ସହିତ model numbers ଗୁଡ଼ିକୁ ସାଇତି ରଖେ, ଯାହାଫଳରେ ମଡେଲ୍ ବହୁତ କମ୍ memory ବ୍ୟବହାର କରେ ଏବଂ quality ରେ ସାମାନ୍ୟ କ୍ଷତି ସହିତ ଶସ୍ତା ହାର୍ଡୱେର୍‌ରେ ଚାଲେ।

ଟ୍ୟାଗ୍ସ

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