ai-agents-for-beginners

יצירת סוכני בינה מלאכותית מקומיים באמצעות Microsoft Foundry Local ו-Qwen

יצירת סוכני בינה מלאכותית מקומיים

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

למה תרצה את זה? שלושה סיבות שבאות לידי ביטוי בתדירות גבוהה בעבודה הנדסית אמיתית:

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

הקדמה

שיעור זה יכסה:

מטרות למידה

לאחר סיום שיעור זה תדע כיצד:

דרישות מוקדמות

שיעור זה מניח שסיימת את השיעורים הקודמים ונוח לך עם:

תזדקק גם ל:

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

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

SLMs מצטיינים ב:

SLMs חלשים ב:

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

flowchart LR
    U[מפתח] --> A[סוכן SLM מקומי]
    A -->|מחליט איזו כלי| T1[קריאת קובץ]
    A -->|מחליט איזו כלי| T2[חיפוש מסמכים RAG]
    A -->|מחליט איזו כלי| T3[ניתוח קוד]
    T1 --> A
    T2 --> A
    T3 --> A
    A --> R[תשובה, מלאה במכשיר]

Microsoft Foundry Local

Microsoft Foundry Local היא סביבת הרצה קלה שיורדת, מנהלת ומספקת מודלים לגמרי על המכונה שלך. התכונה החשובה ביותר עבורנו היא שהיא חושפת נקודת קצה HTTP תואמת OpenAI — מה שאומר ש-SDK של OpenAI ולקוח OpenAI במסגרת סוכני Microsoft עובדים איתה עם שינוי בלבד של base_url. כל מה שלמדת על בניית סוכנים עובר ישירות; רק נקודת הקצה זזה מהענן ל־localhost.

Foundry Local גם בוחרת אוטומטית את הבניה הטובה ביותר של מודל לחומרה שלך — בניית CPU, בניית CUDA/GPU, או בניית NPU — כדי שלא תצטרך לבצע אופטימיזציה ידנית למכונה.

התקנה

התקן את Foundry Local (ראה את התיעוד עבור מערכת ההפעלה שלך), ואז בדוק שהוא עובד:

# התקן (לדוגמה; עקוב אחרי התיעוד עבור הפלטפורמה שלך)
winget install Microsoft.FoundryLocal      # חלונות
# brew install microsoft/foundrylocal/foundrylocal   # macOS

# הורד והפעל מודל Qwen, ואז התחל את השירות המקומי
foundry model run qwen2.5-7b-instruct
foundry service status

ברגע שהשירות פועל יש לך נקודת קצה מקומית, תואמת OpenAI (לרוב http://localhost:PORT/v1). הפנקס משתמש ב־foundry-local-sdk כדי לאתר את נקודת הסיום באופן אוטומטי, כך שלא צריך לקבוע את הפורט בקוד באופן נוקשה.

קריאת פונקציות Qwen: למה זה חשוב

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

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

sequenceDiagram
    participant U as משתמש
    participant A as סוכן Qwen (מקומי)
    participant T as כלי מקומי
    U->>A: "מה עושה auth.py?"
    A->>A: החלטה: לקרוא read_file
    A->>T: read_file("auth.py")
    T-->>A: תוכן הקובץ
    A->>A: ניתוח התוכן
    A-->>U: הסבר

RAG מקומי

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

אנחנו משתמשים בChroma, מאגר וקטורי משובץ שרץ בתהליך ללא שרת לניהול. התהליך כולו מקומי: מודל הטמעה מקומי → וקטורים מקומיים → אחזור מקומי → SLM מקומי.

flowchart TB
    D[המסמכים / הקוד שלך] --> E[מודל הטמעה מקומי]
    E --> V[(Chroma vector DB - בדיסק)]
    Q[שאילתו של הסוכן] --> QE[הטמע את השאילתה מקומית]
    QE --> V
    V -->|קטעי top-k| A[סוכן Qwen]
    A --> Ans[תשובה מבוססת]

זה אותו תבנית Agentic RAG משיעור 5 — השינוי היחיד שכל רכיב פועל על המכונה שלך.

שרתי MCP מקומיים

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

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

תבניות משולבות של ענן ומקומי

“מקומי קודם” לא אומר רק מקומי. מערכות בשלות מנתבות לפי רגישות וקושי:

מצב איפה זה פועל
קוד/נתונים רגישים או לא מקוון SLM מקומי
משימה פשוטה ומוגבלת SLM מקומי (זול, מהיר)
הסקת מסקנות מרובת קפיצות קשה על נתונים לא רגישים מודל ענן
הכל בזמן הפסקת שירות SLM מקומי (ירידה איכותית)

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

flowchart LR
    Q[בקשה] --> S{רגיש או לא מקוון?}
    S -->|כן| L[SLM מקומי]
    S -->|לא| C{צריך הסקה מעמיקה?}
    C -->|לא| L
    C -->|כן| Cloud[מודל ענן]
    L --> Out[תגובה]
    Cloud --> Out

מעבדה מעשית: עוזר הנדסי מקומי

פתח code_samples/17-local-agent-foundry-local.ipynb ועבוד דרכו. תבנה עוזר הנדסי מקומי שרץ לגמרי על תחנת העבודה שלך ויכול:

  1. לקרא כלים — דרך קריאת פונקציות Qwen דרך Foundry Local.
  2. לבצע פעולות קבצים מקומיות — לרשום ולקרוא קבצים בתיקיית פרויקט.
  3. לנתח קוד — לדווח מדדים בסיסיים על קובץ מקור.
  4. לחפש בתיעוד — RAG מקומי על תיקיית תיעוד באמצעות Chroma.
  5. להשתמש ב-MCP — להתחבר לשרת MCP מקומי (עם דילוג מתחשב אם אינו מוגדר).

לא נעשה שימוש באינפרנס ענן בשום שלב.

הליכה צעד-אחר-צעד

העוזר מתחבר ל-Foundry Local דרך נקודת קצה תואמת OpenAI, כך שקוד הסוכן כמעט זהה לשיעורי הענן — רק הלקוח משתנה:

from foundry_local import FoundryLocalManager
from openai import OpenAI

# Foundry Local מגלה/מוריד את הדגם ומספק לנו נקודת קצה מקומית.
manager = FoundryLocalManager(\"qwen2.5-7b-instruct\")
client = OpenAI(base_url=manager.endpoint, api_key=manager.api_key)  # api_key הוא מייצג מקומי

הכלים הם פונקציות Python רגילות המוגבלות לתיקיית פרויקט:

def read_file(path: str) -> str:
    \"\"\"Read a file, but only inside the sandboxed project directory.\"\"\"
    full = (PROJECT_ROOT / path).resolve()
    if PROJECT_ROOT not in full.parents and full != PROJECT_ROOT:
        return \"Access denied: path is outside the project directory.\"
    return full.read_text(encoding=\"utf-8\")

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

בדיקת ידע

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

1. תן שני סיבות ברורות להפעיל סוכן מקומית במקום בענן.

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

2. מה החלוקה המומלצת של העבודה בין SLM לכליו בסוכן מקומי, ולמה?

תשובה תן ל-SLM **לארגן** (להחליט איזה כלי לקרוא ובאילו ארגומנטים) ותן ל**כלים לבצע את העבודה הכבדה** (קריאת קבצים, אחזור מסמכים, חישוב תוצאות). SLMs חזקים בהחלטות מוגבלות כמו בחירת כלים אך חלשים בידע רחב ובהסקת מסקנות ארוכת קפיצות, כך שהסתמכות על כלים מנצלת את חוזקותיהם.

3. מה מאפשר שימוש מחדש בקוד סוכני ענן עם Foundry Local?

תשובה Foundry Local חושפת **נקודת קצה HTTP תואמת OpenAI**. SDK של OpenAI ולקוח OpenAI במסגרת סוכנים עובדים איתה על ידי שינוי רק של `base_url` (ושימוש במפתח API מקומי). כל השאר בקוד הסוכן נשאר זהה.

4. למה אנחנו משתמשים במיוחד במודל קריאת פונקציות Qwen ולא בכל SLM?

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

5. באפיק RAG מקומי, אילו רכיבים רצים על המכונה?

תשובה כולם: מודל ההטמעה, מסד הנתונים הוקטורי (Chroma, בדיסק), שלב האחזור, ו-SLM. המסמכים מוטמעים מקומית, נשמרים מקומית, מאוחזרים מקומית, ומנותחים באמצעות מודל מקומי — שום רכיב לא נוגע בענן.

6. שרת MCP מקומי רץ על המכונה שלך. האם זה הופך אותו אוטומטית לבטוח? איזו זהירות עדיין צריך לנקוט?

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

7. תאר חוק ניתוב היברידי הגיוני הכולל מודל מקומי.

תשובה נהל בקשות רגישות או לא מקוונות ל-SLM מקומי; נהל משימות פשוטות ומוגבלות ל-SLM מקומי לשם מהירות ועלות; נהל הסקות קשות מרובות קפיצות על נתונים לא רגישים למודל ענן; וחזור ל-SLM מקומי אם הענן אינו זמין כך שהסוכן מתדרדר באיכות בצורה מתחשבת במקום לכשל. זה ניתוב מודלים (שיעור 16) כאשר המכונה המקומית היא אחד המודלים.

8. מהו נתון מינימום זיכרון RAM ריאלי להפעלת הסוכן המקומי בשיעור זה, ומה זיכרון נוסף נותן לך?

תשובה כ-**8 ג"ב** הוא מינימום ריאלי; 16 ג"ב ומעלה נוח יותר. זיכרון נוסף מאפשר הפעלה של מודלים גדולים ויותר חזקים ושמירת הקשר יותר בזיכרון. GPU או NPU מזרזים אינפרנס אך אינם דרושים — Foundry Local בוחר בניית CPU כשאין מאיץ זמין.

משימה

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

ההגשה שלך צריכה:

  1. לאנדקס תיקיית מסמכים/קוד אמיתית ל-Chroma (לפחות חמישה קבצים).

  2. להוסיף כלי find_todos שסורק את הפרויקט אחר הערות ‘TODO’/’FIXME’ ומחזיר אותן עם שם הקובץ ומספר השורה — תוך שמירה על הבדיקה הביטחונית כמו ב־read_file.

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

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

סיכום

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

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

משאבים נוספים

השיעור הקודם

פריסת סוכנים מתקדמים

השיעור הבא

אבטחת סוכני בינה מלאכותית

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

This site is open source. Improve this page.