פריסת מודלים פתוחים ב-GKE

1. מבוא

סקירה כללית

המטרה של שיעור ה-Lab הזה היא לספק לכם ניסיון מעשי בפריסת מודל פתוח ב-Google Cloud, החל מהגדרה מקומית פשוטה ועד לפריסה ברמת ייצור ב-Google Kubernetes Engine‏ (GKE). תלמדו איך להשתמש בכלים שונים שמתאימים לכל שלב במחזור החיים של הפיתוח.

השיעור הזה מתבסס על השלבים הבאים:

  • יצירת אב טיפוס מהירה: קודם תריצו מודל עם Ollama באופן מקומי כדי לראות כמה קל להתחיל.
  • פריסה בסביבת ייצור: לבסוף, תפרסו את המודל ב-GKE Autopilot באמצעות Ollama כמנוע הגשה שניתן להתאמה לעומס.

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

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

השקיפות הזו מציעה כמה יתרונות לעומת מודלים סגורים, שבדרך כלל אפשר לגשת אליהם רק דרך API מגביל:

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

התרומה של Google ומשפחת Gemma

‫Google תורמת כבר הרבה שנים לקידום השימוש ב-AI בקוד פתוח. ארכיטקטורת הטרנספורמרים המהפכנית, שהוצגה במאמר "Attention Is All You Need" משנת 2017, היא הבסיס לרוב מודלי השפה הגדולים המודרניים. אחריו הגיעו מודלים פורצי דרך כמו BERT,‏ T5 ו-Flan-T5 שעברו כוונון לפי הוראות, וכל אחד מהם הרחיב את גבולות האפשרויות והניע מחקר ופיתוח ברחבי העולם.

על בסיס ההיסטוריה העשירה הזו של חדשנות פתוחה, Google הציגה את משפחת המודלים Gemma. מודלים של Gemma נוצרים על בסיס אותם מחקרים וטכנולוגיות שמשמשים ליצירת המודלים המתקדמים של Gemini בקוד סגור, אבל הם זמינים עם משקלים פתוחים. לקוחות Google Cloud נהנים משילוב עוצמתי של טכנולוגיה מתקדמת וגמישות של קוד פתוח, שמאפשר להם לשלוט במחזור החיים של המודל, להשתלב עם מערכת אקולוגית מגוונת וליישם אסטרטגיית מולטי-קלאוד.

זרקור על Gemma 3

בשיעור ה-Lab הזה נתמקד ב-Gemma 3, הדור האחרון והיכולות ביותר במשפחה הזו. מודלים של Gemma 3 הם קלי משקל אבל המתקדמים ביותר (SOTA), והם מיועדים לפעול ביעילות בכרטיס גרפי יחיד או אפילו במעבד (CPU).

  • ביצועים וגודל: מודלים של Gemma 3 הם קלי משקל אבל מתקדמים, ומיועדים לפעול ביעילות במעבד גרפי יחיד או אפילו במעבד מרכזי. הם מספקים איכות מעולה וביצועים מתקדמים (SOTA) ביחס לגודל שלהם.
  • מודאליות: הם מולטי-מודאליים, כלומר יכולים לעבד קלט של טקסט ותמונות כדי ליצור פלט של טקסט.
  • תכונות עיקריות: ל-Gemma 3 יש חלון הקשר גדול של 128K והיא תומכת ביותר מ-140 שפות.
  • תרחישי שימוש: המודלים האלה מתאימים למגוון משימות, כולל מענה לשאלות, סיכום והסקת מסקנות.

מונחים חשובים

במהלך העבודה עם מודלים פתוחים, תיתקלו בכמה מונחים נפוצים:

  • אימון מוקדם כולל אימון של מודל על מערך נתונים עצום ומגוון כדי ללמוד דפוסי שפה כלליים. המודלים האלה הם בעצם מכונות עוצמתיות להשלמה אוטומטית.
  • כוונון לפי הוראות הוא כוונון עדין של מודל שאומן מראש, כדי לשפר את היכולת שלו לפעול לפי הוראות והנחיות ספציפיות. אלה המודלים ש "יודעים איך לנהל שיחה".
  • וריאציות של מודלים: מודלים פתוחים בדרך כלל מופצים בכמה גדלים (לדוגמה, ל-Gemma 3 יש גרסאות עם פרמטרים של 1B,‏ 4B,‏ 12B ו-27B) ווריאציות, כמו גרסאות שעברו כוונון להוראות (‎-it), גרסאות שאומנו מראש או גרסאות שעברו קוונטיזציה כדי לשפר את היעילות.
  • דרישות משאבים: מודלים גדולים של שפה הם גדולים ודורשים משאבי מחשוב משמעותיים כדי לארח אותם. אפשר להריץ אותם באופן מקומי, אבל פריסה שלהם בענן מספקת ערך משמעותי, במיוחד כשמבצעים אופטימיזציה לביצועים ולגמישות באמצעות כלים כמו Ollama.

למה כדאי להשתמש ב-GKE להצגת מודלים פתוחים?

במעבדה הזו נלמד איך להריץ מודל מקומי פשוט ואיך לבצע פריסה מלאה בסביבת ייצור ב-Google Kubernetes Engine ‏ (GKE). כלים כמו Ollama מצוינים ליצירת אב טיפוס מהיר, אבל בסביבות ייצור יש דרישות מחמירות ש-GKE יכול לעמוד בהן באופן ייחודי.

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

  • ניהול פשוט יותר עם Autopilot: ‏ GKE Autopilot מנהל את התשתית הבסיסית בשבילכם. אתם מתמקדים בהגדרת האפליקציה, ו-Autopilot מקצה משאבים לצמתים ומשנה את גודלם באופן אוטומטי.
  • ביצועים גבוהים ומדרגיות: התמודדות עם תנועה משתנה ותובענית באמצעות התאמה אוטומטית לעומס ב-GKE. כך אפשר לוודא שהאפליקציה יכולה לספק תפוקה גבוהה עם זמן אחזור נמוך, ולהגדיל או להקטין את הקיבולת לפי הצורך.
  • יעילות כלכלית בהיקף גדול: ניהול יעיל של משאבים. אפשר להגדיר את GKE כך שיקטין את עומסי העבודה לאפס כדי להימנע מתשלום על משאבים לא פעילים, ואפשר להשתמש במכונות VM במודל Spot כדי לצמצם משמעותית את העלויות של עומסי עבודה של היקש בלי שמירת מצב.
  • ניידות ומערכת אקולוגית עשירה: כדי להימנע מנעילת ספק, אפשר להשתמש בפריסה ניידת שמבוססת על Kubernetes. בנוסף, GKE מספק גישה למערכת האקולוגית העצומה של Cloud Native ‏ (CNCF) כדי לקבל את הכלים הכי טובים לניטור, לרישום ביומן ולאבטחה.

בקיצור, כדאי לעבור ל-GKE כשאפליקציית ה-AI שלכם מוכנה לייצור ונדרשת פלטפורמה שמותאמת לשינוי גודל, לביצועים ולבגרות תפעולית.

מה תלמדו

בשיעור ה-Lab הזה תלמדו איך לבצע את המשימות הבאות:

  • הפעלה מקומית של מודל בקוד פתוח באמצעות Ollama.
  • פריסת מודל פתוח ב-Google Kubernetes Engine‏ (GKE) Autopilot באמצעות Ollama להצגה.
  • הסבר על המעבר ממסגרות פיתוח מקומיות לארכיטקטורת הגשה ברמת ייצור ב-GKE.

2. הגדרת הפרויקט

חשבון Google

אם אין לכם חשבון Google אישי, אתם צריכים ליצור חשבון Google.

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

כניסה למסוף Google Cloud

נכנסים למסוף Google Cloud באמצעות חשבון Google אישי.

הפעלת חיוב

הגדרה של חשבון לחיוב לשימוש אישי

אם הגדרתם חיוב באמצעות קרדיטים ל-Google Cloud, אתם יכולים לדלג על השלב הזה.

כדי להגדיר חשבון לחיוב לשימוש אישי, עוברים לכאן כדי להפעיל את החיוב ב-Cloud Console.

הערות:

  • העלות של השלמת ה-Lab הזה במשאבי Cloud צריכה להיות פחות מ-1$.
  • כדי למנוע חיובים נוספים, אפשר למחוק את המשאבים לפי השלבים שמפורטים בסוף ה-Lab הזה.
  • משתמשים חדשים זכאים לתקופת ניסיון בחינם בשווי 300$.

יצירת פרויקט (אופציונלי)

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

3. פתיחת Cloud Shell Editor

  1. כדי לעבור ישירות אל Cloud Shell Editor, לוחצים על הקישור הזה.
  2. אם מתבקשים לאשר בשלב כלשהו היום, לוחצים על אישור כדי להמשיך. לוחצים כדי לתת הרשאה ל-Cloud Shell
  3. אם הטרמינל לא מופיע בתחתית המסך, פותחים אותו:
    • לוחצים על הצגה.
    • לוחצים על Terminal (מסוף)פתיחת טרמינל חדש ב-Cloud Shell Editor.
  4. בטרמינל, מגדירים את הפרויקט באמצעות הפקודה הבאה:
    gcloud config set project [PROJECT_ID]
    • דוגמה:
      gcloud config set project lab-project-id-example
    • אם אתם לא זוכרים את מזהה הפרויקט, אתם יכולים להציג רשימה של כל מזהי הפרויקטים באמצעות הפקודה:
      gcloud projects list
      הגדרת מזהה הפרויקט בטרמינל של Cloud Shell Editor
  5. תוצג ההודעה הבאה:
    Updated property [core/project].

4. הפעלת Gemma באמצעות Ollama

המטרה הראשונה שלכם היא להפעיל את Gemma 3 בסביבת פיתוח כמה שיותר מהר. תשתמשו ב-Ollama, כלי שמפשט מאוד את ההרצה של מודלים גדולים של שפה (LLM) באופן מקומי. במשימה הזו נראה לכם את הדרך הכי פשוטה להתחיל להתנסות במודל קוד פתוח.

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

התקנה והרצה של Ollama

עכשיו אפשר להתקין את Ollama, להוריד את מודל Gemma 3 ולקיים איתו אינטראקציה משורת הפקודה.

  1. בטרמינל של Cloud Shell, מורידים ומתקינים את Ollama:
    ‫
    curl -fsSL https://ollama.com/install.sh | sh
    הפקודה הזו מורידה את Ollama, מתקינה אותו ומפעילה את שירות Ollama.
  2. מפעילים את שירות Ollama ברקע:
    ollama serve &
  3. מושכים (מורידים) את המודל Gemma 3 1B באמצעות Ollama:
    ollama pull gemma3:1b
  4. מריצים את המודל באופן מקומי:
    ‫
    ollama run gemma3:1b
    הפקודה ollama run מציגה הנחיה (>>>) לשאילת שאלות את המודל.
  5. בודקים את המודל באמצעות שאלה. לדוגמה, מקלידים Why is the sky blue? ומקישים על Enter. אמורה להתקבל תגובה שדומה לזו:
    >>> Why is the sky blue?
Okay, let's break down why the sky is blue – it's a fascinating phenomenon related to how light interacts with the Earth's atmosphere.
Here's the explanation:

**1. Sunlight and Colors:**

* Sunlight appears white, but it's actually made up of all the colors of the rainbow (red, orange, yellow, green, blue, indigo, and violet).
Think of a prism splitting sunlight.

**2. Rayleigh Scattering:**

* As sunlight enters the Earth's atmosphere...
...
  6. כדי לצאת מההנחיה של Ollama בטרמינל, מקלידים /bye ומקישים על Enter.

שימוש ב-OpenAI SDK עם Ollama

עכשיו, אחרי שהשירות Ollama פועל, אפשר ליצור איתו אינטראקציה באופן פרוגרמטי. תשתמשו ב-OpenAI Python SDK, שתואם ל-API ש-Ollama חושף.

  1. בטרמינל של Cloud Shell, יוצרים סביבה וירטואלית ומפעילים אותה באמצעות uv. כך תוכלו לוודא שיחסי התלות של הפרויקט לא יתנגשו עם Python של המערכת.
    uv venv --python 3.14
source .venv/bin/activate
  2. במסוף, מתקינים את OpenAI SDK:
    uv pip install openai
  3. כדי ליצור קובץ חדש בשם ollama_chat.py, מזינים בטרמינל:
    cloudshell edit ollama_chat.py
  4. מדביקים את קוד Python הבא ב-ollama_chat.py. הקוד הזה שולח בקשה לשרת Ollama המקומי.
    from openai import OpenAI

client = OpenAI(
    base_url = 'http://localhost:11434/v1',
    api_key='ollama', # required by OpenAI SDK, but not used by Ollama
)

response = client.chat.completions.create(
    model="gemma3:1b",
    messages=[
        {
            "role": "user",
            "content": "Why is the sky blue?"
        },
    ],
)
print(response.choices[0].message.content)
  5. מריצים את הסקריפט במסוף:
    python3 ollama_chat.py
    אחרי כמה שניות, תופיע תגובה דומה לזו שקיבלתם משורת הפקודה.
  6. כדי לנסות את מצב הסטרימינג, יוצרים קובץ נוסף בשם ollama_stream.py על ידי הרצת הפקודה הבאה בטרמינל:
    cloudshell edit ollama_stream.py
  7. מדביקים את התוכן הבא לקובץ ollama_stream.py. שימו לב לפרמטר stream=True בבקשה. כך המודל יכול להחזיר טוקנים ברגע שהם נוצרים.
    from openai import OpenAI

client = OpenAI(
    base_url = 'http://localhost:11434/v1',
    api_key='ollama',
)

stream = client.chat.completions.create(
    model="gemma3:1b",
    messages=[
        {
            "role": "user",
            "content": "Why is the sky blue?"
        },
    ],
    stream=True
)
for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="", flush=True)
print()
  8. מריצים את סקריפט הסטרימינג בטרמינל:
    python3 ollama_stream.py
    התשובה תופיע עכשיו טוקן אחרי טוקן.

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

מה למדתם: הפעלת מודלים פתוחים באמצעות Ollama

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

5. פריסת Gemma עם Ollama ב-GKE Autopilot

לסביבות עבודה של ייצור שדורשות פעולות פשוטות ומדרגיות, Google Kubernetes Engine‏ (GKE) היא הפלטפורמה המומלצת. במשימה הזו תפרסו את Gemma באמצעות Ollama באשכול GKE Autopilot.

GKE Autopilot הוא מצב פעולה ב-GKE שבו Google מנהלת את תצורת האשכול, כולל הצמתים, ההרחבה, האבטחה והגדרות אחרות שהוגדרו מראש. הוא יוצר חוויית Kubernetes שהיא באמת 'בלי שרת (serverless)', ומושלמת להרצת עומסי עבודה (workload) של היקש בלי לנהל את משאבי המחשוב הבסיסיים.

הכנת סביבת GKE

במשימה האחרונה של הפריסה ב-Kubernetes, תספקו אשכול GKE Autopilot.

  1. בטרמינל של Cloud Shell, מגדירים משתני סביבה לפרויקט ולאזור הרצוי.
    export PROJECT_ID=$(gcloud config get-value project)
export REGION=europe-west1

gcloud config set compute/region $REGION
  2. כדי להפעיל את GKE API בפרויקט, מריצים את הפקודה הבאה בטרמינל:
    gcloud services enable container.googleapis.com
  3. יוצרים אשכול GKE Autopilot על ידי הפעלת הפקודה הבאה במסוף: 
    gcloud container clusters create-auto gemma-cluster \
  --region $REGION \
  --release-channel rapid
  4. כדי לקבל את פרטי הכניסה לאשכול החדש, מריצים את הפקודה הבאה בטרמינל:
    gcloud container clusters get-credentials gemma-cluster \
  --region $REGION

פריסת Ollama ו-Gemma

עכשיו שיש לכם אשכול GKE Autopilot, אתם יכולים לפרוס את שרת Ollama. התכונה Autopilot תספק באופן אוטומטי משאבי מחשוב (CPU וזיכרון) על סמך הדרישות שאתם מגדירים במניפסט הפריסה.

  1. כדי ליצור קובץ חדש בשם gemma-deployment.yaml, מריצים את הפקודה הבאה בטרמינל:
    cloudshell edit gemma-deployment.yaml
  2. מדביקים את הגדרת ה-YAML הבאה ב-gemma-deployment.yaml. ההגדרה הזו מגדירה פריסה שמשתמשת בתמונת Ollama הרשמית כדי לפעול במעבד.
    apiVersion: apps/v1
kind: Deployment
metadata:
  name: ollama-gemma
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ollama-gemma
  template:
    metadata:
      labels:
        app: ollama-gemma
    spec:
      containers:
      - name: ollama-gemma-container
        image: ollama/ollama:0.12.10
        resources:
          requests:
            cpu: "8"
            memory: "8Gi"
            ephemeral-storage: "10Gi"
          limits:
            cpu: "8"
            memory: "8Gi"
            ephemeral-storage: "10Gi"
        # We use a script to start the server and pull the model
        command: ["/bin/bash", "-c"]
        args:
        - |
          ollama serve &
          OLLAMA_PID=$!
          echo "Waiting for Ollama server to start..."
          sleep 5
          echo "Pulling Gemma model..."
          ollama pull gemma3:1b
          echo "Model pulled. Ready to serve."
          wait $OLLAMA_PID
        ports:
        - containerPort: 11434
        env:
        - name: OLLAMA_HOST
          value: "0.0.0.0"
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: ollama-gemma
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 11434
    הסבר על ההגדרה של Autopilot:
    • image: ollama/ollama:latest: כאן מצוין קובץ אימג' של Docker הרשמי של Ollama.
    • ‫resources: אנחנו מבקשים במפורש 8 מעבדי vCPU ו-8Gi של זיכרון. מצב GKE Autopilot משתמש בערכים האלה כדי להקצות את המחשוב הבסיסי. מכיוון שאנחנו לא משתמשים ב-GPU, המודל יפעל ב-CPU. זיכרון בנפח 8Gi מספיק כדי להכיל את מודל Gemma 1B ואת ההקשר שלו.
    • ‫command/args: אנחנו מבטלים את הפקודה להפעלה כדי לוודא שהמודל נשלף כשה-Pod מתחיל לפעול. הסקריפט מפעיל את השרת ברקע, ממתין עד שהוא יהיה מוכן, מושך את מודל gemma3:1b ואז משאיר את השרת פועל.
    • ‫OLLAMA_HOST: אם מגדירים את הערך הזה ל-0.0.0.0,‏ Ollama מאזין לכל ממשקי הרשת בקונטיינר, כך שניתן לגשת אליו דרך Kubernetes Service.
  3. בטרמינל, מחילים את מניפסט הפריסה על האשכול:
    kubectl apply -f gemma-deployment.yaml
    יחלפו כמה דקות עד שהמשאבים יוקצו על ידי Autopilot והפוד יתחיל לפעול. אפשר לעקוב אחריו באמצעות:
    ‫
    kubectl get pods --watch
    לפני שממשיכים, צריך להמתין עד שהסטטוס של ה-pod יהיה Running והסטטוס של READY יהיה 1/1.

בדיקת נקודת הקצה של GKE

שירות Ollama פועל עכשיו באשכול GKE Autopilot. כדי לבדוק את זה מהטרמינל של Cloud Shell, משתמשים ב-kubectl port-forward.

  1. פותחים כרטיסייה של טרמינל חדש ב-Cloud Shell (לוחצים על הסמל + בחלון הטרמינל). הפקודה port-forward היא תהליך חסימה, ולכן היא צריכה סשן טרמינל משלה.
  2. במסוף החדש, מריצים את הפקודה הבאה כדי להעביר יציאה מקומית (למשל, 8000) ליציאה של השירות (8000):
    kubectl port-forward service/llm-service 8000:8000
    יוצג פלט שמציין שההעברה התחילה. משאירים את הטרמינל הזה פועל.
  3. חוזרים אל הטרמינל המקורי.
  4. שולחים בקשה לניוד אל 8000. שרת Ollama חושף API שתואם ל-OpenAI, ובגלל העברת הפורט, עכשיו אפשר לגשת אליו בכתובת http://127.0.0.1:8000.
    ‫
    curl http://127.0.0.1:8000/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "gemma3:1b",
"messages": [
{"role": "user", "content": "Explain why the sky is blue."}
]
}'
    השירות יחזיר תגובת JSON עם ההשלמה של המודל.

6. ניקוי תלונות

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

  1. בטרמינל של Cloud Shell, מוחקים את אשכול GKE Autopilot:
    ‫
    gcloud container clusters delete gemma-cluster \
  --region $REGION --quiet
    הפקודה הזו תסיר את האשכול ואת כל המשאבים שמשויכים אליו.

7. סיכום

מעולה! בשיעור ה-Lab הזה למדתם על כמה שיטות מרכזיות לפריסת מודלים פתוחים ב-Google Cloud. התחלתם עם הפשטות והמהירות של פיתוח מקומי באמצעות Ollama. לבסוף, פרסתם את Gemma בסביבה ניתנת להרחבה ברמת ייצור באמצעות Google Kubernetes Engine Autopilot ו-Ollama framework.

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

Recap

בשיעור ה-Lab הזה למדתם:

  • מהם מודלים פתוחים ולמה הם חשובים.
  • איך מריצים מודל בקוד פתוח באופן מקומי באמצעות Ollama.
  • איך פורסים מודל פתוח ב-Google Kubernetes Engine ‏ (GKE) Autopilot באמצעות Ollama להסקת מסקנות.

מידע נוסף