בניית סוכן AI אוטונומי לניהול משימות באמצעות Python

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

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

סוכן אוטונומי מתבסס על לולאה שנקראת ReAct (Reasoning + Acting). בכל סיבוב הסוכן חושב ("מה הצעד הבא?"), פועל (מפעיל כלי, כותב קוד, קורא API), מתבונן בתוצאה ("מה קרה?"), ומחליט אם המשימה הושלמה או שצריך צעד נוסף.

מהם הרכיבים המרכזיים של סוכן AI?

כל סוכן AI אוטונומי בנוי מארבעה רכיבים בסיסיים:

1. מוח (LLM): מודל שפה גדול כמו GPT-4o, Claude, או Llama שמפעיל את ההיגיון של הסוכן. המודל מקבל הקשר ומחליט מה הפעולה הבאה.

2. כלים (Tools): פונקציות Python שהסוכן יכול להפעיל — שליחת מייל, חיפוש באינטרנט, קריאה וכתיבה של קבצים, גישה למסד נתונים, הפעלת API חיצוני.

3. זיכרון (Memory): מנגנון שמאפשר לסוכן לזכור מה עשה, מה עבד ומה לא, ומה המשתמש ביקש. יש זיכרון לטווח קצר (תוך שיחה) וזיכרון לטווח ארוך (בין שיחות, בדרך כלל מבוסס vector database).

4. לולאת ביצוע (Agent Loop): הקוד שמחבר הכול, מפעיל את המודל, מנתח את התשובה, מריץ את הכלי הנכון, ומזין את התוצאה בחזרה ללולאה.

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

למה דווקא Python לבניית סוכנים?

Python שולטת באקוסיסטם של AI בצורה מוחלטת, כל ספריית סוכנים מרכזית — LangChain, CrewAI, AutoGen — כתובה ב-Python. כל ספק API של מודלי שפה מספק SDK רשמי ל-Python. התשתית קיימת, התיעוד עשיר, והקהילה ענקית.

מעבר לזה, Python מאפשרת prototyping מהיר. אפשר לעבור מרעיון לסוכן עובד תוך שעות, לא ימים. וכשמגיעים לפרודקשן, כלים כמו FastAPI ו-Docker מאפשרים לעטוף את הסוכן ב-API ולהריץ אותו בענן.

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

שלב 1: הקמת סביבת הפיתוח והתקנת תלויות

מתחילים בהגדרת סביבה וירטואלית ויתקנו את הספריות הנדרשות:

# יצירת סביבה וירטואלית
python -m venv agent-env
source agent-env/bin/activate  # Linux/Mac
# agent-env\Scripts\activate  # Windows

# התקנת ספריות
pip install langchain langchain-openai langchain-community python-dotenv

# יצירת קובץ הגדרות
echo "OPENAI_API_KEY=sk-your-key-here" > .env

חשוב: שמרו את מפתח ה-API בקובץ .env ולעולם אל תכניסו אותו לקוד ישירות. זה נכון גם לפרויקטים אישיים, הרגלים טובים מתחילים מהיום הראשון.

שלב 2: הגדרת הכלים (Tools) שהסוכן ישתמש בהם

כלים הם הידיים של הסוכן, כל כלי הוא פונקציית Python רגילה עם decorator שמסביר ל-LLM מה הכלי עושה. הנה הקוד:

import os
import json
from datetime import datetime
from dotenv import load_dotenv
from langchain.tools import tool
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

load_dotenv()

# --- הגדרת כלים ---

@tool
def read_file(file_path: str) -> str:
    """קורא תוכן של קובץ טקסט מהדיסק. משמש לקריאת רשימות משימות, הגדרות, או כל קובץ טקסט."""
    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            return f.read()
    except FileNotFoundError:
        return f"שגיאה: הקובץ {file_path} לא נמצא"
    except Exception as e:
        return f"שגיאה בקריאת הקובץ: {str(e)}"


@tool
def write_file(file_path: str, content: str) -> str:
    """כותב תוכן לקובץ טקסט. משמש לשמירת תוצאות, יצירת דוחות, ועדכון רשימות משימות."""
    try:
        os.makedirs(os.path.dirname(file_path) if os.path.dirname(file_path) else '.', exist_ok=True)
        with open(file_path, 'w', encoding='utf-8') as f:
            f.write(content)
        return f"הקובץ {file_path} נכתב בהצלחה"
    except Exception as e:
        return f"שגיאה בכתיבת הקובץ: {str(e)}"


@tool
def list_directory(directory: str = ".") -> str:
    """מציג את רשימת הקבצים והתיקיות בנתיב נתון. משמש לסקירת תוכן תיקייה."""
    try:
        items = os.listdir(directory)
        return json.dumps(items, ensure_ascii=False, indent=2)
    except Exception as e:
        return f"שגיאה: {str(e)}"


@tool
def get_current_time() -> str:
    """מחזיר את התאריך והשעה הנוכחיים. משמש לתיעוד זמנים ויצירת timestamps."""
    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")


@tool
def create_task_report(tasks: str, status: str) -> str:
    """יוצר דוח משימות מסודר בפורמט Markdown. מקבל רשימת משימות וסטטוס לכל אחת."""
    report = f"""# דוח משימות
## נוצר: {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}

### משימות:
{tasks}

### סטטוס כללי:
{status}

---
*דוח זה נוצר אוטומטית על ידי סוכן AI*
"""
    return report

שימו לב ל-docstrings — הם לא רק תיעוד לנו. ה-LLM קורא אותם כדי להבין מתי ואיך להשתמש בכל כלי. docstring טוב = סוכן חכם יותר. docstring עמום = סוכן שמשתמש בכלי הלא-נכון.

שלב 3: בניית הסוכן עם לולאת ReAct

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

# --- הגדרת הסוכן ---

# רשימת כל הכלים
tools = [read_file, write_file, list_directory, get_current_time, create_task_report]

# הגדרת המודל
llm = ChatOpenAI(
    model="gpt-4o",
    temperature=0.1  # טמפרטורה נמוכה = התנהגות עקבית ופחות יצירתית
)

# Prompt שמגדיר את האישיות והכללים של הסוכן
system_prompt = """אתה סוכן AI לניהול משימות. התפקיד שלך:

1. לקבל משימות מהמשתמש בשפה טבעית
2. לפרק כל משימה לצעדים קטנים וברורים
3. לבצע כל צעד באמצעות הכלים שלך
4. לדווח על ההתקדמות אחרי כל צעד
5. ליצור דוח סיכום בסיום

כללים:
- תמיד תכנן לפני שאתה פועל
- אם צעד נכשל, נסה גישה חלופית
- אל תבצע יותר מ-10 צעדים בלי לעדכן את המשתמש
- כתוב בעברית
"""

prompt = ChatPromptTemplate.from_messages([
    ("system", system_prompt),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])

# יצירת הסוכן
agent = create_openai_tools_agent(llm, tools, prompt)

# עטיפת הסוכן ב-executor עם הגבלות בטיחות
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,       # מדפיס את תהליך החשיבה — חיוני לדיבוג
    max_iterations=15,  # מונע לולאות אינסופיות
    handle_parsing_errors=True,  # מתאושש מטעויות parsing
)

# --- הפעלת הסוכן ---

if __name__ == "__main__":
    result = agent_executor.invoke({
        "input": """
        בבקשה בצע את המשימות הבאות:
        1. בדוק מה יש בתיקייה הנוכחית
        2. צור קובץ בשם tasks.md עם רשימת משימות לדוגמה
        3. קרא את הקובץ שיצרת ואמת שהתוכן תקין
        4. צור דוח סיכום ושמור אותו בקובץ report.md
        """
    })
    
    print("\n" + "=" * 50)
    print("תוצאה סופית:")
    print(result["output"])

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

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

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

אם מתחילים מאפס ורוצים לבנות סוכן יחיד — LangChain עם OpenAI הוא המסלול הבטוח ביותר. אם רוצים צוות של סוכנים שעובדים יחד (למשל, אחד חוקר, אחד כותב, אחד בודק) — CrewAI מפשט את התהליך דרמטית.

מתי כדאי לבחור LangGraph במקום LangChain קלאסי?

LangGraph הוא הדור הבא של LangChain. במקום שרשרת לינארית (chain), הוא מאפשר גרף מצבים (state graph) — הסוכן יכול לחזור לצעדים קודמים, להסתעף, ולנהל תהליכים מורכבים. אם הסוכן שלכם צריך רק "קבל משימה → בצע → דווח", LangChain קלאסי מספיק. אם צריך לוגיקה כמו "אם X נכשל, חזור ל-Y ונסה גישה אחרת" — LangGraph הוא הכלי הנכון.

הנה דוגמה להגדרת גרף בסיסי ב-LangGraph:

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated, Sequence
import operator

# הגדרת מבנה ה-state
class AgentState(TypedDict):
    messages: Annotated[Sequence[dict], operator.add]
    current_task: str
    tasks_completed: list
    retry_count: int

# הגדרת הצמתים בגרף
def plan_node(state: AgentState) -> AgentState:
    """צומת תכנון — הסוכן מחליט מה הצעד הבא"""
    # כאן הלוגיקה של התכנון
    return {"current_task": "next_task_here"}

def execute_node(state: AgentState) -> AgentState:
    """צומת ביצוע — הסוכן מפעיל כלי"""
    # כאן הלוגיקה של הביצוע
    return {"tasks_completed": state.get("tasks_completed", []) + [state["current_task"]]}

def should_continue(state: AgentState) -> str:
    """בודק אם יש עוד משימות או שסיימנו"""
    if state.get("retry_count", 0) > 3:
        return "end"
    if len(state.get("tasks_completed", [])) >= 5:
        return "end"
    return "continue"

# הרכבת הגרף
workflow = StateGraph(AgentState)
workflow.add_node("plan", plan_node)
workflow.add_node("execute", execute_node)
workflow.add_edge("plan", "execute")
workflow.add_conditional_edges("execute", should_continue, {
    "continue": "plan",
    "end": END,
})
workflow.set_entry_point("plan")

app = workflow.compile()

בואו נהיה ישירים: סוכן AI בלי guardrails הוא כמו מכונית בלי בלמים. הוא יעבוד מצוין ב-90% מהמקרים ויפגע ב-10% שנותרו. הנה מנגנוני ההגנה שחובה להטמיע:

אילו מנגנוני בטיחות חייבים להיות בכל סוכן AI?

הגבלת איטרציות: תמיד הגדירו max_iterations. ערך של 15-25 מספיק לרוב המשימות. אם הסוכן לא סיים בזמן, עדיף שיעצור וידווח מאשר ימשיך לרוץ.

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

from langchain.callbacks import BaseCallbackHandler

class TokenBudgetCallback(BaseCallbackHandler):
    def __init__(self, max_tokens: int = 50000):
        self.total_tokens = 0
        self.max_tokens = max_tokens
    
    def on_llm_end(self, response, **kwargs):
        # מעקב אחרי צריכת טוקנים
        if hasattr(response, 'llm_output') and response.llm_output:
            usage = response.llm_output.get('token_usage', {})
            self.total_tokens += usage.get('total_tokens', 0)
            
            if self.total_tokens > self.max_tokens:
                raise Exception(
                    f"חריגה מתקציב טוקנים: {self.total_tokens}/{self.max_tokens}"
                )

# שימוש:
budget_callback = TokenBudgetCallback(max_tokens=50000)
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    callbacks=[budget_callback],
    max_iterations=15,
)

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

לוגים מפורטים: הדליקו verbose=True בפיתוח, ובפרודקשן שמרו לוגים מלאים של כל צעד. כשהסוכן עושה משהו לא צפוי (וזה יקרה), הלוגים הם הדרך היחידה להבין למה.

שורה תחתונה לפועלים: אל תשחררו סוכן AI לפרודקשן בלי שהגדרתם מי מאשר פעולות הרסניות (מחיקה, שליחת מיילים, שינוי נתונים). Human-in-the-loop הוא לא חולשה — הוא הגנה הכרחית.

איך מוסיפים זיכרון לטווח ארוך לסוכן?

סוכן בלי זיכרון מתחיל מאפס בכל שיחה. כדי שהסוכן ילמד מניסיון קודם, נוסיף זיכרון מבוסס vector store. הנה דוגמה עם ChromaDB:

from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings
from langchain.memory import VectorStoreRetrieverMemory

# יצירת vector store מקומי
embeddings = OpenAIEmbeddings()
vectorstore = Chroma(
    collection_name="agent_memory",
    embedding_function=embeddings,
    persist_directory="./agent_memory_db"
)

# יצירת זיכרון מבוסס חיפוש סמנטי
retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
memory = VectorStoreRetrieverMemory(retriever=retriever)

# שמירת ניסיון
memory.save_context(
    {"input": "צור דוח מכירות חודשי"},
    {"output": "השתמשתי בכלי read_file כדי לקרוא את נתוני המכירות, ואז create_task_report ליצירת הדוח."}
)

# שליפת ניסיון רלוונטי
relevant_memories = memory.load_memory_variables({"prompt": "אני צריך דוח מכירות"})

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

לפי סקרים בתעשייה מהשנה האחרונה, כ-60% מפרויקטי AI agents נשארים בשלב ה-POC ולא מגיעים לפרודקשן. הסיבות העיקריות: חוסר אמינות, עלויות בלתי צפויות, וקושי באינטגרציה עם מערכות קיימות.

מהם הצעדים להעברת סוכן לפרודקשן?

עטיפה ב-API: הסוכן צריך לרוץ כשירות, לא כסקריפט. עטפו אותו ב-FastAPI:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI()

class TaskRequest(BaseModel):
    task: str
    max_iterations: int = 15

class TaskResponse(BaseModel):
    result: str
    steps_taken: int
    tokens_used: int

@app.post("/execute", response_model=TaskResponse)
async def execute_task(request: TaskRequest):
    try:
        result = agent_executor.invoke({
            "input": request.task
        })
        return TaskResponse(
            result=result["output"],
            steps_taken=len(result.get("intermediate_steps", [])),
            tokens_used=budget_callback.total_tokens
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

מוניטורינג: השתמשו ב-LangSmith (מבית LangChain) או Helicone לעקוב אחרי כל ריצה — זמני ביצוע, שגיאות, עלויות. בלי מוניטורינג אתם עיוורים.

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

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

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

• התחילו קטן: סוכן עם 2-3 כלים ומשימה אחת ברורה. אל תנסו לבנות AGI ביום הראשון.
• השקיעו ב-prompt engineering: ה-system prompt הוא 50% מהביצועים של הסוכן. נסחו אותו בבהירות, עם כללים מפורשים ודוגמאות.
• הגדירו guardrails מהרגע הראשון: max_iterations, תקציב טוקנים, הגבלת הרשאות. לא "אחר כך" — עכשיו.
• השתמשו ב-verbose mode: תצפו בסוכן עובד, תבינו איך הוא חושב, ותשפרו על סמך מה שאתם רואים.
• בחרו את הפריימוורק לפי הצורך: LangChain לסוכן יחיד גמיש, CrewAI לצוות סוכנים, LangGraph לתהליכים מורכבים עם הסתעפויות.

עודכן: 2026-09-22

מה ההבדל בין סוכן AI לבין צ'אטבוט?

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

כמה עולה להריץ סוכן AI באופן שוטף?

העלות תלויה במודל ובמורכבות המשימות. משימה טיפוסית שדורשת 5-10 צעדים עם GPT-4o עולה בערך 0.05-0.15 דולר. אם הסוכן מבצע 100 משימות ביום, מדברים על 5-15 דולר ביום. כדי להוריד עלויות, אפשר להשתמש במודלים קטנים יותר (GPT-4o-mini) למשימות פשוטות ולשמור מודלים חזקים למשימות מורכבות בלבד.

האם אפשר לבנות סוכן AI בלי API בתשלום?

כן. אפשר להשתמש במודלים מקומיים באמצעות Ollama — להתקין מודלים כמו Llama 3, Mistral או Phi-3 על המחשב האישי ולהריץ אותם בחינם. הביצועים יהיו נמוכים יותר ממודלים מסחריים, אבל לפרויקטים של למידה ולמשימות פשוטות זה עובד מצוין. ב-LangChain פשוט מחליפים את ChatOpenAI ב-ChatOllama.

אילו משימות סוכן AI יכול לבצע טוב ואילו לא?

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

איך מונעים מהסוכן לעשות טעויות קריטיות?

שלוש שכבות הגנה: ראשית, הגבלת הרשאות — הסוכן לא יכול למחוק, לשלוח מיילים, או לגשת למערכות קריטיות בלי אישור. שנית, human-in-the-loop — לפני פעולות הרסניות הסוכן מבקש אישור מאדם. שלישית, sandbox — בפיתוח ובטסטים הסוכן רץ בסביבה מבודדת שבה טעויות לא גורמות נזק אמיתי.

כמה ידע ב-Python צריך כדי לבנות סוכן AI?

ידע ברמת ביניים מספיק. צריך להכיר: פונקציות ו-decorators, עבודה עם מילונים ורשימות, async/await ברמה בסיסית, התקנת ספריות עם pip, ועבודה עם משתני סביבה. לא צריך ידע בלמידה עמוקה או מתמטיקה מתקדמת — הפריימוורקים מסתירים את המורכבות.

מה עדיף — סוכן יחיד חזק או כמה סוכנים שעובדים יחד?

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

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

מקורות לימוד מומלצים

• קורסים: מסלול קורס AI Engineer המעניק הבנה מעמיקה בבנייה ואימון של מודלים למידת מכונה ולמידה עמוקה (Deep Learning), עבודה עם ארכיטקטורות Transformer, פיתוח אפליקציות מבוססות LLM (כמו RAG ו-Agents), ופריסת מודלים בסביבות ייצור (MLOps).

• בלוגים / פורומים: Hugging Face Blog, Distill.pub, OpenAI Research, Towards Data Science (Medium), Reddit (r/MachineLearning, r/LocalLLaMA).

• ספרים: Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow (של Aurélien Géron), Designing Machine Learning Systems (של Chip Huyen).

• קורס סייבר ואבטחת מידע
• קורס Real Time Embedded
• קורס דאטה סיינס
• קורס למידת מכונה AI
• קורס דאטה אנליסט
• קורס DEVOPS
• קורס IT
• קורס אוטומציה
• קורס Full Stack
• קורס בניית אתרים