📘 תיעוד 150

אירוח ה-Agent SDK

פריסת ה-Agent SDK בסביבת ייצור: ארכיטקטורת תהליכי משנה (subprocesses), התמדת הפעלות (sessions), הרחבת היקף (scaling), יכולת צפייה (observability), ובידוד מרובה דיירים (multi-tenant) עבור Docker, Kubernetes, וספקי סביבות מבודדות (sandbox).

ה-Agent SDK מפעיל ומפקח על תהליך משנה (subprocess) של ה-CLI של claude, שמחזיק במעטפת פקודה (shell), בספריית עבודה (working directory), ובקובצי הפעלה בדיסק. אירוח שלו אינו כמו אירוח של עטיפת API נטולת מצב (stateless). כל סוכן שרץ הוא תהליך ארוך טווח הקשור למצב מקומי, מה שמעצב את האופן שבו אתם מקצים משאבים, מתמידים הפעלות, ומבצעים התאמת קנה מידה (scaling) בין דיירים שונים.

דף זה עוסק באירוח עצמי על גבי התשתית שלכם. לקובצי Dockerfile ומניפסטים של Kubernetes המוכנים לפריסה, ראו את hosting cookbook.

אם אינכם זקוקים לשליטה בתשתית, לבידוד מותאם אישית, או למישור נתונים (data plane) משלכם, שקלו להשתמש במקום זאת ב-Managed Agents: ממשק REST API מתארח שבו Anthropic מריצה את הסוכן ואת ה-sandbox, כך שהיישום שלכם שולח אירועים ומקבל תוצאות בהזרמה ללא צורך בתפעול תשתית אירוח.

#מודל תהליך המשנה

כל החלטת אירוח בדף זה נובעת מהאופן שבו ה-SDK מריץ את הסוכן. כאשר הקוד שלכם קורא ל-query(), ה-SDK מפעיל תהליך CLI נפרד של claude ומתקשר איתו דרך stdio. תהליך משנה זה מחזיק במעטפת הפקודה, בספריית העבודה, ובתמלילי ההפעלה בפורמט JSONL בדיסק המקומי.

הפעלת סוכן אחת (session) ממופה לתהליך משנה אחד. הרצה של N הפעלות במקביל משמעותה N תהליכי משנה, לכל אחד עץ תהליכים וקובץ תמליל משלו. כברירת מחדל, כולם יורשים את ספריית העבודה של היישום שלכם. כאשר הפעלות זקוקות למערכות קבצים נפרדות, העבירו ערך cwd נפרד באפשרויות של כל קריאת query() של ההפעלה:

TypeScript:

import { query } from "@anthropic-ai/claude-agent-sdk";

for await (const message of query({
  prompt: "Summarize the files in this directory",
  options: { cwd: "/work/session-a" },
})) {
  console.log(message);
}

Python:

import asyncio

from claude_agent_sdk import ClaudeAgentOptions, query


async def main():
    async for message in query(
        prompt="Summarize the files in this directory",
        options=ClaudeAgentOptions(cwd="/work/session-a"),
    ):
        print(message)


asyncio.run(main())

דוגמאות ה-TypeScript בדף זה משתמשות ב-await ברמה העליונה (top-level await), לכן שמרו אותן כקובצי .mts או הגדירו "type": "module" בתוך package.json.

#מצב שנשמר בדיסק המקומי

שלושה סוגים של מצב סוכן נשמרים במערכת הקבצים של הקונטיינר כברירת מחדל. אף אחד מהם אינו שורד הפעלה מחדש של הקונטיינר, צמצום קנה מידה (scale-down), או העברה לצומת (node) אחר.

כדי לשמר תמלילים בין מארחים (hosts), הגדירו מתאם SessionStore. קובצי זיכרון ותוצרים אחרים של ספריית העבודה זקוקים לאסטרטגיית אחסון משלהם, כגון אמצעי אחסון מחובר (mounted volume) או סנכרון מול אחסון אובייקטים (object-store sync).

למידע על אופן הפעולה של הפעלות (sessions), חידוש (resumption), ופיצול (forking) ברמת ה-API, ראו Sessions.

#בחירת דפוס הפעלה

ארבעת הדפוסים הללו מכסים את מחזור חיי ההפעלה: כמה זמן קונטיינר חי ביחס להפעלות שהוא משרת. לגבי המקום שבו הקונטיינר רץ, ה-hosting cookbook כולל קוד מוכן לפריסה עבור Docker מקומי, Modal, ו-Kubernetes. בחרו דפוס הפעלה כאן ויעד פריסה מתוך ה-cookbook.

#הפעלות ארעיות (Ephemeral sessions)

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

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

הקונטיינר מריץ נקודת כניסה חד פעמית הקוראת את המשימה ממשתנה הסביבה TASK_PROMPT, קוראת ל-SDK, ויוצאת.

TypeScript:

import { query } from "@anthropic-ai/claude-agent-sdk";

const prompt = process.env.TASK_PROMPT!;
for await (const message of query({ prompt, options: { maxTurns: 20 } })) {
  console.log(message);
}

Python:

import asyncio
import os

from claude_agent_sdk import ClaudeAgentOptions, query


async def main():
    async for message in query(
        prompt=os.environ["TASK_PROMPT"],
        options=ClaudeAgentOptions(max_turns=20),
    ):
        print(message)


asyncio.run(main())

הסקריפט מדפיס כל הודעה עם הגעתה, כולל הודעת תוצאה שה-subtype שלה הוא success כאשר המשימה מסתיימת בתוך מגבלת התורות. אם המשימה מגיעה במקום זאת למגבלת 20 התורות, ה-subtype של הודעת התוצאה הוא error_max_turns והקריאה ל-query() מעלה שגיאה לאחר שהיא מניבה אותה, לכן עטפו את הלולאה בבלוק try אם הקונטיינר צריך לצאת בצורה נקייה. ראו Handle the result עבור סוגי המשנה של השגיאות.

#הפעלות ארוכות טווח (Long-running sessions)

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

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

הקונטיינר חושף נקודת קצה של HTTP או WebSocket וממפה כל הפעלה פעילה לשאילתה ארוכת טווח ולתהליך המשנה שמאחוריה. ב-TypeScript, השתמשו ב-streamInput() כדי להוסיף תורות להפעלה פעילה וב-startup() כדי לחמם מראש תהליכי משנה לפני תעבורה נכנסת. ב-Python, השתמשו ב-ClaudeSDKClient כדי להחזיק הפעלה פתוחה לאורך תורות שונים. קבעו את גודל הקונטיינר כך שיוכל להחזיק בזיכרון את המספר המרבי של הפעלות במקביל.

#הפעלות היברידיות (Hybrid sessions)

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

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

כווננו את פסק הזמן למצב סרק (idle timeout) של הספק שלכם לפי התדירות שבה אתם מצפים שהמשתמשים יחזרו. כיבוי קונטיינר ללא הגדרת SessionStore גורם לאובדן התמליל יחד איתו, ולכן רכיב האחסון נדרש עבור דפוס זה, ואינו רשות.

הדפוס מתבסס על חידוש הפעלה לפי מזהה כאשר מצורף מאגר משותף:

TypeScript:

import { query, type SessionStore } from "@anthropic-ai/claude-agent-sdk";

declare const userInput: string;
declare const sessionId: string;          // looked up from your database by user
declare const sessionStore: SessionStore; // S3, Redis, Postgres, or your own adapter

for await (const message of query({
  prompt: userInput,
  options: { resume: sessionId, sessionStore },
})) {
  // ...
}

Python:

from claude_agent_sdk import query, ClaudeAgentOptions, SessionStore
import asyncio

user_input: str = ...
session_id: str = ...              
# looked up from your database by user
session_store: SessionStore = ...  
# S3, Redis, Postgres, or your own adapter


async def main():
    async for message in query(
        prompt=user_input,
        options=ClaudeAgentOptions(
            resume=session_id,
            session_store=session_store,
        ),
    ):
        ...


asyncio.run(main())

#קונטיינר מרובה סוכנים (Multi-agent container)

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

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

#הקצאת הקונטיינר

#ארגז חול מבוסס קונטיינר (Container-based sandboxing)

הריצו את ה-SDK בתוך קונטיינר מבודד (sandbox) לצורך בידוד תהליכים, מגבלות משאבים, בקרת רשת, ומערכת קבצים ארעית.

שאלות שיש לענות עליהן בעת בחירת ספק:

• מי מריץ את ה-sandbox: ספק sandbox-as-a-service מפעיל את התשתית עבורכם, בעוד שאפשרויות אירוח עצמי מספקות תוכנה שאתם מריצים בעצמכם.
• זמן השהיה של התחלה קרה (Cold-start latency): כמה זמן עובר מרגע "יצירת sandbox" ועד "מוכן לקבל את הבקשה הראשונה". דפוסים ארעיים דורשים התחלות של שבריר שנייה. דפוסים ארוכי טווח יכולים לסבול יותר.
• אחסון מתמיד (Persistent storage): האם הספק מציע אמצעי אחסון עמידים או דיסק ארעי בלבד. הדפוס ההיברידי זקוק לאחסון עמיד במקום כלשהו, בין אם בתוך ה-sandbox ובין אם לצידו.
• מודל תמחור (Pricing model): חיוב לפי שנייה, לפי בקשה, או חיוב שעתי קבוע. תמחור לפי שנייה מתאים לעומסי עבודה ארעיים ומשתנים (bursty). תמחור שעתי מתאים להפעלות ארוכות טווח.
• רישות (Networking): תמיכה בכללי תעבורה יוצאת (egress) מותאמים אישית, שרתי פרוקסי יוצאים, וצימוד VPC פרטי (private VPC peering) עבור סביבות מוסדרות.

עבור אפשרויות אירוח עצמי כגון Docker, gVisor, ו-Firecracker, והגדרות בידוד מפורטות, ראו Isolation Technologies.

#תלויות סביבת ריצה (Runtime dependencies)

הקונטיינר זקוק לסביבת הריצה של שפת ה-SDK שלכם:

• Python 3.10+ עבור ה-SDK של Python, או Node.js 18+ עבור ה-SDK של TypeScript.
• שני ה-SDKs, הן של TypeScript והן של Python, מגיעים עם קובץ בינארי טבעי (native) של Claude Code עבור רוב ההתקנות, וה-CLI המופעל אינו זקוק להתקנת Node.js נפרדת. ראו את הערת ההתקנה במדריך ההתחלה המהירה עבור התקנות הזקוקות להתקנה נפרדת של קובץ Claude Code טבעי.

הקובץ הבינארי המצורף מוצמד לגרסת חבילת ה-SDK, כך שעדכון ה-SDK הוא האופן שבו אתם מעדכנים את ה-CLI. ה-SDK פועל לפי ניהול גרסאות סמנטי (semver): עדכנו גרסאות תיקון (patch releases) באופן שוטף ועיינו ביומן השינויים של TypeScript או Python לפני שאתם מעדכנים גרסה משנית (minor).

#משאבים

1 GiB RAM, דיסק של 5 GiB, ו-1 מעבד (CPU) לכל סוכן הם נקודת התחלה סבירה עבור מופע שהופעל זה עתה. השימוש בזיכרון גדל ככל שמשך ההפעלה מתארך ופעילות הכלים גוברת, לכן הקצו משאבים בהתאם למשך ההפעלה ולרמת המקביליות הנדרשים לכם בפועל, ולא לפי קו הבסיס של מצב סרק. ראו הרחבת היקף ומקביליות לגבי אופן חישוב מספר הסוכנים לכל מארח.

#רשת

ה-SDK זקוק לתעבורת HTTPS יוצאת אל api.anthropic.com, או לנקודת הקצה האזורית של הספק שלכם בעת הרצה על Amazon Bedrock או על Agent Platform של Google Cloud. אם הסוכנים שלכם משתמשים ב-שרתי MCP או בכלים חיצוניים, הם זקוקים לגישה יוצאת גם לנקודות קצה אלה. בסביבת ייצור, נתבו תעבורה יוצאת דרך שרת פרוקסי יוצא (egress proxy) שאוכף רשימות דומיינים מורשים, מזריק אישורים ומתעד בקשות. ראו Secure Deployment עבור הדפוס המלא.

עבור תעבורה נכנסת, חשפו יציאת HTTP או WebSocket בקונטיינר. היישום שלכם מטפל בבקשות לקוח ביציאה זו וקורא ל-SDK באופן פנימי; תהליך המשנה עצמו אינו מאזין לרשת.

#טיפול בשיקולי ייצור

עברו על החלטות אלה לפני השקת סוכן באירוח עצמי.

#התמדת הפעלות ומצב

דיסק מקומי ברירת מחדל אובד בעת הפעלה מחדש, צמצום קנה מידה, או מעבר לצומת אחר. עבור כל הפעלה שהמשתמש מצפה לחדש, שקפו את התמליל לאחסון עמיד באמצעות מתאם SessionStore. ראו יישומי ייחוס עבור מתאמי S3, Redis ו-Postgres ובדיקות תאימות עבור מתאם משלכם.

שלושה דברים שכדאי לדעת על התנהגות SessionStore:

• תמלילים בלבד: SessionStore משקף תמלילים, לא קובצי זיכרון CLAUDE.md או תוצרים אחרים של ספריית העבודה. חברו אמצעי אחסון משותף (volume) או סנכרנו אותם בנפרד.
• שיקוף, לא תחליף: תהליך המשנה כותב לדיסק המקומי תחילה, וה-SDK מעביר עותק של כל מקבץ (batch) אל מאגר האחסון. תמליל מקומי של הפעלה חדשה נשאר גם לאחר סיום הריצה; ריצה שחודשה מתוך מאגר האחסון מוחקת את העותק המקומי שלה בסיום, כך שמאגר האחסון מחזיק בעותק העמיד היחיד. ראו ארכיטקטורת כתיבה כפולה.
• הודעות mirror_error: כאשר ה-SDK אינו מצליח להעביר מקבץ למאגר האחסון, הוא משמיט את המקבץ, פולט הודעת { type: "system", subtype: "mirror_error" }, וממשיך בשאילתה. הגדירו התראות על שגיאות אלו אם עמידות המאגר חשובה לכם. ראו כתיבות שיקוף הן לפי מיטב המאמץ עבור התנהגות ניסיונות חוזרים ופסקי זמן.

#יכולת צפייה

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

ה-SDK יורש הגדרות OpenTelemetry מסביבת הריצה. הגדירו את משתני הסביבה של OTEL ברמת הקונטיינר או ברמת מערכת התזמור (orchestrator), כך שכל קריאת query() תייצא מקטעים (spans), מדדים (metrics) ואירועי יומן (logs) אל ה-collector שלכם. הדוגמה להלן מפעילה ייצוא OTLP עבור שלושת האותות. CLAUDE_CODE_ENHANCED_TELEMETRY_BETA נדרש רק עבור עקבות (traces); השמיטו אותו אם אתם מייצאים מדדים ויומנים בלבד.

CLAUDE_CODE_ENABLE_TELEMETRY=1
CLAUDE_CODE_ENHANCED_TELEMETRY_BETA=1
OTEL_TRACES_EXPORTER=otlp
OTEL_METRICS_EXPORTER=otlp
OTEL_LOGS_EXPORTER=otlp
OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
OTEL_EXPORTER_OTLP_ENDPOINT=http://collector.example.com:4318

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

#אימות וסודות

שלושה שיקולי אימות חשובים בזמן האירוח:

• ה-API של Anthropic: תהליך המשנה קורא את ANTHROPIC_API_KEY מהסביבה שלו. ספקו אותו ממנהל הסודות שלכם, או הגדירו את ANTHROPIC_BASE_URL כדי לנתב קריאות למודל דרך שרת פרוקסי שמזריק את המפתח מחוץ לקונטיינר. ראו ניהול אישורים עבור דפוס הפרוקסי ואת הגדרה במדריך ההתחלה המהירה של ה-SDK עבור שיטות אימות נתמכות.
• תעבורה נכנסת: הציבו אימות בשער (gateway) לפני קונטיינר הסוכן. הסוכן צריך לקבל בקשות מאומתות מראש ולא צריך להיות הרכיב שמאמת אסימוני משתמש.
• כלים יוצאים: הרחיקו אישורי כלים מסביבת הסוכן. נתבו קריאות יוצאות דרך שרת פרוקסי שמזריק מפתחות API לאחר שהבקשה עוזבת את הקונטיינר. הסוכן מבצע את הקריאה; שרת הפרוקסי מוסיף את האישור.

#הרחבת היקף ומקביליות

כל הפעלה רצה בתהליך משנה משלה, כך שמקביליות במארח מוגבלת לפי כמות תהליכי המשנה שזיכרון ה-RAM שלו יכול להכיל.

קבעו את גודל כל מארח באמצעות נוסחה זו:

agents per host = (host RAM - overhead) / (per-session RAM ceiling)

מדדו את תקרת ה-RAM לכל הפעלה על ידי הרצת הפעלה מייצגת באורך היעד שלכם תחת עומס הכלים הצפוי ומדידת שיא ה-RSS (Resident Set Size). נקודת ההתחלה של 1 GiB בסעיף משאבים היא רצפה, ולא תקרה.

ניתוב התרחבות אופקית (horizontal scaling) תלוי בדפוס שלכם. עבור הפעלות ארוכות טווח, שבהן קונטיינרים מחזיקים הפעלות רבות, הריצו מאגר קונטיינרים מאחורי מאזן עומסים (load balancer) והצמידו כל הפעלה לקונטיינר יחיד באמצעות גיבוב עקבי (consistent hashing) על sessionId. הפעלה מוצמדת תמשיך להגיע לאותו קונטיינר, ולכן לאותו תהליך משנה רץ, עד שהיא תפונה או שהקונטיינר יופעל מחדש.

#עלויות

עלות האסימונים (tokens) של Anthropic בדרך כלל גבוהה מעלות תשתית הקונטיינר בסדר גודל אחד או יותר. קונטיינר בהקצאה מינימלית עולה כ-0.05$ לשעה, בעוד שהפעלת סוכן ארוכה אחת יכולה לצרוך דולרים רבים באסימונים. ראו מעקב עלויות עבור חשבונאות אסימונים לכל הפעלה.

#בידוד מרובה דיירים

התנהגות ברירת המחדל של ה-SDK היא קריאת הגדרות וקובצי זיכרון CLAUDE.md ממערכת הקבצים. בקונטיינר משותף המשרת מספר דיירים, קבצים אלה עלולים להדליף הקשר של דייר אחד להפעלה של דייר אחר.

כדי לבודד דיירים בתוך קונטיינר משותף:

• העבירו settingSources: [] ב-TypeScript או setting_sources=[] ב-Python כדי לדלג על הגדרות משתמש, פרויקט והגדרות מקומיות.
• הגדירו CLAUDE_CODE_DISABLE_AUTO_MEMORY=1 בתוך env. זיכרון אוטומטי (Auto memory) במיקום ~/.claude/projects/<project>/memory/ נטען להנחיית המערכת (system prompt) ללא קשר ל-settingSources. ראו מה ש-settingSources אינו שולט בו עבור הקלטים האחרים שנטענים ללא תנאי.
• כוונו את CLAUDE_CONFIG_DIR לספרייה ייעודית לכל דייר, כך שדיירים לא ישתפו את התצורה הגלובלית ~/.claude.json. כאשר כל ספריית תצורה משרתת ספריית עבודה אחת ואינכם משתפים SessionStore בין דיירים, תוכלו גם להגדיר את CLAUDE_CODE_PROJECT_DIR_NAME בתוך env כדי לשמור על נתיבי תמלילים קצרים תחתיה. דורש TypeScript Agent SDK מגרסה v0.3.234 ואילך, או Python Agent SDK מגרסה v0.2.140 ואילך.
• השתמשו בספריית עבודה ייעודית לכל דייר. העבירו את cwd במפורש בכל קריאת query().
• החילו כללי תעבורה יוצאת (egress) ייעודיים לכל דייר בשרת הפרוקסי שלכם, כגון כתובות IP יוצאות נפרדות, אישורים נפרדים או רשימות דומיינים מורשים, כך שדייר שנפגע לא יוכל לדלוף נתונים דרך מדיניות התעבורה היוצאת של דייר אחר.

הדוגמה להלן מיישמת יחד את אפשרויות ההגדרות, הזיכרון האוטומטי, ספריית התצורה וספריית העבודה. בנו את tenantDir ואת configDir כך שכל דייר יקבל נתיב שאף דייר אחר אינו יכול לקרוא. ב-TypeScript, הערך env מחליף את סביבת תהליך המשנה, לכן פירסו את ...process.env כדי לשמור על משתנים מורשים כגון PATH ו-ANTHROPIC_API_KEY. ב-Python, הערך env ממוזג על גבי הסביבה המורשת.

TypeScript:

import { query } from "@anthropic-ai/claude-agent-sdk";

declare const prompt: string;
declare const tenantDir: string;
declare const configDir: string;

for await (const message of query({
  prompt,
  options: {
    cwd: tenantDir,
    settingSources: [],
    env: {
      ...process.env,
      CLAUDE_CONFIG_DIR: configDir,
      CLAUDE_CODE_DISABLE_AUTO_MEMORY: "1",
    },
  },
})) {
  // ...
}

Python:

from claude_agent_sdk import query, ClaudeAgentOptions
import asyncio

prompt: str = ...
tenant_dir: str = ...
config_dir: str = ...


async def main():
    async for message in query(
        prompt=prompt,
        options=ClaudeAgentOptions(
            cwd=tenant_dir,
            setting_sources=[],
            env={
                "CLAUDE_CONFIG_DIR": config_dir,
                "CLAUDE_CODE_DISABLE_AUTO_MEMORY": "1",
            },
        ),
    ):
        ...


asyncio.run(main())

#מגבלות ידועות

תכננו את תכנון הפריסה שלכם בהתחשב במגבלות אלו.

#פתרון בעיות בכשלי פריסה

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

• ה-CLI לא נמצא בעת הפעלת השירות (CLI not found at service start): ב-Python, קונטיינר או מנהל שירותים מריץ את היישום שלכם עם משתנה PATH שונה מזה של המעטפת (shell) שלכם, ולכן התקנה שעובדת מקומית אינה גלויה לתהליך. ב-TypeScript, בניית התמונה דילגה על התלויות האופציונליות של ה-SDK, או ש-pathToClaudeCodeExecutable מצביע על קובץ שאינו קיים בתמונה. ראו Claude Code not found.
• ה-CLI קיים בתמונה אך אינו מופעל (CLI present in the image but won't launch): Claude Code אינו יכול לפעול מקובץ בינארי שאינו תואם לארכיטקטורת הקונטיינר או ל-libc שלו, או מקובץ שאיבד את הרשאת ההרצה שלו במהלך בניית התמונה. ראו Failed to start Claude Code.
• תהליך Claude Code יוצא באמצע הריצה (Claude Code process exits mid-run): השגיאה שהיישום שלכם מקבל תלויה בשפת ה-SDK ובשאלה האם ה-CLI דיווח תחילה על תוצאת שגיאה. הרשומות תחת CLI process exit מכסות כל הודעה.

#השלבים הבאים

• Hosting cookbook: מדריך מבוסס notebook עם קוד מוכן לפריסה עבור Docker, Modal, ו-Kubernetes.
• אחסון הפעלות (Session storage): התמדת תמלילים בין מארחים באמצעות מתאם SessionStore.
• יכולת צפייה (Observability): ייצוא עקבות OTEL, מדדים, ויומנים אל ה-collector שלכם.
• פריסה מאובטחת (Secure deployment): בקרות רשת, ניהול אישורים, והקשחת בידוד.
• מעקב עלויות (Cost tracking): חשבונאות אסימונים ועלויות לכל הפעלה.