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

אירוח עצמי של Kimi K3: דרישות חומרה וחישובי זיכרון

רוצים להריץ את Kimi K3 בעצמכם? המודל דורש 1.4TB של VRAM רק עבור המשקולות. גלו את החישוב המדויק של ה-KV cache ושלוש הדרכים להריץ את המודל ללא אשכול של 32 מעבדים.

מה נדרש לאירוח עצמי של Kimi K3

אירוח עצמי של Kimi K3 מחייב מציאת מקום עבור 2.8 טריליון פרמטרים. Moonshot פרסמה את המשקולות הפתוחות בפורמט MXFP4, המהווה כחצי בייט לכל משקולת, כך שהמשקולות לבדן מגיעות לכ-1.4 TB, עוד לפני הקצאת טוקן אחד של cache. כיום אין מאיץ זמין בשוק שמסוגל להכיל זאת בעצמו. עבור GPU בודד, התשובה היא לא. עבור שרת בודד, התשובה היא כן בשתי תצורות. הראשונה היא צומת של 8 יחידות GPU עם מאיצי 288 GB, שזו התצורה שבה משתמשים המתכונים הקטנים ביותר שפורסמו להגשת שירות מרובה-משתמשים. השנייה היא מכונה אחת עם כ-1.6 TB של זיכרון משולב (RAM ו-VRAM) המריצה את פורמט Q8 GGUF ללא אובדן נתונים של Unsloth בתוך llama.cpp, עם או בלי GPU, המגישה שירות למשתמש אחד בכל פעם.

זהו פסק הדין. כל מה שמופיע להלן הוא החישוב העומד מאחוריו, שכן החישוב הוא החלק שבו תשתמשו שוב בגרסה הבאה. מספר ספקי תשתית פרסמו מדריכי פריסה ל-K3 בשבועות שלאחר ההכרזה ב-16 ביולי 2026, וכל אחד מהם הניח שברשותכם כבר אשכול שרתים. דף זה מתחיל מהקצה השני: מה העלות, מה ניתן להריץ במקום, וכיצד לקבוע באיזו משתי האפשרויות הללו אתם נמצאים.

מספר הפרמטרים הכולל ומספר הפרמטרים הפעילים אינם זהים

K3 הוא מודל מסוג Mixture of Experts. ארכיטקטורת MoE מפצלת את הרשת לתת-רשתות רבות ומאפשרת לנתב (router) לבחור כמה מהן עבור כל אסימון (token). כרטיס המודל מציין 2.8T פרמטרים בסך הכל ו-104B פרמטרים פעילים לכל אסימון, מתוך 896 מומחים מנותבים שמהם 16 מופעלים עבור כל אסימון נתון, לאורך 93 שכבות.

שני נתוני הפרמטרים הללו עונים על שאלות שונות, והחלפה ביניהם היא הטעות הנפוצה ביותר בכל דיון בנושא "האם אוכל להריץ את זה".

פרמטרים פעילים קובעים את עלות החישוב. אסימון עובר הכפלה דרך כ-104B פרמטרים, לכן קצב העיבוד (throughput) הצפוי דומה לזה של מודל צפוף (dense) בעל 104B פרמטרים, ולא לזה של מודל בעל 2.8T. זוהי הסיבה המרכזית לבניית מודל MoE.

פרמטרים כוללים קובעים את עלות הזיכרון. הנתב עשוי לבחור בכל מומחה עבור כל אסימון, לכן יש לאחסן כל מומחה במיקום מהיר לפני הגעת הבקשה הראשונה. קיימת אפשרות להחזיק רק את המומחים הפעילים ב-VRAM ולטעון את השאר לפי דרישה: ה---moe-cache-mib של llama.cpp שומר מטמון GPU של מומחים שנמצאים בדרך כלל ב-RAM של המערכת, ומעלה את אלו החסרים כאשר הנתב בוחר בהם. עם זאת, הדבר אינו מקטין את הסך הכולל. שאר המומחים עדיין חייבים להימצא ב-RAM, וחיבור PCIe מעביר עשרות גיגה-בייט לשנייה לעומת טרה-בייט לשנייה ב-HBM, כך שכל החטאה במטמון (cache miss) גובה זמן. הזרמת מומחים מ-NVMe במקרה שהמודל אינו נכנס גם ל-RAM היא איטית עוד יותר, ומדריך ה-K3 של Unsloth מזהיר כי פריקה לדיסק (disk offloading) פועלת לאט משמעותית.

לסיכום, החישוב זול אך האחסון יקר. תכננו את החומרה לפי 2.8T. תכננו את ציפיות המהירות שלכם לפי 104B.

בייטים למשקל, ומקור הטרה-בייטים

מספר הפרמטרים כפול בייטים למשקל. עבור המשקולות, זוהי הנוסחה המלאה.

תרשיםWeight footprint of 2.8 trillion parameters, by precision
הנתונים שמאחורי התרשים
[
  {
    "label": "bf16",
    "bytes_per_weight": 2,
    "weights_tb": 5.6
  },
  {
    "label": "fp8",
    "bytes_per_weight": 1,
    "weights_tb": 2.8
  },
  {
    "label": "4-bit (MXFP4, as shipped)",
    "bytes_per_weight": 0.5,
    "weights_tb": 1.4
  },
  {
    "label": "2-bit",
    "bytes_per_weight": 0.25,
    "weights_tb": 0.7
  }
]

המודל K3 אומן תוך מודעות לקוונטיזציה (quantisation aware) ושוחרר עם משקולות בפורמט MXFP4 ואקטיבציות בפורמט MXFP8, לכן השורה של 4-bit היא הרלוונטית. השורות שמעליה נועדו להמחשת קנה המידה: בפורמט bf16, אותו מודל היה דורש 5.6 TB. פורמט MXFP4 מאחסן גם scale משותף של 8-bit עבור כל בלוק של 32 משקולות, מה שמוסיף כ-6 אחוזים. בנוסף, התצורה של Moonshot משאירה את מנגנון ה-attention, את ה-experts המשותפים ואת ה-vision tower מחוץ לפורמט ה-4-bit, כך שה-checkpoint המלא מגיע לכ-1.56 TB לפי החישוב של Unsloth, ולא ל-1.4 TB נקיים.

נתון זה מצמצם את מרחב התמרון המקובל מבלי לסגור אותו לחלוטין. ה-checkpoint ששוחרר הוא כבר ב-4-bit, כך שהחיסכון הקל כבר בוצע, אך ירידה נוספת בביטים עדיין משנה את המספרים. נכון ל-27 באוקטובר 2026, קוונטיזציות ה-GGUF הדינמיות של K3 שמדד Unsloth נעות בין 861.3 GB עבור ה-UD-Q2_K_XL ב-2-bit, ועד 594 GB עבור ה-UD-IQ1_S ב-1-bit. Unsloth מפרסם את העלות של מהלך זה: התאמת טוקנים (top-1 token agreement) מול המודל המלא עומדת על 90.390 אחוז ב-UD-Q2_K_XL, על 84.127 אחוז ב-UD-IQ2_XXS שגודלו 711.1 GB, ועל 78.875 אחוז ב-UD-IQ1_S. ה-repo של Unsloth ב-Hugging Face מכיל גם קובצי 1-bit קטנים יותר, עד 466 GB עבור UD-Q1_0, ללא נתוני התאמה שפורסמו לצדם. מדובר באובדן דיוק מדיד, ואפילו הקובץ הקטן ביותר עדיין גדול פי 1.6 מהכרטיס הבודד הגדול ביותר הקיים.

כמה מעבדים גרפיים (GPUs) נדרשים עבור Kimi K3

תרשיםGPUs required to hold 1.4 TB of weights, before any KV cache
הנתונים שמאחורי התרשים
[
  {
    "config": "H100 80GB",
    "hbm_per_gpu_gb": 80,
    "gpus_for_weights": 18
  },
  {
    "config": "H200 141GB",
    "hbm_per_gpu_gb": 141,
    "gpus_for_weights": 10
  },
  {
    "config": "B200 192GB",
    "hbm_per_gpu_gb": 192,
    "gpus_for_weights": 8
  },
  {
    "config": "GB300 288GB",
    "hbm_per_gpu_gb": 288,
    "gpus_for_weights": 5
  }
]

התייחסו לנתונים אלו כאל רף מינימלי, לא כיעד. הם סופרים את המשקולות בלבד: ללא KV cache, ללא מאגרי הפעלה (activation buffers), ללא פרגמנטציה של ה-allocator, וללא מקום לבקשה שנייה במקביל. הפיצול עצמו אינו חייב להיות שווה: ה-pipeline parallelism של vLLM מפצל את המודל לאורך שכבות ותומך בפיצולים לא שווים, ומתכוני ה-prefill של SGLang עבור K3 מריצים 8 ו-16 שלבי pipeline על פני 93 שכבות.

ההנחיות שפורסמו נמצאות מעל לרף המינימלי. הנחיות ההשקה של Moonshot המליצו על supernode של 64 מאיצים או יותר. נכון ל-27 באוקטובר 2026, ה-cookbook של SGLang מציע תצורת H100 הבנויה מארבעה צמתים של 8 מעבדים גרפיים כל אחד, סך הכל 32 מעבדים גרפיים ו-2,560 GB של זיכרון מצטבר, לעומת רף של 18 כרטיסים. הוא מפרט גם מתכונים לצומת יחיד על גבי צומת B300 עם 8 מעבדים גרפיים וצומת MI350X או MI355X עם 8 מעבדים גרפיים, בנפח של 2,304 GB המבוסס על 288 GB לכרטיס. הפער הזה מעל לרף אינו בזבוז. הוא מיועד ל-KV cache, לזיכרון הפעלה, ולמרווח המאפשר לשרת לעבד בקשות רבות בו-זמנית. השורה הנוחה ביותר, כרטיסי מחלקת 5 GB300, מתעגלת בפועל בדיוק לסוג כזה של צומת עם 8 מעבדים גרפיים, שהוא המכונה הקטנה ביותר שעבורה מישהו מפרסם מתכון להגשת K3 למשתמשים מרובים.

מטמון ה-KV הוא החלק המפתיע

המשקולות (weights) הן עלות קבועה. מטמון ה-KV (קיצור של key-value) אינו כזה: הוא גדל בהתאם לאורך ההקשר (context length) וגדל שוב עם כל משתמש בו-זמני. עבור מנגנון attention רגיל, הנוסחה היא bytes per token = 2 * layers * kv_heads * head_dim * bytes_per_element, ואז יש להכפיל באורך ההקשר ובמספר המשתמשים בו-זמנית.

להלן דוגמה מחושבת, והיא מהווה דוגמה בלבד: 64 שכבות, 8 ראשי KV, ממד ראש של 128, בפורמט fp8. זה נותן 2 64 8 128 1 = 131,072 בתים, כלומר 128 KiB לכל טוקן.

תרשיםKV cache per user in the worked example, at 128 KiB per token
הנתונים שמאחורי התרשים
[
  {
    "label": "8k context",
    "kv_gib_per_user": 1
  },
  {
    "label": "32k context",
    "kv_gib_per_user": 4
  },
  {
    "label": "128k context",
    "kv_gib_per_user": 16
  },
  {
    "label": "1M context",
    "kv_gib_per_user": 128
  }
]

משתמש אחד עם הקשר של 128k עולה 16 GiB. משתמש אחד עם הקשר מלא של מיליון טוקנים עולה 128 GiB, שזה כמעט מחצית מכרטיס של 288 GB עבור שיחה אחת, עוד לפני שנטענה משקולת אחת.

K3 אינו משתמש ב-attention רגיל, וזהו בדיוק ההסבר למספר האחרון. 93 השכבות שלו מורכבות מ-69 שכבות KDA (קיצור של Kimi Delta Attention) ו-24 שכבות Gated MLA (קיצור של multi-head latent attention). מנגנון KDA שומר מצב רקורסיבי בגודל קבוע במקום מטמון שגדל עם כל טוקן, ו-MLA דוחס את ה-key וה-value לוקטור לטנטי אחד בדרגה נמוכה, כך שהעלות האמיתית לכל טוקן נמוכה משמעותית מהדוגמה שחושבה. קובץ ה-config.json שפורסם על ידי Moonshot מציין את גודל הוקטור הלטינטי הזה: kv_lora_rank בגודל 512 בתוספת מפתח סיבובי (rotary key) ברוחב 64 (qk_rope_head_dim), כלומר 576 ערכים לכל טוקן בכל שכבת MLA. בפריסה על פני 24 שכבות, ב-2 בתים לכל ערך, מדובר ב-27,648 בתים, כ-27 KiB לכל טוקן, או בערך 27 GiB עבור שיחה מלאה של 1,048,576 טוקנים, בתוספת מצב ה-KDA הקבוע. התייחסו לזה כאל הערכה ולא כמדידה מדויקת: מנועים מבצעים padding ומארגנים את המטמון בדרכים שונות, ומטמון של 8-bit מקטין את הנפח בערך בחצי.

כדי לראות מה מכילה הפריסה שלכם, אל תנטרו את nvidia-smi בזמן העלאת ה---max-model-len. המנוע vLLM מקצה מראש את מאגר מטמון ה-KV שלו, שגודלו נקבע לפי --gpu-memory-utilization (0.92 כברירת מחדל בתיעוד הנוכחי) או לפי תקציב מטמון מפורש לכל GPU, לכן זיכרון ה-GPU הכולל מציג את המאגר ולא שיחה בודדת. במקום זאת, קראו את לוג ההפעלה, שבו vLLM מדווח על גודל מטמון ה-KV בטוקנים ועל רמת ה-concurrency המקסימלית באורך ההקשר שלכם.

מבנה ה-reasoning יישמר גם בגרסה הבאה. אם מודל מצהיר על הקשר של מיליון טוקנים ואינו מציין דבר לגבי תכנון ה-attention שלו, הניחו שהמטמון הוא צוואר הבקבוק המגביל, עד שיוכח אחרת.

דרגה 1: השכרת אשכול לפי שעה

זוהי הדרגה המשרתת את K3 ברמת הדיוק שבה שוחרר עבור משתמשים רבים בו-זמנית. מכונה אחת עם מספיק RAM יכולה גם היא להחזיק את K3 ברמת הדיוק המקורית שלו באמצעות Q8 GGUF של Unsloth, ש־Unsloth מגדיר כרמת דיוק מלאה ללא אובדן נתונים, אך מסלול זה משרת משתמש אחד בכל פעם והוא מכוסה בדרגה 2. כאן אינכם קונים את החומרה. אתם שוכרים אותה לשעות שבהן אתם זקוקים לה ועוצרים אותה לאחר מכן.

תרשיםMonthly cost at an assumed 2.50 USD per GPU hour, 30 day month
הנתונים שמאחורי התרשים
[
  {
    "label": "1 GPU, always on",
    "gpu_hours": 720,
    "usd_cost": "1,800"
  },
  {
    "label": "8 GPUs, 4 hours a day",
    "gpu_hours": 960,
    "usd_cost": "2,400"
  },
  {
    "label": "8 GPUs, always on",
    "gpu_hours": 5760,
    "usd_cost": "14,400"
  },
  {
    "label": "32 GPUs, always on",
    "gpu_hours": 23040,
    "usd_cost": "57,600"
  }
]

התעריף הוא הערכה בלבד, לא הצעת מחיר. תעריפי On-demand משתנים משמעותית בין ספקים ובין דורות של GPU; רכיבי 288 GB שמתכוני ה-single-node דורשים עולים יותר לשעה מאשר H100, וקיבולת שמורה (reserved capacity) זולה יותר. קחו את המספר האמיתי של הספק שלכם ובצעו את הכפל מחדש: מספר ה-GPUs כפול שעות כפול תעריף. מטרת הטבלה היא להציג את היחס. הרצה בפרץ (bursting) של צומת עם 8 GPUs למשך ארבע שעות ביום עולה 2,400 USD לחודש, בעוד השארת תצורת 32 GPU H100 בגודל SGLang פועלת ללא הפסקה עולה 57,600 USD.

שני השרתים המרכזיים מפרסמים פקודת הפעלה בדף המודל (model card).

pip install vllm
vllm serve "moonshotai/Kimi-K3"
pip install sglang
python3 -m sglang.launch_server --model-path "moonshotai/Kimi-K3" --host 0.0.0.0 --port 30000

אף אחת מהפקודות הגולמיות אינה הפקודה שמריצים על אשכול אמיתי. הוסיפו את דגלי המקביליות (parallelism flags) התואמים לחומרה שלכם: SGLang משתמש ב---tp-size עבור tensor parallel, ב---pp-size עבור pipeline parallel וב---ep-size עבור expert parallel. המכפלה של tensor parallel ב-pipeline parallel חייבת להיות שווה למספר ה-GPUs שיש לכם בפועל, ו-expert parallel מפצל את ה-experts בתוך אותה קבוצה; זו הסיבה שמתכון ה-32 GPU H100 מגדיר גם את --tp-size 32 וגם את --ep-size 32.

וודאו שהשרת עלה לפני שאתם שולחים תעבורה אמיתית:

curl http://127.0.0.1:30000/v1/models

שרת תקין משיב עם אובייקט JSON המפרט את מזהה המודל. Connection refused מציין שהתהליך עדיין טוען משקולות (weights) או שכבר יצא, לכן קראו את לוג השרת לפני שתנסו שוב.

הכשל הנפוץ ביותר בשבועות הראשונים היה סביבת הרצה (runtime) ישנה יותר מהמודל. K3 שוחרר עם KDA ושכבת MoE חדשה שגרסאות ה-vLLM וה-SGLang היציבות לא כללו בעת ההשקה, והסימפטום לכך הוא יציאת השרת במהלך העלייה עם שורה בתבנית Model architectures [...] are not supported for now. שום שינוי בתצורה לא מתקן זאת, כיוון שהקוד להרצת שכבות אלו אינו קיים ב-build שלכם. מאז המצב השתנה: נכון ל-27 באוקטובר 2026, SGLang כולל תמיכה ב-K3 בגרסאותיו החל מ-v0.5.17, כאשר v0.5.22 היא העדכנית ביותר, והערות השחרור של vLLM מגרסה v0.28.0 ועד v0.32.0 כוללות כולן עבודה על K3. התקינו גרסה עדכנית. נתיבים מסוימים התלויים בחומרה עדיין מצביעים על image ייעודי, למשל ה-builds של SGLang מסוג NVFP4 על Blackwell, לכן בדקו את המתכון עבור הכרטיס שלכם.

הערת עלות אחת שתופסת אנשים לא מוכנים: המונה מתחיל לפעול ברגע שה-instance עולה, לא כשהמודל מוכן. הורדה של 1.56 TB במהירות 1 GB/s דורשת כ-26 דקות של זמן אשכול לפני ה-token הראשון. אחסנו את המשקולות בנפח (volume) ששורד את ה-instance, כך שההרצה השנייה תתחיל בתוך דקות.

דרג 2: הרצת מודל קטן יותר על מאיץ יחיד

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

כלל ההתאמה הוא אותה נוסחה בקנה מידה קטן: מספר הפרמטרים כפול בייטים לכל משקל, בתוספת ה-KV cache, בתוספת כ-2 GB של תקורה בזמן ריצה, חייבים להיכנס בתוך ה-VRAM שלכם. ב-4-bit מדובר בערך בחצי בייט לפרמטר, מה שמאפשר שילובים נוחים:

  • כרטיס 16 GB: מודל 7B ב-4-bit עם מקום להקשר (context) ארוך
  • כרטיס 24 GB: מודל 14B ב-4-bit
  • כרטיס 48 GB: מודל 32B ב-4-bit
  • כרטיס 80 GB: מודל 70B ב-4-bit, או מודל מסוג 30B MoE ב-8-bit

כל שילוב לעיל מניח בקשה אחת בכל פעם. ברגע שאדם שני שולח הנחיה (prompt), כל slot מקבילי דורש KV cache משלו; זהו הפשרה ש-הגדרות NUM_PARALLEL ו-MAX_QUEUE של Ollama מבצעות עבורכם בין slots מקביליים, בקשות בתור וה-VRAM שנותר לכם.

קיימת דרך אחת להריץ את K3 עצמו על מכונה גדולה יחידה, והיא נמצאת בין דרג זה לדרג האחרון. Unsloth מתעדת גרסאות GGUF של K3 ב-llama.cpp, החל מקוונטיזציה של 1-bit ו-2-bit ועד ל-UD-Q8_K_XL, שאותה היא מגדירה כ-lossless בדיוק מלא, ומציינת את NVIDIA DGX Station כחומרה המסוגלת להריץ אותן. כלל האצבע שלה הוא שסכום ה-RAM וה-VRAM צריך להיות שווה בערך לגודל הקוונטיזציה, החל מ-610 GB עבור גרסת ה-1-bit UD-IQ1_S ועד כ-1.6 TB עבור ה-Q8. מתחת לערכים אלו, המודל עובר לשימוש בדיסק והביצועים יורדים בחדות. כרטיס מסך הוא אופציונלי: הוראות הבנייה של Unsloth מכבות את CUDA "אם אין לכם GPU או שאתם פשוט רוצים הסקה (inference) על ה-CPU". גרסאות ה-1-bit וה-2-bit הן K3 בקוונטיזציה כבדה, במחיר של פגיעה בדיוק כפי שנמדד לעיל. גרסת ה-Q8 היא K3 בדיוק שבו שוחרר, המוגש למשתמש יחיד במהירות ה-RAM. אף אחת מהן אינה מודל קטן יותר.

Ollama היא הדרך הקצרה ביותר לשרת עובד על שרת VPS עם GPU מחובר:

curl -fsSL https://ollama.com/install.sh | sh
ollama run qwen3:14b

ollama run מוריד את המודל בשימוש הראשון, ולאחר מכן מעביר אתכם לשורת פקודה. תג (tag) שאינו קיים מחזיר Error: model "..." not found, לכן העתיקו תגים מדף הספרייה במקום להקליד אותם מהזיכרון. המדריך המלא, כולל יחידת systemd וגישה מרחוק, נמצא ב-הרצת Ollama על גבי VPS.

llama.cpp מעניק לכם שליטה רבה יותר על קוונטיזציה ו-offload:

git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j
./build/bin/llama-server -m model.gguf -c 8192 -ngl 99 --host 0.0.0.0 --port 8080

-ngl 99 מבקש להעביר כל שכבה ל-GPU. קראו את לוג הטעינה: הוא מדפיס כמה שכבות הועברו. שכבות שזולגות ל-RAM של המערכת רצות ברוחב הפס של ה-RAM במקום ברוחב הפס של ה-HBM, לכן מהירות היצירה צונחת בסדר גודל ברגע שהמודל מפסיק להיכנס לזיכרון. הפשרות בין שני הכלים מכוסות ב-Ollama ו-llama.cpp זה לצד זה.

דרג 3: API מאוחסן, תזמור (orchestration) בניהול עצמי

תרשיםKimi K3 published API pricing, USD per million tokens, checked 17 July 2026
הנתונים שמאחורי התרשים
[
  {
    "label": "Input, cache hit",
    "usd_per_million_tokens": "0.30"
  },
  {
    "label": "Input, cache miss",
    "usd_per_million_tokens": "3.00"
  },
  {
    "label": "Output",
    "usd_per_million_tokens": "15.00"
  }
]

נקודת הקצה (endpoint) תואמת ל-OpenAI, לכן לקוח קיים יעבוד לאחר שתשנה את ה-base URL.

curl https://api.moonshot.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $MOONSHOT_API_KEY" \
  -d '{"model": "kimi-k3", "messages": [{"role": "user", "content": "Say hello."}]}'

מפתח תקין מחזיר אובייקט JSON עם מערך choices. שגיאת 401 מציינת כי האימות נכשל: ודא שהמפתח נכון, לא פג תוקפו ולא הושבת, ושה-header מכיל Authorization: Bearer ולאחריו המפתח. שגיאת model-not-found מעידה בדרך כלל על כך שה-id השתנה, כיוון שספקים מוציאים משימוש מזהי מודלים בין נקודות ביקורת (checkpoints).

כעת נבחן את נקודת האיזון, בהתבסס על עלות ההשכרה שהונחה לעיל. צומת (node) עם 8 מעבדים גרפיים (GPU) הפועל ללא הפסקה עולה 14,400 דולר בחודש. במחיר של 15.00 דולר למיליון טוקנים של פלט, אותו סכום כסף יקנה כ-960 מיליון טוקנים של פלט מה-API. כדי להשיג כדאיות כלכלית עליך לייצר קרוב למיליארד טוקנים של פלט בחודש, בערך 30 מיליון ביום, ולשמור על ה-cluster עמוס לאורך כל הזמן, כיוון שמעבדים גרפיים במצב סרק מחויבים באותו תעריף כמו מעבדים פעילים. עומסי עבודה של סוכנים (agents) עתירי-הנחיות (prompts) מרחיקים את נקודת האיזון עוד יותר: הקשר (context) חוזר מחויב לפי תעריף פגיעה במטמון (cache-hit) של 0.30 דולר למיליון, במקום תעריף אי-פגיעה במטמון של 3.00 דולר.

מה שאתה מנהל בעצמך בדרג זה הוא כל מה שסובב את המודל: gateway שמחזיק את מפתח ה-API כך שהוא לעולם לא מגיע ללקוח, לוגים של בקשות ותגובות, ניסיונות חוזרים (retries), הגבלות קצב (rate limits) ותקציבים לכל משתמש. רכיבים אלו רצים על VPS קטן ללא צורך ב-GPU כלל. אותה חלוקה חלה על מודלים בעלי משקולות סגורות, שבהם אירוח עצמי של Claude אינו אפשרי ברמת המודל, והתזמור הוא החלק היחיד שנמצא בשליטתך.

לאיזו שכבה שייך כל מחסנית שירות

שרתים מסוג vLLM ו־SGLang שייכים לשכבה 1. הם נועדו לשרת בקשות רבות בו-זמנית, תוך שימוש ב-continuous batching וב-paged KV cache, לצד הקבלה של טנזורים ומומחים (tensor and expert parallelism) הפרוסה על פני כמה צמתים. הם מניחים קיום של מאיצי מרכז נתונים וחיבור מהיר ביניהם. על כרטיס צרכני בודד, התקנתם מורכבת יותר והתועלת שתפיקו מהם תהיה זניחה.

llama.cpp ו־Ollama שייכים לשכבה 2. הם ממוקדים במכונה בודדת, בקוונטיזציה מסוג GGUF, בפריקת חישובים ל-CPU כאשר המודל אינו נכנס בזיכרון, ובקונקורנטיות נמוכה. llama.cpp יטען מודל MoE עצום על ידי שמירת משקולות המומחים ב-RAM של המערכת (--cpu-moe או --n-cpu-moe), ובעזרת --moe-cache-mib, יבצע caching למומחים שבהם הוא משתמש על ה-GPU; כך רצים מבני K3 GGUF של Unsloth על מכונה בודדת. המהירות תלויה אז ברוחב הפס של ה-RAM ובתדירות שבה ה-router מפספס את ה-cache. אם הקובץ גדול יותר מסך ה-RAM וה-VRAM, המערכת תעבור לשימוש בדיסק. זהו מערך עבודה תקין למשתמש יחיד. זהו אינו שירות שניתן להעמיד לרשות משתמשים רבים. ההשוואה המלאה נמצאת ב-Ollama מול vLLM, והיא אינה משתנה בהתאם למודל: השאלה היא תמיד האם אתם משרתים משתמשים רבים על חומרה משותפת או משתמש יחיד על החומרה שלכם.

ארבעת המספרים ששורדים את נקודת הביקורת הזו

  1. מכפלת סך הפרמטרים בבתים לכל משקל קובעת את רף הזיכרון המינימלי. שום דבר לא ירוץ מתחת לרף זה בדיוק (precision) שבו שוחרר המודל, וקוונטיזציה מתחת לגרסת 4-bit תעניק לכם חיסכון של עד כ-70 אחוז במחיר של פגיעה בדיוק, ולא בסדר גודל שלם.
  2. מספר הפרמטרים הפעילים קובע את מחלקת התפוקה (throughput). מודל MoE של 2.8T עם 104B פרמטרים פעילים מחושב כמו מודל של 104B.
  3. ה-KV cache לכל טוקן, כפול אורך ההקשר (context length), כפול רמת המקביליות (concurrency), הוא העלות שממשיכה לגדול לאחר שכבר שילמתם על המשקלים.
  4. טוקנים לשנייה לכל דולר הוא המספר היחיד שקובע את הדרג. כל מה שצוין לעיל הוא קלט לחישוב זה.

יישמו את ארבעת הכללים הללו על כל גרסה שתקבלו, ותגיעו לתשובה הנכונה עוד לפני שתפתחו את המדריך של הספק. הגרסה הבאה כבר הוכרזה: Moonshot השיקה את K3.1 Pro, שנבנה על בסיס K3 עם אימון נוסף (post-training), בתוך Kimi Code ב-23 באוקטובר 2026, ומדריך ה-API שלה מציין כי המשקלים המלאים ישוחררו עד ה-4 בנובמבר. הקפידו לתעדף בתאריך כל נתון שאתם כותבים. המחירים ורשימות הארכיטקטורות הנתמכות השתנו שניהם בשבועיים שלאחר השקת K3. נתוני ההשקה בדף זה פורסמו ביולי 2026, ומתכוני ההגשה (serving recipes), גרסאות ה-runtime ומספרי הקוונטיזציה נבדקו מחדש ב-27 באוקטובר 2026.

FAQ

האם ניתן להריץ את Kimi K3 על מעבד גרפי יחיד?

לא. המשקולות הן בנפח של כ-1.4 TB בפורמט MXFP4 ש-Moonshot מפיצה, ואפילו הקוונטיזציה הקטנה ביותר שפורסמה עבור K3, קובץ ה-UD-Q1_0 של Unsloth בגודל 466 GB, גדולה פי 1.6 מה-288 GB הקיימים במאיצים הגדולים ביותר הזמינים באופן נרחב. llama.cpp יכול לשמור מומחים בזיכרון ה-RAM של המערכת ולבצע caching לאלו הפעילים על ה-GPU, אך זה עדיין דורש בערך את גודל הקוונטיזציה ב-RAM בתוספת VRAM, ומתחת לכך המודל עובר לדיסק ורץ לאט משמעותית. מתכוני ההגשה הקטנים ביותר שפורסמו משתמשים בצומת יחיד של 8 מעבדים גרפיים מסוג B300 או MI350X/MI355X, והמתכון עבור H100 משתמש ב-32.

כמה VRAM נדרש עבור Kimi K3?

התחילו ב-1.4 TB עבור המשקולות בלבד, שהם 18 כרטיסי H100 של 80GB או 5 כרטיסים ממחלקת GB300. לאחר מכן הוסיפו מעל את ה-KV cache וזיכרון ההפעלה. הנחיות ההשקה של Moonshot המליצו על 64 מאיצים או יותר. נכון ל-27 באוקטובר 2026, ה-cookbook של SGLang מפרסם מתכונים לצומת יחיד על 8 כרטיסי B300 או 8 כרטיסי MI350X/MI355X, עם 2,304 GB מצטבר, ותצורת H100 עם 32 מעבדים גרפיים ו-2,560 GB מצטבר, לכן התייחסו לנתון המשקולות כאל רף מינימלי ולא כאל דרישה סופית.

האם קוונטיזציה מאפשרת ל-Kimi K3 להיכנס לצומת יחיד?

נקודת הביקורת (checkpoint) ב-4-bit שכבר הופצה נכנסת לצומת יחיד אם מדובר בצומת של שמונה כרטיסי 288 GB, שזה מה שמתכוני ה-B300 וה-MI355X של SGLang משתמשים בו, ועל מכונה אחת עם כ-1.6 TB של RAM בתוספת VRAM באמצעות ה-Q8 GGUF ללא איבוד נתונים של Unsloth. ירידה בקוונטיזציה מסייעת למכונות קטנות יותר: בניית GGUF דינמית שנמדדה על ידי Unsloth נעה בין 861.3 GB ב-2-bit ל-594 GB ב-1-bit, וה-repo שלהם מציג קובצי 1-bit שגודלם יורד עד ל-466 GB, לעומת כ-1.56 TB ללא איבוד נתונים. עלות הדיוק נמדדה: התאמת top-1 למודל המלא יורדת ל-90.390 אחוז ב-UD-Q2_K_XL ול-78.875 אחוז ב-UD-IQ1_S. אף אחד מהם לא נכנס לכרטיס יחיד.

האם השכרת מעבדים גרפיים זולה יותר מ-API של Kimi K3?

רק בנפח עבודה גבוה וקבוע. בהנחה של 2.50 דולר לשעה עבור מעבד גרפי, צומת של 8 מעבדים גרפיים הפועל ללא הפסקה עולה 14,400 דולר בחודש, ואותו סכום כסף קונה כ-960 מיליון טוקנים של פלט לפי התעריף שפורסם של 15.00 דולר למיליון. אתם משלמים גם על שעות סרק, הורדות משקולות ועל האדם שמתחזק את האשכול. שכרו לפי שעה עבור פרצי עבודה, והשוו זאת מול נפח הטוקנים הנמדד שלכם במקום לנחש.

מה המשמעות של 104B פרמטרים פעילים עבור המהירות?

המשמעות היא שהחישוב האריתמטי לכל טוקן הוא של מודל 104B, לכן קצב העבודה (throughput) נופל למחלקה זו ולא למחלקת ה-2.8T. זה לא אומר דבר על הזיכרון: כל 2.8T הפרמטרים נשארים בזיכרון, מכיוון שהנתב (router) יכול לקרוא לכל מומחה עבור כל טוקן. השתמשו בספירת הפרמטרים הפעילים כדי לחזות טוקנים לשנייה, ובספירה הכוללת כדי לקבוע את גודל ה-VRAM.

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

#kimi-k3#self-hosted-llm#gpu#vram#inference