SSD Nodes Learn Hosting plans →

Ollama vs vLLM: எந்த LLM server தேர்வு செய்வது?

ஒரு பயனருக்கு CPU-யிலும் இயங்கும் Ollama பொருத்தம்; GPU throughput தேவைப்படும் team application-க்கு vLLM. இரண்டிற்குமான உண்மையான commands மற்றும் workload தேர்வை அறிக.

Ollama vs vLLM, ஒரே பத்தியில்

Ollama என்பது server இணைக்கப்பட்ட model manager ஆகும்: இது quantized weights-ஐ download செய்து load செய்கிறது; அதன் பின்னர் 127.0.0.1:11434-ல் பதிலளிக்கிறது. அந்த box-ல் CPU மட்டுமே இருந்தாலும் இது இயங்கும். vLLM என்பது throughput engine ஆகும்: ஒரே நேரத்தில் பல requests இயங்கும்போது GPU-ஐ முழுத் திறனில் பயன்படுத்துகிறது. GPU இல்லாத machine-ல் இதைப் பயன்படுத்துவது பொருத்தமற்றது. முடிவு இதுதான். ஒருவர் local assistant-உடன் பேசுவது Ollama job ஆகும். ஒரு team-க்கு application சேவை வழங்குவது vLLM job ஆகும்.

இரண்டும் OpenAI-compatible HTTP API-ஐ பயன்படுத்துகின்றன. ஆகவே base URL-ஐ மாற்றுவதன் மூலம் client code-ஐ ஒன்றிலிருந்து மற்றொன்றுக்கு மாற்றலாம். வேறுபாடு API-ல் இல்லை. முதல் request இன்னும் tokens generate செய்துகொண்டிருக்கும்போது இரண்டாவது request வந்தால் என்ன நடக்கிறது என்பதில்தான் வேறுபாடு உள்ளது.

Ollama என்றால் என்ன

Ollama என்பது ஒரு வசதிக்கான அடுக்கு (convenience layer) ஆகும். இது ஒரே ஒரு install கட்டளை மூலம் ஒரு model registry (ollama pull llama3.1:8b), local weights store, chat prompt, systemd service மற்றும் HTTP API ஆகியவற்றை வழங்குகிறது. இது வழங்கும் பெரும்பாலான மாதிரிகள் GGUF கோப்புகள் ஆகும், இவை பொதுவாக 4-bit quantized செய்யப்பட்டவை. இதனால்தான் 7B அல்லது 8B அளவுள்ள ஒரு மாதிரி வட்டில் 16 GB-க்கு பதிலாக 5 GB அளவில் உள்ளது. Quantization என்பது CPU inference-க்குத் தேவையான நினைவகத்தைக் குறைக்கிறது. Apple Silicon Mac கணினிகளில், இது MLX engine மூலம் safetensors அடிப்படையிலான மாதிரிகளையும் இயக்க முடியும். v0.40.0 (செப்டம்பர் 2026) பதிப்பிலிருந்து, ஆதரிக்கப்படும் கட்டமைப்புகள் தானாகவே MLX-ல் இயங்குகின்றன.

இதன் GGUF runner, llama.cpp-ஐ அடிப்படையாகக் கொண்டது. இது சாதாரண வன்பொருள்களில் GGUF quantization-ஐச் சாத்தியமாக்கிய C++ inference library ஆகும். அக்டோபர் 2026 நிலவரப்படி, Ollama இரண்டு engines-ஐ ஆதரிக்கிறது: llama.cpp மற்றும் MLX. Linux பதிப்புகள் CUDA-வுடன் கூடிய MLX inference-ஐயும் ஆதரிக்கின்றன. மேம்பாட்டு வழிகாட்டி (development guide) அந்த backend-ஐ cmake -B build . -DOLLAMA_MLX_BACKENDS=cuda_v13 மூலம் செயல்படுத்துகிறது; இதற்கு CUDA 13+ மற்றும் cuDNN 9+ ஆகியவை முன்நிபந்தனைகளாகும். எனவே, மக்கள் Ollama-வை llama.cpp-உடன் ஒப்பிடும்போது, அவர்கள் உண்மையில் ஒரு ergonomics அடுக்கை அது உள்ளடக்கியிருக்கும் தொழில்நுட்பத்துடன் ஒப்பிடுகிறார்கள்.

இதன் வடிவமைப்பு ஒரு பயனருக்கானது. அக்டோபர் 2026 நிலவரப்படி, OLLAMA_NUM_PARALLEL-க்கான default மதிப்பு 1 ஆகும். அதாவது, ஒரு மாதிரி ஒரு நேரத்தில் ஒரு கோரிக்கையை மட்டுமே செயலாக்கும், மற்ற அனைத்தும் வரிசையில் காத்திருக்கும். இந்த வரிசையில் முன்னிருப்பாக 512 பதிவுகள் இருக்கும் (OLLAMA_MAX_QUEUE). நீங்கள் parallel அமைப்பை அதிகரிக்கலாம், ஆனால் அதற்கான விளைவுகள் என்ன என்பதை கீழே உள்ள பகுதி விளக்குகிறது. நீங்கள் இதற்கு முன்பு Ollama-வை இயக்கியதில்லை என்றால், Ollama-வை VPS-ல் ஹோஸ்ட் செய்து 11434 போர்ட்டை மூடி வைத்தல் என்பதிலிருந்து தொடங்கவும், ஏனெனில் local API-க்கு எந்த அங்கீகாரமும் (authentication) தேவையில்லை.

vLLM என்றால் என்ன

vLLM என்பது ஒரு inference server மட்டுமே. இது model library-ஐ நிர்வகிப்பதில்லை, இயங்கும் server-க்கு ஒரு vllm chat client-ஐ வழங்குகிறது, மேலும் கோரிக்கை வரும்போது இது தானாகவே model-ஐ பதிவிறக்கம் செய்யாது. நீங்கள் தொடங்கும் போது ஒரு Hugging Face repository-ஐக் குறிப்பிட்டால், அது அந்த ஒரு model-ஐ மட்டும் ஏற்றி, நீங்கள் process-ஐ நிறுத்தும் வரை அதைச் செயல்படுத்தும்.

இந்தக் குறுகிய செயல்பாட்டின் மூலம் உங்களுக்குக் கிடைப்பது அதிக throughput ஆகும். இரண்டு நுட்பங்கள் இதற்காகச் செயல்படுகின்றன. PagedAttention என்பது KV cache-ஐ (key-value cache, ஒவ்வொரு active request-க்கும் model வைத்திருக்கும் per-token attention state) நிலையான அளவுள்ள blocks-ஆகச் சேமிக்கிறது; இது ஒரு operating system memory-ஐ paging செய்வது போன்றது. ஒரு request-க்கு இனி worst-case சூழலுக்காகப் பெரிய அளவிலான தொடர்ச்சியான memory ஒதுக்கீடு தேவையில்லை. இதனால், முன்பு ஒதுக்கப்பட்டு பயன்படுத்தப்படாமல் இருந்த memory, கூடுதல் concurrent requests-க்குக் கிடைக்கிறது. Continuous batching என்பது, தற்போதைய batch முடியும் வரை காத்திருக்காமல், அடுத்த decoding step-ல் ஒரு புதிய request-ஐ இயங்கும் batch-ல் இணைய அனுமதிக்கிறது. ஒரு sequence முடிந்தவுடன் அது உடனடியாக batch-லிருந்து வெளியேறுகிறது, அதன் இடம் புதிய request-ஆல் நிரப்பப்படுகிறது.

இதன் நடைமுறை விளைவு: ஒரு GPU-வில், ஒரு concurrent user-லிருந்து முப்பது பயனர்களாக அதிகரிக்கும்போது, மொத்த tokens per second அளவு கணிசமாக உயர்கிறது, அதே சமயம் ஒரு பயனருக்கான வேகம் நீங்கள் எதிர்பார்ப்பதை விடக் குறைவாகவே குறைகிறது. Ollama-வின் default அமைப்பில், ஒரு பயனரிடமிருந்து முப்பது பயனர்களாக மாறும்போது, இருபத்தொன்பது பேர் காத்திருக்க வேண்டிய சூழல் மட்டுமே உருவாகும்.

Continuous batching என்பதே முழு வேறுபாடு

ஒரே hardware-ல் இயங்கும் ஒவ்வொரு server-க்கும் ஒரே நேரத்தில் ஐந்து requests வருகின்றன என்று கருதுங்கள்.

Default settings-உடன் Ollama, முதல் request-ஐ முழுமையாக முடித்த பிறகே இரண்டாவது request-ஐ இயக்கும்; இதேபோல் தொடரும். எனவே, ஐந்தாவது caller நான்கு முழு generations முடியும் வரை காத்திருக்க வேண்டும். மொத்த throughput, சுமார் ஒரு generation-ன் வேகத்துக்கு மட்டுமே இருக்கும். காரணம், processor எந்த நேரத்திலும் ஒரு sequence-ல் மட்டுமே வேலை செய்கிறது.

vLLM, ஒரே forward pass-ல் ஐந்து requests-ஐயும் decode செய்கிறது. ஒரு sequence-க்கு ஒரு token உருவாக்குவதைவிட, ஐந்து sequences-க்கு தலா ஒரு token உருவாக்குவதற்கான செலவு மிகச் சிறிதளவே அதிகம். காரணம், அதிக செலவுள்ள பகுதி model weights-ஐ memory-யிலிருந்து வாசிப்பதாகும்; அந்த வாசிப்பு முழு batch-க்கும் பகிரப்படுகிறது. CPU inference மெதுவாக இருப்பதற்கும் இதே memory-bandwidth காரணிதான்: செலவு arithmetic-க்காக அல்ல, weights-ஐ நகர்த்துவதற்காக ஏற்படுகிறது.

OLLAMA_NUM_PARALLEL=4 அமைப்பை set செய்தால், இதில் ஒரு பகுதியை நீங்கள் பெறலாம். ஆனால் இதற்கான செலவு memory. ஒவ்வொரு parallel slot-க்கும் தனித்தனி KV cache தேவைப்படும். மேலும், Ollama context allocation-ஐ பிரிப்பதற்குப் பதிலாக பெருக்குகிறது: அதன் FAQ-இன்படி, தேவையான RAM, OLLAMA_NUM_PARALLEL மடங்கு OLLAMA_CONTEXT_LENGTH அளவில் அதிகரிக்கும். எனவே, 8192 tokens-க்கு configured செய்யப்பட்ட model-க்கு எதிராக நான்கு parallel requests இருந்தால், ஒவ்வொரு request-க்கும் 8192 tokens கிடைக்கும்; ஆனால் box மொத்தம் 32768 tokens-க்கான cache-ஐ வைத்திருக்க வேண்டும். அந்த 8192 என்பதும் முன்கூட்டியே நிர்ணயிக்கப்பட்ட மதிப்பு அல்ல; அது ஒரு configuration choice. ஆகவே, num_ctx-ஐ அதிகரித்து அதற்குத் தேவையான RAM-ஐ கணக்கிடுவது நான்கு slots உண்மையில் பொருந்துமா என்பதைத் தீர்மானிக்கும் படியாகும். ஒவ்வொரு slot-க்கும் முழு window-ஐ ஆரம்பத்திலேயே reserve செய்ய வேண்டிய நிலையை vLLM-ன் paged cache தவிர்க்கிறது. காரணம், request உண்மையில் வளரும்போது அதற்குத் தேவையான blocks ஒதுக்கப்படுகின்றன. எப்படியிருந்தாலும், ஒரு box ஒரே நேரத்தில் சேவை செய்யக்கூடிய பயனர்களின் உச்ச வரம்பு KV cache size, prefill cost, மற்றும் queue depth ஆகியவற்றைப் பொறுத்தே அமையும். அதனால்தான் ஒரு பயனருக்கு நன்றாக இயங்கிய server, ஐந்து பயனர்கள் வந்தால் மெதுவாகிவிடுகிறது.

Ollama-ஐ நிறுவி சேவை செய்யவும்

curl -fsSL https://ollama.com/install.sh | sh
ollama pull llama3.1:8b
ollama run --verbose llama3.1:8b "Write two sentences about Linux."

Install script, ஒரு ollama system user-ஐ உருவாக்கி, binary-ஐ நிறுவுகிறது. மேலும், 127.0.0.1:11434-க்கு bind செய்யப்பட்ட ollama.service-ஐ பதிவு செய்கிறது. --verbose அச்சிடும் eval rate line, அந்த box-ல் கிடைக்கும் உண்மையான tokens per second அளவாகும். வெளியிடப்பட்ட எந்த figure-ஐவிடவும் இதை நம்புங்கள். ஒரு prompt-இலிருந்து கிடைக்கும் ஒரு reading, capacity-ஐ அளவிடும் எண்ணாக அல்ல; அது தொடக்கப் புள்ளி மட்டுமே. எனவே, பல concurrency நிலைகளில் tokens per second-ஐ அளவிடுவது, நீங்கள் எதிர்பார்க்கும் load-ல் அந்த box நிலைத்திருக்குமா என்பதையும், ஒவ்வொரு token-க்கும் கட்டணம் செலுத்துவதைவிட GPU-ஐ rent செய்வது சிறந்ததா என்பதையும் காட்டும்.

Concurrency-ஐ அதிகரிக்க, upgrade செய்தாலும் இந்த மாற்றம் மேலெழுதப்படாதபடி systemd drop-in-ஐ பயன்படுத்தவும்:

sudo systemctl edit ollama.service
[Service]
Environment="OLLAMA_NUM_PARALLEL=4"
Environment="OLLAMA_KEEP_ALIVE=30m"
sudo systemctl restart ollama
ollama ps

ollama ps தற்போது load செய்யப்பட்டுள்ள configuration-ஐ காட்டும். அதன் PROCESSOR column உண்மையான நிலையைத் தெரிவிக்கும். 100% CPU என்றால் GPU பயன்படுத்தப்படவில்லை என்பதாகும். Ollama மெதுவாக இருப்பதாக வரும் பெரும்பாலான reports-க்கான நேர்மையான விளக்கம் இதுவே. அந்த drop-in-ல் உள்ள OLLAMA_KEEP_ALIVE=30m line, குறைந்த load உள்ள box-ல்கூட அதே அளவு முக்கியமானது. Request இல்லாமல் ஐந்து நிமிடங்களுக்குப் பிறகு default நிலையில் model unload செய்யப்படும். எனவே, requests-க்கிடையில் model-ஐ memory-ல் வைத்திருப்பது, அரை மணி நேரம் வரை இடைவெளிக்குப் பிறகு வரும் முதல் prompt மீண்டும் முழு load time-ஐ செலுத்த வேண்டிய நிலையைத் தடுக்கிறது. உங்கள் இடைவெளிகள் அதைவிட நீண்டதாக இருந்தால், அதிக நேர value-ஐ அமைக்கவும்.

vLLM-ஐ நிறுவுதல் மற்றும் இயக்குதல்

vLLM-ன் GPU build-களுக்கு Linux தேவை (Apple Silicon கொண்ட macOS-ல் 0.32.0 release-ல் உள்ள prebuilt wheel மூலம் CPU-மட்டும் இயங்கும் ஆதரவு உள்ளது; அந்த Mac-களில் GPU acceleration-க்கு MLX-ன் அடிப்படையில் இயங்கும் vLLM-Metal என்ற சமூகத்தால் பராமரிக்கப்படும் தனி plugin தேவை). Python-ஐப் பொறுத்தவரை, தற்போதைய release (0.32.0, அக்டோபர் 2026) 3.11 முதல் 3.14 வரையிலான பதிப்புகளை ஏற்கும்; நிறுவல் வழிகாட்டியும் இதே வரம்பையே குறிப்பிடுகிறது. Python 3.10 பதிப்பிற்கான ஆதரவு 0.32.0-ல் நீக்கப்பட்டுவிட்டது, எனவே கீழே பயன்படுத்தப்பட்டுள்ள 3.12 பாதுகாப்பான தேர்வாகும். இதை அதன் சொந்த virtual environment-ல் நிறுவவும், ஏனெனில் இது ஒரு குறிப்பிட்ட PyTorch build-ஐத் தரவிறக்கம் செய்கிறது:

uv venv --python 3.12 --seed
source .venv/bin/activate
uv pip install vllm --torch-backend=auto
vllm download-kernels

கடைசி வரி, அக்டோபர் 2026 நிலவரப்படி vLLM-ன் NVIDIA நிறுவல் வழிகாட்டியில் உள்ளது. இது FlashInfer-ன் precompiled kernels-ஐ நிறுவுகிறது. இவை இல்லையெனில், vLLM தொடங்கும் போது kernels-ஐத் தரவிறக்கம் செய்து compile செய்யும்; Hopper மற்றும் புதிய GPU-களில் இதற்குச் சில நிமிடங்கள் கூடுதலாக ஆகலாம் என்று வழிகாட்டி கூறுகிறது. ஒவ்வொரு முறை vLLM-ஐ upgrade செய்த பிறகும் இதை மீண்டும் இயக்கவும், ஏனெனில் kernels பொருந்தவில்லை எனில் FlashInfer import ஆகாது.

பிறகு ஒரு model-ஐ இயக்கவும். இதன் பெயர் Hugging Face repository id ஆக இருக்க வேண்டும், சுருக்கமான tag ஆக இருக்கக்கூடாது:

vllm serve Qwen/Qwen2.5-1.5B-Instruct

முதல் முறை தொடங்கும் போது வேகம் குறைவாக இருக்கும், ஏனெனில் இது weights-ஐத் தரவிறக்கம் செய்து, எத்தனை KV cache blocks பொருந்தும் என்பதைத் தீர்மானிக்க GPU-ஐ profile செய்யும். இது 8000 port-ல் இயங்கும். எந்தவொரு client code-ஐயும் எழுதும் முன் இதைச் சரிபார்க்கவும்:

curl http://localhost:8000/v1/models
curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{"model": "Qwen/Qwen2.5-1.5B-Instruct", "messages": [{"role": "user", "content": "Who won the world series in 2020?"}]}'

Docker ஏற்கனவே அந்த machine-ல் இருந்தால், official image-ஐப் பயன்படுத்துவது CUDA dependency சிக்கல்களைத் தவிர்க்கும்:

docker run --runtime nvidia --gpus all \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=$HF_TOKEN" \
    -p 8000:8000 \
    --ipc=host \
    vllm/vllm-openai:latest \
    --model Qwen/Qwen3-0.6B

--ipc=host, container-க்கு host shared memory-க்கான அணுகலை வழங்குகிறது; --shm-size-ஐ அதிகரிப்பது மற்றொரு வழியாகும். PyTorch, tensor-parallel inference போன்ற சூழல்களில், processes-களுக்கு இடையே tensors-ஐ shared memory வழியாகப் பரிமாறுகிறது.

Production சூழலில் மிக முக்கியமான flags: --max-model-len (நீங்கள் பயன்படுத்த விரும்பும் context window), --gpu-memory-utilization (vLLM எடுத்துக்கொள்ளக்கூடிய card-ன் அளவு, அக்டோபர் 2026 நிலவரப்படி இது இயல்பாக 0.92), --tensor-parallel-size (ஒரு model-ஐப் பல GPU-களுக்குப் பிரிப்பதற்கு), மற்றும் --api-key.

vLLM-ல் ஒரு flag மூலம் authentication வசதி உள்ளது, ஆனால் Ollama-வின் local API-ல் இந்த வசதி இல்லை

நீங்கள் ஒரு bearer token-ஐ வழங்கினால், vLLM அதை கட்டாயமாக்குகிறது:

vllm serve Qwen/Qwen2.5-1.5B-Instruct --api-key token-abc123

அதே மதிப்பை VLLM_API_KEY environment variable மூலமும் வழங்கலாம். இந்த token இல்லாமல் /v1 routes-க்கு அனுப்பப்படும் கோரிக்கைகள் HTTP 401 பிழையைப் பெறும். இருப்பினும், இந்த key முழு server-க்கும் பொருந்தாது. vLLM-ன் security guide மற்றும் 0.32.0 source code-ல் உள்ள authentication குறியீடு, இதை /v1, /v2, /inference, மற்றும் /cohere ஆகிய path prefixes-க்கு கீழ் உள்ள endpoints-க்கு மட்டுமே பயன்படுத்துகிறது. vllm serve பக்கத்தில் உள்ள --api-key உதவி உரையில் முதல் மூன்று மட்டுமே பட்டியலிடப்பட்டுள்ளன, ஆனால் குறியீடு நான்கையும் சரிபார்க்கிறது. வழிகாட்டி மற்றும் உதவி உரை ஆகிய இரண்டிலும், பிற endpoints, குறிப்பாக /v1 போன்ற அதே inference-ஐ வழங்கும் /invocations, authentication செய்யப்படுவதில்லை என்று குறிப்பிடப்பட்டுள்ளது. பொதுவான interface-ல் port 8000-ஐத் திறக்காமல் இருப்பதற்கு இதுவே போதுமான காரணமாகும். vLLM-ன் security guide, rate limiting-ஐ அதற்கு முன்னால் உள்ள reverse proxy-யிடம் விட்டுவிடுகிறது. plain HTTP வழியாக அனுப்பப்படும் token-ஐ இடையில் யாராவது பார்க்க முடியும், ஆனால் இந்த flag இருப்பதால், server-க்கு ஒரு caller யார் என்பது தெரியும்.

Ollama-வின் local API-க்கு எந்த authentication-ம் தேவையில்லை. Cloud models, model publishing, மற்றும் private model downloads-க்கு sign-in தேவை; ollama.com-க்கான நேரடி API அணுகலுக்கு API key தேவை. 11434 port-ஐ அணுகக்கூடிய எந்தவொரு process-ம் models-ஐ இயக்கவோ, பதிவிறக்கவோ அல்லது நீக்கவோ முடியும். இதை loopback-ல் வைத்து, நீங்கள் சொந்தமாக நடத்தும் WireGuard VPN மூலமாகவோ அல்லது TLS (transport layer security)-ஐ முடிக்கும் ஒரு authenticating reverse proxy மூலமாகவோ அணுகவும்.

Hardware: ஒவ்வொன்றுக்கும் தேவையானவை

Ollama CPU-ல் இயங்கும். 4-bit quantized model-க்கு, ஒவ்வொரு billion parameters-க்கும் சுமார் அரை gigabyte RAM தேவைப்படும். இதனுடன் சுமார் 1 gigabyte runtime overhead மற்றும் context-க்கு கூடுதல் memory தேவைப்படும். எனவே, 3B model-க்கு சுமார் 4 GB free memory-யும், 8B model-க்கு சுமார் 8 GB free memory-யும் தேவைப்படும். Shared vCPU-ல் வேகம், ஒரு second-க்கு ஒற்றை இலக்கத்திலிருந்து குறைந்த இரட்டை இலக்க tokens அளவாக இருக்கும். இது memory bandwidth-ன் வரம்பு; misconfiguration அல்ல. எந்த flag-மும் இதைச் சரிசெய்யாது. ஒரு பொதுவான விதியைப் பயன்படுத்துவதற்குப் பதிலாக, குறிப்பிட்ட release-ல் இந்தக் கணக்கு எவ்வாறு செயல்படுகிறது என்பதைப் பார்க்க VPS-ல் Nemotron 3.5 Lightning-ஐ இயக்குதல் exact tag-ஐ pull செய்ய வேண்டியது, model load ஆன பிறகு அது பயன்படுத்தும் RAM அளவு, மற்றும் CPU-only போதுமான வேகத்தில் பயன்படுத்தக்கூடியதா என்பதைத் தெளிவுபடுத்துகிறது.

vLLM ஒரு GPU இருப்பதாகக் கருதுகிறது. அதன் default path, unquantized weights-ஐ 16-bit precision-ல் serve செய்கிறது. இதற்கு ஒவ்வொரு billion parameters-க்கும் சுமார் 2 GB தேவைப்படும். எனவே, 8B model-க்கு weights மட்டும் சுமார் 16 GB video memory தேவைப்படும். vLLM-ஐ இயக்கியதற்கான concurrency-ஐ வழங்கும் KV cache இதற்கு மேலாகத் தேவைப்படும். 24 GB card-ல் usable cache-க்கு இடம் இருக்கும். 16 GB card-ல் இருக்காது. எனவே, சிறிய model-ஐத் தேர்வு செய்ய வேண்டும், அல்லது --quantization-ஐ pass செய்ய வேண்டும் (quantized checkpoint உடன், அல்லது load time-ல் full-precision weights-ஐ quantize செய்ய), அல்லது --cpu-offload-gb மூலம் weights-ன் ஒரு பகுதியை system RAM-க்கு நகர்த்த வேண்டும். இந்த முறையில் precision மாறாது. ஆனால் வேகம் குறையும், ஏனெனில் ஒவ்வொரு forward pass-லும் அந்த weights GPU-க்கு மாற்றப்படும். தனித்தனி wheels தேவைப்படும் CPU backend உள்ளது. ஆனால் அதைப் பயன்படுத்தினால் vLLM இயக்குவதற்கான முக்கிய காரணமே நீங்கிவிடும்.

எனவே, பெரும்பாலான நேரங்களில் hardware பற்றிய கேள்வியே software பற்றிய கேள்விக்கும் பதிலளிக்கிறது. GPU இல்லையெனில் Ollama பயன்படுத்தவும். Requests serialise செய்யப்படுவதால் rented GPU 5 percent utilisation-ல் மட்டுமே இயங்கினால், vLLM பயன்படுத்தவும்.

உங்கள் workload-க்கு எது பொருத்தமானது

  • ஒருவர் மட்டுமே பயன்படுத்தும் CPU VPS-ல் drafting மற்றும் summarising செய்ய: Ollama. இதன் வேகம் ஏற்றுக்கொள்ளத்தக்கது; இதைவிட எளிமையானது வேறு இல்லை.
  • நீங்கள் மட்டுமே பயன்படுத்தும் coding assistant அல்லது உங்கள் tools-ஐ local model-உடன் இணைக்கும் MCP server: Ollama. ஒரே நேரத்தில் ஒரு request மட்டுமே வருவது உண்மையான workload.
  • இந்த வாரம் ஐந்து models-ஐ ஒப்பிட: Ollama. tagged models-ஐ pull செய்து delete செய்வது இதன் சிறந்த பயன்பாடு; vLLM-க்கு ஒவ்வொரு model-க்கும் process restart தேவைப்படும்.
  • உண்மையான users பயன்படுத்தும் internal app, chat product, அல்லது retrieval pipeline: vLLM. இங்குதான் batching, GPU bill-க்கு உரிய பயனை வழங்குகிறது.
  • ஒரே இரவில் ஒரு லட்சம் documents-ஐ score செய்யும் batch job: அதிக --max-num-seqs உடன் vLLM. இங்கு throughput மட்டுமே முக்கியமான metric; ஒவ்வொரு document-க்கான latency முக்கியமல்ல.
  • ஒரே நேரத்தில் பல self-hosted AI agents model-ஐ அணுகும் agent platform: vLLM. agent traffic இயல்பாகவே bursty மற்றும் parallel ஆக இருக்கும்.

தோல்வி முறைகள் மற்றும் நீங்கள் காணக்கூடிய செய்திகள்

vLLM ஒரு KV cache பிழையுடன் தொடங்க மறுக்கிறது. அந்தச் செய்தி இரண்டு எண்களையும் குறிப்பிடுகிறது:

ValueError: To serve at least one request with the model's max seq len (32768), (4.00 GiB KV cache is needed, which is larger than the available KV cache memory (1.00 GiB). Based on the available memory, the estimated maximum model length is 8192. Try increasing `gpu_memory_utilization` (which also controls CPU memory on the CPU backend) or decreasing `max_model_len` when initializing the engine. See https://docs.vllm.ai/en/latest/configuration/conserving_memory/ for more details.

மாதிரியானது (model), weights ஏற்றப்பட்ட பிறகு மீதமுள்ள நினைவகத்தை விட பெரிய context window-ஐக் கோருகிறது. --max-model-len 8192 மூலம் அதைக்குறைக்கவும், அல்லது வேறு எதுவும் அந்த card-ஐப் பயன்படுத்தவில்லை என்றால் --gpu-memory-utilization-ஐ அதிகரிக்கவும்.

Ollama generation-ன் போது Killed என்று அச்சிடுகிறது. மாதிரிக்கு கணினியில் உள்ள RAM-ஐ விட அதிக நினைவகம் தேவைப்பட்டதால், Linux out-of-memory killer அந்தச் செயல்பாட்டை நிறுத்திவிட்டது. sudo dmesg | grep -i oom மூலம் இதை உறுதிப்படுத்தவும். இதற்குத் தீர்வு ஒரு சிறிய அல்லது அதிக அளவில் quantized செய்யப்பட்ட மாதிரியைப் பயன்படுத்துவதே தவிர, ஏதேனும் ஒரு setting-ஐ மாற்றுவது அல்ல.

Ollama தனியாக இயங்கும்போது சரியாகப் பதிலளிக்கிறது, ஆனால் அதிக சுமை இருக்கும்போது தேங்குகிறது. எங்கும் எந்தப் பிழையும் தெரிவதில்லை. OLLAMA_NUM_PARALLEL=1 கோரிக்கைகளை வரிசைப்படுத்துவதால், பயனர்கள் அதிகரிக்க அதிகரிக்க பதிலளிக்கும் நேரம் அதிகரிக்கிறது. நீண்ட பதில்கள் வரிசையை மோசமாக்குகின்றன, ஏனெனில் ஒரு பயனர் மாதிரியின் பதில் முடியும் வரை அந்த இடத்தைப் பிடித்துக்கொண்டால், பின்னால் இருப்பவர்கள் அனைவரும் காத்திருக்க வேண்டியிருக்கும். எனவே num_predict மூலம் பதிலை வரம்புக்குட்படுத்துவது ஒரு பயனர் எவ்வளவு நேரம் server-ஐத் தடுத்து வைத்திருக்கலாம் என்பதற்கு ஒரு உச்சவரம்பை அமைக்கிறது. Parallel setting-ஐ அதிகரிக்கவும், ஆனால் ஒவ்வொரு slot-ன் context-க்கும் கூடுதல் RAM தேவைப்படும் என்பதை நினைவில் கொள்ளவும், அல்லது பணிச்சுமையை vLLM-க்கு மாற்றவும்.

ஒவ்வொரு /v1 அழைப்பிற்கும் vLLM 401 பிழையைத் தருகிறது. நீங்கள் அதை --api-key உடன் தொடங்கியுள்ளீர்கள், ஆனால் client எந்த Authorization header-ஐயும் அனுப்பவில்லை. பெரும்பாலான OpenAI client libraries நீங்கள் key-ஆக எதைக் கொடுக்கிறீர்களோ அதையே அனுப்புகின்றன, எனவே அந்த flag-ஐ நீக்குவதற்குப் பதிலாக அங்கே அதை அமைக்கவும்.

மாதிரி (model) காணப்படவில்லை என்று vLLM கூறுகிறது. Ollama தேவைப்படும்போது மாதிரிகளைத் தரவிறக்கம் செய்யும், vLLM அவ்வாறு செய்யாது. கோரிக்கையின் (request body) model புலம், நீங்கள் தொடங்கிய repository id-யுடன் அல்லது நீங்கள் அமைத்திருந்தால் --served-model-name-ன் மதிப்புடன் ஒத்துப்போக வேண்டும். curl http://localhost:8000/v1/models மூலம் சரியான string-ஐ உறுதிப்படுத்தவும்.

இரண்டையும் இயக்குவது பொருத்தமான தீர்வாகும்

இவை ஒன்றுக்கொன்று முரணானவை அல்ல. பொதுவாக, application-க்கு சேவை வழங்கும் GPU instance-ல் vLLM இயங்கும். அதே நேரத்தில், உள்ளூர் scripts, cron jobs, மற்றும் புதிய model releases-ஐச் சோதிப்பதற்காக சாதாரண VPS-ல் Ollama இயங்கும். இரண்டு endpoints-உம் OpenAI-compatible ஆக இருப்பதால், ஒரே client library மற்றும் base-URL மாற்றம் போதுமானது. இங்கு எந்த engine-ஐத் தேர்ந்தெடுப்பதைவிட cost control முக்கியமானது. காரணம், idle GPU-க்கும் busy GPU-க்கும் ஒரே கட்டணம் வசூலிக்கப்படும். மேலும், agent மற்றும் inference செலவுகளை முன்கூட்டியே கட்டுப்படுத்தக்கூடியதாக வைத்திருப்பது server-ஐத் தேர்ந்தெடுப்பதிலிருந்து தனியான நிர்வாகப் பணியாகும்.

FAQ

vLLM, Ollama-வை விட வேகமானதா?

ஒரே GPU-வில் ஒரு கோரிக்கையை (request) கையாளும்போது, இரண்டிலும் கணித செயல்பாடுகள் ஒன்றாகவே இருப்பதால் வேகத்தில் பெரிய வித்தியாசம் இருக்காது. ஆனால், ஒரே நேரத்தில் பல கோரிக்கைகள் வரும்போது vLLM மிக வேகமாகச் செயல்படும். ஏனெனில், vLLM-ன் continuous batching வசதி, அனைத்து செயல்பாடுகளையும் ஒரே forward pass-ல் கையாள்கிறது. Ollama-வின் இயல்புநிலை அமைப்பு, கோரிக்கைகளை ஒவ்வொன்றாகவே வரிசைப்படுத்துகிறது. CPU-மட்டும் கொண்ட கணினிகளில், இரண்டிற்கும் தனித்தனி inference பாதைகள் உள்ளன; vLLM இதற்காகத் தனித்தனி CPU wheels-ஐப் பயன்படுத்துகிறது.

GPU இல்லாமல் vLLM-ஐ இயக்க முடியுமா?

ஆம், அதன் CPU backend மூலம் இயக்கலாம். வழக்கமான wheels, NVIDIA அல்லது AMD GPU-க்களை இலக்காகக் கொண்டவை. vLLM-ன் முக்கிய நோக்கமே, பல கோரிக்கைகளை batch செய்து accelerator-ஐ முழுமையாகப் பயன்படுத்துவதுதான்; இது CPU-வில் சாத்தியமில்லை. இருப்பினும், x86 மற்றும் Arm கட்டமைப்புகளுக்குத் தனித்தனி wheels உடன் கூடிய CPU backend உள்ளது. உண்மையான CPU inference-க்கு Ollama அல்லது llama.cpp-ஐ நேரடியாகப் பயன்படுத்துவது சிறந்தது.

Ollama மற்றும் llama.cpp-க்கு இடையே உள்ள வேறுபாடு என்ன?

llama.cpp என்பது ஒரு inference library ஆகும், GGUF என்பது அதன் quantized weight format ஆகும். Ollama, GGUF inference-க்காக llama.cpp-ஐப் பயன்படுத்துவதோடு, ஒரு model registry, tagged downloads, model management மற்றும் systemd unit போன்ற வசதிகளையும் வழங்குகிறது. Ollama, Apple Silicon-ல் safetensors-அடிப்படையிலான மாதிரிகளை இயக்க MLX engine-ஐயும், Linux-ல் CUDA builds-ஐயும் ஆதரிக்கிறது. எனவே, இவை இரண்டின் உட்புற அமைப்புகளும் எப்போதும் ஒன்றாக இருப்பதில்லை.

8B மாதிரியை இயக்க vLLM-க்கு எவ்வளவு GPU memory தேவை?

16-bit precision-ல், weights மட்டுமே சுமார் 16 GB தேவைப்படும் (ஒரு பில்லியன் parameters-க்கு தோராயமாக 2 GB). இதனுடன் KV cache-க்கும் கூடுதல் இடம் தேவை. 24 GB திறன் கொண்ட கார்டு இதற்குப் போதுமானது. 16 GB கார்டு பயன்படுத்துபவர்கள், quantized model-ஐப் பயன்படுத்த வேண்டும் அல்லது சிறிய மாதிரியைத் தேர்ந்தெடுக்க வேண்டும். இல்லையெனில், --cpu-offload-gb-ஐப் பயன்படுத்தி, வேகத்தைக் குறைத்துக்கொண்டு, weights-ன் ஒரு பகுதியை system RAM-க்கு மாற்றலாம். vLLM, --gpu-memory-utilization மூலம் GPU-வின் ஒரு பகுதியைத் தனக்கென ஒதுக்கும்; அக்டோபர் 2026 நிலவரப்படி, இதன் இயல்புநிலை மதிப்பு 0.92 ஆகும்.

இரண்டிற்கும் இடையே மாறும்போது எனது application code-ஐ மாற்ற வேண்டுமா?

பொதுவாக base URL, API key மற்றும் model name ஆகியவற்றை மட்டும் மாற்றினால் போதும். Ollama, தனது OpenAI-compatible சேவையை http://127.0.0.1:11434/v1-ல் வழங்குகிறது மற்றும் API key-ஐக் கருத்தில் கொள்வதில்லை. அதேசமயம் vLLM, http://localhost:8000/v1-ல் சேவையை வழங்கி, நீங்கள் அமைத்திருந்தால் அதன் /v1 வழிகளில் key-ஐக் கட்டாயமாக்குகிறது. Model பெயர்களின் வடிவம் மாறுபடும்: Ollama-விற்கு llama3.1:8b, vLLM-க்கு Qwen/Qwen2.5-1.5B-Instruct போன்ற முழுமையான repository id தேவைப்படும்.

இந்தக் கட்டுரை பயனுள்ளதாக இருந்ததா?