דלג לתוכן הראשי
arrow_forwardמדריכים / Claude AI
מעודכן לאפריל 2026 20 דקות קריאה למפתחים ומשתמשים מתקדמים

מדריך Claude AI המלא
Tool Use, System Prompts, API ו-Extended Thinking

כל מה שצריך לדעת על Claude מבית Anthropic — מה מייחד אותו, איך כותבים System Prompts שעובדים, Tool Use צעד אחר צעד, ואיך בונים סוכנים חכמים עם ה-API.

200K
Context Window
Constitutional
AI Safety
#1
Coding Benchmarks

ארבעה מוצרים בשם אחד

HuggingFace מתוארת בדרך כלל כ"GitHub של ה-AI", וזה מדויק בערך כמו לומר שגוגל היא מנוע חיפוש. בפועל זה ארבעה דברים נפרדים, ורוב האנשים צריכים רק אחד מהם — לרוב לא זה שהם חשבו.

השאלה שממיינת אותך לאחד מהם היא לא טכנית: האם אתה צריך להריץ מודל בעצמך, או רק לקרוא לאחד? אם התשובה השנייה — ולרוב היא — ההחלטה האמיתית שלך היא בין HuggingFace לבין ספק API מסחרי, וזה הסעיף הבא.

lightbulb
לפני שמתחילים

אם מה שאתה בונה יכול לרוץ על מודל מסחרי בקריאת API — התחל שם. תגיע ל-HuggingFace כשיש סיבה ספציפית, והסעיף הבא מפרט מה הן.

להריץ בעצמך או לשלם לספק

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

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

התחלה: שלוש שורות

הדרך המהירה ביותר להריץ מודל היא pipeline — עטיפה שמסתירה את הטוקניזציה ואת עיבוד הפלט:

pip install transformers torch

from transformers import pipeline

# תמלול — Whisper רץ מקומית
asr = pipeline("automatic-speech-recognition",
               model="openai/whisper-small")
print(asr("meeting.mp3", generate_kwargs={"language": "he"}))

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

הפרמטר language="he" בדוגמה הוא לא קישוט: בלעדיו Whisper מנחש את השפה מהשניות הראשונות, ובאודיו עברי שמתחיל במונח לועזי הוא מנחש לא נכון ומתמלל את כל הקובץ כאילו הוא באנגלית.

מה בעצם צריך כדי להריץ את זה

השאלה הראשונה שעולה אחרי הדוגמה הראשונה שרצה לאט: מה החומרה שצריך, ובאיזה סדר גודל.

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

מכאן שלוש מסקנות מעשיות:

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

איך בוחרים מודל מתוך מאות אלפים

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

  1. סנן לפי משימה בסרגל הצד. זה מוריד מאות אלפים לעשרות.
  2. בדוק רישיון לפני הכל. הסעיף הבא מסביר למה זה ראשון ולא אחרון.
  3. הורדות — כאות חלש. מודל עם מאות אלפי הורדות כנראה עובד. מודל עם שתים־עשרה כנראה לא נבדק על ידי איש. זה לא מדד איכות אלא מדד סיכון.
  4. תאריך עדכון אחרון. מודל מלפני שלוש שנים בתחום שזז מהר הוא בדרך כלל לא הבחירה.
  5. כרטיס המודל. אם אין תיעוד על מה הוא אומן, מה המגבלות ואיך להריץ — זה סימן טוב לדלג.
  6. גודל. מספר הפרמטרים קובע אם זה בכלל ירוץ אצלך. מודל שדורש יותר זיכרון גרפי ממה שיש לך פשוט לא ייטען.

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

רישיון: החלק שקובע אם מותר בכלל

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

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

עברית: מה באמת עובד

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

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

מה שכן עובד בפועל, לפי משימה:

הטוקנייזר — העלות הנסתרת

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

from transformers import AutoTokenizer
tok = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B")

he = "המערכת מעבדת חשבוניות באופן אוטומטי"
en = "The system processes invoices automatically"

print(len(tok.encode(he)), len(tok.encode(en)))
# תריץ בעצמך — הפער בין השניים הוא מה שחשוב

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

Inference: חינם, ייעודי, ומה ביניהם

הרצה כשירות מגיעה בשתי צורות שקל לבלבל ביניהן:

הטעות הנפוצה היא לבנות פרוטוטייפ על הרמה החינמית, לראות שזה עובד, ולהניח שהתמחור יתרחב באופן ליניארי. הוא לא — המעבר לייצור הוא מדרגה, לא שיפוע.

import requests

API_URL = "https://api-inference.huggingface.co/models/openai/whisper-large-v3"
headers = {"Authorization": "Bearer hf_YOUR_TOKEN"}

r = requests.post(API_URL, headers=headers,
                  data=open("meeting.mp3", "rb"))

if r.status_code == 503:
    # המודל נטען כרגע — estimated_time אומר כמה לחכות
    print("cold start:", r.json().get("estimated_time"))

הטיפול ב-503 הוא לא פינה נידחת אלא מצב שיקרה לך תמיד ברמה החינמית. קוד שלא מטפל בו ייראה כשבור באופן אקראי.

מודלים הם קוד

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

שלוש הפעולות האלה לוקחות דקה וחוסכות את התרחיש שאף אחד לא מצפה לו — שהמכונה שמריצה מודל תמלול הפכה למשהו אחר.

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

Datasets — החלק שמדלגים עליו

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

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

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

from datasets import load_dataset

ds = load_dataset("some-org/some-eval", split="test")
print(ds[0])

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

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

כוונון: מתי זה בכלל שווה

Fine-tuning נשמע כמו התשובה לכל בעיה של איכות, והוא כמעט אף פעם לא הצעד הראשון הנכון.

הסדר שמחזיר תוצאות מהר יותר:

  1. פרומפט טוב יותר. חינם, מיידי, ופותר יותר ממה שנדמה.
  2. דוגמאות בתוך הפרומפט. שלוש-חמש דוגמאות טובות משנות התנהגות דרמטית.
  3. שליפה מהנתונים שלך — RAG. פותר את "המודל לא יודע את הדברים שלנו", שזו הבעיה שרוב האנשים מנסים לפתור בכוונון.
  4. ורק אז כוונון, ובעיקר כשצריך התנהגות קבועה — פורמט, סגנון, החלטה — ולא ידע.

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

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

Spaces — למה זה כן ולמה לא

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

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

ההמלצה הפשוטה: דמו — כן. משהו שמישהו משלם עליו — לא.

מדמו למשהו שרץ

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

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

שימושים שמתאימים לכאן

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

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

מתי לא

טעויות שחוזרות

rocket_launch

מוכן להתחיל?

המשך לשכבות שמעל — חיבור מודלים לאפליקציה ושליפה מהנתונים שלך.

LangChain מדריך RAG