Ollamaను కోడింగ్ ఏజెంట్‌తో ఎలా కనెక్ట్ చేయాలి?

మీరు దేనికి కనెక్ట్ అవుతున్నారు

మీరు మీ కోడింగ్ ఏజెంట్‌తో Ollama ను ఉపయోగించవచ్చు, మరియు ఈ కనెక్షన్ ప్రక్రియ చాలా మంది ఊహించిన దానికంటే సరళంగా ఉంటుంది. మీరు కేవలం ఒక base URL ను మార్చి, ఒక model పేరును ఎంచుకోవాలి. API key ఫీల్డ్‌లో ఏదైనా విలువను నమోదు చేయాల్సి ఉంటుంది, కానీ స్థానిక సర్వర్ (local server) దానిని పట్టించుకోదు, కాబట్టి ఏదైనా స్ట్రింగ్‌ను ఇవ్వవచ్చు.

Ollama పోర్ట్ 11434 పై వింటుంది (listens) మరియు ఒకే సమయంలో రెండు రకాల అభ్యర్థనలను (request shapes) స్వీకరిస్తుంది. /v1/chat/completions అనేది OpenAI-compatible ఆకృతి, మరియు Ollama డాక్యుమెంటేషన్ ప్రకారం అక్కడ కీ (key) అవసరమని పేర్కొన్నప్పటికీ, అది విస్మరించబడుతుంది. /v1/messages అనేది Anthropic-compatible ఆకృతి, దీనినే Claude Code ఉపయోగిస్తుంది. మీ ఏజెంట్ ఇప్పటికే ఈ రెండింటిలో ఒకదానికి అనుగుణంగా పనిచేస్తుంది కాబట్టి, దానిలో మరే ఇతర మార్పులు చేయనవసరం లేదు.

ఈ ప్రక్రియకు ఐదు నిమిషాలు పడుతుంది. ఫలితం ఉపయోగకరంగా ఉంటుందా లేదా అనేది చాలా మంది మార్చని రెండు సెట్టింగ్‌లపై ఆధారపడి ఉంటుంది: అవి context length మరియు keep-alive. అలాగే, మోడల్‌కు అది బాగా చేయగల పనిని అప్పగించడం కూడా ముఖ్యం. వీటి గురించి ప్రత్యేక విభాగాలలో వివరించబడింది, మరియు వాస్తవిక పరిమితులు చివరలో ఇవ్వబడ్డాయి.

ఏ కోడింగ్ ఏజెంట్లు లోకల్ బేస్ URLను అనుమతిస్తాయి

ఈ పరీక్ష ఒకే ప్రశ్నపై ఆధారపడి ఉంటుంది: ఆ టూల్ బేస్ URL సెట్టింగ్‌ను అందిస్తుందా? ఒకవేళ అందిస్తే, అది మీ సర్వర్‌తో కమ్యూనికేట్ చేయగలదు.

Ollama తన ఇంటిగ్రేషన్ పేజీలలో Claude Code, OpenCode, Codex, Cline, Roo Code, Zed, JetBrains IDEలు మరియు VS Code గురించి ప్రచురించింది. Aider తన సొంత Ollama సపోర్ట్ గురించి విడిగా డాక్యుమెంట్ చేసింది. ఆగస్టు 2026 నాటికి కోడింగ్ ఏజెంట్ అని పిలిచే వాటిలో చాలా వరకు ఇవి కవర్ అవుతాయి. ఇవన్నీ ఒకే రకమైన ఫార్మాట్‌ను అనుసరించవు, ఈ వ్యత్యాసమే సెటప్‌లు విఫలం కావడానికి కారణమవుతుంది.

• చాలా ఏజెంట్లు OpenAI-అనుకూల ఎండ్‌పాయింట్‌ను కోరుకుంటాయి. వాటికి http://localhost:11434/v1 బేస్ URLను మరియు ఏదైనా ఖాళీ లేని API కీ స్ట్రింగ్‌ను ఇవ్వండి.
• Claude Code అసలు OpenAI బేస్ URLను అంగీకరించదు. ఇది Anthropic Messages APIని ఉపయోగిస్తుంది, కాబట్టి దీనికి ANTHROPIC_BASE_URL ను http://localhost:11434 గా సెట్ చేయాలి, ఇక్కడ Ollama /v1/messages ను సర్వ్ చేస్తుంది.
• Codex అనేది OpenAI Responses APIని ఉపయోగిస్తుంది. Ollama వెర్షన్ 0.13.3 లో చేర్చబడిన /v1/responses ను కూడా సర్వ్ చేస్తుంది.
• బేస్ URL సెట్టింగ్ లేని ఏజెంట్‌ను రీడైరెక్ట్ చేయడం సాధ్యం కాదు, ఎందుకంటే ఎండ్‌పాయింట్ క్లయింట్‌లోనే నిర్మించబడి ఉంటుంది. దానికి బదులుగా, self-hosted LiteLLM gateway వంటి ట్రాన్స్‌లేషన్ లేయర్‌ను ముందు ఉంచి, క్లయింట్ కోరిన ఫార్మాట్‌లో మీ మోడల్‌ను మళ్ళీ ఎక్స్‌పోజ్ చేయండి.

Ollama మీ కోసం ఈ కాన్ఫిగరేషన్‌లను రాయగలదు. ollama launch opencode మీరు ఎంచుకున్న మోడల్ కోసం ఇన్‌లైన్ కాన్ఫిగరేషన్‌తో OpenCodeను ప్రారంభిస్తుంది, ollama launch claude Claude Code కోసం అదే పని చేస్తుంది, మరియు ollama launch droid --config టూల్‌ను లాంచ్ చేయకుండానే కాన్ఫిగరేషన్‌ను రాస్తుంది.

Ollama ను ఇన్‌స్టాల్ చేసి, టూల్ కాల్ చేయగల మోడల్‌ను డౌన్‌లోడ్ చేయడం

curl -fsSL https://ollama.com/install.sh | sh
systemctl status ollama --no-pager
ollama pull qwen3-coder:30b
ollama ls

ఇన్‌స్టాలర్ ఒక systemd యూనిట్‌ను జోడించి దానిని ప్రారంభిస్తుంది, కాబట్టి systemctl status ollama కమాండ్ active (running) అని చూపాలి. ఒకవేళ అది చూపకపోతే, journalctl -e -u ollama కమాండ్ దానికి గల కారణాన్ని తెలియజేస్తుంది.

ఏజెంట్ పని చేయడానికి టూల్ కాలింగ్ సామర్థ్యం అవసరం, కాబట్టి మోడల్ తప్పనిసరిగా దీనికి మద్దతు ఇవ్వాలి. ఏజెంట్ ఒక ఫైల్‌ను చదివి, ప్యాచ్ రాసి, టెస్ట్ రన్ చేసి, ఆపై వైఫల్యాన్ని గమనించి మళ్ళీ ప్రయత్నిస్తుంది. టూల్ కాల్ చేయలేని మోడల్ మార్పులను చేయడానికి బదులుగా వివరణాత్మక పాఠాన్ని (prose) ఇస్తుంది, దీనివల్ల ఏజెంట్ లూప్‌లో పడటం లేదా ఆగిపోవడం జరుగుతుంది. మీరు మోడల్‌ను డౌన్‌లోడ్ చేసే ముందు ollama.com లోని ఆ మోడల్ పేజీలో tools లేబుల్ ఉందో లేదో చూడండి. qwen3-coder:30b మోడల్‌కు ఈ సామర్థ్యం ఉంది, మరియు ఆగస్టు 2026 నాటికి ఈ ట్యాగ్ 19 GB డౌన్‌లోడ్ పరిమాణాన్ని మరియు 256K కాంటెక్స్ట్ విండోను కలిగి ఉంది. మీ సర్వర్ కేవలం CPU మాత్రమే కలిగి ఉన్నా లేదా RAM తక్కువగా ఉన్నా, VPS పై Qwen 27B ట్యాగ్ కోసం మెమరీ గణనలు అనే విభాగం 8 నుండి 64 GB RAM లో ఏది సరిపోతుందో వివరిస్తుంది, కాబట్టి డౌన్‌లోడ్ చేసే ముందు దీనిని చూడండి. మీరు మోడల్‌ను డౌన్‌లోడ్ చేసిన తర్వాత, ఆ గిగాబైట్ల డేటా సర్వర్ యొక్క root డిస్క్‌లో నిల్వ అవుతుంది. VPS లో సాధారణంగా root డిస్క్ తక్కువ స్థలాన్ని కలిగి ఉంటుంది, కాబట్టి డిస్క్ నిండిపోకముందే Ollama మోడల్ ఫైళ్లను ఎక్కడ ఉంచుతుంది మరియు వాటిని వేరే చోటికి ఎలా తరలించాలి అనే సమాచారాన్ని చదవడం మంచిది.

ఇప్పుడు సర్వర్ ఏ మోడల్ పేర్లను అందిస్తుందో నిర్ధారించుకోండి:

curl http://localhost:11434/v1/models

ఆ ప్రతిస్పందనలో ఉన్న స్ట్రింగ్స్ మీ ఏజెంట్ కాన్ఫిగరేషన్‌లో అక్షర దోషం లేకుండా ఉండాలి. ముందుగానే వీటిని తనిఖీ చేయడం వల్ల మోడల్-నాట్-ఫౌండ్ (model-not-found) వంటి లోపాలు రాకుండా ఉంటాయి. ఒకవేళ Ollama ఇంకా ఇన్‌స్టాల్ చేయకపోతే, VPS పై Ollama తో LLM ను సెల్ఫ్-హోస్ట్ చేయడం అనే పూర్తి గైడ్‌ను చూడండి.

OpenCode ను Ollama కు అనుసంధానించడం

~/.config/opencode/opencode.json ఫైల్‌ను ఎడిట్ చేయండి:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ollama",
      "options": {
        "baseURL": "http://localhost:11434/v1"
      },
      "models": {
        "qwen3-coder:30b": {
          "name": "qwen3-coder 30b"
        }
      }
    }
  }
}

models కింద ఉన్న కీ Ollama కు పంపబడే మోడల్ పేరు, కాబట్టి ఇది ollama ls తో ఖచ్చితంగా సరిపోలాలి. name ఫీల్డ్ అనేది మోడల్ పికర్‌లో కనిపించే లేబుల్ మాత్రమే. opencode ను ప్రారంభించి, Ollama ప్రొవైడర్‌కు మారండి. అభ్యర్థన వేరే ఎక్కడికో కాకుండా మీ సర్వర్‌కే చేరిందని నిర్ధారించుకోవడానికి journalctl -e -u ollama ను గమనించండి. ఏజెంట్‌ను సెటప్ చేయడం గురించి VPS పై OpenCode ను రన్ చేయడం విభాగంలో వివరించబడింది.

Claude Code ను Ollama కు అనుసంధానించడం

export ANTHROPIC_AUTH_TOKEN=ollama
export ANTHROPIC_API_KEY=""
export ANTHROPIC_BASE_URL=http://localhost:11434
claude --model qwen3-coder:30b

ANTHROPIC_API_KEY ఉద్దేశపూర్వకంగానే ఖాళీగా ఉంచబడింది. ఒకవేళ నిజమైన కీని environment లో వదిలేస్తే, మీ అభ్యర్థనలు స్థానిక inference కు బదులుగా hosted API కి వెళ్తాయి, దీనివల్ల మీకు బిల్లు పడుతుంది కానీ స్థానిక ఫలితాలు రావు. ollama launch claude మీ కోసం ఇవన్నీ సెట్ చేస్తుంది.

ఈ compatibility layer లో ఏవి లేవో తెలుసుకోండి. ఇది tool_choice ను లేదా prompt caching ను అమలు చేయదు, మరియు దీనికి token counting endpoint లేదు, కాబట్టి మీరు చూసే token సంఖ్యలు మోడల్ యొక్క స్వంత tokenizer నుండి వచ్చిన అంచనాలు మాత్రమే. Claude Code పెద్ద మొత్తంలో system prompt మరియు tool set ను కలిగి ఉంటుంది, కాబట్టి దీనికి సాధారణ chat client కంటే ఎక్కువ context అవసరం. ఏవి పనిచేస్తాయి, ఏవి పనిచేయవు అనే దానిపై మరింత సమాచారం కోసం Claude ను self-host చేయవచ్చా చూడండి.

Ollama వద్ద Aider ను పాయింట్ చేయడం

export OLLAMA_API_BASE=http://127.0.0.1:11434
aider --model ollama_chat/qwen3-coder:30b

Aider డాక్యుమెంటేషన్ ollama/ కంటే ollama_chat/ ప్రిఫిక్స్‌ను ఉపయోగించమని సిఫార్సు చేస్తుంది. ఇది .aider.model.settings.yml లో ప్రతి మోడల్‌కు కాంటెక్స్ట్ విండోను పిన్ చేయడానికి కూడా అనుమతిస్తుంది. సర్వర్ డిఫాల్ట్ కంటే భిన్నమైన విండో ఒక మోడల్‌కు అవసరమైనప్పుడు ఇది ఉపయోగకరంగా ఉంటుంది:

- name: ollama_chat/qwen3-coder:30b
  extra_params:
    num_ctx: 65536

పనిచేస్తున్న సెటప్ కూడా అర్థరహితమైన ఫలితాలను ఎందుకు ఇస్తుంది

ఇది అత్యంత ముఖ్యమైన విభాగం. Ollama తనకు కనిపించే VRAM (GPU లోని వీడియో మెమరీ) ఆధారంగా డిఫాల్ట్ కాంటెక్స్ట్ పొడవును ఎంచుకుంటుంది, ఈ డిఫాల్ట్ విలువలు ప్రచురించబడ్డాయి:

[
  {
    "label": "Under 24 GiB VRAM",
    "default_context_tokens": "4,096"
  },
  {
    "label": "24 to 48 GiB VRAM",
    "default_context_tokens": "32,768"
  },
  {
    "label": "48 GiB VRAM or more",
    "default_context_tokens": "262,144"
  }
]

చాలా VPS ప్లాన్‌లు మరియు CPU-మాత్రమే ఉన్న సర్వర్‌లు మొదటి వరుసలోకి వస్తాయి: 4,096 టోకెన్లు. కేవలం పెద్ద GPUలు మాత్రమే చివరి వరుసలోని 262,144 టోకెన్లను పొందుతాయి.

ఒక ఏజెంట్ ఎటువంటి పనిని ప్రారంభించకముందే 4096 టోకెన్లను వినియోగిస్తుంది. సిస్టమ్ ప్రాంప్ట్, టూల్ డెఫినిషన్లు, రిపోజిటరీ లిస్టింగ్ మరియు అది తెరిచే మొదటి ఫైల్ అప్పటికే అంతకంటే పెద్దవిగా ఉంటాయి. ఆ తర్వాత జరిగేదే అసలు సమస్య: ఎటువంటి ఎర్రర్ రాదు. Ollama విండో పరిమితిని మించిన కాంటెక్స్ట్‌ను నిశ్శబ్దంగా తొలగిస్తుందని Aider డాక్యుమెంటేషన్ పేర్కొంది. పాత టోకెన్లు తొలగిపోతాయి, కాబట్టి మోడల్ తనకు ఇక కనిపించని ఫైల్ గురించి ఆత్మవిశ్వాసంతో సమాధానం ఇస్తుంది లేదా రెండు అడుగుల క్రితం మీరు ఇచ్చిన సూచనను మర్చిపోతుంది. లోకల్ మోడల్ కోడ్ రాయడానికి సరిపోదని వచ్చే చాలా ఫిర్యాదులకు ఈ మెకానిజమే కారణం. ఈ సంఖ్యను ఎంచుకోవడం అనేది మీ నిర్ణయం, మరియు ప్రతి పరిమాణం వద్ద KV cache మెమరీలో num_ctx ఎంత ఖర్చవుతుంది అనే దాని గురించి చదవడం మంచిది.

ఏజెంట్లు మరియు కోడింగ్ టూల్స్ వంటి పనులకు కనీసం 64000 టోకెన్లు సెట్ చేయాలని Ollama డాక్యుమెంటేషన్ చెబుతోంది. దీన్ని సర్వర్‌లో సెట్ చేయండి:

sudo systemctl edit ollama.service

override ఫైల్‌లో ఈ లైన్లను జోడించండి:

[Service]
Environment="OLLAMA_CONTEXT_LENGTH=64000"

ఆ తర్వాత రీలోడ్ చేసి రీస్టార్ట్ చేయండి:

sudo systemctl daemon-reload
sudo systemctl restart ollama
ollama ps

ollama ps అనేది తనిఖీ చేయడానికి ఉపయోగపడుతుంది. ఇది CONTEXT కాలమ్‌ను ప్రింట్ చేస్తుంది, ఆ సంఖ్యే మోడల్‌కు వాస్తవంగా అందిన టోకెన్ల సంఖ్య. మీ ID మరియు SIZE విలువలు భిన్నంగా ఉంటాయి:

NAME               ID              SIZE     PROCESSOR    CONTEXT    UNTIL
qwen3-coder:30b    a1b2c3d4e5f6    24 GB    100% GPU     64000      4 minutes from now

దీన్ని ఏజెంట్‌లో కాకుండా సర్వర్‌లో సెట్ చేయడానికి రెండు కారణాలు ఉన్నాయి. OpenAI చాట్ కంప్లీషన్స్ స్కీమాలో కాంటెక్స్ట్ పొడవు కోసం ఎటువంటి ఫీల్డ్ లేదు, కాబట్టి OpenAI-అనుకూల క్లయింట్ దీన్ని అడగలేదు. మరియు ఈ సెట్టింగ్ సర్వర్ వారీగా ఉంటుంది, కాబట్టి మీరు ఆ సర్వర్‌కు కనెక్ట్ చేసే ప్రతి ఏజెంట్ దీన్ని పొందుతుంది. అవుట్‌పుట్ సైడ్‌కు దాని స్వంత పరిమితి ఉంటుంది, కాంటెక్స్ట్ పొడవులా కాకుండా ఇది కంపాటిబిలిటీ ఎండ్‌పాయింట్ ద్వారా ప్రయాణిస్తుంది, కాబట్టి ఒక ప్యాచ్ మధ్యలో సమాధానం ఆగిపోయినప్పుడు num_predict మరియు దానికి మ్యాప్ అయ్యే max_tokens ఫీల్డ్ గురించి తెలుసుకోవాలి. ఒక మోడల్‌కు వేరే విండో అవసరమైతే, Modelfile ఉపయోగించి ఒక కాపీని సృష్టించండి:

FROM qwen3-coder:30b
PARAMETER num_ctx 65536

ollama create qwen3-coder-64k -f Modelfile

కాంటెక్స్ట్ ఉచితం కాదు. ఎక్కువ విండో పరిమాణం ఎక్కువ మెమరీని తీసుకుంటుంది, కాబట్టి PROCESSOR కాలమ్‌ను గమనించండి. 100% GPU మీకు కావాల్సిన విలువ. మోడల్‌లో కొంత భాగం CPUకి మారినప్పుడు, టోకెన్ రేటు ఎంతగా పడిపోతుందంటే ఏజెంట్ లూప్ ఉపయోగించలేని స్థితికి చేరుకుంటుంది, మరియు లోకల్ LLMలో టోకెన్ల వేగాన్ని కొలవడం ద్వారా మీ సర్వర్ యొక్క అసలు పరిమితిని తెలుసుకోవచ్చు. మెషీన్‌ను కొనుగోలు చేసే ముందు దాని సామర్థ్యాన్ని అంచనా వేయడం గురించి కోడింగ్ ఏజెంట్ VPSకి ఎంత RAM మరియు CPU అవసరం అనే దాంట్లో వివరించబడింది.

అభ్యర్థనల మధ్య మోడల్‌ను లోడ్ చేసి ఉంచడం

డిఫాల్ట్‌గా, Ollama తన చివరి అభ్యర్థన తర్వాత 5 నిమిషాలకు మోడల్‌ను అన్‌లోడ్ చేస్తుంది. ఇది చాట్ బాక్స్‌కు సరిపోతుంది కానీ ఏజెంట్ పనులకు కాదు. మీరు ఒక diff చదవడానికి విరామం తీసుకున్నప్పుడు, టైమర్ ముగిసిపోతుంది. తదుపరి అభ్యర్థన వచ్చినప్పుడు, మొదటి టోకెన్ కనిపించేలోపు పదుల కొద్దీ గిగాబైట్ల బరువులను (weights) డిస్క్ నుండి మళ్లీ లోడ్ చేయాల్సి వస్తుంది. ఇది సర్వర్ హ్యాంగ్ అయినట్లు కనిపిస్తుంది.

OLLAMA_KEEP_ALIVE అనేది 10m లేదా 24h వంటి డ్యూరేషన్ స్ట్రింగ్‌ను, లేదా సెకన్లలో ఒక సాధారణ సంఖ్యను తీసుకుంటుంది. మోడల్‌ను నిరవధికంగా లోడ్ చేసి ఉంచడానికి -1 ని, లేదా వెంటనే అన్‌లోడ్ చేయడానికి 0 ని ఉపయోగించవచ్చు. దీన్ని కాంటెక్స్ట్ లెంగ్త్ పక్కన సెట్ చేయండి:

[Service]
Environment="OLLAMA_CONTEXT_LENGTH=64000"
Environment="OLLAMA_KEEP_ALIVE=-1"

keep_alive అభ్యర్థన ఫీల్డ్ Ollama యొక్క నేటివ్ /api/generate మరియు /api/chat ఎండ్‌పాయింట్‌లలో మాత్రమే ఉంటుంది, కంపాటబిలిటీ ఎండ్‌పాయింట్‌లలో ఉండదు. కాబట్టి, ఏజెంట్ దీన్ని ప్రతి అభ్యర్థనకు సెట్ చేయలేదు. ఎన్విరాన్‌మెంట్ వేరియబుల్ మాత్రమే మీకు ఉన్న ఏకైక మార్గం. మీకు మెమరీ తిరిగి కావాల్సినప్పుడు, ollama stop qwen3-coder:30b సర్వర్‌ను ఆపకుండానే మోడల్‌ను అన్‌లోడ్ చేస్తుంది. ఈ సెట్టింగ్ రీబూట్ తర్వాత కూడా ఉండాలన్నా, లేదా రోజంతా మెమరీలో బరువులను ఉంచడం వల్ల కలిగే మెమరీ వినియోగాన్ని బేరీజు వేసుకోవాలన్నా, Ollama మోడల్‌ను మెమరీలో ఉంచడం అనే పద్ధతి రెండింటికీ ఉపయోగపడుతుంది.

Ollama ను వేరొక సర్వర్‌లో రన్ చేయడం

Ollama డిఫాల్ట్‌గా localhost కి బైండ్ అవుతుంది. వేరొక మెషిన్ నుండి దీనిని యాక్సెస్ చేయడానికి, అదే systemd override లో OLLAMA_HOST=0.0.0.0:11434 ని సెట్ చేసి, సర్వీస్‌ను రీస్టార్ట్ చేయండి.

దీనిని కేవలం ప్రైవేట్ నెట్‌వర్క్‌లో మాత్రమే చేయండి. Ollama డాక్యుమెంటేషన్ ప్రకారం, లోకల్ API కి ఎటువంటి అథెంటికేషన్ అవసరం లేదు. కాబట్టి, 11434 పోర్ట్‌ను ఇంటర్నెట్‌కు ఓపెన్ చేస్తే, ఎవరైనా మీ హార్డ్‌వేర్‌ను ఉపయోగించుకోవచ్చు మరియు మీ ఏజెంట్ పంపే సమాచారాన్ని చదవవచ్చు. దీనికి రెండు సురక్షితమైన మార్గాలు ఉన్నాయి. బైండింగ్‌ను localhost లోనే ఉంచి, మీ ల్యాప్‌టాప్ నుండి SSH ద్వారా పోర్ట్‌ను ఫార్వర్డ్ చేయండి:

ssh -N -L 11434:localhost:11434 you@your-vps

మీ ఏజెంట్ http://localhost:11434/v1 నే పాయింట్ చేస్తూ ఉంటుంది, దానికి ఎటువంటి మార్పు తెలియదు. మరొక మార్గం VPN, ఇందులో Ollama ను 0.0.0.0 కి బదులుగా VPN అడ్రస్‌కు బైండ్ చేయాలి. ఒకే సర్వర్‌ను పలువురు వ్యక్తులు లేదా పలు ఏజెంట్లు పంచుకోవాలనుకుంటే, Ollama యొక్క షెడ్యూలర్ అటువంటి లోడ్ కోసం రూపొందించబడలేదు. Ollama మరియు vLLM మధ్య పోలిక చూస్తే, త్రూపుట్ (throughput) వ్యత్యాసం ఎక్కడ ప్రభావం చూపుతుందో అర్థమవుతుంది.

లోకల్ కోడింగ్ మోడల్ ఎక్కడ ఉపయోగపడుతుంది, ఎక్కడ ఉపయోగపడదు

మీరు హోస్ట్ చేసే మోడల్ ద్వారా నడిచే ఏజెంట్, ప్రతి పనిలోనూ frontier API స్థానాన్ని భర్తీ చేయలేదు. ఇది నాలుగు రకాల పనుల్లో స్పష్టంగా విజయం సాధిస్తుంది.

• భారీ స్థాయిలో చేసే చిన్న మార్పులు (Bulk mechanical edits): ఇక్కడ ప్రతి మార్పు చిన్నదిగా ఉంటుంది మరియు మీరు దాన్ని తనిఖీ చేయవచ్చు. రిపోజిటరీ అంతటా పేర్లను మార్చడం, type hints జోడించడం, docstrings రాయడం, వ్యాఖ్యలను అనువదించడం వంటివి. మోడల్ గంటల తరబడి నడిచినా మీకు అదనపు ఖర్చు ఉండదు.
• మీ హార్డ్‌వేర్ దాటి బయటకు వెళ్లకూడని పనులు: గోప్యతా ఒప్పందం (confidentiality agreement) కింద ఉన్న క్లయింట్ కోడ్ లేదా మూడవ పక్షానికి పంపడానికి అనుమతి లేని అంతర్గత రిపోజిటరీ.
• ఆఫ్‌లైన్ మరియు ఎయిర్-గ్యాప్డ్ యంత్రాలు: ఇక్కడ కాల్ చేయడానికి ఎటువంటి హోస్ట్ చేసిన API అందుబాటులో ఉండదు.
• ఊహించదగిన ఖర్చు: సర్వర్ కోసం ఒకసారి చెల్లించిన తర్వాత, లూప్‌లో టోకెన్‌లను ఉపయోగించే ఏజెంట్‌కు అదనపు ఖర్చు ఉండదు, ఇది metered API కి పూర్తి విరుద్ధం. Where a GPU VPS breaks even against API tokens లో దీనికి సంబంధించిన గణాంకాలు ఉన్నాయి.

సుదీర్ఘమైన, బహుళ దశల పనుల్లో ఇది విఫలమవుతుంది. "ఈ టెస్ట్ ఎందుకు ఫెయిల్ అవుతుందో కనుగొనండి, కారణాన్ని సరిచేయండి, కాల్ చేసేవారిని అప్‌డేట్ చేయండి" వంటి పనులకు వరుసగా అనేక సరైన టూల్ కాల్స్ అవసరం, మరియు మొత్తం హిస్టరీని కాంటెక్స్ట్‌లో ఉంచుకోవాలి. సాధారణ సర్వర్‌పై 8B నుండి 14B పరిధిలో ఉండే మోడల్ తప్పుగా టూల్ కాల్‌ను రూపొందించవచ్చు లేదా కొన్ని దశల తర్వాత ప్లాన్‌ను మర్చిపోవచ్చు. అప్పుడు మీరు ఆ పనిని పూర్తి చేయడానికి పట్టే సమయం కంటే, దాన్ని సరిదిద్దడానికే ఎక్కువ సమయం వెచ్చిస్తారు. ఇది మీరు ప్రాంప్ట్ రాయడం ద్వారా పరిష్కరించుకోగల సమస్య కాదు. ఇది మోడల్ సామర్థ్యానికి (capacity) సంబంధించిన పరిమితి.

అలాగే, తప్పు జరిగితే భారీ నష్టం వాటిల్లే పనుల్లో మరియు మీరు ప్రతి లైన్‌ను చదవని పనుల్లో ఇది విఫలమవుతుంది. లోకల్ మోడల్‌కు మీరు ధృవీకరించగల చిన్న చిన్న పనులను మాత్రమే అప్పగించండి. మీరు దశలవారీగా తనిఖీ చేయలేని పనుల కోసం హోస్ట్ చేసిన మోడల్‌ను ఉపయోగించండి.

వైఫల్య రీతులు మరియు మీకు కనిపించే సందేశాలు

curl: (7) Failed to connect to localhost port 11434 after 0 ms: Connection refused. సర్వర్ నడువడం లేదు, లేదా ఏజెంట్ వేరే హోస్ట్‌కు పాయింట్ చేయబడింది. systemctl status ollama రన్ చేసి, ఆపై journalctl -e -u ollama రన్ చేయండి.

మోడల్ లేదని ఏజెంట్ తెలియజేస్తోంది. మీ కాన్ఫిగరేషన్‌లో ఉన్న పేరు, సర్వర్ అందిస్తున్న పేరుతో సరిపోలడం లేదు. దీన్ని curl http://localhost:11434/v1/models తో పోల్చి, అక్కడ ఉన్న స్ట్రింగ్‌ను కాపీ చేయండి. ట్యాగ్ అనేది పేరులో ఒక భాగం, కాబట్టి మీరు ఎప్పుడూ డౌన్‌లోడ్ చేయని ట్యాగ్‌ను కాన్ఫిగరేషన్‌లో పేర్కొంటే, అదే పేరుతో మరొక మోడల్ ఉన్నప్పటికీ అది విఫలమవుతుంది.

ఏజెంట్ సమాధానాలను వచన రూపంలో ఇస్తోంది కానీ ఫైల్‌ను ఎడిట్ చేయడం లేదు. మోడల్‌కు టూల్ సపోర్ట్ లేకపోవడం లేదా అభ్యర్థన మరియు దాని టూల్ డెఫినిషన్లు ఇప్పటికే కాంటెక్స్ట్ విండోను నింపేయడం దీనికి కారణం కావచ్చు. మోడల్ పేజీలోని tools లేబుల్‌ను తనిఖీ చేయండి, ఆపై ollama ps లోని CONTEXT కాలమ్‌ను చూడండి.

మొదటి టోకెన్ రావడానికి ముందు సుదీర్ఘ నిశ్శబ్దం, ఆపై సాధారణ వేగం. కీప్-అలైవ్ గడువు ముగిసింది, కాబట్టి వెయిట్స్ (weights) మళ్ళీ డిస్క్ నుండి చదవబడుతున్నాయి. OLLAMA_KEEP_ALIVE ని సెట్ చేయండి.

మోడల్ ఇప్పుడే చదివిన ఫైల్‌కు విరుద్ధంగా సమాధానం ఇస్తోంది. కాంటెక్స్ట్ ట్రంకేషన్ (truncation) జరుగుతోంది. మీరు సెట్ చేసిన దానికంటే ollama ps లో CONTEXT విలువ తక్కువగా కనిపిస్తుంది, ఎందుకంటే ఆ ఎన్విరాన్మెంట్ వేరియబుల్ సిస్టమ్డ్ యూనిట్‌కు వెళ్లకుండా మీ షెల్‌కు మాత్రమే పరిమితమైంది.

అన్నీ పనిచేస్తున్నాయి, కానీ నెమ్మదిగా ఉన్నాయి మరియు PROCESSOR అనేది 100% GPU కాదు. మోడల్ మరియు దాని కాంటెక్స్ట్ VRAM లో సరిపోవడం లేదు. కాంటెక్స్ట్ లెంగ్త్‌ను తగ్గించండి, లేదా చిన్న మోడల్‌కు లేదా తక్కువ క్వాంటైజేషన్ ఉన్న మోడల్‌కు మారండి. మీరు మళ్ళీ డౌన్‌లోడ్ చేసే ముందు, q4_K_M, q8_0 మరియు fp16 లకు ఎంత మెమరీ అవసరమవుతుంది మరియు క్వాలిటీ ఎక్కడ తగ్గుతుంది అనే లింక్ ద్వారా, ఒక స్థాయి తగ్గడం వల్ల ఎంత మెమరీ ఆదా అవుతుందో మరియు మీరు దేనిని కోల్పోతారో తెలుసుకోండి.

FAQ

నేను Claude Code ను Ollama కు పాయింట్ చేయవచ్చా?

అవును, కానీ OpenAI-compatible URL తో కాదు. Claude Code అనేది Anthropic Messages API తో పనిచేస్తుంది, Ollama అదే ఆకృతిని /v1/messages వద్ద 11434 పోర్ట్‌లో అందిస్తుంది. ANTHROPIC_BASE_URL=http://localhost:11434, ANTHROPIC_AUTH_TOKEN=ollama మరియు ఖాళీ ANTHROPIC_API_KEY లను ఎగుమతి (export) చేసి, ఆపై claude --model qwen3-coder:30b తో ప్రారంభించండి. ollama launch claude మీ కోసం అదే సెట్టింగులను వ్రాస్తుంది. ఈ అనుకూలత పొర (compatibility layer) tool_choice లేదా ప్రాంప్ట్ క్యాచింగ్‌ను అమలు చేయదు, మరియు దీనికి టోకెన్ కౌంటింగ్ ఎండ్‌పాయింట్ లేదు, కాబట్టి చూపబడే టోకెన్ గణనలు అంచనాలు మాత్రమే.

నా లోకల్ మోడల్ అది చూడలేని కోడ్ గురించి ఎందుకు సమాధానం ఇస్తోంది?

ఎందుకంటే అభ్యర్థన (request) కాంటెక్స్ట్ విండోకు సరిపోవడం లేదు, మరియు దానిలోని పాత భాగం ఎటువంటి దోష సందేశం లేకుండా తొలగించబడింది. Ollama తన డిఫాల్ట్ కాంటెక్స్ట్‌ను అందుబాటులో ఉన్న VRAM ఆధారంగా నిర్ణయిస్తుంది. 24 GiB కంటే తక్కువ VRAM ఉన్నప్పుడు, ఆ డిఫాల్ట్ విలువ 4,096 టోకెన్లు మాత్రమే. ఏజెంట్ యొక్క సిస్టమ్ ప్రాంప్ట్ మరియు టూల్ డెఫినిషన్లు కలిపి అంతకంటే ఎక్కువ స్థలాన్ని ఆక్రమిస్తాయి. systemd యూనిట్‌లో OLLAMA_CONTEXT_LENGTH=64000 ను సెట్ చేయండి, Ollama ను రీస్టార్ట్ చేయండి, మరియు ollama ps లోని CONTEXT కాలమ్ కొత్త విలువను చూపుతుందో లేదో నిర్ధారించుకోండి.

VPS లో కోడింగ్ ఏజెంట్ కోసం నేను ఏ మోడల్‌ను రన్ చేయాలి?

64k కాంటెక్స్ట్ విండోతో మెమరీలో సరిపోయే, tools లేబుల్ ఉన్న అతిపెద్ద మోడల్‌ను ఎంచుకోండి. కోడింగ్ కోసం ప్రత్యేకంగా ట్యూన్ చేసిన మోడల్‌కు ప్రాధాన్యత ఇవ్వండి. తగినంత VRAM ఉన్న GPU సర్వర్‌లో qwen3-coder:30b సాధారణంగా సరిపోతుంది. ఒకవేళ ఆ ట్యాగ్ మీ సర్వర్‌కు చాలా పెద్దదైతే, Nemotron 3.5 Lightning కోసం RAM గణాంకాలు మరియు CPU-మాత్రమే వేగం డౌన్‌లోడ్ చేయడానికి ముందు ఉపయోగకరమైన పోలికను అందిస్తాయి. సుమారు 14B పారామీటర్ల కంటే తక్కువ ఉన్న మోడల్ కోడ్ గురించి ప్రశ్నలకు బాగానే సమాధానం ఇవ్వగలదు, కానీ మల్టీ-స్టెప్ ఎడిటింగ్ చేసేటప్పుడు విఫలం కావచ్చు. ఎందుకంటే ఏజెంట్ పనిలో టూల్ కాల్స్ చేసేటప్పుడు చిన్న ఫార్మాటింగ్ తప్పులు కూడా పెద్ద సమస్యలను కలిగిస్తాయి. ఒక శాంపిల్ ప్రాంప్ట్ కంటే, మీ స్వంత రిపోజిటరీ నుండి ఒక నిజమైన టాస్క్‌తో పరీక్షించండి.

నా స్వంత మోడల్‌లో కోడింగ్ ఏజెంట్‌ను రన్ చేయడానికి నాకు GPU అవసరమా?

ఆచరణలో అవును. CPU-మాత్రమే ఉపయోగించే ఇన్ఫరెన్స్ (inference) ఒకే ప్రశ్నలకు బాగానే ఉంటుంది, కానీ ఒక ఏజెంట్ ప్రతి టాస్క్ కోసం అనేక అభ్యర్థనలను పంపుతుంది మరియు ప్రతిసారీ సుదీర్ఘ చరిత్రను మళ్లీ చదువుతుంది. కాబట్టి నెమ్మదిగా ఉండే టోకెన్ రేటు రెండు నిమిషాల పనిని గంట సమయం పట్టేలా చేస్తుంది. ollama ps లోని PROCESSOR కాలమ్‌ను తనిఖీ చేయండి: 100% GPU కాకుండా వేరే ఏదైనా విలువ ఉంటే, మోడల్‌లో కొంత భాగం CPU పై నడుస్తోందని మరియు టోకెన్ రేటు గణనీయంగా పడిపోతుందని అర్థం.