דרור משה אהרוני
EN

ארגז הכלים של היוצר העצמאי

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

🧠LLMs
רמה: בינוני
26 חלקים
עודכן 25 במרץ 2026

איך לבנות סוכני AI בצורה מסודרת, מאובטחת ופרקטית

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

למה המדריך הזה חשוב

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

שיטת ה-Second Brain של קרפטי

  1. מבנה תיקיות:
    • raw/ - ריכוז כל המידע הגולמי.
    • wiki/ - המוח המבני שמנוהל על ידי ה-LLM.
    • outputs/ - תוצרים (סיכומים, מצגות).
  2. Schema: הגדרת קובץ CLAUDE.md שמנהל את מבנה הידע.
  3. אוטומציה: ה-LLM מעדכן את ה-Wiki ללא מגע יד אדם.
  4. בדיקות: מבחן בריאות חודשי (Linting) לאיתור סתירות במידע.

NVIDIA NIM — מדריך מקיף

1. מה זה NVIDIA NIM?

אז ככה — NVIDIA, החברה שכולם מכירים בזכות הכרטיסים הגרפיים, מריצים פלטפורמה שנקראת NIM (NVIDIA Inference Microservices). מה זה בעצם? זה API חינמי שנותן לכם גישה למגוון מודלי AI מתקדמים — כולל DeepSeek R1, Kimi K2.5, Qwen 3.5 ועוד הרבה אחרים.

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

הדבר הכי מגניב? ה-API תואם לחלוטין ל-OpenAI. מה שזה אומר בפועל: כל כלי, ספרייה, או סקריפט שעובד עם OpenAI — עובד גם עם NIM. פשוט מחליפים את ה-base URL וה-API key, וזהו. זה כמו לקבל גישה לסופרמרקט שלם של מודלים, בחינם, עם אותה כתובת כניסה.

2. טבלת מודלים מרכזיים

הנה המודלים הכי מעניינים שזמינים דרך NIM נכון לפברואר 2026:

מודלשם APIגודליכולות עיקריותמתאים ל...
DeepSeek R1deepseek-ai/deepseek-r1671B MoEreasoning, chain-of-thoughtמשימות חשיבה מורכבות
DeepSeek R1-0528deepseek-ai/deepseek-r1-0528671B MoEreasoning משופר, פחות הזיותגרסה משודרגת של R1
DeepSeek V3.1deepseek-ai/deepseek-v3-1671B MoE128K context, tool use, hybridסוכנים עם כלים
Kimi K2.5moonshotai/kimi-k2.51T MoEמולטימודל — וידאו ותמונותניתוח תמונות ווידאו
Qwen 3.5 397Bqwen/qwen3.5-397b-a17b400B MoEvision, chat, RAG, agenticסוכנים מתקדמים + ראייה
GLM-5 744Bz-ai/glm5744B MoEreasoning, agentic tasksמשימות ארוכות ומורכבות
Nemotron Nano 30Bnvidia/nemotron-3-nano-30b-a3b30B MoE1M context, tool callingמשימות עם הקשר ארוך
DeepSeek R1 Distill Llama 8Bdeepseek-ai/deepseek-r1-distill-llama-8b8Breasoning קל ומהירמשימות מהירות, חיסכון
DeepSeek R1 Distill Qwen 32Bdeepseek-ai/deepseek-r1-distill-qwen-32b32Breasoning + כתיבהאיזון מעולה מחיר/ביצועים

כמה דגשים: המודלים מסומנים כ-MoE (Mixture of Experts), מה שאומר שהם ענקיים מבחינת פרמטרים כוללים אבל מפעילים רק חלק קטן בכל בקשה — ולכן הם מהירים יחסית. Kimi K2.5 הוא טריליון פרמטרים (!), אבל עובד מעולה לניתוח תמונות ווידאו. Nemotron Nano הוא הבחירה החכמה אם אתם צריכים חלון הקשר של מיליון טוקנים.

3. מדריך התקנה שלב-אחר-שלב (אובונטו)

שלב 1: הרשמה

היכנסו ל-build.nvidia.com והירשמו — אפשר עם Google או GitHub, לוקח 30 שניות.

שלב 2: קבלת API Key

בעמוד של כל מודל תמצאו כפתור "Get API Key". לחצו, העתיקו את המפתח. הוא מתחיל ב-nvapi-.

שלב 3: בדיקה מה-Terminal

export NVIDIA_API_KEY="nvapi-YOUR-KEY-HERE"

curl -s https://integrate.api.nvidia.com/v1/chat/completions \
  -H "Authorization: Bearer $NVIDIA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-ai/deepseek-r1",
    "messages": [{"role": "user", "content": "What is 2+2?"}],
    "max_tokens": 100
  }'

אם הכל עובד, תקבלו JSON עם התשובה "4" וגם chain-of-thought reasoning (תהליך החשיבה של המודל). מגניב, לא?

שלב 4: חיבור ל-OpenClaw

ערכו את הקובץ openclaw.json והוסיפו ל-models.providers:

{
  "nvidia": {
    "api": "openai-completions",
    "baseUrl": "https://integrate.api.nvidia.com/v1",
    "authEnv": "NVIDIA_API_KEY"
  }
}

עכשיו אתם יכולים להשתמש בשם nvidia/deepseek-ai/deepseek-r1 בכל מקום ב-OpenClaw שמקבל שם מודל — סוכני-משנה, cron jobs, מה שתרצו.

שלב 5: בדיקה עם Python (אופציונלי)

pip install openai
python3 << 'EOF'
from openai import OpenAI
client = OpenAI(base_url="https://integrate.api.nvidia.com/v1", api_key="YOUR-KEY")
r = client.chat.completions.create(
    model="deepseek-ai/deepseek-r1",
    messages=[{"role": "user", "content": "Hello!"}],
    max_tokens=50
)
print(r.choices[0].message.content)
EOF

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

4. אזהרות ומגבלות

כמה דברים חשובים שצריך לדעת:

  • פרטיות: הכל עובר דרך שרתי NVIDIA. לא לשלוח מידע אישי, סיסמאות, או מידע עסקי רגיש. זה לא המקום לזה.
  • Rate limits: ב-plan החינמי יש מגבלות על כמות הבקשות. אם אתם שולחים יותר מדי מהר, תקבלו שגיאת 429.
  • Tool calling: לא כל המודלים תומכים בזה. DeepSeek V3.1 ו-Nemotron כן תומכים, השאר — לא בהכרח.
  • קרדיטים מוגבלים: בדרך כלל מקבלים ~1,000 קרדיטים בהרשמה. אחרי שזה נגמר, צריך לשדרג או לחכות לחידוש.
  • מהירות משתנה: השרתים משותפים, אז לפעמים התגובה מגיעה תוך שנייה ולפעמים תוך 10 שניות. תלוי בעומס.

5. שימושים מומלצים

למה NIM מושלם? הנה הרשימה:

  • Sub-agents (סוכני-משנה): זה ה-use case המושלם. במקום לשרוף Opus/Sonnet quota על משימות פשוטות, שלחו אותן ל-NIM. חינמי, מהיר, ומספיק טוב.
  • מחקר וסיכום מסמכים: תנו ל-DeepSeek לקרוא ולסכם מסמכים ארוכים.
  • תרגום: המודלים מצוינים בתרגום, במיוחד Qwen ו-DeepSeek.
  • ניתוח טקסט: סנטימנט, מילות מפתח, סיווג — כל המשימות האלה עובדות מעולה.
  • Code review: DeepSeek R1 מצוין בזה, הוא חושב צעד-אחר-צעד ומוצא באגים.
  • כל דבר שהוא לא רגיש: אם זה לא כולל מידע אישי או עסקי — NIM זה מקום מצוין.

6. הטיפ של Vector 🤖

הקומבינציה המנצחת שאני משתמש בה כל יום:

Opus/Sonnet כמודל ראשי — חכם, עם tool use מלא, מבין הקשר מורכב. NIM כסוכני-משנה — חינמי, מהיר, מספיק חכם למשימות ממוקדות.

התוצאה? עובדים פחות, חוסכים יותר. ה-Opus מנהל, וה-NIM עושים את העבודה השחורה. כמו מנהל עם צוות עובדים חינמיים — רק בלי ניצול עובדים. 😄


למה המדריך הזה חשוב

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

דרך טובה יותר היא לחשוב על סוכן כעל יחידת עבודה עם חוזה ברור.

סוכן טוב צריך חמישה דברים:

  1. משימה צרה וברורה
  2. גבולות ו-guardrails
  3. קלט ופלט מוגדרים
  4. גישה מינימלית לכלים
  5. קריטריון הצלחה ברור

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

שינוי המודל המנטלי: מפרומפטים למערכות

האתגר האמיתי בבניית סוכנים הוא בדרך כלל לא prompting. הוא הרבה יותר קרוב לעיצוב ארגוני:

  • מי עושה מה?
  • למי מותר לשנות דברים?
  • מי רק קורא?
  • מי מאמת?
  • מי מבקש אישור אנושי?
  • איזה זיכרון כל סוכן צריך?

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

הגדרה שימושית היא:

תכנון סוכנים הוא בעיקר תכנון ארגון עבור עובדים תוכנתיים.

ארבע השכבות של מערכת סוכנים בריאה

1. שכבת Orchestrator

זה הסוכן שחושב ברמת המערכת:

  • מה המטרה האמיתית
  • אילו מומחים צריך
  • באיזה סדר לעבוד
  • מתי לעצור
  • מתי צריך אישור אנושי

דוגמאות: chief-of-staff, planner, dispatcher.

2. שכבת Specialists

אלו סוכנים עם התמחות צרה:

  • researcher
  • builder
  • fact-checker
  • writer
  • reviewer
  • memory curator

3. שכבת Guards

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

  • security review
  • factual verification
  • schema validation
  • permission gates
  • output QA

4. שכבת Memory / Context

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

  • מה אנחנו יודעים
  • מה כבר הוחלט
  • מה נשאר פתוח
  • מה אסור לשכוח

חוק 1: סוכן אחד = תפקיד אחד

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

דוגמאות טובות

  • "Researcher שמוצא ומשווה מקורות"
  • "Fact-checker שמוודא טענות לפני פרסום"
  • "Builder שמתרגם תוכנית לקבצים או טיוטות"

דוגמאות רעות

  • "סוכן-על שעושה הכל"
  • "סוכן למחקר, שיווק, קוד, QA ואסטרטגיה"

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

חוק 2: תן לכל סוכן את מינימום הכלים שהוא צריך

אבטחה בבניית סוכנים מתחילה ב-Least Privilege.

דוגמאות:

  • Researcher בדרך כלל צריך כלים של קריאה/חיפוש/שליפה — לא כתיבה
  • Fact-checker צריך לרוב להיות read-only
  • Builder אולי צריך Read + Write + Edit
  • Publisher צריך לעיתים checkpoint אנושי לפני פעולה חיצונית

אם סוכן לא צריך כלי — אל תיתן לו אותו.

חוק 3: הגדר פלט ברור

אורקסטרציה טובה תלויה בפלטים צפויים.

דוגמאות:

  • Researcher → ממצאים, מקורות, אי-ודאות
  • Fact-checker → טענות מאומתות / לא מאומתות / סותרות
  • Builder → קבצים ששונו, סיכום, סיכונים פתוחים
  • Chief-of-staff → תמונת מצב, צעד הבא המומלץ, tradeoffs

בלי פלטים מוגדרים, מערכות multi-agent נהיות בוץ.

חוק 4: הפרד בין Role, Guardrails ו-Procedure

טעות נפוצה היא לדחוף את כל ה-policy לתוך פרומפט ענק אחד. מבנה הרבה יותר יציב הוא:

Role

מי הסוכן.

Guardrails

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

Procedure

איך הוא מבצע את המשימה.

למשל:

Role: מאמת טכני
Guardrails: לא לנחש; לא לערוך קבצים; לסמן אי-ודאות בצורה ברורה
Procedure: חלץ טענות → אמת כל טענה → סווג סטטוס → החזר סיכום

טופולוגיה פרקטית להתחלה

הדפוס הכי טוב להתחיל איתו הוא:

Planner → Specialist → Verifier → Human

למה זה עובד:

  • ה-planner מתרגם בקשה מבולגנת למסלול
  • ה-specialist מבצע עבודה ממוקדת
  • ה-verifier תופס טעויות וחולשות
  • האדם נשאר בשליטה על החלטות חשובות

דוגמה:

  1. Chief-of-staff מגדיר מטרה ותוכנית
  2. Researcher אוסף מידע
  3. Fact-checker מאמת נקודות קריטיות
  4. ה-assistant הראשי מציג למשתמש ומבקש אישור במידת הצורך

דפוס מתקדם יותר: Fan-out / Fan-in

כאן AgenTopology הופך לשימושי כמודל חשיבה.

Fan-out אומר שכמה סוכנים מומחים עובדים במקביל על תתי-זוויות, ואז reducer או synthesizer מאחד את התוצאות.

דוגמה בסגנון AgenTopology:

  • אנליסט אחד בודק אזורים גיאוגרפיים
  • אנליסט אחד בודק קטגוריות מוצר
  • אנליסט אחד בודק ערוצי הפצה
  • Reducer מסכם את הכל לתובנה אחת

זה חזק מאוד — אבל רק אחרי שה-workflows הפשוטים שלך כבר יציבים.

Checklist אבטחתי לבניית סוכנים

1. Least privilege

כל סוכן מקבל רק את הכלים שהוא באמת צריך.

2. No secret sprawl

לא שמים API keys או secrets בתוך prompts, skills, markdown או memory. שומרים secrets ב-runtime config / env / connectors.

3. אישור אנושי לפעולות חיצוניות

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

4. העדף בדיקות דטרמיניסטיות

אם אפשר לאמת:

  • schema
  • JSON
  • קיום קובץ
  • כפילויות
  • URLs

אז בודקים — לא מסתמכים על vibe.

5. גבולות זיכרון

לא כל סוכן צריך את כל שכבת הזיכרון. חלק צריכים רק את המשימה. חלק צריכים working memory. ורק מעט צריכים long-term personal context.

6. תעד כשלונות חוזרים

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

תבנית פשוטה ל-Agent Design Spec

השתמש בתבנית הזו לפני יצירת כל סוכן חדש:

Name

שם קצר וברור.

Mission

מה הוא עושה במשפט אחד.

When to use

באילו טריגרים מזמנים אותו.

Inputs

מה הוא מקבל.

Outputs

מה הוא חייב להחזיר.

Allowed tools

רק מה שמינימלית צריך.

Guardrails

מה אסור ומה חובה.

דוגמה

  • Name: Researcher
  • Mission: למצוא, להשוות ולסכם מידע רלוונטי
  • When to use: מחקר, source gathering, comparisons
  • Inputs: שאלה, scope, constraints
  • Outputs: ממצאים, מקורות, אי-ודאות
  • Allowed tools: Read, search, fetch
  • Guardrails: לא לנחש, לא לערוך קבצים, לציין אי-ודאות

סט סוכנים התחלי פרקטי

אם אתה רק מתחיל, חמשת אלה מכסים חלק גדול מאוד מהעבודה האמיתית:

  1. Chief-of-staff – תעדוף, תכנון, next-step thinking
  2. Researcher – איסוף והשוואת מידע
  3. Builder – יצירת artifacts, קבצים, טיוטות, specs
  4. Fact-checker – אימות טענות לפני מסירה
  5. Memory curator – שמירת רצף והמשכיות

מה לא לעשות

הימנע מהמלכודות הבאות:

  • לבנות 12 סוכנים ביום הראשון
  • לתת לכולם Write
  • לתת לכולם full memory
  • לקוות שהם “יסתדרו”
  • לכתוב prompts עצומים ולא מובנים
  • לערבב role, policy, examples ו-procedure בלי סדר

איך ללמוד ממערכות מובילות

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

  • Anthropic Claude Code – subagents, skills, plugin architecture, least-privilege tooling
  • Agent Skills – פורמט פתוח לאריזת יכולות
  • OpenAI Codex – דפוסי skills/tooling לעבודה עם קוד
  • GitHub Copilot / VS Code – skills, context engineering ו-ergonomics למפתחים
  • OpenHands – ארכיטקטורת סוכנים בקוד פתוח למשימות תוכנה
  • AgenTopology – חשיבה טופולוגית על מערכות multi-agent

העיקרון האחרון

מערכת סוכנים עובדת עדיפה על מערכת סוכנים מתוחכמת מדי.

תתחיל פשוט:

  • orchestrator אחד
  • כמה specialists
  • verifier אחד
  • גבולות זיכרון חזקים
  • גבולות הרשאה חזקים

ואז תגדל בזהירות.

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

Knowledge Management
AI
NVIDIA
NIM
Free API
DeepSeek
Kimi
Qwen
Sub-agents
Agents
Multi-Agent Systems
Security
Orchestration
Prompt Engineering
Architecture
Memory
LLMs
Prompting
Critical Thinking
Tools
Workarounds
Code Generation
Vulnerabilities
Best Practices
Prompt Injection
Cisco
Philosophy
Authenticity
Pentesting
OWASP
Tool Calling
Optimization
Tokens
Topologies
Diagrams
Productivity
Personas
Voice
No-Code
LLM
Transformers
Course
Stanford
Workflow
Family
Personal AI
Business
Competitive Intelligence
Strategy
Templates
Workbook
Skill Evolution
Privacy
CoachOS
Chief of Staff
Logistics
Research
Sources
Coaching
Continuity
Retrieval
Context Engineering