SSD Nodes Learn Hosting plans →
מדריכים Matt Connorמאת Matt Connor · עודכן 2026-11-04

Ollama או llama.cpp: מה עדיף להריץ על VPS?

מה ההבדל בין Ollama לבין llama.cpp בשרת ללא GPU? גלו מתי כדאי להשתמש ב-daemon של Ollama ומתי עדיף להריץ ישירות את llama.cpp כדי לחסוך בזיכרון RAM יקר ב-VPS.

Ollama לעומת llama.cpp: באיזו שכבה כדאי להשתמש?

Ollama ו-llama.cpp אינם מתחרים במובן שהשאלה מרמזת עליו. llama.cpp הוא מנוע ה-inference: הוא טוען קובץ מודל והופך prompt ל-tokens. Ollama הוא מנהל מודלים, daemon שרץ ברקע ו-HTTP API שיושב על גבי המנוע הזה. ה-README של Ollama עדיין מציין את llama.cpp כ-backend ה-inference שלו (נבדק ב-27 באוקטובר 2026). לכן, השאלה האמיתית היא על איזו שכבה ברצונכם לעבוד ב-VPS, ולא איזו מהן מהירה יותר.

הריצו את Ollama כאשר אתם זקוקים לשירות שמושך מודלים לפי שם וממשיך לעבוד ללא צורך בתחזוקה. הריצו את llama.cpp ישירות כאשר השרת קטן ואתם צריכים לבחור את קובץ המודל המדויק, את גודל ה-context המדויק ואת מספר ה-threads המדויק, כיוון שב-VPS קטן כל אחת מההגדרות הללו עולה בזיכרון שאין לכם.

מהותם של הפרויקטים

llama.cpp הוא מימוש ב-C וב-C++ של הסקת (inference) מודלי transformer, הבנוי על גבי ספריית ggml. הוא קורא קובצי GGUF. פורמט GGUF (ראשי תיבות של GGML universal file format) הוא מכולה בקובץ יחיד המכילה את המשקולות, את ה-tokeniser ואת המטא-נתונים שהמנוע דורש כדי להריץ את המודל. הפרויקט מפיץ קבצים בינאריים נפרדים עבור משימות שונות. llama-server הוא שרת HTTP, llama-cli הוא ממשק שורת פקודה אינטראקטיבי, ו-llama-bench מודד את קצב העיבוד (throughput). הפרויקט מפיץ כעת גרסאות לפי תקינה סמנטית (MAJOR.MINOR.PATCH); גרסה v0.7.0, שפורסמה ב-15 באוקטובר 2026, הייתה הגרסה האחרונה נכון ל-27 באוקטובר 2026. תגיות nightly ממוספרות ממשיכות להתפרסם לצד הגרסאות הרשמיות, לעיתים כמה פעמים ביום, כאשר הגרסה החדשה ביותר נכון ל-27 באוקטובר 2026 היא b11913.

Ollama היא תוכנית שנכתבה ב-Go. דמון (daemon) הפועל ברקע, שמופעל באמצעות ollama serve, טוען מודלים ומשיב לבקשות HTTP, ולקוח שורת פקודה מתקשר עם דמון זה. מאחורי שניהם עומד מאגר (registry) בכתובת ollama.com המכיל מודלים ארוזים מראש. Ollama משתמשת בגרסאות סמנטיות. גרסה v0.32.5 הופצה ב-27 ביולי 2026, וגרסה v0.40.12 שוחררה ב-27 באוקטובר 2026 בשעה 00:07 UTC. הפקודה ollama pull מורידה קובץ GGUF יחד עם תבנית prompt וקבוצת פרמטרי ברירת מחדל, ולאחר מכן מאחסנת אותו תחת /usr/share/ollama/.ollama/models בלינוקס. קבצים אלו ממוקמים על כונן ה-root ומגיעים לנפח של כמה גיגה-בייטים כל אחד; לכן, בשרת VPS עם נפח root של 25 GB, כדאי לדעת מה נשאר לאחר פעולת pull וכיצד להעביר את ספריית המודלים למקום אחר לפני שהורדה שלישית תמלא את הדיסק.

האריזה היא ההבדל המהותי. Ollama קובעת עבורך את ה-quantisation, את התבנית ואת אורך ה-context, ומספקת שם אחד בלבד לזכור. llama.cpp חושף את הבחירות הללו כדגלים (flags), עם ערכי ברירת מחדל אוטומטיים עבור הגדרות שלא צוינו.

ציר 1: בקרת מודל וקוונטיזציה (Quantisation)

קוונטיזציה מאחסנת את המשקולות במספר ביטים קטן יותר מ-16 או 32 הביטים של המודל המקורי, כאשר גרסאות GGUF נפוצות משתמשות בממוצע בכ-4, 5 או 8 ביטים לכל משקולת. הדיוק אינו אחיד לאורך הקובץ. בקוד המקור של הקוונטיזר ב-llama.cpp (נכון ל-27 באוקטובר 2026), גרסת Q4_K_M שומרת את רוב הטנסורים ב-4-bit, אך מקצה לשכבת הפלט, לטנסורי ה-attention value ולטנסורי ה-feed-forward down בכמחצית מהשכבות, דיוק של 6-bit מסוג Q6_K. טנסורים קטנים, כגון ה-norms, אינם עוברים קוונטיזציה כלל. זה מה שמאפשר למודל של 8 מיליארד פרמטרים להיכנס לזיכרון ה-RAM של שרת VPS סטנדרטי. שמות הקבצים בפורמט GGUF מובנים ברגע שמכירים את התבנית: Q4_K_M פירושו K-quant של 4-bit, בגודל בינוני. מספר גבוה יותר שומר על דיוק רב יותר אך דורש יותר זיכרון.

תרשיםMeta-Llama-3.1-8B-Instruct GGUF file size by quantisation (GiB)
הנתונים שמאחורי התרשים
[
  {
    "label": "Q2_K",
    "file_size_gib": 2.96
  },
  {
    "label": "Q3_K_M",
    "file_size_gib": 3.74
  },
  {
    "label": "Q4_K_M",
    "file_size_gib": 4.58
  },
  {
    "label": "Q5_K_M",
    "file_size_gib": 5.34
  },
  {
    "label": "Q6_K",
    "file_size_gib": 6.14
  },
  {
    "label": "Q8_0",
    "file_size_gib": 7.95
  }
]

אלו הם גדלי הקבצים שפורסמו במאגר bartowski/Meta-Llama-3.1-8B-Instruct-GGUF ב-Hugging Face, נכון ל-2 באוגוסט 2026, לאחר המרה מבתים ל-GiB. קיימים 6 בילדים (builds) למודל אחד, כאשר הקטן ביותר הוא 2.96 GiB לעומת 7.95 GiB לגדול ביותר. ברירת המחדל הנפוצה, Q4_K_M, היא 4.58 GiB. בשרת VPS עם 4 GiB, בחירה זו קובעת האם המודל ייטען בכלל. הגודל הוא רק חצי מהשיקול, כיוון ששורה שניתן להרשות לעצמך אינה בהכרח שורה שכדאי להשתמש בה, ו-מה העלות האמיתית של Q4, Q8 ו-fp16 באיכות התשובה היא זו שתקבע אם הגיגה-בייטים הנוספים מספקים תמורה מורגשת.

ב-llama.cpp אתם מציינים את שם הקובץ, כך שאתם בוחרים את השורה בעצמכם.

llama-server -m ~/models/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf \
  -c 4096 -t 4 --host 127.0.0.1 --port 8080

-c הוא גודל ההקשר (context size) בטוקנים, -t הוא מספר התהליכונים (threads), ו--ngl קובע כמה שכבות יועברו ל-GPU (ערך 0 בשרת ללא GPU). להגדרות שלא צוינו יש ערכי ברירת מחדל, ו---fit מופעל כברירת מחדל כדי להתאים הגדרות חסרות לזיכרון המכשיר.

ב-Ollama הקוונטיזציה נגזרת מהתג (tag) שאתם מושכים, ו-ollama ls מציג מה קיים אצלכם בדיסק. כאשר ה-registry אינו מכיל את הבילד הרצוי, ייבאו קובץ GGUF בעצמכם. צרו Modelfile:

FROM ./Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf
PARAMETER num_ctx 4096

לאחר מכן בצעו build ובדקו את התוצאה:

ollama create llama31-q4 -f ./Modelfile
ollama ls

אורך ההקשר הוא ההגדרה שמכשילה משתמשים רבים. Ollama בוחרת את ברירת המחדל שלה לפי ה-VRAM הזמין, ושרת ללא GPU נופל לקטגוריה הקטנה ביותר: 4096 טוקנים. אם תשלחו לו מסמך של 20,000 טוקנים, הטוקנים העודפים יימחקו לפני שהמודל יראה אותם, ולכן התשובה תהיה שגויה בביטחון מלא לגבי קובץ שהוא קרא רק בחציו. הגדילו את הערך באמצעות OLLAMA_CONTEXT_LENGTH ב-daemon, או באמצעות PARAMETER num_ctx בתוך Modelfile. אם רק משימה אחת זקוקה לחלון גדול יותר, ניתן להגדיר num_ctx לכל בקשה בנפרד במקום ברמת השרת, מה שמונע מה-cache הנוסף להשפיע על כל שאר המשימות שה-daemon מבצע. ל-llama.cpp אין ברירת מחדל אמינה. הגדירו את -c במפורש ודעו מה הגדרתם.

החשבון האריתמטי של הזיכרון שאף אחד לא מראה לכם

קובץ המודל אינו העלות היחידה. ה-KV cache (מטמון מפתחות/ערכים) מחזיק רשומה אחת לכל שכבה עבור כל טוקן בהקשר, והוא גדל ככל שהשיחה מתארכת.

בואו נחשב זאת עבור Llama 3.1 8B. למודל יש 32 שכבות, 8 ראשי מפתח/ערך ומימד ראש של 128. כל טוקן מאחסן גם מפתח וגם ערך ב-2 בתים כל אחד בפורמט f16, כלומר 2 x 8 x 128 x 2 = 4096 בתים לכל שכבה. לאורך 32 שכבות מדובר ב-128 KiB לכל טוקן. לכן, הקשר של 4096 טוקנים עולה 512 MiB, והקשר של 32,768 טוקנים עולה 4 GiB.

לפיכך, מודל Q4_K_M 8B עם הקשר של 4k דורש בערך 4.58 GiB עבור המשקולות, פלוס כ-0.5 GiB עבור המטמון, בתוספת סביבת הריצה עצמה. הוא לא ייכנס ב-4 GiB של RAM. הוא ייכנס ב-8 GiB עם מרווח עבודה. אם תעלו את ההקשר ל-32k באותה מכונת 8 GiB, המטמון לבדו יאכל את כל המרווח הפנוי. עקבו אחר המצב בזמן אמת עם free -h בזמן שהמודל נטען, ואל תסמכו על הערכה שלא מדדתם בעצמכם. אם אתם מתכננים משאבים עבור מודל הגדול מ-8B, אותו חישוב אריתמטי שבוצע עבור מודל 27B על שרת VPS מבוסס CPU בלבד מראה מה כל רמת זיכרון מ-8 עד 64 GB מסוגלת להחזיק בפועל.

Ollama מכפילה את זה. הערך המוגדר כברירת מחדל ב-OLLAMA_NUM_PARALLEL הוא 1, והזיכרון שהמודל דורש גדל בהתאם למכפלה של מספר זה באורך ההקשר. אם תעלו את שניהם בו-זמנית, ה-daemon יבקש בשקט פי כמה מה-RAM שציפיתם לו. אותו חישוב אריתמטי קובע את תקרת המשתמשים הסימולטניים שלכם, כיוון שכל בקשה מקבילה דורשת נתח משלה ב-KV cache, וזו הסיבה לכך ששרת שמרגיש תקין עבור אדם אחד קורס תחת עומס של חמישה.

ציר 2: ה-daemon שעליך להפעיל

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

sudo systemctl edit ollama
[Service]
Environment="OLLAMA_CONTEXT_LENGTH=8192"
Environment="OLLAMA_KEEP_ALIVE=30m"
sudo systemctl daemon-reload
sudo systemctl restart ollama
journalctl -e -u ollama

OLLAMA_KEEP_ALIVE חשוב בשרתי CPU VPS יותר מבכל מקום אחר. מודלים נשמרים בזיכרון למשך 5 דקות כברירת מחדל ולאחר מכן מוסרים ממנו. הבקשה הבאה מחייבת טעינה מחדש של הקובץ כולו לפני מתן מענה. אם ה-kernel עדיין מחזיק את הקובץ ב-page cache שלו, הפעולה מהירה, אך רק זיכרון RAM פנוי שומר אותו שם. ברגע שעומס עבודה אחר דוחק אותו החוצה, הקובץ נטען מחדש מהדיסק, כך שטעינה של 4.58 GiB הופכת תגובה של שתי שניות לתגובה של שלושים שניות באחסון איטי. הגדרת keep-alive ארוך פותרת את בעיית ה-latency ומשתמשת ב-RAM באופן קבוע. לשתי האפשרויות יש עלות ממשית. בחר את זו שפוגעת פחות. אם החלטת שהמודל צריך להישאר בזיכרון, הגדרת keep_alive כך שישרוד תקופות המתנה ואתחולים דורשת שורות בודדות וחוסכת ממך את הצורך בחימום המודל ידנית בכל פעם שהשרת עולה.

llama.cpp אינו מספק daemon או משתמש שירות, לכן עליך להגדיר את שניהם בעצמך. מתוך ספריית ה-llama.cpp שבה ביצעת את ה-build, התקן את ה-binary ואת הספריות שלו לתוך /usr/local, צור משתמש llama, ותן לו עותק של המודל:

sudo cmake --install build
sudo ldconfig
sudo useradd --system --no-create-home --shell /usr/sbin/nologin llama
sudo install -d -o llama -g llama /srv/models
sudo install -o llama -g llama -m 644 ~/models/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf /srv/models/model-Q4_K_M.gguf

אם השתמשת ב-release archive במקום ב-build, כוון את ExecStart אל ה-llama-server שבתוכו, כיוון שה-archive שומר את הספריות שלו לצד ה-binary. לאחר מכן, כתוב את היחידה כ-/etc/systemd/system/llama-server.service:

[Unit]
Description=llama.cpp server
After=network-online.target

[Service]
ExecStart=/usr/local/bin/llama-server -m /srv/models/model-Q4_K_M.gguf -c 4096 -t 4 --host 127.0.0.1 --port 8080
Restart=always
RestartSec=3
User=llama

[Install]
WantedBy=multi-user.target

הפעל אותה בעזרת sudo systemctl enable --now llama-server. התהליך מחזיק כעת את המודל לאורך כל זמן פעולתו. כברירת מחדל, שום דבר לא מוסר מהזיכרון בזמן המתנה, אך הוספת --sleep-idle-seconds מאפשרת הסרה וטעינה אוטומטית ללא עצירת השירות. אם כתיבת יחידות היא תחום חדש עבורך, מדובר באותה תבנית של הרצת שירותים עצמאיים תחת systemd ב-VPS.

ציר 3: ה-API שאליו היישום שלכם יתקשר

ציר זה הצטמצם משמעותית. שני הפרויקטים תומכים כעת בפורמט ה-chat של OpenAI, כך שרוב ספריות הלקוח עובדות מול שניהם לאחר שינוי של ה-base URL בלבד.

Ollama מאזין ב־127.0.0.1:11434. הנתיב התואם ל־OpenAI הוא http://localhost:11434/v1/chat/completions, ולצדו קיים גם API מקורי ב־/api/chat. בנוסף, מתועד נתיב התואם ל־Anthropic. אף אחד מהנתיבים האלה אינו מאפשר למודל לחפש מידע בעצמו. לכן, אם היישום זקוק לתשובות עדכניות יותר מנתוני האימון של המודל, תכננו לחבר חיפוש באינטרנט באמצעות ה־API של Ollama,‏ Open WebUI או לולאת כלים קצרה.

curl -X POST http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model": "llama31-q4", "messages": [{"role": "user", "content": "Say this is a test"}]}'

כאשר הוא מופעל עם הדגלים שלעיל, llama-server מאזין ב-127.0.0.1:8080. כברירת מחדל, הוא מאזין כעת לפורט 9931 (נבדק ב-27 באוקטובר 2026), לכן השאירו את --port בשורת הפקודה אם היישום שלכם מצפה ל-8080. הוא מגיש את /v1/chat/completions, /v1/completions ו-/v1/embeddings, בנוסף ל-endpoint ייעודי משלו /completion וממשק אינטרנט מובנה. הוא גם חושף נתיבים תפעוליים ש-Ollama אינו מציע: /health לבדיקת מוכנות (readiness probe), /props להגדרות המודל הטעון, /slots לסטטוס של כל slot בקשה, ו-/metrics בפורמט Prometheus לאחר שתוסיפו את --metrics, כיוון ש-endpoint זה כבוי כברירת מחדל. אם אתם מתכננים לנטר שירות זה, הבדל זה הוא כנראה מה שיכריע את ההחלטה.

אף אחד מהשרתים אינו מפעיל אימות (authentication) עבורכם. שניהם מוגדרים כברירת מחדל ל-loopback מסיבות טובות. גשו אליהם דרך SSH tunnel או מאחורי reverse proxy, ולעולם אל תפתחו את 11434 או 8080 לאינטרנט.

מה שרת VPS מבוסס CPU בלבד יכול לעשות בפועל

שרת VPS מבוסס CPU בלבד מריץ מודלים קטנים באיטיות. זהו הסיכום הכנה, והחלק המועיל הוא לדעת היכן עובר הגבול. בצעו מדידות לפני שאתם מתכננים משהו סביב זה:

llama-bench -m ~/models/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf -p 512 -n 128

עמודת pp מייצגת את מהירות עיבוד ה-prompt, ועמודת tg מייצגת את מהירות יצירת ה-tokens, שתיהן ב-tokens לשנייה. בתוכנית vCPU משותפת, מודל 8B בפורמט Q4_K_M מגיע בדרך כלל לערכים חד-ספרתיים נמוכים ב-tg. עיבוד ה-prompt הוא החלק הבעייתי: כל ה-prompt מעובד לפני שמופיע ה-token הראשון, לכן prompt מערכת ארוך מוסיף זמן המתנה לכל בקשה. אורך התשובה הוא החצי השני של המשוואה שניתן לשלוט בו, כיוון שבקצב של שלושה tokens לשנייה, מודל שפולט 600 tokens תופס את השרת למשך 200 שניות – מעל שלוש דקות של יצירה בלבד. לכן, הגבלת הפלט באמצעות num_predict היא הדרך הזולה ביותר למנוע מתשובה ארוכה מדי לגרום ל-timeout.

מה שמיש על CPU: מודל בגודל 1B עד 4B לביצוע סיווג, חילוץ נתונים, סיכומים קצרים או ניתוב. תשובות מגיעות תוך שניות והזיכרון מתאים לתוכנית אירוח רגילה. לדוגמה מעשית בגודל זה במקום טווח גדלים, Nemotron 3.5 Lightning שנמשך ונמדד על VPS מספק את התג המדויק, את ה-RAM הנדרש בפועל ואת המהירות המתקבלת ללא GPU. מה שאינו מיש על CPU: צ'אט אינטראקטיבי במהירות קריאה, עוזרי כתיבת קוד, עבודה על מסמכים ארוכים, או כל דבר הכולל לולאת סוכן (agent loop) המבצעת קריאות רבות ברצף. לולאה שמבצעת שתים-עשרה קריאות של ארבע שניות כל אחת תיקח דקה לפני שתפיק תוצאה כלשהי. אם התוכנית הייתה בכל מקרה להשתמש בעוזר כתיבת קוד, הפניית סוכן למודל שאתם מארחים בעצמכם מבהירה אילו משימות מודל מקומי קטן באמת מנצח, ואילו מהן חייבות להישאר ב-API מאוחסן.

ישנן שתי דרכי פעולה כאשר המספרים אינם מספקים. אם הבעיה היא concurrency, כלומר משתמשים רבים הפונים למודל אחד בו-זמנית, בחירת המנוע משתנה, ו-השוואה בין Ollama ל-vLLM עבור שירות במקביל מכסה את הנושא הזה. אם הבעיה היא מהירות גולמית, הפתרון הוא שרת VPS עם GPU מחובר, שם -ngl מתחיל להיות בעל משמעות. לפני כל אחד מהצעדים הללו, קבעו baseline לחומרה עצמה, כיוון שרוחב הפס של הדיסק והזיכרון משפיעים על זמן הטעינה לא פחות מה-CPU. ביצוע benchmark חוזר ל-VPS שווה את השעה שתשקיעו בו.

התקנת llama.cpp, בגרסה מקובעת

שני הפרויקטים מתעדכנים מדי שבוע, לכן תעדו את הגרסה שהתקנתם. פקודת ה-one-liner של המקור מתקינה את הגרסה העדכנית ביותר:

curl -LsSf https://llama.app/install.sh | sh
llama serve -hf ggml-org/Qwen3.5-0.8B-GGUF

כדי לקבע גרסה ספציפית, הורידו את קובץ ה-tarball המוכן מראש מדף ה-releases. הפרויקט מפרסם כעת גם גרסאות עם מספור סמנטי: v0.7.0 הייתה הגרסה האחרונה ב-27 באוקטובר 2026, ודף ה-release שלה מפנה ל-nightly b11669 עבור הקבצים הבינאריים. v0.8.0 שוחררה ב-28 באוקטובר 2026, ודף ה-release שלה מפנה ל-nightly b11960 עבור הקבצים הבינאריים. הפקודות להלן משתמשות ב-b10224, ה-tag העדכני נכון ל-2 באוגוסט 2026; החליפו אותו בכל tag שבדקתם:

curl -LO https://github.com/ggml-org/llama.cpp/releases/download/b10224/llama-b10224-bin-ubuntu-x64.tar.gz
tar xf llama-b10224-bin-ubuntu-x64.tar.gz
find . -type f -name 'llama-server'

לחלופין, ניתן לקמפל את אותו ה-tag ממקור:

sudo apt update && sudo apt install -y build-essential cmake git libssl-dev
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
git checkout b10224
cmake -B build
cmake --build build --config Release -j $(nproc)

libssl-dev הוא התלות המתועדת עבור תכונות HTTPS. תהליך הקימפול אורך מספר דקות ודורש יותר RAM ממה שזמין בתוכניות האירוח הקטנות ביותר; לכן, קמפלו על שרת חזק יותר והעתיקו את הקבצים הבינאריים אם השרת הקטן נתקל במחסור בזיכרון.

התקנת Ollama, בגרסה מקובעת

curl -fsSL https://ollama.com/install.sh | OLLAMA_VERSION=0.32.5 sh
ollama -v

הסקריפט קורא את OLLAMA_VERSION, כך שניתן לקבע גרסה יציבה ומוכרת במקום להשתמש במה ששוחרר הבוקר. הגרסה v0.32.5 פורסמה ב-27 ביולי 2026. קיימת גם דרך ידנית אם אינכם מעוניינים להריץ סקריפט ישירות לתוך ה-shell:

sudo rm -rf /usr/lib/ollama
curl -fsSL https://ollama.com/download/ollama-linux-amd64.tar.zst | sudo tar x -C /usr
ollama -v

הדרך הידנית אינה יוצרת את יחידת ה-systemd או את משתמש השירות, לכן עליכם להוסיף אותם בעצמכם. המדריך המלא להתקנת Ollama על גבי VPS מכסה את שלבי הגדרת השירות צעד אחר צעד.

מצבי כשל והודעות שגיאה

Ollama מסרב לטעון את המודל. גרסאות ישנות של Ollama בדקו את גודל המודל לפני הטעינה, והיו מחזירות שורה במבנה הבא: ollama run

Error: model requires more system memory (5.6 GiB) than is available (3.2 GiB)

קוד המקור הנוכחי של Ollama כבר אינו כולל הודעה זו (נבדק ב-27 באוקטובר 2026). כיום Ollama מעביר את פעולת הטעינה ל-llama-server, ולכן מודל שאינו נכנס בזיכרון מופיע ככשל של ה-runner, עם שגיאות שמתחילות כך:

llama-server reported out-of-memory during startup
llama-server process has terminated

כך או כך, הפתרון זהה. עברו לשורת קוונטיזציה (quantisation) אחת נמוכה יותר, צמצמו את אורך ההקשר (context length), או בחרו מודל קטן יותר.

llama.cpp לא קורס, אלא זוחל. כברירת מחדל, llama.cpp מבצע memory-map לקובץ ה-GGUF, כך שקובץ הגדול מה-RAM עדיין יתחיל לעבוד. במצב זה, ה-kernel מבצע paging למשקולות מהדיסק בכל token, ומהירות היצירה צונחת לשניות לכל token, כאשר הדיסק נמצא ב-100 אחוזי ניצול. העבירו את הדגל --load-mode none כדי לבטל את ה-memory mapping. אפשרות זו החליפה את --no-mmap, אשר מתועד כ-deprecated בגרסת ה-build הנעוצה b10224 ואינו מופיע עוד בגרסאות נוכחיות (נבדק ב-29 באוקטובר 2026). כאשר ה-kernel מתערב, dmesg מציג את הסיבה:

Out of memory: Killed process 1234 (llama-server)

קובץ המודל אינו נטען כלל. קובץ GGUF שנבנה עבור משפחת מודלים חדשה יותר מהמנוע שלכם יציג שגיאה המציינת את הארכיטקטורה שאינה מוכרת, כאשר <arch> הוא השם השמור במטא-דאטה של הקובץ:

llama_model_load: error loading model: unknown model architecture: '<arch>'

הפתרון הוא שדרוג המנוע, ולא החלפת הקובץ. זהו המחיר של נעילת גרסאות (pinning), וזו הסיבה שעליכם לתעד את מספר ה-build. עליכם לדעת מאיזו גרסה אתם משדרגים.

ה-API עונה מקומית אך לא מהאפליקציה שלכם. Ollama מאזין ל-127.0.0.1:11434, ולכן מארח אחר יקבל שגיאת connection refused. הגדירו את OLLAMA_HOST=0.0.0.0:11434 ל-systemctl edit ollama רק כאשר הפורט נמצא מאחורי firewall או רשת פרטית, כיוון של-API אין מנגנון אימות מובנה.

התגובה הראשונה לאחר הפסקה איטית מאוד. התרחש תהליך unload עקב חוסר פעילות של 5 דקות, והמודל נטען מחדש מהדיסק אם ה-page cache לא שמר אותו. הרצת ollama ps רגע לפני הבקשה תראה ששום דבר אינו טעון, מה שמאשר זאת. העלו את הערך של OLLAMA_KEEP_ALIVE.

אז מה כדאי להריץ?

הריצו את Ollama כאשר אתם מעוניינים בניהול מודלים אוטומטי ובנקודת קצה (endpoint) בתצורת OpenAI ללא מאמץ נוסף. זוהי ברירת המחדל המתאימה ביותר עבור פריסה ראשונית, ועבור כל תרחיש שבו בחירת המודל עשויה להשתנות.

הריצו את llama.cpp ישירות כאשר זיכרון המערכת מוגבל במידה שמחייבת אתכם לבחור ידנית את רמת ה-quantisation, כאשר אתם זקוקים ל-/health, /slots ו-/metrics לצורכי ניטור, או כאשר נדרש דגל (flag) ש-Ollama אינו חושף. זוהי הבחירה המקצועית עבור שרת VPS שבו המודל בקושי נכנס בזיכרון, שכן ההגדרות המאפשרות את הרצתו הן בדיוק אלו ש-Ollama בוחר עבורכם באופן אוטומטי.

הרצה של שניהם במקביל היא תקינה לחלוטין. השתמשו ב-Ollama לניסויים, וב-llama.cpp עבור המודל היחיד שאתם מעלים לסביבת הייצור (production) ושאינכם מתכננים לשנות.

FAQ

האם Ollama הוא רק מעטפת (wrapper) ל-llama.cpp?

קרוב לכך, אך המעטפת מבצעת עבודה ממשית. ה-README של Ollama מציין את llama.cpp כמנוע ההסקה (inference backend) שלו (נבדק ב-27 באוקטובר 2026). מעליו, Ollama מוסיף רישום מודלים (model registry), תבנית prompt שהופכת הודעות צ'אט ל-prompt, קבוצת פרמטרי דגימה (sampling parameters) כברירת מחדל, daemon עם יכולת פינוי זיכרון בזמן המתנה, ו-HTTP API. כאשר משווים טוקנים לשנייה בהגדרות זהות, משווים את אותו מנוע לעצמו. הבחירה האמיתית היא בין שכבות הניהול.

מה מהיר יותר ב-VPS ללא GPU?

הם חולקים את אותו מנוע, לכן באותו קובץ מודל, קוונטיזציה (quantisation), גודל הקשר (context size) ומספר threads, הביצועים יהיו דומים מאוד. הבדלים שאנשים מדווחים עליהם נובעים בדרך כלל מהגדרות ברירת מחדל שונות, לרוב אורך ההקשר ומספר ה-threads, ולא מהמנוע עצמו. מדדו זאת בעזרת llama-bench -m <file> -p 512 -n 128 והשוו את עמודת tg על השרת שלכם לפני שאתם מסתמכים על נתונים שפורסמו.

האם אני יכול להשתמש בקובץ GGUF משלי עם Ollama?

כן. הניחו את הקובץ על השרת, כתבו Modelfile שהשורה הראשונה בו היא FROM ./your-model.gguf, הוסיפו כל שורת PARAMETER נחוצה כמו num_ctx, ולאחר מכן הריצו את ollama create your-name -f ./Modelfile. הפקודה ollama ls תציג אותו לצד כל מודל שמשכתם מה-registry. כך משתמשים בקוונטיזציה שאינה קיימת ב-registry.

כמה RAM אני צריך עבור מודל 8B?

חשבו את גודל הקובץ, בתוספת ה-KV cache, בתוספת זמן הריצה. גרסת Q4_K_M של Llama 3.1 8B תופסת כ-4.58 GiB על הדיסק, והקשר (context) של 4096 טוקנים מוסיף בערך 512 MiB של cache, לכן 8 GiB של RAM הם כמות נוחה ו-4 GiB אינם מספיקים. ה-cache גדל בהתאם להקשר: אותו מודל בהקשר של 32,768 טוקנים דורש כ-4 GiB של cache בפני עצמו. ב-Ollama, זכרו שהדרישה גדלה גם בהתאם ל-OLLAMA_NUM_PARALLEL.

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