Hvor mye RAM trenger jeg for å kjøre Gemma 4 lokalt?

Gemma 4 E2B og E4B kjører på så lite som 5GB RAM med 4-bit quantization — alle moderne laptoper er kvalifisert. 26B MoE-modellen trenger omtrent 18GB RAM (passer i en RTX 4090's 24GB VRAM). 31B Dense-modellen trenger omtrent 20GB RAM. For CPU-only kjøring, legg til 20-30% mer RAM enn modellvekten.

Hvilken Gemma 4-modell bør jeg velge for lokal bruk?

For laptoper uten dedikert GPU: E2B (raskest, lettest). For laptoper med GPU eller stasjonære PC-er: E4B (bedre kvalitet, fortsatt lettvekt). For stasjonære PC-er med RTX 4090 eller tilsvarende: 26B MoE (best forhold mellom kvalitet og ytelse). For arbeidsstasjoner med 24GB+ VRAM: 31B Dense (høyest kvalitet). 26B MoE er det ideelle valget for de fleste utviklere.

Er Gemma 4 gratis å bruke lokalt?

Ja. Gemma 4 er utgitt under Apache 2.0, som tillater ubegrenset bruk inkludert kommersielle applikasjoner. Ollama er også gratis og open source. Den eneste kostnaden er maskinvaren din. Det er ingen API-gebyrer, ingen bruksbegrensninger og ingen lisensrestriksjoner.

Hvor rask er Gemma 4 lokalt sammenlignet med cloud APIs?

På en RTX 4090 genererer Gemma 4 E4B 80-120 tokens per sekund. 26B MoE genererer 30-50 tokens/sec. 31B Dense genererer 20-35 tokens/sec. Cloud APIs som Google AI Studio kan være raskere for de største modellene, men legger til en nettverkslatens på 100-500ms per forespørsel. For interaktiv bruk føles lokal inference på de mindre modellene umiddelbar.

Kan jeg bruke Gemma 4 lokalt som et API for mine applikasjoner?

Ja. Ollama eksponerer et lokalt REST API på port 11434 som er kompatibelt med OpenAI API-formatet. Enhver applikasjon, rammeverk eller verktøy som støtter OpenAI API kan koble seg til lokal Gemma 4 ved å peke base-URL til http://localhost:11434/v1. Dette inkluderer Python, Node.js og de fleste AI-rammeverk.

Støtter Gemma 4 GPU-akselerasjon med Ollama?

Ja. Ollama oppdager og bruker automatisk NVIDIA-GPU-er (CUDA), Apple Silicon (Metal) og AMD-GPU-er (ROCm). Ingen ekstra konfigurasjon er nødvendig — hvis din GPU har nok VRAM til å holde modellen, vil Ollama bruke den automatisk. NVIDIA har også utgitt RTX-optimaliserte versjoner av Gemma 4 for ytterligere ytelsesgevinster.

Viktigste poeng

Å kjøre Gemma 4 lokalt tar mindre enn 5 minutter med Ollama: installer Ollama, kjør én kommando, og du har en fullt kapabel AI-modell som kjører på din egen maskinvare med null API-kostnader, null data som forlater maskinen din, og null bruksbegrensninger under Apache 2.0. E2B-modellen kjører på enhver bærbar PC. 26B MoE-modellen passer på et enkelt RTX 4090 og leverer kvalitet som rivaliserer modeller med 10x så mange aktive parametere.

Kjør Gemma 4 lokalt: Den komplette guiden

Hvorfor kjøre Gemma 4 lokalt?

Før vi går inn på oppsettet, her er grunnen til at lokal inferens er viktig i 2026:

Personvern — Dine data forlater aldri maskinen din. Ingen prompter sendes til eksterne servere. Kritisk for proprietær kode, juridiske dokumenter, medisinske data eller annen sensitiv informasjon.
Kostnad — Null kostnad per token etter den engangsutgiften til maskinvare. Storbrukere sparer hundrevis av dollar per måned sammenlignet med API-prising.
Latens — Ingen nettverksforsinkelser. E2B- og E4B-modellene svarer på millisekunder på moderne maskinvare.
Pålitelighet — Ingen API-ratbegrensninger, ingen nedetid, ingen endringer i leverandørens retningslinjer. Modellen din er alltid tilgjengelig.
Tilpasning — Du kan fritt finjustere, kvantisere og modifisere modellen under Apache 2.0.
Offline-tilgang — Fungerer uten internettforbindelse når modellen først er lastet ned.

Gemma 4 er spesielt godt egnet for lokal distribusjon fordi Google designet de mindre modellene spesifikt for edge- og on-device-bruk. E2B- og E4B-modellene er ikke ettertanker — de er førsteklasses modeller optimalisert for begrensningene i lokal maskinvare.

Forutsetninger

Maskinvarekrav per modell

Modell	Minimum RAM	Anbefalt VRAM	Mulig med kun CPU?	Diskplass
E2B (4-bit)	5 GB	4 GB	Ja	~1.5 GB
E4B (4-bit)	5 GB	4 GB	Ja	~2.8 GB
E4B (FP16)	9 GB	9 GB	Treg	~9 GB
26B MoE (4-bit)	18 GB	16 GB	Veldig treg	~15 GB
26B MoE (FP16)	52 GB	48 GB	Nei	~52 GB
31B Dense (4-bit)	20 GB	18 GB	Veldig treg	~18 GB
31B Dense (FP16)	62 GB	48 GB+	Nei	~62 GB

Viktigste poeng: Hvis du har en bærbar PC laget etter 2022, kan du kjøre E2B eller E4B. Hvis du har et RTX 4090 (24GB VRAM) eller Apple M-serie Mac med 32GB+ RAM, kan du kjøre 26B MoE eller 31B Dense med 4-bit kvantisering.

Programvarekrav

Operativsystem: macOS, Linux, eller Windows
Ollama: Versjon 0.6+ (last ned fra ollama.com)
GPU-drivere (valgfritt): NVIDIA CUDA 12+ for NVIDIA-GPUer, ingen ekstra drivere trengs for Apple Silicon

Steg 1: Installer Ollama

macOS

Last ned fra ollama.com/download eller bruk Homebrew:

brew install ollama

Linux

Installasjonsskript på én linje:

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

Windows

Last ned installasjonsprogrammet fra ollama.com/download og kjør det. Ollama kjører som en bakgrunnstjeneste på Windows.

Verifiser installasjon

ollama --version

Du bør se ollama version 0.6.x eller høyere. Hvis du ser et versjonsnummer, er Ollama riktig installert.

Kilde: Ollama installasjonsguide

Steg 2: Hent en Gemma 4-modell

Velg modellen som passer din maskinvare:

For bærbare PC-er og lette arbeidsoppgaver

# Minste modell — kjører på enhver moderne bærbar PC (5GB RAM)
ollama pull gemma4:e2b

# Liten modell med bredere kapasitet (5-9GB RAM)
ollama pull gemma4:e4b

For stasjonære PC-er med dedikert GPU

# Best effektivitet — flaggskipkvalitet med 3.8B aktive parametere (18GB RAM)
ollama pull gemma4:26b-moe

# Høyest kvalitet — fulle 31B parametere (20GB RAM)
ollama pull gemma4:31b

Spesifisering av kvantisering

Som standard henter Ollama den anbefalte kvantiseringen for hver modell (vanligvis Q4_K_M for en god balanse mellom kvalitet og størrelse). Du kan spesifisere andre kvantiseringer:

# Høyere kvalitet, større størrelse
ollama pull gemma4:31b-q5_K_M

# Mindre størrelse, noe lavere kvalitet
ollama pull gemma4:31b-q3_K_M

# Full presisjon (krever mye mer RAM)
ollama pull gemma4:31b-fp16

Nedlastingen vil ta noen minutter avhengig av internettforbindelsen din. Modellstørrelsene varierer fra ~1.5GB (E2B 4-bit) til ~62GB (31B FP16).

Steg 3: Kjør Gemma 4

Interaktiv chat

ollama run gemma4:e4b

Dette åpner en interaktiv chatsesjon. Skriv inn din prompt og trykk Enter:

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

Modellen vil svare direkte i terminalen din. Skriv /bye for å avslutte.

Enkel prompt (ikke-interaktiv)

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

Med tenkemodus (Thinking Mode)

Gemma 4 støtter konfigurerbar tenkemodus for komplekse oppgaver. Aktiver det ved å legge til en system-prompt:

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

For oppgaver innen matematikk, logikk og kompleks analyse forbedrer tenkemodusen svarets kvalitet betydelig. Modellen vil generere over 4,000 tokens med intern resonnering før den produserer sitt endelige svar.

Steg 4: Bruk det lokale API-et

Ollama eksponerer et REST API på localhost:11434 som er kompatibelt med OpenAI sitt API-format. Dette betyr at ethvert verktøy eller bibliotek som støtter OpenAI sitt API kan koble seg til din lokale Gemma 4 med en enkel endring av URL.

Test API-et med 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
}'

OpenAI-kompatibelt endepunkt

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

Kilde: Ollama API-dokumentasjon

Steg 5: Integrer med din applikasjon

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

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

Python med OpenAI SDK

from openai import OpenAI

# Pek til lokal Ollama i stedet for OpenAI
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # Ollama krever ikke en ekte API-nøkkel
)

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

Bruk med 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)

Bruk med 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)

Kvantiseringsvalg forklart

Kvantisering reduserer modellstørrelse og minnebruk ved å bruke tall med lavere presisjon for å representere modellvekter. Avveiningen er mellom kvalitet og ressursbruk:

Kvantisering	Bits per vekt	Kvalitetspåvirkning	Minnebesparelser	Best for
FP16	16 bits	Ingen (full kvalitet)	Basislinje	Servere med rikelig VRAM
Q8_0	8 bits	Ubetydelig	~50%	Lokal inferens av høy kvalitet
Q6_K	6 bits	Veldig liten	~62%	Kvalitetsfokusert lokal bruk
Q5_K_M	5 bits	Liten	~69%	God balanse
Q4_K_M	4 bits	Liten	~75%	Anbefalt standard
Q3_K_M	3 bits	Moderat	~81%	Begrenset maskinvare
Q2_K	2 bits	Betydelig	~87%	Ekstreme begrensninger

Q4_K_M er det optimale punktet for de fleste brukere. Kvalitetsforskjellen fra FP16 er liten nok til at de fleste oppgaver gir umerkelige resultater, mens minnebesparelsen på 75% utgjør forskjellen mellom "trenger en server" og "kjører på min bærbare PC."

Velge riktig kvantisering

For Gemma 4 E2B/E4B: Bruk standarden (Q4_K_M). Disse modellene er allerede små nok til at høyere kvantisering ikke endrer brukeropplevelsen nevneverdig.

For Gemma 4 26B MoE: Q4_K_M passer i 18GB RAM, som er innenfor et RTX 4090 sitt 24GB VRAM med plass til overs for KV cache. Hvis du har 48GB+ VRAM (A6000, doble GPUer), bør du vurdere Q8_0 for marginalt bedre kvalitet.

For Gemma 4 31B Dense: Q4_K_M på 20GB passer i et RTX 4090 med små marginer. Q5_K_M gir noe bedre resultater, men krever ~24GB, noe som forbruker alt tilgjengelig VRAM. Hvis du har 32GB+ VRAM (RTX 5090, A6000), er Q6_K eller Q8_0 verdt oppgraderingen.

Ytelsesjustering

GPU-avlastning

Ollama avlaster automatisk modellag til GPU-en når VRAM er tilgjengelig. Hvis bare deler av modellen passer i VRAM, deler Ollama mellom GPU og CPU. Du kan kontrollere dette:

# Tving alle lag til GPU (feiler hvis utilstrekkelig VRAM)
OLLAMA_NUM_GPU=999 ollama run gemma4:26b-moe

# Tving kun CPU (nyttig for testing)
OLLAMA_NUM_GPU=0 ollama run gemma4:e4b

Konfigurering av kontekstvindu

Som standard bruker Ollama et kontekstvindu på 2048 tokens for effektivitet. For å utnytte Gemma 4 sine fulle kontekstkapasiteter:

# Sett kontekstvindu til 32K tokens
ollama run gemma4:26b-moe --num-ctx 32768

# Sett kontekstvindu til 128K tokens (krever mer RAM)
ollama run gemma4:26b-moe --num-ctx 131072

Viktig: Større kontekstvinduer bruker mer RAM til KV cache. Et 128K kontekstvindu på 31B-modellen kan kreve 8-16GB ekstra RAM utover modellvektene. Start med 32K og øk kun hvis ditt bruksområde krever det.

Samtidige forespørsler

Ollama støtter å betjene flere forespørsler samtidig:

# Tillat opptil 4 samtidige forespørsler
OLLAMA_NUM_PARALLEL=4 ollama serve

Hver samtidige forespørsel gir ekstra minnebruk for sin KV cache. På en 24GB GPU som kjører 26B MoE med Q4_K_M (~18GB), har du omtrent 6GB margin — nok til 2-3 samtidige forespørsler med korte kontekster.

Keep-Alive-innstillinger

Som standard holder Ollama modeller lastet i minnet i 5 minutter etter den siste forespørselen. Juster dette for ditt bruksområde:

# Hold modellen lastet i 1 time
OLLAMA_KEEP_ALIVE=3600 ollama serve

# Hold modellen lastet på ubestemt tid
OLLAMA_KEEP_ALIVE=-1 ollama serve

# Avlast umiddelbart etter hver forespørsel (sparer minne)
OLLAMA_KEEP_ALIVE=0 ollama serve

NVIDIA RTX-optimalisering

NVIDIA har sluppet optimaliserte bygg av Gemma 4 for RTX-GPUer. Disse optimaliseringene inkluderer:

Tilpassede CUDA-kjerner for Gemma 4 sin attention-mekanisme
TensorRT-LLM-integrasjon for raskere inferens
Flash Attention-støtte for redusert minnebruk under inferens med lang kontekst
Optimalisert KV cache-håndtering for bedre gjennomstrømming

Installere NVIDIA-optimalisert Gemma 4

Hvis du har en GPU i RTX 4000- eller 5000-serien:

# Sjekk din GPU
nvidia-smi

# Hent den NVIDIA-optimaliserte versjonen (hvis tilgjengelig i Ollama)
ollama pull gemma4:31b-nvidia

Alternativt kan du bruke NVIDIA sin AI Workbench eller TensorRT-LLM direkte for maksimal ytelse. De NVIDIA-optimaliserte versjonene kan gi 30-50% raskere inferens på RTX-GPUer sammenlignet med standard Ollama-bygg.

Ytelsestester fra virkeligheten

Målt på vanlige maskinvarekonfigurasjoner:

Tokens per sekund (Genereringshastighet)

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

Kontekst: Menneskelig lesehastighet er omtrent 4-5 tokens per sekund. Enhver modell som genererer over 10 tok/s føles "øyeblikkelig" for interaktiv bruk. E2B- og E4B-modellene er raske nok for sanntidsstreaming på nesten hvilken som helst maskinvare.

Tid til første token (Latens)

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

For interaktive applikasjoner betyr tid til første token mer enn genereringshastighet. E2B- og E4B-modellene begynner å generere nesten umiddelbart selv på CPU, noe som gjør dem ideelle for chat-grensesnitt i sanntid.

Vanlige bruksområder

Lokal kodeassistent

Bruk Gemma 4 som en privat kodeassistent som aldri sender koden din til eksterne servere:

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

Kombiner dette med VS Code-utvidelser som Continue eller Twinny som støtter Ollama som backend.

Dokumentanalyse

Behandle sensitive dokumenter lokalt:

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

Med 256K kontekst kan 31B-modellen behandle dokumenter opp til ~750 sider — tilstrekkelig for de fleste kontrakter, forskningsartikler og teknisk dokumentasjon.

Lokal RAG (Retrieval-Augmented Generation)

Kombiner Gemma 4 med en lokal vektordatabase for et fullstendig privat RAG-system:

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

# Bruk Gemma 4 for både embeddings og generering
embeddings = OllamaEmbeddings(model="gemma4:e4b")
llm = Ollama(model="gemma4:26b-moe")

# Opprett vector store fra dine dokumenter
vectorstore = Chroma.from_documents(documents, embeddings)

# Spør med 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?")

Bygge AI-funksjoner inn i applikasjoner

For utviklere som bygger applikasjoner med AI-kapasiteter, er det å kjøre Gemma 4 lokalt via Ollama sitt API den raskeste veien til en fungerende prototype. Det OpenAI-kompatible API-et betyr at du kan starte med lokal Gemma 4 for utvikling og bytte til cloud APIer for produksjon uten å endre applikasjonskoden.

Plattformer som ZBuild kan håndtere applikasjonsinfrastrukturen — frontend, backend, autentisering, database — mens du fokuserer på AI-integrasjonslaget. Pek applikasjonens AI-endepunkt til localhost:11434 under utvikling og bytt til et cloud-endepunkt når du er klar til å skalere.

Feilsøking

"Out of memory"-feil

Hvis du ser minnefeil:

Prøv en mindre kvantisering: ollama pull gemma4:31b-q3_K_M
Reduser kontekstvinduet: --num-ctx 4096
Lukk andre GPU-intensive applikasjoner
Bytt til en mindre modell: 26B MoE leverer nesten 31B-kvalitet til en lavere minnekostnad

Treg genereringshastighet

Hvis genereringen er tregere enn forventet:

Sjekk GPU-bruk: nvidia-smi (bør vise høy GPU-bruk)
Sørg for at modellen passer helt i VRAM — delvis CPU-avlastning er dramatisk tregere
Reduser --num-ctx for å frigjøre VRAM til beregninger
Sjekk om andre prosesser bruker GPU-en

Modell ikke funnet

Hvis ollama run gemma4:26b-moe feiler:

# List tilgjengelige modeller
ollama list

# Søk etter Gemma 4-modeller
ollama search gemma4

# Hent den spesifikke modellen
ollama pull gemma4:26b-moe

API-tilkobling avvist

Hvis applikasjoner ikke kan koble til localhost:11434:

# Sjekk om Ollama kjører
ollama list

# Start Ollama-serveren manuelt
ollama serve

# Sjekk porten
curl http://localhost:11434/api/tags

Beslutningstre for modellvalg

Bruk dette for å raskt velge riktig modell:

Har du en dedikert GPU med 16GB+ VRAM?

Ja → Vil du ha maksimal kvalitet eller maksimal effektivitet?
- Maksimal kvalitet → gemma4:31b (Q4_K_M, trenger 20GB)
- Maksimal effektivitet → gemma4:26b-moe (Q4_K_M, trenger 18GB)
Nei → Har du 8GB+ RAM?
- Ja → gemma4:e4b (Q4_K_M, bedre kvalitet)
- No → gemma4:e2b (Q4_K_M, kjører på 5GB)

For de fleste utviklere med en moderne stasjonær eller gaming-PC: Start med gemma4:26b-moe. Den tilbyr det beste forholdet mellom kvalitet og ressurser i hele Gemma 4-familien.

Hva du kan bygge

Med Gemma 4 kjørende lokalt har du en kostnadsfri AI-backend for:

Chat-applikasjoner med fullstendig personvern for samtalen
Kodeanalyse-verktøy som fungerer på proprietære kodebaser
Dokumentbehandlings-pipelines for sensitive data
Lokale AI-assistenter som fungerer offline
Prototype AI-funksjoner før du binder deg til kostnader for cloud API
Finjusterte modeller for domenespesifikke oppgaver (Apache 2.0 tillater dette fritt)

Apache 2.0-lisensen betyr at alt du bygger er ditt — ingen bruksbegrensninger, ingen inntektsdeling, ingen godkjenning nødvendig. Kjør det lokalt, distribuer det på dine servere, bygg det inn i dine produkter. Dette er slik virkelig åpen AI ser ut.

Kjør Gemma 4 lokalt på 5 minutter: Komplett guide for Ollama-oppsett (2026)