Mennyi RAM szükséges a Gemma 4 helyi futtatásához?

A Gemma 4 E2B és E4B akár 5GB RAM-mal is elfut 4-bit quantization mellett — bármely modern laptop megfelel. A 26B MoE modellnek körülbelül 18GB RAM-ra van szüksége (belefér egy RTX 4090 24GB VRAM-jába). A 31B Dense modellnek körülbelül 20GB RAM kell. Csak CPU alapú futtatás esetén adjunk hozzá 20-30%-kal több RAM-ot a modell súlyánál.

Melyik Gemma 4 modellt válasszam helyi használatra?

Dedikált GPU nélküli laptopokhoz: E2B (leggyorsabb, legkönnyebb). GPU-val rendelkező laptopokhoz vagy asztali gépekhez: E4B (jobb minőség, még mindig könnyű). RTX 4090-nel vagy azzal egyenértékűvel rendelkező asztali gépekhez: 26B MoE (legjobb minőség-számítási arány). 24GB+ VRAM-mal rendelkező munkaállomásokhoz: 31B Dense (legmagasabb minőség). A legtöbb fejlesztő számára a 26B MoE az ideális választás.

Ingyenes a Gemma 4 használata helyileg?

Igen. A Gemma 4 Apache 2.0 licenc alatt jelent meg, amely korlátozás nélküli használatot tesz lehetővé, beleértve az üzleti alkalmazásokat is. Az Ollama szintén ingyenes és open source. Az egyetlen költség a hardware. Nincsenek API díjak, nincsenek használati korlátok és nincsenek licencbeli megkötések.

Milyen gyors a Gemma 4 helyileg a felhőalapú API-khoz képest?

RTX 4090-en a Gemma 4 E4B másodpercenként 80-120 tokent generál. A 26B MoE 30-50 tokens/sec-et produkál. A 31B Dense pedig 20-35 tokens/sec-et. A felhőalapú API-k, mint a Google AI Studio, gyorsabbak lehetnek a legnagyobb modellek esetén, de 100-500ms hálózati késleltetést (latency) adnak kérésenként. Interaktív használat esetén a kisebb modellek helyi futtatása (local inference) azonnalinak tűnik.

Használhatom a Gemma 4-et helyileg API-ként az alkalmazásaimhoz?

Igen. Az Ollama egy helyi REST API-t tesz elérhetővé a 11434-es porton, amely kompatibilis az OpenAI API formátumával. Bármely alkalmazás, keretrendszer vagy eszköz, amely támogatja az OpenAI API-t, kapcsolódhat a helyi Gemma 4-hez az alap URL-t a http://localhost:11434/v1 címre irányítva. Ez magában foglalja a Python-t, a Node.js-t és a legtöbb AI keretrendszert.

Támogatja a Gemma 4 a GPU acceleration-t Ollama-val?

Igen. Az Ollama automatikusan felismeri és használja az NVIDIA GPU-kat (CUDA), az Apple Silicon-t (Metal) és az AMD GPU-kat (ROCm). Nincs szükség további konfigurációra — ha a GPU elegendő VRAM-mal rendelkezik a modell tárolásához, az Ollama automatikusan használni fogja. Az NVIDIA RTX-optimalizált verziókat is kiadott a Gemma 4-hez a további teljesítménynövekedés érdekében.

Fő tanulság

A Gemma 4 helyi futtatása kevesebb mint 5 percet vesz igénybe az Ollama segítségével: telepítse az Ollama szoftvert, futtasson egy parancsot, és máris egy teljes értékű AI modellel rendelkezik a saját hardverén, nulla API költséggel, az adatok elszivárgása nélkül, és használati korlátozások nélkül az Apache 2.0 licenc alatt. Az E2B modell bármilyen laptopon fut. A 26B MoE modell elfér egyetlen RTX 4090 kártyán, és olyan minőséget nyújt, amely vetekszik az aktív paraméterszámánál 10-szer nagyobb modellekkel.

A Gemma 4 futtatása helyben: A teljes útmutató

Miért futtassuk a Gemma 4-et helyben?

Mielőtt belevágnánk a beállításba, íme, miért fontos a helyi következtetés (inference) 2026-ban:

Adatvédelem — Az adatai soha nem hagyják el a gépét. Nem küld promptokat külső szerverekre. Ez kritikus fontosságú saját tulajdonú kódok, jogi dokumentumok, orvosi adatok vagy bármilyen érzékeny információ esetén.
Költség — Nulla per-token költség az egyszeri hardverbefektetés után. A rendszeres felhasználók havonta több száz dollárt takaríthatnak meg az API árazáshoz képest.
Késleltetés — Nincsenek hálózati körutak. Az E2B és E4B modellek ezredmásodpercek alatt válaszolnak a modern hardvereken.
Megbízhatóság — Nincsenek API rate limits korlátok, nincsenek leállások, nincsenek szolgáltatói szabályzatváltozások. A modellje mindig elérhető.
Testreszabhatóság — Szabadon finomhangolhatja, kvantálhatja és módosíthatja a modellt az Apache 2.0 licenc alatt.
Offline hozzáférés — A modell letöltése után internetkapcsolat nélkül is működik.

A Gemma 4 különösen alkalmas a helyi telepítésre, mert a Google a kisebb modelleket kifejezetten edge és eszközön belüli használatra tervezte. Az E2B és E4B modellek nem utólagos gondolatok — ezek elsőrangú modellek, amelyeket a helyi hardverek korlátaihoz optimalizáltak.

Előfeltételek

Hardverkövetelmények modellenként

Modell	Minimum RAM	Javasolt VRAM	CPU-val futtatható?	Lemezterület
E2B (4-bit)	5 GB	4 GB	Igen	~1.5 GB
E4B (4-bit)	5 GB	4 GB	Igen	~2.8 GB
E4B (FP16)	9 GB	9 GB	Lassú	~9 GB
26B MoE (4-bit)	18 GB	16 GB	Nagyon lassú	~15 GB
26B MoE (FP16)	52 GB	48 GB	Nem	~52 GB
31B Dense (4-bit)	20 GB	18 GB	Nagyon lassú	~18 GB
31B Dense (FP16)	62 GB	48 GB+	Nem	~62 GB

Fő tanulság: Ha 2022 után készült laptopja van, futtathatja az E2B vagy E4B modellt. Ha RTX 4090 (24GB VRAM) kártyával vagy 32GB+ RAM-mal rendelkező Apple M-szériás Mac-el rendelkezik, futtathatja a 26B MoE vagy 31B Dense modelleket 4-bit kvantálással.

Szoftverkövetelmények

Operációs rendszer: macOS, Linux, vagy Windows
Ollama: 0.6+ verzió (letölthető innen: ollama.com)
GPU illesztőprogramok (opcionális): NVIDIA CUDA 12+ az NVIDIA GPU-khoz, Apple Silicon esetén nincs szükség extra illesztőprogramokra

1. lépés: Az Ollama telepítése

macOS

Töltse le az ollama.com/download oldalról vagy használja a Homebrew-t:

brew install ollama

Linux

Egysoros telepítő szkript:

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

Windows

Töltse le a telepítőt az ollama.com/download oldalról és futtassa. Az Ollama háttérszolgáltatásként fut Windows alatt.

Telepítés ellenőrzése

ollama --version

Látnia kell az ollama version 0.6.x vagy magasabb verziószámot. Ha megjelenik a verziószám, az Ollama megfelelően van telepítve.

Forrás: Ollama telepítési útmutató

2. lépés: A Gemma 4 modell letöltése (Pull)

Válassza ki a hardverének megfelelő modellt:

Laptopokhoz és könnyű munkaterheléshez

# Legkisebb modell — bármilyen modern laptopon fut (5GB RAM)
ollama pull gemma4:e2b

# Kis modell szélesebb képességekkel (5-9GB RAM)
ollama pull gemma4:e4b

Dedikált GPU-val rendelkező asztali gépekhez

# Legjobb hatékonyság — zászlóshajó minőség 3.8B aktív paraméterrel (18GB RAM)
ollama pull gemma4:26b-moe

# Legmagasabb minőség — teljes 31B paraméterszám (20GB RAM)
ollama pull gemma4:31b

Kvantálás megadása

Alapértelmezés szerint az Ollama az egyes modellekhez javasolt kvantálást tölti le (általában Q4_K_M a jó minőség-méret egyensúly érdekében). Megadhat különböző kvantálásokat is:

# Magasabb minőség, nagyobb méret
ollama pull gemma4:31b-q5_K_M

# Kisebb méret, valamivel alacsonyabb minőség
ollama pull gemma4:31b-q3_K_M

# Teljes precizitás (sokkal több RAM-ot igényel)
ollama pull gemma4:31b-fp16

A letöltés az internetkapcsolattól függően néhány percet vesz igénybe. A modellméretek ~1.5GB (E2B 4-bit) és ~62GB (31B FP16) között mozognak.

3. lépés: A Gemma 4 futtatása

Interaktív chat

ollama run gemma4:e4b

Ez megnyit egy interaktív chat munkamenetet. Írja be a promptot és nyomja meg az Entert:

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

A modell közvetlenül a terminálban fog válaszolni. A kilépéshez írja be: /bye.

Egyszeri prompt (nem interaktív)

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

Gondolkodási móddal (Thinking Mode)

A Gemma 4 támogatja a konfigurálható gondolkodási módot az összetett feladatokhoz. Ezt egy rendszer prompt (system prompt) hozzáadásával engedélyezheti:

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

Matematikai, logikai és összetett elemzési feladatok esetén a gondolkodási mód jelentősen javítja a válaszminőséget. A modell több mint 4,000 tokens belső érvelést generál a végső válasz megadása előtt.

4. lépés: A helyi API használata

Az Ollama egy REST API-t tesz közzé a localhost:11434 címen, amely kompatibilis az OpenAI API formátumával. Ez azt jelenti, hogy bármely eszköz vagy könyvtár, amely támogatja az OpenAI API-ját, egy egyszerű URL-módosítással csatlakozhat a helyi Gemma 4 modellhez.

Az API tesztelése curl használatával

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
}'

OpenAI-kompatibilis végpont

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

Forrás: Ollama API dokumentáció

5. lépés: Integráció az alkalmazásába

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"]

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

Python OpenAI SDK-val

from openai import OpenAI

# Kapcsolódás a helyi Ollama-hoz az OpenAI helyett
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # Az Ollama nem igényel valódi API kulcsot
)

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);

Használat LangChain-nel

from langchain_community.llms import Ollama

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

Használat LlamaIndex-szel

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)

Kvantálási lehetőségek magyarázata

A kvantálás csökkenti a modell méretét és memóriahasználatát azáltal, hogy alacsonyabb precizitású számokat használ a modell súlyainak ábrázolásához. A kompromisszum a minőség és az erőforrás-használat között van:

Kvantálás	Bit per súly	Minőségi hatás	Memória megtakarítás	Legjobb felhasználás
FP16	16 bits	Nincs (teljes minőség)	Alapérték	Bőséges VRAM-mal rendelkező szerverek
Q8_0	8 bits	Elhanyagolható	~50%	Magas minőségű helyi következtetés
Q6_K	6 bits	Nagyon csekély	~62%	Minőségközpontú helyi használat
Q5_K_M	5 bits	Csekély	~69%	Jó egyensúly
Q4_K_M	4 bits	Kicsi	~75%	Javasolt alapértelmezés
Q3_K_M	3 bits	Mérsékelt	~81%	Korlátozott hardver
Q2_K	2 bits	Jelentős	~87%	Szélsőséges korlátok

A legtöbb felhasználó számára a Q4_K_M az ideális pont. Az FP16-hoz képest a minőségi különbség elég kicsi ahhoz, hogy a legtöbb feladat megkülönböztethetetlen eredményt adjon, miközben a 75%-os memóriamegtakarítás jelenti a különbséget a "szerver kell hozzá" és a "fut a laptopomon" között.

A megfelelő kvantálás kiválasztása

Gemma 4 E2B/E4B esetén: Használja az alapértelmezettet (Q4_K_M). Ezek a modellek már eleve elég kicsik ahhoz, hogy a magasabb kvantálás ne változtasson érdemben a felhasználói élményen.

Gemma 4 26B MoE esetén: A Q4_K_M elfér 18GB RAM-ban, ami egy RTX 4090 24GB VRAM-ján belül van, helyet hagyva a KV cache-nek is. Ha 48GB+ VRAM-mal rendelkezik (A6000, duális GPU), fontolja meg a Q8_0-at a minimálisan jobb minőség érdekében.

Gemma 4 31B Dense esetén: A Q4_K_M 20GB-on szűkös margóval fér el egy RTX 4090-en. A Q5_K_M valamivel jobb eredményt ad, de ~24GB-ot igényel, ami felemészti az összes elérhető VRAM-ot. Ha 32GB+ VRAM-mal rendelkezik (RTX 5090, A6000), a Q6_K vagy Q8_0 megéri a frissítést.

Teljesítmény optimalizálás

GPU-ra helyezés (GPU Offloading)

Az Ollama automatikusan áthelyezi a modell rétegeit a GPU-ra, ha van elérhető VRAM. Ha a modellnek csak egy része fér el a VRAM-ban, az Ollama megosztja azt a GPU és a CPU között. Ezt Ön is szabályozhatja:

# Minden réteg kényszerítése a GPU-ra (sikertelen lesz, ha nincs elég VRAM)
OLLAMA_NUM_GPU=999 ollama run gemma4:26b-moe

# Csak CPU használatának kényszerítése (teszteléshez hasznos)
OLLAMA_NUM_GPU=0 ollama run gemma4:e4b

Kontextus ablak konfigurálása

Alapértelmezés szerint az Ollama 2048 tokens kontextus ablakot használ a hatékonyság érdekében. A Gemma 4 teljes kontextus képességeinek kihasználásához:

# Kontextus ablak beállítása 32K tokenre
ollama run gemma4:26b-moe --num-ctx 32768

# Kontextus ablak beállítása 128K tokenre (több RAM-ot igényel)
ollama run gemma4:26b-moe --num-ctx 131072

Fontos: A nagyobb kontextus ablakok több RAM-ot fogyasztanak a KV cache számára. Egy 128K-s kontextus ablak a 31B modellen további 8-16GB RAM-ot igényelhet a modell súlyain felül. Kezdje 32K-val, és csak akkor növelje, ha a felhasználási esete megköveteli.

Egyidejű kérések

Az Ollama támogatja több kérés egyidejű kiszolgálását:

# Legfeljebb 4 egyidejű kérés engedélyezése
OLLAMA_NUM_PARALLEL=4 ollama serve

Minden egyidejű kérés memória többletköltséget jelent a saját KV cache-e miatt. Egy 24GB-os GPU-n, amely a 26B MoE modellt futtatja Q4_K_M kvantálással (~18GB), nagyjából 6GB szabad hely marad — ami elegendő 2-3 egyidejű kéréshez rövid kontextussal.

Keep-Alive beállítások

Alapértelmezés szerint az Ollama az utolsó kérés után 5 percig tartja a modelleket a memóriában betöltve. Ezt módosíthatja az igényei szerint:

# Modell betöltve tartása 1 órán át
OLLAMA_KEEP_ALIVE=3600 ollama serve

# Modell betöltve tartása határozatlan ideig
OLLAMA_KEEP_ALIVE=-1 ollama serve

# Azonnali eltávolítás minden kérés után (memória megtakarítás)
OLLAMA_KEEP_ALIVE=0 ollama serve

NVIDIA RTX optimalizálás

Az NVIDIA kiadott optimalizált Gemma 4 verziókat az RTX GPU-khoz. Ezek az optimalizációk a következőket tartalmazzák:

Egyedi CUDA kernelek a Gemma 4 attention mechanizmusához
TensorRT-LLM integráció a gyorsabb következtetés érdekében
Flash Attention támogatás a csökkentett memóriahasználathoz hosszú kontextusú következtetés során
Optimalizált KV cache kezelés a jobb átviteli sebesség érdekében

Az NVIDIA-optimalizált Gemma 4 telepítése

Ha RTX 4000 vagy 5000 szériás GPU-val rendelkezik:

# GPU ellenőrzése
nvidia-smi

# Az NVIDIA-optimalizált verzió letöltése (ha elérhető az Ollama-ban)
ollama pull gemma4:31b-nvidia

Alternatív megoldásként használja közvetlenül az NVIDIA AI Workbench-et vagy a TensorRT-LLM-et a maximális teljesítmény érdekében. Az NVIDIA-optimalizált verziók 30-50%-kal gyorsabb következtetést biztosíthatnak RTX GPU-kon a standard Ollama build-ekhez képest.

Valós teljesítmény benchmarkok

Gyakori hardverkonfigurációkon mérve:

Token per másodperc (Generálási sebesség)

Modell	RTX 4090 (24GB)	RTX 3090 (24GB)	M3 Max (36GB)	Csak 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

Kontextus: Az emberi olvasási sebesség nagyjából 4-5 token másodpercenként. Bármely modell, amely 10 tok/s felett generál, "azonnalinak" érződik interaktív használat során. Az E2B és E4B modellek elég gyorsak a valós idejű streameléshez szinte bármilyen hardveren.

Első tokenig eltelt idő (Latency)

Modell	RTX 4090	M3 Max	Csak CPU
E2B	<100ms	<200ms	<500ms
E4B	<200ms	<300ms	~1s
26B MoE	~500ms	~1s	~5s
31B Dense	~800ms	~1.5s	~8s

Interaktív alkalmazásoknál az első tokenig eltelt idő fontosabb, mint a generálási sebesség. Az E2B és E4B modellek szinte azonnal elkezdenek generálni még CPU-n is, így ideálisak valós idejű chat felületekhez.

Gyakori felhasználási esetek

Helyi kódolási asszisztens

Használja a Gemma 4-et privát kódolási asszisztensként, amely soha nem küldi el a kódját külső szerverekre:

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."

Párosítsa ezt olyan VS Code bővítményekkel, mint a Continue vagy a Twinny, amelyek támogatják az Ollama-t backendként.

Dokumentum elemzés

Érzékeny dokumentumok feldolgozása helyben:

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

A 256K kontextussal a 31B modell akár ~750 oldalas dokumentumokat is képes feldolgozni — ez elegendő a legtöbb szerződéshez, kutatási tanulmányhoz és műszaki dokumentációhoz.

Helyi RAG (Retrieval-Augmented Generation)

Kombinálja a Gemma 4-et egy helyi vektoradatbázissal egy teljesen privát RAG rendszerhez:

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

# A Gemma 4 használata mind az embedding-hez, mind a generáláshoz
embeddings = OllamaEmbeddings(model="gemma4:e4b")
llm = Ollama(model="gemma4:26b-moe")

# Vektoradatbázis létrehozása a dokumentumokból
vectorstore = Chroma.from_documents(documents, embeddings)

# Lekérdezés RAG-gal
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 funkciók beépítése alkalmazásokba

Az AI képességekkel rendelkező alkalmazásokat építő fejlesztők számára a Gemma 4 helyi futtatása az Ollama API-ján keresztül a leggyorsabb út a működő prototípushoz. Az OpenAI-kompatibilis API azt jelenti, hogy a fejlesztést elkezdheti a helyi Gemma 4-gyel, majd az alkalmazás kódjának megváltoztatása nélkül válthat felhő alapú API-kra az éles üzemhez.

Olyan platformok, mint a ZBuild, kezelhetik az alkalmazás infrastruktúráját — frontend, backend, hitelesítés, adatbázis —, miközben Ön az AI integrációs rétegre összpontosít. Irányítsa az alkalmazás AI végpontját a localhost:11434 címre a fejlesztés során, és váltson felhővégpontra, amikor készen áll a skálázásra.

Hibaelhárítás

"Out of memory" hibák

Ha memória hibákat lát:

Próbáljon ki egy kisebb kvantálást: ollama pull gemma4:31b-q3_K_M
Csökkentse a kontextus ablakot: --num-ctx 4096
Zárjon be más GPU-intenzív alkalmazásokat
Váltson egy kisebb modellre: a 26B MoE közel 31B-szintű minőséget nyújt alacsonyabb memóriaköltség mellett

Lassú generálási sebesség

ha a generálás lassabb a vártnál:

Ellenőrizze a GPU kihasználtságát: nvidia-smi (magas GPU használatot kell mutatnia)
Győződjön meg róla, hogy a modell teljesen elfér a VRAM-ban — a részleges CPU-ra helyezés drasztikusan lassabb
Csökkentse a --num-ctx értéket, hogy VRAM-ot szabadítson fel a számításokhoz
Ellenőrizze, hogy más folyamatok használják-e a GPU-t

A modell nem található

Ha az ollama run gemma4:26b-moe hibaüzenetet ad:

# Elérhető modellek listázása
ollama list

# Keresés a Gemma 4 modellek között
ollama search gemma4

# A konkrét modell letöltése
ollama pull gemma4:26b-moe

API kapcsolat elutasítva

Ha az alkalmazások nem tudnak csatlakozni a localhost:11434 címhez:

# Ellenőrizze, hogy fut-e az Ollama
ollama list

# Indítsa el manuálisan az Ollama szervert
ollama serve

# Ellenőrizze a portot
curl http://localhost:11434/api/tags

Modellválasztási döntési fa

Használja ezt a megfelelő modell gyors kiválasztásához:

Rendelkezik dedikált GPU-val 16GB+ VRAM-mal?

Igen → Maximális minőséget vagy maximális hatékonyságot szeretne?
- Maximális minőség → gemma4:31b (Q4_K_M, 20GB-ot igényel)
- Maximális hatékonyság → gemma4:26b-moe (Q4_K_M, 18GB-ot igényel)
Nem → Rendelkezik 8GB+ RAM-mal?
- Igen → gemma4:e4b (Q4_K_M, jobb minőség)
- Nem → gemma4:e2b (Q4_K_M, 5GB-on is fut)

A legtöbb modern asztali géppel vagy gamer PC-vel rendelkező fejlesztő számára: Kezdje a gemma4:26b-moe modellel. Ez kínálja a legjobb minőség-erőforrás arányt a teljes Gemma 4 családban.

Amit építhet

A helyben futó Gemma 4-gyel egy nulla költségű AI backenddel rendelkezik a következőkhöz:

Chat alkalmazások teljes beszélgetési adatvédelemmel
Kódelemző eszközök, amelyek saját tulajdonú kódbázisokon működnek
Dokumentumfeldolgozó csővezetékek érzékeny adatokhoz
Helyi AI asszisztensek, amelyek offline is működnek
Prototípus AI funkciók, mielőtt elkötelezné magát a felhő API költségek mellett
Finomhangolt modellek tartományspecifikus feladatokhoz (az Apache 2.0 ezt szabadon lehetővé teszi)

Az Apache 2.0 licenc azt jelenti, hogy minden, amit épít, az Öné — nincs használati korlátozás, nincs bevételmegosztás, nincs szükség jóváhagyásra. Futtassa helyben, telepítse a szervereire, ágyazza be termékeibe. Ez az, amiről a valóban nyitott AI szól.

Gemma 4 futtatása helyileg 5 perc alatt: Teljes Ollama telepítési útmutató (2026)