Agent Architecture & Design Patterns — ארכיטקטורת סוכנים ודפוסי עיצוב

לולאת ReAct — הדפוס המרכזי

כל סוכן AI בעולם — לא משנה באיזה SDK הוא בנוי, באיזה מודל הוא משתמש, או מה הוא עושה — פועל לפי אותו דפוס בסיסי. הדפוס הזה נקרא ReAct (קיצור של Reason + Act), ואם תבינו אותו לעומק, תבינו כל SDK שתפגשו בקורס הזה.

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

זה הכול. כל סוכן AI שתראו — מ-Claude Code ועד CrewAI עם 10 סוכנים — הוא וריאציה על הלולאה הזו. הבנתם אותה? הבנתם 80% מארכיטקטורת סוכנים.

Pseudocode של לולאת ReAct

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

function agent_loop(user_message, tools, max_iterations=10):
    messages = [system_prompt, user_message]

    for i in range(max_iterations):
        response = llm.call(messages)          // שלב Reason

        if response.has_tool_calls:
            for tool_call in response.tool_calls:
                result = execute_tool(tool_call) // שלב Act
                messages.append(result)          // שלב Observe
        else:
            return response.text                 // עצירה — התשובה מוכנה

    return "הגעתי למגבלת הסיבובים"              // Failsafe

ReAct בפועל — Python עם Streaming ו-Token Tracking

הנה גרסה מתקדמת יותר של לולאת ReAct, עם מעקב אחרי טוקנים ו-streaming — שני דברים קריטיים בפרודקשן:

# Python — ReAct Loop עם Token Tracking
import anthropic
import json
import time

client = anthropic.Anthropic()

def react_loop_with_tracking(
    user_msg: str,
    tools: list,
    tool_fns: dict,
    max_iterations: int = 10,
    max_tokens_budget: int = 50000,
    system_prompt: str = "You are a helpful assistant."
) -> dict:
    """
    ReAct loop מתקדם עם:
    - Token budget tracking (מונע חשבונות גבוהים)
    - Iteration logging (לדיבוג)
    - Timing per step (לזיהוי צווארי בקבוק)
    """
    messages = [{"role": "user", "content": user_msg}]
    total_tokens = 0
    steps_log = []

    for i in range(max_iterations):
        step_start = time.time()

        resp = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            system=system_prompt,
            tools=tools,
            messages=messages
        )

        # עדכון תקציב טוקנים
        step_tokens = resp.usage.input_tokens + resp.usage.output_tokens
        total_tokens += step_tokens
        step_time = time.time() - step_start

        steps_log.append({
            "step": i + 1,
            "tokens": step_tokens,
            "time_sec": round(step_time, 2),
            "stop_reason": resp.stop_reason
        })

        # בדיקת תקציב
        if total_tokens > max_tokens_budget:
            return {
                "result": "חרגתי מתקציב הטוקנים",
                "total_tokens": total_tokens,
                "steps": steps_log
            }

        # בדיקת tool calls
        tool_calls = [b for b in resp.content if b.type == "tool_use"]
        if not tool_calls:
            return {
                "result": "".join(
                    b.text for b in resp.content if b.type == "text"
                ),
                "total_tokens": total_tokens,
                "steps": steps_log
            }

        # ביצוע כלים
        messages.append({"role": "assistant", "content": resp.content})
        for tc in tool_calls:
            fn = tool_fns.get(tc.name)
            if fn:
                result = fn(**tc.input)
            else:
                result = f"Error: Unknown tool '{tc.name}'"
            messages.append({
                "role": "user",
                "content": [{
                    "type": "tool_result",
                    "tool_use_id": tc.id,
                    "content": str(result)
                }]
            })

    return {
        "result": "הגעתי למגבלת הסיבובים",
        "total_tokens": total_tokens,
        "steps": steps_log
    }

אותו הדבר ב-TypeScript — עם Streaming

// TypeScript — ReAct Loop עם Token Tracking ו-Streaming
import Anthropic from "@anthropic-ai/sdk";

interface StepLog {
  step: number;
  tokens: number;
  timeSec: number;
  stopReason: string;
}

interface AgentResult {
  result: string;
  totalTokens: number;
  steps: StepLog[];
}

async function reactLoopWithTracking(
  userMsg: string,
  tools: Anthropic.Tool[],
  toolFns: Record<string, (args: any) => Promise<string>>,
  maxIterations = 10,
  maxTokensBudget = 50000,
  systemPrompt = "You are a helpful assistant."
): Promise<AgentResult> {
  const client = new Anthropic();
  const messages: Anthropic.MessageParam[] = [
    { role: "user", content: userMsg }
  ];
  let totalTokens = 0;
  const stepsLog: StepLog[] = [];

  for (let i = 0; i < maxIterations; i++) {
    const stepStart = Date.now();

    const resp = await client.messages.create({
      model: "claude-sonnet-4-20250514",
      max_tokens: 1024,
      system: systemPrompt,
      tools,
      messages,
    });

    const stepTokens =
      resp.usage.input_tokens + resp.usage.output_tokens;
    totalTokens += stepTokens;

    stepsLog.push({
      step: i + 1,
      tokens: stepTokens,
      timeSec: Math.round((Date.now() - stepStart) / 100) / 10,
      stopReason: resp.stop_reason ?? "unknown",
    });

    // בדיקת תקציב
    if (totalTokens > maxTokensBudget) {
      return {
        result: "חרגתי מתקציב הטוקנים",
        totalTokens,
        steps: stepsLog,
      };
    }

    const toolCalls = resp.content.filter(
      (b) => b.type === "tool_use"
    );
    if (toolCalls.length === 0) {
      return {
        result: resp.content
          .filter((b) => b.type === "text")
          .map((b) => (b as Anthropic.TextBlock).text)
          .join(""),
        totalTokens,
        steps: stepsLog,
      };
    }

    messages.push({ role: "assistant", content: resp.content });
    for (const tc of toolCalls) {
      const block = tc as Anthropic.ToolUseBlock;
      const fn = toolFns[block.name];
      const result = fn
        ? await fn(block.input as any)
        : `Error: Unknown tool '${block.name}'`;
      messages.push({
        role: "user",
        content: [{
          type: "tool_result",
          tool_use_id: block.id,
          content: result,
        }],
      });
    }
  }

  return {
    result: "הגעתי למגבלת הסיבובים",
    totalTokens,
    steps: stepsLog,
  };
}

שימו לב: המודל הוא זה שמחליט מתי לעצור. כשהוא לא מבקש לקרוא לכלי (no tool calls), הלולאה נגמרת והתשובה הטקסטואלית חוזרת למשתמש. זה הדפוס שכל SDK מיישם — רק עם יותר אבטחה, Streaming, ו-Error Handling.

נקודה חשובה: כל SDK שנלמד בקורס — Claude Agent SDK, OpenAI Agents SDK, Vercel AI SDK, LangGraph, CrewAI, Google ADK — מסתיר את הלולאה הזו מאחורי API יפה. אבל כשמבינים את ה-Pseudocode למעלה, מבינים בדיוק מה כל SDK עושה מתחת לפני השטח. ב-LangGraph, למשל, הלולאה הזו מיוצגת כ-graph עם nodes ו-edges. ב-Vercel AI SDK, היא מיוצגת כ-generateText + tools + stopWhen. התוצאה זהה — רק ה-syntax שונה.

Chain of Thought — שרשרת חשיבה ווריאציות

Chain of Thought (CoT) היא טכניקה שבה המודל "חושב בקול רם" — פורט את תהליך החשיבה שלו צעד אחרי צעד לפני שהוא נותן תשובה סופית. זה לא טריק — זה מנגנון שמשפר דיוק באופן מדיד. מחקרים מראים שיפור של 20-40% בדיוק על משימות מורכבות כשמשתמשים ב-CoT.

למה זה עובד? כי בלי CoT, המודל "קופץ" ישר לתשובה. עם CoT, הוא מפרק את הבעיה ליחידות קטנות. ההבדל:

וריאציות של Chain of Thought

CoT הוא הבסיס, אבל יש כמה גרסאות שחשוב להכיר:

ארכיטקטורת Tool Calling — הידיים של הסוכן

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

האנטומיה של כלי (Tool)

כל כלי מורכב מ-5 חלקים:

איך המודל בוחר כלי?

זה עובד ככה: כשאתם שולחים הודעה לסוכן, אתם גם שולחים את רשימת הכלים הזמינים (עם השמות, התיאורים וה-Schemas). המודל קורא את כל זה ומחליט: "בהתחשב בבקשת המשתמש ובכלים שיש לי, הכלי הנכון הוא X עם הפרמטרים Y."

מה זה אומר בפועל? שתיאור הכלי (Description) הוא הדבר הכי חשוב שתכתבו. תיאור גרוע = הסוכן בוחר את הכלי הלא נכון = תוצאה גרועה. תיאור טוב = דיוק של 90%+.

Static Tools מול Dynamic Tools

יש שני סוגים של כלים:

• Static Tools (כלים סטטיים) — מוגדרים מראש בקוד. אתם יודעים בדיוק אילו כלים יש לסוכן לפני שהוא רץ. דוגמה: calculate, send_email, query_database.
• Dynamic Tools (כלים דינמיים) — נטענים בזמן ריצה, בדרך כלל ממשרת MCP. הסוכן מתחבר לשרת ומגלה אילו כלים זמינים. דוגמה: סוכן שמתחבר לשרת MCP של GitHub ומקבל כלים כמו create_issue, list_repos.

בפרק 3 נעמיק ב-MCP ובכלים דינמיים. כרגע, הדבר החשוב להבין: כלים סטטיים פשוטים יותר ומהירים יותר, כלים דינמיים גמישים יותר ו-reusable.

Tool Calling — Python Example

הנה איך מגדירים כלי ושולחים אותו ל-API של Anthropic (Claude). שימו לב — זה בלי SDK, רק API ישיר:

import anthropic

client = anthropic.Anthropic()

# הגדרת כלי
tools = [{
    "name": "get_weather",
    "description": "Get current weather for a city. Use when user asks "
                   "about weather, temperature, or if they need an umbrella. "
                   "Returns temperature in Celsius and conditions.",
    "input_schema": {
        "type": "object",
        "properties": {
            "city": {
                "type": "string",
                "description": "City name, e.g. 'Tel Aviv', 'Jerusalem'"
            }
        },
        "required": ["city"]
    }
}]

# שליחת בקשה עם כלים
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=tools,
    messages=[{"role": "user", "content": "מה מזג האוויר בתל אביב?"}]
)

# המודל מחליט לקרוא ל-get_weather
print(response.content)
# [ToolUse(type='tool_use', name='get_weather', input={'city': 'Tel Aviv'})]

Tool Calling — TypeScript Example

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

// הגדרת כלי
const tools = [{
  name: "get_weather",
  description: "Get current weather for a city. Use when user asks " +
               "about weather, temperature, or if they need an umbrella. " +
               "Returns temperature in Celsius and conditions.",
  input_schema: {
    type: "object" as const,
    properties: {
      city: {
        type: "string" as const,
        description: "City name, e.g. 'Tel Aviv', 'Jerusalem'"
      }
    },
    required: ["city"]
  }
}];

// שליחת בקשה עם כלים
const response = await client.messages.create({
  model: "claude-sonnet-4-20250514",
  max_tokens: 1024,
  tools,
  messages: [{ role: "user", content: "מה מזג האוויר בתל אביב?" }]
});

console.log(response.content);
// [{ type: 'tool_use', name: 'get_weather', input: { city: 'Tel Aviv' } }]

State Management — ניהול מצב

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

שלושה דפוסים של ניהול מצב

השוואה מעשית — מתי להשתמש באיזה דפוס

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

State Machine — דוגמה מעשית

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

מצבים אפשריים:
┌──────────────────────────────────────────────────────────┐
│                                                          │
│  [START] ──> [COLLECTING_INFO] ──> [CHECKING_POLICY]    │
│                                        │                 │
│                                   ┌────┴────┐            │
│                              [APPROVED]  [DENIED]        │
│                                   │         │            │
│                           [PROCESSING]  [EXPLAINING]     │
│                                   │         │            │
│                               [DONE]    [ESCALATE]       │
│                                                          │
└──────────────────────────────────────────────────────────┘

מעברים:
  START → COLLECTING_INFO:  כשמגיע בקשה חדשה
  COLLECTING_INFO → CHECKING_POLICY:  כשיש את כל הפרטים
  CHECKING_POLICY → APPROVED:  כשהבקשה עומדת במדיניות
  CHECKING_POLICY → DENIED:  כשהבקשה לא עומדת במדיניות
  APPROVED → PROCESSING:  אוטומטי
  DENIED → EXPLAINING:  מסביר למשתמש
  DENIED → ESCALATE:  אם המשתמש מבקש מנהל
  PROCESSING → DONE:  החזר בוצע

למה זה חשוב? כי ב-State Machine אתם שולטים במה הסוכן יכול לעשות בכל רגע. הוא לא יכול "לקפוץ" ממצב START ישר ל-PROCESSING — הוא חייב לעבור דרך כל השלבים. זה מה שהופך סוכנים ל-Production-ready.

SDKs כמו LangGraph בנויים סביב State Machines — כל ה-Architecture שלהם היא גרף של מצבים ומעברים. Google ADK מציע SequentialAgent, ParallelAgent, ו-LoopAgent שהם State Machines מוכנים. ב-OpenAI Agents SDK וב-Claude Agent SDK, הדפוס הוא יותר Implicit — אבל אפשר לבנות State Machine מעל.

Memory — זיכרון קצר-טווח, ארוך-טווח ואפיזודי

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

אפשר לחשוב על הזיכרון של סוכן בדיוק כמו הזיכרון של מחשב — בהיררכיה של מהירות, גודל, ועלות:

Short-term Memory — Context Window

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

הבעיה? Context Window מוגבל. Claude: 1M טוקנים (כ-750,000 מילים). GPT-5: 1M טוקנים. Gemini 2.5 Pro: 1M טוקנים. נשמע הרבה, אבל כשסוכן מבצע 50 קריאות כלים ומקבל תוצאות ארוכות — זה מתמלא מהר.

שלוש אסטרטגיות לניהול Context Window:

• Summarization (סיכום) — כל X הודעות, מסכמים את מה שהיה ומחליפים את ההודעות המקוריות בסיכום. חוסך טוקנים, מאבד פרטים
• Sliding Window (חלון נע) — שומרים רק את N ההודעות האחרונות. פשוט, אבל "שוכח" את ההתחלה
• Priority-based Eviction (פינוי לפי חשיבות) — מסמנים הודעות חשובות ומוחקים רק את הפחות חשובות. הכי מתוחכם, הכי מדויק

Episodic Memory — זיכרון אירועים

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

דוגמאות לזיכרון אפיזודי:

• "הלקוח ביקש שלא ישלחו לו הודעות אחרי 21:00" — נשמר ומשפיע על כל אינטראקציה עתידית
• "הפעם האחרונה שהסוכן ניסה להשתמש ב-API של Stripe, הוא קיבל Error 429 (Rate Limit)" — הסוכן לומד לחכות לפני ניסיון נוסף
• "הלקוח מעדיף תקשורת בעברית" — נשמר כהעדפה

Long-term Memory — Vector Store ומעבר

לזיכרון ארוך-טווח יש כמה פתרונות, מהפשוט למורכב:

דפוסים מעשיים לניהול זיכרון

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

דפוס 1: Summarization Buffer — סיכום אוטומטי

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

# Python — Summarization Buffer Pattern
def manage_context_with_summary(
    messages: list,
    model,
    max_messages: int = 20,
    summary_so_far: str = ""
) -> tuple[list, str]:
    """
    כשמספר ההודעות חורג מ-max_messages:
    1. מסכם את ההודעות הישנות
    2. שומר רק את ה-summary + הודעות אחרונות
    """
    if len(messages) <= max_messages:
        return messages, summary_so_far

    # ההודעות שנסכם (החצי הראשון)
    to_summarize = messages[:max_messages // 2]
    to_keep = messages[max_messages // 2:]

    # בניית prompt לסיכום
    summary_prompt = f"""Previous summary: {summary_so_far}

New messages to incorporate:
{format_messages(to_summarize)}

Write a concise summary of the full conversation so far.
Focus on: user preferences, decisions made, pending items."""

    new_summary = model.invoke(summary_prompt).content

    # מחזירים: הודעת summary + הודעות שנשארו
    summary_msg = {"role": "system",
                   "content": f"Conversation summary: {new_summary}"}
    return [summary_msg] + to_keep, new_summary

דפוס 2: User Profile Memory — זיכרון משתמש

// TypeScript — User Profile Pattern
interface UserProfile {
  userId: string;
  name?: string;
  language: "he" | "en" | "auto";
  preferences: Record<string, string>;
  recentTopics: string[];
  lastInteraction: string;
}

class UserMemory {
  private profiles: Map<string, UserProfile> = new Map();

  getSystemPromptAddition(userId: string): string {
    const profile = this.profiles.get(userId);
    if (!profile) return "";

    const parts: string[] = [];
    if (profile.name) parts.push(`User's name: ${profile.name}`);
    if (profile.language !== "auto")
      parts.push(`Preferred language: ${profile.language}`);
    if (Object.keys(profile.preferences).length > 0)
      parts.push(
        `Preferences: ${JSON.stringify(profile.preferences)}`
      );
    if (profile.recentTopics.length > 0)
      parts.push(
        `Recent topics: ${profile.recentTopics.slice(-3).join(", ")}`
      );

    return parts.length > 0
      ? `\n\nKnown user info:\n${parts.join("\n")}`
      : "";
  }

  updateFromConversation(
    userId: string,
    topic: string,
    extractedPrefs: Record<string, string>
  ) {
    const profile = this.profiles.get(userId) ?? {
      userId,
      language: "auto",
      preferences: {},
      recentTopics: [],
      lastInteraction: new Date().toISOString(),
    };
    profile.recentTopics.push(topic);
    if (profile.recentTopics.length > 10)
      profile.recentTopics.shift(); // Sliding window
    Object.assign(profile.preferences, extractedPrefs);
    profile.lastInteraction = new Date().toISOString();
    this.profiles.set(userId, profile);
  }
}

דפוס 3: Tool Result Cache — קאש תוצאות כלים

כשכלי מחזיר תוצאה זהה לאותם פרמטרים, אין טעם לקרוא לו שוב. Cache פשוט חוסך tokens, זמן, ועלויות API חיצוניים:

# Python — Tool Result Cache
import hashlib
import json
from datetime import datetime, timedelta

class ToolCache:
    def __init__(self, ttl_minutes: int = 30):
        self.cache = {}
        self.ttl = timedelta(minutes=ttl_minutes)

    def _key(self, tool_name: str, args: dict) -> str:
        raw = f"{tool_name}:{json.dumps(args, sort_keys=True)}"
        return hashlib.md5(raw.encode()).hexdigest()

    def get(self, tool_name: str, args: dict):
        key = self._key(tool_name, args)
        if key in self.cache:
            result, timestamp = self.cache[key]
            if datetime.now() - timestamp < self.ttl:
                return result  # Cache hit!
        return None  # Cache miss

    def set(self, tool_name: str, args: dict, result):
        key = self._key(tool_name, args)
        self.cache[key] = (result, datetime.now())

# שימוש בלולאת ReAct
cache = ToolCache(ttl_minutes=15)

def execute_tool_cached(tool_name, args, tool_fn):
    cached = cache.get(tool_name, args)
    if cached:
        print(f"  [Cache HIT] {tool_name}")
        return cached
    result = tool_fn(**args)
    cache.set(tool_name, args, result)
    print(f"  [Cache MISS] {tool_name} — called API")
    return result

Scratchpad Pattern — פנקס טיוטה

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

# Python — Scratchpad Pattern
scratchpad = []

for article in articles:
    summary = agent.summarize(article)
    scratchpad.append({
        "source": article.url,
        "key_points": summary,
        "relevance": agent.rate_relevance(summary, user_query)
    })

# הסוכן משתמש ב-scratchpad כ-input לכתיבת הדוח
final_report = agent.write_report(
    query=user_query,
    notes=scratchpad
)

Multi-Agent Architecture — דפוסי ריבוי סוכנים

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

ארבעת הדפוסים הגדולים

Pattern 1: Single Agent — סוכן יחיד

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

┌─────────────────────────────┐
│         USER                │
│   "בדוק סטטוס הזמנה 12345" │
└──────────┬──────────────────┘
           │
    ┌──────▼──────┐
    │  SINGLE     │
    │  AGENT      │──── [check_order] ──── [send_email]
    │  (LLM)      │──── [lookup_user] ──── [update_db]
    └──────┬──────┘
           │
    ┌──────▼──────────────────┐
    │  "ההזמנה שלך בדרך!     │
    │   צפי הגעה: מחר 14:00" │
    └─────────────────────────┘

Pattern 2: Router Agent — ניתוב

┌─────────────────────────────┐
│         USER                │
│   "יש לי בעיה עם החיוב"   │
└──────────┬──────────────────┘
           │
    ┌──────▼──────┐
    │  ROUTER     │ ← מודל זול (Haiku/Flash)
    │  AGENT      │   מנתח ומחליט לאן לנתב
    └──┬───┬───┬──┘
       │   │   │
  ┌────▼┐ ┌▼───┐ ┌▼────┐
  │BILL-│ │TECH│ │SALES│  ← סוכנים מתמחים
  │ING  │ │    │ │     │    (מודלים חזקים)
  └─────┘ └────┘ └─────┘

טיפ עלויות: ב-Router Pattern, הסוכן שמנתב (Router) לא צריך מודל חזק — הוא רק מחליט "זה billing או tech?". השתמשו במודל זול כמו Claude Haiku ($0.25/M input) או Gemini Flash ($0.30/M input) לניתוב, ובמודל חזק כמו Claude Sonnet או GPT-5 לסוכנים המתמחים. זה חוסך 80-90% בעלויות.

Pattern 3: Orchestrator-Worker

┌──────────────────────────────────┐
│  USER: "כתוב דוח מחקר שוק      │
│         על שוק ה-AI בישראל"     │
└───────────┬──────────────────────┘
            │
     ┌──────▼──────┐
     │ ORCHESTRATOR│ ← מתכנן, מחלק משימות, אוסף
     │   (מנהל)    │
     └──┬───┬───┬──┘
        │   │   │
   ┌────▼┐ ┌▼───┐ ┌▼─────┐
   │SEARCH│ │DATA│ │WRITE │ ← Workers
   │WORKER│ │    │ │      │    עובדים במקביל
   └──┬───┘ └─┬──┘ └──┬───┘
      │       │       │
   ┌──▼───────▼───────▼──┐
   │   ORCHESTRATOR       │ ← אוסף תוצאות, מרכיב
   │   אוסף ומרכיב       │
   └──────────┬───────────┘
              │
       ┌──────▼──────┐
       │  דוח מחקר   │
       │  מלא ומעוצב │
       └─────────────┘

Pattern 4: Collaborative — שיתופי

    ┌─────────┐     ┌──────────┐
    │ WRITER  │────▶│ EDITOR   │
    │ כותב    │◀────│ עורך     │
    └────┬────┘     └────┬─────┘
         │               │
         ▼               ▼
    ┌─────────────────────────┐
    │     SHARED STATE        │ ← מסמך משותף
    │  (מצב משותף לכל        │    שכולם רואים
    │   הסוכנים)              │    ועובדים עליו
    └─────────────────────────┘
         ▲               ▲
         │               │
    ┌────┴────┐     ┌────┴─────┐
    │RESEARCH │     │FACT-     │
    │חוקר     │     │CHECKER   │
    └─────────┘     └──────────┘

תקשורת בין סוכנים

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

Error Handling & Retry — טיפול בשגיאות

סוכני AI נכשלים. לא "אולי" — בוודאות. על משימות מורכבות, סוכנים נכשלים ב-10-30% מהמקרים. הבדל בין סוכן חובבני לסוכן Production הוא לא שהסוכן לא נכשל — אלא מה קורה כשהוא נכשל.

סוגי כשלונות

Retry Strategy — Python

import time
import random

def call_tool_with_retry(tool_fn, args, max_retries=3):
    """
    קורא לכלי עם Exponential Backoff.
    ניסיון 1: מיידי, ניסיון 2: 1-2 שניות, ניסיון 3: 2-4 שניות.
    """
    for attempt in range(max_retries):
        try:
            result = tool_fn(**args)
            return result
        except RateLimitError:
            wait = (2 ** attempt) + random.uniform(0, 1)
            print(f"Rate limited. Waiting {wait:.1f}s (attempt {attempt + 1})")
            time.sleep(wait)
        except ToolError as e:
            if attempt == max_retries - 1:
                return {"error": f"Tool failed after {max_retries} attempts: {e}"}
            time.sleep(1)

    return {"error": "Max retries exceeded"}

Retry Strategy — TypeScript

async function callToolWithRetry(
  toolFn: Function,
  args: Record<string, unknown>,
  maxRetries = 3
): Promise<unknown> {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await toolFn(args);
    } catch (error) {
      if (error instanceof RateLimitError) {
        const wait = 2 ** attempt + Math.random();
        console.log(`Rate limited. Waiting ${wait.toFixed(1)}s (attempt ${attempt + 1})`);
        await new Promise(r => setTimeout(r, wait * 1000));
      } else if (attempt === maxRetries - 1) {
        return { error: `Tool failed after ${maxRetries} attempts: ${error}` };
      } else {
        await new Promise(r => setTimeout(r, 1000));
      }
    }
  }
  return { error: "Max retries exceeded" };
}

Fallback Strategies

כשכלי נכשל אחרי כל הניסיונות, יש כמה אפשרויות:

• Alternative Tool — נסה כלי אחר שעושה משהו דומה. למשל: חיפוש ב-Google נכשל? נסה Bing
• Cached Result — השתמש בתוצאה ישנה מה-cache. לא אידיאלי, אבל טוב מכלום
• Graceful Degradation — תן תשובה חלקית. "מצאתי 3 מתוך 5 תוצאות, 2 מקורות לא זמינים כרגע"
• Human Escalation — העבר לאדם. "לא הצלחתי לטפל בבקשה — מעביר לנציג"

The Agent Stack — שכבות ההפשטה

כמו שבפיתוח Web יש את ה-"Tech Stack" (React + Node + PostgreSQL + AWS), גם לסוכני AI יש Stack משלהם. הבנת שבע השכבות תעזור לכם לבחור SDK, לתכנן ארכיטקטורה, ולהבין מה בדיוק כל SDK נותן ומה צריך לבנות בעצמכם.

Agent Development Lifecycle — מחזור חיי פיתוח

בניית סוכן AI זה לא "כתוב קוד, Deploy, תשכח." סוכנים הם מערכות שדורשות שיפור מתמיד — כי הם לא דטרמיניסטיים. אותה שאלה יכולה לתת תשובות שונות ביומים שונים. לכן יש מחזור חיים ייחודי לפיתוח סוכנים:

תרגילים מעשיים

import anthropic, json

client = anthropic.Anthropic()  # ANTHROPIC_API_KEY from env

tools = [{
    "name": "get_weather",
    "description": "Get weather for a city. Returns temp (C) and conditions.",
    "input_schema": {
        "type": "object",
        "properties": {"city": {"type": "string"}},
        "required": ["city"]
    }
}]

def get_weather(city: str) -> str:
    # בפרויקט אמיתי — קריאה ל-API. כאן: Mock
    data = {"Tel Aviv": "28°C, Sunny", "Jerusalem": "22°C, Partly Cloudy"}
    return data.get(city, f"No data for {city}")

def run_agent(user_msg: str, max_loops: int = 10) -> str:
    msgs = [{"role": "user", "content": user_msg}]

    for _ in range(max_loops):
        resp = client.messages.create(
            model="claude-sonnet-4-20250514", max_tokens=1024,
            system="You are a helpful weather assistant. Answer in Hebrew.",
            tools=tools, messages=msgs
        )

        # בודקים אם יש Tool Use
        tool_calls = [b for b in resp.content if b.type == "tool_use"]
        if not tool_calls:
            # אין קריאות כלים — התשובה מוכנה
            return "".join(b.text for b in resp.content if b.type == "text")

        # מוסיפים את תגובת המודל ומבצעים כלים
        msgs.append({"role": "assistant", "content": resp.content})
        for tc in tool_calls:
            result = get_weather(**tc.input)
            msgs.append({
                "role": "user",
                "content": [{"type": "tool_result", "tool_use_id": tc.id,
                             "content": result}]
            })

    return "הגעתי למגבלת הסיבובים"

# הרצה
print(run_agent("מה מזג האוויר בתל אביב ובירושלים?"))

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic(); // ANTHROPIC_API_KEY from env

const tools: Anthropic.Tool[] = [{
  name: "get_weather",
  description: "Get weather for a city. Returns temp (C) and conditions.",
  input_schema: {
    type: "object" as const,
    properties: { city: { type: "string" as const } },
    required: ["city"]
  }
}];

function getWeather(city: string): string {
  const data: Record<string, string> = {
    "Tel Aviv": "28°C, Sunny", "Jerusalem": "22°C, Partly Cloudy"
  };
  return data[city] ?? `No data for ${city}`;
}

async function runAgent(userMsg: string, maxLoops = 10): Promise<string> {
  const msgs: Anthropic.MessageParam[] = [{ role: "user", content: userMsg }];

  for (let i = 0; i < maxLoops; i++) {
    const resp = await client.messages.create({
      model: "claude-sonnet-4-20250514", max_tokens: 1024,
      system: "You are a helpful weather assistant. Answer in Hebrew.",
      tools, messages: msgs
    });

    const toolCalls = resp.content.filter(b => b.type === "tool_use");
    if (toolCalls.length === 0) {
      return resp.content
        .filter(b => b.type === "text")
        .map(b => (b as Anthropic.TextBlock).text)
        .join("");
    }

    msgs.push({ role: "assistant", content: resp.content });
    for (const tc of toolCalls) {
      const result = getWeather((tc as Anthropic.ToolUseBlock).input.city as string);
      msgs.push({
        role: "user",
        content: [{
          type: "tool_result", tool_use_id: (tc as Anthropic.ToolUseBlock).id,
          content: result
        }]
      });
    }
  }
  return "הגעתי למגבלת הסיבובים";
}

runAgent("מה מזג האוויר בתל אביב ובירושלים?").then(console.log);

import json
from pathlib import Path

MEMORY_FILE = Path("agent_memory.json")

def load_memory() -> dict:
    if MEMORY_FILE.exists():
        return json.loads(MEMORY_FILE.read_text())
    return {"preferences": {}, "history": []}

def save_memory(memory: dict):
    MEMORY_FILE.write_text(json.dumps(memory, ensure_ascii=False, indent=2))

def run_agent_with_memory(user_msg: str) -> str:
    memory = load_memory()

    # הוספת context מהזיכרון ל-System Prompt
    system = "You are a helpful assistant. Answer in Hebrew.\n"
    if memory["preferences"]:
        system += f"User preferences: {json.dumps(memory['preferences'])}\n"
    if memory["history"]:
        system += f"Recent interactions: {json.dumps(memory['history'][-5:])}\n"

    # הרצת הסוכן (כמו קודם, עם system מעודכן)
    result = run_agent_with_system(user_msg, system)

    # שמירת האינטראקציה בזיכרון
    memory["history"].append({
        "query": user_msg,
        "response": result[:200],  # שומרים רק 200 תווים ראשונים
        "timestamp": "2026-03-24"
    })
    save_memory(memory)

    return result

טעויות נפוצות — וידוי ארכיטקטורי

צ'קליסט — סיכום פרק 2

• הבנתי את לולאת ReAct ויכול/ה לצייר אותה מזיכרון (Input → Reason → Act → Observe → Stop)
• הבנתי מה Chain of Thought עושה ומתי להשתמש בכל וריאציה
• יודע/ת לכתוב Tool Definition עם שם, תיאור מפורט, ו-Input Schema
• מכיר/ה את 3 דפוסי ניהול המצב (Implicit, Explicit, State Machine) ומתי להשתמש בכל אחד
• מכיר/ה את ההיררכיה של זיכרון סוכנים: Working → Short-term → Episodic → Long-term
• מכיר/ה את 4 דפוסי Multi-Agent ויודע/ת לבחור את הנכון לכל מצב
• הבנתי את חשיבות Stop Conditions (max iterations, token budget, timeout, cost cap)
• בניתי סוכן מינימלי ב-20 שורות Python או TypeScript
• הוספתי Memory לסוכן המינימלי (קובץ JSON)
• כתבתי 4 הגדרות כלים לסוכן תמיכת לקוחות
• כתבתי 10 Test Cases והרצתי אותם על הסוכן
• מילאתי Agent Stack Template עם 7 שכבות לפרויקט שלי
• הבנתי למה "Deploy and Forget" לא עובד לסוכנים
• יודע/ת להסביר את ההבדל בין Router ל-Orchestrator-Worker
• מכיר/ה את 5 הטעויות הנפוצות ויודע/ת איך למנוע כל אחת