Ollama ను coding agent తో ఎలా ఉపయోగించాలి

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

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

Ollama port 11434 పై listening చేస్తూ, ఒకేసారి రెండు request రూపాలను అందిస్తుంది. /v1/chat/completions OpenAI-compatible రూపం. అక్కడి key ను required గా పేర్కొన్నప్పటికీ, దాన్ని ignore చేస్తామని Ollama documentation వివరిస్తుంది. /v1/messages Anthropic-compatible రూపం. Claude Code ఇదే రూపంలో requests పంపుతుంది. మీ agent ఇప్పటికే ఈ రెండింటిలో ఒక రూపాన్ని ఉపయోగిస్తోంది. అందువల్ల దానిలో మరే మార్పు అవసరం లేదు.

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

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

పరీక్ష ఒకే ప్రశ్నపై ఆధారపడి ఉంటుంది: ఆ tool base URL setting ను అందిస్తుందా? అందిస్తే, అది మీ server తో మాట్లాడగలదు.

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

• చాలా 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 కు set చేయాలి. Ollama ఈ endpoint ను /v1/messages వద్ద అందిస్తుంది.
• Codex OpenAI Responses API ను ఉపయోగిస్తుంది. Ollama /v1/responses ను కూడా అందిస్తుంది. ఈ support version 0.13.3 లో చేర్చబడింది.
• Base URL setting లేని agent ను redirect చేయలేరు, ఎందుకంటే endpoint client లోనే నిర్మించబడి ఉంటుంది. బదులుగా ముందు ఒక translation layer ఉంచండి. ఉదాహరణకు self-hosted LiteLLM gateway ను ఉపయోగించి, client కోరే రూపంలో మీ model ను మళ్లీ expose చేయవచ్చు.

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

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 కారణాన్ని చూపుతుంది.

Tool calling కు model మద్దతు ఇవ్వాలి, ఎందుకంటే agent పనిచేసే విధానం అదే. అది file ను చదివి, patch ను రాసి, test ను అమలు చేస్తుంది. తరువాత వచ్చిన failure ను చదివి, మళ్లీ ప్రయత్నిస్తుంది. Tool call ను ఉత్పత్తి చేయలేని model మార్పును అమలు చేయకుండా prose లో వివరిస్తుంది. దాంతో agent loop లో ఇరుక్కుపోవచ్చు లేదా ఆగిపోవచ్చు. Pull చేయడానికి ముందు ollama.com లోని model page పై tools label ఉందో చూడండి. qwen3-coder:30b లో ఈ label ఉంది. August 2026 నాటికి, ఆ tag పరిమాణం 19 GB. దాని context window 256K. మీ box CPU-only అయితే లేదా RAM తక్కువగా ఉంటే, download ప్రారంభించే ముందు 8 నుంచి 64 GB లో వాస్తవంగా ఏది సరిపోతుందో VPSలో Qwen 27B tag కోసం memory లెక్కలు చూపిస్తాయి.

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

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

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

Ollama కు OpenCode ను సూచించండి

~/.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 కింద ఉన్న key అనేది Ollama కు పంపే model name. అందువల్ల అది ollama ls తో ఖచ్చితంగా సరిపోవాలి. name field అనేది model picker లో కనిపించే label మాత్రమే. opencode ను ప్రారంభించి, Ollama provider కు మారండి. అభ్యర్థన వేరే చోటుకు కాకుండా మీ server కు వచ్చిందని నిర్ధారించడానికి journalctl -e -u ollama ను monitor చేయండి. Agent ను స్వయంగా ఏర్పాటు చేసే విధానం VPS పై OpenCode నడపడం లో వివరించబడింది.

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

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 గా సెట్ చేశారు. Environment లో నిజమైన key ఉంటే, మీ అభ్యర్థనలు hosted API కు పంపబడతాయి. దాంతో మీకు బిల్లు వస్తుంది, local inference జరగదు. 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 ను ఉపయోగించమని సిఫార్సు చేస్తుంది. అలాగే .aider.model.settings.yml లో ప్రతి model కు context window ను నిర్దిష్టంగా సెట్ చేయవచ్చు. ఒక model కు server default కంటే భిన్నమైన window అవసరమైనప్పుడు ఇది ఉపయోగకరంగా ఉంటుంది:

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

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

ఇదే ముఖ్యమైన విభాగం. Ollama తాను గుర్తించగలిగే VRAM (GPUలోని video memory) ఆధారంగా default context length ను ఎంచుకుంటుంది. ఆ default విలువలు ఇలా ప్రచురించబడ్డాయి:

[
  {
    "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 plans, అలాగే CPU-only serverలు, మొదటి వరుసలోకి వస్తాయి: 4,096 tokens. చివరి వరుసలోని 262,144 tokens ను పెద్ద GPU మాత్రమే అందిస్తుంది.

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

Agents మరియు coding tools వంటి పనులకు కనీసం 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

ollama ps అనేది తనిఖీ. ఇది CONTEXT column ను చూపిస్తుంది. ఆ సంఖ్య model వాస్తవంగా అందుకున్న context length. మీ ID మరియు SIZE విలువలు భిన్నంగా ఉంటాయి:

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

దీన్ని agentలో కాకుండా serverలో సెట్ చేయండి. దీనికి రెండు కారణాలు ఉన్నాయి. OpenAI chat completions schemaలో context length కోసం field లేదు. అందువల్ల OpenAI-compatible client అలాంటి విలువను అడగలేదు. రెండవది, ఈ setting server స్థాయిలో ఉంటుంది. కాబట్టి మీరు ఆ serverకు అనుసంధానించే ప్రతి agent దాన్ని స్వయంగా పొందుతుంది. ఒక modelకు వేరే window అవసరమైతే, Modelfileతో copyలో ఆ విలువను చేర్చండి:

FROM qwen3-coder:30b
PARAMETER num_ctx 65536

ollama create qwen3-coder-64k -f Modelfile

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

అభ్యర్థనల మధ్య model ను loaded స్థితిలో ఉంచండి

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

OLLAMA_KEEP_ALIVE కు 10m లేదా 24h వంటి duration string, seconds ను సూచించే సాధారణ సంఖ్య, model ను నిరవధికంగా 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 లో మాత్రమే ఉంటుంది. ఇది compatibility endpoints లో ఉండదు. అందువల్ల agent దీన్ని ప్రతి request కు విడిగా సెట్ చేయలేడు. మీ వద్ద ఉన్న ఏకైక నియంత్రణ environment variable. memory ను తిరిగి ఖాళీ చేయాల్సినప్పుడు, server ను ఆపకుండా ollama stop qwen3-coder:30b model ను unload చేస్తుంది.

వేరే సర్వర్‌పై 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 ను ఉపయోగించవచ్చు. మీ agent పంపే సమాచారాన్ని కూడా చదవవచ్చు. రెండు సురక్షితమైన ఎంపికలు ఉన్నాయి. 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 పంచుకుంటే, ఆ load కోసం Ollama scheduler రూపొందించబడలేదు. Ollama మరియు vLLM మధ్య పోలిక throughput తేడా ప్రభావం చూపడం ఎక్కడ ప్రారంభమవుతుందో వివరిస్తుంది.

స్థానిక coding model ఎక్కడ మెరుగ్గా ఉంటుంది, ఎక్కడ ఉండదు

మీరు host చేసే model తో నడిచే agent ప్రతి పనిలోనూ frontier API కి ప్రత్యామ్నాయం కాదు. ఈ నాలుగు రకాల పనుల్లో అది స్పష్టంగా మెరుగ్గా ఉంటుంది.

• భారీ పరిమాణంలోని యాంత్రిక మార్పులు, అందులో ప్రతి మార్పు చిన్నదిగా ఉండి, మీరు వాటిని తనిఖీ చేయగలిగితే. Repository అంతటా పేర్లను మార్చడం, type hints జోడించడం, docstrings రాయడం, comments అనువదించడం వంటి పనులు ఇందులోకి వస్తాయి. Model గంటల తరబడి నడిచినా బిల్లు పెరగదు.
• మీ hardware బయటకు వెళ్లకూడని పని. Confidentiality agreement కింద ఉన్న client code లేదా third partyకి పంపడానికి మీకు అనుమతి లేని internal repository ఇందుకు ఉదాహరణలు.
• Hosted APIని అసలు పిలవలేని offline మరియు air-gapped machines.
• ముందే అంచనా వేయగల ఖర్చు. Server కోసం ఒకసారి చెల్లించిన తర్వాత, loopలో tokens వినియోగించే agentకు అదనపు ఖర్చు ఉండదు. Metered API విషయంలో దీనికి పూర్తి విరుద్ధంగా ఉంటుంది. GPU VPS API tokensతో సమతుల్య స్థితికి వచ్చే విధానం లో లెక్కలు ఉన్నాయి.

దీర్ఘమైన, అనేక దశల పనుల్లో ఇది బలహీనంగా ఉంటుంది. “ఈ test ఎందుకు విఫలమవుతుందో కనుగొని, కారణాన్ని సరిచేసి, callersను update చేయండి” అనే పనికి వరుసగా అనేక సరైన tool calls అవసరం. మొత్తం చరిత్ర కూడా contextలో ఉండాలి. పరిమిత serverపై 8B నుంచి 14B పరిధిలోని model malformed tool call రూపొందించవచ్చు లేదా కొన్ని turns తర్వాత planను కోల్పోవచ్చు. అప్పుడు ఆ పనికి పట్టే సమయం కంటే ఎక్కువ సమయం దాన్ని దిశానిర్దేశం చేయడానికే వెచ్చించాల్సి వస్తుంది. దీన్ని promptతో మాత్రమే పరిష్కరించలేరు. సమస్య model capacityలో ఉంది.

తప్పు ఖరీదైనదిగా ఉండి, మీరు ప్రతి lineను చదవని సందర్భాల్లో కూడా ఇది బలహీనంగా ఉంటుంది. Outputను మీరు verify చేయగలిగే narrow jobs మాత్రమే local modelకు ఇవ్వండి. ప్రతి దశను తనిఖీ చేయని పనుల కోసం hosted modelను ఉపయోగించండి.

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

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 లోని పేరు సర్వర్ అందించే పేరుతో సరిపోలడం లేదు. దాన్ని curl http://localhost:11434/v1/models తో పోల్చి, అక్కడి string ను కాపీ చేయండి. tag కూడా పేరులో భాగమే. కాబట్టి మీరు ఎప్పుడూ pull చేయని tag ను config లో పేర్కొంటే, ఇన్‌స్టాల్ అయిన model కు సమానమైన మరో 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 value ను చూపిస్తుంది. కారణం environment variable systemd unit కు కాకుండా మీ shell కు సెట్ కావడమే.

అన్నీ పనిచేస్తున్నాయి, కానీ నెమ్మదిగా ఉన్నాయి; PROCESSOR, 100% GPU కాదు. Model మరియు దాని context VRAM లో సరిపోవడం లేదు. Context length ను తగ్గించండి లేదా చిన్న model కు, లేక చిన్న quantisation కు మారండి.

FAQ

నేను Claude Code ను Ollama కు point చేయవచ్చా?

అవును, కానీ OpenAI-compatible URL తో కాదు. Claude Code, Anthropic Messages API ను ఉపయోగిస్తుంది. Ollama అదే ఆకృతిని 11434 port పై /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 లేకుండా తొలగించబడింది. Ollama తన default context ను గుర్తించిన VRAM ఆధారంగా అమర్చుతుంది. 24 GiB కంటే తక్కువ VRAM ఉన్నప్పుడు ఆ default 4,096 tokens. Agent యొక్క system prompt మరియు tool definitions మాత్రమే దీనిని మించిపోతాయి. systemd unit లో OLLAMA_CONTEXT_LENGTH=64000 ను సెట్ చేసి, Ollama ను restart చేయండి. తరువాత ollama ps లోని CONTEXT column కొత్త విలువను చూపిస్తోందని నిర్ధారించండి.

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

tools label ఉన్న, 64k context window తో memory లో సరిపోయే అతిపెద్ద model ను ఎంచుకోండి. Code కోసం tune చేసిన model కు ప్రాధాన్యత ఇవ్వండి. తగినంత VRAM ఉన్న GPU server పై qwen3-coder:30b సాధారణ ఎంపిక. సుమారు 14B parameters కంటే తక్కువ ఉన్న model code గురించి ప్రశ్నలకు బాగా సమాధానం ఇవ్వగలదు. అయితే multi-step edits సమయంలో విఫలమవచ్చు. Tool calls లోని చిన్న formatting తప్పిదాలను 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% GPU కాకుండా ఏ విలువ ఉన్నా, model లో కొంత భాగం CPU పై నడుస్తోందని అర్థం. దాంతో token rate గణనీయంగా తగ్గుతుంది.