Claude API —
מדריך מפתחים

התקנה ראשונה — Python SDK

Anthropic מספקת SDK רשמי ל-Python ול-TypeScript. ההתקנה פשוטה ומחייבת API Key מ-console.anthropic.com.

pip install anthropic

import anthropic

client = anthropic.Anthropic(api_key="YOUR_API_KEY")
# מומלץ: ANTHROPIC_API_KEY כ-env variable, אז אפשר בלי api_key=

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "שלום! מה אתה יכול לעשות?"}
    ]
)
print(message.content[0].text)

המודלים — אפריל 2026

System Prompts

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

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system="""אתה מומחה לניתוח נתונים פיננסיים.
תמיד השב בפורמט: נתון עיקרי → משמעות → המלצה.
אם חסר מידע — שאל לפני שאתה מנחש.
שפה: עברית בלבד.""",
    messages=[
        {"role": "user", "content": "נתח את הנתונים הבאים: ..."}
    ]
)

XML Tags — הטכניקה המועדפת של Anthropic

Claude מגיב מצוין למבנה XML בתוך הפרומפט. Anthropic ממליצה על זה רשמית לפרמפטים מורכבים:

system_prompt = """
<role>אתה עוזר משפטי שעוזר לסטארטאפים.</role>

<instructions>
- ענה רק על שאלות משפטיות הקשורות לסטארטאפים בישראל
- הוסף תמיד הערת אזהרה: "אין זה ייעוץ משפטי מחייב"
- אם אינך בטוח — אמור זאת במפורש
</instructions>

<output_format>
1. תשובה ישירה
2. הסבר קצר
3. המלצה לפעולה
</output_format>
"""

Tool Use (Function Calling)

Tool Use מאפשר ל-Claude "לקרוא לפונקציות" שאתה מגדיר — לחפש ברשת, לשלוף נתונים מ-DB, לשלוח מיילים, וכל דבר אחר. המודל מחליט מתי לקרוא לכלי ומה לשלוח אליו.

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

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

# Claude מחזיר tool_use block
if response.stop_reason == "tool_use":
    tool_call = next(b for b in response.content if b.type == "tool_use")
    print(f"קריאה לכלי: {tool_call.name}")
    print(f"קלט: {tool_call.input}")
    # כאן תריץ את הפונקציה האמיתית ותחזיר תוצאה

Extended Thinking

Extended Thinking מאפשר ל-Claude "לחשוב בקול" לפני שהוא עונה — הוא מייצר thinking tokens נסתרים שמשפרים דרמטית תשובות לבעיות מורכבות: מתמטיקה, לוגיקה, קוד קשה.

response = client.messages.create(
    model="claude-opus-4-6",   # Thinking מומלץ עם Opus
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000  # כמה tokens ל"חשיבה" — עד 10K מומלץ
    },
    messages=[{
        "role": "user",
        "content": "פתור את הבעיה הבאה שלב אחר שלב: ..."
    }]
)

for block in response.content:
    if block.type == "thinking":
        print("חשיבה פנימית:", block.thinking[:200], "...")
    elif block.type == "text":
        print("תשובה:", block.text)

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

Claude יכול לנתח תמונות, screenshots, PDF וגרפים — שלח base64 או URL ישיר.

import base64
from pathlib import Path

# קריאת תמונה מקומית
img_data = base64.standard_b64encode(Path("chart.png").read_bytes()).decode()

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": img_data
                }
            },
            {
                "type": "text",
                "text": "נתח את הגרף: מה המגמה? אילו חריגים בולטים?"
            }
        ]
    }]
)
print(response.content[0].text)

בניית MCP Server

MCP (Model Context Protocol) מאפשר לחבר Claude לכלים חיצוניים. כשאתה בונה MCP Server, כל לקוח MCP תואם (כולל claude.ai, Claude Code, Cursor) יכול להשתמש בו.

from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp import types

app = Server("my-tool-server")

@app.list_tools()
async def list_tools() -> list[types.Tool]:
    return [
        types.Tool(
            name="search_db",
            description="מחפש רשומות בבסיס הנתונים לפי שאילתה",
            inputSchema={
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "שאילתת חיפוש"}
                },
                "required": ["query"]
            }
        )
    ]

@app.call_tool()
async def call_tool(name: str, arguments: dict) -> list[types.TextContent]:
    if name == "search_db":
        results = await db.search(arguments["query"])  # הלוגיקה שלך כאן
        return [types.TextContent(type="text", text=str(results))]

async def main():
    async with stdio_server() as streams:
        await app.run(*streams, app.create_initialization_options())

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())

AI Agents עם Claude

Agent הוא לולאה שבה Claude מקבל משימה, מחליט על פעולות (Tool Use), מריץ אותן, ומשתמש בתוצאות להמשיך — עד שהמשימה הושלמה.

def run_agent(task: str, tools: list, max_iterations: int = 10) -> str:
    messages = [{"role": "user", "content": task}]

    for i in range(max_iterations):
        response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=4096,
            tools=tools,
            messages=messages
        )

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

        if response.stop_reason == "end_turn":
            # הסתיים — החזר את הטקסט הסופי
            return next(b.text for b in response.content if hasattr(b, "text"))

        if response.stop_reason == "tool_use":
            tool_results = []
            for block in response.content:
                if block.type == "tool_use":
                    result = execute_tool(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})

    return "הגעתי למגבלת iterations"

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

Model IDs מעודכנים

שגיאות נפוצות ופתרונות

Prompt Caching — חיסכון של עד 90%

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system=[{
        "type": "text",
        "text": "מסמך ארוך שמשמש בכל הקריאות...",
        "cache_control": {"type": "ephemeral"}  # ← מאחסן את זה בcache
    }],
    messages=[{"role": "user", "content": "שאלה על המסמך"}]
)
# הקריאה הראשונה כותבת ל-cache, שאר הקריאות זולות ב-90%