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)

Python SDK 1.0 — שינויים שוברי תאימות

ארבעה שינויים, לפי סדר הסבירות שייגעו בך:

1. פרמטרי הדגימה הוסרו ממתודות ההודעות

temperature, top_p ו-top_k אינם קיימים יותר על מתודות ה-Messages. קוד שמעביר אותם ייכשל.

# לפני
msg = client.messages.create(
    model="claude-opus-5",
    max_tokens=1024,
    temperature=0.2,          # ← לא קיים יותר
    messages=[...],
)

# אחרי — השליטה עוברת לניסוח
msg = client.messages.create(
    model="claude-opus-5",
    max_tokens=1024,
    system="ענה עובדתית ובאופן עקבי. אל תוסיף וריאציות סגנוניות. "
           "כשיש כמה ניסוחים אפשריים - בחר את הפשוט ביותר.",
    messages=[...],
)

זה שינוי שקשה יותר משנראה. אם השתמשת ב-temperature=0 כדי לקבל פלט יציב לתוכנה, ההחלפה אינה פרמטר אחר אלא פלט מובנה — סכמה שכופה את המבנה ממילא, ואז היציבות לא תלויה בדגימה.

2. שכבת ה-HTTP עברה ל-httpx2

הספרייה הפנימית עברה מ-httpx ל-httpx2, פיצול מתוחזק עם אותו ממשק. שני מקרים שנשברים:

• לקוח HTTP מותאם. אם בנית http_client, Timeout או transport משלך — בנה אותם מ-httpx2.
• בדיקות ומעקב. ספריות שמטליאות את httpx — כלי mocking, כלי tracing — לא יראו את הבקשות. הפתרון הוא קריאה אחת באתחול:

import httpx2
httpx2.alias_httpx()      # לפני יצירת הלקוח, פעם אחת

client = anthropic.Anthropic()

3. Text Completions הוסר

הממשק הישן client.completions נמחק לחלוטין. אם יש לך קוד שעדיין משתמש בו, המעבר ל-Messages הוא שינוי מבני: במקום מחרוזת אחת עם Human: ו-Assistant:, רשימת הודעות עם תפקידים.

4. דרישת גרסת Python

המינימום הועלה ל-Python 3.10. סביבה שרצה על 3.9 לא תוכל להתקין את הגרסה החדשה כלל.

אומת מול מסמך גרסאות השחרור הרשמי. אם אתה קורא את זה זמן רב אחרי הפרסום, בדוק שם מה השתנה מאז.

המודלים

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"

המודל משתנה מתחתיך — ואיך לא להישבר מזה

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

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

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

להוזיל בלי לוותר על איכות

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

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

ראה הוזלת עלויות LLM להרחבה, ומטמון למנגנון עצמו.

גיליון עזר — 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%