שיעור 0.1 - מודל מנטלי לעבודה עם LLMs

ברוכים הבאים לקורס AI Dev. השיעור הזה הוא שיעור שאני מאוד אוהב, כי הוא שיעור שהייתי רוצה שמישהו היה נותן לי בהתחלה.

אתם כבר יודעים מה זה AI. אתם כבר השתמשתם ב-ChatGPT, ב-Claude, אולי כתבתם קצת קוד עם Copilot. אבל יש הבדל גדול בין להשתמש בכלי לבין להבין מה קורה מבפנים. וההבנה הזו משנה את כל הדרך שבה תבנו איתם.

בשיעור הזה נבנה מודל מנטלי. לא נכנס למתמטיקה. לא נדבר על Transformers בצורה אקדמית. נדבר על מה שצריך לדעת כדי לבנות מוצרים טובים עם LLMs, כדי לכתוב פרומפטים שעובדים, כדי להבין למה הכלי עשה מה שעשה ואיך לתקן.

ניגע בחמישה נושאים מרכזיים. מה LLM בעצם עושה. Tokens. Context Window. Temperature ו-Sampling. ו-Tool Use עם Agent Loop. בסוף השיעור הכל יתחבר לתמונה אחת שלמה.

[מעבר שקף]

בואו נתחיל מהשאלה הפשוטה ביותר. מה LLM בעצם עושה?

LLM, ראשי תיבות של Large Language Model, הוא בבסיסו מכונת ניבוי. ממש בבסיסו. הוא מקבל רצף של מילים, ושואל: מה המילה הבאה הכי סבירה?

לא מה המילה ה"נכונה". לא מה הכותב "התכוון". מה הכי סביר בהינתן כל הטקסט שהוא ראה באימון.

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

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

הנקודה הקריטית: זה לא מוח. זה לא חושב. זה לא מבין במובן האנושי. זה פונקציה מתמטית שמנבאת את הטוקן הבא ברצף.

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

[מעבר שקף]

עכשיו Token. זה המושג הכי חשוב שתזכרו מהשיעור הזה, ושיפתיע אתכם שהוא כל כך בסיסי.

LLMs לא קוראים מילים. הם קוראים Tokens.

Token הוא יחידה שיכולה להיות מילה שלמה, חלק ממילה, תו בודד, או לפעמים כמה מילים. המודל לומד חלוקה אופטימלית של הטקסט ליחידות שנקראות BPE, Byte Pair Encoding. בפועל, בעברית, מילה ממוצעת שווה בערך שני עד ארבעה Tokens. באנגלית, מילה קצרה רגילה זה בדרך כלל Token אחד.

למה זה חשוב לכם?

קודם כל, עלות. API מחייב לפי Tokens. כשאתם שולחים בקשה לClaude או לGPT, אתם משלמים על כמות ה-Tokens בקלט ועל כמות ה-Tokens בפלט. פרומפט של אלף מילים בעברית הוא בערך שלושת אלפים עד ארבעת אלפים Tokens. אם אתם שולחים אותו מאה פעם ביום, הסכומים מצטברים.

שנית, Context Window. נגיע לזה בשניה, אבל ה-Context Window נמדד ב-Tokens, לא במילים.

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

קיצורי הדרך לעבודה מעשית: אם תרצו לאמוד Tokens, יש Tokenizer חינמי של OpenAI בשם Tiktoken, ואפשר גם פשוט לחשב כאצבע אחת לשלוש מילים באנגלית, ואחת לשתיים בעברית.

[מעבר שקף]

Context Window. אם Token הוא הבנייה, Context Window הוא גודל הדירה שה-LLM יכול להחזיק בו זמנית.

Context Window הוא כמות ה-Tokens שהמודל יכול לקרוא ולזכור בשיחה אחת. הכל שנמצא בתוך ה-Window, המודל יכול להסתמך עליו. כל מה שמחוצה לו, הוא פשוט לא רואה. בכלל.

זה לא כמו זיכרון אנושי שמטשטש בהדרגה. זה חד. אם מסמך חורג מה-Context Window, ה-LLM לא ידע שהוא קיים.

ב-2026, המספרים נראים ככה. Claude Sonnet 4.6 תומך במאתיים אלף Tokens, שזה בערך מאה וחמישים אלף מילים, ספר שלם. Gemini 2.5 Pro תומך במיליון Tokens. GPT-4o תומך במאה ועשרים ושמונה אלף Tokens.

אבל יש נקודה עדינה שחשוב להבין. גדול לא תמיד אומר טוב. מחקרים מראים שמודלים לפעמים מפספסים מידע שנמצא באמצע Context Window ארוך מאוד. פנומן זה נקרא Lost in the Middle. הריכוז הכי חזק הוא בהתחלה ובסוף.

מה זה אומר בפרקטיקה? שאם אתם שולחים מסמך ארוך, שימו את המידע הקריטי בהתחלה. שאם אתם בונים צ'אטבוט שצריך לזכור שיחה ארוכה, תצטרכו לנהל את ה-Context בעצמכם, לא לסמוך שה-LLM יזכור הכל.

ולגבי עלות: Tokens נספרים לכל הכיוונים. שתשלחו, שהמודל מחזיר, ואם משתמשים ב-Prompt Caching של Anthropic, אפשר לחסוך עד תשעים אחוז על הקלט החוזר. נדבר על זה יותר כשנגיע ל-Claude API.

[מעבר שקף]

Temperature. זה הפרמטר שהכי אנשים מכירים את השם שלו ולא מבינים מה הוא עושה.

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

Temperature קובע כמה לחשב על ההסתברויות האלה.

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

Temperature אחד אומר: השתמש בהסתברויות כמו שהן. קצת אקראיות, קצת גיוון.

Temperature שניים, ערך גבוה, אומר: שטח את ההסתברויות, תיתן סיכוי גם לאפשרויות פחות סבירות. התוצאה יותר יצירתית, לפעמים מפתיעה, לפעמים הגיונית פחות.

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

פרמטרים נוספים שנפגשים לפעמים: Max Tokens, שמגביל את אורך הפלט. Top-P, שחותך את הסתברויות הנמוכות. אבל Temperature הוא הבסיס.

[מעבר שקף]

עכשיו נגיע לנושא שמשנה הכל לגבי איך LLMs יכולים לעשות דברים בעולם האמיתי. Tool Use, שנקרא גם Function Calling.

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

Tool Use פותח חלון בחדר הזה.

הרעיון: אתם מגדירים לה-LLM רשימה של כלים שהוא יכול לבקש להשתמש בהם. כל כלי מוגדר בשם, תיאור, ופרמטרים. ה-LLM קורא את ה-System Prompt שלכם, מבין מה הכלים עושים, ואם הוא מחליט שהוא צריך כלי, הוא לא מריץ אותו בעצמו, הוא מבקש מה-Code שלכם להריץ אותו.

בואו ניקח דוגמה קונקרטית. אתם בונים צ'אטבוט שיכול לבדוק מחיר מנייה. אתם מגדירים כלי שנקרא get_stock_price שמקבל שם מנייה ומחזיר מחיר. אתם אומרים לClaude: "יש לך גישה לכלי הזה". משתמש שואל "מה מחיר מנייה של אפל?".

Claude מחליט שהוא צריך את הכלי. הוא מחזיר תגובה שהיא לא טקסט, היא בקשה: "תקרא ל-get_stock_price עם הפרמטר AAPL". ה-Code שלכם מקבל את הבקשה הזו, מפעיל את הפונקציה האמיתית, מקבל את המחיר מה-API של הבורסה, ומחזיר את התוצאה לClaude. Claude עכשיו ממשיך את התשובה עם הנתון האמיתי.

הנקודה הקריטית: ה-LLM מחליט מתי לקרוא לכלי. ה-Code שלכם מריץ אותו. זה חלוקת עבודה. ה-LLM מביא את ההגיון, ה-Code מביא את הביצוע.

אחת השאלות שנשאלות הרבה: מה כותבים בתיאור של הכלי? הכל. ה-LLM מקרא את התיאור כדי להחליט מתי לקרוא לכלי ואיך. תיאור עמום נותן שימוש עמום. תיאור מדויק נותן שימוש מדויק. "מחזיר את המחיר הנוכחי של מנייה לפי סימבול" הרבה יותר טוב מ"כלי למניות".

[מעבר שקף]

ועכשיו כל הדברים שדיברנו עליהם מתחברים לרעיון אחד: Agent Loop.

Agent הוא LLM שיכול לפעול ברצף. במקום שאלה אחת ותשובה אחת, הוא עובד בלולאה: חושב, מחליט על פעולה, מקבל תוצאה, חושב שוב, מחליט על פעולה הבאה, וממשיך כך עד שהמשימה מסתיימת.

הלולאה נראית כך. המשתמש נותן משימה. ה-LLM מנתח ומחליט: האם אני יכול לענות ישירות, או שאני צריך כלי? אם הוא צריך כלי, הוא מבקש את זה. ה-Code מריץ את הכלי ומחזיר תוצאה. ה-LLM מקבל את התוצאה ומחליט שוב: האם אני יכול עכשיו לסכם ולסיים, או שאני צריך עוד מידע? אם הוא צריך עוד, הוא ממשיך. כשהוא מסיים, הוא מחזיר stop_reason שאומר end_turn, ואז ה-Code שלכם יודע לעצור.

זו הלולאה שמפעילה כל AI Agent שיצרתם. Claude Code, כשהוא עובד על פרויקט, מריץ בדיוק את הלולאה הזו. הוא קורא קבצים, כותב קוד, מריץ טסטים, רואה שגיאות, קורא את הקוד שוב, תיקן. כל אחת מהאלה היא איטרציה בלולאה.

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

שנית, ה-LLM לא "זוכר" מה עשה בין שיחות שונות. הזיכרון של ה-Agent הוא ה-Context Window. כל מה שקרה בשיחה הנוכחית נמצא שם. כשהשיחה נגמרת, ה-Agent מתחיל מחדש. אם אתם רוצים זיכרון ארוך טווח, אתם צריכים לבנות אותו בעצמכם, לשמור מידע בדאטאבייס ולהכניס אותו חזרה ל-Context כשצריך.

[מעבר שקף]

בואו נחבר הכל לתמונה אחת.

LLM הוא מכונת ניבוי שעובדת על Tokens. הוא מנבא Token אחד בכל פעם. כמה Tokens הוא יכול לראות בבת אחת, זה ה-Context Window. כמה אקראי הוא בניבוי, זה ה-Temperature. כשהוא מגדיר שיכול לקרוא לכלים חיצוניים, זה Tool Use. וכשמרצפים את כל זה בלולאה שרצה עד סיום, זה Agent.

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

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

השני: Context הוא כסף ועצמה. כל מה שאתם שמים ב-Context Window עולה Tokens. תחשבו מה באמת צריך להיות שם. System Prompt ממוצע, כמה Shots לדוגמה, ו-History רלוונטי. לא הכל.

השלישי: Tool Use הוא הגשר בין ה-LLM לעולם האמיתי. כשאתם מגדירים כלים טובים עם תיאורים טובים, אתם נותנים ל-LLM את היכולת לעשות דברים שלא יכול בלעדיהם. תיאור הכלי הוא ה-API שלכם ל-LLM. כתבו אותו בדיוק כמו שהייתם כותבים תיעוד טוב.

בשיעור הבא נעשה סקירה מעשית של כלי הפיתוח שנעבוד איתם לאורך הקורס. Claude Code, Cursor, Copilot, ומה שמתאים מתי.

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