מדריך Claude AI המלא
Tool Use, System Prompts, API ו-Extended Thinking

מה זה Claude?

Claude הוא מודל שפה גדול (LLM) מבית Anthropic — חברת AI שנוסדה ב-2021 על ידי לשעבר עובדי OpenAI, בראשות Dario Amodei ו-Daniela Amodei. ה-DNA של Anthropic הוא AI Safety — פיתוח מודלים בטוחים, יושרניים ושקופים יותר.

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

הגרסאות הנוכחיות (אפריל 2026)

מה מייחד את Claude?

• Context Window של 200K טוקן — בערך 150,000 מילים. מספיק לספר שלם, קוד-בייס גדול, או שיחה ארוכה מאוד
• Constitutional AI — Claude עוצב לענות באופן כן, להודות בטעויות, ולסרב לבקשות מזיקות בצורה מנומסת ומוסברת
• Artifacts — יצירת קבצי קוד, SVG, React components, HTML ישירות מהצ'אט עם Preview
• יושר אנליטי — Claude פחות נוטה ל"הסכמה מרצון" (sycophancy) מאשר מודלים מתחרים
• Extended Thinking — מצב של חשיבה עמוקה לבעיות מורכבות (ב-Claude Sonnet 4.6)

השוואה מהירה: Claude vs ChatGPT vs Gemini

מפת דרכים לשליטה ב-Claude

להלן מסלול למידה מובנה — מ-Zero ועד בניית סוכנים מתקדמים עם Claude API. כל שלב בנוי על הקודם.

System Prompts ב-Claude — עומק ומעשה

System Prompt הוא ההוראה שנשלחת ל-Claude לפני כל שיחה עם המשתמש. זה המקום בו אתה מגדיר מי הוא, מה הוא יודע, ומה הגבולות שלו.

מה מייחד System Prompts בקלוד?

Claude "לוקח ברצינות" את ה-System Prompt יותר ממודלים מתחרים. הוא לא ינסה לעקוף אותו, ו-Constitutional AI מבטיח שהוא יפעל לפי ערכים מובנים גם כשמנסים לשכנע אותו אחרת.

Best Practices לSystem Prompt

• תפקיד ברור — "אתה מומחה ל-X" עובד טוב יותר מהוראות כלליות
• XML Tags — Claude מגיב מצוין ל-tags כמו <context>, <instructions>, <examples>
• פורמט תשובות — ציין אם אתה רוצה Markdown, JSON, רשימות קצרות
• גבולות שליליים — "אל תענה על X" עובד טוב ב-Claude, בניגוד לחלק מהמודלים
• דוגמאות — Few-shot examples ב-System Prompt משפרים עקביות דרמטית

Template מלא לסוכן Claude

אתה [תפקיד] המסייע ל[ארגון/משתמש].

<context>
[רקע על החברה, המוצר, או המשתמש]
</context>

<capabilities>
כישורים:
- [כישור 1]
- [כישור 2]
- [כישור 3]
</capabilities>

<constraints>
הגבלות:
- אל תענה על שאלות שאינן קשורות ל[נושא]
- תמיד [כלל חשוב]
- אם אינך יודע, אמור "אני לא יודע" ואל תבדה
</constraints>

<format>
פורמט תשובות:
השתמש ב-Markdown. היה תמציתי אך מלא.
תמיד סיים עם: "האם יש משהו נוסף שאתה רוצה לדעת?"
</format>

Tool Use / Function Calling — מעמיק

Tool Use (המכונה גם Function Calling) הוא היכולת של Claude לקרוא לפונקציות חיצוניות שאתה מגדיר. במקום לענות מידע מהזיכרון, Claude יכול לשאול מסד נתונים, לקרוא API, לשלוח מייל, או לבצע כל פעולה שתכתוב לו.

מחזור חיים של Tool Use

קוד Python מלא — Tool Use

import anthropic

client = anthropic.Anthropic(api_key="sk-ant-...")

# הגדרת כלים
tools = [
  {
    "name": "get_weather",
    "description": "מחזיר מזג אוויר עדכני לעיר מסוימת",
    "input_schema": {
      "type": "object",
      "properties": {
        "city": {
          "type": "string",
          "description": "שם העיר באנגלית, למשל: Tel Aviv"
        },
        "unit": {
          "type": "string",
          "enum": ["celsius", "fahrenheit"],
          "description": "יחידת טמפרטורה"
        }
      },
      "required": ["city"]
    }
  }
]

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

# בדיקה אם Claude ביקש כלי
if response.stop_reason == "tool_use":
  tool_use = next(
    b for b in response.content if b.type == "tool_use"
  )

  print(f"Claude ביקש: {tool_use.name}")
  print(f"פרמטרים: {tool_use.input}")

  # הרצת הפונקציה שלנו
  tool_result = get_weather(
    tool_use.input["city"],
    tool_use.input.get("unit", "celsius")
  )

  # שליחת התוצאה בחזרה ל-Claude
  final_response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    tools=tools,
    messages=[
      {"role": "user", "content": "מה מזג האוויר בתל אביב היום?"},
      {"role": "assistant", "content": response.content},
      {
        "role": "user",
        "content": [{
          "type": "tool_result",
          "tool_use_id": tool_use.id,
          "content": str(tool_result)
        }]
      }
    ]
  )

  print(final_response.content[0].text)

Multi-turn Tool Use

ב-Multi-turn Tool Use, Claude יכול לקרוא לכמה כלים ברצף. למשל: "תמצא את כל ה-leads שלא הגיבו השבוע, שלח להם מייל follow-up, ועדכן את ה-CRM". Claude ינהל את הרצף בעצמו.

Extended Thinking — חשיבה עמוקה

Extended Thinking הוא מצב מיוחד ב-Claude Sonnet 4.6 שמאפשר למודל "לחשוב בקול" לפני שהוא עונה. בדומה ל-Chain of Thought, אך ב-scale גדול יותר — עם תקציב טוקנים ייעודי לחשיבה.

מה ההבדל מ-Chain of Thought רגיל?

• תקציב מוגדר — אתה שולט כמה "זמן חשיבה" Claude מקבל (budget_tokens)
• חשיבה פנימית — ה-thinking blocks לא נשלחים למשתמש (אפשרי לקרוא אותם ב-debug)
• תוצאות טובות בהרבה — בבעיות מתמטיקה, קוד ולוגיקה מורכבת
• עלות גבוהה יותר — כל טוקן חשיבה עולה כסף, תכנן בהתאם

מתי להשתמש ב-Extended Thinking?

• בעיות מתמטיקה ואלגוריתמים מורכבים
• debug של קוד עם bugs עמוקים
• ניתוח legal / אסטרטגי עם trade-offs מורכבים
• שאלות מדעיות שדורשות הסקה רב-שלבית

קוד — הפעלת Extended Thinking

import anthropic

client = anthropic.Anthropic(api_key="sk-ant-...")

response = client.messages.create(
  model="claude-sonnet-4-6",
  max_tokens=16000,
  thinking={
    "type": "enabled",
    "budget_tokens": 10000  # תקציב הטוקנים לחשיבה
  },
  messages=[{
    "role": "user",
    "content": """
    יש לי מערכת של 3 שרתים. שרת A עומד 40% מהזמן,
    שרת B עומד 70% מהזמן, שרת C עומד 20% מהזמן.
    מה הסיכוי שלפחות שני שרתים פועלים בו-זמנית?
    הסבר את הפתרון שלב אחר שלב.
    """
  }]
)

# איטרציה על blocks (יש thinking block + text block)
for block in response.content:
  if block.type == "thinking":
    print("--- תהליך חשיבה פנימי ---")
    print(block.thinking[:500], "...")  # הדפסת חלק
  elif block.type == "text":
    print("--- תשובה סופית ---")
    print(block.text)

Artifacts, Computer Use ו-Vision

Artifacts — יצירה ישירה מהצ'אט

Artifacts הוא פיצ'ר ייחודי ל-Claude.ai שמאפשר יצירת קבצים עם Preview בזמן אמת. כשאתה מבקש מ-Claude לכתוב קוד, הוא פותח Panel נפרד עם עורך + תצוגה מקדימה.

• HTML/CSS/JS — אתרים ואפליקציות שרצות ישירות בדפדפן
• React Components — components אינטראקטיביים עם state
• SVG — גרפיקה וקטורית, דיאגרמות, לוגואים
• Markdown — תוכן מפורמט לניהול
• Code Files — Python, TypeScript, SQL ועוד

Computer Use — Claude שולט במחשב

Computer Use הוא capability ניסיוני שמאפשר ל-Claude לקבל screenshots של מסך ולבצע פעולות — לחיצות עכבר, הקלדה, גלילה. הוא רואה את המסך ומגיב לו.

• מילוי טפסים אוטומטי ללא API
• ניווט באתרים מורכבים
• בדיקות UI אוטומטיות (E2E testing)
• אוטומציה של תהליכים עסקיים שאין להם API

Vision API — ניתוח תמונות ומסמכים

import anthropic
import base64

client = anthropic.Anthropic(api_key="sk-ant-...")

# קריאת תמונה
with open("screenshot.png", "rb") as f:
  image_data = base64.standard_b64encode(f.read()).decode("utf-8")

response = client.messages.create(
  model="claude-sonnet-4-6",
  max_tokens=1024,
  messages=[{
    "role": "user",
    "content": [
      {
        "type": "image",
        "source": {
          "type": "base64",
          "media_type": "image/png",
          "data": image_data,
        },
      },
      {
        "type": "text",
        "text": "מה יש בתמונה? תתאר כל פרט."
      }
    ],
  }]
)

print(response.content[0].text)

Claude API — המדריך הטכני

התקנה ו-Authentication

# Python
pip install anthropic

# TypeScript / Node.js
npm install @anthropic-ai/sdk

# Environment variable (מומלץ — לא בקוד!)
export ANTHROPIC_API_KEY="sk-ant-api03-..."

Messages API — כל הפרמטרים

import anthropic

client = anthropic.Anthropic()  # לוקח מ-ANTHROPIC_API_KEY

message = client.messages.create(
  model="claude-sonnet-4-6",  # מודל
  max_tokens=1024,                      # מקסימום טוקנים בתשובה
  system="אתה עוזר מועיל בעברית.",    # System Prompt
  messages=[
    {
      "role": "user",
      "content": "מה ההבדל בין ML ל-AI?"
    }
  ]
)

print(message.content[0].text)
print(f"Input tokens: {message.usage.input_tokens}")
print(f"Output tokens: {message.usage.output_tokens}")

Streaming — תשובות בזמן אמת

import anthropic

client = anthropic.Anthropic()

# Streaming
with client.messages.stream(
  model="claude-sonnet-4-6",
  max_tokens=1024,
  messages=[{"role": "user", "content": "כתוב סיפור קצר"}]
) as stream:
  for text in stream.text_stream:
    print(text, end="", flush=True)

TypeScript SDK

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

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

const message = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 1024,
  system: "אתה עוזר מועיל.",
  messages: [
    { role: "user", content: "שלום קלוד!" }
  ],
});

console.log(message.content[0].text);

טבלת תמחור — אפריל 2026

5 פרויקטים מעשיים עם Claude

להלן 5 פרויקטים מדורגים לפי רמת קושי — מ-Hello World ועד Multi-Agent System מלא.

import anthropic, base64, json

client = anthropic.Anthropic()

def analyze_document(pdf_path: str) -> dict:
    with open(pdf_path, "rb") as f:
        pdf_data = base64.standard_b64encode(f.read()).decode()

    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=2048,
        system="""אתה מנתח מסמכים מקצועי.
חלץ מהמסמך ומחזיר JSON עם השדות:
- summary: סיכום קצר (2-3 משפטים)
- key_dates: מערך תאריכים חשובים
- action_items: מערך פריטי פעולה
- parties: שמות הצדדים המעורבים""",
        messages=[{
            "role": "user",
            "content": [
                {
                    "type": "document",
                    "source": {
                        "type": "base64",
                        "media_type": "application/pdf",
                        "data": pdf_data
                    }
                },
                {"type": "text", "text": "נתח את המסמך הזה"}
            ]
        }]
    )

    return json.loads(response.content[0].text)

result = analyze_document("contract.pdf")
print(result)

import anthropic

client = anthropic.Anthropic()

REVIEWER_SYSTEM = """אתה מהנדס בכיר המבצע Code Review.
לכל בעיה שאתה מוצא, ספק:
1. תיאור הבעיה
2. רמת חומרה: CRITICAL / MAJOR / MINOR
3. דוגמת קוד מתוקן

בדוק: ביצועים, אבטחה, קריאות, Best Practices."""

def review_code(code: str, language: str = "python") -> str:
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=3000,
        system=REVIEWER_SYSTEM,
        messages=[{
            "role": "user",
            "content": f"בצע Code Review על הקוד הבא ({language}):\n\n```{language}\n{code}\n```"
        }]
    )
    return response.content[0].text

with open("my_code.py") as f:
    code = f.read()

review = review_code(code)
print(review)

crm_tools = [
  {
    "name": "get_customer_info",
    "description": "מושך פרטי לקוח לפי מספר ID",
    "input_schema": {
      "type": "object",
      "properties": {
        "customer_id": {"type": "string"}
      },
      "required": ["customer_id"]
    }
  },
  {
    "name": "create_ticket",
    "description": "פותח ticket תמיכה חדש",
    "input_schema": {
      "type": "object",
      "properties": {
        "customer_id": {"type": "string"},
        "subject": {"type": "string"},
        "priority": {
          "type": "string",
          "enum": ["low", "medium", "high", "critical"]
        }
      },
      "required": ["customer_id", "subject", "priority"]
    }
  }
]

response = client.messages.create(
  model="claude-sonnet-4-6",
  max_tokens=2048,
  system="אתה נציג תמיכה מקצועי. יש לך גישה ל-CRM. ענה ללקוחות בצורה חמה ומקצועית.",
  tools=crm_tools,
  messages=[{
    "role": "user",
    "content": "היי, לקוח מספר 12345 מתלונן שהזמנה שלו לא הגיעה"
  }]
)

import anthropic

client = anthropic.Anthropic()

# Computer Use tools מובנים ב-Claude
response = client.messages.create(
  model="claude-sonnet-4-6",
  max_tokens=4096,
  tools=[
    {
      "type": "computer_20241022",
      "name": "computer",
      "display_width_px": 1920,
      "display_height_px": 1080
    }
  ],
  messages=[{
    "role": "user",
    "content": "פתח את הדפדפן, כנס ל-google.com וחפש 'Anthropic Claude'"
  }]
)

# Claude יחזיר screenshot actions — לחיצות, הקלדות וכו'
for block in response.content:
  if hasattr(block, "type") and block.type == "tool_use":
    print(f"Action: {block.name} — {block.input}")

import anthropic, json

client = anthropic.Anthropic()

def orchestrate(task: str) -> list:
    """Sonnet מחלק למשימות קטנות"""
    resp = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        system="חלק את המשימה ל-3 תת-משימות. החזר JSON בלבד: {\"subtasks\": [...]}",
        messages=[{"role": "user", "content": task}]
    )
    return json.loads(resp.content[0].text)["subtasks"]

def execute_subtask(subtask: str) -> str:
    """Haiku מבצע כל תת-משימה — זול ומהיר"""
    resp = client.messages.create(
        model="claude-haiku-4-5-20251001",
        max_tokens=512,
        messages=[{"role": "user", "content": subtask}]
    )
    return resp.content[0].text

# הרצה
subtasks = orchestrate("כתוב דוח שיווקי על מוצר AI חדש")
results = [execute_subtask(s) for s in subtasks]
print("\n\n".join(results))

גיליון עזר — Claude API

מודלים ו-Model IDs

API Endpoints

# Base URL
https://api.anthropic.com/v1/

# Messages (עיקרי)
POST /messages

# Headers נדרשים
x-api-key: sk-ant-...
anthropic-version: 2023-06-01
content-type: application/json

Tool Use Boilerplate — Python

import anthropic

client = anthropic.Anthropic()

def run_tool_loop(user_message: str, tools: list, tool_runner) -> str:
    """לולאת Tool Use אוטומטית"""
    messages = [{"role": "user", "content": user_message}]

    while True:
        response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=4096,
            tools=tools,
            messages=messages
        )

        if response.stop_reason != "tool_use":
            # Claude סיים — מחזיר תשובה סופית
            return response.content[0].text

        # הוסף תגובת Claude להיסטוריה
        messages.append({"role": "assistant", "content": response.content})

        # בצע כל הכלים שביקש
        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                result = tool_runner(block.name, block.input)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": str(result)
                })

        messages.append({"role": "user", "content": tool_results})

Prompt Templates מהירים

סכם את המסמך הבא ב-3 נקודות.
כל נקודה: מקסימום 20 מילה.
פורמט: רשימה ממוספרת.

<document>
{{DOCUMENT}}
</document>

חלץ מהטקסט הבא JSON מובנה.
החזר JSON בלבד, ללא הסבר.

Schema:
{name, email, phone, company}

טקסט: {{TEXT}}

בצע Code Review. ציין:
- בעיות אבטחה (CRITICAL)
- בעיות ביצועים (MAJOR)
- שיפורי קריאות (MINOR)

```{{LANGUAGE}}
{{CODE}}
```

תרגם לעברית ושפר את הניסוח.
שמור על טון {{TONE}}.
מקסימום {{MAX_WORDS}} מילים.

טקסט מקורי:
{{TEXT}}