VPS-ல் Ollama vs llama.cpp: எது சிறந்தது?
VPS-ல் LLM-களை இயக்க Ollama மற்றும் llama.cpp ஆகியவற்றின் வேறுபாடுகளை அறியுங்கள். CPU மட்டும் கொண்ட சர்வரில் RAM பயன்பாடு, quantization மற்றும் செயல்திறன் குறித்த விரிவான ஒப்பீடு.
Ollama மற்றும் llama.cpp: நீங்கள் எந்த அடுக்கை (layer) இயக்க விரும்புகிறீர்கள்?
Ollama மற்றும் llama.cpp ஆகிய இரண்டும் இந்தக் கேள்வி குறிப்பிடுவது போல ஒன்றையொன்று போட்டியிடுபவை அல்ல. llama.cpp என்பது ஒரு inference engine ஆகும்: இது ஒரு model file-ஐ ஏற்றி, prompt-ஐ tokens-ஆக மாற்றுகிறது. Ollama என்பது ஒரு model manager, background daemon மற்றும் அந்த engine-க்கு மேலே இயங்கும் ஒரு HTTP API ஆகும். Ollama-வின் README-ல் இப்போதும் llama.cpp அதன் inference backend-ஆக பட்டியலிடப்பட்டுள்ளது (27 October 2026 அன்று சரிபார்க்கப்பட்டது). எனவே, எது வேகமானது என்பது கேள்வியல்ல, உங்கள் VPS-ல் எந்த அடுக்கை நீங்கள் இயக்க விரும்புகிறீர்கள் என்பதே உண்மையான கேள்வி.
பெயரின் அடிப்படையில் models-ஐத் தரவிறக்கம் செய்து, எந்தக் கவனமும் இன்றித் தொடர்ந்து இயங்கும் ஒரு service தேவைப்படும்போது Ollama-வை இயக்கவும். உங்கள் server-ன் திறன் குறைவாக இருந்து, சரியான model file, சரியான context size மற்றும் சரியான thread count ஆகியவற்றை நீங்களே தீர்மானிக்க வேண்டியிருக்கும் போது llama.cpp-ஐ நேரடியாக இயக்கவும். ஏனெனில், சிறிய VPS-ல் இந்த ஒவ்வொரு அமைப்பும் உங்களிடம் இல்லாத memory-ஐப் பயன்படுத்தும்.
ஒவ்வொரு திட்டமும் உண்மையில் என்ன
llama.cpp என்பது ggml library-ஐ அடிப்படையாகக் கொண்டு உருவாக்கப்பட்ட transformer inference-ன் C மற்றும் C++ செயலாக்கம் ஆகும். இது GGUF கோப்புகளை வாசிக்கிறது. GGUF (GGML universal file format) என்பது ஒரு ஒற்றைக் கோப்பு கொள்கலன் (container) ஆகும்; இது ஒரு model-ஐ இயக்குவதற்குத் தேவையான weights, tokeniser மற்றும் metadata ஆகியவற்றை உள்ளடக்கியது. இந்தத் திட்டம் வெவ்வேறு பணிகளுக்காகத் தனித்தனி binaries-ஐ வழங்குகிறது. llama-server ஒரு HTTP server, llama-cli ஒரு interactive prompt, மற்றும் llama-bench throughput-ஐ அளவிடுகிறது. இந்தத் திட்டம் இப்போது semantic-versioning (MAJOR.MINOR.PATCH) முறையில் releases-ஐ வெளியிடுகிறது. 15 அக்டோபர் 2026 அன்று வெளியிடப்பட்ட v0.7.0, 27 அக்டோபர் 2026 நிலவரப்படி சமீபத்திய பதிப்பாகும். Build-number கொண்ட nightly tags இப்போதும் அவற்றுடன் சேர்ந்து தினசரி பலமுறை வெளியிடப்படுகின்றன; 27 அக்டோபர் 2026 அன்று வெளியான புதிய பதிப்பு b11913 ஆகும்.
Ollama என்பது ஒரு Go நிரல் ஆகும். ollama serve மூலம் தொடங்கப்படும் ஒரு background daemon, model-களை ஏற்றி HTTP கோரிக்கைகளுக்குப் பதிலளிக்கிறது; ஒரு command line client அந்த daemon-உடன் தொடர்பு கொள்கிறது. இவை இரண்டிற்கும் பின்னால், முன்கூட்டியே தொகுக்கப்பட்ட (prepacked) model-களைக் கொண்ட ollama.com என்ற registry உள்ளது. Ollama semantic versions-ஐப் பயன்படுத்துகிறது. v0.32.5 பதிப்பு 27 ஜூலை 2026 அன்று வெளியானது, மற்றும் v0.40.12 பதிப்பு 27 அக்டோபர் 2026 அன்று 00:07 UTC நேரத்தில் வெளியிடப்பட்டது. ollama pull ஒரு GGUF கோப்பை, prompt template மற்றும் இயல்புநிலை அளவுருக்களுடன் (default parameters) பதிவிறக்கம் செய்து, Linux-ல் /usr/share/ollama/.ollama/models என்ற பாதையில் சேமிக்கிறது. இந்தக் கோப்புகள் root disk-ல் சேமிக்கப்படுகின்றன மற்றும் ஒவ்வொன்றும் பல gigabytes அளவு கொண்டவை. எனவே, 25 GB root volume கொண்ட VPS-ல், மூன்றாவது பதிவிறக்கத்திற்கு முன்பே pull கட்டளை எதை விட்டுச் செல்கிறது மற்றும் model directory-ஐ எவ்வாறு வேறு இடத்திற்கு மாற்றுவது என்பதைத் தெரிந்துகொள்வது அவசியம்.
இந்த பேக்கேஜிங் முறையே அவற்றுக்கிடையேயான முக்கிய வேறுபாடு ஆகும். Ollama உங்களுக்காக quantisation, template மற்றும் context length ஆகியவற்றைத் தீர்மானித்து, நினைவில் கொள்ள ஒரு பெயரை மட்டும் வழங்குகிறது. llama.cpp இந்தத் தேர்வுகளை flags-ஆக வழங்குகிறது; நீங்கள் குறிப்பிடாத அமைப்புகளுக்கு அது தானியங்கி இயல்புநிலைகளை (automatic defaults) பயன்படுத்துகிறது.
அச்சு 1: மாதிரி மற்றும் குவாண்டிசேஷன் கட்டுப்பாடு
குவாண்டிசேஷன் (Quantisation) என்பது மாதிரியின் எடைகளை (weights) அதன் அசல் 16 அல்லது 32 பிட்களை விடக் குறைவான பிட்களில் சேமிப்பதாகும். பொதுவாகப் பயன்படுத்தப்படும் GGUF கட்டமைப்புகள் ஒரு எடைக்கு சராசரியாக 4, 5 அல்லது 8 பிட்களைக் கொண்டிருக்கும். கோப்பு முழுவதும் துல்லியம் ஒரே சீராக இருப்பதில்லை. llama.cpp-ன் குவாண்டிசர் மூலக் குறியீட்டின்படி (27 அக்டோபர் 2026 அன்று வாசிக்கப்பட்டது), ஒரு Q4_K_M கட்டமைப்பு பெரும்பாலான டென்சர்களை 4-பிட்டில் வைத்திருக்கும். ஆனால், அவுட்புட் லேயர், அட்டென்ஷன் வேல்யூ மற்றும் ஃபீட்-ஃபார்வர்டு டவுன் டென்சர்களில் பாதியளவு லேயர்களை 6-பிட் Q6_K-க்கு மாற்றும். அதேசமயம், நார்ம்ஸ் (norms) போன்ற சிறிய டென்சர்கள் குவாண்டிஸ் செய்யப்படுவதில்லை. இதுவே 8 பில்லியன் அளவுருக்கள் கொண்ட மாதிரியை ஒரு சாதாரண VPS-ன் RAM-ல் பொருத்த உதவுகிறது. GGUF பெயரிடும் முறையை அதன் அமைப்பைப் புரிந்துகொண்டால் எளிதாக வாசிக்கலாம்: Q4_K_M என்பது 4-பிட் K-குவாண்ட், நடுத்தர அளவு என்று பொருள்படும். அதிக எண் அதிக துல்லியத்தைத் தரும், ஆனால் அதிக நினைவகத்தை (memory) எடுத்துக்கொள்ளும்.
இந்த விளக்கப்படத்தின் தரவு
[
{
"label": "Q2_K",
"file_size_gib": 2.96
},
{
"label": "Q3_K_M",
"file_size_gib": 3.74
},
{
"label": "Q4_K_M",
"file_size_gib": 4.58
},
{
"label": "Q5_K_M",
"file_size_gib": 5.34
},
{
"label": "Q6_K",
"file_size_gib": 6.14
},
{
"label": "Q8_0",
"file_size_gib": 7.95
}
]இவை Hugging Face-ல் உள்ள bartowski/Meta-Llama-3.1-8B-Instruct-GGUF களஞ்சியத்தில் வெளியிடப்பட்ட கோப்பு அளவுகள் ஆகும். இவை 2 ஆகஸ்ட் 2026 அன்று வாசிக்கப்பட்டு, பைட்களிலிருந்து GiB-க்கு மாற்றப்பட்டன. ஒரு மாதிரியின் 6 கட்டமைப்புகளில், மிகச்சிறியது 2.96 GiB, மிகப்பெரியது 7.95 GiB ஆகும். பொதுவான இயல்புநிலை (default) கட்டமைப்பான Q4_K_M, 4.58 GiB ஆகும். 4 GiB VPS-ல், இந்தத் தேர்வுதான் மாதிரி இயங்குமா இல்லையா என்பதைத் தீர்மானிக்கிறது. அளவு என்பது முடிவின் ஒரு பாதி மட்டுமே; ஏனெனில் உங்களால் வாங்கக்கூடிய ஒரு கோப்பு, பயன்படுத்துவதற்குத் தகுதியானதாக இருக்க வேண்டிய அவசியமில்லை. Q4, Q8 மற்றும் fp16 ஆகியவற்றின் உண்மையான பதில் தரம் குறித்த தகவலே, கூடுதல் ஜிகாபைட்கள் உங்களுக்குத் தேவையான பலனைத் தருகிறதா என்பதைத் தீர்மானிக்க உதவும்.
llama.cpp-ல் கோப்பின் பெயரை நீங்களே குறிப்பிடுவதால், அந்த வரிசையை நீங்களே தேர்வு செய்கிறீர்கள்.
llama-server -m ~/models/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf \
-c 4096 -t 4 --host 127.0.0.1 --port 8080-c என்பது டோக்கன்களில் சூழல் அளவு (context size), -t என்பது த்ரெட் எண்ணிக்கை (thread count), மற்றும் -ngl என்பது GPU-க்கு மாற்றப்படும் லேயர்களின் எண்ணிக்கையைக் குறிக்கிறது (CPU மட்டுமே உள்ள கணினியில் இது 0). குறிப்பிடப்படாத அமைப்புகளுக்கு இயல்புநிலைகள் உண்டு. --fit இயல்பாகவே ஆன் செய்யப்பட்டிருக்கும், இது சாதனத்தின் நினைவகத்திற்கு ஏற்ப அமைப்புகளைச் சரிசெய்யும்.
Ollama-வில், நீங்கள் பதிவிறக்கும் டேக் (tag)-உடன் குவாண்டிசேஷனும் சேர்ந்து வரும். ollama ls உங்கள் வட்டில் உண்மையில் என்ன உள்ளது என்பதைக் காட்டும். பதிவேட்டில் உங்களுக்குத் தேவையான கட்டமைப்பு இல்லையென்றால், நீங்களே ஒரு GGUF-ஐ இறக்குமதி செய்யலாம். ஒரு Modelfile-ஐ உருவாக்கவும்:
FROM ./Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf
PARAMETER num_ctx 4096பின்பு அதை உருவாக்கி முடிவைச் சரிபார்க்கவும்:
ollama create llama31-q4 -f ./Modelfile
ollama lsசூழல் நீளம் (Context length) என்பது பலரைச் சிக்க வைக்கும் அமைப்பாகும். Ollama தனக்குக் கிடைக்கும் VRAM-ஐப் பொறுத்து இயல்புநிலையைத் தேர்வு செய்யும். GPU இல்லாத கணினியில் இது மிகச்சிறிய அளவான 4096 டோக்கன்களைத் தேர்வு செய்யும். அதற்கு 20,000 டோக்கன்கள் கொண்ட ஆவணத்தை அனுப்பினால், மாதிரி பார்ப்பதற்கு முன்பே கூடுதல் டோக்கன்கள் நீக்கப்படும். இதனால், பாதியளவு மட்டுமே வாசித்த கோப்பைப் பற்றி அது தவறான பதிலைத் தரும். இதைச் சரிசெய்ய OLLAMA_CONTEXT_LENGTH மூலம் டீமானில் (daemon) அல்லது PARAMETER num_ctx மூலம் Modelfile-ல் அளவை அதிகரிக்கவும். ஒரு குறிப்பிட்ட பணிக்கு மட்டும் பெரிய விண்டோ தேவைப்பட்டால், num_ctx-ஐ சர்வர் முழுமைக்கும் மாற்றாமல் ஒவ்வொரு கோரிக்கைக்கும் தனித்தனியாக அமைக்கலாம். இது டீமானின் பிற பணிகளுக்குத் தேவையற்ற கேச் (cache) சுமையைக் குறைக்கும். llama.cpp-லும் நம்பகமான இயல்புநிலை எதுவும் இல்லை. -c-ஐத் தெளிவாக அமைத்து, நீங்கள் எதை மாற்றுகிறீர்கள் என்பதை உறுதிப்படுத்திக் கொள்ளுங்கள்.
யாரும் சொல்லாத நினைவகக் கணக்கீடு (Memory arithmetic)
Model கோப்பு மட்டுமே மொத்தச் செலவு அல்ல. KV cache (key/value cache) என்பது ஒவ்வொரு layer-க்கும், ஒவ்வொரு context token-க்கும் ஒரு entry-ஐ வைத்திருக்கும். உரையாடல் வளர வளர இதுவும் வளரும்.
Llama 3.1 8B-க்கு இதைக் கணக்கிடுவோம். இந்த model-ல் 32 layers, 8 key/value heads மற்றும் 128 head dimension உள்ளன. ஒவ்வொரு token-ம் f16 வடிவில் தலா 2 bytes கொண்ட key மற்றும் value-ஐச் சேமிக்கும். எனவே, ஒரு layer-க்கு 2 x 8 x 128 x 2 = 4096 bytes தேவை. 32 layers-க்கு இது ஒரு token-க்கு 128 KiB ஆகும். எனவே, 4096 token context-க்கு 512 MiB-ம், 32,768 token context-க்கு 4 GiB-ம் தேவைப்படும்.
ஆகவே, 4k context கொண்ட ஒரு Q4_K_M 8B model-க்கு weights-க்காக 4.58 GiB, cache-க்காக சுமார் 0.5 GiB மற்றும் runtime-க்குத் தேவையான நினைவகம் தேவை. இது 4 GiB RAM-ல் இயங்காது. 8 GiB RAM-ல் போதுமான இடவசதியுடன் இயங்கும். அதே 8 GiB கணினியில் context-ஐ 32k ஆக உயர்த்தினால், cache மட்டுமே மொத்த இடத்தையும் எடுத்துக்கொள்ளும். Model load ஆகும்போது free -h மூலம் நேரலையில் இதைக் கவனியுங்கள்; நீங்களாக அளவிடாத எந்தவொரு மதிப்பீட்டையும் நம்ப வேண்டாம். நீங்கள் 8B-க்கும் அதிகமான model-களைத் திட்டமிடுகிறீர்கள் என்றால், a 27B model on a CPU-only VPS-ல் விவரிக்கப்பட்டுள்ள அதே கணக்கீடு, 8 GB முதல் 64 GB வரையிலான ஒவ்வொரு நிலையிலும் எவ்வளவு கொள்ளளவு இருக்கும் என்பதைக் காட்டும்.
Ollama இதை மேலும் பெருக்கும். OLLAMA_NUM_PARALLEL இயல்பாக 1 என இருக்கும். ஒரு model-க்குத் தேவைப்படும் நினைவகம், அந்த எண்ணையும் context length-ஐயும் பெருக்கினால் கிடைக்கும் அளவிற்கு உயரும். இரண்டையும் ஒரே நேரத்தில் அதிகரித்தால், நீங்கள் எதிர்பார்த்ததை விட பல மடங்கு அதிக RAM-ஐ daemon கேட்கும். ஒரே நேரத்தில் பல பயனர்கள் பயன்படுத்தும்போது, ஒவ்வொரு கோரிக்கைக்கும் தனித்தனி KV cache தேவைப்படுவதால், இந்த கணக்கீடே உங்கள் வரம்பைத் தீர்மானிக்கிறது. இதனால்தான் why a server that feels fine for one person stalls at five என்ற நிலை ஏற்படுகிறது.
அச்சு 2: நீங்கள் இயக்க வேண்டிய daemon
Ollama நிறுவல் script ஒரு systemd unit-ஐ எழுதி, ollama system user-ஐ உருவாக்கி, அந்தச் சேவையை enable செய்கிறது. நீங்கள் எதையும் எழுதாமலேயே lifecycle மேலாண்மையைப் பெறுகிறீர்கள். கட்டமைப்பு (configuration) systemd வழியாகவே நடைபெறுகிறது:
sudo systemctl edit ollama[Service]
Environment="OLLAMA_CONTEXT_LENGTH=8192"
Environment="OLLAMA_KEEP_ALIVE=30m"sudo systemctl daemon-reload
sudo systemctl restart ollama
journalctl -e -u ollamaOLLAMA_KEEP_ALIVE என்பது CPU VPS-ல் மற்ற இடங்களை விட மிக முக்கியமானது. மாதிரிகள் (models) இயல்பாக 5 நிமிடங்கள் நினைவகத்தில் (memory) வைக்கப்பட்டிருக்கும், அதன் பிறகு நீக்கப்படும். அடுத்த கோரிக்கையின்போது, பதிலளிக்கத் தொடங்கும் முன் முழு கோப்பையும் மீண்டும் ஏற்ற வேண்டும். kernel அந்த கோப்பை அதன் page cache-ல் வைத்திருந்தால் அது வேகமாக இருக்கும், ஆனால் உபரி RAM மட்டுமே அதை அங்கு வைத்திருக்கும். பிற வேலைகள் அதை வெளியே தள்ளியவுடன், கோப்பு வட்டில் (disk) இருந்து மீண்டும் வர வேண்டும். எனவே, ஒரு 4.58 GiB கோப்பை மீண்டும் ஏற்றுவது, மெதுவான சேமிப்பகத்தில் இரண்டு வினாடி பதிலை முப்பது வினாடியாக மாற்றும். நீண்ட keep-alive அமைப்பானது latency-ஐச் சரிசெய்து, RAM-ஐ நிரந்தரமாகப் பயன்படுத்தும். இவை இரண்டுமே உண்மையான செலவுகள். எது குறைவான பாதிப்பை ஏற்படுத்துமோ அதைத் தேர்ந்தெடுக்கவும். மாதிரி எப்போதும் நினைவகத்தில் இருக்க வேண்டும் என்று நீங்கள் முடிவு செய்தால், keep_alive அமைப்பதன் மூலம் அது செயலற்ற காலங்களிலும் reboot-க்குப் பிறகும் நீடிக்கும், இது சில வரிகள் மட்டுமே எடுக்கும் மற்றும் ஒவ்வொரு முறை box restart ஆகும்போதும் மாதிரியை நீங்களே தயார் செய்யும் வேலையைத் தவிர்க்கும்.
llama.cpp உங்களுக்கு daemon-ஐயோ அல்லது service user-ஐயோ வழங்காது, எனவே இரண்டையும் நீங்களே அமைக்க வேண்டும். நீங்கள் build செய்த llama.cpp கோப்பகத்திலிருந்து, binary மற்றும் அதன் libraries-ஐ /usr/local-க்கு நிறுவி, ஒரு llama பயனரை உருவாக்கி, அவரிடம் மாதிரியின் நகலை வழங்கவும்:
sudo cmake --install build
sudo ldconfig
sudo useradd --system --no-create-home --shell /usr/sbin/nologin llama
sudo install -d -o llama -g llama /srv/models
sudo install -o llama -g llama -m 644 ~/models/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf /srv/models/model-Q4_K_M.ggufநீங்கள் build செய்வதற்குப் பதிலாக release archive-ஐப் பயன்படுத்தியிருந்தால், ExecStart-ஐ அதனுள் இருக்கும் llama-server-க்குச் சுட்டிக்காட்டவும், ஏனெனில் archive அதன் libraries-ஐ binary-க்கு அருகிலேயே வைத்திருக்கும். பிறகு unit-ஐ /etc/systemd/system/llama-server.service என எழுதவும்:
[Unit]
Description=llama.cpp server
After=network-online.target
[Service]
ExecStart=/usr/local/bin/llama-server -m /srv/models/model-Q4_K_M.gguf -c 4096 -t 4 --host 127.0.0.1 --port 8080
Restart=always
RestartSec=3
User=llama
[Install]
WantedBy=multi-user.targetஅதை sudo systemctl enable --now llama-server மூலம் enable செய்யவும். அந்தச் செயல்முறை (process) அதன் வாழ்நாள் முழுவதும் மாதிரியைத் தன் வசம் வைத்திருக்கும். இயல்பாக செயலற்ற நிலையில் எதுவும் நீக்கப்படாது, ஆனால் --sleep-idle-seconds-ஐச் சேர்ப்பது சேவையை நிறுத்தாமலேயே தானாகவே நீக்கி மீண்டும் ஏற்றும் வசதியை அளிக்கும். unit-களை எழுதுவது உங்களுக்குப் புதியது என்றால், அது VPS-ல் systemd கீழ் உங்கள் சொந்த சேவைகளை இயக்குவது போன்ற அதே முறையே ஆகும்.
அச்சு 3: உங்கள் செயலி தொடர்பு கொள்ளும் API
இந்த அச்சு கணிசமாகக் குறைந்துள்ளது. இரண்டு திட்டங்களும் இப்போது OpenAI chat format-ஐப் பயன்படுத்துகின்றன, எனவே base URL-ஐ மாற்றிய பிறகு பெரும்பாலான client libraries இரண்டிலும் வேலை செய்யும்.
Ollama 127.0.0.1:11434-ல் listening செய்கிறது. அதன் OpenAI-compatible route http://localhost:11434/v1/chat/completions ஆகும்; அதனுடன் native API-ஐ /api/chat-ல் வழங்குகிறது. Anthropic-compatible route-உம் documented ஆக உள்ளது. இந்த routes எதுவும் model தானாக தகவல்களைத் தேடிப் பார்க்க அனுமதிப்பதில்லை. எனவே, model-ன் training data-வை விட புதிய தகவல்களைக் கொண்ட answers உங்கள் app-க்கு தேவைப்பட்டால், Ollama-ன் API, Open WebUI, அல்லது குறுகிய tool loop மூலம் web search-ஐ இணைக்க திட்டமிடுங்கள்.
curl -X POST http://localhost:11434/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{"model": "llama31-q4", "messages": [{"role": "user", "content": "Say this is a test"}]}'மேலே உள்ள flags-உடன் தொடங்கப்படும்போது, llama-server ஆனது 127.0.0.1:8080-ல் கேட்கிறது. எந்த மாற்றமும் செய்யவில்லை என்றால், இது இப்போது port 9931-ல் இயங்குகிறது (27 October 2026 அன்று சரிபார்க்கப்பட்டது), எனவே உங்கள் செயலி 8080-ஐ எதிர்பார்க்கிறது என்றால் --port-ஐ command line-ல் சேர்க்கவும். இது /v1/chat/completions, /v1/completions மற்றும் /v1/embeddings ஆகியவற்றை வழங்குகிறது, அதனுடன் அதன் சொந்த /completion endpoint மற்றும் உள்ளமைக்கப்பட்ட web UI-யையும் வழங்குகிறது. இது Ollama-வில் இல்லாத செயல்பாட்டு வழிகளையும் (operational routes) வழங்குகிறது: readiness probe-க்கு /health, ஏற்றப்பட்ட model-ன் அமைப்புகளுக்கு /props, ஒவ்வொரு request slot-ம் என்ன செய்கிறது என்பதை அறிய /slots, மற்றும் --metrics-ஐச் சேர்த்த பிறகு Prometheus format-ல் /metrics ஆகியவற்றை வழங்குகிறது, ஏனெனில் அந்த endpoint இயல்பாகவே முடக்கப்பட்டிருக்கும். நீங்கள் இந்தச் சேவையை monitor செய்யத் திட்டமிட்டால், இந்த வேறுபாடே முடிவெடுக்கும் காரணியாக இருக்கும்.
எந்தவொரு server-ம் உங்களுக்காக authentication-ஐத் தானாகச் செயல்படுத்துவதில்லை. பாதுகாப்பு காரணங்களுக்காக இரண்டுமே இயல்பாக loopback-ல் இயங்குகின்றன. இவற்றை SSH tunnel மூலமாகவோ அல்லது reverse proxy-க்கு பின்னால் இருந்தோ அணுகவும், ஒருபோதும் 11434 அல்லது 8080 ports-ஐ இணையத்திற்குத் திறக்க வேண்டாம்.
CPU-மட்டும் கொண்ட VPS-ஆல் உண்மையாக என்ன செய்ய முடியும்
CPU-மட்டும் கொண்ட ஒரு VPS சிறிய மாடல்களை மெதுவாகவே இயக்கும். இதுவே அதன் சுருக்கமான உண்மை, இந்த வரம்பை அறிந்துகொள்வதே பயனுள்ளது. எதையும் வடிவமைக்கும் முன் அளவீடுகளைச் சரிபார்க்கவும்:
llama-bench -m ~/models/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf -p 512 -n 128pp நிரல் prompt processing வேகத்தையும், tg நிரல் token generation வேகத்தையும் குறிக்கிறது; இவை இரண்டும் tokens per second-ல் அளவிடப்படுகின்றன. ஒரு shared vCPU திட்டத்தில், 8B மாடல் Q4_K_M நிலையில் இருக்கும்போது, tg-ல் பொதுவாக ஒற்றை இலக்க வேகத்தையே தரும். Prompt processing என்பதுதான் சவாலான பகுதி: முதல் output token தோன்றுவதற்கு முன்பே முழு prompt-ம் செயலாக்கப்பட வேண்டும், எனவே நீண்ட system prompt ஒவ்வொரு கோரிக்கைக்கும் காத்திருப்பு நேரத்தை அதிகரிக்கும். பதிலின் நீளத்தை உங்களால் கட்டுப்படுத்த முடியும், ஏனெனில் வினாடிக்கு மூன்று tokens என்ற வேகத்தில், 600 tokens கொண்ட ஒரு நீண்ட பதில் 200 வினாடிகள் வரை எடுக்கும்; இது மூன்று நிமிடங்களுக்கும் மேலான generation நேரம். எனவே, num_predict மூலம் output-ஐக் கட்டுப்படுத்துவது ஒரு நீண்ட பதில் timeout ஆவதைத் தடுப்பதற்கான எளிய வழியாகும்.
CPU-ல் பயன்படுத்தக்கூடியவை: classification, extraction, சுருக்கமான summaries அல்லது routing செய்யும் 1B முதல் 4B வரையிலான மாடல்கள். பதில்கள் சில வினாடிகளில் கிடைக்கும் மற்றும் நினைவகத் தேவை சாதாரண திட்டங்களுக்குள் அடங்கும். இந்த அளவிலான மாடலுக்கு ஒரு உதாரணத்திற்கு, Nemotron 3.5 Lightning-ஐ VPS-ல் பதிவிறக்கி அளவிடுதல் என்ற கட்டுரையைப் பார்க்கவும்; இது சரியான tag, தேவைப்படும் RAM மற்றும் GPU இல்லாமல் கிடைக்கும் வேகத்தை விளக்குகிறது. CPU-ல் பயன்படுத்த முடியாதவை: வாசிப்பு வேகத்தில் நடக்கும் interactive chat, coding assistants, நீண்ட ஆவணப் பணிகள் அல்லது வரிசையாகப் பல அழைப்புகளைச் செய்யும் agent loop. நான்கு வினாடிகள் எடுக்கும் பன்னிரண்டு அழைப்புகளைக் கொண்ட ஒரு loop, முடிவைத் தர ஒரு நிமிடம் வரை எடுத்துக்கொள்ளும். ஒரு coding assistant-ஐ உருவாக்கத் திட்டமிட்டால், ஒரு agent-ஐ நீங்கள் host செய்யும் மாடலுடன் இணைத்தல் என்ற கட்டுரை, சிறிய local மாடல்கள் எவற்றில் சிறந்து விளங்கும் என்பதையும், எவை hosted API-ல் இருக்க வேண்டும் என்பதையும் தெளிவுபடுத்தும்.
எண்கள் சரியாக அமையவில்லை எனில் இரண்டு வழிகள் உள்ளன. சிக்கல் concurrency-ஆக இருந்தால், அதாவது பல பயனர்கள் ஒரே நேரத்தில் ஒரு மாடலை அணுகினால், engine-ஐ மாற்ற வேண்டும்; concurrent serving-க்காக Ollama மற்றும் vLLM ஒப்பீடு இதைப் பற்றி விளக்குகிறது. சிக்கல் வேகத்தைப் பொறுத்ததாக இருந்தால், GPU இணைக்கப்பட்ட VPS-ஐப் பயன்படுத்துவதே தீர்வு; அங்குதான் -ngl-க்கு அர்த்தம் கிடைக்கும். எதற்கும் முன்பாக, வன்பொருளின் அடிப்படை வேகத்தை (baseline) கண்டறியவும், ஏனெனில் CPU-வைப் போலவே disk மற்றும் memory bandwidth-ம் load time-ஐத் தீர்மானிக்கின்றன. மீண்டும் செய்யக்கூடிய VPS benchmark-க்கு ஒரு மணிநேரம் ஒதுக்குவது பயனுள்ளது.
llama.cpp-ஐ நிறுவுதல் மற்றும் ஒரு குறிப்பிட்ட build-ஐ நிலைநிறுத்துதல் (pinning)
இரண்டு திட்டங்களும் வாரந்தோறும் மாற்றமடைவதால், நீங்கள் பயன்படுத்தும் version-ஐ குறித்து வைத்துக்கொள்ளுங்கள். upstream-ல் உள்ள ஒற்றை வரி கட்டளை தற்போதைய build-ஐ நிறுவுகிறது:
curl -LsSf https://llama.app/install.sh | sh
llama serve -hf ggml-org/Qwen3.5-0.8B-GGUFஒரு குறிப்பிட்ட build-ஐ நிலைநிறுத்த, releases பக்கத்திலிருந்து முன்கூட்டியே தொகுக்கப்பட்ட (prebuilt) tarball-ஐப் பயன்படுத்தவும். இந்தத் திட்டம் இப்போது semantic-versioned releases-களையும் வெளியிடுகிறது: 27 அக்டோபர் 2026 அன்று v0.7.0 சமீபத்திய பதிப்பாக இருந்தது, அதன் release பக்கம் binaries-க்காக nightly b11669-ஐக் குறிப்பிடுகிறது. 28 அக்டோபர் 2026 அன்று v0.8.0 வெளியானது, அதன் release பக்கம் binaries-க்காக nightly b11960-ஐக் குறிப்பிடுகிறது. கீழே உள்ள கட்டளைகள் 2 ஆகஸ்ட் 2026 அன்று தற்போதைய tag-ஆக இருந்த b10224-ஐப் பயன்படுத்துகின்றன; நீங்கள் சோதித்த எந்த tag-ஐ வேண்டுமானாலும் அதற்குப் பதிலாகப் பயன்படுத்தவும்:
curl -LO https://github.com/ggml-org/llama.cpp/releases/download/b10224/llama-b10224-bin-ubuntu-x64.tar.gz
tar xf llama-b10224-bin-ubuntu-x64.tar.gz
find . -type f -name 'llama-server'அல்லது அதே tag-ஐ source-லிருந்து தொகுக்கவும் (build):
sudo apt update && sudo apt install -y build-essential cmake git libssl-dev
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
git checkout b10224
cmake -B build
cmake --build build --config Release -j $(nproc)libssl-dev என்பது HTTPS வசதிகளுக்கான ஆவணப்படுத்தப்பட்ட dependency ஆகும். தொகுக்கும் பணி (compile) பல நிமிடங்கள் எடுக்கும் மற்றும் சிறிய திட்டங்களில் (plans) இருப்பதை விட அதிக RAM தேவைப்படும்; எனவே, சிறிய server-ல் போதிய நினைவகம் இல்லையெனில், பெரிய server-ல் தொகுத்துவிட்டு binaries-ஐ நகலெடுக்கவும்.
Ollama-வை நிறுவுதல், ஒரு குறிப்பிட்ட version-ல் நிலைநிறுத்துதல்
curl -fsSL https://ollama.com/install.sh | OLLAMA_VERSION=0.32.5 sh
ollama -vஇந்த script OLLAMA_VERSION-ஐ வாசிக்கிறது, எனவே இன்று வெளியிடப்பட்ட புதிய version-ஐ எடுப்பதற்குப் பதிலாக, உங்களுக்குத் தெரிந்த சரியான release-ஐ நீங்கள் பயன்படுத்தலாம். v0.32.5 ஆனது 27 July 2026 அன்று வெளியிடப்பட்டது. ஒரு script-ஐ நேரடியாக shell-க்கு pipe செய்ய விரும்பவில்லை என்றால், manual வழிமுறையும் உள்ளது:
sudo rm -rf /usr/lib/ollama
curl -fsSL https://ollama.com/download/ollama-linux-amd64.tar.zst | sudo tar x -C /usr
ollama -vஇந்த manual வழிமுறை systemd unit-ஐயோ அல்லது service user-ஐயோ உருவாக்காது, எனவே அவற்றை நீங்கள் நீங்களே சேர்க்க வேண்டும். Ollama-வை VPS-ல் நிறுவுவதற்கான முழுமையான வழிகாட்டி அந்த service அமைப்பை படிப்படியாக விளக்குகிறது.
தோல்வி நிலைகள் மற்றும் நீங்கள் காணும் செய்திகள்
Ollama மாதிரியை (model) ஏற்ற மறுக்கிறது. பழைய Ollama releases மாதிரியை ஏற்றுவதற்கு முன்பே அதன் அளவைச் சரிபார்க்கும், அப்போது ollama run இந்த வடிவிலான வரியை வழங்கும்:
Error: model requires more system memory (5.6 GiB) than is available (3.2 GiB)தற்போதைய Ollama source-ல் அந்தச் செய்தி இல்லை (27 அக்டோபர் 2026 அன்று சரிபார்க்கப்பட்டது). Ollama இப்போது மாதிரியை ஏற்றும் பணியை llama-server-க்கு வழங்குகிறது. எனவே, கொள்ளளவு போதாத மாதிரி ஒரு runner தோல்வியாகவே காட்டப்படும். அப்போது கீழ்க்கண்டவாறு தொடங்கும் பிழைகள் தோன்றும்:
llama-server reported out-of-memory during startup
llama-server process has terminatedஎப்படியிருப்பினும், தீர்வு ஒன்றுதான். ஒரு quantisation நிலையை குறைக்கவும், context length-ஐக் குறைக்கவும் அல்லது சிறிய மாதிரியைத் தேர்ந்தெடுக்கவும்.
llama.cpp தோல்வியடையவில்லை, ஆனால் மிக மெதுவாக இயங்குகிறது. llama.cpp இயல்பாகவே GGUF-ஐ memory-map செய்கிறது, எனவே RAM-ஐ விட பெரிய கோப்பும் தொடங்கும். ஒவ்வொரு token-க்கும் kernel வட்டில் (disk) இருந்து weights-ஐ மாற்றி மாற்றி ஏற்றும். இதனால் disk 100 சதவீதம் பயன்பாட்டில் இருக்கும், generation வேகம் ஒரு token-க்கு பல நொடிகள் என குறையும். memory mapping-ஐ முடக்க --load-mode none-ஐப் பயன்படுத்தவும். அந்த விருப்பம் --no-mmap-க்கு மாற்றாக வந்தது. b10224 build-ல் அது deprecated என்று குறிப்பிடப்பட்டுள்ளது மற்றும் தற்போதைய builds-ல் அது இல்லை (29 அக்டோபர் 2026 அன்று சரிபார்க்கப்பட்டது). kernel தலையிடும்போது, dmesg அதற்கான காரணத்தைக் காட்டும்:
Out of memory: Killed process 1234 (llama-server)மாதிரிக் கோப்பு (model file) ஏற்றப்படவே இல்லை. உங்கள் engine-ஐ விட புதிய model family-க்காக உருவாக்கப்பட்ட GGUF கோப்பு, தனக்குத் தெரியாத architecture-ஐக் குறிப்பிட்டு பிழையைக் காட்டும். இதில் <arch> என்பது கோப்பின் metadata-வில் சேமிக்கப்பட்டுள்ள பெயர்:
llama_model_load: error loading model: unknown model architecture: '<arch>'இதற்குத் தீர்வு engine-ஐ upgrade செய்வதுதான், வேறு கோப்பைத் தேர்ந்தெடுப்பது அல்ல. இது pinning செய்வதற்கான விலை, இதனால்தான் நீங்கள் build எண்ணைக் குறித்து வைக்க வேண்டும். நீங்கள் எந்தப் பதிப்பிலிருந்து upgrade செய்கிறீர்கள் என்பதை நீங்கள் அறிந்திருக்க வேண்டும்.
API உள்ளூர் அளவில் பதிலளிக்கிறது, ஆனால் உங்கள் app-லிருந்து பதிலளிக்கவில்லை. Ollama 127.0.0.1:11434-ல் bind செய்கிறது, எனவே பிற host-கள் connection refused என்று பெறும். OLLAMA_HOST=0.0.0.0:11434-ஐ systemctl edit ollama வழியாக அமைக்கவும். அந்த port ஒரு firewall அல்லது private network-க்கு பின்னால் இருக்கும்போது மட்டுமே இதைச் செய்யவும், ஏனெனில் இந்த API-க்கு முன்னால் authentication கிடையாது.
சிறிது இடைவெளிக்குப் பிறகு வரும் முதல் பதில் மிக மெதுவாக உள்ளது. 5 நிமிட idle unload நிகழ்ந்திருக்கலாம், மாதிரி மீண்டும் வட்டில் இருந்து ஏற்றப்படுகிறது (page cache-ல் அது இல்லையெனில்). கோரிக்கைக்குச் சற்று முன்பு ollama ps-ஐ இயக்கினால், எதுவும் ஏற்றப்படவில்லை என்பதைக் காட்டும், இதுவே இதற்கான உறுதிப்படுத்தல். OLLAMA_KEEP_ALIVE-ஐ அதிகரிக்கவும்.
எதை நீங்கள் இயக்க வேண்டும்?
உங்களுக்கு மாதிரிகள் (models) நிர்வகிக்கப்பட வேண்டும் மற்றும் கூடுதல் வேலைகள் இன்றி OpenAI போன்ற endpoint தேவைப்படும்போது Ollama-வை இயக்கவும். முதல்முறை deployment செய்வதற்கும், அடிக்கடி மாதிரிகளை மாற்ற வேண்டிய சூழல்களுக்கும் இதுவே சரியான தேர்வாகும்.
நினைவகத் திறன் (memory) குறைவாக இருந்து, நீங்களே quantisation வரிசையைத் தேர்ந்தெடுக்க வேண்டியிருக்கும்போது, கண்காணிப்பிற்காக /health, /slots மற்றும் /metrics தேவைப்படும்போது, அல்லது Ollama வழங்காத ஒரு குறிப்பிட்ட flag தேவைப்படும்போது llama.cpp-ஐ நேரடியாக இயக்கவும். ஒரு VPS-ல் மாதிரி மிகக் குறைந்த இடவசதியிலேயே பொருந்தும் சூழலில் இதுவே சிறந்த தேர்வாகும், ஏனெனில் அந்த மாதிரியைப் பொருத்துவதற்குத் தேவையான அமைப்புகளை Ollama உங்களுக்காகவே தானாகவே கையாள்கிறது.
இவ்விரண்டையும் இயக்குவது இயல்பான ஒன்றுதான். சோதனைகளுக்கு Ollama-வையும், production-ல் வைத்து மாற்றாமல் பயன்படுத்த விரும்பும் ஒரு குறிப்பிட்ட மாதிரிக்கு llama.cpp-யையும் பயன்படுத்தலாம்.
FAQ
Ollama என்பது llama.cpp-ன் வெறும் wrapper மட்டும்தானா?
இல்லை, இது வெறும் wrapper மட்டுமல்ல, கூடுதல் பணிகளையும் செய்கிறது. Ollama-வின் README, llama.cpp-ஐ அதன் inference backend-ஆகக் குறிப்பிடுகிறது (27 October 2026 அன்று சரிபார்க்கப்பட்டது). இதன் மேல், Ollama ஒரு model registry, chat செய்திகளை prompt-ஆக மாற்றும் prompt template, இயல்பான sampling parameters, idle நிலையில் இருக்கும்போது model-ஐ நீக்கும் daemon மற்றும் ஒரு HTTP API ஆகியவற்றை வழங்குகிறது. ஒரே அமைப்புகளில் tokens per second-ஐ ஒப்பிடும்போது, நீங்கள் ஒரே engine-ஐத்தான் ஒப்பிடுகிறீர்கள். நீங்கள் உண்மையில் தேர்வு செய்வது அதன் மேலாண்மை அடுக்கு (management layer) ஆகும்.
CPU-மட்டும் கொண்ட VPS-ல் எது வேகமானது?
இரண்டும் ஒரே engine-ஐப் பயன்படுத்துவதால், ஒரே model file, quantisation, context size மற்றும் thread count ஆகியவற்றில் அவை ஏறக்குறைய ஒரே வேகத்தையே தரும். மக்கள் தெரிவிக்கும் வேக வேறுபாடுகள் பெரும்பாலும் engine-னால் வருவதில்லை; மாறாக, context length மற்றும் thread count போன்ற இயல்புநிலை அமைப்புகளால் (defaults) ஏற்படுகின்றன. எந்தவொரு தரவையும் நம்புவதற்கு முன், llama-bench -m <file> -p 512 -n 128 மூலம் அளவிட்டு, உங்கள் server-ல் tg column-ஐ ஒப்பிட்டுப் பாருங்கள்.
எனது சொந்த GGUF கோப்பை Ollama-வில் பயன்படுத்த முடியுமா?
ஆம். கோப்பை server-ல் பதிவேற்றி, ஒரு Modelfile-ஐ உருவாக்கவும். அதன் முதல் வரியாக FROM ./your-model.gguf இருக்க வேண்டும். தேவையான PARAMETER வரிகளைச் சேர்க்கவும் (உதாரணமாக num_ctx). பிறகு ollama create your-name -f ./Modelfile-ஐ இயக்கவும். ollama ls கட்டளை, registry-யிலிருந்து நீங்கள் பதிவிறக்கிய பிற மாதிரிகளுடன் இதையும் பட்டியலிடும். registry-யில் இல்லாத quantisation-ஐப் பயன்படுத்த இதுவே வழி.
8B model-க்கு எவ்வளவு RAM தேவை?
கோப்பின் அளவு, KV cache மற்றும் runtime ஆகியவற்றை கணக்கில் கொள்ள வேண்டும். Llama 3.1 8B-ன் Q4_K_M build வட்டில் சுமார் 4.58 GiB இருக்கும். 4096 token context-க்கு சுமார் 512 MiB cache தேவைப்படும். எனவே, 8 GiB RAM போதுமானது, ஆனால் 4 GiB போதாது. Cache அளவு context-க்கு ஏற்ப அதிகரிக்கும்: அதே model-க்கு 32,768 token context-ல் சுமார் 4 GiB cache தேவைப்படும். Ollama-வைப் பயன்படுத்தும்போது, தேவைப்படும் RAM அளவானது OLLAMA_NUM_PARALLEL-ஐப் பொறுத்தும் அதிகரிக்கும் என்பதை நினைவில் கொள்க.