פיתוח AI Agents אוטונומיים: מדריך מעשי עם CrewAI ו-AutoGen

כדי לבנות AI Agent אוטונומי שמבצע משימות מורכבות בצורה עצמאית, צריך שלושה דברים: מודל שפה (LLM) שמשמש כ"מוח", פריימוורק אורקסטרציה שמנהל את זרימת העבודה, וכלים (tools) שנותנים לסוכן גישה לעולם האמיתי — חיפוש ברשת, קריאה ל-API, גישה למסד נתונים. CrewAI ו-AutoGen הם שני הפריימוורקים המובילים כיום לבניית מערכות כאלה, וכל אחד מהם מביא גישה שונה למשחק. במדריך הזה נבנה יחד, שורה אחרי שורה, מערכת סוכנים שעובדת באמת — לא PowerPoint, לא תיאוריה, אלא קוד שרץ.

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

המונח הטכני הוא agentic loop — לולאה שבה הסוכן חושב (reasoning), פועל (action), מתבונן בתוצאה (observation), ומחליט אם הוא סיים או צריך לחזור על התהליך. זה ה-ReAct pattern שהוצג במחקר שפורסם לאחרונה, והוא הבסיס של כמעט כל פריימוורק סוכנים מודרני.

מתי כדאי לבנות AI Agent ומתי מספיק prompt רגיל?

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

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

נקודת מפתח: הטעות הנפוצה ביותר בפיתוח סוכנים היא over-engineering — לבנות מערכת מרובת-סוכנים כשמספיק שרשרת prompts פשוטה. תמיד תתחילו מהפשוט ותסבכו רק כשזה הכרחי.

CrewAI בנוי על מטאפורה אחת פשוטה: צוות (Crew) מורכב מסוכנים (Agents) שלכל אחד יש תפקיד (role), ולכל סוכן יש משימות (Tasks). ה-Crew מנהל את סדר הביצוע ואת העברת המידע בין הסוכנים. זו גישת role-based orchestration — כל סוכן הוא מומחה בתחום שלו.

איך מתקינים ומגדירים סביבת CrewAI?

ההתקנה פשוטה — pip install ומפתח API. הנה הצעדים:

# יצירת סביבה וירטואלית
python3 -m venv agents-env
source agents-env/bin/activate

# התקנת CrewAI עם כלים מובנים
pip install crewai crewai-tools

# הגדרת מפתח API כמשתנה סביבה
export OPENAI_API_KEY="sk-your-key-here"

# אימות התקנה
python -c "from crewai import Agent, Task, Crew; print('CrewAI ready!')"

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

from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool

# כלי חיפוש ברשת — דורש SERPER_API_KEY בסביבה
search_tool = SerperDevTool()

# === הגדרת סוכנים ===
researcher = Agent(
    role="חוקר טכנולוגי בכיר",
    goal="למצוא מידע עדכני ומהימן על {topic}",
    backstory=(
        "אתה חוקר טכנולוגי עם ניסיון של 15 שנה. "
        "אתה קפדן לגבי מקורות ותמיד מצליב מידע."
    ),
    tools=[search_tool],
    verbose=True,
    allow_delegation=False,
)

analyst = Agent(
    role="מנתח מגמות",
    goal="לנתח את הממצאים ולזהות דפוסים ותובנות",
    backstory=(
        "אתה אנליסט שמחפש את הסיגנל בתוך הרעש. "
        "אתה מזהה מגמות לפני שהן הופכות למיינסטרים."
    ),
    verbose=True,
    allow_delegation=False,
)

writer = Agent(
    role="כותב טכני",
    goal="לכתוב דוח מקצועי ונגיש בעברית",
    backstory=(
        "אתה כותב טכני שמאמין שכל נושא מורכב "
        "ניתן להסביר בצורה ברורה ומעניינת."
    ),
    verbose=True,
    allow_delegation=False,
)

# === הגדרת משימות ===
research_task = Task(
    description=(
        "חקור את הנושא: {topic}. "
        "מצא לפחות 5 מקורות עדכניים. "
        "תעד את הממצאים בצורה מסודרת."
    ),
    expected_output="רשימת ממצאים עם מקורות",
    agent=researcher,
)

analysis_task = Task(
    description=(
        "נתח את ממצאי המחקר. "
        "זהה 3 מגמות מרכזיות ו-2 סיכונים. "
        "הצע המלצות מעשיות."
    ),
    expected_output="דוח ניתוח עם מגמות, סיכונים והמלצות",
    agent=analyst,
    context=[research_task],  # תלוי בתוצאת המחקר
)

writing_task = Task(
    description=(
        "כתוב דוח מקצועי בעברית על בסיס הניתוח. "
        "הדוח חייב לכלול: תקציר מנהלים, ממצאים מרכזיים, "
        "ניתוח מגמות, והמלצות. 800-1200 מילים."
    ),
    expected_output="דוח מקצועי מוכן לפרסום בעברית",
    agent=writer,
    context=[research_task, analysis_task],
    output_file="report.md",
)

# === הרכבת הצוות והרצה ===
crew = Crew(
    agents=[researcher, analyst, writer],
    tasks=[research_task, analysis_task, writing_task],
    process=Process.sequential,  # משימות רצות בסדר
    verbose=True,
)

result = crew.kickoff(inputs={"topic": "Edge AI in manufacturing"})
print(result)

שימו לב לכמה דברים קריטיים בקוד: הפרמטר context מאפשר למשימה לקבל את הפלט של משימות קודמות — זו שרשרת המידע שהופכת את המערכת ממקבץ סוכנים בודדים לצוות אמיתי. הפרמטר process קובע אם המשימות רצות ברצף (sequential) או במקביל (hierarchical).

טעות נפוצה: מפתחים רבים שמים allow_delegation=True על כל הסוכנים ואז מתפלאים שהמערכת נכנסת ללולאות אינסופיות. התחילו עם delegation כבוי, והפעילו רק כשיש לכם סיבה ספציפית.

AutoGen של Microsoft לוקח גישה שונה לחלוטין. במקום תפקידים ומשימות, הוא בונה שיחות (conversations) בין סוכנים. כל סוכן הוא ConversableAgent שיכול לדבר, להקשיב, ולהפעיל קוד. זה כמו חדר ישיבות וירטואלי שבו הסוכנים מדברים ביניהם עד שמגיעים לפתרון.

איך מתקינים AutoGen ובונים שיחת סוכנים ראשונה?

# התקנת AutoGen
pip install autogen-agentchat autogen-ext[openai]

# אימות
python -c "from autogen_agentchat.agents import AssistantAgent; print('AutoGen ready!')"

הנה דוגמה מעשית — שני סוכנים שמשתפים פעולה לכתיבת ובדיקת קוד Python:

import asyncio
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.conditions import TextMentionTermination
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_ext.models.openai import OpenAIChatCompletionClient

# הגדרת מודל
model_client = OpenAIChatCompletionClient(
    model="gpt-4o",
    # api_key נלקח אוטומטית מ-OPENAI_API_KEY
)

# סוכן מתכנת
coder = AssistantAgent(
    name="coder",
    model_client=model_client,
    system_message=(
        "אתה מתכנת Python מומחה. "
        "כתוב קוד נקי, מתועד ויעיל. "
        "כשהקוד מוכן ונבדק, כתוב APPROVED."
    ),
)

# סוכן בודק קוד
reviewer = AssistantAgent(
    name="reviewer",
    model_client=model_client,
    system_message=(
        "אתה בודק קוד קפדני. "
        "בדוק ביצועים, אבטחה וקריאות. "
        "אם הקוד תקין, כתוב APPROVED. "
        "אחרת, הצע תיקונים ספציפיים."
    ),
)

# תנאי סיום — כששני הסוכנים מסכימים
termination = TextMentionTermination("APPROVED")

# יצירת צוות עם שיחה מעגלית
team = RoundRobinGroupChat(
    participants=[coder, reviewer],
    termination_condition=termination,
    max_turns=6,  # מגביל כדי למנוע לולאות
)


async def main():
    result = await team.run(
        task=(
            "כתוב פונקציית Python שמקבלת רשימת URLs, "
            "מוריד את התוכן שלהם באופן אסינכרוני עם aiohttp, "
            "ומחזיר dict של URL->status_code. "
            "טפל בשגיאות timeout ו-connection errors."
        )
    )
    for message in result.messages:
        print(f"[{message.source}]: {message.content[:200]}...")


asyncio.run(main())

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

איך מוסיפים כלים (Tools) לסוכנים ב-AutoGen?

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

import json
import urllib.request
from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient


# הגדרת כלי — פונקציה פשוטה עם type hints ו-docstring
def get_weather(city: str) -> str:
    """
    מחזיר מזג אוויר נוכחי לעיר נתונה.
    משתמש ב-wttr.in API (חינמי, לא דורש מפתח).
    """
    try:
        url = f"https://wttr.in/{city}?format=j1"
        req = urllib.request.Request(url)
        with urllib.request.urlopen(req, timeout=10) as resp:
            data = json.loads(resp.read())
            current = data["current_condition"][0]
            return (
                f"מזג אוויר ב-{city}: "
                f"{current['temp_C']}°C, "
                f"{current['weatherDesc'][0]['value']}, "
                f"לחות {current['humidity']}%"
            )
    except Exception as e:
        return f"שגיאה בשליפת מזג אוויר: {e}"


model_client = OpenAIChatCompletionClient(model="gpt-4o")

# רישום הכלי בסוכן
weather_agent = AssistantAgent(
    name="weather_assistant",
    model_client=model_client,
    tools=[get_weather],
    system_message=(
        "אתה עוזר מזג אוויר. "
        "השתמש בכלי get_weather כדי לענות על שאלות. "
        "תמיד ענה בעברית."
    ),
)

שימו לב: ה-docstring של הפונקציה קריטי — ה-LLM משתמש בו כדי להבין מתי ואיך להפעיל את הכלי. type hints הם חובה כדי שה-framework יידע לסדר את הפרמטרים בפורמט function calling של OpenAI.

CrewAI אם אתם יודעים מראש מה כל סוכן צריך לעשות, AutoGen אם אתם צריכים שהסוכנים ינהלו שיחה דינמית כדי להגיע לפתרון.

לפי סקרים בקהילת המפתחים בשנה האחרונה, CrewAI צובר פופולריות מהירה בקרב צוותים קטנים בזכות הפשטות שלו — זמן ה-time-to-first-demo נמוך משמעותית. AutoGen, לעומתו, מועדף בסביבות enterprise שבהן צריך שליטה מלאה על זרימת השיחה ואינטגרציה עם Azure.

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

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

מה חייבים לדעת על עלויות, אמינות ואבטחה?

1. ניהול עלויות: כל קריאה ל-LLM עולה כסף. מערכת שלושה סוכנים שכל אחד שולח 3-4 הודעות יכולה לבלוע אלפי tokens בתהליך אחד. חייבים להגדיר max_turns, לעקוב אחרי צריכת tokens, ולשקול מודלים מקומיים (Ollama עם Llama 3 או Mistral) למשימות שלא דורשות את הרמה של GPT-4o.

2. טיפול בכשלונות: LLMs הם לא דטרמיניסטיים. אותו prompt יכול להחזיר תוצאות שונות. חייבים retry logic, validation על הפלט, ו-fallback למודל אחר אם המודל הראשי לא זמין.

3. אבטחה: סוכן עם גישה לכלים הוא סוכן עם יכולת לפעול. prompt injection — כשמישהו מזריק הוראות זדוניות דרך הנתונים שהסוכן מעבד — הוא איום אמיתי. חובה: sandboxing לביצוע קוד, הרשאות מינימליות (least privilege), ו-human-in-the-loop לפעולות קריטיות.

4. observability: חייבים לראות מה הסוכנים עושים. LangSmith, Arize, או אפילו לוגים מובנים — בלי trace מלא של כל שיחה, אי אפשר לדבג בעיות ולשפר ביצועים.

5. בדיקות: כן, גם לסוכני AI צריך בדיקות. לא unit tests קלאסיים, אלא eval frameworks שבודקים שהסוכן מגיע לתוצאה הנכונה על סט מוגדר של תרחישים. ספריות כמו DeepEval או promptfoo מקלות על זה משמעותית.

# דוגמה: הוספת retry ו-token tracking ב-CrewAI
from crewai import Crew, Process

crew = Crew(
    agents=[researcher, analyst, writer],
    tasks=[research_task, analysis_task, writing_task],
    process=Process.sequential,
    verbose=True,
    max_rpm=10,          # הגבלת קריאות לדקה למודל
    memory=True,         # הפעלת זיכרון מובנה
    cache=True,          # קאשינג תוצאות כלים — חוסך tokens
    max_execution_time=300,  # timeout ב-שניות
)

result = crew.kickoff(inputs={"topic": "AI Agents in healthcare"})

# גישה לסטטיסטיקות שימוש
print(f"Total tokens: {result.token_usage}")

איך משלבים מודלים מקומיים כדי לחסוך עלויות?

לא כל משימה צריכה GPT-4o. סוכן שמסכם טקסטים יכול להסתדר מצוין עם Llama 3 שרץ מקומית דרך Ollama. הנה איך מגדירים את זה:

# התקנת Ollama והורדת מודל
curl -fsSL https://ollama.ai/install.sh | sh
ollama pull llama3.1:8b

# אימות שהמודל רץ
ollama list

# שימוש במודל מקומי ב-CrewAI
from crewai import Agent, LLM

local_llm = LLM(
    model="ollama/llama3.1:8b",
    base_url="http://localhost:11434",
)

local_agent = Agent(
    role="מסכם מסמכים",
    goal="לסכם מסמכים ארוכים בצורה תמציתית",
    backstory="אתה מומחה בסיכום מידע מורכב.",
    llm=local_llm,
    verbose=True,
)

הטריק: לתת למודל המקומי את המשימות ה"כבדות" מבחינת volume אבל ה"קלות" מבחינת מורכבות, ולשמור את GPT-4o רק לסוכנים שצריכים reasoning מתקדם. לפי הערכות בתעשייה, הגישה הזו יכולה לחסוך 60%-80% מעלויות ה-API בלי פגיעה משמעותית באיכות.

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

• התחילו עם CrewAI אם אתם רוצים להגיע ל-POC עובד תוך שעה — שלושה סוכנים עם משימות ברורות.
• עברו ל-AutoGen כשצריך שיחות מורכבות, הרצת קוד בסנדבוקס, או אינטגרציה עם Azure.
• שלבו מודלים מקומיים (Ollama + Llama 3) עבור משימות פשוטות כדי לחסוך עלויות משמעותיות.
• אל תדלגו על observability — בלי trace מלא של שיחות הסוכנים, אתם עיוורים ב-production.
• בנו eval מהיום הראשון — הגדירו תרחישי בדיקה ובדקו שהמערכת עומדת בהם אחרי כל שינוי.

עודכן: 2026-09-30

מה ההבדל בין AI Agent לבין שרשרת prompts רגילה?

שרשרת prompts (prompt chaining) היא רצף קבוע מראש — הפלט של prompt אחד מוזן ל-prompt הבא. AI Agent, לעומת זאת, מקבל החלטות דינמיות: הוא יכול לבחור אילו כלים להפעיל, לחזור על צעדים אם התוצאה לא מספקת, ולשנות מסלול תוך כדי ביצוע. Agent כולל לולאת reasoning-action-observation, בעוד שרשרת היא ליניארית.

האם אפשר לפתח AI Agents בלי מפתח API של OpenAI?

בהחלט. גם CrewAI וגם AutoGen תומכים במודלים מקומיים דרך Ollama, LM Studio, או כל שרת שחושף API תואם OpenAI. מודלים כמו Llama 3.1, Mistral ו-Qwen עובדים מצוין למשימות רבות. התחילו עם מודל 8B פרמטרים ובדקו אם האיכות מספיקה לפני שמשלמים על API חיצוני.

כמה זמן לוקח לבנות מערכת סוכנים ראשונה?

POC בסיסי עם CrewAI — שעה עד שעתיים, כולל התקנה. מערכת AutoGen עם שיחות מרובות-סוכנים — חצי יום עבודה. מערכת production-ready עם טיפול בשגיאות, observability ובדיקות — שבוע עד שבועיים. ההשקעה הגדולה היא לא בקוד עצמו אלא בעיצוב הנכון של התפקידים, המשימות וה-prompts.

מתי עדיף LangChain על CrewAI או AutoGen?

LangChain הוא ספרייה לבניית שרשראות LLM, לא פריימוורק סוכנים מרובים. הוא מצוין כשצריך סוכן יחיד עם כלים רבים, או שרשרת RAG מורכבת. כשצריך מספר סוכנים שמשתפים פעולה — CrewAI ו-AutoGen עדיפים. אגב, CrewAI משתמש ב-LangChain מתחת למכסה למנוע, כך שהם לא מתחרים אלא משלימים.

אילו שפות תכנות תומכות בפיתוח AI Agents?

Python שולטת בתחום — גם CrewAI וגם AutoGen הם ספריות Python. יש ספריות JavaScript/TypeScript כמו LangGraph.js, אבל האקוסיסטם שלהן קטן יותר. לסוכנים שצריכים לרוץ ב-edge או ב-embedded, ניתן לבנות את הלוגיקה ב-Python ולתקשר עם קוד C++/Rust דרך API.

האם AI Agents יכולים להחליף מתכנתים?

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

מה הסיכונים העיקריים בהפעלת AI Agents בסביבת production?

שלושה סיכונים מרכזיים: prompt injection (הזרקת הוראות זדוניות דרך נתונים שהסוכן מעבד), עלויות בלתי צפויות (סוכן שנכנס ללולאה יכול לשרוף אלפי דולרים ב-API calls), ו-hallucinations שמובילות לפעולות שגויות. הפתרון: sandboxing, budget limits, human-in-the-loop לפעולות קריטיות, ובדיקות אוטומטיות על כל pipeline.

עולם ה-AI Agents זז מהר — ומי שבונה ידיים-על היום מקבל יתרון שקשה לסגור. המדריך הזה נתן לכם את הבסיס, אבל הדרך האמיתית ללמוד היא לבנות. קחו את הקוד, שנו את ה-prompts, שברו דברים ותקנו אותם. באתר Real Time College תמצאו מדריכים נוספים על בינה מלאכותית, למידת מכונה ופיתוח מערכות — כולם כתובים באותה גישה: פחות תיאוריה, יותר קוד שרץ. נתראה שם.

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