VPS లో Ollama హోస్ట్ చేయడం: సురక్షితంగా LLM సెల్ఫ్ హోస్ట్

మీరు నిర్మించేది ఏమిటి

మీకు సొంతమైన సర్వర్‌లో నడుస్తున్న ఒకే ఒక ఓపెన్-వెయిట్ భాషా నమూనా. ఇది HTTP API ద్వారా సమాధానాలు ఇస్తుంది. అలాగే, మీకు కావాలంటే మీ బ్రౌజర్‌లో ఒక చాట్ పేజీ కూడా ఉంటుంది. Ollama అనేది నమూనాను డౌన్‌లోడ్ చేసి, దాన్ని మెమరీలోకి లోడ్ చేసి, http://127.0.0.1:11434 పై అభ్యర్థనలను అందిస్తుంది. దీన్ని ఇన్‌స్టాల్ చేయడానికి ఒకే ఒక కమాండ్ సరిపోతుంది. దీనిలో కష్టమైన పని మరేమీ లేదు: మీ VPS నిజంగా RAM లో పట్టుకోగలిగే నమూనాను ఎంచుకోవడం, మరియు ప్రామాణీకరణ లేని ఇన్‌ఫరెన్స్ సర్వర్‌ను అనుకోకుండా మొత్తం ఇంటర్నెట్‌కు బహిరంగం చేయకుండా ఉండటం.

ముందుగా రెండు నిజాయితీ హెచ్చరికలు. CPU మాత్రమే ఉన్న VPS చిన్న నమూనాలను నెమ్మదిగా నడుపుతుంది. అలాగే API లో అంతర్గత ప్రామాణీకరణ ఏమీ లేదు. ఈ రెండూ కూడా దిగువన వివరంగా చర్చించబడ్డాయి, ఎందుకంటే ఈ రెండూ ప్రజలు ఇబ్బందులకు గురయ్యే ప్రదేశాలే.

సైజింగ్ వాస్తవికత పరిశీలన, స్పష్టమైన సంఖ్యలలో

ఒక మోడల్ మెమరీ అధిభావం దాదాపు దాని ఫైల్ పరిమాణానికి సమానం. దానికి దాదాపు ఒక గిగాబైట్ రన్‌టైమ్ ఓవర్‌హెడ్ కలుపుతారు. కాంటెక్స్ట్ విండో కోసం మరికొంత అదనంగా అవసరం. Ollama డిఫాల్ట్ మోడల్స్ 4-బిట్ క్వాంటైజ్డ్ (Q4 గా లేబుల్ చేయబడింది). ఇది ప్రతి బిలియన్ పారామీటర్లకు దాదాపు సగం గిగాబైట్ RAM ఖర్చు చేస్తుంది. కాబట్టి ఈ అంకగణితం సరళంగా ఉంటుంది. ఇది ప్రతిదాన్ని నిర్ణయిస్తుంది.

llama3.2:3b వంటి 3B మోడల్ దాదాపు 2 GB డౌన్‌లోడ్. అది నడవడానికి దాదాపు 4 GB ఖాళీ RAM అవసరం. mistral:7b లేదా llama3.1:8b వంటి 7B లేదా 8B మోడల్ డిస్క్‌లో దాదాపు 5 GB ఉంటుంది. దానికి దాదాపు 8 GB RAM అవసరం, సౌకర్యవంతంగా ఉండటానికి 16 GB. 13B లేదా 14B మోడల్‌కు దాదాపు 16 GB అవసరం. 30B నుండి 70B మధ్య ఏదైనా పెద్ద-RAM పెట్టె కావాలి లేదా వాస్తవానికి ఒక GPU కావాలి. CPU VPS పై అది సరిపోదు లేదా చాలా నెమ్మదిగా స్పందిస్తుంది, అందువల్ల పనికిరాదు.

ఇప్పుడు వేగం, ఎందుకంటే ప్రజలు దీన్ని తక్కువగా అంచనా వేస్తారు. CPU ఇన్‌ఫరెన్స్ మెమరీ బ్యాండ్‌విడ్త్‌పై ఆధారపడి ఉంటుంది, క్లాక్ స్పీడ్‌పై కాదు. ఒక షేర్డ్ vCPU VPSకి మధ్యస్థమైన బ్యాండ్‌విడ్త్ ఉంటుంది. సెకనుకు ఒంటి అంకె నుండి తక్కువ రెట్టింపు అంకెల వరకు టోకన్లు ఊహించండి: 7-8B Q4 మోడల్ సెకనుకు 4 నుండి 10 టోకన్లు ఇవ్వగలదు, 3B మోడల్ 10 నుండి 25. GPU దాదాపు పది రెట్లు వేగంగా ఉంటుంది. ఇవి ఉద్దేశపూర్వకంగా స్థూల అంకెలు. సరైన పని మీ స్వంత పెట్టెను కొలవడం, దానిని ఎలా చేయాలో దిగువ రన్ దశ చూపిస్తుంది. మీ eval rate పై నమ్మకం ఉంచండి, ఏ వ్యాసంలోని అంకెపై కాదు, ఈ వ్యాసం సహిత.

ఆచరణాత్మక ముగింపు: మీరు వేగాన్ని అంగీకరించగలిగితే, CPU పై చిన్న క్వాంటైజ్డ్ మోడల్స్ డ్రాఫ్టింగ్, సారాంశం, మరియు వర్గీకరణ కోసం నిజంగా ఉపయోగపడతాయి. పెద్దవి లేదా వేగవంతమైనవి కావాలంటే, GPU ఇన్‌స్టాన్స్ కోసం బడ్జెట్ కేటాయించండి.

ఒక నిర్దిష్ట మోడల్‌ను ఒక నిర్దిష్ట పెట్టెతో సరిపోల్చడానికి, దాని మెమరీ అధిభావాన్ని ఇక్కడ అంచనా వేయండి:

Ollama ని ఇన్‌స్టాల్ చేయండి

రెండు సరైన పద్ధతులు ఉన్నాయి. ఖాళీ VPS లో అధికారిక స్క్రిప్ట్ అత్యంత సులభం:

curl -fsSL https://ollama.com/install.sh | sh

ఇది ollama అనే సిస్టమ్ యూజర్‌ను సృష్టిస్తుంది, బైనరీని /usr/local/bin/ollama కి ఇన్‌స్టాల్ చేస్తుంది, మరియు బూట్ అయ్యేటప్పుడు ప్రారంభమయ్యే మరియు 127.0.0.1:11434 కు బైండ్ అయ్యే ollama.service అనే systemd సర్వీస్‌ను నమోదు చేస్తుంది. అది నడుస్తోందో లేదో నిర్ధారించుకోండి:

systemctl status ollama
ollama --version

మీరు ఇప్పటికే Docker నడుపుతుంటే, దాని బదులు కంటైనర్‌ను ఉపయోగించండి:

docker run -d --name ollama \
  -p 127.0.0.1:11434:11434 \
  -v ollama:/root/.ollama \
  --restart always \
  ollama/ollama

పోర్ట్ మాపింగ్‌పై 127.0.0.1: ప్రిఫిక్స్‌ను గమనించండి. అది పోర్ట్‌ను కేవలం localhost కు మాత్రమే బైండ్ చేస్తుంది. దాని బదులు -p 11434:11434 అని రాయడం ద్వారా అది ప్రతి ఇంటర్‌ఫేస్‌లోనూ ప్రచురితమవుతుంది, ఇదే సెక్యూరిటీ విభాగం హెచ్చరించే తప్పు. ఒక ఇన్‌స్టాలేషన్ పద్ధతిని ఎంచుకోండి; స్క్రిప్ట్ మరియు కంటైనర్ రెండింటినీ ఒకేసారి నడపవద్దు, లేదా రెండు ప్రాసెస్‌లు పోర్ట్ కోసం పోరాడుతాయి.

మీ మొదటి మోడల్‌ను పుల్ చేసి రన్ చేయండి

ollama pull llama3.2:3b
ollama run llama3.2:3b

pull మోడల్ లేయర్‌లను డిస్క్‌కు డౌన్‌లోడ్ చేస్తుంది (దీనికి దాదాపు 2 GB). run వాటిని మెమరీలోకి లోడ్ చేసి, మిమ్మల్ని >>> ప్రాంప్ట్ వద్దకు తీసుకువెళ్తుంది. ఒక ప్రశ్నను టైప్ చేయండి. వెయిట్స్ డిస్క్ నుండి RAM లోకి లోడ్ అయ్యేటప్పుడు మొదటి టోకెన్‌కు కొన్ని సెకన్లు పడొచ్చు, ఆ తర్వాత సమాధానం స్ట్రీమ్ అవుతుంది. చాట్ నుండి నిష్క్రమించడానికి /bye టైప్ చేయండి; Ollama బ్యాక్‌గ్రౌండ్‌లో నడుస్తూనే ఉంటుంది.

ఏమి లోడ్ అయిందో మరియు అది ఎలా సరిపోతుందో చూడండి:

ollama ps

PROCESSOR కాలమ్ నిజాన్ని చెబుతుంది. 100% CPU అంటే GPU పాత్ర లేదని అర్థం, మరియు నెమ్మది అక్కడ నుండే వస్తుంది. వర్బోస్ ఫ్లాగ్‌తో నిజమైన వేగాన్ని కొలవండి:

ollama run --verbose llama3.2:3b "Write two sentences about Linux."

చివరలో ప్రింట్ అయ్యే eval rate లైన్, ఈ హార్డ్‌వేర్‌పై మీ సెకనుకు టోకెన్ల సంఖ్య. ప్రణాళిక చేయడానికి పరిగణించాల్సింది ఆ సంఖ్యే.

మోడల్లు ఎక్కడ ఉంటాయి, ఎంత డిస్క్ కొనాలి

స్క్రిప్ట్ ద్వారా స్థాపించి సర్వీస్‌గా నడిచేటప్పుడు, మోడల్లు ollama యూజర్ హోమ్‌లో ఉంటాయి:

sudo du -sh /usr/share/ollama/.ollama/models

మీ యూజర్‌గా ఇంటరాక్టివ్‌గా నడిచేటప్పుడు, అవి ~/.ollama/models లో ఉంటాయి. కంటైనర్‌లో అవి ollama నేమ్‌డ్ వాల్యూమ్‌లో ఉంటాయి. ఇది ముఖ్యమైనది ఎందుకంటే క్వాంటైజ్డ్ వెయిట్లు వేగంగా పెరుగుతాయి: 3B మోడల్ ~2 GB, 7-8B మోడల్ ~5 GB, 14B మోడల్ ~9 GB. పోల్చడానికి నాలుగు మోడల్లను పుల్ చేస్తే మీరు గమనించకుండానే 20 GB ఖర్చు చేశారు. మీరు ఉంచాలనుకుంటున్న మోడల్ల కోసం డిస్క్ పరిమాణం నిర్ణయించండి, మిగిలినవాటిని ollama rm <model> తో తొలగించండి.

మీరు నియంత్రించే సర్వీస్‌గా దాన్ని నడపండి

ఇన్‌స్టాల్ స్క్రిప్ట్ ఇప్పటికే ollama.service నమోదు చేసింది. కాబట్టి ఇది బూట్ సమయంలో మళ్లీ ప్రారంభమవుతుంది. మార్పు చేయడానికి విలువైన సెట్టింగ్, ఒక మోడల్ ఎంతకాలం మెమరీలో ఉండటం. కొన్ని సెటప్‌లలో, బైండ్ చిరునామా కూడా మార్చవచ్చు. ఈ రెండూ ఒక systemd డ్రాప్-ఇన్‌లో వెళ్ళాలి. దీనివల్ల Ollama అప్‌గ్రేడ్ వాటిని ఓవర్‌రైట్ చేయదు:

sudo systemctl edit ollama.service

ఎడిటర్ చూపించే [Service] హెడర్ కింద దీన్ని జోడించండి:

[Service]
Environment="OLLAMA_KEEP_ALIVE=30m"

OLLAMA_KEEP_ALIVE అనేది చివరి అభ్యర్థన తర్వాత ఒక మోడల్ మెమరీలో ఎంతకాలం ఉంటుందో సూచిస్తుంది (డిఫాల్ట్ 5 నిమిషాలు). రోజంతా మీరు ప్రశ్నలు అడిగే సిస్టమ్‌లో దీన్ని పెంచండి. అప్పుడు ప్రతిసారి వెయిట్‌లను రీలోడ్ చేయకుండా ఉంటుంది. మెమరీ తక్కువగా ఉన్న సిస్టమ్‌లో దీన్ని 0 గా సెట్ చేయండి. అప్పుడు ఒక అభ్యర్థన పూర్తయిన వెంటనే RAM ఖాళీ అవుతుంది. systemctl edit మీ కోసం యూనిట్ ఫైళ్లను రీలోడ్ చేస్తుంది. కాబట్టి మార్పును వర్తింపజేయడానికి రీస్టార్ట్ చేయండి:

sudo systemctl restart ollama

అత్యంత ముఖ్యమైన భద్రతా అంశం

అప్రమేయంగా Ollama అనేది 127.0.0.1:11434 కు బైండ్ అవుతుంది, కాబట్టి VPS లోని ప్రాసెస్‌లు మాత్రమే దాన్ని చేరుకోగలవు. ఆ అప్రమేయం సరైనదే. దాన్ని అలాగే ఉంచండి.

ఈ APIకి ఎలాంటి ప్రామాణీకరణ లేదు. అసలు లేదు. దీనికి API కీ లేదు, లాగిన్ లేదు, రేట్ లిమిట్ లేదు, అనుమతి-జాబితా లేదు. పోర్ట్ 11434 ను చేరుకోగలిగిన ఎవరైనా మీరు పుల్ చేసిన ఏ మోడల్‌నైనా రన్ చేయవచ్చు, కొత్తవి పుల్ చేయవచ్చు, తొలగించవచ్చు, మరియు మీ CPU లేదా GPU ను అపరిమితంగా పూర్తి లోడ్‌తో నిలిపివేయవచ్చు. Shodan వంటి స్కానర్‌లు ఓపెన్ Ollama ఇన్‌స్టాన్స్‌లను వేలాది సంఖ్యలో ఇండెక్స్ చేస్తాయి, బహిర్గతమైన దాన్ని గంటల్లోపే కనుగొని దుర్వినియోగం చేస్తారు.

కాబట్టి ఎప్పుడూ చేయకూడని ఒక్కటే తప్పు ఇది: OLLAMA_HOST=0.0.0.0 సెట్ చేయకండి మరియు మీ ఫైర్‌వాల్‌లో 11434 ను ఓపెన్ చేయకండి. అలా చేస్తే ప్రామాణీకరణ లేని ఇన్‌ఫరెన్స్ సర్వర్ మొత్తం ఇంటర్నెట్‌కు ప్రచురితమవుతుంది. ఏ మొత్తంలో కాన్ఫిగరేషన్ చేసినా 0.0.0.0 పై రా అయిన 11434 ను సురక్షితంగా మార్చదు, ఎందుకంటే Ollama లో కాన్ఫిగర్ చేయడానికి ఏమీ లేదు — ప్రామాణీకరణ అసలు ఉనికిలోనే లేదు.

పెట్టె (box) కాని ప్రదేశం నుండి మోడల్‌ను చేరుకోవడానికి మూడు సురక్షిత మార్గాలు ఉన్నాయి:

• దాన్ని లోకల్‌గా ఉంచండి. కాలర్ ఒకే VPS పై ఉన్న మరొక ప్రోగ్రామ్ మాత్రమే అయితే — ఒక cron స్క్రిప్ట్, ఒక bot, ఒక మీ టూల్స్‌ను మోడల్‌కు బ్రిడ్జ్ చేసే MCP సర్వర్ — బైండ్ ను 127.0.0.1 వద్దే ఉంచండి మరియు ఆ ప్రోగ్రామ్ http://127.0.0.1:11434 కు కాల్ చేయనివ్వండి. ఏదీ బహిర్గతం కాదు మరియు మరేమీ అవసరం లేదు.
• ప్రైవేట్ టనల్ ద్వారా చేరుకోండి. VPS ను ఒక మీరే హోస్ట్ చేసే WireGuard VPN లో ఉంచండి, OLLAMA_HOST ను టనల్ చిరునామాకు సెట్ చేయండి (ఉదాహరణకు 10.8.0.1, 0.0.0.0 కాదు), అప్పుడు VPN పీర్లు మాత్రమే కనెక్ట్ అవ్వగలరు. పబ్లిక్ ఇంటర్నెట్‌కు 11434 పై ఏదీ కనిపించదు.
• దాని ముందు ప్రామాణీకరణ చేసే రివర్స్ ప్రాక్సీని ఉంచండి. nginx, Traefik, లేదా Caddy వద్ద TLS ను టెర్మినేట్ చేసి పాస్‌వర్డ్ లేదా టోకెన్‌ను అభ్యర్థించండి, తర్వాత 127.0.0.1:11434 కు ప్రాక్సీ చేయండి. Ollama దాని localhost బైండ్‌ను కలిగి ఉంటుంది; పబ్లిక్ పోర్ట్‌పై లిజన్ అయ్యేది ప్రాక్సీ మాత్రమే. ఇది ఏ లోకల్ సర్వీస్ ముందైనా nginx పై ఒక Let's Encrypt సర్టిఫికేట్‌ను ఉంచడం వంటి అదే నిర్మాణం.

రివర్స్-ప్రాక్సీ ఎంపిక అనేది ఛాట్ UI మీకు తదుపరి దశలో అందించేదే, దానికి నిజమైన లాగిన్ జతపరచబడి ఉంటుంది.

TLS వెనుక ఉంచి, Open WebUIతో చాట్ UIని జోడించండి

Open WebUI అనేది స్వయం-హోస్ట్ చేసిన చాట్ ఇంటర్‌ఫేస్. దీన్ని Dockerలో అమలు చేసి, స్థానిక Ollama వైపు మళ్లించండి:

docker run -d \
  --name open-webui \
  --network=host \
  -e OLLAMA_BASE_URL=http://127.0.0.1:11434 \
  -v open-webui:/app/backend/data \
  --restart always \
  ghcr.io/open-webui/open-webui:main

Linux VPSలో --network=host ఫ్లాగ్ ముఖ్యమైన వివరం. ఇది కంటైనర్‌ను హోస్ట్ నెట్‌వర్క్ నేమ్‌స్పేస్‌లో ఉంచుతుంది. దీనివల్ల కంటైనర్ లోపల 127.0.0.1 అనేది హోస్ట్ యొక్క స్వంత లూప్‌బ్యాక్ అవుతుంది. మరియు Ollama వేరే ఇంటర్‌ఫేస్‌పై లిజన్ చేయకుండానే కంటైనర్ 127.0.0.1:11434 వద్ద Ollamaను చేరుకుంటుంది. మీకు ఇతరత్రా ఎక్కడైనా కనిపించే బ్రిడ్జ్-నెట్‌వర్క్ పద్ధతి — --add-host=host.docker.internal:host-gateway తో OLLAMA_BASE_URL=http://host.docker.internal:11434 — ఇక్కడ పనిచేయదు: ఆ పేరు Docker బ్రిడ్జ్ గేట్‌వేగా పరిష్కారమవుతుంది, మరియు హోస్ట్‌లో 127.0.0.1 కు బైండ్ అయిన సర్వీస్ బ్రిడ్జ్ ద్వారా చేరుకోలేదు, కాబట్టి Open WebUI అక్కడే ఉండిపోయి Ollamaకు కనెక్ట్ కాలేదని నివేదిస్తూ ఉంటుంది.

హోస్ట్ నెట్‌వర్కింగ్ వల్ల ప్రతిఫలం ఏమిటంటే, Open WebUI ఇప్పుడు ప్రతి ఇంటర్‌ఫేస్‌పై హోస్ట్ పోర్ట్ 8080 పై లిజన్ చేస్తుంది; ఏ -p మ్యాపింగ్ వదిలివేయబడుతుంది, మరియు Docker దీన్ని సూచిస్తూ హెచ్చరిక ముద్రిస్తుంది. కాబట్టి హోస్ట్ మరియు ప్రొవైడర్ ఫైర్‌వాల్ రెండింటి వద్దా 8080 ను మూసివేసి, TLS రివర్స్ ప్రాక్సీని మాత్రమే పబ్లిక్ తలుపుగా ఉండనివ్వండి. మొదటి సందర్శనలోనే Open WebUI మిమ్మల్ని అడ్మిన్ ఖాతాను సృష్టించమని అడుగుతుంది — ఆ ఖాతాయే మీ ప్రామాణీకరణ పొర, కాబట్టి బలమైన పాస్‌వర్డ్‌ను ఎంచుకోండి.

మీ ల్యాప్‌టాప్ నుండి HTTPS ద్వారా చాట్‌ను తెరవడానికి, 127.0.0.1:8080 ముందు ఒక TLS రివర్స్ ప్రాక్సీని ఉంచండి. మీకు ఇప్పటికే ఆ సిస్టమ్‌లో అనేక Docker యాప్‌లను రూట్ చేస్తుంటే, అనేక యాప్‌ల్లో ఆటోమేటిక్ TLSతో Traefik అనేది సరైన ఎంపిక: ఒకే లేబల్ బ్లాక్ సర్టిఫికేట్‌ను జారీ చేస్తుంది మరియు chat.example.com ను Open WebUIకి రూట్ చేస్తుంది. భద్రతా విభాగం నుండి వచ్చిన నియమం ఇప్పటికీ వర్తిస్తుంది — ప్రాక్సీ పబ్లిక్ పోర్ట్ మరియు లాగిన్‌ను కలిగి ఉంటుంది, అదే సమయంలో Ollama localhostలోనే ఉంటుంది మరియు Open WebUI యొక్క స్వంత 8080 ఫైర్‌వాల్ వెనుకనే ఉంటుంది.

మీ కోడ్ నుండి OpenAI-అనుకూల ఎండ్‌పాయింట్‌ను ఉపయోగించండి

Ollama అనేది /v1 వద్ద OpenAI చాట్ API యొక్క ఉపసమితితో మాట్లాడుతుంది. కాబట్టి రెండు అంశాలను మార్చిన తర్వాత చాలా OpenAI క్లయింట్ లైబ్రరీలు పనిచేస్తాయి: బేస్ URL మరియు ఒక విస్మరించదగిన కీ.

from openai import OpenAI

client = OpenAI(base_url="http://127.0.0.1:11434/v1", api_key="ollama")

resp = client.chat.completions.create(
    model="llama3.2:3b",
    messages=[{"role": "user", "content": "Name three Linux distributions."}],
)
print(resp.choices[0].message.content)

api_key అనేది క్లయింట్ లైబ్రరీకి అవసరం. కానీ Ollama దాన్ని పట్టించుకోదు. కాబట్టి ఏ స్ట్రింగ్ అయినా పనిచేస్తుంది. model అనేది మీరు ఇప్పటికే పుల్ చేసుకున్న పేరు అయి ఉండాలి. తెలియని పేరు model "x" not found, try pulling it first ను ఇస్తుంది. సాధారణ curl కాల్ కూడా ఇదే విధంగా ఉంటుంది:

curl http://127.0.0.1:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"llama3.2:3b","messages":[{"role":"user","content":"Hello"}]}'

మోడల్‌ను ఏజెంట్ మరియు ఎడిటర్ టూలింగ్‌కు అనుసంధానించడం కూడా ఇదే విధంగా చేస్తారు. మీరు ఇప్పటికే ఆ బాక్స్‌లో డెవలప్ చేస్తుంటే, స్థానిక మోడల్ స్క్రిప్ట్‌లు మరియు ప్లగిన్‌లకు మద్దతు ఇస్తుంది. అదే సమయంలో tmux లోపల VPS పై నడుస్తున్న Claude Codeతో పాటు పనిచేస్తుంది. తక్కువ ఖర్చుతో, ప్రైవేట్‌గా చేసే డ్రాఫ్టింగ్ పనులను చెల్లింపు API నుండి దూరంగా ఉంచుతుంది. భారీ రీజనింగ్ మాత్రం హోస్ట్ చేసిన మోడల్‌తోనే ఉంటుంది.

వైఫల్య రకాలు, మీరు చూసే స్పష్టమైన స్ట్రింగ్‌లు

ప్రక్రియ జనరేషన్ మధ్యలో "Killed" అవుతుంది. మీరు పెద్ద మోడల్‌ను ప్రారంభిస్తే టెర్మినల్ Killed ప్రింట్ చేస్తుంది, లేదా సర్వర్ లాగ్ llama runner process has terminated: signal: killed చూపుతుంది. Linux OOM killer దీన్ని ఆపివేసింది ఎందుకంటే మోడల్‌కు సర్వర్‌లో ఉన్నదానికన్నా ఎక్కువ RAM అవసరం. sudo dmesg | grep -i oomతో కారణాన్ని నిర్ధారించండి, అక్కడ మీరు Out of memory: Killed process ... (ollama) వంటి ఒక వరుస చూస్తారు. పరిష్కారం చిన్న లేదా మరింత క్వాంటైజ్ చేసిన మోడల్ — 13B బదులు llama3.2:3b — లేదా swap జోడించడం, తద్వారా భౌతిక RAMను కొద్దిగా మించే లోడ్ మరణించకుండా నెమ్మదిగా నడుస్తుంది. Swap తక్షణ క్రాష్‌ను నెమ్మదైన సమాధానంగా మారుస్తుంది; అది 4 GBలో 70B మోడల్‌ను ఆచరణీయమవుతోంది చేయదు.

"Error: model requires more system memory". Ollama మోడల్‌ను ప్రారంభించడానికి తిరస్కరిస్తుంది మరియు Error: model requires more system memory (X GiB) than is available (Y GiB) ప్రింట్ చేస్తుంది. ఇది పై క్రాష్ దౌతీయ రూపం: Ollama లెక్కింపు చేసి OOM killer చేయనివ్వకుండా ఆపివేసింది. అది మీకు ఆ రెండు సంఖ్యలను కూడా ఇస్తుంది. మీ ఖాళీ RAM కంటే తక్కువ అవసరం ఉన్న మోడల్‌ను ఎంచుకోండి (free -hతో తనిఖీ చేయండి), కాంటెక్స్ట్ పొడవును తగ్గించండి, లేదా పెద్ద VPSకి మారండి. ఏ ఫ్లాగ్ మోడల్‌ను సరిపోయేలా చేయదు — మెమరీ నిజమైనది.

మొదటి టోకెన్ చాలా సేపు పడుతుంది, తర్వాత సరే. కోల్డ్ మోడల్ ఐదు నుండి ముప్పై సెకన్ల వరకు ఏమీ ప్రింట్ చేయదు, తర్వాత సాధారణంగా స్ట్రీమ్ అవుతుంది. ఆ విరామం వెయిట్స్ మొదటిసారి డిస్క్ నుండి RAMలోకి లోడ్ అవుతున్నది, మరియు నెమ్మదైన స్టోరేజ్ దీన్ని మరింత దిగజారుస్తుంది. ఒకసారి లోడ్ అయ్యాక, మోడల్ OLLAMA_KEEP_ALIVE వ్యవధిలో రెసిడెంట్‌గా ఉంటుంది, కాబట్టి రెండవ ప్రాంప్ట్ తక్షణమే సమాధానమిస్తుంది. ఆ ఖాళీలు మీకు బాధిస్తే ఆ విలువను పెంచండి, మరియు ప్రస్తుతం మోడల్ లోడ్ అయి ఉందో లేదో చూడటానికి ollama ps ఉపయోగించండి.

ప్రతిదీ కేవలం నెమ్మదిగా ఉంది. సెకనుకు పది టోకెన్లు లేదా అంతకంటే తక్కువ, ఎలాంటి ఎర్రర్ లేకుండా. అది CPU ఇన్‌ఫరెన్స్ CPU ఇన్‌ఫరెన్స్ చేసేది సరిగ్గా చేస్తోంది. ollama ps 100% CPU చూపుతుంది, అంటే GPU లేదు. ఇది బగ్ కాదు మరియు ఏ సెట్టింగ్ దీన్ని పరిష్కరించదు, ఎందుకంటే పరిమితి మెమరీ బ్యాండ్‌విడ్త్, తప్పు కాన్ఫిగరేషన్ కాదు. చిన్న మోడల్ ఉపయోగించండి, వేగాన్ని అంగీకరించండి, లేదా GPU ఇన్‌స్టాన్స్‌కు మారండి — మరియు ఏదైనా పాడైందని నిర్ణయించే ముందు --verboseతో మీ వాస్తవ రేట్‌ను కొలవండి.

మరొక మెషీన్ నుండి కనెక్షన్ తిరస్కరించబడింది. మీ లాప్‌టాప్ నుండి మీరు curl: (7) Failed to connect to <ip> port 11434: Connection refused పొందుతారు. ఇది రూపొందించినట్లుగానే పనిచేస్తోంది: Ollama localhostను మాత్రమే బైండ్ చేస్తుంది. దాన్ని 0.0.0.0 బైండ్ చేయడం ద్వారా "పరిష్కరించకండి", అది పై ఎక్స్‌పోజర్ తప్పు సరిగ్గా అదే. బదులుగా VPN ద్వారా లేదా ఆథెంటికేటింగ్ ప్రాక్సీ ద్వారా మోడల్‌ను చేరుకోండి.

మీరు 11434ను ఇంటర్నెట్‌కు ఎక్స్‌పోజ్ చేశారు. మీరు OLLAMA_HOST=0.0.0.0 సెట్ చేసి, ఫైర్‌వాల్ తెరిచి, ఇప్పుడు మీరు ప్రారంభించని మోడల్ పుల్‌లు లేదా తెలియని క్లయింట్‌ల వల్ల CPU 100%లో పిన్ అయిఉన్నట్లు చూస్తే, మీరు కనుగొనబడి ఉపయోగించబడ్డారు. ఇది ప్రధాన తప్పు, ఎడ్జ్ కేస్ కాదు. 127.0.0.1 లేదా VPN చిరునామాకు రీబైండ్ చేయండి, ఫైర్‌వాల్ వద్ద 11434ను మూసివేయండి, మరియు ముందు ఆథెంటికేషన్ ఉంచండి. అది ఓపెన్‌లో ఉన్నప్పుడు ఆ చిరునామా వద్ద చేరుకోగలిగిన ప్రతిదీ అపరిచితులు ప్రశ్నించారని భావించండి.

బ్యాకప్‌లు మరియు అప్‌గ్రేడ్‌లు

కోల్పోవడానికి దాదాపు ఏ స్థితి లేదు. మోడల్‌లను మళ్లీ డౌన్‌లోడ్ చేసుకోవచ్చు. కాబట్టి బ్యాకప్ చేయడానికి విలువైనవి Open WebUI డేటా వాల్యూమ్ మాత్రమే — అకౌంట్‌లు, చాట్ హిస్టరీ, సెట్టింగులు — మరియు మీరు వ్రాసిన ఏ systemd డ్రాప్-ఇన్ అయినా. ఒక థ్రోఅవే కంటైనర్‌తో ఆ వాల్యూమ్‌ను బ్యాకప్ చేయండి:

docker run --rm -v open-webui:/data -v "$PWD":/backup alpine \
  tar czf /backup/open-webui.tgz -C /data .

ఇన్‌స్టాల్ స్క్రిప్ట్‌ను మళ్లీ అమలు చేయడం ద్వారా Ollamaను అప్‌గ్రేడ్ చేయండి. docker pull ghcr.io/open-webui/open-webui:main తర్వాత కంటైనర్‌ను తిరిగి సృష్టించడం ద్వారా Open WebUIని అప్‌గ్రేడ్ చేయండి. ఎదని దీర్ఘకాలంగా పిన్ చేయవద్దు. మోడల్ నాణ్యత మరియు రన్‌టైమ్ రెండూ వేగంగా మారుతూ ఉంటాయి. కాబట్టి రిలీజ్ నోట్స్ చదవండి. గత త్రైమాసిక సంఖ్యలను నమ్మకందానికి బదులుగా మీ సొంత సిస్టమ్‌లో తిరిగి బెంచ్‌మార్క్ చేయండి.

FAQ

CPU-మాత్రమే ఉన్న VPSలో నిజంగా ఒక LLMని నడిపించగలనా?

అవును, కొన్ని పరిమితులతో. 3B నుండి 8B పరిధిలో ఉన్న చిన్న క్వాంటైజ్డ్ మోడల్‌లు CPUపై నడుస్తాయి. అవి డ్రాఫ్టింగ్, సారాంశం, వర్గీకరణ కోసం నిజంగా ఉపయోగపడతాయి — కానీ నెమ్మదిగా, ఒక షేర్డ్ vCPUపై సెకనుకు ఒంటి-అంకె నుండి తక్కువ-రెండంకెల టోకన్‌ల వేగంతో. 13B నుండి పైకి ఉన్న ఏవైనా చాలా నెమ్మదిగా ఉంటాయి లేదా RAMలో అస్సలే అమరవు. నిజమైన వేగం లేదా పెద్ద మోడల్‌ల కోసం మీకు GPU ఇన్‌స్టెన్స్ అవసరం.

ప్రతి మోడల్‌కు ఎంత RAM అవసరం?

డిఫాల్ట్ 4-bit క్వాంటైజ్డ్ మోడల్‌లకు ఒక స్థూల నియమం: బిలియన్ పారామీటర్లకు వెయిట్‌ల కోసం సుమారు 0.5 GB RAM, పైగా సుమారు 1 GB ఓవర్‌హెడ్ మరియు కాంటెక్స్ట్ కోసం కొంచెం ఎక్కువ. కాబట్టి 3B మోడల్‌కు సుమారు 4 GB ఖాళీ కావాలి, 7-8B మోడల్‌కు సుమారు 8 GB, మరియు 14B మోడల్‌కు సుమారు 16 GB కావాలి. free -hతో మీ అందుబాటులో ఉన్న ఖాళీని పరిశీలించండి. ఆపరేటింగ్ సిస్టమ్ మరియు ఆ పెట్టెలో ఉన్న ఇతర అప్లికేషన్‌ల కోసం కూడా స్థలం వదిలివేయండి.

Ollama API ప్రామాణీకరించబడిందా?

లేదు. Ollamaకు అంతర్నిర్మిత ప్రామాణీకరణ, API కీ లేదా రేట్ లిమిట్ లేదు — పోర్ట్ 11434ని చేరుకోగలిగిన ఎవరికైనా దానిపై పూర్తి నియంత్రణ ఉంటుంది. అందుకే అది డిఫాల్ట్‌గా 127.0.0.1కి బైండ్ అవుతుంది. అందుకే మీరు 11434ని ఎప్పుడూ 0.0.0.0పై ఇంటర్నెట్‌కు బహిర్గతం చేయకూడదు. దాన్ని స్థానికంగా, ప్రైవేట్ VPN ద్వారా లేదా లాగిన్‌ని జోడించే రివర్స్ ప్రాక్సీ ద్వారా చేరుకోండి.

వెబ్ చాట్ ఇంటర్‌ఫేస్‌ని ఎలా జోడించాలి?

Open WebUIని --network=hostతో Dockerలో నడపండి. దానివల్ల అది హోస్ట్ యొక్క లూప్‌బ్యాక్‌ని పంచుకుంటుంది మరియు స్థానిక Ollamaని http://127.0.0.1:11434వద్ద చేరుకుంటుంది. తర్వాత మీ ల్యాప్‌టాప్ నుండి యాక్సెస్ కోసం దాని పోర్ట్ 8080 ముందు ఒక TLS రివర్స్ ప్రాక్సీని ఉంచండి. ప్రాక్సీ మాత్రమే ఏకైక పబ్లిక్ ద్వారంగా ఉండేలా ఫైర్‌వాల్‌లో 8080ని మూసివేయండి. Open WebUI యొక్క స్వంత అడ్మిన్ ఖాతా లాగిన్‌ని అందిస్తుంది. మీరు దాని పాస్‌వర్డ్‌ని మొదటి లాంచ్‌పై సెట్ చేస్తారు.

నేను దాన్ని నా స్వంత అప్లికేషన్ నుండి ఎలా కాల్ చేయాలి?

http://127.0.0.1:11434/v1 వద్ద ఉన్న OpenAI-అనుకూల ఎండ్‌పాయింట్‌ని ఉపయోగించండి. ఏదైనా OpenAI SDKని ఆ బేస్ URL వైపు ప్రాయోగించండి. అది విస్మరించబడుతుంది కాబట్టి API కీగా ఏదైనా స్ట్రింగ్‌ని పాస్ చేయండి. మీరు పుల్ చేసిన పేరుకు modelని సెట్ చేయండి. బేస్ URL మరియు కీ తప్ప మిగతావన్నీ, ఇప్పటికే ఉన్న OpenAI కోడ్ సాధారణంగా మార్పు లేకుండా నడుస్తుంది.