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

KV cache לעומת prompt cache: מה ההבדל ואיך זה משפיע?

הבינו את ההבדל בין KV cache שצורך משאבי RAM בשרת לבין prompt caching שמוזיל עלויות. גלו מדוע ה-KV cache עלול לגרום לשגיאת Out of Memory בעוד שהשני רק משפיע על התעריף.

KV cache לעומת prompt cache: התשובה הקצרה

המונחים KV cache ו־prompt cache של ספק שירות חולקים מילה משותפת, אך מעבר לכך אין ביניהם כמעט דבר. ה־KV cache הוא זיכרון עבודה לכל בקשה (per-request). הוא שוכן ב־RAM או ב־VRAM של השרת שלכם לאורך כל משך החיים של בקשה בודדת, והוא גדל בהתאם לאורך ההקשר (context length) ולמספר הבקשות שאתם מריצים במקביל. לעומת זאת, prompt caching של ספק שירות הוא תכונה הקשורה לחיוב ולזמן תגובה (latency). תחילית קבועה של ה־prompt שלכם נשמרת בשרתי הספק, ולאחר מכן מחויבת בתעריף מוזל כאשר אתם שולחים אותה שוב.

האחד הוא זיכרון שאתם רוכשים כחומרה. השני הוא זיכרון שמישהו אחר מחזיק ואתם משלמים עליו דמי שכירות.

להבדל המעשי יש חשיבות רבה יותר מההגדרה. אתם יכולים למצות את ה־KV cache, וכאשר זה קורה, המודל מסרב להיטען או שהבקשה נדחית. לא ניתן למצות prompt cache. במקרה הגרוע פשוט לא תצליחו להשתמש במטמון (cache miss), ואז תשלמו בשקט את המחיר המלא.

מה מכיל ה-KV cache ומדוע הוא קיים

מודל Transformer שמייצר את הטוקן ה-500 חייב לבצע attention לכל 499 הטוקנים שלפניו. עבור כל אחד מהטוקנים הללו, כל שכבה זקוקה ל-key vector ו-value vector. חישוב מחדש של כולם עבור כל טוקן חדש יגרום לזמן היצירה לגדול בריבוע של אורך הרצף, לכן סביבת הריצה שומרת אותם בזיכרון. מאגר זה הוא ה-KV cache (מטמון מפתחות/ערכים).

זהו מצב (state) ברמת הבקשה, כיוון שהוא נבנה מרצף הטוקנים המדויק של אותה בקשה. שני משתמשים השולחים prompts שונים אינם יכולים לשתף אותו, אלא אם סביבת הריצה מבצעת prefix caching, תכונה נפרדת שמתוארת בהמשך.

הגשת השירות (serving) מתבצעת בשני שלבים. שלב ה-prefill קורא את כל ה-prompt שלכם וממלא את ה-cache, והוא מוגבל על ידי כוח עיבוד (compute). שלב ה-decode מייצר טוקן אחד בכל פעם ומוסיף אותו ל-cache, והוא מוגבל על ידי רוחב פס של זיכרון (memory bandwidth). הפיצול הזה הוא הסיבה לכך שעיבוד ה-prompt ויצירת הטוקנים מציגים מהירויות שונות כאשר אתם מודדים טוקנים לשנייה על השרת שלכם.

כמה זיכרון צורך ה-KV cache?

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

bytes per token = 2 * layers * kv_heads * head_dim * bytes per element

הספרה 2 מייצגת את ה-key ואת ה-value. כל שאר המספרים נגזרים מה-config.json של המודל, כפי שפורסם בדף ה-Hugging Face שלו.

קחו לדוגמה את Llama 3.1 8B. ה-config שלו מציין num_hidden_layers 32 ו-num_key_value_heads 8. ה-hidden_size של 4096, מחולק בין 32 ראשי attention, נותן גודל ראש (head dimension) של 128. בפורמט f16, כל אלמנט תופס 2 בתים:

2 * 32 * 8 * 128 * 2 = 131072 bytes = 128 KiB per token

הכפילו זאת באורך ה-context המבוקש, ולאחר מכן במספר הבקשות המורצות במקביל.

תרשיםLlama 3.1 8B KV cache at f16, in GiB
הנתונים שמאחורי התרשים
[
  {
    "label": "2k context",
    "one_request_gib": 0.25,
    "four_requests_gib": 1
  },
  {
    "label": "8k context",
    "one_request_gib": 1,
    "four_requests_gib": 4
  },
  {
    "label": "32k context",
    "one_request_gib": 4,
    "four_requests_gib": 16
  },
  {
    "label": "128k context",
    "one_request_gib": 16,
    "four_requests_gib": 64
  }
]

ב-context של 8k, ה-cache תופס 1 GiB. ב-32k הוא תופס 4 GiB, טווח דומה למשקולות המודל ב-4-bit. ב-context המלא של המודל, 128k, הוא מגיע ל-16 GiB עבור בקשה אחת, ול-64 GiB אם ארבע בקשות ממלאות אותו במלואו. המשקולות לא השתנו, רק ה-cache גדל.

טכניקת ה-Grouped query attention (GQA) משפיעה משמעותית על מספר זה. ב-Llama 3.1 8B ישנם 8 ראשי key/value המשרתים 32 ראשי query, כך שארבעה ראשי query חולקים זוג key/value מאוחסן אחד. מודל שבו ה-num_key_value_heads שווה ל-num_attention_heads שלו יצרוך פי ארבעה זיכרון cache עבור אותו מספר פרמטרים. בדקו שדה זה לפני שאתם מניחים שעלות ההגשה של שני מודלי 8B היא זהה.

מדוע מודל שרץ ב-2k מסרב להיטען ב-32k

סביבת הריצה משריינת את ה-KV cache בעת טעינת המודל, לפי גודל ה-context length שהגדרת, ולא לפי אורך ה-prompt שאתה שולח בפועל. ברירת המחדל של Ollama אינה עוד מספר יחיד. נכון לאוקטובר 2026, תיעוד ה-context length קובע אותו לפי נפח ה-VRAM: כ-4k במכונות עם פחות מ-24 GiB, כ-32k במכונות עם 24 עד 48 GiB, ו-256k במכונות עם 48 GiB ומעלה, בעוד מודלים בענן משתמשים כברירת מחדל בערך המקסימלי שלהם. שרת VPS מבוסס CPU בלבד או GPU קטן מתחילים ב-4k. העלאת הערך ל-32k משמעותה שביקשת הקצאה נוספת של 4 GiB עוד לפני שהגיע ה-token הראשון. בכרטיס עם 24 GiB, הערך 32k הוא ממילא ברירת המחדל, כך שהשריון הזה מתבצע בין אם ביקשת אותו ובין אם לא.

OLLAMA_CONTEXT_LENGTH=32768 ollama serve

אותה הגדרה לכל session, מתוך ה-prompt האינטראקטיבי:

ollama run llama3.1:8b
/set parameter num_ctx 32768

הכשל נראה אחרת בכל stack. המערכת vLLM בודקת את החישובים בעת העלייה ומסרבת לרוץ:

ValueError: To serve at least one request with the model's max seq len (131072), (16.0 GiB KV cache is needed, which is larger than the available KV cache memory (9.56 GiB). Based on the available memory, the estimated maximum model length is 78336. Try increasing `gpu_memory_utilization` (which also controls CPU memory on the CPU backend) or decreasing `max_model_len` when initializing the engine. See https://docs.vllm.ai/en/latest/configuration/conserving_memory/ for more details.

בשרת VPS מבוסס CPU בלבד המריץ Ollama או llama.cpp, ההקצאה היא ב-RAM של המערכת והחוסר עשוי שלא להתגלות בעת העלייה. מנגנון ה-out-of-memory killer של ה-kernel עוצר את התהליך, והוא משאיר עקבות ב-kernel ring buffer:

dmesg -T | grep -i "killed process"

שורה המציינת את תהליך השרת שלך מעידה על כך שהשרת התחייב ליותר זיכרון ממה שיש לו. הפתרון הוא context קטן יותר, לא קובץ swap גדול יותר: KV cache שנכתב לדיסק נקרא בכל token שנוצר, ולכן מהירות היצירה תואט עד לרמה שאינה שימושית. בחירת מספר הגיוני מוסברת ב-מדריך שלנו ל-num_ctx ו-context length ב-Ollama.

השפעת ה-concurrency על המספר

כל בקשה שנמצאת בעיבוד (in-flight) נושאת איתה את ה-KV cache הייחודי לה. זו השורה שרוב תוכניות הקיבולת מחמיצות. ארבעה משתמשים, שכל אחד מהם מחזיק context של 32k, זקוקים ל-16 GiB במצטבר, מעבר למשקולות המודל.

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

ארבע דרכים להקטנת ה-KV cache

  1. הפחתת אורך ההקשר (context length). זהו המנוף המשמעותי ביותר ובדרך כלל הזול ביותר. רוב עומסי העבודה של צ'אט אינם מתקרבים ל-32k.
  2. קוונטיזציה (Quantization) של ה-cache עצמו. ערכי ברירת המחדל של OLLAMA_KV_CACHE_TYPE ב-Ollama הם f16, והוא תומך ב-q8_0, שמשתמש בכמחצית מהזיכרון, וב-q4_0, שמשתמש ברבע ממנו. המקבילות ב-llama.cpp הן -ctk q8_0 ו--ctv q8_0.
  3. בחירת מודל עם פחות ראשי key/value או פחות שכבות. קראו את config.json לפני שתורידו 40 GB של משקולות (weights).
  4. הגשת פחות בקשות בו-זמנית והעברת השאר לתור.

ב-q4_0, הנתון עבור Llama 3.1 8B יורד מ-128 KiB לטוקן לכ-32 KiB, כך ש-32k של הקשר עולים כ-1 GiB במקום 4 GiB. חיסכון זה אינו מגיע בחינם. המפתחות והערכים נשמרים ברמת דיוק נמוכה יותר, לכן השוו את הפלט עם ה-prompts שלכם לפני שתחליטו להשתמש בהגדרה זו.

מה באמת משיגים באמצעות Prompt Caching של ספק השירות

Prompt Caching של ספק השירות הוא מוצר שונה עם יחידת חיוב שונה. אתם מסמנים תחילית (prefix) קבועה, הספק מאחסן אותה, וקריאות מאוחרות יותר שחוזרות בדיוק על אותה תחילית מחויבות בתעריף מופחת במקום במחיר הקלט המלא.

מכפילי המחיר שפרסמה Anthropic, נכון לאוקטובר 2026: כתיבה למטמון (cache write) ל-5 דקות עולה פי 1.25 ממחיר טוקן קלט בסיסי. כתיבה ל-שעה עולה פי 2, וקריאה מהמטמון (cache read) עולה פי 0.1 ברוב המודלים. המודלים החדשים ביותר זולים עוד יותר לקריאה: פי 0.05 ב-Claude Opus 5.5 וב-Sonnet 5.5, ופי 0.025 ב-Claude Fable 5.1 וב-Mythos 5.1. הציבו system prompt של 20,000 טוקנים מאחורי המספרים הסטנדרטיים, והמשמעות הכלכלית של העסקה הופכת ברורה.

תרשיםCost of a 20,000 token prefix, in base input token equivalents
הנתונים שמאחורי התרשים
[
  {
    "label": "No caching, every call",
    "billed_token_equivalents": "20,000"
  },
  {
    "label": "First call, 5 minute cache write",
    "billed_token_equivalents": "25,000"
  },
  {
    "label": "First call, 1 hour cache write",
    "billed_token_equivalents": "40,000"
  },
  {
    "label": "Every later call, cache hit",
    "billed_token_equivalents": "2,000"
  }
]

קראו זאת כחשבון אריתמטי. הפרמיה על כתיבה ל-5 דקות היא שוות ערך ל-5,000 טוקנים בקריאה הראשונה: 25,000 לעומת 20,000 עבור שליחה ללא מטמון. כל קריאה מאוחרת בתוך חלון הזמן מחויבת ב-2,000 במקום ב-20,000, חיסכון של 18,000 טוקנים. לכן, המטמון ל-5 דקות הופך למשתלם החל מהקריאה השנייה ואילך.

המטמון ל-שעה הוא הימור מסוג אחר. הוא מחייב ב-40,000 בעת הכתיבה, פרמיה של 20,000 טוקנים, ולכן הוא דורש שתי פגיעות (hits) בתוך השעה כדי להפוך למשתלם. זו שאלה שנוגעת לדפוס התעבורה שלכם, לא למודל. החישוב המלא, כולל האופן שבו בוחרים את חלון הזמן, נמצא ב-חישוב נקודת האיזון עבור Claude prompt caching.

שני פרטים קובעים אם תפגעו במטמון בכלל. ראשית, תחילית הקצרה מהאורך המינימלי של המודל אינה נשמרת במטמון ללא התראה: נכון לאוקטובר 2026, המינימום המתועד הוא 512 טוקנים עבור Claude Opus 5, Opus 5.5 ו-Sonnet 5.5, ו-1,024 טוקנים עבור Claude Sonnet 5; בקשה קצרה יותר מעובדת כרגיל ללא החזרת שגיאה. שנית, אורך החיים נמדד מתחילת הבקשה שכותבת או קוראת את הרשומה, וכל קריאה מרעננת אותו ללא עלות נוספת. לכן, נקודת קצה עמוסה שומרת על מטמון של 5 דקות פעיל ללא הגבלת זמן. נקודת קצה שנקראת פעם בעשר דקות משלמת את פרמיית הכתיבה בכל פעם מחדש ולעולם לא מפיקה תועלת.

בדקו את התגובה במקום להניח הנחות. האובייקט usage מדווח על cache_creation_input_tokens ועל cache_read_input_tokens. ספירת קריאות (read count) של אפס בכל קריאה משמעותה שאתם קונים כתיבות ולא מקבלים דבר בתמורה.

היכן ששני סוגי הזיכרון המטמון נפגשים

הנחיית מערכת (system prompt) ארוכה היא נקודת המפגש ביניהם, והיא גובה ממך משאבים משני הצדדים בו-זמנית.

באופן מקומי, הנחיית מערכת בת 20,000 טוקנים תופסת כ-2.4 GiB של זיכרון מטמון KV בשרת Llama 3.1 8B בפורמט f16, והיא עושה זאת בנפרד עבור כל בקשה מקבילה שכוללת אותה. מרחוק, אותו קידומת (prefix) עולה בכתיבה אחת לזיכרון המטמון ולאחר מכן ב-0.1 מהקלט בכל קריאה מאוחרת, או פחות בדגמים החדשים ביותר. העלות המקומית גדלה בהתאם למספר המשתמשים שלך. העלות המרוחקת גדלה בהתאם לנפח התעבורה ומתאפסת בזמני חוסר פעילות.

קיימת תכונה מקומית שנראית כמו prompt caching של ספקי שירות ומתבלבלים ביניהן ללא הרף: prefix caching. התיעוד של vLLM מתאר prefix caching אוטומטי כשימור "זיכרון המטמון KV של שאילתות קיימות, כך ששאילתה חדשה יכולה לעשות שימוש חוזר ישיר בזיכרון המטמון KV אם היא חולקת את אותה קידומת עם אחת השאילתות הקיימות". הגרסאות הנוכחיות של vLLM מפעילות זאת כברירת מחדל. שרת llama.cpp שומר זיכרון מטמון להנחיה לכל slot כברירת מחדל, והפרמטר --cache-reuse N מגדיר את גודל הנתח הקטן ביותר שהוא ינסה לעשות בו שימוש חוזר.

מה ש-prefix caching חוסך הוא כוח העיבוד של שלב ה-prefill. הנחיית המערכת שלך בת 20,000 הטוקנים מעובדת פעם אחת במקום בכל בקשה, מה שמקצר משמעותית את הזמן עד לקבלת הטוקן הראשון. ב-vLLM, בלוקים משותפים עוברים שימוש חוזר במקום שכפול, כך שגם ניצול הזיכרון משתפר. מה שזה לעולם לא עושה הוא לצמצם את זיכרון המטמון שעליך להחזיק עבור הטוקנים הפעילים כרגע. שמירת המשקולות (weights) בזיכרון בין בקשות היא מנגנון קשור אך נפרד, המוסבר ב-שמירת מודל Ollama טעון בין בקשות.

מה למדוד בשרת הפרטי שלך

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

ollama ps
nvidia-smi --query-gpu=memory.used,memory.total --format=csv
free -g

ollama ps מציג את המודל הטעון יחד עם גודלו, ההקשר שבו נטען, והאם הוא רץ על ה-GPU או על ה-CPU. בדוק תחילה את עמודת ההקשר, שכן ערך ברירת המחדל תלוי כעת ב-VRAM שלך. אם מודל שציפית שישב במלואו על ה-GPU מדווח על פיצול ל-CPU, המשמעות היא שזיכרון ה-KV cache דחק חלק ממנו החוצה, ומהירות יצירת הטקסט תרד בהתאם. nvidia-smi מספק את נתון ה-VRAM האמיתי, ו-free -g מבצע את אותה פעולה בשרת VPS מבוסס CPU בלבד. הגדל את ההקשר בשלבים, טען מחדש, ועקוב אחר השינוי במספרים. החישובים שלך והנתון המדווח צריכים להיות קרובים זה לזה. כאשר הם אינם תואמים, הפער נובע בדרך כלל ממאגרי החישוב (compute buffers) של סביבת הריצה עצמה, ולא משגיאה בנוסחה.

אם המספרים הללו מכוונים אותך לחומרה שאינך מעוניין לשכור, השוואה מול תשלום לפי טוקן מפורטת ב-השוואה בין GPU VPS לבין תשלום לפי טוקנים ב-API.

FAQ

האם ה-KV cache הוא אותו הדבר כמו prompt caching?

לא. ה-KV cache הוא זיכרון לכל בקשה בתוך תהליך השרת, המאחסן את וקטורי ה-key וה-value עבור כל טוקן בהקשר (context) הנוכחי. הוא קיים ב-RAM או ב-VRAM שלכם ומשוחרר בסיום הבקשה. ה-prompt caching של ספק השירות הוא תכונת חיוב המאחסנת תחילית (prefix) קבועה של פרומפט בתשתית של הספק, ומחייבת בתעריף מופחת כאשר שולחים אותה שוב. מחסור ב-KV cache מונע ממודל להיטען. היעדר prompt cache רק מעלה את החשבונית שלכם ואת הזמן עד לטוקן הראשון.

מדוע המודל שלי נטען ב-context של 2k אך נכשל ב-32k?

מכיוון שסביבת הריצה מקצה את כל ה-KV cache בזמן הטעינה, בגודל המותאם לאורך ה-context שהגדרתם ולא לפי הפרומפט שאתם שולחים. עבור Llama 3.1 8B בפורמט f16, המטמון הוא 128 KiB לכל טוקן, כך ש-2k של context עולים 0.25 GiB ו-32k עולים 4 GiB. המשקולות נכנסות בשני המקרים. ההקצאה היא זו שנכשלת. vLLM מדווח על כך באמצעות ValueError המציין כמה זיכרון KV cache נדרש לעומת כמה זמין, עם הערכה של אורך המודל המקסימלי, ומציע להעלות את gpu_memory_utilization או להוריד את max_model_len. במכונה מבוססת CPU המריצה Ollama או llama.cpp, מנגנון ה-out-of-memory killer של ה-kernel עלול להפסיק את התהליך, דבר שניתן לאמת באמצעות dmesg -T | grep -i "killed process".

כיצד עלי לחשב את גודל ה-KV cache עבור המודל שלי?

הכפילו ב-2 את מספר השכבות, את מספר ה-key/value heads, את ממד ה-head, ואת מספר הבייטים לכל אלמנט. זה נותן את מספר הבייטים לכל טוקן. לאחר מכן הכפילו באורך ה-context שלכם ובמספר הבקשות המקבילות. קראו את מספר השכבות וה-heads מתוך ה-config.json של המודל. השתמשו ב-2 בייטים לכל אלמנט עבור f16 או bf16. מטמון q8_0 הוא בערך מחצית מכך, ו-q4_0 הוא בערך רבע.

האם prompt caching מפחית את צריכת הזיכרון בשרת שלי?

ה-prompt caching של ספק השירות אינו משפיע על החומרה שלכם, מכיוון שהאחסון נמצא בצד של הספק. המקבילה המקומית היא prefix caching, המוצעת על ידי vLLM ועל ידי שרת llama.cpp. היא עושה שימוש חוזר בוקטורי key ו-value שכבר חושבו עבור תחילית משותפת, מה שחוסך חישובי prefill ומקצר את הזמן עד לטוקן הראשון. ב-vLLM בלוקים משותפים עוברים שימוש חוזר במקום להיות משוכפלים, כך שגם הזיכרון משתפר. אף אחת מהתכונות הללו אינה מקטינה את המטמון הנדרש עבור הטוקנים שנמצאים כרגע בתהליך, לכן חישובי ה-context והמקביליות שלכם עדיין קובעים את רף המינימום.

האם כדאי לבצע caching לפרומפט שאני שולח רק פעם אחת?

לא. כתיבה למטמון עולה יותר מאשר קלט רגיל, פי 1.25 מהתעריף הבסיסי עבור אפשרות ה-5 דקות נכון לאוקטובר 2026, לכן תחילית שלעולם לא תשלחו שוב בתוך החלון היא הפסד ישיר. ה-caching משתלם כאשר אותה תחילית חוזרת על עצמה, כגון system prompt ארוך או מסמך שתשאלו עליו מספר שאלות. בדקו את cache_read_input_tokens בתגובת ה-API כדי לוודא שאתם מקבלים hits במקום לשלם על כתיבות.

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