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

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

మీ సొంత సర్వర్‌పై నడిచే ఒక open-weight language model. ఇది HTTP API ద్వారా సమాధానాలు ఇస్తుంది. కావాలంటే మీ browserలో chat page కూడా ఉపయోగించవచ్చు. Modelను download చేసి, memoryలో load చేసి, http://127.0.0.1:11434లో requestsను అందించే భాగం Ollama. Installation కోసం ఒకే command సరిపోతుంది. ఈ విధానంలోని అసలు క్లిష్టతలు వేరే చోట ఉన్నాయి: మీ VPS RAMలో వాస్తవంగా సరిపడే modelను ఎంచుకోవడం, authentication లేని inference serverను అనుకోకుండా మొత్తం internetకు public చేయకుండా ఉండటం.

ముందుగా రెండు ముఖ్యమైన హెచ్చరికలు. CPU-only VPSలో చిన్న models కూడా నెమ్మదిగా నడుస్తాయి. అలాగే APIలో built-in authentication ఏమాత్రం లేదు. ఈ రెండు అంశాలను దిగువన వివరంగా చర్చిస్తాం, ఎందుకంటే సమస్యలు ఎక్కువగా ఇక్కడే ఏర్పడతాయి.

సరళ సంఖ్యల్లో మోడల్ పరిమాణ వాస్తవికత

మోడల్ memory footprint సుమారుగా దాని file size కు, runtime overhead కోసం అవసరమైన సుమారు ఒక gigabyte కు, context window కోసం అవసరమైన కొంత అదనపు memory కు సమానం. Ollama యొక్క default models 4-bit quantized గా ఉంటాయి. వీటిని Q4 అని పిలుస్తారు. ప్రతి billion parameters కు సుమారు అర gigabyte RAM అవసరం. కాబట్టి లెక్క సులభమే. ఇదే మొత్తం నిర్ణయిస్తుంది.

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

ఇప్పుడు వేగం గురించి చూద్దాం. చాలామంది తక్కువగా అంచనా వేసేది ఇదే. CPU inference clock speed కంటే memory bandwidth పై ఎక్కువగా ఆధారపడి ఉంటుంది. Shared vCPU VPS లో memory bandwidth పరిమితంగా ఉంటుంది. సెకనుకు single-digit నుంచి low-double-digit tokens ఆశించాలి. 7-8B Q4 model సెకనుకు 4 నుంచి 10 tokens ను ప్రాసెస్ చేయవచ్చు. 3B model సెకనుకు 10 నుంచి 25 tokens ను ప్రాసెస్ చేయవచ్చు. GPU సుమారుగా ఒక order of magnitude వేగంగా ఉంటుంది. ఇవి ఉద్దేశపూర్వకంగా సుమారు అంచనాలు మాత్రమే. మీ స్వంత box పై కొలవడం సరైన పద్ధతి. దిగువ run దశలో దాన్ని ఎలా చేయాలో చూపించాం. ఏ article లోని సంఖ్యనైనా, ఇందులోని సంఖ్యనైనా నమ్మకుండా మీ eval rate ను నమ్మండి.

ప్రాయోగికంగా చెప్పాలంటే, వేగం కొంత తక్కువగా ఉన్నా అంగీకరించగలిగితే CPU పై నడిచే చిన్న quantized models drafting, summarizing, classification కోసం నిజంగా ఉపయోగకరంగా ఉంటాయి. ఇంకా పెద్ద లేదా వేగవంతమైన model అవసరమైతే GPU instance కోసం బడ్జెట్ కేటాయించండి.

నిర్దిష్ట model ను నిర్దిష్ట box తో పోల్చడానికి, దాని memory footprint ను ఇక్కడ అంచనా వేయండి:

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

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

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

ఇది ollama పేరుతో ఒక system userను సృష్టిస్తుంది, binaryని /usr/local/bin/ollamaకు ఇన్‌స్టాల్ చేస్తుంది, అలాగే boot సమయంలో ప్రారంభమై 127.0.0.1:11434పై bind అయ్యే ollama.service అనే systemd serviceను నమోదు చేస్తుంది. అది నడుస్తోందో నిర్ధారించండి:

systemctl status ollama
ollama --version

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

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

Port mappingలోని 127.0.0.1: prefixను గమనించండి. ఇది portను localhostకు మాత్రమే bind చేస్తుంది. దాని బదులుగా -p 11434:11434 రాస్తే, అది portను ప్రతి interfaceపై publish చేస్తుంది. Security section హెచ్చరించే తప్పిదం ఇదే. ఒక install పద్ధతినే ఎంచుకోండి. Scriptను మరియు containerను ఒకేసారి నడపకండి. లేకపోతే రెండు processes ఒకే port కోసం పోటీ పడతాయి.

మీ మొదటి model ను pull చేసి అమలు చేయండి

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

pull model layers ను disk కు download చేస్తుంది (ఈ model కోసం సుమారు 2 GB). run వాటిని memory లోకి load చేసి, మిమ్మల్ని >>> prompt వద్దకు తీసుకువెళ్తుంది. ఒక ప్రశ్నను టైప్ చేయండి. Weights ను disk నుంచి RAM లోకి load చేసే సమయంలో మొదటి token రావడానికి కొన్ని seconds పట్టవచ్చు. ఆ తర్వాత సమాధానం stream అవుతుంది. Chat నుంచి బయటకు రావడానికి /bye టైప్ చేయండి; Ollama background లో నడుస్తూనే ఉంటుంది.

ఏది load అయిందో, అది ఎలా పనిచేస్తుందో చూడండి:

ollama ps

PROCESSOR column వాస్తవ పరిస్థితిని చూపుతుంది. 100% CPU అంటే GPU ఉపయోగించబడటం లేదని అర్థం. Slowగా ఉండటానికి ఇదే కారణం. నిజమైన speed ను verbose flag తో కొలవండి:

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

చివరలో ముద్రించబడే eval rate line, ఈ hardware పై మీ tokens per second వేగం. Planning చేసేటప్పుడు ఉపయోగించాల్సిన సంఖ్య ఇదే.

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

స్క్రిప్ట్ ద్వారా ఇన్‌స్టాల్ చేసి, సేవగా నడిపినప్పుడు మోడళ్లు ollama వినియోగదారు home directory లో ఉంటాయి:

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

మీ స్వంత వినియోగదారుగా ఇంటరాక్టివ్‌గా నడిపితే, అవి ~/.ollama/models లో ఉంటాయి. Container లో అవి ollama పేరుగల named volume లో ఉంటాయి. ఇది ముఖ్యమైన విషయం, ఎందుకంటే quantized weights త్వరగా ఎక్కువ స్థలాన్ని ఆక్రమిస్తాయి: 3B మోడల్‌కు సుమారు 2 GB, 7-8B మోడల్‌కు సుమారు 5 GB, 14B మోడల్‌కు సుమారు 9 GB అవసరం. పోల్చడానికి నాలుగు మోడళ్లను pull చేస్తే, గమనించకుండానే 20 GB స్థలం వినియోగించబడుతుంది. ఉంచాలని భావిస్తున్న మోడళ్లకు సరిపడే పరిమాణంలో డిస్క్‌ను ఎంచుకోండి. మిగిలినవాటిని ollama rm <model> తో తొలగించండి. అదే VPS లో photo library ను నిల్వ చేసే PhotoPrism లేదా Immich వంటి ఎక్కువ డిస్క్ స్థలాన్ని వినియోగించే మరొక సేవ ఇప్పటికే నడుస్తుంటే, ముందుగా ఆ వినియోగాన్ని అందుబాటులో ఉన్న ఖాళీ స్థలం నుంచి తీసివేయండి. మిగిలిన స్థలాన్నే మీ వాస్తవ model budget గా పరిగణించండి.

మీ నియంత్రణలో సేవగా నడపండి

ఇన్‌స్టాల్ స్క్రిప్ట్ ఇప్పటికే ollama.service ను నమోదు చేసింది. అందువల్ల అదనపు పని లేకుండానే boot సమయంలో ఇది మళ్లీ ప్రారంభమవుతుంది. మార్చాల్సిన ముఖ్యమైన setting మోడల్ ఎంతకాలం memoryలో resident గా ఉండాలన్నది. కొన్ని setupsలో bind address కూడా మార్చాల్సి ఉంటుంది. ఈ రెండు విలువలను systemd drop-inలో ఉంచాలి. అలా చేస్తే Ollama upgrade వాటిని overwrite చేయదు:

sudo systemctl edit ollama.service

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

[Service]
Environment="OLLAMA_KEEP_ALIVE=30m"

చివరి request తర్వాత మోడల్ memoryలో ఎంతకాలం ఉండాలన్నది OLLAMA_KEEP_ALIVE నిర్దేశిస్తుంది (default 5 minutes). రోజంతా query చేసే boxలో weights ను ప్రతి సారి మళ్లీ load చేయకుండా ఉండేందుకు దీని విలువను పెంచండి. RAM పరిమితిగా ఉన్న boxలో request పూర్తయిన వెంటనే RAMను ఖాళీ చేయడానికి దీన్ని 0 గా సెట్ చేయండి. systemctl edit unit filesను reload చేస్తుంది. కాబట్టి మార్పును అమలు చేయడానికి serviceను restart చేయండి:

sudo systemctl restart ollama

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

డిఫాల్ట్‌గా Ollama 127.0.0.1:11434 కు bind అవుతుంది. అందువల్ల VPS లోనే నడుస్తున్న processes మాత్రమే దాన్ని చేరుకోగలవు. ఈ డిఫాల్ట్ సరైనదే. దీన్ని అలాగే ఉంచండి.

APIలో authentication లేదు. అసలు లేదు. API key లేదు, login లేదు, rate limit లేదు, allow-list లేదు. port 11434 ను చేరుకోగల ఎవరైనా మీరు pull చేసిన ఏ modelనైనా run చేయవచ్చు, కొత్త models ను pull చేయవచ్చు, వాటిని delete చేయవచ్చు, అలాగే మీ CPU లేదా GPUను నిరవధికంగా full loadలో ఉంచవచ్చు. Shodan వంటి scanners వేల సంఖ్యలో open Ollama instances ను index చేస్తాయి. Exposed instance కొన్ని గంటల్లోనే కనుగొనబడి దుర్వినియోగానికి గురవుతుంది.

అందువల్ల ఎట్టి పరిస్థితుల్లోనూ చేయకూడని ఒకే తప్పు ఇది: OLLAMA_HOST=0.0.0.0 సెట్ చేసి, firewall లో 11434 ను తెరవకండి. అలా చేస్తే authentication లేని inference server మొత్తం internet కు public అవుతుంది. raw 11434-on-0.0.0.0 ను సురక్షితంగా చేయడానికి ఎంత configuration చేసినా ప్రయోజనం ఉండదు, ఎందుకంటే Ollama లో configure చేయడానికి ఏదీ లేదు; authentication అసలు అందుబాటులో లేదు. ఇది ఈ నిర్దిష్ట service కు సంబంధించిన నియమం మాత్రమే. ఎప్పుడూ port తెరవకూడదనే నిషేధం కాదు: remote desktop కోసం self-hosted RustDesk relay తన పని చేయడానికి public traffic ను తప్పనిసరిగా స్వీకరించాలి. దానికి సొంత key-based authentication మరియు documentation లో పేర్కొన్న కొద్దిపాటి ports ఉన్నాయి. Ollama లో ఇవేవీ లేవు.

ఈ machine కాకుండా మరెక్కడి నుంచైనా modelను చేరుకోవడానికి మూడు సురక్షిత మార్గాలు ఉన్నాయి:

• Localగానే ఉంచండి. ఒకే VPSలో నడుస్తున్న మరో program, cron script, bot లేదా మీ tools ను modelకు కలిపే MCP server మాత్రమే caller అయితే, bindను 127.0.0.1 వద్దే ఉంచి, ఆ programతో http://127.0.0.1:11434 కు call చేయించండి. ఏదీ బయటకు expose కాదు. మరేదీ అవసరం లేదు.
• Private tunnel ద్వారా చేరుకోండి. మీరు స్వయంగా నిర్వహించే WireGuard VPNలో VPSను చేర్చండి. OLLAMA_HOST ను tunnel addressకు set చేయండి (ఉదాహరణకు 10.8.0.1, 0.0.0.0 కాదు). అప్పుడు VPN peers మాత్రమే connect చేయగలరు. Public internetకు 11434పై ఏదీ కనిపించదు.
• Authentication కలిగిన reverse proxyని ముందు ఉంచండి. TLSను terminate చేసి, nginx, Traefik లేదా Caddy వద్ద password లేదా tokenను తప్పనిసరి చేయండి. తరువాత 127.0.0.1:11434 కు proxy చేయండి. Ollama తన localhost bindను కొనసాగిస్తుంది. Public portపై listening చేసే ఏకైక service proxy అవుతుంది. ఏదైనా local service ముందు nginxలో Let's Encrypt certificate ఉంచడంతో ఇది సమానమైన విధానం.

తరువాత chat UI మీకు ఇచ్చే విధానం ఇదే reverse-proxy option. దీనికి నిజమైన login కూడా జతచేయబడుతుంది.

TLS వెనుక Open WebUIతో chat UIని జోడించడం

Open WebUI self-hosted chat interface. దీన్ని Dockerలో నడిపి, local Ollamaకి point చేయండి:

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 flag ముఖ్యమైనది. ఇది containerను host network namespaceలో ఉంచుతుంది. అందువల్ల containerలోని 127.0.0.1, host యొక్క స్వంత loopback అవుతుంది. Container Ollamaను 127.0.0.1:11434 వద్ద చేరుతుంది. Ollamaను ఇతర interfaceలో listen చేయించాల్సిన అవసరం ఉండదు. మీరు ఇతర చోట్ల చూసే bridge-network విధానం, --add-host=host.docker.internal:host-gateway తో OLLAMA_BASE_URL=http://host.docker.internal:11434, ఇక్కడ పనిచేయదు. ఆ పేరు Docker bridge gatewayకి resolve అవుతుంది. Hostలో 127.0.0.1కి bind అయిన serviceను bridge ద్వారా చేరుకోలేరు. అందువల్ల Open WebUI Ollamaకు connect కాలేదని చూపిస్తూ అలాగే ఉంటుంది.

Host networking వల్ల Open WebUI ఇప్పుడు hostలోని port 8080పై ప్రతి interfaceలో listen చేస్తుంది. ఏ -p mapping అయినా విస్మరించబడుతుంది. Docker కూడా దీనిని తెలియజేస్తూ warning చూపిస్తుంది. కాబట్టి host firewallలోనూ provider firewallలోనూ 8080ను మూసివేయండి. TLS reverse proxy మాత్రమే public entry pointగా ఉండేలా చేయండి. మొదటి visitలో Open WebUI admin account సృష్టించమని అడుగుతుంది. ఆ account మీ authentication layerగా పనిచేస్తుంది. అందువల్ల బలమైన password ఎంచుకోండి.

మీ laptop నుంచి HTTPS ద్వారా chatను తెరవడానికి 127.0.0.1:8080 ముందు TLS reverse proxyని ఉంచండి. ఈ serverలో ఇప్పటికే అనేక Docker appsను route చేస్తుంటే, అనేక apps కోసం automatic TLSతో Traefik అత్యంత అనుకూలమైన ఎంపిక. ఒక label block certificateను issue చేసి, chat.example.comను Open WebUIకి route చేస్తుంది. Security sectionలోని నియమం ఇక్కడ కూడా వర్తిస్తుంది. Public port మరియు loginను proxy నిర్వహిస్తుంది. Ollama localhostలోనే ఉంటుంది. Open WebUI యొక్క స్వంత 8080 firewall ద్వారా నిరోధించబడుతుంది.

మీ కోడ్ నుంచి OpenAI-compatible endpoint ను ఉపయోగించండి

Ollama /v1 వద్ద OpenAI chat API లోని కొంత భాగాన్ని అందిస్తుంది. అందువల్ల base URL మరియు తాత్కాలిక key ను మార్చిన తర్వాత చాలా OpenAI client libraries పనిచేస్తాయి.

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)

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

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"}]}'

Agent మరియు editor tooling లో model ను అనుసంధానించడానికి కూడా ఇదే విధానాన్ని ఉపయోగించవచ్చు. మీరు ఇప్పటికే ఆ box పై అభివృద్ధి చేస్తుంటే, tmux లో VPS పై నడుస్తున్న Claude Code తో పాటు local model ను scripts మరియు plugins కోసం ఉపయోగించవచ్చు. దీనివల్ల చవకైన, ప్రైవేట్ drafting పనిని paid API నుంచి బయట ఉంచి, క్లిష్టమైన reasoning ను hosted model కు అప్పగించవచ్చు.

వైఫల్య పరిస్థితులు: మీరు ఖచ్చితంగా చూసే strings

ప్రక్రియ మధ్యలో "Killed" అవుతుంది. మీరు పెద్ద model ను ప్రారంభించినప్పుడు terminal లో Killed కనిపిస్తుంది లేదా server log లో llama runner process has terminated: signal: killed కనిపిస్తుంది. ఆ model కు server లో ఉన్నదానికంటే ఎక్కువ RAM అవసరమైనందున Linux OOM killer దాన్ని ఆపింది. sudo dmesg | grep -i oom తో కారణాన్ని నిర్ధారించండి. అందులో Out of memory: Killed process ... (ollama) వంటి line కనిపిస్తుంది. తక్కువ పరిమాణం గల లేదా మరింత quantized model ఉపయోగించడం పరిష్కారం. 13B కు బదులుగా llama3.2:3b ఉపయోగించవచ్చు. Physical RAM స్వల్పంగా మించిపోయే load నెమ్మదిగా పూర్తయ్యేలా swap ను కూడా జోడించవచ్చు. అయితే swap వెంటనే జరిగే crash ను నెమ్మదైన సమాధానంగా మారుస్తుంది. 4 GB పై 70B model ను ఆచరణయోగ్యంగా మార్చదు. మీరు terminal ను గమనిస్తున్నప్పుడు తప్ప ఈ kill సాధారణంగా నిశ్శబ్దంగా జరుగుతుంది. అందువల్ల వేరే చోట నుంచి query చేసే server లో, OnFailure= unit ను ollama.service కు జత చేసి, push alerts కోసం మీరు నిర్వహించే ntfy server కు notification పంపేలా చేయండి. అప్పుడు ప్రక్రియ ఆగిన వెంటనే మీకు తెలుస్తుంది. తదుపరి request సమయంలో మాత్రమే గుర్తించాల్సిన పరిస్థితి ఉండదు.

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

మొదటి token రావడానికి చాలా సమయం పడుతుంది, తరువాత సరిగ్గా పనిచేస్తుంది. Cold model మొదటిసారి ఐదు నుంచి ముప్పై seconds వరకు ఏమీ ప్రింట్ చేయదు. తరువాత సాధారణంగా stream అవుతుంది. మొదటిసారి weights ను disk నుంచి RAM లోకి load చేయడం వల్ల ఈ విరామం వస్తుంది. Slow storage ఉంటే ఇది మరింత ఎక్కువవుతుంది. Load పూర్తయిన తరువాత, model OLLAMA_KEEP_ALIVE వ్యవధి వరకు memoryలో resident గా ఉంటుంది. అందువల్ల రెండవ prompt కు వెంటనే సమాధానం వస్తుంది. Call path లోని ఏదైనా timeout కంటే మొదటి load ఎక్కువ సమయం తీసుకుంటే, slow answer కు బదులుగా error వస్తుంది. context deadline exceeded ను ఏ layer report చేసిందో గుర్తించడం ద్వారా client, proxy లేదా model load లో ఏది వేచి ఉండే పరిమితిని దాటిందో తెలుసుకోవచ్చు. ఈ gaps ఇబ్బందిగా ఉంటే ఆ value ను పెంచండి. ప్రస్తుతం model load అయి ఉందో లేదో చూడటానికి ollama ps ఉపయోగించండి.

అన్నీ సాధారణంగానే slow గా ఉన్నాయి. ఎటువంటి error లేకుండా seconds కు పది tokens లేదా అంతకంటే తక్కువ వస్తాయి. ఇది CPU inference సాధారణంగా పనిచేసే విధానమే. ollama ps, 100% CPU ను చూపిస్తుంది. అంటే GPU లేదు. ఇది bug కాదు. Memory bandwidth పరిమితి కారణంగా ఏ setting తోనూ దీనిని సరిచేయలేరు. చిన్న model ను ఉపయోగించండి, ఈ వేగాన్ని అంగీకరించండి లేదా GPU instance కు మారండి. ఏదైనా విరిగిపోయిందని నిర్ణయించుకునే ముందు --verbose తో వాస్తవ వేగాన్ని కొలవండి.

మరొక machine నుంచి Connection refused వస్తుంది. మీ laptop నుంచి curl: (7) Failed to connect to <ip> port 11434: Connection refused వస్తుంది. ఇది నిర్దేశించిన విధంగానే పనిచేస్తోంది. Ollama localhost కు మాత్రమే bind అవుతుంది. 0.0.0.0 కు bind చేసి దీనిని "fix" చేయవద్దు. అది పైన పేర్కొన్న exposure తప్పిదమే. VPN ద్వారా లేదా authentication కలిగిన proxy ద్వారా model ను చేరుకోండి.

మీరు 11434 ను internet కు expose చేశారు. మీరు OLLAMA_HOST=0.0.0.0 ను set చేసి, firewall లో port ను తెరిచి, ఇప్పుడు మీరు ప్రారంభించని model pulls లేదా తెలియని clients కారణంగా CPU 100% వద్ద నిలిచిపోవడాన్ని చూస్తే, ఇతరులు మీ server ను గుర్తించి ఉపయోగించారు. ఇది అరుదైన edge case కాదు. ఇదే ప్రధాన తప్పిదం. 127.0.0.1 లేదా VPN address కు మళ్లీ bind చేయండి. Firewall లో 11434 ను మూసివేయండి. ముందు authentication ను అమలు చేయండి. ఆ address తెరిచి ఉన్న సమయంలో దానికి చేరుకోగల ఏదైనా service ను అపరిచితులు query చేసి ఉండవచ్చని భావించండి.

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

బ్యాకప్ చేయాల్సిన state చాలా తక్కువగా ఉంటుంది. Models ను మళ్లీ download చేసుకోవచ్చు. అందువల్ల Open WebUI data volume, accounts, chat history, settings, అలాగే మీరు రాసిన ఏదైనా systemd drop-in మాత్రమే బ్యాకప్ చేయడం విలువైనది. తాత్కాలిక container తో volume ను బ్యాకప్ చేయండి:

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

Install script ను మళ్లీ అమలు చేయడం ద్వారా Ollama ను అప్‌గ్రేడ్ చేయండి. docker pull ghcr.io/open-webui/open-webui:main అమలు చేసిన తర్వాత container ను మళ్లీ సృష్టించడం ద్వారా Open WebUI ను అప్‌గ్రేడ్ చేయండి. దీర్ఘకాలం ఏదినీ pin చేయవద్దు. Model నాణ్యత మరియు runtime రెండూ వేగంగా మారుతాయి. అందువల్ల release notes చదివి, గత త్రైమాసికంలోని సంఖ్యలను నమ్మకుండా మీ స్వంత server పై మళ్లీ benchmark చేయండి.

FAQ

నేను నిజంగా CPU-only VPSలో LLMను నడపగలనా?

అవును, కొన్ని పరిమితులతో. 3B నుంచి 8B పరిధిలోని చిన్న quantized models CPUపై నడుస్తాయి. Drafting, summarizing, classification వంటి పనులకు అవి వాస్తవంగా ఉపయోగకరంగా ఉంటాయి. అయితే వేగం తక్కువగా ఉంటుంది. Shared vCPUపై సాధారణంగా single-digit నుంచి low-double-digit tokens per second వేగం మాత్రమే ఉంటుంది. 13B లేదా అంతకంటే పెద్ద models చాలా నెమ్మదిగా ఉంటాయి లేదా RAMలో అసలు సరిపోవు. నిజమైన వేగం లేదా పెద్ద models కోసం GPU instance అవసరం.

ప్రతి modelకు ఎంత RAM అవసరం?

Default 4-bit quantized models కోసం ఒక సుమారు నియమం ఇలా ఉంటుంది: weights కోసం ప్రతి billion parametersకు దాదాపు 0.5 GB RAM, అదనంగా సుమారు 1 GB overhead, అలాగే context కోసం కొంత అదనపు RAM అవసరం. అందువల్ల 3B modelకు సుమారు 4 GB ఖాళీ RAM, 7-8B modelకు సుమారు 8 GB, 14B modelకు సుమారు 16 GB అవసరం. free -h తో అందుబాటులో ఉన్న headroomను తనిఖీ చేయండి. Operating system మరియు ఆ serverలో నడుస్తున్న ఇతర సేవల కోసం కూడా స్థలం ఉంచండి.

Ollama APIకి authentication ఉందా?

లేదు. Ollamaలో built-in authentication, API key లేదా rate limit లేవు. Port 11434ను చేరుకోగల ఎవరైనా దానిపై పూర్తి నియంత్రణ పొందగలరు. అందుకే ఇది defaultగా 127.0.0.1 కు bind అవుతుంది. అలాగే మీరు 11434ను 0.0.0.0పై internetకు ఎప్పటికీ expose చేయకూడదు. దాన్ని localగా, private VPN ద్వారా లేదా loginను జోడించే reverse proxy ద్వారా మాత్రమే అందుబాటులోకి తీసుకురండి.

Web chat interfaceను ఎలా జోడించాలి?

--network=hostతో Open WebUIను Dockerలో నడపండి. అప్పుడు అది host యొక్క loopbackను share చేసి, native Ollamaను http://127.0.0.1:11434 వద్ద చేరుకోగలదు. తరువాత మీ laptop నుంచి access కోసం దాని port 8080 ముందు TLS reverse proxyను ఉంచండి. Firewallలో 8080ను మూసి ఉంచండి. అప్పుడు proxy మాత్రమే public access pointగా ఉంటుంది. Open WebUI యొక్క స్వంత admin account loginను అందిస్తుంది. మొదటి launch సమయంలో దాని passwordను సెట్ చేయాలి.

నా స్వంత application నుంచి దానిని ఎలా call చేయాలి?

http://127.0.0.1:11434/v1 వద్ద ఉన్న OpenAI-compatible endpointను ఉపయోగించండి. ఏదైనా OpenAI SDKను ఆ base URLకు point చేయండి. API keyను ఉపయోగించకపోయినా, ఏదైనా stringను పంపవచ్చు, ఎందుకంటే అది ignore చేయబడుతుంది. modelను మీరు pull చేసిన model nameకు సెట్ చేయండి. Base URL మరియు key మినహా ఇప్పటికే ఉన్న OpenAI code సాధారణంగా ఎలాంటి మార్పు లేకుండా నడుస్తుంది.