SSD Nodes Learn Hosting plans →

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

మీ కోడింగ్ ఏజెంట్‌ను Ollama లోకల్ మోడల్‌కు కనెక్ట్ చేయడం ఎలాగో తెలుసుకోండి. Base URL, డమ్మీ API కీ, కాంటెక్స్ట్ లెంగ్త్ సెట్టింగ్స్ మరియు లోకల్ మోడల్స్ ఏ పనులకు ఉత్తమమో ఇక్కడ చూడండి.

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

మీ coding agent తో Ollama ను ఉపయోగించవచ్చు. దీనికి అవసరమైన connection చాలా సరళంగా ఉంటుంది. ఒక base URL ను మార్చి, ఒక model name ను ఎంచుకోవాలి. API key field లో విలువ తప్పనిసరిగా ఇవ్వాలి. అయితే local server దానిని పట్టించుకోదు. అందువల్ల ఏ string అయినా పనిచేస్తుంది.

Ollama port 11434 పై listen చేస్తుంది మరియు ఒకేసారి మూడు API surfaces ను అందిస్తుంది. /api అనేది Ollama యొక్క native API. /v1 అనేది OpenAI-compatible layer. ఇందులో అనేక రూపాలు ఉంటాయి: /v1/chat/completions, /v1/responses, /v1/completions, /v1/models మరియు /v1/embeddings. అక్కడ key అవసరమని, కానీ దాన్ని పట్టించుకోరని Ollama documentation పేర్కొంటుంది. మూడవ surface Anthropic-compatible. Client http://localhost:11434 ను base URL గా తీసుకుని, దానికి /v1/messages ను జత చేస్తుంది. Claude Code ఉపయోగించేది ఇదే. చాలా agents /v1/chat/completions ను ఉపయోగిస్తాయి. Codex /v1/responses ను ఉపయోగిస్తుంది. Claude Code /v1/messages ను ఉపయోగిస్తుంది. మీ agent ఇప్పటికే వీటిలో ఒకదానితో మాట్లాడగలదు. అందువల్ల దానిలో మరే మార్పు అవసరం లేదు.

ఈ భాగాన్ని పూర్తి చేయడానికి ఐదు నిమిషాలు పడుతుంది. ఫలితం ఉపయోగించదగినదిగా ఉండటం రెండు settings పై ఆధారపడి ఉంటుంది. చాలా మంది మార్చని context length మరియు keep-alive settings అవే. అలాగే, model కు అది బాగా చేయగలిగే రకమైన పనిని ఇవ్వాలి. ఈ రెండు settings కు ఒక్కొక్కటి ప్రత్యేక section ఉంటుంది. నిజమైన పరిమితులు చివర్లో ఉన్నాయి.

స్థానిక base URL ను ఏ coding agents అంగీకరిస్తాయి

పరీక్షలో ఒకే ప్రశ్న ఉంటుంది: ఆ సాధనం base URL ను సెట్ చేసే ఎంపికను అందిస్తుందా? అందిస్తే, అది మీ server తో అనుసంధానమవుతుంది.

Ollama, Claude Code, OpenCode, Codex, Cline, Roo Code, Zed, JetBrains IDEs మరియు VS Code కోసం integration పేజీలను అందిస్తుంది. Aider తన Ollama మద్దతును ప్రత్యేకంగా document చేస్తుంది. అక్టోబర్ 2026 నాటికి coding agent అని చెప్పినప్పుడు సాధారణంగా ఉద్దేశించేవాటిలో ఎక్కువ భాగం ఇవే. ఇవన్నీ ఒకే API రూపాన్ని ఉపయోగించవు. సెటప్‌లు విఫలమయ్యే ప్రధాన కారణం ఇదే.

  • చాలా agents కు OpenAI-compatible endpoint అవసరం. వాటికి base URL http://localhost:11434/v1 మరియు ఖాళీ కాని ఏదైనా API key string ఇవ్వండి.
  • Claude Code OpenAI base URL ను అసలు అంగీకరించదు. ఇది Anthropic Messages API ను ఉపయోగిస్తుంది. కాబట్టి ANTHROPIC_BASE_URL ను http://localhost:11434 కు సెట్ చేయాలి. Ollama ఈ endpoint ను /v1/messages వద్ద అందిస్తుంది.
  • Codex OpenAI Responses API ను ఉపయోగిస్తుంది. Ollama /v1/responses ను కూడా అందిస్తుంది. ఈ మద్దతు version 0.13.3 లో చేర్చబడింది.
  • base URL సెట్టింగ్ లేని agent ను redirect చేయలేరు, ఎందుకంటే endpoint client లోనే నిర్మించబడి ఉంటుంది. Agent custom URL ను అంగీకరించినా, వేరే API రూపం అవసరమైతే, దాని ముందు translation layer ఉంచండి. ఉదాహరణకు self-hosted LiteLLM gateway ఉపయోగించి, client కోరే API రూపంలో మీ model ను మళ్లీ అందించవచ్చు.

Ollama ఈ configurations ను మీ కోసం రాయగలదు. ollama launch opencode మీరు ఎంచుకున్న model కోసం inline config తో OpenCode ను ప్రారంభిస్తుంది. ollama launch claude Claude Code కోసం అదే పని చేస్తుంది. ollama launch droid --config tool ను ప్రారంభించకుండా configuration ను రాస్తుంది.

Ollamaను ఇన్‌స్టాల్ చేసి tools ను కాల్ చేయగల model ను pull చేయండి

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

Installer ఒక systemd unit ను జోడించి, దాన్ని ప్రారంభిస్తుంది. అందువల్ల systemctl status ollama అమలు చేస్తే active (running) కనిపించాలి. అలా కనిపించకపోతే, కారణాన్ని journalctl -e -u ollama చూపిస్తుంది.

Model tool calling కు మద్దతు ఇవ్వాలి, ఎందుకంటే agent పనిచేసే విధానం tool calling పై ఆధారపడి ఉంటుంది. Agent file ను చదివి, patch ను రాసి, test ను అమలు చేస్తుంది. తరువాత వచ్చిన failure ను చదివి మళ్లీ ప్రయత్నిస్తుంది. Tool call ను రూపొందించలేని model, edit ను అమలు చేయకుండా దాన్ని prose లో వివరిస్తుంది. దాంతో agent పునరావృతంగా తిరుగుతుంది లేదా ఆగిపోతుంది. Model ను pull చేయడానికి ముందు, ollama.com లోని దాని page పై tools label ఉందో చూడండి. qwen3-coder:30b లో ఆ label ఉంది. October 2026 నాటికి, ఆ tag పరిమాణం 19 GB, context window 256K. మీ machine CPU-only అయితే లేదా RAM తక్కువగా ఉంటే, download ప్రారంభించే ముందు 8 నుంచి 64 GB వరకు వాస్తవంగా ఏది సరిపోతుందో VPSలో Qwen 27B tag కోసం memory లెక్కలు చూపిస్తుంది. Model ను pull చేసిన తరువాత, ఆ gigabytes server యొక్క root disk పై నిల్వ అవుతాయి. VPSలో సాధారణంగా తక్కువ ఖాళీ ఉండేది ఈ diskపైనే. అందువల్ల disk నిండే ముందు Ollama తన model files ను ఎక్కడ ఉంచుతుంది, వాటిని వేరే చోటుకు ఎలా తరలించాలి చదవడం ఉపయోగకరం.

ఇప్పుడు server వాస్తవంగా అందిస్తున్న పేర్లను నిర్ధారించండి:

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

ఆ responseలోని strings ను మీ agent configలో అక్షరాలా, ఎలాంటి మార్పు లేకుండా ఉంచాలి. ముందుగా దీనిని పరిశీలిస్తే, model-not-found errors లో ఎక్కువ భాగం పరిష్కారమవుతుంది. Ollama ఇంకా ఇన్‌స్టాల్ చేయకపోతే, VPSలో Ollamaతో LLMను self-host చేయడం అనే విస్తృత walkthrough చూడండి.

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 ను ఉద్దేశపూర్వకంగా ఖాళీ string గా సెట్ చేశారు. అభ్యర్థనలు ఎక్కడికి వెళ్లాలో base URL నియంత్రిస్తుంది; ఈ local setup లో hosted credentials ఉపయోగించకుండా ఉండేందుకు key ను ఖాళీ చేయడం అవసరం. ollama launch claude ఇవన్నీ మీ కోసం సెట్ చేస్తుంది.

Compatibility layer ఏ అంశాలను అందించదో తెలుసుకోండి. ఇది tool_choice లేదా prompt caching ను అమలు చేయదు. దీనికి token counting endpoint కూడా లేదు. అందువల్ల మీరు చూసే token సంఖ్యలు model స్వంత 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 documentation, ollama/ కంటే ollama_chat/ prefix ను సిఫార్సు చేస్తుంది. డిఫాల్ట్‌గా, ప్రతి request కు అవసరమైన context తో పాటు reply కోసం 8k tokens ను Aider అభ్యర్థిస్తుంది. అలాగే .aider.model.settings.yml లో ప్రతి model కు context window ను నిర్దిష్టంగా సెట్ చేయవచ్చు. server default కంటే ఒక model కు వేరే window అవసరమైనప్పుడు ఇది ఉపయోగకరంగా ఉంటుంది:

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

పనిచేసే setup అయినా అర్థంలేని ఫలితాలను ఎందుకు ఇస్తుంది

ఇది ముఖ్యమైన section. Ollama తాను గుర్తించగల GPUల మొత్తం VRAM (GPUలలోని video memory) ఆధారంగా default context length ను ఎంచుకుంటుంది. గుర్తించిన ప్రతి GPU కోసం OLLAMA_GPU_OVERHEAD ను తీసివేస్తుంది. Implementation ఈ thresholds ను ఉపయోగిస్తుంది:

చార్ట్Ollama default context length by aggregate VRAM, checked 2026-10-26
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
  {
    "label": "Under 23 GiB aggregate VRAM",
    "default_context_tokens": "4,096"
  },
  {
    "label": "23 to under 47 GiB aggregate VRAM",
    "default_context_tokens": "32,768"
  },
  {
    "label": "47 GiB aggregate VRAM or more",
    "default_context_tokens": "262,144"
  }
]

చాలా VPS plans, అలాగే CPU-only serverలు, మొదటి rowలోకి వస్తాయి: 4,096 tokens. అనేక చిన్న GPUలు కలిపి చివరి rowలోని 47 GiB threshold ను చేరవచ్చు. దాంతో 262,144 tokens లభిస్తాయి.

Agent ఏ పని ప్రారంభించకముందే 4096 tokens పంపుతుంది. System prompt, tool definitions, repository listing, అలాగే అది తెరిచే మొదటి file కూడా ఇప్పటికే అంతకంటే పెద్దవిగా ఉంటాయి. తరువాత జరిగేదే అసలు సమస్య: ఎలాంటి error కనిపించదు. Window పరిమితిని మించే context ను Ollama నిశ్శబ్దంగా తొలగిస్తుందని Aider documentation చెబుతుంది. పాత tokens బయటకు తొలగిపోతాయి. అందువల్ల model తాను ఇక చూడలేని file గురించి కూడా నమ్మకంగా సమాధానం ఇస్తుంది లేదా రెండు steps ముందు మీరు ఇచ్చిన instruction ను మరిచిపోతుంది. Local model code రాయడంలో చాలా బలహీనంగా ఉందని వచ్చే reports లో ఎక్కువ భాగం ఈ mechanism వల్లే వస్తాయి. ఈ సంఖ్యను ఎంచుకోవడం కూడా ప్రత్యేక నిర్ణయం. ఒక పరిమాణంలో KV cache memoryకి num_ctx ఎంత ఖర్చవుతుందో ఎంచుకునే ముందు చదవడం ఉపయోగకరం.

Agents మరియు coding tools వంటి tasks కోసం కనీసం 64000 tokens సెట్ చేయాలని Ollama documentation చెబుతుంది. దీన్ని serverలో సెట్ చేయండి:

sudo systemctl edit ollama.service

Override fileలో ఈ lines చేర్చండి:

[Service]
Environment="OLLAMA_CONTEXT_LENGTH=64000"

తరువాత reload చేసి restart చేయండి:

sudo systemctl daemon-reload
sudo systemctl restart ollama
ollama ps

Restart తర్వాత మీ agent నుంచి ఒక request పంపండి. తరువాత ollama ps ను మళ్లీ run చేయండి, తద్వారా పరిశీలించడానికి loaded model ఉంటుంది. ollama ps అనేది పరిశీలించాల్సిన check. ఇది CONTEXT column ను చూపిస్తుంది. ఆ సంఖ్య model వాస్తవంగా అందుకున్న context length. మీ ID మరియు SIZE విలువలు వేరుగా ఉంటాయి:

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

దీన్ని agentలో కాకుండా serverలో సెట్ చేయండి. దీనికి రెండు కారణాలు ఉన్నాయి. OpenAI chat completions schemaలో context length కోసం field లేదు. అందువల్ల OpenAI-compatible client దీనిని అడగలదు. అలాగే model లేదా request దాన్ని override చేయనంత వరకు server default ప్రతి agentకు వర్తిస్తుంది. Outputకు ప్రత్యేక ceiling ఉంటుంది. Context lengthకు భిన్నంగా ఇది compatibility endpoint ద్వారా పంపబడుతుంది. అందువల్ల patch మధ్యలో reply ఆగిపోయినప్పుడు ఉపయోగించాల్సింది num_predict మరియు దానికి mapping అయ్యే max_tokens field. ఒక modelకు వేరే window అవసరమైతే, Modelfileతో దాని copyలో ఆ పరిమితిని ముందుగానే సెట్ చేయండి:

FROM qwen3-coder:30b
PARAMETER num_ctx 65536
ollama create qwen3-coder-64k -f Modelfile

Context ఉచితం కాదు. పొడవైన windowకు ఎక్కువ memory అవసరం. అందువల్ల PROCESSOR columnను monitor చేయండి. 100% GPU మీకు కావాల్సినది. Modelలో కొంత భాగం CPUపైకి వెళ్లిన వెంటనే token rate గణనీయంగా పడిపోతుంది. అప్పుడు agent loop ఉపయోగించలేనిదిగా మారుతుంది. మీ machineకు వాస్తవమైన పరిమితిని తెలుసుకోవడానికి local LLMలో tokens per secondను కొలవడం ఉపయోగపడుతుంది. Machine కొనుగోలు చేయకముందే దాని sizing ఎలా చేయాలో coding agent కోసం VPSకు ఎంత RAM మరియు CPU అవసరమో వివరించబడింది.

అభ్యర్థనల మధ్య మోడల్‌ను లోడ్‌డ్‌గా ఉంచడం

డిఫాల్ట్‌గా, చివరి అభ్యర్థన తర్వాత 5 నిమిషాలకు Ollama మోడల్‌ను unload చేస్తుంది. Chat box కోసం ఇది సరైనదే, కానీ agent పనికి సరైంది కాదు. మీరు diff చదవడానికి కొద్దిసేపు ఆగుతారు. Timer ముగుస్తుంది. తరువాతి అభ్యర్థనలో మొదటి token కనిపించే ముందు disk నుంచి పదుల gigabytes weights‌ను మళ్లీ load చేయాలి. ఇది hang అయినట్లుగా కనిపిస్తుంది.

OLLAMA_KEEP_ALIVE, 10m లేదా 24h వంటి duration string, seconds‌లో plain number, మోడల్‌ను నిరవధికంగా loaded‌గా ఉంచడానికి -1, లేదా వెంటనే unload చేయడానికి 0 ను స్వీకరిస్తుంది. దీన్ని context length పక్కన సెట్ చేయండి:

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

keep_alive request field Ollama యొక్క native /api/generate మరియు /api/chat endpoints‌లో, అలాగే /v1/chat/completions పై Ollama extension‌గా అందుబాటులో ఉంటుంది. అదనపు request fields‌ను అందించే agent దాన్ని అక్కడ పంపగలదు. లేకపోతే environment variable‌ను ఉపయోగించండి. Memoryను తిరిగి అవసరమైనప్పుడు, server‌ను ఆపకుండా ollama stop qwen3-coder:30b మోడల్‌ను unload చేస్తుంది. ఈ setting reboot తర్వాత కూడా కొనసాగాలనుకుంటే, లేదా రోజంతా weights‌ను memoryలో ఉంచడం మరియు ఆ memoryను తిరిగి పొందడం మధ్య నిర్ణయించాలనుకుంటే, Ollama మోడల్‌ను memoryలో loaded‌గా ఉంచడం రెండింటి ద్వారా పనిచేస్తుంది.

వేరే సర్వర్‌పై Ollama నడపడం

Ollama localhost కు bind అవుతుంది. మరో machine నుంచి దాన్ని చేరుకోవాలంటే, అదే systemd override లో OLLAMA_HOST=0.0.0.0:11434 ను సెట్ చేసి service ను restart చేయండి.

దీన్ని private network లో మాత్రమే చేయండి. స్థానిక API కోసం authentication అవసరం లేదని Ollama documentation పేర్కొంటుంది. అందువల్ల port 11434 ను internet కు open చేస్తే, ఎవరైనా మీ hardware ను ఉపయోగించగలరు. రెండు సురక్షితమైన ఎంపికలు ఉన్నాయి. bind ను localhost పై ఉంచి, మీ laptop నుంచి SSH ద్వారా port ను forward చేయండి:

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

మీ agent http://localhost:11434/v1 ను లక్ష్యంగా చేసుకుంటూనే ఉంటుంది. దానికి ఎలాంటి తేడా తెలియదు. మరో ఎంపిక VPN. ఈ సందర్భంలో Ollama ను 0.0.0.0 కు బదులుగా VPN address పై bind చేయండి. ఒకే box ను పలువురు వ్యక్తులు లేదా అనేక agents పంచుకోబోతే, memory అందుబాటులో ఉన్నంత వరకు Ollama parallel requests కు మద్దతు ఇస్తుంది. 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) సంబంధించిన పరిమితి.

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

విఫలత పరిస్థితులు, మీరు చూసే strings

curl: (7) Failed to connect to localhost port 11434 after 0 ms: Connection refused. సర్వర్ నడవడం లేదు లేదా agent వేరే host కు సూచించబడింది. ముందుగా systemctl status ollama ను అమలు చేసి, తరువాత journalctl -e -u ollama ను అమలు చేయండి.

agent model లేదని నివేదిస్తుంది. మీ config లోని పేరు server అందించే పేరుతో సరిపోలడం లేదు. దాన్ని curl http://localhost:11434/v1/models తో పోల్చి, అక్కడి string ను కాపీ చేయండి. tag కూడా పేరులో భాగమే. మీరు ఎప్పుడూ pull చేయని tag ను config లో పేర్కొంటే, ఇన్‌స్టాల్ చేసినది సమానమైన model అయినప్పటికీ అది విఫలమవుతుంది.

agent prose లో సమాధానం ఇస్తుంది, కానీ file ను ఎప్పుడూ సవరించదు. model కు tool support లేకపోవచ్చు లేదా request మరియు దాని tool definitions కలిపి context window ను ఇప్పటికే నింపి ఉండవచ్చు. model page లోని tools label ను పరిశీలించండి. తరువాత ollama ps లోని CONTEXT column ను పరిశీలించండి.

మొదటి token రావడానికి ముందు ఎక్కువసేపు నిశ్శబ్దంగా ఉండి, తరువాత సాధారణ వేగంతో పనిచేస్తుంది. keep-alive గడువు ముగిసింది. అందువల్ల weights ను disk నుంచి మళ్లీ చదువుతోంది. OLLAMA_KEEP_ALIVE ను సెట్ చేయండి.

తాను ఇప్పుడే చదివిన file కు model విరుద్ధంగా సమాధానం ఇస్తుంది. ఇది context truncation. ollama ps సాధారణంగా మీరు సెట్ చేశానని అనుకున్నదానికంటే చిన్న CONTEXT విలువను చూపిస్తుంది. కారణం environment variable మీ shell కు వెళ్లి systemd unit కు వెళ్లకపోవడమే.

అన్నీ పనిచేస్తాయి, కానీ నెమ్మదిగా ఉంటాయి; PROCESSOR లో 100% CPU లేదా CPU/GPU split కనిపిస్తుంది. సాధారణంగా model మరియు దాని context VRAM లో సరిపోవు. GPU ఉన్న machine లో PROCESSOR లో 100% CPU కనిపిస్తే, ముందుగా ఇతర కారణాన్ని తొలగించండి: Ollama కు GPU అసలు కనిపించకపోయి ఉండవచ్చు. Linux లో suspend/resume cycle తరువాత NVIDIA GPU ను కనుగొనడంలో కొన్నిసార్లు విఫలమై CPU కి fallback అవుతుందని Ollama documentation పేర్కొంటుంది. sudo rmmod nvidia_uvm && sudo modprobe nvidia_uvm తో driver ను reload చేయడం ఈ సమస్యను పరిష్కరించవచ్చు. GPU కనిపించినా split అలాగే ఉంటే context length ను తగ్గించండి లేదా చిన్న model కు, ఇంకా చిన్న quantisation కు మారండి. మళ్లీ pull చేయడానికి ముందు, q4_K_M, q8_0 మరియు fp16 ప్రతి ఒక్కటి memory లో ఎంత స్థలం తీసుకుంటాయో, quality వాస్తవంగా ఎక్కడ తగ్గుతుందో తెలిపే వివరణను చూడండి. దానివల్ల ఒక స్థాయి తగ్గితే ఎంత స్థలం లభిస్తుందో, దానికి బదులుగా మీరు ఏమి కోల్పోతారో తెలుసుకోవచ్చు. Unknown కూడా సాధ్యమైన PROCESSOR విలువ కావచ్చు; అయితే అది CPU offloading జరుగుతోందని నిర్ధారించదు.

FAQ

Claude Code ను Ollama వైపు సూచించవచ్చా?

అవును, కానీ OpenAI-compatible URL తో కాదు. Claude Code, Anthropic Messages API ను ఉపయోగిస్తుంది. Ollama అదే port 11434 పై /v1/messages వద్ద ఆ ఆకృతిని అందిస్తుంది. ANTHROPIC_BASE_URL=http://localhost:11434, ANTHROPIC_AUTH_TOKEN=ollama మరియు ఖాళీ ANTHROPIC_API_KEY ను export చేసి, దాన్ని claude --model qwen3-coder:30b తో ప్రారంభించండి. ollama launch claude ఈ settings ను మీ కోసం రాస్తుంది. ఈ compatibility layer tool_choice లేదా prompt caching ను అమలు చేయదు. దీనికి token counting endpoint కూడా లేదు. అందువల్ల చూపించే token counts సుమారు విలువలు మాత్రమే.

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

Request context window లో ఇక సరిపోకపోవడం వల్ల ఇది జరుగుతుంది. దాని పాత భాగం ఎటువంటి error లేకుండా తొలగించబడుతుంది. ప్రతి GPUకి configure చేసిన overhead ను తీసివేసిన తర్వాత గుర్తించిన మొత్తం VRAM ఆధారంగా Ollama తన default context ను నిర్ణయిస్తుంది: 23 GiB కంటే తక్కువగా ఉంటే default 4,096 tokens, 23 నుంచి 47 GiB కంటే తక్కువ వరకు 32,768 tokens, 47 GiB లేదా అంతకంటే ఎక్కువగా ఉంటే 262,144 tokens. systemd unit లో OLLAMA_CONTEXT_LENGTH=64000 ను సెట్ చేసి, Ollama ను restart చేయండి. తరువాత ollama ps లోని CONTEXT column కొత్త విలువను చూపిస్తోందని నిర్ధారించండి.

VPS పై coding agent కోసం ఏ model ను అమలు చేయాలి?

tools label ఉన్న models లో, 64k context window తో memory లో సరిపోయే అతిపెద్ద model ను ఎంచుకోండి. Code కోసం ప్రత్యేకంగా tune చేసిన model కు ప్రాధాన్యత ఇవ్వండి. తగినంత VRAM ఉన్న GPU server పై సాధారణ ఎంపిక qwen3-coder:30b. ఆ tag మీ server కు చాలా పెద్దదైతే, download చేయడానికి ముందుగా Nemotron 3.5 Lightning కోసం RAM గణాంకాలు మరియు CPU-only వేగాలు ఉపయోగకరమైన పోలికను అందిస్తాయి. సుమారు 14B parameters కంటే తక్కువ ఉన్న model code గురించి ప్రశ్నలకు బాగా సమాధానం ఇవ్వగలదు. అయినా multi-step edits సమయంలో విఫలమయ్యే అవకాశం ఉంటుంది. Tool calls లో చిన్న formatting mistakes కూడా agent పనిని ప్రభావితం చేస్తాయి. Sample prompt కు బదులుగా మీ స్వంత repository నుంచి ఒక నిజమైన task తో పరీక్షించండి.

నా సొంత model పై coding agent ను అమలు చేయడానికి GPU అవసరమా?

ఆచరణలో అవును. CPU-only inference పనిచేస్తుంది. ఒక్కో ప్రశ్నకు అది సరిపోతుంది. కానీ ఒక task కు agent అనేక requests పంపుతుంది. ప్రతి request దీర్ఘమైన history ను మళ్లీ చదువుతుంది. అందువల్ల token rate తక్కువగా ఉంటే రెండు నిమిషాల task ఒక గంట పడుతుంది. ollama ps లోని PROCESSOR column ను పరిశీలించండి: 100% CPU లేదా CPU/GPU split కనిపిస్తే CPU వినియోగం జరుగుతోందని అర్థం. ఇది inference ను నెమ్మదిస్తుంది. Unknown CPU offloading జరుగుతోందని నిర్ధారించదు.

ఈ వ్యాసం ఉపయోగకరంగా ఉందా?

#ollama#coding-agent#openai-compatible#local-llm#self-hosted-ai