כמה RAM אני צריך כדי להריץ את Gemma 4 באופן מקומי?

המודלים Gemma 4 E2B ו-E4B פועלים על החל מ-5GB RAM עם 4-bit quantization — כל מחשב נייד מודרני מתאים. מודל 26B MoE דורש בערך 18GB RAM (נכנס לתוך 24GB VRAM של RTX 4090). מודל 31B Dense דורש בערך 20GB RAM. עבור הרצה מבוססת CPU בלבד, יש להוסיף 20-30% יותר RAM ממשקל המודל.

באיזה מודל Gemma 4 כדאי לי לבחור לשימוש מקומי?

עבור מחשבים ניידים ללא GPU ייעודי: E2B (המהיר והקל ביותר). עבור מחשבים ניידים עם GPU או מחשבים נייחים: E4B (איכות טובה יותר, עדיין קל משקל). עבור מחשבים נייחים עם RTX 4090 או מקביל לו: 26B MoE (יחס האיכות-חישוב הטוב ביותר). עבור תחנות עבודה עם 24GB+ VRAM: ‏31B Dense (האיכות הגבוהה ביותר). ה-26B MoE הוא ה-"sweet spot" עבור רוב המפתחים.

האם Gemma 4 חינמי לשימוש מקומי?

כן. Gemma 4 שוחרר תחת רישיון Apache 2.0, המאפשר שימוש ללא הגבלה כולל יישומים מסחריים. Ollama היא גם חינמית ובקוד פתוח. העלות היחידה היא החומרה שלך. אין דמי שימוש ב-API, אין מגבלות שימוש ואין הגבלות רישיון.

כמה מהיר Gemma 4 באופן מקומי בהשוואה ל-cloud APIs?

ב-RTX 4090, ה-Gemma 4 E4B מייצר 80-120 tokens לשנייה. ה-26B MoE מייצר 30-50 tokens/sec. ה-31B Dense מייצר 20-35 tokens/sec. cloud APIs כמו Google AI Studio עשויים להיות מהירים יותר עבור המודלים הגדולים ביותר אך מוסיפים network latency של 100-500ms לכל בקשה. לשימוש אינטראקטיבי, local inference במודלים הקטנים יותר מרגיש מיידי.

האם אוכל להשתמש ב-Gemma 4 באופן מקומי כ-API עבור האפליקציות שלי?

כן. Ollama חושפת REST API מקומי בפורט 11434 התואם לפורמט של OpenAI API. כל אפליקציה, framework או כלי התומך ב-OpenAI API יכול להתחבר ל-Gemma 4 המקומי על ידי הפניית ה-base URL אל http://localhost:11434/v1. זה כולל את Python, Node.js ורוב ה-AI frameworks.

האם Gemma 4 תומך בהאצת GPU עם Ollama?

כן. Ollama מזהה ומשתמשת באופן אוטומטי ב-NVIDIA GPUs (CUDA), Apple Silicon (Metal) ו-AMD GPUs (ROCm). אין צורך בהגדרה נוספת — אם ל-GPU שלך יש מספיק VRAM כדי להכיל את המודל, Ollama תשתמש בו אוטומטית. NVIDIA שחררה גם גרסאות RTX-optimized של Gemma 4 לשיפורי ביצועים נוספים.

נקודות מפתח

הרצה של Gemma 4 באופן מקומי לוקחת פחות מ-5 דקות עם Ollama: התקן את Ollama, הרץ פקודה אחת, ויש לך מודל AI בעל יכולות מלאות שרץ על החומרה שלך עם 0 עלויות API, 0 נתונים שעוזבים את המכונה שלך, ו-0 הגבלות שימוש תחת Apache 2.0. המודל E2B רץ על כל מחשב נייד. מודל ה-26B MoE מתאים ל-RTX 4090 יחיד ומספק איכות שמתחרה במודלים עם פי 10 מכמות ה-active parameter שלו.

הריצו את Gemma 4 באופן מקומי: המדריך המלא

למה להריץ את Gemma 4 באופן מקומי?

לפני שצוללים להגדרה, הנה הסיבות לכך ש-local inference חשוב בשנת 2026:

פרטיות — הנתונים שלך לעולם לא עוזבים את המכונה שלך. אף פרומפט לא נשלח לשרתים חיצוניים. קריטי עבור קוד קנייני, מסמכים משפטיים, נתונים רפואיים או כל מידע רגיש אחר.
עלות — 0 עלות לכל token לאחר ההשקעה החד-פעמית בחומרה. משתמשים כבדים חוסכים מאות דולרים בחודש בהשוואה לתמחור API.
Latency — אין סבבי תקשורת ברשת. מודלי ה-E2B וה-E4B מגיבים במילי-שניות על חומרה מודרנית.
אמינות — אין API rate limits, אין הפסקות שירות, אין שינויי מדיניות של ספקים. המודל שלך תמיד זמין.
התאמה אישית — בצעו fine-tune, quantization ושנו את המודל בחופשיות תחת Apache 2.0.
גישה לא מקוונת — עובד ללא חיבור לאינטרנט לאחר הורדת המודל.

Gemma 4 מתאים במיוחד לפריסה מקומית מכיוון ש-Google עיצבה את המודלים הקטנים יותר במיוחד לשימוש ב-edge ועל גבי מכשירים. מודלי ה-E2B וה-E4B אינם מחשבה משנית — הם מודלים מהשורה הראשונה המותאמים למגבלות של חומרה מקומית.

דרישות קדם

דרישות חומרה לפי מודל

מודל	RAM מינימלי	VRAM מומלץ	אפשרי לשימוש עם CPU בלבד?	שטח דיסק
E2B (4-bit)	5 GB	4 GB	כן	~1.5 GB
E4B (4-bit)	5 GB	4 GB	כן	~2.8 GB
E4B (FP16)	9 GB	9 GB	איטי	~9 GB
26B MoE (4-bit)	18 GB	16 GB	איטי מאוד	~15 GB
26B MoE (FP16)	52 GB	48 GB	לא	~52 GB
31B Dense (4-bit)	20 GB	18 GB	איטי מאוד	~18 GB
31B Dense (FP16)	62 GB	48 GB+	לא	~62 GB

תובנה מרכזית: אם יש לך מחשב נייד שיוצר לאחר 2022, תוכל להריץ את E2B או E4B. אם יש לך RTX 4090 (24GB VRAM) או Apple M-series Mac עם 32GB+ RAM, תוכל להריץ את ה-26B MoE או 31B Dense ב-4-bit quantization.

דרישות תוכנה

מערכת הפעלה: macOS, Linux, או Windows
Ollama: גרסה 0.6+ (הורדה מ-ollama.com)
GPU drivers (אופציונלי): NVIDIA CUDA 12+ עבור NVIDIA GPUs, אין צורך בדרייברים נוספים עבור Apple Silicon

שלב 1: התקנת Ollama

macOS

הורד מ-ollama.com/download או השתמש ב-Homebrew:

brew install ollama

Linux

סקריפט התקנה בשורה אחת:

curl -fsSL https://ollama.com/install.sh | sh

Windows

הורד את המתקין מ-ollama.com/download והרץ אותו. Ollama רץ כשירות רקע ב-Windows.

אימות התקנה

ollama --version

אתה אמור לראות ollama version 0.6.x או גבוה יותר. אם אתה רואה מספר גרסה, Ollama הותקן כהלכה.

מקור: מדריך התקנה של Ollama

שלב 2: משיכת מודל Gemma 4

בחר את המודל המתאים לחומרה שלך:

עבור מחשבים ניידים ועומסי עבודה קלים

# המודל הקטן ביותר — רץ על כל מחשב נייד מודרני (5GB RAM)
ollama pull gemma4:e2b

# מודל קטן עם יכולות רחבות יותר (5-9GB RAM)
ollama pull gemma4:e4b

עבור מחשבים נייחים עם GPU ייעודי

# היעילות הטובה ביותר — איכות דגל ב-3.8B active params (18GB RAM)
ollama pull gemma4:26b-moe

# האיכות הגבוהה ביותר — מודל 31B parameters מלא (20GB RAM)
ollama pull gemma4:31b

הגדרת Quantization

כברירת מחדל, Ollama מושך את ה-quantization המומלץ עבור כל מודל (בדרך כלל Q4_K_M לאיזון טוב בין איכות לגודל). ניתן לציין quantizations שונים:

# איכות גבוהה יותר, גודל גדול יותר
ollama pull gemma4:31b-q5_K_M

# גודל קטן יותר, איכות מעט נמוכה יותר
ollama pull gemma4:31b-q3_K_M

# דיוק מלא (דורש הרבה יותר RAM)
ollama pull gemma4:31b-fp16

ההורדה תיקח מספר דקות בהתאם לחיבור האינטרנט שלך. גדלי המודלים נעים בין ~1.5GB (E2B 4-bit) ל-~62GB (31B FP16).

שלב 3: הרצת Gemma 4

צ'אט אינטראקטיבי

ollama run gemma4:e4b

זה יפתח סשן צ'אט אינטראקטיבי. הקלד את הפרומפט שלך ולחץ Enter:

>>> What are the key differences between REST and GraphQL APIs?

המודל יגיב ישירות ב-terminal שלך. הקלד /bye כדי לצאת.

פרומפט בודד (לא אינטראקטיבי)

echo "Explain the Builder design pattern in Python with an example" | ollama run gemma4:26b-moe

עם מצב חשיבה (Thinking Mode)

Gemma 4 תומך ב-thinking mode הניתן להגדרה עבור משימות מורכבות. הפעל אותו על ידי הוספת system prompt:

ollama run gemma4:31b --system "Think step by step before answering. Show your reasoning process."

עבור משימות מתמטיקה, לוגיקה וניתוח מורכב, ה-thinking mode משפר משמעותית את איכות התשובה. המודל ייצור 4,000+ tokens של חשיבה פנימית לפני הפקת התגובה הסופית שלו.

שלב 4: שימוש ב-API המקומי

Ollama חושף REST API בכתובת localhost:11434 התואם לפורמט של OpenAI API. זה אומר שכל כלי או ספרייה שתומכים ב-OpenAI API יכולים להתחבר ל-Gemma 4 המקומי שלך באמצעות שינוי URL פשוט.

בדיקת ה-API עם curl

curl http://localhost:11434/api/generate -d '{
  "model": "gemma4:26b-moe",
  "prompt": "Write a Python function to parse CSV files with error handling",
  "stream": false
}'

Endpoint תואם OpenAI

curl http://localhost:11434/v1/chat/completions -d '{
  "model": "gemma4:26b-moe",
  "messages": [
    {"role": "user", "content": "Explain async/await in JavaScript"}
  ]
}'

מקור: תיעוד API של Ollama

שלב 5: אינטגרציה עם האפליקציה שלך

Python

import requests

def ask_gemma(prompt, model="gemma4:26b-moe"):
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "stream": False
        }
    )
    return response.json()["response"]

# Usage
answer = ask_gemma("What is the time complexity of merge sort?")
print(answer)

Python עם OpenAI SDK

from openai import OpenAI

# Point to local Ollama instead of OpenAI
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # Ollama doesn't require a real API key
)

response = client.chat.completions.create(
    model="gemma4:26b-moe",
    messages=[
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Write a React hook for debounced search"}
    ]
)
print(response.choices[0].message.content)

Node.js / TypeScript

const response = await fetch("http://localhost:11434/v1/chat/completions", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "gemma4:26b-moe",
    messages: [
      { role: "user", content: "Explain the Observer pattern with a TypeScript example" }
    ]
  })
});

const data = await response.json();
console.log(data.choices[0].message.content);

שימוש עם LangChain

from langchain_community.llms import Ollama

llm = Ollama(model="gemma4:26b-moe")
response = llm.invoke("Summarize the key principles of clean architecture")
print(response)

שימוש עם LlamaIndex

from llama_index.llms.ollama import Ollama

llm = Ollama(model="gemma4:26b-moe", request_timeout=120.0)
response = llm.complete("What are the SOLID principles in software engineering?")
print(response)

הסבר על אפשרויות Quantization

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

Quantization	ביטים לכל משקולת	השפעה על האיכות	חיסכון בזיכרון	הכי מתאים ל-
FP16	16 bits	ללא (איכות מלאה)	בסיס	שרתים עם שפע VRAM
Q8_0	8 bits	זניחה	~50%	Inference מקומי באיכות גבוהה
Q6_K	6 bits	מינורית מאוד	~62%	שימוש מקומי ממוקד איכות
Q5_K_M	5 bits	מינורית	~69%	איזון טוב
Q4_K_M	4 bits	קטנה	~75%	ברירת מחדל מומלצת
Q3_K_M	3 bits	בינונית	~81%	חומרה מוגבלת
Q2_K	2 bits	משמעותית	~87%	הגבלות קיצוניות

Q4_K_M הוא ה-sweet spot עבור רוב המשתמשים. ההבדל באיכות לעומת FP16 הוא קטן מספיק כך שרוב המשימות מייצרות תוצאות בלתי ניתנות להבחנה, בעוד שחיסכון בזיכרון של 75% עושה את ההבדל בין "זקוק לשרת" לבין "רץ על המחשב הנייד שלי".

בחירת ה-Quantization הנכון

עבור Gemma 4 E2B/E4B: השתמש בברירת המחדל (Q4_K_M). המודלים האלו כבר קטנים מספיק כך ש-quantization גבוה יותר לא משנה משמעותית את חווית המשתמש.

עבור Gemma 4 26B MoE: ה-Q4_K_M מתאים ל-18GB RAM, מה שנמצא בתוך ה-24GB VRAM של RTX 4090 עם מקום ל-KV cache. אם יש לך 48GB+ VRAM (כמו A6000 או dual GPUs), שקול להשתמש ב-Q8_0 לאיכות טובה במעט.

עבור Gemma 4 31B Dense: ה-Q4_K_M בנפח 20GB מתאים ל-RTX 4090 עם שוליים צפופים. Q5_K_M מייצר תוצאות מעט טובות יותר אך דורש ~24GB, מה שצורך את כל ה-VRAM הזמין. אם יש לך 32GB+ VRAM (כמו RTX 5090, A6000), ה-Q6_K או Q8_0 שווים את השדרוג.

כוונון ביצועים

העברה ל-GPU (GPU Offloading)

Ollama מעביר אוטומטית שכבות מודל ל-GPU כאשר VRAM זמין. אם רק חלק מהמודל מתאים ל-VRAM, Ollama מפצל בין GPU ל-CPU. ניתן לשלוט בזה:

# אילוץ כל השכבות ל-GPU (נכשל אם אין מספיק VRAM)
OLLAMA_NUM_GPU=999 ollama run gemma4:26b-moe

# אילוץ CPU בלבד (שימושי לבדיקות)
OLLAMA_NUM_GPU=0 ollama run gemma4:e4b

הגדרת Context Window

כברירת מחדל, Ollama משתמש ב-context window של 2048 tokens ליעילות. כדי לנצל את יכולות ה-context המלאות של Gemma 4:

# הגדרת context window ל-32K tokens
ollama run gemma4:26b-moe --num-ctx 32768

# הגדרת context window ל-128K tokens (דורש יותר RAM)
ollama run gemma4:26b-moe --num-ctx 131072

חשוב: context windows גדולים יותר צורכים יותר RAM עבור ה-KV cache. context window של 128K במודל 31B עשוי לדרוש 8-16GB RAM נוספים מעבר למשקולות המודל. התחל עם 32K והגדל רק אם מקרה הבוחן שלך דורש זאת.

בקשות בו-זמניות

Ollama תומך בהגשת מספר בקשות בו-זמנית:

# אפשור עד 4 בקשות בו-זמניות
OLLAMA_NUM_PARALLEL=4 ollama serve

כל בקשה בו-זמנית מוסיפה תקורה של זיכרון עבור ה-KV cache שלה. ב-GPU של 24GB המריץ את ה-26B MoE ב-Q4_K_M (~18GB), יש לך בערך 6GB מרחב — מספיק עבור 2-3 בקשות בו-זמניות עם contexts קצרים.

הגדרות Keep-Alive

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

# שמירת המודל טעון למשך שעה אחת
OLLAMA_KEEP_ALIVE=3600 ollama serve

# שמירת המודל טעון ללא הגבלה
OLLAMA_KEEP_ALIVE=-1 ollama serve

# פריקה מיידית לאחר כל בקשה (חוסך זיכרון)
OLLAMA_KEEP_ALIVE=0 ollama serve

אופטימיזציה ל-NVIDIA RTX

NVIDIA שחררה גרסאות מותאמות של Gemma 4 עבור RTX GPUs. אופטימיזציות אלו כוללות:

Custom CUDA kernels עבור מנגנון ה-attention של Gemma 4
אינטגרציה עם TensorRT-LLM ל-inference מהיר יותר
תמיכה ב-Flash Attention להפחתת השימוש בזיכרון במהלך long-context inference
ניהול KV cache מותאם עבור throughput טוב יותר

התקנת Gemma 4 מותאם ל-NVIDIA

אם יש לך GPU מסדרת RTX 4000 או 5000:

# בדוק את ה-GPU שלך
nvidia-smi

# משוך את הגרסה המותאמת ל-NVIDIA (אם זמינה ב-Ollama)
ollama pull gemma4:31b-nvidia

לחלופין, השתמש ב-NVIDIA AI Workbench או ב-TensorRT-LLM ישירות לביצועים מקסימליים. הגרסאות המותאמות ל-NVIDIA יכולות לספק inference מהיר ב-30-50% ב-RTX GPUs בהשוואה לגרסאות Ollama סטנדרטיות.

מבחני ביצועים (Benchmarks) מהעולם האמיתי

נמדד על תצורות חומרה נפוצות:

Tokens per Second (מהירות יצירה)

מודל	RTX 4090 (24GB)	RTX 3090 (24GB)	M3 Max (36GB)	CPU בלבד (32GB)
E2B (Q4)	~150 tok/s	~120 tok/s	~100 tok/s	~30 tok/s
E4B (Q4)	~100 tok/s	~80 tok/s	~70 tok/s	~15 tok/s
26B MoE (Q4)	~40 tok/s	~30 tok/s	~25 tok/s	~3 tok/s
31B Dense (Q4)	~30 tok/s	~20 tok/s	~20 tok/s	~2 tok/s

הקשר: מהירות קריאה אנושית היא בערך 4-5 tokens לשנייה. כל מודל שיוצר מעל 10 tok/s מרגיש "מיידי" לשימוש אינטראקטיבי. מודלי ה-E2B וה-E4B מהירים מספיק לסטרימינג בזמן אמת כמעט על כל חומרה.

Time to First Token (זמן תגובה/Latency)

מודל	RTX 4090	M3 Max	CPU בלבד
E2B	<100ms	<200ms	<500ms
E4B	<200ms	<300ms	~1s
26B MoE	~500ms	~1s	~5s
31B Dense	~800ms	~1.5s	~8s

עבור אפליקציות אינטראקטיביות, ה-time to first token חשוב יותר ממהירות היצירה הכללית. מודלי ה-E2B וה-E4B מתחילים ליצור כמעט מיידית אפילו ב-CPU, מה שהופך אותם לאידיאליים עבור ממשקי צ'אט בזמן אמת.

מקרים נפוצים לשימוש (Use Cases)

עוזר קוד מקומי

השתמש ב-Gemma 4 כעוזר קוד פרטי שלעולם לא שולח את הקוד שלך לשרתים חיצוניים:

ollama run gemma4:26b-moe --system "You are an expert software engineer. When given code, analyze it for bugs, suggest improvements, and explain your reasoning. Be concise and practical."

חבר זאת לתוספי VS Code כמו Continue או Twinny שתומכים ב-Ollama כ-backend.

ניתוח מסמכים

עבד מסמכים רגישים באופן מקומי:

echo "Analyze this contract clause and identify potential risks: [paste clause]" | ollama run gemma4:31b

עם context של 256K, מודל ה-31B יכול לעבד מסמכים של עד ~750 דפים — מספיק לרוב החוזים, מאמרי מחקר ותיעוד טכני.

RAG מקומי (Retrieval-Augmented Generation)

שלב את Gemma 4 עם vector database מקומי למערכת RAG פרטית לחלוטין:

from langchain_community.llms import Ollama
from langchain_community.embeddings import OllamaEmbeddings
from langchain_community.vectorstores import Chroma

# Use Gemma 4 for both embeddings and generation
embeddings = OllamaEmbeddings(model="gemma4:e4b")
llm = Ollama(model="gemma4:26b-moe")

# Create vector store from your documents
vectorstore = Chroma.from_documents(documents, embeddings)

# Query with RAG
retriever = vectorstore.as_retriever()
docs = retriever.get_relevant_documents("What is our refund policy?")
context = "\n".join([doc.page_content for doc in docs])
response = llm.invoke(f"Based on this context:\n{context}\n\nAnswer: What is our refund policy?")

בניית יכולות AI לתוך אפליקציות

עבור מפתחים הבונים אפליקציות עם יכולות AI, הרצת Gemma 4 באופן מקומי דרך ה-API של Ollama היא הדרך המהירה ביותר לאב-טיפוס עובד. ה-API התואם ל-OpenAI אומר שניתן להתחיל עם Gemma 4 מקומי לפיתוח ולעבור ל-cloud APIs לייצור מבלי לשנות את קוד האפליקציה.

פלטפורמות כמו ZBuild יכולות לטפל בתשתית האפליקציה — frontend, backend, אימות, בסיס נתונים — בזמן שאתה מתמקד בשכבת האינטגרציה של ה-AI. כוון את ה-AI endpoint של האפליקציה שלך ל-localhost:11434 במהלך הפיתוח והחלף אותו ל-endpoint בענן כשתהיה מוכן לגדול.

פתרון בעיות (Troubleshooting)

שגיאות "Out of memory"

אם אתה רואה שגיאות זיכרון:

נסה quantization קטן יותר: ollama pull gemma4:31b-q3_K_M
צמצם את ה-context window: --num-ctx 4096
סגור אפליקציות אחרות הצורכות משאבי GPU
עבור למודל קטן יותר: ה-26B MoE מספק איכות קרובה ל-31B בעלות זיכרון נמוכה יותר

מהירות יצירה איטית

אם היצירה איטית מהצפוי:

בדוק את ניצול ה-GPU: nvidia-smi (אמור להראות שימוש גבוה ב-GPU)
ודא שהמודל נכנס במלואו ל-VRAM — העברה חלקית ל-CPU איטית משמעותית
צמצם את --num-ctx כדי לפנות VRAM לחישוב
בדוק אם תהליכים אחרים משתמשים ב-GPU

מודל לא נמצא

אם ollama run gemma4:26b-moe נכשל:

# הצגת רשימת מודלים זמינים
ollama list

# חיפוש מודלי Gemma 4
ollama search gemma4

# משיכת המודל הספציפי
ollama pull gemma4:26b-moe

API Connection Refused

אם אפליקציות לא מצליחות להתחבר ל-localhost:11434:

# בדוק אם Ollama רץ
ollama list

# הפעל את שרת Ollama ידנית
ollama serve

# בדוק את הפורט
curl http://localhost:11434/api/tags

עץ החלטות לבחירת מודל

השתמש בזה כדי לבחור במהירות את המודל הנכון:

האם יש לך GPU ייעודי עם 16GB+ VRAM?

כן ← האם אתה רוצה איכות מקסימלית או יעילות מקסימלית?
- איכות מקסימלית ← gemma4:31b (Q4_K_M, דורש 20GB)
- יעילות מקסימלית ← gemma4:26b-moe (Q4_K_M, דורש 18GB)
לא ← האם יש לך 8GB+ RAM?
- כן ← gemma4:e4b (Q4_K_M, איכות טובה יותר)
- לא ← gemma4:e2b (Q4_K_M, רץ על 5GB)

עבור רוב המפתחים עם מחשב נייח מודרני או מחשב גיימינג: התחל עם gemma4:26b-moe. הוא מציע את יחס האיכות-למשאבים הטוב ביותר בכל משפחת Gemma 4.

מה ניתן לבנות

עם Gemma 4 שרץ מקומית, יש לך AI backend ב-0 עלות עבור:

אפליקציות צ'אט עם פרטיות שיחה מלאה
כלי ניתוח קוד שעובדים על קוד קנייני
תהליכי עיבוד מסמכים עבור נתונים רגישים
עוזרי AI מקומיים שעובדים ללא חיבור לאינטרנט
אב-טיפוס של יכולות AI לפני התחייבות לעלויות API בענן
מודלים שעברו Fine-tuning למשימות ספציפיות לתחום (Apache 2.0 מאפשר זאת בחופשיות)

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

הרצת Gemma 4 באופן מקומי ב-5 דקות: מדריך הגדרה מלא ל-Ollama‏ (2026)