SSD Nodes Learn Hosting plans →
מדריכים Matt Connorמאת Matt Connor

איך להשאיר מודל של Ollama טעון בזיכרון

Ollama פורק מודל לאחר 5 דקות ללא פעילות. הגדירו OLLAMA_KEEP_ALIVE ב־systemd override והפעילו טעינה מראש לאחר אתחול, כדי למנוע המתנה לטעינה מחדש.

מדוע Ollama פורק את המודל לאחר כמה דקות?

Ollama משאיר מודל טעון בזיכרון למשך חמש דקות לאחר הבקשה האחרונה, ולאחר מכן מפנה אותו. הבקשה הבאה צריכה לטעון שוב את המשקולות ל־RAM או ל־VRAM, ולכן היא מתעכבת לפני שהטוקן הראשון מתקבל. זו הסיבה שממשק צ׳אט או סוכן קידוד מרגישים מהירים, נעשים לא פעילים לזמן מה, ואז שוב מרגישים איטיים בהודעה הבאה. שום דבר אינו מקולקל. טיימר חוסר הפעילות פג.

שם הטיימר הוא keep_alive. הוא מוגדר לכל מודל בנפרד, והוא מופעל מחדש בכל פעם שבקשה מסתיימת. מודל שמשיב כעת לבקשה לעולם אינו נפרק, משום שהשרת פג תוקף רק למודל שאין לו בקשה פעילה. נכון ל־October 2026, ברירת המחדל היא חמש דקות, והיא חלה על כל מודל שהשרת טוען.

יש שתי דרכים להגדיר את זמן קציבת חוסר הפעילות: השדה keep_alive בבקשה מסוימת, או OLLAMA_KEEP_ALIVE כברירת המחדל של השרת. קובץ drop-in של systemd הוא שמאפשר לברירת המחדל של השרת להישמר לאחר אתחול. המדריך הזה מניח ש־Ollama כבר פועל כשירות. אם לא, התחילו ב־התקנת Ollama ב־VPS וחזרו לכאן.

אילו מודלים טעונים כעת, ומתי הם יפוגו?

ollama ps
NAME        ID              SIZE      PROCESSOR    CONTEXT    UNTIL
qwen3:8b    500a1f067a9f    6.6 GB    100% GPU     4096       4 minutes from now

פלט ריק פירושו שאף מודל אינו טעון, ולכן הבקשה הבאה צריכה לטעון את המודל תחילה. PROCESSOR מציין היכן נטענו המשקלים. 100% GPU ו־100% CPU הם המקרים הברורים. פיצול כגון 25%/75% CPU/GPU פירושו שרק חלק מהמודל נמצא ב־VRAM, ולכן השאר רץ על המעבד והיצירה איטית יותר. בדרך כלל הסיבה לכך היא שהמודל לא התאים, אך הגדרה של num_gpu שמגבילה את מספר השכבות שעוברות ל־GPU יוצרת פיצול מאותו סוג.

UNTIL הוא הספירה לאחור, והוא מציג זמן יחסי כגון 4 minutes from now. הוא מציג Forever כאשר המודל נטען עם keep_alive שלילי. לאחר פקיעת התוקף הוא מציג Stopping..., כולל בזמן שבקשות פעילות מעכבות את פריקת המודל.

מערך העמודות השתנה בין גרסאות, לכן יש לקרוא את הכותרת במקום לספור שדות בסקריפט. Ollama v0.40.5, שנבדק ב־2026-10-30, מציג גם עמודת RUNNER בין CONTEXT לבין UNTIL. עמודה זו מציינת את ה־runner שמשרת את המודל, ולכן ייתכן שהכותרת שלכם רחבה בעמודה אחת מהדוגמה שלעיל. עבור כל אוטומציה, יש לפנות אל ה־API:

curl -s http://localhost:11434/api/ps

כל רשומה כוללת expires_at, חותמת זמן מוחלטת כגון 2026-08-09T14:38:31.83753Z, וכן size_vram, החלק של אותו מודל שנמצא בזיכרון ה־GPU. ערך size_vram של 0 פירושו שהמודל פועל על ה־CPU.

מה באמת עולה הטעינה מחדש

אל תנחשו. Ollama מדווח על זמן הטעינה בכל תגובה, תחת load_duration, בננו־שניות.

sudo apt install -y jq
ollama stop qwen3:8b
curl -s http://localhost:11434/api/generate -d '{"model": "qwen3:8b", "prompt": "hi", "stream": false}' | jq '{load_duration, total_duration}'
curl -s http://localhost:11434/api/generate -d '{"model": "qwen3:8b", "prompt": "hi", "stream": false}' | jq '{load_duration, total_duration}'

המתינו עד ש־ollama ps לא יציג עוד את המודל לאחר ollama stop, ורק אז הריצו את שתי קריאות ה־API. הקריאה הראשונה טוענת את המודל, ולכן הערך שלה תחת load_duration גדול. חלקו אותו ב־1000000000 כדי לקרוא אותו בשניות. הקריאה השנייה מתבצעת כשהמודל כבר נמצא בזיכרון, ומדווחת על מספר קטן בהרבה. הפער בין שני הערכים האלה הוא העלות שכל משתמש משלם לאחר שהטיימר פג, וזו הסיבה המלאה לשינוי של keep_alive. לאחר פריקת המודל, מטמון הדפים של kernel עדיין מכיל לעיתים קרובות את קובץ המודל. לכן, בשרת עם RAM פנוי, טעינה מחדש עשויה להיות מהירה יותר מהטעינה הראשונה לאחר אתחול. כאשר המטמון הזה מפונה, המשקלים נקראים מהדיסק. לכן, אם העברתם את ספריית המודל לאמצעי אחסון שני, המהירות של אמצעי האחסון הזה קובעת את זמן המינימום של כל טעינה קרה. כדי למדוד את מהירות ההפקה משני צדי ההשהיה הזאת, ראו כיצד למדוד tokens per second בשרת שלכם.

השארת מודל Ollama טעון בזיכרון במהלך בקשה אחת

שלחו את keep_alive יחד עם הבקשה. ההגדרה חלה על המודל מרגע שהבקשה מסתיימת.

curl -s http://localhost:11434/api/chat -d '{
  "model": "qwen3:8b",
  "messages": [{"role": "user", "content": "hello"}],
  "keep_alive": "30m"
}'

ארבעה סוגי ערכים מתקבלים:

  • מחרוזת משך: "30m", "24h", "90s"
  • מספר רגיל, שמתפרש בשניות: 3600
  • ערך שלילי, -1 או "-1m", שפירושו שאין כלל פסק זמן לחוסר פעילות
  • 0, שפירושו ביטול הטעינה לאחר שלמודל אין עוד בקשות פעילות

ערך שמופיע בבקשה גובר על ברירת המחדל של השרת, בשני הכיוונים. הדבר חשוב יותר מכפי שנדמה: לקוח ששולח ערך keep_alive משלו גובר על כל הגדרה שביצעתם בשרת.

אפשר גם לטעון מודל בלי להפיק דבר. שלחו רק את שם המודל. השרת יטען אותו ויחזיר תגובה ריקה עם "done": true.

curl -s http://localhost:11434/api/generate -d '{"model": "qwen3:8b", "keep_alive": "30m"}'

זו הפקודה שיש להפעיל לאחר אתחול, או לאחר משיכת מודל חדש, כדי שהבקשה הראשונה של משתמש אמיתי לא תשלם את מחיר הטעינה. ה־CLI מבצע את אותה פעולה באמצעות דגל:

ollama run --keepalive 30m qwen3:8b "hello"

שמירה על טעינת המודל כברירת מחדל באמצעות OLLAMA_KEEP_ALIVE

השרת קורא את OLLAMA_KEEP_ALIVE בעת העלייה ומשתמש בו עבור כל מודל שאינו נושא ערך משלו. המשתנה מקבל את אותם הפורמטים כמו שדה הבקשה, כך ש-30m, 3600 ו--1 כולם תקינים.

הקושי הוא להבין באיזו סביבה המשתנה צריך להיות מוגדר. הרצת export OLLAMA_KEEP_ALIVE=30m בתוך סשן ה-SSH שלכם לא תבצע דבר, כיוון שהתקנה ארוזה מריצה את השרת כשירות systemd תחת משתמש ייעודי עם סביבה משלו. ה-shell שלכם והשירות הזה לעולם אינם נפגשים. זוהי הסיבה הנפוצה ביותר לכך שההגדרה נראית כאילו היא מתעלמת מהערך שנקבע.

הפכו את ההגדרה לעמידה באתחול מחדש באמצעות drop-in של systemd

sudo systemctl edit ollama.service

העורך נפתח ובו שני סמני הערה. הקלידו ביניהם: systemd מתעלם מכל מה שתכתבו מתחת לסמן השני.

[Service]
Environment="OLLAMA_KEEP_ALIVE=30m"

השמירה יוצרת את /etc/systemd/system/ollama.service.d/override.conf. זהו drop-in ולא עריכה של היחידה שסופקה, לכן שדרוג של חבילת Ollama שמחליף את ollama.service לא ישנה את ההגדרה שלכם. אם drop-ins וקובצי יחידות חדשים לכם, המדריך לשירותים ול־timer של systemd מסביר את מנגנון הפעולה.

sudo systemctl daemon-reload
sudo systemctl restart ollama
systemctl show ollama --property=Environment

הפקודה האחרונה מציגה את הסביבה שבה השירות יפעל בפועל. אם OLLAMA_KEEP_ALIVE=30m חסר בשורה הזו, ה־drop-in לא נטען, והסיבה היא כמעט תמיד כותרת [Service] חסרה או שורות שהוקלדו מתחת לסמן. האתחול מחדש עצמו מסיר כל מודל שנטען, ולכן הבקשה הבאה תטען את המודל מחדש. חממו את השירות באמצעות קריאת ה־preload שלמעלה. ה־drop-in שומר את ההגדרה לאחר אתחול מחדש, אך לא את המודל: השירות מופעל עם ollama serve ושום מודל אינו טעון, לכן הריצו את אותה קריאת preload לאחר כל אתחול.

העלות של החזקת מודל בזיכרון

העמודה SIZE בתוך ollama ps מייצגת זיכרון שמוחזק לאורך כל חלון ההמתנה (idle window), ולא רק בזמן עיבוד בקשה. מודל 8B בקוונטיזציה של 4-bit תופס סביב 5 עד 6 GB. מודל 27B הוא סיפור אחר, וכדאי לבצע את חישובי הזיכרון להרצת מודל על שרת VPS מבוסס CPU בלבד לפני שמחליטים להחזיק אותו בזיכרון באופן קבוע. הגדרת keep_alive ל--1 מבטלת את פקיעת התוקף בזמן המתנה; בקשות עתידיות לאותו מודל יכולות לעדכן את ה-timeout שלו או לכפות טעינה מחדש כאשר אפשרויות ה-runner משתנות. בשרת VPS קטן, מדובר בוויתור ישיר על משאבים עבור מסד הנתונים, יישום ה-web ומשימות ה-build שלכם.

עקבו אחר המספרים בפועל במקום להסתמך על הערכות. הריצו את הפקודה הבאה בזמן שהמודל טעון, ולאחר מכן שוב לאחר ollama stop:

free -h

העמודה available מציגה את הזיכרון שה-kernel עדיין יכול להקצות לתהליך חדש. בשרת עם GPU של NVIDIA, הפקודה nvidia-smi מציגה תמונה דומה עבור ה-VRAM. אם השרת אוזל ממשאבים, ה-kernel יסיים תהליך כדי לפנות מקום:

sudo dmesg -T | grep -i "out of memory"

שורה המציינת את ollama פירושה ששרת המודל היה הקורבן. שורה המציינת את מסד הנתונים שלכם פירושה שהמודל "ניצח" ומשהו שחשוב לכם "הפסיד". שתי התוצאות נובעות מאותה החלטה: חלון keep-alive ארוך מדי בשרת ללא מרווח נשימה.

ישנן שתי עלויות שקל לפספס. אורך הקשר (context length) ארוך יותר משריין KV cache גדול יותר (key value cache, מצב ה-attention לכל token שהמודל שומר בזמן יצירת פלט), וזיכרון זה הוא חלק מהזיכרון התפוס (resident size). גודלו נגזר מ-num_ctx, לכן הגדלת חלון ההקשר מגדילה את הזיכרון שהמודל התפוס מחזיק לאורך כל תקופת ההמתנה, ולא רק בזמן מתן תשובה. ערך OLLAMA_NUM_PARALLEL הגדול מ-1 משריין את ה-cache הזה פעם אחת עבור כל slot מקבילי, כאשר המודל תומך בכך. הגרסה Ollama v0.40.16 כופה מקביליות של 1 עבור מודלים ללא יכולת השלמה, כולל מודלי embedding; ה-scheduler שלה כבר לא מבדיל בין mllama ל-qwen3next. אם אתם מתכננים לשרת כמה משתמשים ממודל אחד, חשבו את הזיכרון לפי ה-slots, ולא רק לפי משקלי המודל.

ברירת מחדל סבירה: מודל אחד בשרת עם מרווח נשימה יכול להשתמש ב--1. שרת משותף צריך להשתמש בחלון שמכסה את הפערים בין הבקשות שלכם, כמו 30m, כך שהזיכרון יתפנה כאשר תפסיקו לעבוד.

ביטול טעינה מיידי של מודל

ollama stop qwen3:8b

הפקודה מחזירה פלט ריק לאחר בקשת התפוגה. ביטול הטעינה ממתין לסיום בקשות פעילות, ולכן הפקודה יכולה להסתיים לפני שהזיכרון משתחרר. היא מחזירה פלט ריק גם עבור מודל שהורד לשרת, אך אינו טעון בו כעת. הפקודה אינה בודקת אילו מודלים נמצאים בזיכרון. היא שולחת את בקשת ביטול הטעינה, והשרת מחזיר הצלחה, בין שבזיכרון נטען מודל ובין שלא. השגיאה couldn't find model "qwen3:8b" to stop מופיעה רק כאשר לא מותקן בשרת מודל בשם זה. בדרך כלל הסיבה לכך היא שגיאת כתיב בשם או בתג. לכן, ollama stop ללא פלט אינו מוכיח שזיכרון כלשהו השתחרר. ollama ps כן מוכיח זאת. צורת השימוש ב־API היא בקשה ללא prompt, כאשר keep_alive מוגדר לערך 0:

curl -s http://localhost:11434/api/chat -d '{"model": "qwen3:8b", "messages": [], "keep_alive": 0}'

התגובה כוללת את "done_reason": "unload". השתמשו בפקודה זו במקום להפעיל מחדש את השירות. systemctl restart ollama משחררת גם את הזיכרון, אך היא מבטלת את הטעינה של כל מודל אחר שנטען ומפסיקה כל בקשה שהייתה פעילה.

הרצת יותר ממודל אחד בשרת

OLLAMA_MAX_LOADED_MODELS מגביל את מספר המודלים שיכולים להישאר טעונים בו-זמנית. נכון לאוקטובר 2026, ברירת המחדל היא 3 מודלים לכל GPU, או 3 במחשב ללא GPU. המגבלה סופרת מודלים, אך הזיכרון הוא המגבלה בפועל. לכן ייתכן שמודל גדול שני לא יקבל מקום זמן רב לפני שתגיעו ל-3.

כאשר מתבקש מודל חדש ואין מספיק זיכרון עבורו, או כאשר המגבלה הושגה, המתזמן פורק אחד מהמודלים שכבר טעונים כדי לפנות מקום. הוא מעדיף מודל שאין עבורו בקשה פעילה. הוא עשוי לפרוק גם מודל שהטיימר שלו עדיין לא פג, כולל מודל שנטען עם -1, אך הוא מנסה תחילה מודלים עם חלונות זמן קצרים יותר. לכן ערך שלילי ב-keep_alive פירושו שאין פסק זמן לחוסר פעילות. ההגדרה אינה מקבעת את המשקלים ומונעת טעינת מודל אחר לפי דרישתו.

ההחלטות האלה מופיעות בלוג של השירות, אך המקרה שבו הושגה המגבלה נרשם רק ברמת debug. הוסיפו שורת Environment="OLLAMA_DEBUG=1" שנייה לאותו drop-in, הפעילו מחדש את השירות ועקבו אחר הלוג:

sudo journalctl -u ollama -f

קראו את הסיבה שמופיעה לצד הבקשה שהפעילה את פריקת המודל. max runners achieved, unloading one to make room פירושו שהמגבלה OLLAMA_MAX_LOADED_MODELS הושגה. מצב כזה יכול להתרחש גם כאשר שני המודלים יכולים להיכנס לזיכרון, ולכן הגדילו את המגבלה אם free -h מציג מרווח זיכרון פנוי. שורה המציינת שהמודל החדש צפוי לחרוג מהזיכרון הזמין, ולאחריה פריקה, פירושה שבדיקת ההתאמה של המתזמן דחתה את טעינת שני המודלים יחד בהתאם למרווח הזיכרון הזמין. במקרה כזה, הפתרון הוא להפעיל פחות מודלים במחשב הזה, או להגדיר חלון זמן ארוך עבור המודל שחייב להשיב במהירות, ולהשתמש ב-0 עבור המודל שאתם מפעילים לעיתים רחוקות.

הנחיות שרלוונטיות גם לאחר הגרסה הבאה

Ollama משחררת גרסאות בתדירות גבוהה וערכי ברירת המחדל משתנים, לכן מומלץ לבדוק את ה-build הנוכחי שברשותכם במקום לשנן מספרים:

ollama --version
ollama serve --help

ollama serve --help מציג את משתני הסביבה שה-build הספציפי הזה קורא בפועל, וביניהם OLLAMA_KEEP_ALIVE. שני כללים נותרו יציבים לאורך הגרסאות וניתן להסתמך עליהם. ערך שנשלח בבקשה (request) גובר על ברירת המחדל של השרת. בנוסף, ollama ps הוא המקור האמין ביותר למה שנטען בפועל, ללא קשר למה שמוגדר בקובץ התצורה.

אם עורך קוד או סוכן (agent) מנהלים את השרת שלכם, בדקו מה הלקוח שולח לפני שאתם מאשימים את השרת. הפניית סוכן קידוד לשרת Ollama עצמי מפרט היכן נמצאות הגדרות הבקשה הללו.

FAQ

מדוע Ollama פורק את המודל שלי לאחר 5 דקות?

חמש דקות הן ברירת המחדל של keep_alive, טיימר חוסר הפעילות ש־Ollama מפעיל כאשר בקשה מסתיימת. כאשר הטיימר פג, השרת משחרר את המשקולות, ולכן הבקשה הבאה צריכה לטעון אותן מחדש. הטעינה מחדש היא ההשהיה שאתם מרגישים. אפשר להאריך אותו עבור בקשה אחת באמצעות שליחת "keep_alive": "30m" בגוף ה־JSON, או עבור השרת כולו באמצעות משתנה הסביבה OLLAMA_KEEP_ALIVE.

כיצד משאירים מודל של Ollama טעון בזיכרון לצמיתות?

השתמשו בערך שלילי: "keep_alive": -1 בבקשה, או OLLAMA_KEEP_ALIVE=-1 עבור השרת. לאחר מכן ollama ps מציג Forever בעמודה UNTIL. פעולה זו מסירה את טיימר חוסר הפעילות בלבד. אם מתבקש מודל אחר ואין די זיכרון, המתזמן עדיין יפרוק את המודל הזה כדי לפנות מקום. בקשות מאוחרות יותר לאותו מודל עשויות גם להחליף את הזמן הקצוב שלו או להפעיל טעינה מחדש כאשר אפשרויות ה־runner משתנות. גם אתחול של השירות או של השרת מנקה הגדרה זו, ולכן יש לטעון את המודל מראש מחדש לאחר מכן.

מדוע מתעלמים מ־OLLAMA_KEEP_ALIVE?

בדקו היכן הגדרתם אותו. הריצו systemctl show ollama --property=Environment. אם המשתנה אינו מופיע בפלט, השרת מעולם לא קיבל אותו, משום שמשתנה שיוצא מה־shell שלכם אינו מגיע לשירות systemd. הגדירו אותו באמצעות sudo systemctl edit ollama.service, ולאחר מכן הריצו sudo systemctl daemon-reload ו־sudo systemctl restart ollama. סיבה אחרת היא לקוח ששולח keep_alive משלו בבקשה, ובכך עוקף את ברירת המחדל של השרת.

כיצד משחררים את הזיכרון בלי להפעיל מחדש את Ollama?

ollama stop qwen3:8b מבקש לפוג את תוקפו של אותו מודל בלבד, ומשאיר את השרת ואת כל שאר המודלים הטעונים פעילים. בקשות פעילות חייבות להסתיים לפני שהמודל יפורק. דרך ה־API, שלחו בקשה ללא prompt ועם "keep_alive": 0, והתשובה תוחזר עם "done_reason": "unload". אשרו זאת באמצעות ollama ps. לאחר השלמת הפריקה, המודל כבר לא אמור להופיע ברשימה.

האם המאמר הזה היה מועיל?