SSD Nodes Learn Hosting plans →
Mga Gabay Matt ConnorNi Matt Connor · Na-update 2026-10-21

Ollama num_ctx: Paano Ayusin ang Context Length

Tahimik na pinuputol ng Ollama ang mahahabang prompt. Alamin ang 2048, 4096, 32k, at 256k defaults, itakda ang num_ctx, at tantiyahin ang KV cache RAM.

Ano ang ginagawa ng num_ctx, at kung bakit naputol ang mahaba mong prompt

Ang Ollama context length ay bilang ng mga token na kayang panatilihin ng loaded model sa memory nang sabay-sabay, at ang num_ctx ang option na nagse-set nito. Pumipili ang Ollama ng default na mas mababa kaysa sa maximum na ina-advertise ng model. Kaya napuputol ang mas mahabang prompt bago pa man ito mabasa ng model. Walang ipinapakita sa response na nagsasabing nangyari ito.

Nakalista ang Llama 3.1 8B sa Ollama model library na may 128k context window. Hindi ito ang ibibigay ng stock server. Magkakaiba ang default na nasa sariling documentation ng Ollama depende sa page: sinasabi sa FAQ na 4096 tokens, sinasabi sa Modelfile reference na ang num_ctx ay may default na 2048, at sinasabi sa context length page na pinipili ang default batay sa available VRAM (video RAM): 4k kapag mas mababa sa 24 GiB, 32k mula 24 GiB hanggang 48 GiB, at 256k kapag 48 GiB pataas. Totoo ang bawat isa sa ilang build. Iyan ang mahalagang aral: basahin ang value mula sa sarili mong running server sa halip na umasa sa anumang page, kabilang na ang page na ito.

Tahimik ang truncation dahil sumasagot pa rin ang model, at maayos pa ring basahin ang sagot. Isinulat ito batay sa hulihan ng input mo. Ang summary na hindi kasama ang unang kalahati ng document ay maaaring magmukhang gawa ng mahinang model. Karaniwan, maliit lang ang context window.

Tingnan ang context length ng Ollama na aktuwal na inilapat ng server

Ang check na gumagana sa anumang build ay prompt_eval_count, ang bilang ng prompt token na iniulat ng server na naproseso nito. Magpadala ng mas maraming token kaysa sa kayang hawakan ng context, at titigil ang bilang na iyon sa limitasyon.

sudo apt update && sudo apt install -y jq
LONG=$(python3 -c "print('the quick brown fox jumps over the lazy dog. ' * 2000)")
jq -n --arg p "$LONG" '{model:"llama3.1:8b", prompt:$p, stream:false, options:{num_ctx:4096}}' |
  curl -s http://localhost:11434/api/generate -d @- |
  jq '{prompt_eval_count, prompt_eval_duration}'

Humigit-kumulang 18,000 salita ang prompt na iyon, kaya higit na mas marami ito sa 4096 token. Bumabalik ang prompt_eval_count na malapit sa 4096 sa halip na malapit sa aktuwal na bilang ng token dahil itinapon ng server ang natitira. Patakbuhin itong muli gamit ang "num_ctx":16384 at tataas ang bilang. Kung error ang ibinabalik ng build mo sa halip na i-truncate ang input, pareho pa rin ang finding; mas malinaw lang ang signal.

ollama ps

Ang column na CONTEXT, sa mga build na nagpi-print nito, ay naglalaman ng context length na ginagamit ngayon ng naka-load na model. Ipinapakita naman ng column na PROCESSOR sa tabi nito kung saan nakalagay ang model. Normal ang 100% CPU sa isang VPS na walang GPU. Ang split na gaya ng 30%/70% CPU/GPU sa isang GPU box ay nangangahulugang hindi na kasya sa VRAM ang weights at cache, at karaniwang dahilan nito ang mas mataas na num_ctx.

journalctl -u ollama --no-pager | grep -i n_ctx | tail -n 5

Ini-print ng inference runner ang context size nito sa isang line na naglalaman ng n_ctx. Nagbabago ang eksaktong wording sa bawat release, kaya ituring ang nawawalang line bilang pagpapalit ng pangalan, hindi bilang patunay ng anuman.

Apat na lugar para itakda ang num_ctx

Sa request. Ipadala ang "options": {"num_ctx": 16384} sa /api/generate o /api/chat. Ito ang may pinakamataas na precedence sa lahat ng ibang setting, at nalalapat lamang ito sa isang call. Kung iba ang value nito sa kasalukuyang ginagamit ng loaded model, ire-reload muna ng server ang model. Makikita ito sa load_duration sa response: mula sa halos zero ay tataas ito sa ilang buong segundo. Lumilitaw din ang parehong paghihintay kapag matagal nang idle ang model at na-unload na ito. Kaya kapag napili mo na ang context size, mainam na panatilihing resident ang model gamit ang keep_alive.

Sa interactive session. Sa loob ng ollama run, i-type ang /set parameter num_ctx 16384. Nalalapat ito sa session na iyon.

Sa Modelfile. Isinasama nito ang value sa isang named model, kaya matatanggap ito ng bawat client nang walang pagbabago sa client side.

FROM llama3.1:8b
PARAMETER num_ctx 16384
ollama create llama3.1-16k -f ./Modelfile
ollama run llama3.1-16k

Sa server. Itinatakda ng OLLAMA_CONTEXT_LENGTH ang default para sa bawat request na walang sariling num_ctx. Sa ilalim ng systemd, magdagdag ng drop-in sa halip na i-edit ang unit file.

sudo systemctl edit ollama.service
[Service]
Environment="OLLAMA_CONTEXT_LENGTH=16384"
sudo systemctl daemon-reload
sudo systemctl restart ollama
ollama ps

Pinakamahalaga ang precedence kapag dini-debug mo ang client ng ibang tao. Nauuna ang request na may num_ctx kaysa sa server default. Dahil dito, maaaring tahimik na ma-override ng chat front end o agent na nagpapadala ng sarili nitong maliit na value ang pagbabago mo sa systemd. Kapag itinuro mo ang isang coding agent sa iyong Ollama server, tingnan muna kung ano ang ipinapadala ng client bago sisihin ang server.

Bakit hindi basta itakda ang num_ctx sa maximum ng model

Pinapatingin ng attention ang bawat token sa lahat ng naunang token. Iniingatan ang mga key at value na kinuwenta para sa mga naunang token upang hindi na muling kwentahin sa bawat bagong token. Ang storage na ito ang KV cache (key/value cache). Inilalaan ito para sa buong num_ctx kapag nilo-load ang model, hindi habang lumalaki ang conversation. Kaya may memory cost ang malaking context kahit isang linya lang ang prompt.

May isang key vector at isang value vector ang bawat layer para sa bawat key/value head ng bawat token. Kaya maaaring isulat sa isang linya ang computation:

kv_bytes_per_token = 2 * layers * kv_heads * head_dim * bytes_per_value

Hiwalay na binibilang ng 2 ang mga key at value. Basahin ang iba pang numero mula sa sarili mong model.

curl -s http://localhost:11434/api/show -d '{"model":"llama3.1:8b"}' |
  jq '.model_info | {ctx: ."llama.context_length", layers: ."llama.block_count", heads: ."llama.attention.head_count", kv_heads: ."llama.attention.head_count_kv", embed: ."llama.embedding_length"}'

Inililista ng Llama 3.1 8B ang 32 layer at 8 key/value head. Ang head dimension ay embed na hinati sa heads, kaya 4096 / 32 = 128 dito. Direktang inilalabas din ito ng ilang model bilang llama.attention.key_length. Ang default cache ay gumagamit ng f16 values, kaya ang bytes_per_value ay 2. Ang 2 32 8 128 2 ay nagiging 131,072 bytes. Katumbas ito ng 128 KiB na cache para sa bawat token ng context. Kapag minultiply sa context length, nagiging malinaw ang aktuwal na cost.

TsartLlama 3.1 8B at f16: KV cache and total RAM by context length, in GiB
Ang datos sa likod ng tsart na ito
[
  {
    "label": "4k",
    "kv_cache_gib": 0.5,
    "total_ram_gib": 5.1
  },
  {
    "label": "8k",
    "kv_cache_gib": 1,
    "total_ram_gib": 5.6
  },
  {
    "label": "16k",
    "kv_cache_gib": 2,
    "total_ram_gib": 6.6
  },
  {
    "label": "32k",
    "kv_cache_gib": 4,
    "total_ram_gib": 8.6
  },
  {
    "label": "64k",
    "kv_cache_gib": 8,
    "total_ram_gib": 12.6
  },
  {
    "label": "128k",
    "kv_cache_gib": 16,
    "total_ram_gib": 20.6
  }
]

Ang 6 row ay resulta ng arithmetic mula sa formula sa itaas, hindi mga measurement. Idinadagdag ng total column ang 4.9 GB na download na inilista ng Ollama library para sa llama3.1:8b noong October 2026. Katumbas ito ng 4.6 GiB. Hindi kasama rito ang compute buffer at ang server process mismo. Ituring ito bilang minimum na halaga.

Ang mahalaga ay ang pagbabago ng laki. Sa 8k, nagkakahalaga ang cache ng 1 GiB, na maliit kumpara sa weights. Sa buong 128k ng model, nagkakahalaga ito ng 16 GiB—mahigit tatlong beses sa laki ng weights—para sa kabuuang humigit-kumulang 20.6 GiB. Kaya hindi kayang i-load ng 4 GB VPS ang model na ito sa anumang kapaki-pakinabang na context. Kumportable ang 8 GB VPS sa 8k. Umaabot ang 16 GB VPS sa 32k at may natitirang memory para sa iba pang bahagi ng server. Tumataas ang bawat threshold na ito kasabay ng laki ng weights. Kaya kung ikinukumpara mo ang mas malaking model sa 8B na ito, ipinapakita ng parehong computation para sa 27B tag ng Qwen sa CPU-only VPS kung gaano kaliit ang natitirang memory para sa context sa pagitan ng 8 at 64 GB.

Ano ang nangyayari kapag hindi kasya ang KV cache

Sa CPU-only na VPS, patuloy lang na lalaki ang process. I-monitor ito habang nilo-load ang model at habang tumatakbo ang mahabang request.

free -m
ps -eo rss,comm --sort=-rss | head -n 5

Naka-print ang RSS (resident set size) sa kilobytes. Kapag nagsimulang tumaas ang used swap sa free -m, bawasan ang context. Kapag nasa swap ang KV cache, bumabagal nang husto ang generation at maaaring umabot ng ilang segundo bawat token, dahil binabasa ng bawat bagong token ang buong cache.

Kapag tuluyang naubusan ng memory ang server, pipili ang kernel ng process na papatayin. Karaniwan, ito ang process na gumagamit ng pinakamaraming memory.

sudo dmesg | grep -i "killed process"

Ang linyang may Out of memory: Killed process 1234 (ollama) ay nangangahulugang si Ollama ang process na pinili ng kernel, hindi nangangahulugang siya ang gumamit ng memory. Sa server kung saan si Ollama lang ang malaking process, karaniwang sanhi ang context na masyadong malaki para magkasya. Tingnan muna kung ano pa ang tumatakbo bago bawasan ang num_ctx. Madalas, tumatanggi na si Ollama bago umabot sa puntong iyon, at mabibigo ang request na may mensaheng nagsasaad ng memory na kailangan nito kumpara sa memory na libre.

Sa GPU server, mas tahimik ang failure. May mga layer na napupunta sa system RAM, ipinapakita ng ollama ps ang hatian sa CPU at GPU, at biglang bumababa ang throughput. Depende sa hardware kung gaano kalaki ang ibinababa nito, kaya sukatin ang tokens per second sa sarili mong server sa bawat context setting sa halip na umasa sa bilang mula sa ibang machine.

Mas mabilis lumalaki ang prefill time kaysa sa prompt

Ang prefill ay ang pagproseso sa input bago lumabas ang unang output token. Ang bawat prompt token ay tumitingin sa lahat ng token na nauuna rito, kaya lumalaki ang kabuuang trabaho ayon sa square ng haba ng input. Kapag dinoble ang prompt, higit sa doble ang waiting time bago lumabas ang unang token.

Nasa response ang sukat, kaya hindi mo ito kailangang tanggapin nang walang beripikasyon.

jq -n --arg p "$LONG" '{model:"llama3.1:8b", prompt:$p, stream:false, options:{num_ctx:16384}}' |
  curl -s http://localhost:11434/api/generate -d @- |
  jq '{tokens: .prompt_eval_count, prefill_seconds: (.prompt_eval_duration/1000000000)}'

Patakbuhin ito gamit ang maikling prompt, at ulitin gamit ang mahabang prompt. Pagkatapos, hatiin ang bilang ng tokens sa bilang ng segundo para sa bawat kaso. Sa CPU-only VPS, karaniwang pinakamabagal na bahagi ng long-context request ang prefill. Hindi nito mahuhulaan ang performance ng prefill para sa mahabang prompt kung ang tokens per second figure ay kinuha lamang mula sa maikling prompt. Kapag mas matagal ang prefill kaysa sa timeout na nasa unahan nito, karaniwang nagbabalik ang long prompt ng lumampas sa deadline ng context sa halip na sagot. Kaya alamin muna kung aling layer ang sumuko bago bawasan ang context.

Dito pinakaramdam ang epekto ng concurrency. Kailangan ng bawat sine-serve na request ng sarili nitong cache. Kaya ang memory sa chart sa itaas ay para sa bawat request, hindi para sa buong server. Maaaring hawakan ng isang mahabang request ang buong server habang nakapila sa likod nito ang maiikling request. Itakda nang sinadya ang OLLAMA_NUM_PARALLEL, at basahin ang kung ilang concurrent user ang kayang pagsilbihan ng isang self-hosted LLM bago mo taasan nang sabay ang dalawang value.

Bumawi ng konteksto gamit ang mas maliit na cache

Ang bytes_per_value sa formula ay isang setting na ikaw ang kumokontrol. Idinodokumento ng FAQ ng Ollama ang OLLAMA_KV_CACHE_TYPE, kung saan ang default ay f16, ang q8_0 ay gumagamit ng humigit-kumulang kalahati ng memory ng f16, at ang q4_0 ay gumagamit ng humigit-kumulang isang-kapat. Bahagyang higit sa kalahati ang eksaktong halaga para sa q8_0: ini-store ng llama.cpp ang bawat block na may 32 value bilang 32 one-byte value kasama ang two-byte scale, kaya 34 bytes ito kumpara sa 64 bytes na kailangan ng f16. Kapag lumipat sa q8_0, magiging humigit-kumulang 2.1 GiB ang 32k row sa halip na 4 GiB. Nagpapalaya ng memory mula sa kabilang bahagi ng parehong budget ang pag-quantise ng weights, at ipinapaliwanag ang GLM tag na aktuwal na kasya sa VPS quantisation bawat quantisation kung iyon ang trade-off na mas gusto mong gawin. Ayon din sa parehong FAQ, kino-quantise lamang ang cache kapag naka-enable ang Flash Attention, at idinodokumento nito ang OLLAMA_FLASH_ATTENTION=1 upang sapilitang i-enable ito.

[Service]
Environment="OLLAMA_FLASH_ATTENTION=1"
Environment="OLLAMA_KV_CACHE_TYPE=q8_0"

Mag-confirm sa halip na mag-assume: i-restart ang service, i-load ang model sa parehong num_ctx gaya ng dati, at ikumpara ang RSS. Nakadepende ang support sa model at backend, kaya kung walang binabago ang isang setting, hindi saklaw ng setting ang kombinasyon mo. Global option ang cache type, kaya gagamit nito ang bawat model sa server. Para sa quality, sinasabi ng FAQ na karaniwang walang kapansin-pansing epekto ang q8_0, samantalang mas maraming precision ang nawawala sa q4_0, lalo na sa mas malalaking context size. Kaya i-test ang q4_0 gamit ang sarili mong prompts bago mo ito asahan sa production. Kung ang mga setting na ito ang dahilan kung bakit ka narito, magkaiba ang paraan ng pag-expose ng mga ito sa Ollama at llama.cpp.

Isang gabay sa pagpili ng num_ctx

  1. Basahin mula sa /api/show ang maximum context ng model, bilang ng mga layer nito, at bilang ng key/value head nito.
  2. Kalkulahin ang bytes bawat token gamit ang formula, at pagkatapos ay i-multiply ito sa context na gusto mo.
  3. Idagdag ang laki ng weights, ikumpara ito sa available na RAM, at mag-iwan ng hindi bababa sa 1 GiB para sa iba pang gawain ng server.
  4. Itakda ang value, i-load ang model, at kumpirmahin kung ano ang na-apply gamit ang ollama ps at prompt_eval_count.
  5. Patakbuhin ang aktuwal mong workload habang mino-monitor ang free -m, at hatiin sa 2 ang context kapag nagsimulang gumamit ng swap.

Karamihan ng mga job ay nangangailangan ng mas maliit na context kaysa sa karaniwang ibinibigay ng mga user. Kasya sa 16k ang pagbubuod ng mahabang report. Ang retrieval front end na naglalagay ng limang document chunk ay bihirang lumampas sa 8k. Ang coding agent na nagbabasa ng buong file ang talagang nangangailangan ng 64k o higit pa. Sa ganitong sitwasyon, dapat mong i-size ang machine batay sa context, hindi ang context batay sa machine. Kung bago pa ang server, magsimula sa gumaganang Ollama install sa isang VPS at i-tune ang context kapag malinis nang naglo-load ang mga model.

FAQ

Ano ang default na context length sa Ollama?

Nakadepende ito sa build at hardware, kaya suriin ito sa halip na manghula. Nakadokumento sa FAQ ng Ollama ang 4096 tokens, nakadokumento naman sa Modelfile reference ang default na num_ctx na 2048, at nakadokumento sa context length page ang default na pinipili batay sa available na VRAM: 4k sa mas mababa sa 24 GiB, 32k mula 24 GiB hanggang 48 GiB, at 256k sa 48 GiB pataas. Karaniwang nasa maliit na dulo nito ang CPU-only VPS. Ipinapakita ng ollama ps ang aktuwal na context sa mga build na may ganitong column, at pinatutunayan ito ng prompt_eval_count sa API response sa lahat ng build.

Bakit binabalewala ng Ollama ang simula ng mahaba kong prompt?

Dahil mas mahaba ang prompt kaysa sa context window, kaya pinutol ito ng server bago ito makita ng model, at walang error na ibinalik. Ipadala muli ang parehong prompt gamit ang mas malaking num_ctx at tingnan kung lumalaki ang prompt_eval_count sa response. Kung hindi nagbabago ang numerong iyon, may bahagi sa pagitan mo at ng server na mismong nagse-set ng num_ctx. Karaniwan ito sa mga chat front end at agent framework.

Gaano karaming dagdag na RAM ang kailangan ng mas malaking num_ctx?

I-multiply ang context length sa cache cost bawat token, na 2 * layers * kv_heads * head_dim * bytes_per_value. Para sa Llama 3.1 8B sa f16, 128 KiB ito bawat token. Kaya ang 32k tokens ay kumokonsumo ng 4 GiB, at ang buong 128k ay kumokonsumo ng 16 GiB bukod pa sa memory ng weights. Inilalaan ang cache kapag nilo-load ang model, kaya kumokonsumo ng ganoong memory ang malaking num_ctx kahit maiikli ang mga prompt mo.

Pinapabagal ba ng mas malaking context window ang Ollama?

Oo, sa dalawang paraan. Lumalaki nang ayon sa square ng haba ng prompt ang prefill work, kaya mas matagal bago lumabas ang unang token kapag mahaba ang input kaysa sa ipinahihiwatig ng haba nito. Nakikipag-agawan din sa memory ang mas malaking cache: sa GPU box, itinutulak nito ang ilang layer papunta sa system RAM, at sa CPU box, itinutulak nito ang machine na gumamit ng swap. Kumokonsumo pa rin ng memory ang malaking num_ctx na hindi mo kailanman napupuno, kahit hindi nito pinahahaba ang prefill time.

Maaari ko bang permanenteng itakda ang num_ctx para sa isang model?

Oo. Gumawa ng Modelfile na naglalaman ng FROM llama3.1:8b at PARAMETER num_ctx 16384, pagkatapos ay patakbuhin ang ollama create llama3.1-16k -f ./Modelfile. Makukuha ng bawat client na humihingi ng llama3.1-16k ang context na iyon nang hindi nagpapadala ng anumang options. Mananaig pa rin ang request na may sarili nitong num_ctx, kaya default ang itinatakda nito at hindi maximum na limitasyon.

Nakatulong ba ang artikulong ito?