VPS లో Ollama vs llama.cpp: ఏది ఎంచుకోవాలి?
llama.cpp అనేది ఇంజిన్, Ollama దానిపై ఉండే లేయర్. CPU మాత్రమే ఉన్న VPS లలో మెమరీ ఆదా చేయడానికి ఏది ఉత్తమమో, క్వాంటైజేషన్ మరియు RAM వినియోగంపై పూర్తి విశ్లేషణ ఇక్కడ చూడండి.
Ollama vs llama.cpp: మీరు ఏ లేయర్ను రన్ చేయాలనుకుంటున్నారు?
Ollama మరియు llama.cpp లు ఈ ప్రశ్న సూచించినట్లుగా ప్రత్యర్థులు కావు. llama.cpp అనేది ఒక inference engine: ఇది ఒక మోడల్ ఫైల్ను లోడ్ చేసి, ప్రాంప్ట్ను టోకెన్లుగా మారుస్తుంది. Ollama అనేది ఒక మోడల్ మేనేజర్, ఇది ఆ ఇంజిన్ పైన పనిచేసే ఒక background daemon మరియు HTTP API. Ollama యొక్క README ఇప్పటికీ llama.cpp ని దాని inference backend గానే పేర్కొంటోంది (27 అక్టోబర్ 2026 నాటికి తనిఖీ చేయబడింది). కాబట్టి అసలైన ప్రశ్న ఏది వేగంగా పనిచేస్తుంది అనేది కాదు, మీ VPS లో మీరు ఏ లేయర్ను ఆపరేట్ చేయాలనుకుంటున్నారు అనేది.
మీకు మోడళ్లను పేరుతో తెచ్చుకుని, ఎటువంటి పర్యవేక్షణ లేకుండా నిరంతరం పనిచేసే సేవ కావాలంటే Ollamaను రన్ చేయండి. మీ సర్వర్ చిన్నదిగా ఉండి, ఖచ్చితమైన మోడల్ ఫైల్, ఖచ్చితమైన context size మరియు ఖచ్చితమైన thread count ను మీరే ఎంచుకోవాల్సిన అవసరం ఉంటే llama.cpp ని నేరుగా రన్ చేయండి. ఎందుకంటే చిన్న VPS లలో ఈ సెట్టింగ్లలో ప్రతిదీ మీకు అందుబాటులో లేని మెమరీని ఖర్చు చేస్తుంది.
ప్రతి ప్రాజెక్ట్ అంటే ఏమిటి
llama.cpp అనేది ggml లైబ్రరీపై నిర్మించిన transformer inference యొక్క C మరియు C++ ఇంప్లిమెంటేషన్. ఇది GGUF ఫైళ్లను చదువుతుంది. GGUF (GGML universal file format) అనేది మోడల్ను రన్ చేయడానికి ఇంజిన్కు అవసరమైన weights, tokeniser మరియు metadataను కలిగి ఉండే ఒకే ఫైల్ కంటైనర్. ఈ ప్రాజెక్ట్ వేర్వేరు పనుల కోసం వేర్వేరు బైనరీలను విడుదల చేస్తుంది. llama-server అనేది ఒక HTTP సర్వర్, llama-cli అనేది ఒక ఇంటరాక్టివ్ ప్రాంప్ట్, మరియు llama-bench అనేది త్రూపుట్ను కొలుస్తుంది. ఈ ప్రాజెక్ట్ ఇప్పుడు సెమాంటిక్-వెర్షన్డ్ రిలీజ్లను (MAJOR.MINOR.PATCH) విడుదల చేస్తోంది, మరియు 15 అక్టోబర్ 2026న ప్రచురించబడిన v0.7.0, 27 అక్టోబర్ 2026 నాటికి తాజా వెర్షన్. వీటితో పాటు బిల్డ్-నంబర్డ్ నైట్లీ ట్యాగ్లు రోజుకు కొన్ని చొప్పున వస్తుంటాయి, 27 అక్టోబర్ 2026 నాటికి కొత్తది b11913.
Ollama అనేది ఒక Go ప్రోగ్రామ్. ollama serveతో ప్రారంభమయ్యే ఒక బ్యాక్గ్రౌండ్ డెమోన్, మోడళ్లను లోడ్ చేసి HTTP అభ్యర్థనలకు సమాధానమిస్తుంది, మరియు ఒక కమాండ్ లైన్ క్లయింట్ ఆ డెమోన్తో మాట్లాడుతుంది. ఈ రెండింటి వెనుక ollama.com వద్ద ముందే ప్యాక్ చేసిన మోడళ్లను కలిగి ఉన్న ఒక రిజిస్ట్రీ ఉంటుంది. Ollama సెమాంటిక్ వెర్షన్లను ఉపయోగిస్తుంది. v0.32.5 అనేది 27 జూలై 2026న విడుదలైంది, మరియు v0.40.12 అనేది 27 అక్టోబర్ 2026న 00:07 UTCకి విడుదల చేయబడింది. ollama pull ఒక GGUFను ప్రాంప్ట్ టెంప్లేట్ మరియు డిఫాల్ట్ పారామీటర్ల సెట్తో కలిపి తీసుకువస్తుంది, ఆపై దానిని Linuxలో /usr/share/ollama/.ollama/models కింద నిల్వ చేస్తుంది. ఆ ఫైళ్లు రూట్ డిస్క్లో ఉంటాయి మరియు ఒక్కొక్కటి కొన్ని గిగాబైట్ల పరిమాణంలో ఉంటాయి, కాబట్టి 25 GB రూట్ వాల్యూమ్ ఉన్న VPSలో మూడవ డౌన్లోడ్ నింపకముందే pull ఏమి వదిలివేస్తుంది మరియు మోడల్ డైరెక్టరీని వేరే చోటికి ఎలా తరలించాలి అని తెలుసుకోవడం మంచిది.
ఆ ప్యాకేజింగ్ మాత్రమే ప్రధాన వ్యత్యాసం. Ollama మీ కోసం క్వాంటిజేషన్, టెంప్లేట్ మరియు కాంటెక్స్ట్ లెంగ్త్ను నిర్ణయిస్తుంది, మరియు గుర్తుంచుకోవడానికి మీకు ఒక పేరును ఇస్తుంది. llama.cpp ఆ ఎంపికలను ఫ్లాగ్లుగా చూపిస్తుంది, మీరు సెట్ చేయని సెట్టింగ్ల కోసం ఆటోమేటిక్ డిఫాల్ట్లను ఉపయోగిస్తుంది.
అక్షం 1: మోడల్ మరియు క్వాంటైజేషన్ నియంత్రణ
క్వాంటైజేషన్ అనేది అసలు మోడల్లోని 16 లేదా 32 బిట్ల కంటే తక్కువ బిట్లలో వెయిట్స్ను నిల్వ చేస్తుంది. సాధారణ GGUF బిల్డ్లు సగటున ప్రతి వెయిట్కు సుమారు 4, 5 లేదా 8 బిట్లను ఉపయోగిస్తాయి. ఫైల్ అంతటా ప్రిసిషన్ ఒకేలా ఉండదు. llama.cpp క్వాంటైజర్ సోర్స్లో (27 అక్టోబర్ 2026న చదివినట్లు), Q4_K_M బిల్డ్ చాలా టెన్సర్లను 4-బిట్లో ఉంచుతుంది, కానీ అవుట్పుట్ లేయర్, అటెన్షన్ వాల్యూ మరియు ఫీడ్-ఫార్వర్డ్ డౌన్ టెన్సర్లను సుమారు సగం లేయర్లలో 6-బిట్ Q6_K కి మారుస్తుంది. నార్మ్స్ వంటి చిన్న టెన్సర్లు అస్సలు క్వాంటైజ్ చేయబడవు. దీనివల్లనే 8 బిలియన్ పారామీటర్ల మోడల్ ఒక సాధారణ VPS యొక్క RAMలో సరిపోతుంది. GGUF నామకరణ పద్ధతి తెలిస్తే అది అర్థం చేసుకోవడం సులభం: Q4_K_M అంటే 4-బిట్ K-క్వాంట్, మీడియం సైజు అని అర్థం. సంఖ్య పెరిగేకొద్దీ ప్రిసిషన్ పెరుగుతుంది, కానీ మెమరీ వినియోగం కూడా పెరుగుతుంది.
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
{
"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. సాధారణ డిఫాల్ట్ అయిన 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 అనేది టోకెన్లలో కాంటెక్స్ట్ పరిమాణం, -t అనేది త్రెడ్ కౌంట్, మరియు -ngl ఎన్ని లేయర్లను GPUకి తరలించాలో నిర్ణయిస్తుంది (CPU-మాత్రమే ఉన్న బాక్సుల్లో ఇది 0). సెట్టింగ్లు సెట్ చేయకపోతే డిఫాల్ట్లు వర్తిస్తాయి, మరియు పరికర మెమరీకి అనుగుణంగా ఆర్గ్యుమెంట్లను సర్దుబాటు చేయడానికి --fit డిఫాల్ట్గా ఆన్లో ఉంటుంది.
Ollama తో క్వాంటైజేషన్ మీరు పుల్ చేసే ట్యాగ్తో పాటు వస్తుంది, మరియు 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కాంటెక్స్ట్ లెంగ్త్ అనేది చాలా మందిని ఇబ్బంది పెట్టే సెట్టింగ్. Ollama అందుబాటులో ఉన్న VRAM నుండి తన డిఫాల్ట్ను ఎంచుకుంటుంది, GPU లేని బాక్స్ అతి చిన్న బకెట్లోకి వెళ్తుంది: 4096 టోకెన్లు. దీనికి 20,000 టోకెన్ల డాక్యుమెంట్ను పంపితే, మోడల్ చూడకముందే అదనపు టోకెన్లు తొలగించబడతాయి. కాబట్టి, సగం మాత్రమే చదివిన ఫైల్ గురించి మోడల్ తప్పుడు సమాధానం ఇస్తుంది. దీనిని డెమోన్ మీద OLLAMA_CONTEXT_LENGTH తో లేదా Modelfile లో PARAMETER num_ctx తో పెంచండి. ఒకవేళ ఒకే జాబ్కు పెద్ద విండో అవసరమైతే, num_ctx ను సర్వర్ అంతటా కాకుండా ప్రతి అభ్యర్థనకు విడిగా సెట్ చేయవచ్చు, ఇది డెమోన్ చేసే ఇతర పనులపై అదనపు కాష్ భారాన్ని పడకుండా చేస్తుంది. llama.cpp లో కూడా నమ్మదగిన డిఫాల్ట్ ఏదీ లేదు. -c ను స్పష్టంగా సెట్ చేయండి మరియు మీరు ఏమి సెట్ చేస్తున్నారో తెలుసుకోండి.
మెమరీ గణన గురించి ఎవరూ చెప్పని విషయాలు
మోడల్ ఫైల్ మాత్రమే మొత్తం ఖర్చు కాదు. KV cache (key/value cache) ప్రతి లేయర్కు, ప్రతి కాంటెక్స్ట్ టోకెన్కు ఒక ఎంట్రీని కలిగి ఉంటుంది. సంభాషణ పెరిగేకొద్దీ ఇది కూడా పెరుగుతుంది.
Llama 3.1 8B కోసం దీనిని లెక్కించండి. ఈ మోడల్లో 32 లేయర్లు, 8 key/value హెడ్స్ మరియు 128 హెడ్ డైమెన్షన్ ఉన్నాయి. ప్రతి టోకెన్ f16 ఫార్మాట్లో 2 బైట్ల చొప్పున కీ మరియు వాల్యూ రెండింటినీ నిల్వ చేస్తుంది. కాబట్టి, ప్రతి లేయర్కు 2 x 8 x 128 x 2 = 4096 బైట్లు అవసరం. 32 లేయర్లకు కలిపి ఇది ప్రతి టోకెన్కు 128 KiB అవుతుంది. అందువల్ల, 4096 టోకెన్ల కాంటెక్స్ట్ కోసం 512 MiB, మరియు 32,768 టోకెన్ల కాంటెక్స్ట్ కోసం 4 GiB మెమరీ ఖర్చవుతుంది.
కాబట్టి, 4k కాంటెక్స్ట్ ఉన్న Q4_K_M 8B మోడల్కు వెయిట్స్ కోసం సుమారు 4.58 GiB, అదనంగా 0.5 GiB cache, మరియు రన్టైమ్ కోసం కొంత మెమరీ అవసరం. ఇది 4 GiB RAM లో సరిపోదు. 8 GiB RAM లో అయితే ఇది సులభంగా సరిపోతుంది. అదే 8 GiB బాక్స్లో కాంటెక్స్ట్ను 32k కి పెంచితే, కేవలం cache మాత్రమే అందుబాటులో ఉన్న మెమరీని పూర్తిగా వాడేస్తుంది. మోడల్ లోడ్ అవుతున్నప్పుడు free -h తో దీనిని ప్రత్యక్షంగా గమనించండి, మీరు స్వయంగా కొలవని అంచనాలను నమ్మకండి. మీరు 8B కంటే పెద్ద మోడల్ కోసం ప్లాన్ చేస్తుంటే, a 27B model on a CPU-only VPS లో వివరించిన అదే గణన పద్ధతిని ఉపయోగించి 8 GB నుండి 64 GB వరకు ప్రతి స్థాయి ఎంత మెమరీని తీసుకుంటుందో తెలుసుకోవచ్చు.
Ollama దీనిని మరింత పెంచుతుంది. OLLAMA_NUM_PARALLEL డిఫాల్ట్గా 1 కి సెట్ చేయబడి ఉంటుంది, మోడల్కు అవసరమైన మెమరీ ఆ సంఖ్య మరియు కాంటెక్స్ట్ లెంగ్త్ రెండింటిపై ఆధారపడి ఉంటుంది. ఈ రెండింటినీ ఒకేసారి పెంచితే, మీరు ఊహించిన దానికంటే చాలా ఎక్కువ RAM అవసరమని daemon అడుగుతుంది. అదే గణన పద్ధతి ఏకకాలంలో ఎంతమంది వినియోగదారులు వాడగలరో నిర్ణయిస్తుంది, ఎందుకంటే ప్రతి అభ్యర్థనకు విడి KV cache అవసరం. అందుకే why a server that feels fine for one person stalls at five.
Axis 2: మీరు నిర్వహించాల్సిన daemon
Ollama ఇన్స్టాల్ స్క్రిప్ట్ ఒక systemd unit ను రాస్తుంది, ollama సిస్టమ్ యూజర్ను సృష్టిస్తుంది మరియు సేవను ఎనేబుల్ చేస్తుంది. మీరు ఏమీ రాయకుండానే lifecycle నిర్వహణను పొందుతారు. కాన్ఫిగరేషన్ 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లో మరెక్కడా లేనంత ముఖ్యమైనది. మోడల్స్ డిఫాల్ట్గా 5 నిమిషాల పాటు మెమరీలో ఉండి, ఆ తర్వాత అన్లోడ్ అవుతాయి. తదుపరి అభ్యర్థన సమాధానం ఇచ్చే ముందు మొత్తం ఫైల్ను మళ్లీ లోడ్ చేయాలి. ఒకవేళ కెర్నల్ ఫైల్ను దాని page cache లో ఉంచితే అది వేగంగా జరుగుతుంది, కానీ ఖాళీ RAM మాత్రమే దానిని అక్కడ ఉంచగలదు. ఇతర పనులు దానిని బయటకు నెట్టినప్పుడు, ఫైల్ డిస్క్ నుండి తిరిగి వస్తుంది. కాబట్టి, 4.58 GiB రీలోడ్ అనేది నెమ్మదిగా ఉండే స్టోరేజ్లో రెండు సెకన్ల సమాధానాన్ని ముప్పై సెకన్లకు మారుస్తుంది. ఎక్కువ సమయం keep-alive ఉంచడం వల్ల latency తగ్గుతుంది మరియు RAM శాశ్వతంగా వినియోగించబడుతుంది. ఈ రెండూ నిజమైన ఖర్చులే. మీకు తక్కువ నష్టం కలిగించే దానిని ఎంచుకోండి. మోడల్ అలాగే ఉండాలని మీరు నిర్ణయించుకుంటే, keep_alive ను సెట్ చేయడం ద్వారా అది idle సమయాల్లో మరియు రీబూట్ల తర్వాత కూడా ఉంటుంది. దీనికి కొన్ని లైన్లు సరిపోతాయి మరియు ప్రతిసారీ బాక్స్ను రీస్టార్ట్ చేసినప్పుడు మాన్యువల్గా మోడల్ను వార్మ్ చేయాల్సిన అవసరం ఉండదు.
llama.cpp మీకు ఎటువంటి daemon లేదా service user ను అందించదు, కాబట్టి మీరు రెండింటినీ మీరే సెటప్ చేసుకోవాలి. మీరు బిల్డ్ చేసిన llama.cpp డైరెక్టరీ నుండి, బైనరీని మరియు దాని లైబ్రరీలను /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మీరు బిల్డ్ చేయడానికి బదులుగా release archive ను ఉపయోగించినట్లయితే, ExecStart ను దానిలోని llama-server కి పాయింట్ చేయండి, ఎందుకంటే ఆ archive దాని లైబ్రరీలను బైనరీ పక్కనే ఉంచుతుంది. ఆ తర్వాత 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 తో ఎనేబుల్ చేయండి. అప్పుడు ఆ ప్రాసెస్ తన జీవితకాలం అంతా మోడల్ను కలిగి ఉంటుంది. డిఫాల్ట్గా idle సమయంలో ఏదీ అన్లోడ్ అవ్వదు, కానీ --sleep-idle-seconds ను జోడించడం ద్వారా సేవను ఆపకుండానే ఆటోమేటిక్ అన్లోడ్ మరియు రీలోడ్ ఎనేబుల్ అవుతుంది. యూనిట్లను రాయడం మీకు కొత్త అయితే, ఇది VPSలో systemd కింద మీ స్వంత సేవలను రన్ చేయడం వంటిదే.
Axis 3: మీ అప్లికేషన్ కమ్యూనికేట్ చేసే API
ఈ విభాగం చాలా వరకు కుదించబడింది. ప్రస్తుతం రెండు ప్రాజెక్టులు OpenAI చాట్ ఫార్మాట్ను ఉపయోగిస్తున్నాయి, కాబట్టి బేస్ URL మార్చిన తర్వాత చాలా క్లయింట్ లైబ్రరీలు రెండింటితోనూ పనిచేస్తాయి.
Ollama 127.0.0.1:11434 పై connections కోసం వింటుంది. దాని OpenAI-compatible route http://localhost:11434/v1/chat/completions; దీనితో పాటు native API ను /api/chat వద్ద అందిస్తుంది. Anthropic-compatible route కూడా documentation లో ఉంది. ఈ routes ఏదీ model స్వయంగా సమాచారాన్ని శోధించడానికి అనుమతించదు. అందువల్ల మీ app కు model training data కంటే కొత్త సమాధానాలు అవసరమైతే, 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"}]}'పైన పేర్కొన్న ఫ్లాగ్లతో ప్రారంభించినప్పుడు, llama-server అనేది 127.0.0.1:8080 వద్ద వింటుంది. ఏ మార్పులు చేయకపోతే ఇది డిఫాల్ట్గా 9931 పోర్ట్ను తీసుకుంటుంది (27 అక్టోబర్ 2026న తనిఖీ చేయబడింది), కాబట్టి మీ అప్లికేషన్ 8080ని ఆశిస్తుంటే కమాండ్ లైన్లో --portని అలాగే ఉంచండి. ఇది /v1/chat/completions, /v1/completions మరియు /v1/embeddings తో పాటు, దాని స్వంత /completion ఎండ్పాయింట్ మరియు అంతర్నిర్మిత వెబ్ UIని అందిస్తుంది. ఇది Ollamaలో లేని అదనపు ఆపరేషనల్ రూట్లను కూడా అందిస్తుంది: readiness probe కోసం /health, లోడ్ అయిన మోడల్ సెట్టింగ్ల కోసం /props, ప్రతి రిక్వెస్ట్ స్లాట్ ఏమి చేస్తుందో తెలుసుకోవడానికి /slots, మరియు మీరు --metricsని జోడించిన తర్వాత Prometheus ఫార్మాట్లో /metrics అందుబాటులో ఉంటాయి, ఎందుకంటే ఈ ఎండ్పాయింట్ డిఫాల్ట్గా ఆఫ్ చేయబడి ఉంటుంది. మీరు ఈ సేవను పర్యవేక్షించాలని (monitor) అనుకుంటే, ఈ వ్యత్యాసమే నిర్ణయాత్మక అంశం కావచ్చు.
ఏ సర్వర్ కూడా మీ కోసం అథెంటికేషన్ను ఆన్ చేయదు. భద్రతా కారణాల దృష్ట్యా రెండూ డిఫాల్ట్గా లూప్బ్యాక్ (loopback) అడ్రస్నే ఉపయోగిస్తాయి. వీటిని SSH టన్నెల్ ద్వారా లేదా రివర్స్ ప్రాక్సీ వెనుక నుండి మాత్రమే యాక్సెస్ చేయండి, ఎట్టి పరిస్థితుల్లోనూ 11434 లేదా 8080 పోర్ట్లను ఇంటర్నెట్కు నేరుగా ఓపెన్ చేయవద్దు.
CPU-only VPS నిజంగా చేయగల పనులు
CPU-only VPS చిన్న models ను నెమ్మదిగా నడుపుతుంది. ఇదే వాస్తవ సారాంశం. ఉపయోగకరమైన విషయం ఏమిటంటే, దాని పరిమితి ఎక్కడ ఉందో తెలుసుకోవడం. దాని చుట్టూ ఏదైనా రూపకల్పన చేయడానికి ముందు కొలవండి:
llama-bench -m ~/models/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf -p 512 -n 128pp column prompt processing speed ను, tg column token generation speed ను చూపిస్తాయి. రెండింటి యూనిట్ tokens per second. Shared vCPU plan లో Q4_K_M వద్ద 8B model సాధారణంగా tg కోసం తక్కువ single-digit విలువలను ఇస్తుంది. ఇబ్బంది కలిగించే భాగం prompt processing: మొదటి output token కనిపించే ముందు మొత్తం prompt process అవుతుంది. అందువల్ల పొడవైన system prompt ప్రతి request కు అదనపు నిరీక్షణను కలిగిస్తుంది. మీరు వాస్తవంగా నియంత్రించగల భాగం reply length. సెకనుకు మూడు tokens వేగంతో model 600 tokens వరకు అనవసరంగా పొడిగిస్తే, box 200 seconds పాటు బిజీగా ఉంటుంది. అంటే generation మాత్రమే మూడు నిమిషాలకు పైగా పడుతుంది. అందువల్ల num_predict తో output పరిమాణాన్ని పరిమితం చేయడం ఒక chatty answer timeout గా మారకుండా ఆపే తక్కువ ఖర్చు మార్గం.
CPUపై ఉపయోగించదగిన పనులు: classification, extraction, short summaries లేదా routing చేసే 1B నుంచి 4B model. Replies కొన్ని seconds లో వస్తాయి. Memory కూడా సాధారణ plan లో సరిపోతుంది. ఆ పరిమాణాన్ని range గా కాకుండా ఒక నిర్దిష్ట ఉదాహరణతో చూడాలంటే, VPSలో pull చేసి కొలిచిన Nemotron 3.5 Lightning ఖచ్చితమైన tag, వాస్తవంగా అవసరమయ్యే RAM, GPU లేకుండా నిలబెట్టే speed ను చూపిస్తుంది. CPUపై ఉపయోగించలేని పనులు: చదివే వేగంతో interactive chat, coding assistants, long-document work లేదా వరుసగా అనేక calls చేసే agent loop ఉన్న పనులు. ప్రతి call కు నాలుగు seconds పట్టే loop పన్నెండు calls చేస్తే, ఏదైనా output వచ్చేలోపు ఒక minute పడుతుంది. Coding assistant ఉపయోగించాలనేది మీ ప్రణాళిక అయితే, మీరు స్వయంగా host చేసే model కు agent ను అనుసంధానించడం చిన్న local model నిజంగా ఏ పనుల్లో ఉపయోగకరమో, ఏ పనులు hosted API వద్దనే ఉంచాలో వివరిస్తుంది.
సంఖ్యలు సరిపోకపోతే రెండు మార్గాలు ఉన్నాయి. సమస్య concurrency అయితే, అంటే ఒకేసారి అనేక users ఒకే model ను ఉపయోగిస్తే, engine ఎంపికను మార్చాలి. concurrent serving కోసం Ollama మరియు vLLM పోలిక ఈ విషయాన్ని వివరిస్తుంది. సమస్య raw speed అయితే, సమాధానం GPU అనుసంధానించిన VPS; అక్కడ -ngl కు వాస్తవ అర్థం రావడం ప్రారంభమవుతుంది. ఈ రెండింటికి ముందు hardware కోసం ఒక baseline తీసుకోండి. ఎందుకంటే CPUతో సమానంగా disk మరియు memory bandwidth కూడా load time ను ప్రభావితం చేస్తాయి. పునరావృతంగా అమలు చేయగల VPS benchmark కోసం ఒక గంట కేటాయించడం విలువైనదే.
llama.cpp ని ఇన్స్టాల్ చేయడం, ఒక నిర్దిష్ట build కి పరిమితం చేయడం
ఈ రెండు ప్రాజెక్టులు వారానికోసారి మారుతుంటాయి, కాబట్టి మీరు ఏ వెర్షన్ను డిప్లాయ్ చేశారో నమోదు చేసుకోండి. అప్స్ట్రీమ్ వన్-లైనర్ కమాండ్ ప్రస్తుత build ను ఇన్స్టాల్ చేస్తుంది:
curl -LsSf https://llama.app/install.sh | sh
llama serve -hf ggml-org/Qwen3.5-0.8B-GGUFఒక నిర్దిష్ట build ను ఫిక్స్ చేయడానికి, releases పేజీ నుండి ముందుగా బిల్డ్ చేసిన (prebuilt) tarball ను తీసుకోండి. ఈ ప్రాజెక్ట్ ఇప్పుడు semantic-versioning పద్ధతిలో releases ను విడుదల చేస్తోంది: 27 అక్టోబర్ 2026 నాటికి v0.7.0 తాజా వెర్షన్, దీని release పేజీ బైనరీల కోసం nightly b11669 ను సూచిస్తుంది. 28 అక్టోబర్ 2026న v0.8.0 విడుదలైంది, దీని release పేజీ బైనరీల కోసం nightly b11960 ను సూచిస్తుంది. క్రింద ఉన్న కమాండ్లు 2 ఆగస్టు 2026 నాటి ప్రస్తుత ట్యాగ్ అయిన b10224 ను ఉపయోగిస్తాయి; మీరు పరీక్షించిన ట్యాగ్ను దీని స్థానంలో ఉపయోగించండి:
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'లేదా అదే ట్యాగ్ను సోర్స్ నుండి బిల్డ్ చేయండి:
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)HTTPS ఫీచర్ల కోసం libssl-dev అవసరమని డాక్యుమెంటేషన్లో పేర్కొనబడింది. కంపైల్ చేయడానికి కొన్ని నిమిషాల సమయం పడుతుంది మరియు అతి చిన్న ప్లాన్లలో ఉండే దానికంటే ఎక్కువ RAM అవసరమవుతుంది, కాబట్టి చిన్న సర్వర్లో మెమరీ సరిపోకపోతే, పెద్ద సర్వర్లో బిల్డ్ చేసి బైనరీలను కాపీ చేయండి.
Ollama ను ఇన్స్టాల్ చేయడం, ఒక వెర్షన్కు పిన్ చేయడం
curl -fsSL https://ollama.com/install.sh | OLLAMA_VERSION=0.32.5 sh
ollama -vఈ స్క్రిప్ట్ OLLAMA_VERSION ని చదువుతుంది, కాబట్టి ఈరోజు విడుదలైన వెర్షన్ను నేరుగా తీసుకునే బదులు, మీకు తెలిసిన సరైన వెర్షన్ను మీరు ఉంచుకోవచ్చు. v0.32.5 వెర్షన్ 27 జూలై 2026న విడుదల చేయబడింది. ఒకవేళ మీరు స్క్రిప్ట్ను నేరుగా shell లోకి పైప్ (pipe) చేయడం ఇష్టం లేకపోతే, మాన్యువల్ పద్ధతి కూడా ఉంది:
sudo rm -rf /usr/lib/ollama
curl -fsSL https://ollama.com/download/ollama-linux-amd64.tar.zst | sudo tar x -C /usr
ollama -vఈ మాన్యువల్ పద్ధతిలో systemd unit లేదా service user సృష్టించబడవు, కాబట్టి వాటిని మీరు స్వయంగా జోడించుకోవాలి. VPS పై Ollama పూర్తి స్థాయి సెటప్ గైడ్ ఆ సర్వీస్ సెటప్ను దశలవారీగా వివరిస్తుంది.
వైఫల్య రీతులు మరియు మీకు కనిపించే సందేశాలు
Ollama మోడల్ను లోడ్ చేయడానికి నిరాకరిస్తుంది. పాత Ollama రిలీజ్లు లోడ్ చేయడానికి ముందే పరిమాణాన్ని తనిఖీ చేసేవి, మరియు ollama run ఈ క్రింది ఆకృతిలో ఒక లైన్ను ఇచ్చేది:
Error: model requires more system memory (5.6 GiB) than is available (3.2 GiB)ప్రస్తుత Ollama సోర్స్లో ఆ సందేశం లేదు (27 అక్టోబర్ 2026న తనిఖీ చేయబడింది). Ollama ఇప్పుడు లోడింగ్ ప్రక్రియను llama-server కి అప్పగిస్తుంది, కాబట్టి సరిపోని మోడల్ రన్నర్ వైఫల్యంగా కనిపిస్తుంది, మరియు ఈ క్రింది విధంగా మొదలయ్యే ఎర్రర్లు వస్తాయి:
llama-server reported out-of-memory during startup
llama-server process has terminatedఏది ఏమైనా పరిష్కారం ఒక్కటే. ఒక క్వాంటైజేషన్ స్థాయిని తగ్గించండి, కాంటెక్స్ట్ లెంగ్త్ను తగ్గించండి, లేదా చిన్న మోడల్ను ఎంచుకోండి.
llama.cpp విఫలం కాదు, కానీ చాలా నెమ్మదిగా నడుస్తుంది. llama.cpp డిఫాల్ట్గా GGUF ను మెమరీ-మ్యాప్ చేస్తుంది, కాబట్టి RAM కంటే పెద్ద ఫైల్ కూడా ప్రారంభమవుతుంది. అప్పుడు కెర్నల్ ప్రతి టోకెన్కు డిస్క్ నుండి వెయిట్స్ను పేజింగ్ చేస్తుంది, దీనివల్ల జనరేషన్ వేగం సెకనుకు ఒక టోకెన్ స్థాయికి పడిపోతుంది మరియు డిస్క్ వినియోగం 100 శాతానికి చేరుకుంటుంది. మెమరీ మ్యాపింగ్ను నిలిపివేయడానికి --load-mode none ని పాస్ చేయండి. ఆ ఆప్షన్ --no-mmap స్థానంలో వచ్చింది, ఇది b10224 బిల్డ్లో deprecated గా పేర్కొనబడింది మరియు ప్రస్తుత బిల్డ్లలో కనిపించదు (29 అక్టోబర్ 2026న తనిఖీ చేయబడింది). కెర్నల్ జోక్యం చేసుకున్నప్పుడు, dmesg కారణాన్ని చూపుతుంది:
Out of memory: Killed process 1234 (llama-server)మోడల్ ఫైల్ అస్సలు లోడ్ అవ్వదు. మీ ఇంజిన్ కంటే కొత్త మోడల్ ఫ్యామిలీ కోసం నిర్మించిన GGUF ఫైల్, దానికి తెలియని ఆర్కిటెక్చర్ను పేర్కొంటూ ఎర్రర్ను ఇస్తుంది, ఇక్కడ <arch> అనేది ఫైల్ మెటాడేటాలో నిల్వ చేయబడిన పేరు:
llama_model_load: error loading model: unknown model architecture: '<arch>'దీనికి పరిష్కారం ఇంజిన్ అప్గ్రేడ్, వేరే ఫైల్ కాదు. ఇది పిన్నింగ్ (pinning) వల్ల వచ్చే పరిణామం, అందుకే మీరు బిల్డ్ నంబర్ను రాసి పెట్టుకోవాలి. మీరు దేని నుండి అప్గ్రేడ్ అవుతున్నారో మీకు తెలిసి ఉండాలి.
API స్థానికంగా స్పందిస్తుంది కానీ మీ యాప్ నుండి స్పందించదు. Ollama 127.0.0.1:11434 కి బైండ్ అవుతుంది, కాబట్టి వేరే హోస్ట్ నుండి కనెక్షన్ తిరస్కరించబడుతుంది (connection refused). OLLAMA_HOST=0.0.0.0:11434 ని systemctl edit ollama ద్వారా సెట్ చేయండి, కానీ ఇది ఫైర్వాల్ లేదా ప్రైవేట్ నెట్వర్క్ వెనుక ఉన్నప్పుడు మాత్రమే చేయండి, ఎందుకంటే ఈ API కి ముందు ఎటువంటి అథెంటికేషన్ ఉండదు.
విరామం తర్వాత మొదటి రిప్లై చాలా నెమ్మదిగా ఉంటుంది. 5 నిమిషాల ఐడిల్ అన్లోడ్ జరిగింది మరియు మోడల్ మళ్ళీ లోడ్ అవుతోంది, పేజ్ క్యాచీలో లేకపోతే అది డిస్క్ నుండి లోడ్ అవుతుంది. అభ్యర్థనకు ముందుగా రన్ చేసిన ollama ps ఏమీ లోడ్ కాలేదని చూపిస్తే, అది దీనిని నిర్ధారిస్తుంది. OLLAMA_KEEP_ALIVE ని పెంచండి.
కాబట్టి మీరు దేనిని రన్ చేయాలి?
మీకు మోడల్స్ నిర్వహణ సులభంగా ఉండాలన్నా, ఎటువంటి అదనపు పని లేకుండా OpenAI-శైలి endpoint కావాలన్నా Ollamaను రన్ చేయండి. మొదటిసారి deployment చేసేటప్పుడు, లేదా మోడల్ ఎంపిక తరచుగా మారుతుండే సందర్భాల్లో ఇదే సరైన ఎంపిక.
మెమరీ చాలా తక్కువగా ఉండి, quantisation స్థాయిని మీరే స్వయంగా ఎంచుకోవాల్సి వచ్చినప్పుడు, పర్యవేక్షణ కోసం /health, /slots మరియు /metrics అవసరమైనప్పుడు, లేదా Ollamaలో అందుబాటులో లేని ఏదైనా flag మీకు కావాల్సి వచ్చినప్పుడు llama.cppని నేరుగా రన్ చేయండి. మోడల్ అతికష్టం మీద సరిపోయే VPSలో ఇది సరైన ఎంపిక, ఎందుకంటే మోడల్ సరిగ్గా అమరడానికి అవసరమైన సెట్టింగులను Ollama మీ తరపున ఎంచుకుంటుంది.
రెండింటినీ రన్ చేయడం సాధారణం. ప్రయోగాల కోసం Ollamaను, ప్రొడక్షన్లో ఉంచి మార్చకూడదు అనుకునే ఒకే ఒక మోడల్ కోసం llama.cppని ఉపయోగించండి.
FAQ
Ollama కేవలం llama.cpp కి ఒక wrapper మాత్రమేనా?
దాదాపు అంతే, కానీ ఈ wrapper నిజమైన పనిని చేస్తుంది. Ollama యొక్క README లో llama.cpp ని దాని inference backend గా పేర్కొన్నారు (27 October 2026 నాటికి). దీని పైన Ollama ఒక model registry ని, చాట్ సందేశాలను ప్రాంప్ట్గా మార్చే prompt template ని, డిఫాల్ట్ sampling parameters సెట్ను, idle సమయంలో మోడల్ను అన్లోడ్ చేసే daemon ను మరియు HTTP API ని అదనంగా అందిస్తుంది. మీరు ఒకే సెట్టింగ్లతో tokens per second ను పోల్చినప్పుడు, మీరు ఒకే ఇంజిన్ను దానితోనే పోల్చుకుంటున్నారు. మీరు నిజానికి ఎంచుకోవాల్సింది management layer ని.
CPU-only VPS లో ఏది వేగంగా పనిచేస్తుంది?
రెండూ ఒకే ఇంజిన్ను ఉపయోగిస్తాయి, కాబట్టి ఒకే మోడల్ ఫైల్, quantisation, context size మరియు thread count ఉన్నప్పుడు రెండింటి పనితీరు దాదాపు సమానంగా ఉంటుంది. ప్రజలు చెప్పే తేడాలు సాధారణంగా ఇంజిన్ వల్ల కాకుండా, వేర్వేరు డిఫాల్ట్ సెట్టింగ్ల వల్ల, ముఖ్యంగా context length మరియు thread count వల్ల వస్తాయి. ఏదైనా ప్రచురించబడిన గణాంకాలను నమ్మే ముందు, llama-bench -m <file> -p 512 -n 128 తో కొలవండి మరియు మీ స్వంత సర్వర్లో tg కాలమ్ను పోల్చి చూడండి.
నేను నా స్వంత GGUF ఫైల్ను Ollama తో ఉపయోగించవచ్చా?
అవును. ఫైల్ను సర్వర్లో ఉంచండి, ఒక Modelfile ని రాయండి, దాని మొదటి లైన్ FROM ./your-model.gguf గా ఉండాలి, మీకు అవసరమైన PARAMETER లైన్లను జోడించండి (ఉదాహరణకు num_ctx), ఆపై ollama create your-name -f ./Modelfile ని రన్ చేయండి. ollama ls మీరు registry నుండి డౌన్లోడ్ చేసిన వాటితో పాటు దీన్ని కూడా చూపిస్తుంది. registry లో లేని quantisation ను ఉపయోగించడానికి ఇది సరైన మార్గం.
8B మోడల్ కోసం నాకు ఎంత RAM అవసరం?
ఫైల్ పరిమాణం, KV cache మరియు runtime అవసరాలను పరిగణనలోకి తీసుకోండి. Llama 3.1 8B యొక్క Q4_K_M బిల్డ్ డిస్క్పై సుమారు 4.58 GiB ఉంటుంది, మరియు 4096 token context సుమారు 512 MiB cache ను అదనంగా తీసుకుంటుంది. కాబట్టి 8 GiB RAM సౌకర్యవంతంగా ఉంటుంది, కానీ 4 GiB సరిపోదు. Cache అనేది context తో పాటు పెరుగుతుంది: అదే మోడల్ 32,768 token context వద్ద సుమారు 4 GiB cache ను తీసుకుంటుంది. Ollama తో, అవసరాలు OLLAMA_NUM_PARALLEL తో కూడా పెరుగుతాయని గుర్తుంచుకోండి.