מפתח AI/ML או ארכיטקט AI agent

בשנה האחרונה התעשייה עוברת שינוי משמעותי: המיקוד זז מ"אימון מודלים" (בניית המוח) ל"בניית סוכנים" (מתן ידיים ורגליים למוח).

ההבדל העיקרי הוא במטרה וברמת ההפשטה. הנה ההשוואה המלאה:

מפתח AI / ML

זהו התפקיד ה"קלאסי". המפתח מתמקד בבניית המנוע עצמו.

• המטרה: ליצור או לשפר מודל מתמטי שיודע לחזות תוצאות, לזהות תמונות או להבין שפה.
• העבודה בפועל: איסוף וניקוי דאטה, אימון רשתות נוירונים (Training), כיוונון פרמטרים (Fine-tuning), אופטימיזציה של CUDA כדי שהאימון ירוץ מהר.
• ארגז הכלים: PyTorch, TensorFlow, Keras, CUDA, NumPy, Pandas.
• האתגר: "המודל שלי מדייק רק ב-80%, איך אני מביא אותו ל-95%?"

 תפקיד חדש יותר. הבונה לוקח מודל קיים ו"חכם" (כמו GPT-4 או Claude) ובונה סביבו מערכת שיודעת לבצע משימות בעולם האמיתי באופן אוטונומי.

• המטרה: ליצור "עובד וירטואלי" שיודע לקבל משימה כללית ("תחקור לי על המתחרים ותשלח מייל סיכום") ולבצע אותה מקצה לקצה.
• העבודה בפועל: תכנון "זרימה" (Flow), חיבור המודל לאינטרנט ולכלים חיצוניים (Tools), ניהול זיכרון (כדי שהסוכן יזכור מה עשה קודם), והנדסת פרומפטים (Prompt Engineering) מתקדמת.
• ארגז הכלים: LangChain, AutoGPT, CrewAI, OpenAI API, Vector Databases (כמו Pinecone).
• האתגר: "הסוכן נתקע בלולאה אינסופית" או "הסוכן המציא עובדות (הזיות)".

טבלת השוואה מהירה

תרחיש להמחשה: פרויקט זיהוי לוחיות רישוי

• מפתח ה-AI: יאסוף אלפי תמונות של מכוניות, יאמן מודל YOLO (זיהוי אובייקטים) לזהות בדיוק איפה הלוחית נמצאת, וישתמש ב-CUDA כדי שזה יקרה תוך 5 מילי-שניות. הוא ימדוד הצלחה לפי אחוז הזיהויים הנכונים.
• בונה ה-Agent: יקח את המודל שהמפתח בנה, ויעטוף אותו במערכת. המערכת שלו תדע:
  1. לקבל וידאו ממצלמת אבטחה.
  2. ברגע שהמודל מזהה לוחית -> הסוכן "יחליט" לבדוק במסד הנתונים של המשטרה.
  3. אם הרכב גנוב -> הסוכן ישלח אוטומטית התראה ב-WhatsApp לשומר.
     הבונה מתעסק ב"מה עושים עם המידע" ואיך מחברים את החלקים.

אם אתה נמשך למתמטיקה, אופטימיזציה ואיך הדברים עובדים "מתחת למכסה המנוע" (CUDA, OpenCV) – המסלול של מפתח AI מתאים לך יותר.

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

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

בונה סוכנים (AI Agent Builder) משתמש בסט כלים שונה לגמרי מזה של מפתח ה-AI הקלאסי. הוא לא צריך PyTorch או אימון רשתות, אלא כלים שיודעים "להדביק" את המודל לעולם החיצוני ולנהל את השיחה.

. השלד והניהול (Orchestration Frameworks)

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

• LangGraph (מבית LangChain): כיום הסטנדרט המוביל לבניית סוכנים מורכבים. בניגוד ל-LangChain הישנה שעבדה בקו ישר (Chain), LangGraph עובדת בצורה מעגלית (Loops), מה שקריטי לסוכנים שצריכים "לחשוב שוב" או לתקן את עצמם.
• CrewAI: ספרייה פופולרית מאוד שמתמקד בצוותים של סוכנים (Multi-Agent). היא מאפשרת להגדיר "מנהל", "חוקר" ו"כותב" שעובדים יחד ומעבירים משימות אחד לשני.
• LlamaIndex: הכלי החזק ביותר אם הסוכן שלך צריך לקרוא המון מסמכים (RAG) ולענות עליהם בדיוק רב.
• PydanticAI: ספרייה חדשה שתופסת תאוצה, מתמקדת בכתיבת סוכנים בקוד נקי ובטוח (Type-safe) בפייתון.

2. ה"מוח" (Model Providers)

הבונה לא מאמן את המודל, הוא צורך אותו דרך API.

• OpenAI API (GPT-4o): המודל הכי נפוץ וורסטילי. תומך ב-Function Calling (היכולת להפעיל קוד) בצורה הטובה ביותר.
• Anthropic (Claude 3.5 Sonnet): נחשב כיום לטוב ביותר בכתיבת קוד ובהבנת הוראות מורכבות ("Nuance"). בוני סוכנים רבים עברו אליו לאחרונה.
• Ollama: כלי שמאפשר להריץ מודלים פתוחים (כמו Llama 3 או Mistral) לוקאלית על המחשב שלך. זה מתחבר ל אם יש לך GPU חזק, אתה יכול להריץ את הסוכן בחינם ובפרטיות מלאה דרך Ollama. לוקאלי על המחשב

3. הזיכרון (Vector Databases)

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

• Pinecone: הפתרון הפופולרי ביותר בענן (Serverless). קל מאוד לשימוש.
• ChromaDB: פתרון קוד פתוח (Open Source) מעולה שאפשר להריץ מקומית.
• Supabase (pgvector): למי שמעדיף להשתמש ב-PostgreSQL המוכר והטוב.

4. החושים והידיים (Tools & Connectivity)

סוכן חכם צריך גישה לעולם.

• Tavily AI: זהו "גוגל לאנשים שלא נושמים". זה מנוע חיפוש שנבנה במיוחד ל-Agents. הוא מחזיר תשובות טקסטואליות נקיות ולא דפי HTML מלאים בפרסומות. כלי חובה לכל סוכן מחקר.
• Zapier / Make (לשעבר Integromat): מאפשרים לסוכן להתממשק ל-5,000 אפליקציות (Gmail, Slack, Excel) בלי לכתוב שורת קוד אחת.
• Browserbase / Puppeteer: כלים שנותנים לסוכן שליטה בדפדפן אמיתי (Headless Browser) כדי לבצע פעולות באתרים שאין להם API.

5. הכלים הוויזואליים (No-Code / Low-Code)

לא חייבים לכתוב פייתון כדי לבנות סוכן.

• n8n: כלי אוטומציה חזק מאוד (כמו Make אבל בקוד פתוח) שתומך ב-AI בצורה מובנית. אפשר לבנות שם סוכנים מורכבים בגרירת קוביות.
• Flowise / LangFlow: ממשקים גרפיים שמאפשרים לבנות "זרימה" של LangChain על ידי חיבור קווים בין קופסאות.

6. ניטור ובקרה (Observability)

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

• LangSmith: מאפשר לראות בדיוק מה הסוכן "חשב" בכל שלב, מה היה הפרומפט המדויק שנשלח, ואיפה הוא נכשל.

מה ה-Stack המומלץ למתחילים?

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

1. שפה: Python.
2. מסגרת: LangGraph (או CrewAI אם זה למטרת לימוד מהיר).
3. מוח: OpenAI GPT-4o-mini (זול מאוד וחכם מספיק).
4. חיפוש: Tavily.
5. סביבת פיתוח: Cursor (עורך קוד מבוסס AI שעוזר מאוד בכתיבת הקוד).

הנה תרשים שממחיש איך כל הרכיבים שדיברנו עליהם (LangGraph, GPT-4, Tavily) מתחברים כדי ליצור סוכן חכם שעובד בלולאה (Loop).

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

תרשים הזרימה: סוכן חוקר (Researcher Agent)

Plaintext

      [משתמש: "מה קרה למניית NVIDIA אתמול?"]

                     |

                     v

        +-------------------------+

        |  LangGraph (מנהל העבודה)|

        +-------------------------+

                     |

           (1. שולח את השאלה + רשימת כלים זמינים)

                     |

                     v

          +---------------------+

          |    GPT-4o (המוח)    |

          +---------------------+

                     |

           (2. מחליט: "אני לא יודע, צריך לחפש בגוגל")

           (פלט: Function Call: "search_tool")

                     |

                     v

        +-------------------------+      +------------------+

        |  LangGraph (מבצע פעולה) | ---> | Tavily (הידיים)  |

        +-------------------------+      +------------------+

                     |                          |

           (3. מקבל תוצאות חיפוש)      (מבצע חיפוש ברשת)

                     |                          |

                     v                          v

        +-------------------------+      [תוצאות טקסטואליות]

        |  LangGraph (מעדכן זיכרון)| <------------'

        +-------------------------+

                     |

           (4. שולח שוב למוח: השאלה המקורית + התוצאות שמצאנו)

                     |

                     v

          +---------------------+

          |    GPT-4o (המוח)    |

          +---------------------+

                     |

           (5. מחליט: "יש לי מספיק מידע כדי לענות")

                     |

                     v

           [תשובה סופית למשתמש]

מה קורה בכל שלב? (הסבר טכני)

זה הקסם שקורה "מתחת למכסה המנוע" כשבונים Agent:

1. האיתחול (The Setup)

אנחנו מגדירים ב-LangGraph "גרף" (Graph). הגרף הזה מכיל את המצב הנוכחי (State) - למשל, רשימת ההודעות שנצברו עד כה.

אנחנו נותנים ל-GPT-4o רשימה של כלים בפורמט JSON. למשל:

tools = [{name: "search", description: "Use this to find current events..."}]

2. המחשבה (Reasoning)

המשתמש שואל שאלה. ה-LLM (המוח) מקבל את השאלה ורואה שיש לו כלי חיפוש.

הוא לא מבצע את החיפוש בעצמו. הוא מחזיר טקסט מיוחד שאומר: "בבקשה תריצו עבורי את הפונקציה search עם הפרמטר 'NVIDIA stock news'".

זה נקרא Function Calling.

3. הביצוע (Execution)

LangGraph מזהה שהמודל ביקש להפעיל כלי. הוא עוצר את המודל, לוקח את הבקשה, ושולח אותה ל-API של Tavily.

Tavily סורק את האינטרנט ומחזיר סיכום טקסטואלי נקי (בלי פרסומות ו-HTML).

4. הלולאה (The Loop / ReAct)

זה החלק הקריטי. LangGraph לוקח את התשובה מ-Tavily, מוסיף אותה להיסטוריית השיחה (כאילו זו הודעה שמישהו לחש למודל באוזן), ושולח את הכל חזרה ל-GPT-4o.

כעת המודל רואה:

1. שאלת משתמש: "מה קרה למניה?"
2. תשובת כלי: "המניה עלתה ב-5% בעקבות דוח רווחים..."

5. ההחלטה הסופית

עכשיו ה-LLM שואל את עצמו שוב: "האם חסר לי מידע?".

• אם התשובה היא "לא" -> הוא מנסח תשובה יפה למשתמש בעברית.
• אם התשובה היא "כן" (למשל, חסר לו ההקשר של למה הרווחים עלו) -> הוא יבקש חיפוש נוסף, והלולאה תחזור על עצמה.

התרשים של AI Developer שונה מהותית מזה של בונה ה-Agent.

בעוד שאצל ה-Agent התהליך הוא לולאת שיחה (כמו צ'אט), אצל מפתח ה-AI התהליך הוא פס ייצור (Pipeline) איטרטיבי. המטרה היא לא לענות לשאלה אחת, אלא לייצר "מוח" (קובץ משקולות) שיוכל לענות על מיליוני שאלות בעתיד.

הנה דוגמא של תהליך אימון מודל (The Training Pipeline):

תרשים הזרימה: מפתח ML (Model Training Pipeline)

Plaintext

      [Raw Data: תמונות, טקסט, אודיו]

                     |

                     v

        +----------------------------+

        |  1. Data Preprocessing     | (CPU)

        |  (ניקוי, נירמול, Augmentation)|

        +----------------------------+

                     |

           (המרת דאטה ל-Tensors)

                     |

                     v

        +----------------------------+

        |  2. Model Architecture     | (Code)

        |  (הגדרת השכבות: CNN/Transformer)|

        +----------------------------+

                     |

                     v

        +============================+

        ||    3. THE TRAINING LOOP  || <--- הלב של התהליך

        ||        (רץ על CUDA)      ||

        +============================+

        |   A. Forward Pass (ניחוש)  |

        |            |               |

        |   B. Calculate Loss (טעות) |

        |   ($Loss = Y_{pred} - Y_{true}$)|

        |            |               |

        |   C. Backpropagation       |

        |   (חישוב גרדיאנטים - מתמטיקה)|

        |            |               |

        |   D. Optimizer Step        |

        |   (עדכון המשקולות ב-GPU)   |

        +============================+

                     |

                     v

        +----------------------------+

        |  4. Evaluation & Validation|

        |  (האם המודל באמת למד?)     |

        +----------------------------+

           /                   

  [תוצאה גרועה]              [תוצאה מעולה]

       |                          |

       v                          v

(שינוי Hyperparameters)    +---------------------+

(חזרה לשלב 2 או 3)         |  5. Export & Deploy |

                           |  (ONNX / TensorRT)  |

                           +---------------------+

                                      |

                                      v

                             [Model Artifact (.pt)]

מה קורה בכל שלב? (הסבר טכני)

כאן העבודה היא הרבה יותר מתמטית והנדסית מאשר בבניית Agent:

1. הכנת הדאטה (Data Preprocessing)

לפני שהדאטה מגיע למודל, הוא חייב לעבור עיבוד.

• הכלים: OpenCV, NumPy, Pandas.
• הפעולה: שינוי גודל תמונות, המרה לשחור-לבן, או נרמול ערכים לטווח שבין 0 ל-1.
• הערה: שלב זה לרוב רץ על ה-CPU, וזה לעיתים צוואר הבקבוק (ה-GPU מחכה לנתונים).

2. הגדרת הארכיטקטורה (The Architecture)

המפתח כותב קוד (למשל ב-PyTorch) שמגדיר איך המוח בנוי.

• האם זו רשת CNN (לעיבוד תמונה)?
• האם זה Transformer (לעיבוד שפה)?
• כמה שכבות? כמה "נוירונים" בכל שכבה?

3. לולאת האימון (The Training Loop - CUDA Zone)

זה השלב שבו המחשב "מזיע". כאן ה-GPU וה-CUDA נכנסים לפעולה במלוא העוצמה. התהליך הזה קורה מיליוני פעמים:

1. Forward Pass: המודל מקבל תמונה ומנחש מה יש בה.
2. Loss Calculation: מחשבים מתמטית כמה הניחוש היה רחוק מהאמת (פונקציית הטעות).
3. Backpropagation: משתמשים בנגזרות (Chain Rule) כדי להבין איזו משקולת ברשת גרמה לטעות.
4. Optimizer: מעדכנים מעט את המשקולות לכיוון הנכון (Gradient Descent).

4. הערכה ושיפור (Evaluation & Tuning)

בסוף כל "תקופה" (Epoch), בודקים את המודל על דאטה שהוא לא ראה מעולם (Validation Set).

• המפתח שואל: האם המודל עושה Overfitting (שינן את החומר אבל לא הבין)?
• הפעולה: אם התוצאות לא טובות, המפתח משנה פרמטרים (Learning Rate, Batch Size) ומריץ את האימון מחדש. זה נקרא Hyperparameter Tuning.

5. ייצוא והמרה (Deployment)

אחרי שהמודל אומן, הוא לרוב "כבד" ואיטי.

המפתח משתמש בכלים כמו NVIDIA TensorRT כדי לכווץ את המודל (Quantization - למשל מעבר מ-32bit ל-8bit) כדי שירוץ מהר מאוד בפרודקשן.

הארכיטקט AI הוא מנהל מוצר 
הוא מחבר קוביות לגו (GPT + Tavily + Database) ומתעסק בלוגיקה של השיחה. "למה הוא ענה לא עינינית האם יש כשל בארכיטקטורה?".

מפתח AI ) AI ML Developer( 

הוא המדען במעבדה מריץ ניסוים בודק גרפים ומתעסק באופטימזציה מתמטית 

איזה מהתרשימים נראה לך יותר מושך? צד ה"לוגיקה והמוצר" (Agent) או צד ה"מתמטיקה והביצועים" (Developer)?

דבר איתנו נתאים לך מסלול

• קורס סייבר ואבטחת מידע
• קורס Real Time Embedded
• קורס דאטה סיינס
• קורס למידת מכונה AI
• קורס דאטה אנליסט
• קורס DEVOPS
• קורס IT
• קורס אוטומציה
• קורס Full Stack
• קורס בניית אתרים