AI Agents
המדריך המלא בעברית

מה זה AI Agent?

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

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

הלב של כל Agent הוא לולאת ReAct (Reasoning + Acting): המודל חושב מה לעשות (Thought), מבצע פעולה (Action), רואה את התוצאה (Observation), ואז חושב שוב — עד שהמשימה הושלמה. הלולאה הזו היא שמבדילה Agent מ-LLM פשוט.

איך עובד Agent? — הרכיבים

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

1. LLM — המוח

המודל עצמו (GPT-4o, Claude Sonnet, Gemini Pro וכדומה) הוא מנוע ההחלטות. הוא קורא את ההקשר הנוכחי — מטרה, זיכרון, תוצאות כלים קודמים — ומחליט מה הפעולה הבאה. ה-LLM לא "יודע" להשתמש בכלים מעצמו; מי שמאפשר זאת הוא מנגנון Function Calling (או Tool Use) שמוסיף תיאורי כלים ל-System Prompt ומדרבן את המודל לתת פלט מובנה.

2. Tools — הידיים

ללא Tools, Agent הוא רק LLM. Tools הם הפונקציות שה-Agent יכול לקרוא להן: חיפוש אינטרנט, הרצת קוד Python, קריאה וכתיבה לקבצים, שליחת HTTP requests, שאילתות SQL, שליחת מיילים ועוד. כל Tool מוגדר עם שם, תיאור, ומה הפרמטרים שהוא מקבל — והמודל בוחר אוטומטית מתי ואיך לקרוא לו.

3. Memory — הזיכרון

Short-term memory היא היסטוריית השיחה (Conversation History) שנשמרת ב-Context Window. Long-term memory היא מידע שנשמר מחוץ ל-Context — בדרך כלל ב-Vector Store כמו Pinecone או Chroma — ומאוחזר לפי רלוונטיות כאשר נדרש. Agent שרוצה "לזכור" מידע בין שיחות שונות חייב להשתמש ב-Long-term memory.

4. Planning — התכנון

משימות מורכבות דורשות פירוק למשימות משנה. מנגנוני Planning כמו Task Decomposition מאפשרים ל-Agent לקחת יעד רחב ("כתוב ניתוח תחרותי על שוק הסייבר") ולפרק אותו לשלבים ניתנים לביצוע. Frameworks כמו LangGraph וCrewAI מוסיפים שכבת תכנון מובנית מעל ה-LLM.

סוגי Agents — מתי להשתמש בכל אחד

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

ReAct Agent הוא הסוג הגמיש ביותר ומתאים לרוב המקרים. הוא פועל בלולאת Thought-Action-Observation ומתאים כשהמשימה לא ידועה מראש. Tool Calling Agent מוגדר יותר — המודל בוחר מתוך רשימת Tools ידועה ומחזיר JSON מובנה. Plan-and-Execute מתאים כשיש עבודה שניתן לתכנן מראש: Agent אחד יוצר תוכנית, Agent נפרד מבצע כל שלב. Multi-Agent הוא ארכיטקטורה שבה כמה Agents עובדים יחד — כל אחד עם תפקיד מוגדר, Crew Manager מתאם ביניהם.

CrewAI — Framework ל-Multi-Agent Systems

CrewAI הוא ה-Framework הפופולרי ביותר לבניית מערכות Multi-Agent ב-Python. הרעיון הוא פשוט: מגדירים "צוות" (Crew) של Agents, כל אחד עם תפקיד ומטרה, ומגדירים משימות (Tasks). ה-Framework מנהל את התקשורת ביניהם.

התקנה

pip install crewai crewai-tools

ארבעת הרכיבים המרכזיים של CrewAI

• Agent: עובד בעל תפקיד, מטרה, וסיפור רקע (backstory) שמעצב את התנהגותו
• Task: משימה מוגדרת עם תיאור, פלט מצופה, וה-Agent האחראי עליה
• Crew: הצוות — מחבר Agents ו-Tasks, מנהל את סדר הביצוע
• Process: sequential (כל Agent ממתין לקודמו) או hierarchical (Manager מחלק עבודה)

דוגמה מלאה — Crew לכתיבת מאמר

הנה Crew של שלושה Agents שעובדים יחד לייצור מאמר מקצועי: Researcher שאוסף מידע, Writer שכותב, ו-Editor שמשפר.

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

# כלי חיפוש (מחייב SERPER_API_KEY)
search_tool = SerperDevTool()

# --- הגדרת Agents ---

researcher = Agent(
    role="Senior Research Analyst",
    goal="חפש מידע עדכני ומהימן על הנושא שניתן לך",
    backstory="""אתה אנליסט מחקר בכיר עם ניסיון של 10 שנים.
    אתה יודע למצוא מקורות אמינים ולסנן מידע רלוונטי.""",
    tools=[search_tool],
    verbose=True,
    llm="gpt-4o"
)

writer = Agent(
    role="Content Writer",
    goal="כתוב מאמר מעמיק, מושך ומדויק על בסיס המחקר",
    backstory="""אתה כותב תוכן מנוסה שמתמחה בהנגשת
    נושאים טכניים לקהל רחב. הסגנון שלך ברור ומשכנע.""",
    verbose=True,
    llm="gpt-4o"
)

editor = Agent(
    role="Chief Editor",
    goal="ערוך את המאמר, שפר את הזרימה והבהירות, תקן שגיאות",
    backstory="""אתה עורך ראשי עם עין חדה לפרטים.
    אתה מוודא שכל מאמר עומד בסטנדרטים הגבוהים ביותר.""",
    verbose=True,
    llm="gpt-4o"
)

# --- הגדרת Tasks ---

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

write_task = Task(
    description="כתוב מאמר של 800-1000 מילים על בסיס המחקר. כלול כותרת, מבוא, גוף, ומסקנה.",
    expected_output="מאמר מלא ומעוצב בפורמט Markdown",
    agent=writer,
    context=[research_task]  # מקבל את פלט research_task
)

edit_task = Task(
    description="ערוך את המאמר: שפר ניסוח, ודא עובדות, הוסף כותרות ביניים אם נחוץ.",
    expected_output="מאמר סופי מוכן לפרסום",
    agent=editor,
    context=[write_task]
)

# --- הרצת ה-Crew ---

crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, write_task, edit_task],
    process=Process.sequential,
    verbose=True
)

result = crew.kickoff(inputs={"topic": "השפעת AI Agents על שוק העבודה ב-2026"})
print(result)

LangGraph — Stateful Agents עם Graph Architecture

LangGraph הוא Library של LangChain שמאפשר לבנות Agents כ-Graph של State. בניגוד ל-CrewAI שמוכוון לצוותים, LangGraph מתאים לAgentic flows מורכבים שדורשים ניהול State, לולאות, ו-Human-in-the-Loop.

הרעיון הבסיסי: מגדירים StateGraph — גרף שכל צומת (Node) בו הוא פונקציה שמקבלת ומחזירה State. Edges הם המעברים בין הצמתים, וניתן להגדיר Conditional Edges שמחליטים על נתיב בהתאם לתוצאות.

דוגמת קוד — Chatbot עם Human-in-the-Loop

from langgraph.graph import StateGraph, END
from langgraph.prebuilt import ToolNode
from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from typing import TypedDict, Annotated
import operator

# הגדרת State
class AgentState(TypedDict):
    messages: Annotated[list, operator.add]
    human_approved: bool

# הגדרת Tool
@tool
def calculate(expression: str) -> str:
    """מחשב ביטוי מתמטי. קבל string של ביטוי Python."""
    try:
        return str(eval(expression))
    except Exception as e:
        return f"שגיאה: {e}"

tools = [calculate]
llm = ChatOpenAI(model="gpt-4o").bind_tools(tools)
tool_node = ToolNode(tools)

# פונקציות צמתים
def agent_node(state: AgentState):
    response = llm.invoke(state["messages"])
    return {"messages": [response]}

def human_review_node(state: AgentState):
    # נקודת עצירה — ממתין לאישור אנושי
    last_msg = state["messages"][-1]
    print(f"\n[Human Review] Agent רוצה: {last_msg.content}")
    approval = input("אשר? (y/n): ")
    return {"human_approved": approval.lower() == "y"}

# ניתוב מותנה
def should_continue(state: AgentState):
    last = state["messages"][-1]
    if hasattr(last, "tool_calls") and last.tool_calls:
        return "human_review"  # דורש אישור לפני שימוש בכלים
    return END

def after_review(state: AgentState):
    return "tools" if state["human_approved"] else END

# בניית הגרף
workflow = StateGraph(AgentState)
workflow.add_node("agent", agent_node)
workflow.add_node("human_review", human_review_node)
workflow.add_node("tools", tool_node)

workflow.set_entry_point("agent")
workflow.add_conditional_edges("agent", should_continue)
workflow.add_conditional_edges("human_review", after_review)
workflow.add_edge("tools", "agent")  # חזרה לagent אחרי Tool

app = workflow.compile()

# הרצה
result = app.invoke({
    "messages": [{"role": "user", "content": "כמה זה 847 * 293?"}],
    "human_approved": False
})

בנה Agent ראשון — 5 דקות עם OpenAI Function Calling

לפני שמשתמשים ב-Frameworks, חשוב להבין איך Agent עובד ברמה הבסיסית. הנה Agent מינימלי שבנוי ישירות על OpenAI API עם Function Calling — ללא Frameworks חיצוניים.

שלב 1 — התקנה

pip install openai
export OPENAI_API_KEY="your-key-here"

שלב 2 — הגדרת Tools והרצת Agent

from openai import OpenAI
import json
import math

client = OpenAI()

# --- הגדרת Tools ---
tools = [
    {
        "type": "function",
        "function": {
            "name": "web_search",
            "description": "מחפש מידע עדכני באינטרנט. השתמש כאשר צריך מידע שאינו בזיכרון.",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "שאילתת החיפוש"
                    }
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "מבצע חישוב מתמטי. מקבל ביטוי Python תקין.",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "ביטוי מתמטי, למשל: '2 ** 10' או 'math.sqrt(144)'"
                    }
                },
                "required": ["expression"]
            }
        }
    }
]

# --- מימוש Tools ---
def web_search(query: str) -> str:
    # בפרודקשיין: חבר ל-Serper, Tavily, או Brave Search API
    return f"[תוצאות חיפוש עבור '{query}']: מידע סימולטיבי לדוגמה"

def calculate(expression: str) -> str:
    try:
        result = eval(expression, {"math": math, "__builtins__": {}})
        return str(result)
    except Exception as e:
        return f"שגיאה בחישוב: {e}"

# --- לולאת ה-Agent ---
def run_agent(user_message: str, max_steps: int = 10) -> str:
    messages = [
        {
            "role": "system",
            "content": "אתה עוזר AI מועיל שיכול לחפש מידע ולבצע חישובים. "
                       "השתמש בכלים כאשר נדרש. ענה תמיד בעברית."
        },
        {"role": "user", "content": user_message}
    ]

    for step in range(max_steps):
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            tools=tools,
            tool_choice="auto"
        )

        message = response.choices[0].message
        messages.append(message)

        # אם אין Tool Calls — הAgent סיים
        if not message.tool_calls:
            return message.content

        # ביצוע כל Tool Call
        for tool_call in message.tool_calls:
            func_name = tool_call.function.name
            func_args = json.loads(tool_call.function.arguments)

            print(f"[Agent] קורא ל: {func_name}({func_args})")

            if func_name == "web_search":
                result = web_search(**func_args)
            elif func_name == "calculate":
                result = calculate(**func_args)
            else:
                result = f"כלי לא מוכר: {func_name}"

            # הוספת תוצאת ה-Tool לשיחה
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": result
            })

    return "הAgent לא הצליח להשלים את המשימה במספר הצעדים המותר"

# --- הרצת דוגמאות ---
print(run_agent("מהו השורש הריבועי של 2025?"))
print(run_agent("חפש מידע על ChatGPT-5 ותסכם בנקודות"))

5 מקרי שימוש אמיתיים ל-AI Agents

התיאוריה ברורה — אבל איפה Agents משנים חיים בפועל? הנה חמישה Use Cases אמיתיים שניתן לממש היום עם הכלים שתיארנו.

1. Research Agent — מחקר שוק אוטומטי

הבעיה: ניתוח תחרות שוק לוקח ימים של עבודה ידנית. הפתרון: Agent שמקבל שם תחום, מחפש מידע על מתחרים, אוסף נתוני מחירים ותכונות, ומייצר דוח השוואתי. עם CrewAI: Researcher מוצא מתחרים, Analyst מנתח נתונים, Writer כותב דוח — כל הצוות רץ אוטומטית.

זמן מימוש: 2-3 שעות. חיסכון: 8-16 שעות עבודה ידנית לדוח אחד.

2. Code Review Agent — בדיקת קוד ב-GitHub

הבעיה: Code Reviews לוקחים זמן ומשאירים bugs. הפתרון: Agent שמקבל GitHub Pull Request webhook, קורא את ה-diff, מריץ ניתוח סטטי, בודק Security vulnerabilities, ומוסיף Comments מפורטים ישירות ל-PR. משתמש ב-GitHub API כ-Tool, ו-Claude Sonnet כ-LLM למיקוד בבעיות לוגיות.

זמן מימוש: 4-6 שעות. תועלת: מוצא כ-70% מהבעיות הנפוצות לפני Human Review.

3. Customer Support Agent — מענה אוטומטי לטיקטים

הבעיה: Support חוזר ונשנה גוזל זמן הנדסי. הפתרון: Agent שמחובר ל-Zendesk/Intercom, קורא כל טיקט חדש, מחפש בבסיס הידע (RAG על Documentation), וכותב תשובה מותאמת. אם הבעיה מורכבת — מסמן "human_needed" ומעביר לנציג עם סיכום.

זמן מימוש: 1 יום. תועלת: פותר 60-80% מהטיקטים אוטומטית.

4. Content Agent — יצירת תוכן מ-Brief

הבעיה: יצירת תוכן שיווקי איכותי ועקבי לוקח הרבה זמן. הפתרון: Crew של Agents: SEO Researcher (מחפש keywords), Content Strategist (מגדיר מבנה), Writer (כותב), ו-Social Media Specialist (מתאים לכל פלטפורמה). קלט: Brief קצר של 2-3 שורות. פלט: מאמר, 3 פוסטים LinkedIn, 5 Tweets.

זמן מימוש: 3-4 שעות. חיסכון: 3-4 שעות עבודה ידנית לכל Brief.

5. Data Analysis Agent — ניתוח CSV ויצירת Insights

הבעיה: נתונים גולמיים ב-CSV דורשים ניתוח שלוקח זמן ודורש מומחיות. הפתרון: Agent שמקבל CSV, כותב ומריץ קוד Python (Pandas, Matplotlib), מייצר גרפים, ומחזיר דוח בלשון טבעית עם Insights ו-Recommendations. משתמש ב-Code Interpreter Tool או בסביבת Python מבודדת.

זמן מימוש: 2-3 שעות. תועלת: מנגיש ניתוח נתונים לאנשים שאינם Data Scientists.

לולאת ReAct — קוד מלא מאפס

לפני שמשתמשים ב-Framework כמו CrewAI או LangGraph, חשוב להבין איך לבנות ReAct Agent מאפס. זה ייתן הבנה עמוקה שתעזור לאבחן בעיות בהמשך.

ReAct Agent עם LangChain

from langchain.agents import AgentExecutor, create_react_agent
from langchain_anthropic import ChatAnthropic
from langchain.tools import tool
from langchain_core.prompts import PromptTemplate

@tool
def search_web(query: str) -> str:
    """חפש מידע עדכני באינטרנט. קבל שאילתת חיפוש בעברית."""
    # בפרודקשיין: חבר ל-Tavily / Serper API
    return f"תוצאות חיפוש עבור: {query} — [תוצאות מדומות לדוגמה]"

@tool
def calculate(expression: str) -> str:
    """חשב ביטוי מתמטי. קבל ביטוי Python תקין."""
    try:
        return str(eval(expression, {"__builtins__": {}}))
    except Exception as e:
        return f"שגיאה: {e}"

@tool
def read_file(filename: str) -> str:
    """קרא תוכן מקובץ טקסט מקומי."""
    try:
        with open(filename, 'r', encoding='utf-8') as f:
            return f.read()
    except Exception as e:
        return f"שגיאה בקריאת קובץ: {e}"

# הגדרת ה-LLM
llm = ChatAnthropic(model="claude-3-5-sonnet-20241022", temperature=0)
tools = [search_web, calculate, read_file]

# ReAct Prompt Template
react_prompt = PromptTemplate.from_template("""
אתה Agent AI מועיל שעונה בעברית. פעל לפי ReAct Loop:
Thought → Action → Observation → ... → Final Answer

יש לך גישה לכלים הבאים:
{tools}

שמות הכלים: {tool_names}

שאלה: {input}
{agent_scratchpad}
""")

# יצירת ה-Agent
agent = create_react_agent(llm, tools, react_prompt)
executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,
    max_iterations=10,
    handle_parsing_errors=True
)

# הרצה
result = executor.invoke({"input": "כמה זה 17 * 23? ואיך נקרא המספר שמתחלק רק ב-1 ובעצמו?"})
print(result["output"])

play_circle

AI Agents with LangChain & CrewAI — Full Tutorial

YouTube • חפש סרטוני הסבר

open_in_new

LangGraph — State Machine Agents

LangGraph הוא Library שמוסיפה State Management מלא ל-LangChain Agents. במקום לולאת ReAct פשוטה, LangGraph מאפשר בניית Agents מורכבים עם מצבים, Conditional Routing ו-Human-in-the-Loop.

מתי LangGraph עדיף על ReAct רגיל?

• כשה-Agent צריך לזכור State בין צעדים שונים
• כשיש Branching — "אם X, עבור לשלב A; אחרת לשלב B"
• כשרוצים Human-in-the-Loop — עצירה לאישור פעולה לפני ביצוע
• כשמבנה ה-Agent מורכב מכמה "תפקידים" (Planner, Executor, Critic)

Graph Agent בסיסי — Research + Write

from langgraph.graph import StateGraph, END
from langchain_anthropic import ChatAnthropic
from typing import TypedDict, List

# הגדרת State — המידע שעובר בין ה-Nodes
class AgentState(TypedDict):
    topic: str
    research: str
    draft: str
    feedback: str
    final_article: str

llm = ChatAnthropic(model="claude-3-5-sonnet-20241022")

# Node 1: מחקר
def research_node(state: AgentState) -> AgentState:
    prompt = f"חקור את הנושא: {state['topic']}. ספק 5 עובדות מרכזיות."
    result = llm.invoke(prompt)
    return {"research": result.content}

# Node 2: כתיבה
def write_node(state: AgentState) -> AgentState:
    prompt = f"""כתוב מאמר בעברית על: {state['topic']}
    בסיס על המחקר הבא: {state['research']}
    המאמר צריך להיות 300-500 מילה."""
    result = llm.invoke(prompt)
    return {"draft": result.content}

# Node 3: ביקורת ושיפור
def review_node(state: AgentState) -> AgentState:
    prompt = f"""בדוק את הטיוטה הבאה ושפר אותה:
    {state['draft']}

    הפלט: הטיוטה המשופרת בלבד."""
    result = llm.invoke(prompt)
    return {"final_article": result.content}

# בניית ה-Graph
workflow = StateGraph(AgentState)
workflow.add_node("research", research_node)
workflow.add_node("write", write_node)
workflow.add_node("review", review_node)

# Edges — הגדרת זרימה
workflow.set_entry_point("research")
workflow.add_edge("research", "write")
workflow.add_edge("write", "review")
workflow.add_edge("review", END)

# Compile והרצה
app = workflow.compile()
result = app.invoke({"topic": "בינה מלאכותית ורפואה בישראל"})
print(result["final_article"])

Memory — זיכרון ל-Agents

Agent ללא זיכרון "שוכח" הכל בין שיחות. Memory הוא הרכיב שמאפשר לו לזכור הקשר, העדפות, ומידע ארגוני לאורך זמן.

Short-term Memory — Conversation History

ה-Context Window של ה-LLM הוא הזיכרון לטווח קצר — כל מה שהיה בשיחה הנוכחית. LangChain מנהל זאת אוטומטית ב-ConversationBufferMemory. בעיה: Context Windows מוגבלים (גם GPT-4 Turbo מוגבל ל-128K). לשיחות ארוכות — השתמש ב-ConversationSummaryMemory שמסכם אוטומטית שיחות ישנות.

from langchain.memory import ConversationSummaryBufferMemory
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_react_agent

llm = ChatOpenAI(model="gpt-4o")

# זיכרון שמסכם שיחות ישנות אוטומטית (שומר עד 500 tokens בזיכרון חי)
memory = ConversationSummaryBufferMemory(
    llm=llm,
    max_token_limit=500,
    memory_key="chat_history",
    return_messages=True
)

# שילוב עם Agent
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    memory=memory,
    verbose=True
)

# Agent זוכר הכל מהשיחה — אפילו אחרי 50+ מסרים
r1 = agent_executor.invoke({"input": "שמי אלון ואני עובד ב-Startup של AI"})
r2 = agent_executor.invoke({"input": "מה שמי ואיפה אני עובד?"})
# r2 יענה "שמך אלון ואתה עובד ב-Startup של AI"

Long-term Memory — Vector Store

לזיכרון שנשמר בין Sessions שונים, משתמשים ב-Vector Store. כל מידע חשוב מאוחסן כ-Embedding, ונשלף לפי רלוונטיות כאשר נדרש.

from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings
from langchain.memory import VectorStoreRetrieverMemory

# יצירת Vector Store לזיכרון
embeddings = OpenAIEmbeddings()
vectorstore = Chroma(
    collection_name="agent_memory",
    embedding_function=embeddings,
    persist_directory="./agent_memory_db"  # שמירה לדיסק!
)

retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

# זיכרון שמחפש את 3 הזיכרונות הרלוונטיים ביותר
memory = VectorStoreRetrieverMemory(retriever=retriever)

# שמירת זיכרון
memory.save_context(
    {"input": "אלון מנהל Startup של AI בתל אביב"},
    {"output": "שמרתי: אלון → AI Startup → תל אביב"}
)

# שליפה לפי רלוונטיות — אפילו אחרי ריסטרט של התוכנה!
relevant = memory.load_memory_variables({"prompt": "ספר לי על אלון"})

פרודקשיין — Error Handling ועלויות

Agent שעובד ב-Demo לא תמיד עובד ב-Production. הנה הפרקטיקות החשובות ביותר להפיכת Agent לכלי אמין.

Error Handling ו-Retry Logic

import time
from tenacity import retry, stop_after_attempt, wait_exponential

@retry(
    stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=4, max=10)
)
def safe_llm_call(prompt: str) -> str:
    """קריאה בטוחה ל-LLM עם retry אוטומטי"""
    try:
        response = llm.invoke(prompt)
        return response.content
    except RateLimitError:
        print("Rate Limit — ממתין ומנסה שוב...")
        raise  # tenacity יטפל ב-retry
    except APIError as e:
        print(f"API Error: {e}")
        raise

# Tool עם validation
@tool
def safe_calculate(expression: str) -> str:
    """מחשבון בטוח עם Sandboxing"""
    ALLOWED = set('0123456789+-*/.(). ')
    if not all(c in ALLOWED for c in expression):
        return "שגיאה: ביטוי מכיל תווים לא מורשים"
    if len(expression) > 100:
        return "שגיאה: ביטוי ארוך מדי"
    try:
        result = eval(expression)
        if not isinstance(result, (int, float)):
            return "שגיאה: תוצאה לא תקינה"
        return str(round(result, 6))
    except Exception as e:
        return f"שגיאת חישוב: {e}"

מעקב עלויות ו-Token Usage

גיליון עזר — Framework Comparison

5 נקודות הפתחה מהירה

סיכום — טיפים ושיטות עבודה מומלצות

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

• התחל פשוט: בנה ReAct Agent בסיסי לפני שמשתמשים ב-Framework. ההבנה של הרמה הנמוכה תעזור לאבחן בעיות מאוחר יותר.
• הגבל את מספר הצעדים: תמיד הגדר max_steps או max_iterations. Agent ללא גבול יכול לרוץ בלולאה אינסופית ולבזבז API calls.
• כתוב System Prompts מדויקים: ה-Agent הוא כמו עובד חדש — ככל שהתפקיד מוסבר יותר טוב, כך ביצועיו טובים יותר. כלול מה לעשות ומה לא לעשות.
• הוסף Human-in-the-Loop לפעולות קריטיות: שליחת מיילים, מחיקת נתונים, פרסום תוכן — כל פעולה בלתי הפיכה צריכה אישור אנושי. LangGraph עושה זאת בקלות.
• Logging ו-Observability: השתמש ב-LangSmith, Weights & Biases, או Langfuse כדי לעקוב אחרי כל Trace של ה-Agent. בלי Observability, אי אפשר לשפר.
• בדוק כל Tool בנפרד: לפני שמחברים Tool ל-Agent, ודא שהוא עובד כצפוי עם Unit Tests. Tool שבור יוביל ל-Agent שבור.
• עלות ומעקב: Agents יכולים לצרוך הרבה Tokens. עקוב אחרי העלות בכל שלב, והגדר Budget limits ב-OpenAI / Anthropic.

קישורים שימושיים

• CrewAI Documentation: docs.crewai.com — מדריכים, Examples, וReference מלא
• LangGraph Documentation: langchain-ai.github.io/langgraph — Tutorials ו-How-to guides
• OpenAI Function Calling Guide: platform.openai.com/docs/guides/function-calling
• Tavily AI Search API: tavily.com — Search API בחינם לAgents (1,000 req/חודש)
• LangSmith: smith.langchain.com — Observability ו-Tracing לAgents
• AutoGen (Microsoft): github.com/microsoft/autogen — Framework נוסף ל-Multi-Agent