Ollama: איך מגדירים num_ctx ומונעים חיתוך פרומפטים
פרומפטים ארוכים נחתכים בשקט ב-Ollama. גלו איזה num_ctx השרת באמת משתמש בו, הגדירו אותו לבקשה או לשרת, ובדקו את זיכרון ה-KV cache לפני הגדלה.
מה עושה num_ctx, ומדוע הפרומפט הארוך שלכם נחתך
אורך ההקשר של Ollama הוא מספר ה־tokens שהמודל שנטען יכול להחזיק בזיכרון בו־זמנית, ו־num_ctx היא האפשרות שקובעת אותו. Ollama בוחר ערך ברירת מחדל שנמוך בהרבה מהמקסימום שהמודל מציין, ולכן פרומפט ארוך יותר נחתך עוד לפני שהמודל קורא אותו. שום דבר בתגובה אינו מציין שזה קרה.
Llama 3.1 8B מופיע בספריית המודלים של Ollama עם חלון הקשר בגודל 128k. שרת בהגדרות ברירת המחדל לא יעניק לכם זאת. בתיעוד של Ollama עצמה מופיעים ערכי ברירת מחדל שונים בעמודים שונים: ה־FAQ מציין 4096 tokens, ההפניה של Modelfile מציינת ש־num_ctx מוגדר כברירת מחדל ל־2048, ובעמוד אורך ההקשר נאמר שערך ברירת המחדל נקבע לפי כמות ה־VRAM (זיכרון הווידאו) הזמינה: 4k מתחת ל־24 GiB, 32k מ־24 GiB ועד 48 GiB, ו־256k מ־48 GiB ומעלה. כל אחד מהערכים האלה היה נכון עבור גרסה מסוימת. זו המסקנה המועילה מהמחלוקת: קראו את הערך מהשרת שפועל אצלכם, במקום לסמוך על עמוד כלשהו, כולל העמוד הזה.
החיתוך שקט, משום שהמודל עדיין משיב, והתשובה עדיין נקראת היטב. היא נכתבה על סמך החלק האחרון של הקלט שלכם. סיכום שמפספס את המחצית הראשונה של מסמך נראה כמו תוצאה של מודל חלש. בדרך כלל מדובר בחלון הקשר קטן.
בדיקת אורך ההקשר (context length) ששרת ה-Ollama שלכם החיל בפועל
הבדיקה שעובדת בכל גרסת build היא prompt_eval_count, המונה את מספר ה-tokens של ה-prompt שהשרת מדווח כי עיבד. שלחו כמות גדולה ממה שההקשר יכול להכיל, והמספר הזה ייעצר בדיוק במגבלה.
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}'ה-prompt הזה מכיל כ-18,000 מילים, הרבה מעבר ל-4096 tokens. הערך prompt_eval_count יחזור קרוב ל-4096 במקום קרוב למספר ה-tokens האמיתי, כיוון שהשרת השמיט את השאר. הריצו זאת שוב עם "num_ctx":16384 והמספר יעלה. אם ה-build שלכם מחזיר שגיאה במקום לקטום את הטקסט, זו אותה תוצאה עם חיווי ברור יותר.
ollama psהעמודה CONTEXT, בגרסאות שמדפיסות אותה, מכילה את אורך ההקשר שבו המודל הטעון רץ כרגע. העמודה PROCESSOR לצדה מציגה היכן המודל ממוקם. הערך 100% CPU הוא תקין בשרת VPS ללא GPU. פיצול כמו 30%/70% CPU/GPU בשרת עם GPU מעיד על כך שהמשקולות (weights) יחד עם ה-cache אינם נכנסים יותר ב-VRAM, וערך num_ctx גבוה הוא הסיבה הנפוצה לכך.
journalctl -u ollama --no-pager | grep -i n_ctx | tail -n 5מריץ ההסקה (inference runner) מדפיס את גודל ההקשר שלו בשורה המכילה את n_ctx. הניסוח המדויק משתנה בין גרסאות, לכן התייחסו לשורה חסרה כאל שינוי שם ולא כאל הוכחה למשהו אחר.
ארבעה מקומות להגדרת num_ctx
בבקשה עצמה. שלחו את "options": {"num_ctx": 16384} ל־/api/generate או ל־/api/chat. הגדרה זו גוברת על כל הגדרה אחרת וחלה על הקריאה הספציפית הזו. אם הערך שונה מזה שבו המודל הטעון פועל, השרת יטען מחדש את המודל, דבר שניתן לראות ב־load_duration בתגובה: הערך יקפוץ מאפס לשניות שלמות. המתנה דומה מתרחשת כאשר המודל היה במצב המתנה זמן רב מדי ופונה מהזיכרון, לכן ברגע שהחלטתם על גודל הקשר (context size), כדאי להשאיר את המודל בזיכרון באמצעות keep_alive.
בסשן אינטראקטיבי. בתוך ollama run, הקלידו /set parameter num_ctx 16384. ההגדרה תקפה למשך הסשן הנוכחי בלבד.
בתוך Modelfile. פעולה זו מטמיעה את הערך במודל בעל שם, כך שכל לקוח מקבל אותו ללא צורך בשינוי בצד הלקוח.
FROM llama3.1:8b
PARAMETER num_ctx 16384ollama create llama3.1-16k -f ./Modelfile
ollama run llama3.1-16kבשרת. OLLAMA_CONTEXT_LENGTH קובע את ברירת המחדל עבור כל בקשה שאינה כוללת num_ctx משלה. תחת systemd, הוסיפו קובץ drop-in במקום לערוך את קובץ ה-unit ישירות.
sudo systemctl edit ollama.service[Service]
Environment="OLLAMA_CONTEXT_LENGTH=16384"sudo systemctl daemon-reload
sudo systemctl restart ollama
ollama psסדר הקדימויות חשוב במיוחד בעת ניפוי שגיאות בלקוח של צד שלישי. בקשה הכוללת num_ctx גוברת על ברירת המחדל של השרת, כך שממשק צ'אט או סוכן (agent) השולח ערך קטן משלו יבטל בשקט את השינוי שביצעתם ב-systemd. כאשר אתם מפנים סוכן תכנות לשרת ה-Ollama שלכם, בדקו מה הלקוח שולח לפני שאתם מאשימים את השרת.
אי־אפשר פשוט להגדיר את num_ctx לערך המרבי של המודל
מנגנון ה־attention גורם לכל token להתייחס לכל ה־tokens שלפניו. ה־keys וה־values שחושבו עבור tokens קודמים נשמרים, כדי שלא יהיה צורך לחשב אותם מחדש עבור כל token חדש. מאגר זה נקרא KV cache (מטמון key/value). הוא מוקצה עבור כל ה־num_ctx בעת טעינת המודל, ולא בהדרגה עם התארכות השיחה. לכן context גדול צורך את הזיכרון שלו גם כאשר ה־prompt כולל שורה אחת בלבד.
כל שכבה שומרת וקטור key אחד ווקטור value אחד עבור כל head של key/value ולכל token. לכן אפשר לרכז את החישוב בשורה אחת:
kv_bytes_per_token = 2 * layers * kv_heads * head_dim * bytes_per_valueהמספר 2 סופר את ה־keys ואת ה־values בנפרד. את שאר המספרים יש לקחת מהמודל שלכם.
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"}'Llama 3.1 8B מדווח על 32 שכבות ועל 8 heads של key/value. ממד ה־head הוא embed חלקי heads, ולכן כאן 4096 / 32 = 128. יש מודלים שמפרסמים את הערך הזה ישירות כ־llama.attention.key_length. מטמון ברירת המחדל שומר ערכי f16, ולכן bytes_per_value הוא 2. החישוב 2 32 8 128 2 נותן 131,072 בתים. כלומר, כל token של context צורך 128 KiB במטמון. הכפילו באורך ה־context, ועלות הזיכרון כבר אינה תיאורטית.
הנתונים שמאחורי התרשים
[
{
"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
}
]השורות 6 הן תוצאה חשבונית של הנוסחה שלעיל, ולא מדידות. העמודה הכוללת מוסיפה את ההורדה בנפח 4.9 GB שהספרייה של Ollama הציגה עבור llama3.1:8b באוקטובר 2026, כלומר 4.6 GiB, ואינה כוללת את מאגרי החישוב ואת תהליך השרת עצמו. יש להתייחס לערך הזה כרף תחתון.
הצורה הכללית היא העיקר. ב־8k המטמון צורך 1 GiB, כמות זניחה ביחס למשקלים. ב־128k מלאים של המודל הוא צורך 16 GiB, יותר מפי 3 מהמשקלים, ובסך הכול קרוב ל־20.6 GiB. לכן VPS בנפח 4 GB אינו יכול לטעון את המודל הזה ב־context שימושי כלשהו. VPS בנפח 8 GB מספק מרווח נוח ב־8k. VPS בנפח 16 GB מגיע ל־32k, ועדיין משאיר מקום לשאר רכיבי השרת. כל אחד מהרפים האלה עולה יחד עם נפח המשקלים. לכן, אם אתם משווים בין מודל גדול יותר לבין מודל 8B זה, אותם חישובים שבוצעו עבור תג 27B של Qwen ב־VPS עם CPU בלבד ממחישים כמה מעט זיכרון נשאר ל־context בטווח שבין 8 ל־64 GB.
מה קורה כאשר מטמון ה־KV אינו נכנס לזיכרון
ב־VPS עם CPU בלבד, התהליך פשוט ממשיך לגדול. עקבו אחריו בזמן טעינת המודל ובזמן הרצת בקשה ארוכה.
free -m
ps -eo rss,comm --sort=-rss | head -n 5RSS (גודל קבוצת התושבים בזיכרון) מודפס בקילובייטים. אם השימוש ב־swap בתוך free -m מתחיל לעלות, הקטינו את גודל ההקשר. מטמון KV שנמצא ב־swap גורם להפקה להיעצר למשך שניות לכל token, משום שכל token חדש קורא את המטמון כולו.
אם לשרת נגמר הזיכרון לחלוטין, ה־kernel בוחר תהליך להריגה, בדרך כלל את התהליך שמחזיק בכמות הזיכרון הגדולה ביותר.
sudo dmesg | grep -i "killed process"שורה שמכילה Out of memory: Killed process 1234 (ollama) פירושה ש־Ollama היה התהליך שה־kernel בחר, ולא בהכרח התהליך שצרך את הזיכרון. בשרת שבו Ollama הוא התהליך הגדול היחיד, הקשר גדול מדי הוא בדרך כלל הסיבה. בדקו מה עוד פעל לפני שאתם מקטינים את num_ctx. לעיתים קרובות Ollama מסרב עוד לפני שהוא מגיע למצב הזה, ואז הבקשה נכשלת עם הודעה שמציינת כמה זיכרון נדרש לעומת כמות הזיכרון שהייתה פנויה.
בשרת עם GPU הכשל שקט יותר. שכבות גולשות אל זיכרון המערכת, ollama ps מציג את החלוקה בין ה־CPU ל־GPU, והתפוקה יורדת בחדות. מידת הירידה תלויה בחומרה שלכם, לכן מדדו tokens per second בשרת שלכם בכל הגדרת הקשר, במקום להסתמך על נתון ממחשב של אדם אחר.
זמן ה-Prefill גדל מהר יותר מה-prompt
ה-Prefill הוא העבודה שמתבצעת על הקלט שלכם לפני שמופיע ה-token הראשון של הפלט. כל token ב-prompt מבצע פעולת attention על כל ה-tokens שלפניו, לכן סך העבודה גדל לפי ריבוע אורך הקלט. הכפלת ה-prompt גורמת לעיכוב של יותר מפי שניים בקבלת ה-token הראשון.
התגובה כוללת את המדידה, כך שאין צורך להסתמך על הערכות.
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)}'הריצו זאת פעם עם prompt קצר ופעם נוספת עם prompt ארוך, ולאחר מכן חלקו את מספר ה־tokens במספר השניות בכל אחד מהמקרים. ב־VPS שפועל על CPU בלבד, שלב ה־prefill הוא בדרך כלל החלק האיטי ביותר בבקשה עם הקשר ארוך, ונתון tokens per second שנמדד באמצעות prompt קצר לא ינבא את הביצועים במקרה זה. כאשר שלב ה־prefill נמשך מעבר ל־timeout שמוגדר לפניו, זו בדרך כלל הסיבה לכך ש־prompt ארוך מחזיר חריגה של תום הזמן שהוקצה להקשר במקום תשובה. לכן, בררו איזו שכבה ויתרה על הבקשה לפני שאתם מקצרים את ההקשר.
הבעיה מורגשת ביותר במצבי Concurrency. כל בקשה שמטופלת זקוקה ל-cache משלה, לכן הזיכרון בתרשים לעיל הוא לכל בקשה ולא לכל שרת, ובקשה אחת ארוכה עלולה לתפוס את המשאבים בזמן שבקשות קצרות ממתינות בתור. הגדירו את OLLAMA_NUM_PARALLEL באופן מכוון, וקראו את כמה משתמשים בו-זמנית יכול שרת LLM עצמאי לשרת לפני שתעלו את שני המספרים יחד.
להחזיר זיכרון עבור ההקשר באמצעות מטמון קטן יותר
bytes_per_value בנוסחה הוא הגדרה שבשליטתכם. השאלות והתשובות של Ollama מתעדות את OLLAMA_KV_CACHE_TYPE, כאשר f16 הוא ברירת המחדל, q8_0 משתמש בכמחצית מכמות הזיכרון של f16, ו־q4_0 משתמש בכרבע מכמות זו. הערך המדויק עבור q8_0 מעט גדול ממחצית: llama.cpp שומר כל בלוק של 32 ערכים כ־32 ערכים בגודל בית אחד בתוספת scale בגודל שני בתים, כלומר 34 בתים, בעוד ש־f16 דורש 64. מעבר ל־q8_0 מצמצם לכן את השורה של 32k לכ־2.1 GiB במקום 4 GiB. כימות המשקלים מפנה זיכרון מהצד השני של אותו תקציב, ו־תגית GLM שמתאימה בפועל ל־VPS נבחנת כימות אחר כימות, אם זו הפשרה המועדפת עליכם. באותן שאלות ותשובות מצוין שהמטמון עובר כימות רק כאשר Flash Attention מופעל, ומתועדת בהן האפשרות OLLAMA_FLASH_ATTENTION=1 לאלץ את הפעלתו.
[Service]
Environment="OLLAMA_FLASH_ATTENTION=1"
Environment="OLLAMA_KV_CACHE_TYPE=q8_0"אמתו את התוצאה במקום להניח אותה: הפעילו מחדש את השירות, טענו את המודל באותו num_ctx כמו קודם, והשוו את RSS. התמיכה תלויה במודל וב־backend, לכן הגדרה שאינה משנה דבר מצביעה על כך שהשילוב שלכם אינו נתמך. סוג המטמון הוא אפשרות גלובלית, ולכן כל מודל בשרת יפעל באמצעותו. מבחינת האיכות, בשאלות והתשובות מצוין כי ל־q8_0 בדרך כלל אין השפעה מורגשת, ואילו q4_0 מאבד דיוק רב יותר, בעיקר בגדלי הקשר גדולים יותר. לכן בדקו את q4_0 מול ההנחיות שלכם לפני שתסתמכו עליו. אם ההגדרות האלה הן הסיבה שבגללה הגעתם לכאן, Ollama ו־llama.cpp חושפים אותן בדרכים שונות.
מתכון לבחירת num_ctx
- קראו את הקונטקסט המקסימלי של המודל, את מספר השכבות שלו ואת מספר ה-key/value heads מתוך
/api/show. - חשבו את מספר הבייטים לכל טוקן לפי הנוסחה, והכפילו בקונטקסט הרצוי לכם.
- הוסיפו את גודל המשקולות, השוו מול ה-RAM הפנוי, והשאירו לפחות 1 GiB פנוי עבור שאר המערכת.
- הגדירו את הערך, טענו את המודל, ואז ודאו מה הוחל בפועל באמצעות
ollama psו-prompt_eval_count. - הריצו את עומס העבודה האמיתי שלכם תוך ניטור
free -m, וצמצמו את הקונטקסט בחצי אם מתחילה פעילות ב-swap.
רוב המשימות דורשות פחות קונטקסט ממה שאנשים נוטים להקצות להן. סיכום של דוח ארוך נכנס ב-16k. ממשק שליפה (retrieval) שמדביק חמישה מקטעי מסמכים לעיתים רחוקות עובר את ה-8k. סוכן תכנות שקורא קבצים שלמים הוא המקרה שבאמת זקוק ל-64k ומעלה, וזהו גם המקרה שבו עליכם להתאים את המכונה לקונטקסט ולא להפך. אם השרת עצמו עדיין חדש, התחילו מ-התקנה תקינה של Ollama על גבי VPS וכוונו את הקונטקסט לאחר שהמודלים נטענים בצורה נקייה.
FAQ
מהו אורך ההקשר המוגדר כברירת מחדל ב־Ollama?
הדבר תלוי ב־build ובחומרה, לכן יש לבדוק במקום להניח. ה־FAQ של Ollama מתעד 4096 tokens, ההפניה של Modelfile מתעדת ברירת מחדל של num_ctx בערך 2048, ודף אורך ההקשר מתעד ברירת מחדל שנבחרת לפי כמות ה־VRAM הזמינה: 4k מתחת ל־24 GiB, 32k מ־24 GiB ועד 48 GiB, ו־256k ב־48 GiB ומעלה. VPS שפועל על CPU בלבד יימצא בקצה הנמוך. ollama ps מדפיס את ההקשר שהוחל ב־builds שבהם העמודה קיימת, ו־prompt_eval_count בתגובת API מאמת זאת בכל build.
מדוע Ollama מתעלם מתחילת ה־prompt הארוך שלי?
משום שה־prompt היה ארוך יותר מחלון ההקשר, ולכן השרת קיצר אותו לפני שהמודל קיבל אותו, בלי להחזיר שגיאה. שלחו שוב את אותו prompt עם num_ctx גדול יותר, ועקבו אחר prompt_eval_count בתגובה כשהוא גדל. אם המספר הזה אינו משתנה, רכיב כלשהו ביניכם לבין השרת מגדיר בעצמו את num_ctx, כפי שקורה לעיתים קרובות עם ממשקי chat ועם frameworks של agents.
כמה RAM נוסף נדרש עבור num_ctx גדול יותר?
הכפילו את אורך ההקשר בעלות ה־cache לכל token, שהיא 2 * layers * kv_heads * head_dim * bytes_per_value. עבור Llama 3.1 8B ב־f16 העלות היא 128 KiB לכל token, לכן 32k tokens צורכים 4 GiB, והקשר מלא של 128k tokens צורך 16 GiB בנוסף ל־weights. ה־cache מוקצה בעת טעינת המודל, לכן num_ctx גדול צורך את הזיכרון הזה גם כאשר ה־prompts שלכם קצרים.
האם חלון הקשר גדול יותר הופך את Ollama לאיטי יותר?
כן, בשתי דרכים. עבודת ה־prefill גדלה בריבוע של אורך ה־prompt, לכן קלט ארוך מעכב את ה־token הראשון יותר מכפי שאורכו מרמז. ה־cache הגדול יותר מתחרה גם הוא על הזיכרון: במחשב עם GPU הוא דוחף שכבות אל ה־RAM של המערכת, ובמחשב עם CPU הוא מקרב את המערכת לשימוש ב־swap. num_ctx גדול שאינכם ממלאים עדיין צורך את הזיכרון, אף שאינו מוסיף זמן prefill.
האם אפשר להגדיר num_ctx באופן קבוע עבור מודל אחד?
כן. כתבו Modelfile שמכיל FROM llama3.1:8b ו־PARAMETER num_ctx 16384, ולאחר מכן הריצו ollama create llama3.1-16k -f ./Modelfile. כל client שמבקש llama3.1-16k יקבל את ההקשר הזה בלי לשלוח options כלשהן. בקשה שמכילה num_ctx משלה עדיין גוברת, לכן הגדרה זו קובעת ברירת מחדל ולא תקרה.