Kolik RAM potřebuji ke spuštění Gemma 4 lokálně?

Gemma 4 E2B a E4B běží na pouhých 5GB RAM s 4-bit quantization — stačí jakýkoli moderní laptop. Model 26B MoE vyžaduje přibližně 18GB RAM (vejde se do 24GB VRAM u RTX 4090). Model 31B Dense vyžaduje přibližně 20GB RAM. Pro spuštění pouze na CPU připočítejte o 20-30 % více RAM, než je velikost model weight.

Který model Gemma 4 bych si měl vybrat pro lokální použití?

Pro laptopy bez dedikované GPU: E2B (nejrychlejší, nejlehčí). Pro laptopy s GPU nebo desktopy: E4B (lepší kvalita, stále lightweight). Pro desktopy s RTX 4090 nebo ekvivalentem: 26B MoE (nejlepší poměr kvality k výpočetnímu výkonu). Pro pracovní stanice s 24GB+ VRAM: 31B Dense (nejvyšší kvalita). 26B MoE je sweet spot pro většinu vývojářů.

Je Gemma 4 zdarma pro lokální použití?

Ano. Gemma 4 je vydána pod Apache 2.0, což umožňuje neomezené použití včetně komerčních aplikací. Ollama je také zdarma a open source. Jediným nákladem je váš hardware. Neexistují žádné API fees, žádné usage limits a žádná licenční omezení.

Jak rychlá je Gemma 4 lokálně ve srovnání s cloudovými API?

Na RTX 4090 generuje Gemma 4 E4B 80-120 tokens za sekundu. 26B MoE generuje 30-50 tokens/sec. 31B Dense generuje 20-35 tokens/sec. Cloudová API jako Google AI Studio mohou být u největších modelů rychlejší, ale přidávají network latency 100-500ms na požadavek. Pro interaktivní použití působí lokální inference u menších modelů okamžitě.

Mohu používat Gemma 4 lokálně jako API pro své aplikace?

Ano. Ollama zpřístupňuje lokální REST API na portu 11434, které je kompatibilní s OpenAI API format. Jakákoli aplikace, framework nebo nástroj, který podporuje OpenAI API, se může připojit k lokální Gemma 4 nasměrováním base URL na http://localhost:11434/v1. To zahrnuje Python, Node.js a většinu AI frameworks.

Podporuje Gemma 4 GPU acceleration v Ollama?

Ano. Ollama automaticky detekuje a používá NVIDIA GPUs (CUDA), Apple Silicon (Metal) a AMD GPUs (ROCm). Není potřeba žádná další konfigurace — pokud má vaše GPU dostatek VRAM pro uložení modelu, Ollama ji použije automaticky. NVIDIA také vydala RTX-optimized verze Gemma 4 pro další zvýšení výkonu.

Hlavní poznatek

Spuštění Gemma 4 lokálně trvá s Ollama méně než 5 minut: nainstalujte Ollama, spusťte jeden příkaz a máte plně schopný AI model běžící na vašem vlastním hardwaru s nulovými API náklady, žádnými daty opouštějícími váš stroj a nulovými omezeními použití pod licencí Apache 2.0. Model E2B běží na jakémkoli notebooku. Model 26B MoE se vejde na jednu RTX 4090 a poskytuje kvalitu, která konkuruje modelům s desetinásobným počtem aktivních parametrů.

Spuštění Gemma 4 lokálně: Kompletní průvodce

Proč spouštět Gemma 4 lokálně?

Než se ponoříme do nastavení, zde je důvod, proč na lokální inference v roce 2026 záleží:

Soukromí — Vaše data nikdy neopustí váš stroj. Žádné prompty nejsou odesílány na externí servery. Klíčové pro proprietární kód, právní dokumenty, lékařská data nebo jakékoli citlivé informace.
Náklady — Nulové náklady na tokens po jednorázové investici do hardwaru. Nároční uživatelé ušetří stovky dolarů měsíčně ve srovnání s cenami API.
Latence — Žádné síťové přenosy. Modely E2B a E4B reagují v milisekundách na moderním hardwaru.
Spolehlivost — Žádné API rate limits, žádné výpadky, žádné změny zásad poskytovatele. Váš model je vždy k dispozici.
Přizpůsobení — Volně provádějte fine-tune, kvantizaci a úpravy modelu pod licencí Apache 2.0.
Offline přístup — Funguje bez internetového připojení, jakmile je model stažen.

Gemma 4 je obzvláště vhodná pro lokální nasazení, protože Google navrhl menší modely specificky pro edge použití a použití v zařízeních. Modely E2B a E4B nejsou jen doplňkem — jsou to prvotřídní modely optimalizované pro omezení lokálního hardwaru.

Požadavky

Hardwarové požadavky podle modelu

Model	Minimální RAM	Doporučená VRAM	Použitelné pouze s CPU?	Místo na disku
E2B (4-bit)	5 GB	4 GB	Ano	~1.5 GB
E4B (4-bit)	5 GB	4 GB	Ano	~2.8 GB
E4B (FP16)	9 GB	9 GB	Pomalé	~9 GB
26B MoE (4-bit)	18 GB	16 GB	Velmi pomalé	~15 GB
26B MoE (FP16)	52 GB	48 GB	Ne	~52 GB
31B Dense (4-bit)	20 GB	18 GB	Velmi pomalé	~18 GB
31B Dense (FP16)	62 GB	48 GB+	Ne	~62 GB

Hlavní poznatek: Pokud máte notebook vyrobený po roce 2022, můžete spustit E2B nebo E4B. Pokud máte RTX 4090 (24GB VRAM) nebo Apple M-series Mac s 32GB+ RAM, můžete spustit 26B MoE nebo 31B Dense při 4-bit kvantizaci.

Softwarové požadavky

Operační systém: macOS, Linux nebo Windows
Ollama: Verze 0.6+ (stáhněte z ollama.com)
GPU ovladače (volitelné): NVIDIA CUDA 12+ pro NVIDIA GPUs, pro Apple Silicon nejsou potřeba žádné další ovladače

Krok 1: Instalace Ollama

macOS

Stáhněte z ollama.com/download nebo použijte Homebrew:

brew install ollama

Linux

Instalační skript na jeden řádek:

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

Windows

Stáhněte instalátor z ollama.com/download a spusťte jej. Ollama běží na Windows jako služba na pozadí.

Ověření instalace

ollama --version

Měli byste vidět ollama version 0.6.x nebo vyšší. Pokud vidíte číslo verze, Ollama je nainstalována správně.

Zdroj: Instalační příručka Ollama

Krok 2: Stažení modelu Gemma 4

Vyberte model, který odpovídá vašemu hardwaru:

Pro notebooky a lehké pracovní zátěže

# Nejmenší model — běží na jakémkoli moderním notebooku (5GB RAM)
ollama pull gemma4:e2b

# Malý model s širšími schopnostmi (5-9GB RAM)
ollama pull gemma4:e4b

Pro stolní počítače s dedikovanou GPU

# Nejlepší efektivita — vlajková kvalita při 3.8B aktivních parametrech (18GB RAM)
ollama pull gemma4:26b-moe

# Nejvyšší kvalita — plných 31B parametrů (20GB RAM)
ollama pull gemma4:31b

Specifikace kvantizace

Ve výchozím nastavení Ollama stahuje doporučenou kvantizaci pro každý model (obvykle Q4_K_M pro dobrý poměr kvality a velikosti). Můžete specifikovat různé kvantizace:

# Vyšší kvalita, větší velikost
ollama pull gemma4:31b-q5_K_M

# Menší velikost, mírně nižší kvalita
ollama pull gemma4:31b-q3_K_M

# Plná přesnost (vyžaduje mnohem více RAM)
ollama pull gemma4:31b-fp16

Stahování bude trvat několik minut v závislosti na vašem internetovém připojení. Velikosti modelů se pohybují od ~1.5GB (E2B 4-bit) do ~62GB (31B FP16).

Krok 3: Spuštění Gemma 4

Interaktivní chat

ollama run gemma4:e4b

Tím se otevře interaktivní chatovací relace. Napište svůj prompt a stiskněte Enter:

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

Model odpoví přímo ve vašem terminálu. Pro ukončení napište /bye.

Jednorázový prompt (neinteraktivní)

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

S režimem přemýšlení (Thinking Mode)

Gemma 4 podporuje konfigurovatelný režim přemýšlení pro složité úkoly. Povolte jej přidáním systémového promptu:

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

Pro matematické, logické a složité analytické úkoly režim přemýšlení výrazně zlepšuje kvalitu odpovědí. Model vygeneruje více než 4 000 tokens interního uvažování, než vytvoří svou konečnou odpověď.

Krok 4: Použití lokálního API

Ollama vystavuje REST API na localhost:11434, které je kompatibilní s formátem OpenAI API. To znamená, že jakýkoli nástroj nebo knihovna, která podporuje API od OpenAI, se může připojit k vaší lokální Gemma 4 jednoduchou změnou URL.

Testování API pomocí 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
}'

Koncový bod kompatibilní s OpenAI

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

Zdroj: Dokumentace Ollama API

Krok 5: Integrace do vaší aplikace

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

Použití s 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)

Použití s 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)

Vysvětlení možností kvantizace

Kvantizace snižuje velikost modelu a využití paměti použitím čísel s nižší přesností pro reprezentaci vah modelu. Kompromis je mezi kvalitou a využitím zdrojů:

Kvantizace	Bity na váhu	Dopad na kvalitu	Úspora paměti	Nejlepší pro
FP16	16 bits	Žádný (plná kvalita)	Základní úroveň	Servery s dostatkem VRAM
Q8_0	8 bits	Zanedbatelný	~50%	Vysoce kvalitní lokální inference
Q6_K	6 bits	Velmi malý	~62%	Lokální použití zaměřené na kvalitu
Q5_K_M	5 bits	Malý	~69%	Dobrá rovnováha
Q4_K_M	4 bits	Malý	~75%	Doporučený výchozí bod
Q3_K_M	3 bits	Střední	~81%	Omezený hardware
Q2_K	2 bits	Výrazný	~87%	Extrémní omezení

Q4_K_M je optimální bod pro většinu uživatelů. Rozdíl v kvalitě oproti FP16 je natolik malý, že u většiny úkolů jsou výsledky nerozeznatelné, zatímco úspora paměti o 75 % tvoří rozdíl mezi "potřebuje server" a "běží na mém notebooku".

Výběr správné kvantizace

Pro Gemma 4 E2B/E4B: Použijte výchozí nastavení (Q4_K_M). Tyto modely jsou již dostatečně malé, takže vyšší kvantizace významně nemění uživatelskou zkušenost.

Pro Gemma 4 26B MoE: Q4_K_M se vejde do 18GB RAM, což je v rámci 24GB VRAM karty RTX 4090 s prostorem pro KV cache. Pokud máte 48GB+ VRAM (A6000, duální GPU), zvažte Q8_0 pro mírně lepší kvalitu.

Pro Gemma 4 31B Dense: Q4_K_M při 20GB se vejde do RTX 4090 s těsnou rezervou. Q5_K_M poskytuje o něco lepší výsledky, ale vyžaduje ~24GB, čímž spotřebuje veškerou dostupnou VRAM. Pokud máte 32GB+ VRAM (RTX 5090, A6000), Q6_K nebo Q8_0 stojí za upgrade.

Ladění výkonu

Offloading na GPU

Ollama automaticky přesouvá vrstvy modelu na GPU, pokud je k dispozici VRAM. Pokud se do VRAM vejde jen část modelu, Ollama ji rozdělí mezi GPU a CPU. Toto můžete ovlivnit:

# Vynutit všechny vrstvy na GPU (selže při nedostatku VRAM)
OLLAMA_NUM_GPU=999 ollama run gemma4:26b-moe

# Vynutit pouze CPU (užitečné pro testování)
OLLAMA_NUM_GPU=0 ollama run gemma4:e4b

Konfigurace kontextového okna (Context Window)

Ve výchozím nastavení používá Ollama pro efektivitu kontextové okno 2048 tokens. Chcete-li využít plné možnosti kontextu Gemma 4:

# Nastavit kontextové okno na 32K tokens
ollama run gemma4:26b-moe --num-ctx 32768

# Nastavit kontextové okno na 128K tokens (vyžaduje více RAM)
ollama run gemma4:26b-moe --num-ctx 131072

Důležité: Větší kontextová okna spotřebovávají více RAM pro KV cache. Kontextové okno 128K u modelu 31B může vyžadovat 8-16GB RAM navíc nad rámec vah modelu. Začněte s 32K a zvyšujte pouze v případě, že to váš případ použití vyžaduje.

Souběžné požadavky

Ollama podporuje obsluhu více požadavků současně:

# Povolit až 4 souběžné požadavky
OLLAMA_NUM_PARALLEL=4 ollama serve

Každý souběžný požadavek zvyšuje režii paměti pro svou KV cache. Na 24GB GPU provozující 26B MoE při Q4_K_M (~18GB) máte zhruba 6GB rezervu — dost na 2-3 souběžné požadavky s krátkými kontexty.

Nastavení Keep-Alive

Ve výchozím nastavení udržuje Ollama modely načtené v paměti po dobu 5 minut po posledním požadavku. Toto můžete upravit:

# Udržet model načtený po dobu 1 hodiny
OLLAMA_KEEP_ALIVE=3600 ollama serve

# Udržet model načtený neomezeně dlouho
OLLAMA_KEEP_ALIVE=-1 ollama serve

# Uvolnit okamžitě po každém požadavku (šetří paměť)
OLLAMA_KEEP_ALIVE=0 ollama serve

Optimalizace pro NVIDIA RTX

NVIDIA vydala optimalizované sestavení Gemma 4 pro RTX GPUs. Tyto optimalizace zahrnují:

Vlastní CUDA jádra pro mechanizmus pozornosti (attention) Gemma 4
Integrace TensorRT-LLM pro rychlejší inference
Podpora Flash Attention pro snížení využití paměti během inference s dlouhým kontextem
Optimalizovaná správa KV cache pro lepší propustnost

Instalace NVIDIA-optimalizované Gemma 4

Pokud máte GPU řady RTX 4000 nebo 5000:

# Zkontrolujte své GPU
nvidia-smi

# Stáhněte verzi optimalizovanou pro NVIDIA (pokud je v Ollama k dispozici)
ollama pull gemma4:31b-nvidia

Případně použijte přímo NVIDIA AI Workbench nebo TensorRT-LLM pro maximální výkon. Verze optimalizované pro NVIDIA mohou na RTX GPUs poskytnout o 30-50 % rychlejší inference ve srovnání se standardními sestaveními Ollama.

Výkonnostní benchmarky z reálného světa

Měřeno na běžných hardwarových konfiguracích:

Tokens za sekundu (Rychlost generování)

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

Kontext: Rychlost lidského čtení je zhruba 4-5 tokens za sekundu. Jakýkoli model generující nad 10 tok/s působí při interaktivním použití jako "okamžitý". Modely E2B a E4B jsou dostatečně rychlé pro real-time streamování na téměř jakémkoli hardwaru.

Čas do prvního tokenu (Latence)

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

U interaktivních aplikací záleží na čase do prvního tokenu více než na rychlosti generování. Modely E2B a E4B začínají generovat téměř okamžitě i na CPU, což je činí ideálními pro chatovací rozhraní v reálném čase.

Běžné případy použití

Lokální programovací asistent

Použijte Gemma 4 jako soukromého programovacího asistenta, který nikdy neodesílá váš kód na externí servery:

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

Propojte toto s rozšířeními pro VS Code jako Continue nebo Twinny, které podporují Ollama jako backend.

Analýza dokumentů

Zpracovávejte citlivé dokumenty lokálně:

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

S kontextem 256K dokáže model 31B zpracovat dokumenty o rozsahu až ~750 stran — což stačí pro většinu smluv, výzkumných prací a technické dokumentace.

Lokální RAG (Retrieval-Augmented Generation)

Zkombinujte Gemma 4 s lokální vektorovou databází pro plně soukromý RAG systém:

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?")

Budování AI funkcí do aplikací

Pro vývojáře budující aplikace s AI schopnostmi je spuštění Gemma 4 lokálně přes Ollama API nejrychlejší cestou k funkčnímu prototypu. API kompatibilní s OpenAI znamená, že můžete začít s lokální Gemma 4 pro vývoj a přejít na cloudová API pro produkci bez změny kódu aplikace.

Platformy jako ZBuild mohou spravovat infrastrukturu aplikace — frontend, backend, autentizaci, databázi — zatímco vy se soustředíte na integrační vrstvu AI. Během vývoje nasměrujte AI endpoint vaší aplikace na localhost:11434 a po přechodu na škálování jej vyměňte za cloudový endpoint.

Řešení problémů

Chyby "Out of memory"

Pokud vidíte chyby paměti:

Zkuste menší kvantizaci: ollama pull gemma4:31b-q3_K_M
Zmenšete kontextové okno: --num-ctx 4096
Zavřete ostatní aplikace náročné na GPU
Přejděte na menší model: 26B MoE poskytuje kvalitu blízkou 31B při nižších nárocích na paměť

Pomalá rychlost generování

Pokud je generování pomalejší, než se očekávalo:

Zkontrolujte využití GPU: nvidia-smi (mělo by vykazovat vysoké využití GPU)
Ujistěte se, že se model vejde celý do VRAM — částečný offloading na CPU je dramaticky pomalejší
Snižte --num-ctx pro uvolnění VRAM pro výpočty
Zkontrolujte, zda GPU nepoužívají jiné procesy

Model nenalezen

Pokud ollama run gemma4:26b-moe selže:

# Seznam dostupných modelů
ollama list

# Vyhledávání modelů Gemma 4
ollama search gemma4

# Stažení konkrétního modelu
ollama pull gemma4:26b-moe

Připojení k API odmítnuto

Pokud se aplikace nemohou připojit k localhost:11434:

# Zkontrolujte, zda Ollama běží
ollama list

# Spusťte server Ollama ručně
ollama serve

# Zkontrolujte port
curl http://localhost:11434/api/tags

Rozhodovací strom pro výběr modelu

Použijte toto pro rychlý výběr správného modelu:

Máte dedikovanou GPU s 16GB+ VRAM?

Ano → Chcete maximální kvalitu nebo maximální efektivitu?
- Maximální kvalita → gemma4:31b (Q4_K_M, potřebuje 20GB)
- Maximální efektivita → gemma4:26b-moe (Q4_K_M, potřebuje 18GB)
Ne → Máte 8GB+ RAM?
- Ano → gemma4:e4b (Q4_K_M, lepší kvalita)
- Ne → gemma4:e2b (Q4_K_M, běží na 5GB)

Pro většinu vývojářů s moderním stolním počítačem nebo herním PC: Začněte s gemma4:26b-moe. Nabízí nejlepší poměr kvality a zdrojů v celé rodině Gemma 4.

Co můžete vytvořit

S Gemma 4 běžící lokálně máte k dispozici AI backend s nulovými náklady pro:

Chatovací aplikace s plným soukromím konverzace
Nástroje pro analýzu kódu, které fungují na proprietárních kódových bázích
Potrubí pro zpracování dokumentů pro citlivá data
Lokální AI asistenty, kteří fungují offline
Prototypy AI funkcí před zavázáním se k nákladům na cloudová API
Modely s fine-tune pro specifické doménové úkoly (Apache 2.0 to volně umožňuje)

Licence Apache 2.0 znamená, že vše, co vytvoříte, je vaše — žádná omezení použití, žádné sdílení výnosů, žádné schvalování. Spouštějte to lokálně, nasazujte na své servery, vkládejte do svých produktů. Takto vypadá skutečně otevřená AI.

Spusťte Gemma 4 lokálně za 5 minut: Kompletní Ollama Setup Guide (2026)