Paano Gamitin ang Ollama sa Coding Agent

Ang ikokonekta mo

Magagamit mo ang Ollama kasama ng coding agent mo, at mas kaunti ang kailangang baguhin kaysa sa inaakala ng karamihan. Papalitan mo ang isang base URL at pipili ka ng isang model name. Nangangailangan pa rin ng value ang API key field, pero binabalewala ito ng local server, kaya anumang string ang puwedeng gamitin.

Nakikinig ang Ollama sa port 11434 at sabay na naghahatid ng dalawang request shape. Ang /v1/chat/completions ay ang OpenAI-compatible shape, at inilalarawan ng documentation ng Ollama na required pero binabalewala ang key nito. Ang /v1/messages ay ang Anthropic-compatible shape, na ginagamit ng Claude Code. Marunong na ang agent mo sa isa sa dalawang ito, kaya walang ibang bahagi nito ang kailangang baguhin.

Limang minuto lang ang bahaging ito. Nakadepende kung magagamit ang resulta sa dalawang setting na halos walang nagbabago: ang context length at ang keep-alive. Nakadepende rin ito sa pagbibigay sa model ng uri ng trabahong mahusay nitong gawin. May sariling section ang bawat isa, at nasa dulo ang tapat na paglalarawan ng mga limitasyon nito.

Aling coding agent ang tumatanggap ng local base URL

Isang tanong lang ang pagsusuri: may setting ba ang tool para sa base URL? Kung mayroon, maaari itong makipag-ugnayan sa iyong server.

Naglalathala ang Ollama ng mga integration page para sa Claude Code, OpenCode, Codex, Cline, Roo Code, Zed, JetBrains IDEs, at VS Code. Hiwalay namang idinodokumento ng Aider ang sariling suporta nito sa Ollama. Saklaw nito ang karamihan sa tinutukoy ng mga tao bilang coding agent noong August 2026. Hindi pare-pareho ang format na ginagamit nila, at dito karaniwang nagkakaroon ng problema ang mga setup.

• Karamihan sa mga agent ay nangangailangan ng OpenAI-compatible endpoint. Ibigay sa kanila ang base URL http://localhost:11434/v1 at anumang non-empty na API key string.
• Hindi talaga tumatanggap ang Claude Code ng OpenAI base URL. Gumagamit ito ng Anthropic Messages API, kaya kailangang itakda ang ANTHROPIC_BASE_URL sa http://localhost:11434, kung saan inihahain ng Ollama ang /v1/messages.
• Gumagamit ang Codex ng OpenAI Responses API. Inihahain din ng Ollama ang /v1/responses, na idinagdag sa version 0.13.3.
• Hindi maaaring i-redirect ang agent na walang setting para sa base URL dahil built-in sa client ang endpoint. Maglagay na lang ng translation layer sa harap nito, gaya ng self-hosted LiteLLM gateway, at i-expose muli ang iyong model sa format na hinihingi ng client.

Maaaring isulat ng Ollama ang mga config na ito para sa iyo. Binubuksan ng ollama launch opencode ang OpenCode gamit ang inline config para sa model na pipiliin mo, ganoon din ang ginagawa ng ollama launch claude para sa Claude Code, at isinusulat ng ollama launch droid --config ang config nang hindi binubuksan ang tool.

Mag-install ng Ollama at mag-pull ng model na maaaring tumawag sa tools

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

Nagdaragdag ang installer ng systemd unit at sinisimulan ito, kaya dapat mag-print ang systemctl status ollama ng active (running). Kung hindi, ipinapakita ng journalctl -e -u ollama ang dahilan.

Dapat suportahan ng model ang tool calling dahil ito ang paraan ng paggana ng isang agent. Nagbabasa ito ng file, nagsusulat ng patch, nagpapatakbo ng test, pagkatapos ay binabasa ang failure at sumusubok muli. Ang model na hindi makapaglabas ng tool call ay maglalarawan sa prose ng edit sa halip na aktuwal itong gawin, kaya maglo-loop o hihinto ang agent. Hanapin ang label na tools sa page ng model sa ollama.com bago mo itong i-pull. Taglay ito ng qwen3-coder:30b, at noong August 2026, ang tag na iyon ay 19 GB na download na may 256K context window. Kung CPU-only ang box mo o kulang ang RAM, ipinapakita ng memory arithmetic para sa Qwen 27B tag sa isang VPS kung ano ang aktuwal na kasya sa 8 hanggang 64 GB bago mo gastusin ang download. Kapag na-pull mo na ito, mapupunta ang mga gigabyte na iyon sa root disk ng server. Ito ang bahagi ng VPS na may pinakamaliit na ekstrang espasyo, kaya sulit basahin ang kung saan iniimbak ng Ollama ang mga model file at kung paano ilipat ang mga ito sa ibang lokasyon bago mapuno ang disk.

Ngayon, kumpirmahin kung aling mga pangalan ang aktuwal na sine-serve ng server:

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

Ang mga string sa response na iyon ang dapat ilagay ng agent config mo, character for character. Kapag sinuri mo muna ito, nalulutas ang karamihan ng mga error na model-not-found. Kung hindi pa naka-install ang Ollama, nasa self-hosting ng LLM gamit ang Ollama sa isang VPS ang mas mahabang walkthrough.

Ituro ang OpenCode sa Ollama

I-edit ang ~/.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"
        }
      }
    }
  }
}

Ang key sa ilalim ng models ay pangalan ng model na ipinapadala sa Ollama, kaya dapat eksaktong tumugma ito sa ollama ls. Label lamang sa model picker ang field na name. Simulan ang opencode, lumipat sa Ollama provider, at i-monitor ang journalctl -e -u ollama upang kumpirmahing nakarating ang request sa server mo at hindi sa ibang lokasyon. Saklaw ng pagpapatakbo ng OpenCode sa isang VPS ang pag-set up mismo ng agent.

Ituro ang Claude Code sa Ollama

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

Sadyang itinakda ang ANTHROPIC_API_KEY bilang empty string. Kapag may totoong key sa environment, sa hosted API nito ipinapadala ang mga request mo. Dahil dito, magkakaroon ka ng bill at walang local inference. Awtomatikong itinatakda ng ollama launch claude ang lahat ng ito.

Alamin kung ano ang hindi kasama sa compatibility layer. Hindi nito ini-implement ang tool_choice o prompt caching. Wala rin itong token counting endpoint, kaya mga approximation lamang ang token number na nakikita mo mula sa sariling tokenizer ng model. Nagpapadala rin ang Claude Code ng malaking system prompt at malaking tool set. Dahil dito, mas marami itong kinakailangang context kaysa sa isang chat client. Tinalakay sa kung maaari mong i-self-host ang Claude ang mas malawak na tanong tungkol sa kung ano ang naililipat at kung ano ang hindi.

Ituro ang Aider sa Ollama

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

Inirerekomenda ng dokumentasyon ng Aider ang prefix na ollama_chat/ kaysa sa ollama/. Maaari mo ring itakda ang context window ng bawat model sa .aider.model.settings.yml. Kapaki-pakinabang ito kapag nangangailangan ang isang model ng ibang window kaysa sa default ng server:

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

Bakit naglalabas pa rin ng walang saysay na resulta ang gumaganang setup

Ito ang mahalagang bahagi. Pinipili ng Ollama ang default context length batay sa VRAM (video memory ng GPU) na nakikita nito, at nakapublish ang mga default na ito:

[
  {
    "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"
  }
]

Karamihan ng VPS plan, pati lahat ng CPU-only server, ay nasa unang row: 4,096 token. Malaking GPU lamang ang nakakagamit ng 262,144 token sa huling row.

Nagpapasa ang isang agent ng 4096 token bago pa ito gumawa ng anumang gawain. Mas mahaba na rito ang system prompt, mga tool definition, listing ng repository, at unang file na binubuksan nito. Dito nagsisimula ang buong problema: walang error na lumalabas. Ayon sa documentation ng Aider, tahimik na itinatapon ng Ollama ang context na lumalampas sa window. Nawawala ang pinakamatandang token, kaya may kumpiyansang sumasagot ang model tungkol sa file na hindi na nito nakikita, o nakakalimutan nito ang instruction na ibinigay mo dalawang hakbang ang nakalipas. Ito ang mekanismong nasa likod ng karamihan ng ulat na masyadong mahina para sa coding ang isang local model. Sariling desisyon din ang pagpili ng value, at makatutulong basahin ang gastos ng bawat num_ctx size sa KV cache memory bago ka pumili.

Ayon sa documentation ng Ollama, dapat itakda sa hindi bababa sa 64000 token ang mga task gaya ng agents at coding tools. Itakda ito sa server:

sudo systemctl edit ollama.service

Idagdag ang mga linyang ito sa override file:

[Service]
Environment="OLLAMA_CONTEXT_LENGTH=64000"

Pagkatapos, i-reload at i-restart:

sudo systemctl daemon-reload
sudo systemctl restart ollama
ollama ps

ollama ps ang gagamiting check. Nagpi-print ito ng column na CONTEXT, at ang numerong iyon ang aktuwal na natanggap ng model. Magkakaiba ang iyong ID at SIZE:

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

Itakda ito sa server sa halip na sa agent sa dalawang dahilan. Walang field para sa context length ang OpenAI chat completions schema, kaya hindi makakahingi nito ang isang OpenAI-compatible client. Per server din ang setting, kaya mamamana ito ng bawat agent na ikokonekta mo sa server. May sarili namang limit ang output, at hindi gaya ng context length, ipinapadala ito sa compatibility endpoint. Kaya ang num_predict at max_tokens field na tumutugma rito ang dapat gamitin kapag napuputol sa kalagitnaan ng patch ang isang reply. Kung nangangailangan ng ibang window ang isang model, ilagay ito sa isang kopya gamit ang Modelfile:

FROM qwen3-coder:30b
PARAMETER num_ctx 65536

ollama create qwen3-coder-64k -f Modelfile

Hindi libre ang context. Mas maraming memory ang kailangan ng mas mahabang window, kaya bantayan ang column na PROCESSOR. 100% GPU ang kailangan mo. Kapag napunta sa CPU ang bahagi ng model, sapat na bumabagal ang token rate para maging hindi na magamit ang agent loop, at ang pagsukat ng tokens per second sa isang local LLM ang paraan para malaman ang aktuwal na limitasyon ng server mo. Saklaw ng kung gaano karaming RAM at CPU ang kailangan ng coding agent VPS ang pag-size ng machine bago ito bilhin.

Panatilihing naka-load ang model sa pagitan ng mga request

Bilang default, inaalis ng Ollama sa memory ang isang model 5 minuto matapos ang huling request nito. Tama ito para sa isang chat box, pero hindi para sa agent work. Hihinto ka para basahin ang isang diff, matatapos ang timer, at ire-reload ng susunod na request ang sampu-sampung gigabyte ng weights mula sa disk bago lumabas ang unang token. Mukha itong pag-hang.

OLLAMA_KEEP_ALIVE ay tumatanggap ng duration string gaya ng 10m o 24h, plain number ng mga segundo, -1 upang panatilihing naka-load ang model nang walang takdang oras, o 0 upang agad itong i-unload. Itakda ito kasabay ng context length:

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

Ang keep_alive request field ay umiiral lamang sa native na /api/generate at /api/chat endpoints ng Ollama, hindi sa compatibility endpoints, kaya hindi ito maitatakda ng agent sa bawat request. Ang environment variable lamang ang magagamit mong control. Kapag kailangan mo na ang memory, inu-unload ng ollama stop qwen3-coder:30b ang model nang hindi pinatitigil ang server. Kung gusto mong manatili ang setting pagkatapos ng reboot, o gusto mong timbangin kung pananatilihin ang weights sa memory buong araw o ibabalik ang memory na iyon, gumagana ang pagpapanatiling naka-load ng Ollama model sa memory sa parehong sitwasyon.

Pagpapatakbo ng Ollama sa hiwalay na server

Naka-bind ang Ollama sa localhost. Para maabot ito mula sa ibang machine, itakda ang OLLAMA_HOST=0.0.0.0:11434 sa parehong systemd override at i-restart ang service.

Gawin lamang ito sa private network. Ayon sa documentation ng Ollama, walang kinakailangang authentication para sa local API. Kaya kung bukas sa internet ang port 11434, maaaring gamitin ng sinuman ang hardware mo at basahin ang anumang ipinapadala ng agent mo. May dalawang ligtas na option. Panatilihin ang bind sa localhost at i-forward ang port sa pamamagitan ng SSH mula sa laptop mo:

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

Patuloy na nakaturo ang agent mo sa http://localhost:11434/v1 at hindi nito mapapansin ang pagkakaiba. Ang isa pang option ay VPN, kung saan naka-bind ang Ollama sa VPN address sa halip na sa 0.0.0.0. Kung maraming tao o maraming agent ang gagamit ng isang box, hindi idinisenyo ang scheduler ng Ollama para sa ganoong load, at ipinapakita ng paghahambing ng Ollama at vLLM kung kailan nagsisimulang maging problema ang pagkakaiba sa throughput.

Kung saan mas mahusay ang local coding model, at kung saan hindi

Hindi napapalitan ng agent na gumagamit ng model na ikaw ang nagho-host ng frontier API para sa lahat ng task. Malinaw itong mas mahusay sa apat na uri ng trabaho.

• Mga bulk mechanical edit, kung saan maliit ang bawat pagbabago at maaari mo itong suriin. Pagpapalit ng pangalan sa buong repository, pagdaragdag ng type hints, pagsulat ng docstrings, at pagsasalin ng comments. Tumatakbo ang model nang maraming oras, pero hindi nadaragdagan ang bill.
• Mga trabahong hindi dapat lumabas sa hardware mo. Halimbawa, client code na saklaw ng confidentiality agreement, o internal repository na hindi mo pinapayagang ipadala sa third party.
• Mga offline at air-gapped machine, kung saan wala talagang hosted API na maaaring tawagan.
• Predictable na gastos. Kapag bayad na ang server, walang dagdag na gastos ang agent na patuloy na gumagamit ng tokens sa isang loop. Kabaligtaran ito ng metered API. Nasa Kailan nagiging sulit ang GPU VPS kumpara sa API tokens ang kalkulasyon.

Mas mahina ito sa mahahabang multi-step task. Ang “Alamin kung bakit nagfa-fail ang test na ito, ayusin ang sanhi, at i-update ang mga caller” ay nangangailangan ng maraming magkakasunod na tamang tool call, habang nasa context pa rin ang buong history. Ang model na nasa 8B hanggang 14B range at tumatakbo sa katamtamang server ay maaaring gumawa ng malformed tool call o makalimot sa plano pagkalipas ng ilang turn. Dahil dito, mas matagal mo itong ginagabayan kaysa sa oras na gugugulin sana sa task. Hindi ito prompt problem na maaayos sa pamamagitan lamang ng mas mahusay na pagsulat. Limitasyon ito ng capacity.

Mahina rin ito kapag mahal ang kapalit ng pagkakamali at hindi mo mababasa ang bawat linya. Bigyan ang local model ng makikitid na task na mabe-verify mo ang output, at gumamit ng hosted model para sa trabahong hindi mo susuriin nang paisa-isa.

Mga failure mode at mga string na makikita mo

curl: (7) Failed to connect to localhost port 11434 after 0 ms: Connection refused. Hindi tumatakbo ang server, o nakaturo ang agent sa ibang host. Patakbuhin ang systemctl status ollama, pagkatapos ay ang journalctl -e -u ollama.

Iniulat ng agent na hindi umiiral ang model. Hindi tumutugma ang pangalan sa config sa alinman sa mga pangalang inihahatid ng server. Ihambing ito sa curl http://localhost:11434/v1/models at kopyahin ang string mula roon. Bahagi ng pangalan ang tag, kaya mabibigo ang config na tumutukoy sa tag na hindi mo kailanman na-pull kahit may naka-install na katulad na model.

Sumasagot ang agent sa prose at hindi kailanman nag-e-edit ng file. Maaaring walang tool support ang model, o napupuno na ng request at mga tool definition nito ang context window. Suriin ang label na tools sa model page, pagkatapos ay tingnan ang column na CONTEXT sa ollama ps.

Mahabang katahimikan bago lumabas ang unang token, pagkatapos ay normal ang bilis. Nag-expire ang keep-alive at muling binabasa mula sa disk ang weights. I-set ang OLLAMA_KEEP_ALIVE.

Sinasalungat ng model ang file na kakabasa lang nito. Context truncation ito. Karaniwang nagpapakita ang ollama ps ng value na CONTEXT na mas maliit kaysa sa inaakala mong na-set mo, dahil napunta ang environment variable sa shell mo sa halip na sa systemd unit.

Gumagana ang lahat pero mabagal, at ang PROCESSOR ay hindi 100% GPU. Hindi kasya sa VRAM ang model kasama ang context nito. Bawasan ang context length, o gumamit ng mas maliit na model o mas maliit na quantisation. Bago ka muling mag-pull, ipinapaliwanag sa kung magkano ang memory na ginagamit ng q4_K_M, q8_0 at fp16, at kung saan talaga bumababa ang kalidad kung gaano kalaking espasyo ang makukuha sa pagbaba ng isang antas at kung ano ang isinasakripisyo mo kapalit nito.

FAQ

Maaari ko bang i-point ang Claude Code sa Ollama?

Oo, pero hindi gamit ang OpenAI-compatible URL. Gumagamit ang Claude Code ng Anthropic Messages API, at naghahatid ang Ollama ng ganoong format sa /v1/messages sa parehong port 11434. I-export ang ANTHROPIC_BASE_URL=http://localhost:11434, ANTHROPIC_AUTH_TOKEN=ollama, at isang walang laman na ANTHROPIC_API_KEY, saka ito simulan gamit ang claude --model qwen3-coder:30b. Awtomatikong isinusulat ng ollama launch claude ang parehong mga setting para sa iyo. Hindi ipinapatupad ng compatibility layer ang tool_choice o prompt caching, at wala itong token counting endpoint, kaya pagtatantiya lamang ang mga iniulat na token count.

Bakit sumasagot ang local model ko tungkol sa code na hindi nito nakikita?

Dahil hindi na kasya ang request sa context window, at inalis ang pinakamatandang bahagi nito nang walang error. Itinatakda ng Ollama ang default context batay sa VRAM na nakikita nito. Kapag mas mababa sa 24 GiB ito, ang default ay 4,096 tokens, na nalalampasan na mismo ng system prompt at tool definitions ng isang agent. Itakda ang OLLAMA_CONTEXT_LENGTH=64000 sa systemd unit, i-restart ang Ollama, at tiyaking ipinapakita ng CONTEXT column sa ollama ps ang bagong value.

Aling model ang dapat kong patakbuhin para sa coding agent sa isang VPS?

Piliin ang pinakamalaking model na may tools label at kasya pa rin sa memory gamit ang 64k context window. Mas mainam ang model na na-tune para sa code. Ang qwen3-coder:30b ang karaniwang sagot sa GPU server na may sapat na VRAM. Kung masyadong malaki ang tag na iyon para sa server mo, makatutulong ang mga RAM figure at CPU-only speed para sa Nemotron 3.5 Lightning bilang paghahambing bago ka mag-download. Sa mga model na may humigit-kumulang 14B parameters o mas kaunti, maaari pa ring maging mahusay ang sagot sa mga tanong tungkol sa code, ngunit maaari pa ring mabigo sa mga multi-step edit. Ito ay dahil sensitibo ang agent work sa maliliit na formatting mistake sa tool calls. Subukan ito gamit ang isang aktuwal na task mula sa sarili mong repository sa halip na sample prompt.

Kailangan ko ba ng GPU para magpatakbo ng coding agent gamit ang sarili kong model?

Sa praktika, oo. Gumagana ang CPU-only inference at sapat ito para sa mga indibidwal na tanong, ngunit maraming request ang ipinapadala ng isang agent sa bawat task at binabasa nitong muli ang mahabang history sa bawat isa. Dahil dito, maaaring maging isang oras ang dalawang-minutong task kapag mabagal ang token rate. Suriin ang PROCESSOR column sa ollama ps: anumang value maliban sa 100% GPU ay nangangahulugang bahagi ng model ang tumatakbo sa CPU, kaya matindi ang pagbaba ng token rate.