Hvor meget RAM skal jeg bruge for at køre Gemma 4 lokalt?

Gemma 4 E2B og E4B kan køre med så lidt som 5GB RAM med 4-bit quantization — enhver moderne bærbar computer er tilstrækkelig. 26B MoE-modellen kræver ca. 18GB RAM (passer i en RTX 4090's 24GB VRAM). 31B Dense-modellen kræver ca. 20GB RAM. Ved kørsel udelukkende på CPU skal du tilføje 20-30% mere RAM end modellens filstørrelse.

Hvilken Gemma 4-model skal jeg vælge til lokal brug?

Til bærbare computere uden dedikeret GPU: E2B (hurtigst, lettest). Til bærbare computere med GPU eller stationære: E4B (bedre kvalitet, stadig letvægt). Til stationære med en RTX 4090 eller tilsvarende: 26B MoE (bedste kvalitet-til-beregning-forhold). Til workstations med 24GB+ VRAM: 31B Dense (højeste kvalitet). 26B MoE er det ideelle valg for de fleste udviklere.

Er det gratis at bruge Gemma 4 lokalt?

Ja. Gemma 4 er udgivet under Apache 2.0, hvilket tillader ubegrænset brug, herunder kommercielle applikationer. Ollama er også gratis og open source. Den eneste omkostning er din hardware. Der er ingen API-gebyrer, ingen brugsbegrænsninger og ingen licensrestriktioner.

Hvor hurtig er Gemma 4 lokalt sammenlignet med cloud API'er?

På en RTX 4090 genererer Gemma 4 E4B 80-120 tokens per sekund. 26B MoE genererer 30-50 tokens/sek. 31B Dense genererer 20-35 tokens/sek. Cloud API'er som Google AI Studio kan være hurtigere til de største modeller, men tilføjer en netværksforsinkelse (latency) på 100-500ms pr. anmodning. Til interaktiv brug føles lokal inference på de mindre modeller øjeblikkelig.

Kan jeg bruge Gemma 4 lokalt som en API til mine applikationer?

Ja. Ollama eksponerer en lokal REST API på port 11434, som er kompatibel med OpenAI API-formatet. Enhver applikation, framework eller værktøj, der understøtter OpenAI API, kan oprette forbindelse til lokal Gemma 4 ved at pege base-URL'en til http://localhost:11434/v1. Dette inkluderer Python, Node.js og de fleste AI-frameworks.

Understøtter Gemma 4 GPU-acceleration med Ollama?

Ja. Ollama registrerer og bruger automatisk NVIDIA GPU'er (CUDA), Apple Silicon (Metal) og AMD GPU'er (ROCm). Ingen yderligere konfiguration er nødvendig — hvis din GPU har nok VRAM til at rumme modellen, vil Ollama automatisk bruge den. NVIDIA har også udgivet RTX-optimerede versioner af Gemma 4 for yderligere ydeevneforbedringer.

Vigtigste pointer

At køre Gemma 4 lokalt tager mindre end 5 minutter med Ollama: installer Ollama, kør én kommando, og du har en fuldt kapabel AI-model kørende på din egen hardware med nul API-omkostninger, nul data der forlader din maskine og nul brugsbegrænsninger under Apache 2.0. E2B-modellen kører på enhver bærbar computer. 26B MoE-modellen passer på et enkelt RTX 4090 og leverer kvalitet, der konkurrerer med modeller med 10x dens aktive parameterantal.

Kør Gemma 4 lokalt: Den komplette guide

Hvorfor køre Gemma 4 lokalt?

Før vi går i dybden med opsætningen, er her grunden til, at lokal inferens betyder noget i 2026:

Privatliv — Dine data forlader aldrig din maskine. Ingen prompts sendes til eksterne servere. Kritisk for proprietær kode, juridiske dokumenter, medicinske data eller enhver følsom information.
Omkostninger — Nul pris pr. token efter den engangsinvestering i hardware. Storbrugere sparer hundredvis af dollars om måneden sammenlignet med API-prissætning.
Latens — Ingen netværksforsinkelser. E2B- og E4B-modellerne svarer på millisekunder på moderne hardware.
Pålidelighed — Ingen API-rategrænser, ingen nedetid, ingen ændringer i udbyderens politikker. Din model er altid tilgængelig.
Tilpasning — Finetun, kvantiser og modificer modellen frit under Apache 2.0.
Offline adgang — Fungerer uden internetforbindelse, når modellen først er downloadet.

Gemma 4 er særligt velegnet til lokal udrulning, fordi Google har designet de mindre modeller specifikt til edge- og on-device brug. E2B- og E4B-modellerne er ikke eftertanker — de er førsteklasses modeller optimeret til begrænsningerne i lokal hardware.

Forudsætninger

Hardwarekrav efter model

Model	Minimum RAM	Anbefalet VRAM	CPU-alene muligt?	Diskplads
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	Langsom	~9 GB
26B MoE (4-bit)	18 GB	16 GB	Meget langsom	~15 GB
26B MoE (FP16)	52 GB	48 GB	Nej	~52 GB
31B Dense (4-bit)	20 GB	18 GB	Meget langsom	~18 GB
31B Dense (FP16)	62 GB	48 GB+	Nej	~62 GB

Vigtigste pointe: Hvis du har en bærbar computer fra efter 2022, kan du køre E2B eller E4B. Hvis du har et RTX 4090 (24GB VRAM) eller en Apple M-serie Mac med 32GB+ RAM, kan du køre 26B MoE eller 31B Dense med 4-bit kvantisering.

Softwarekrav

Operativsystem: macOS, Linux eller Windows
Ollama: Version 0.6+ (download fra ollama.com)
GPU-drivere (valgfrit): NVIDIA CUDA 12+ til NVIDIA-GPU'er, ingen ekstra drivere nødvendige til Apple Silicon

Trin 1: Installer Ollama

macOS

Download fra ollama.com/download eller brug Homebrew:

brew install ollama

Linux

Installationsscript på én linje:

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

Windows

Download installationsprogrammet fra ollama.com/download og kør det. Ollama kører som en baggrundstjeneste på Windows.

Bekræft installation

ollama --version

Du bør se ollama version 0.6.x eller højere. Hvis du ser et versionsnummer, er Ollama installeret korrekt.

Kilde: Ollama installationsvejledning

Trin 2: Hent en Gemma 4-model

Vælg den model, der passer til din hardware:

Til bærbare computere og lette arbejdsopgaver

# Mindste model — kører på enhver moderne bærbar (5GB RAM)
ollama pull gemma4:e2b

# Lille model med bredere kapacitet (5-9GB RAM)
ollama pull gemma4:e4b

Til stationære computere med en dedikeret GPU

# Bedste effektivitet — flagskibskvalitet ved 3.8B aktive parametre (18GB RAM)
ollama pull gemma4:26b-moe

# Højeste kvalitet — fulde 31B parametre (20GB RAM)
ollama pull gemma4:31b

Specificering af kvantisering

Som standard henter Ollama den anbefalede kvantisering for hver model (normalt Q4_K_M for en god balance mellem kvalitet og størrelse). Du kan specificere forskellige kvantiseringer:

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

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

# Fuld præcision (kræver meget mere RAM)
ollama pull gemma4:31b-fp16

Downloaden vil tage et par minutter afhængigt af din internetforbindelse. Modelstørrelser varierer fra ~1.5GB (E2B 4-bit) til ~62GB (31B FP16).

Trin 3: Kør Gemma 4

Interaktiv chat

ollama run gemma4:e4b

Dette åbner en interaktiv chatsession. Skriv din prompt og tryk på Enter:

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

Modellen vil svare direkte i din terminal. Skriv /bye for at afslutte.

Enkelt prompt (ikke-interaktiv)

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

Med Thinking-tilstand

Gemma 4 understøtter konfigurerbar Thinking-tilstand til komplekse opgaver. Aktiver den ved at tilføje en system-prompt:

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

Til matematik, logik og komplekse analyseopgaver forbedrer Thinking-tilstanden svarkvaliteten betydeligt. Modellen vil generere 4,000+ tokens med intern ræsonnering, før den producerer sit endelige svar.

Trin 4: Brug det lokale API

Ollama eksponerer et REST API på localhost:11434, som er kompatibelt med OpenAI API-formatet. Dette betyder, at ethvert værktøj eller bibliotek, der understøtter OpenAI's API, kan oprette forbindelse til din lokale Gemma 4 med en simpel ændring af URL'en.

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 slutpunkt

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

Kilde: Ollama API-dokumentation

Trin 5: Integrer med din applikation

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

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

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

Forklaring af kvantiseringsmuligheder

Kvantisering reducerer modelstørrelsen og hukommelsesforbruget ved at bruge tal med lavere præcision til at repræsentere modelvægte. Afvejningen er mellem kvalitet og ressourceforbrug:

Kvantisering	Bits pr. vægt	Kvalitetspåvirkning	Hukommelsesbesparelse	Bedst til
FP16	16 bits	Ingen (fuld kvalitet)	Basislinje	Servere med rigelig VRAM
Q8_0	8 bits	Ubetydelig	~50%	Lokal inferens i høj kvalitet
Q6_K	6 bits	Meget lille	~62%	Kvalitetsfokuseret lokal brug
Q5_K_M	5 bits	Lille	~69%	God balance
Q4_K_M	4 bits	Lille	~75%	Anbefalet standard
Q3_K_M	3 bits	Moderat	~81%	Begrænset hardware
Q2_K	2 bits	Betydelig	~87%	Ekstreme begrænsninger

Q4_K_M er det gyldne middelvej for de fleste brugere. Kvalitetsforskellen fra FP16 er lille nok til, at de fleste opgaver producerer uadskillelige resultater, mens hukommelsesbesparelser på 75% gør forskellen mellem "har brug for en server" og "kører på min bærbare computer".

Valg af den rigtige kvantisering

For Gemma 4 E2B/E4B: Brug standarden (Q4_K_M). Disse modeller er allerede små nok til, at højere kvantisering ikke ændrer brugeroplevelsen væsentligt.

For Gemma 4 26B MoE: Q4_K_M passer i 18GB RAM, hvilket er inden for et RTX 4090's 24GB VRAM med plads til KV cache. Hvis du har 48GB+ VRAM (A6000, dobbelte GPU'er), kan du overveje Q8_0 for marginalt bedre kvalitet.

For Gemma 4 31B Dense: Q4_K_M ved 20GB passer i et RTX 4090 med snævre margener. Q5_K_M producerer lidt bedre resultater, men kræver ~24GB, hvilket bruger al tilgængelig VRAM. Hvis du har 32GB+ VRAM (RTX 5090, A6000), er Q6_K eller Q8_0 opgraderingen værd.

Optimering af ydeevne

GPU Offloading

Ollama flytter automatisk modellag til GPU'en, når VRAM er tilgængelig. Hvis kun en del af modellen passer i VRAM, deler Ollama den mellem GPU og CPU. Du kan styre dette:

# Force all layers to GPU (fails if insufficient VRAM)
OLLAMA_NUM_GPU=999 ollama run gemma4:26b-moe

# Force CPU only (useful for testing)
OLLAMA_NUM_GPU=0 ollama run gemma4:e4b

Konfiguration af kontekstvindue

Som standard bruger Ollama et kontekstvindue på 2048 tokens for effektivitet. For at udnytte Gemma 4's fulde kontekstkapaciteter:

# Set context window to 32K tokens
ollama run gemma4:26b-moe --num-ctx 32768

# Set context window to 128K tokens (requires more RAM)
ollama run gemma4:26b-moe --num-ctx 131072

Vigtigt: Større kontekstvinduer bruger mere RAM til KV cache. Et 128K kontekstvindue på 31B-modellen kan kræve 8-16GB ekstra RAM ud over modelvægtene. Start med 32K og øg kun, hvis dit brugsscenarie kræver det.

Samtidige anmodninger

Ollama understøtter servering af flere anmodninger samtidigt:

# Allow up to 4 concurrent requests
OLLAMA_NUM_PARALLEL=4 ollama serve

Hver samtidig anmodning tilføjer hukommelsesomkostninger til dens KV cache. På en 24GB GPU, der kører 26B MoE ved Q4_K_M (~18GB), har du cirka 6GB frirum — nok til 2-3 samtidige anmodninger med korte kontekster.

Keep-Alive indstillinger

Som standard holder Ollama modeller indlæst i hukommelsen i 5 minutter efter den sidste anmodning. Juster dette til dit brugsscenarie:

# Keep model loaded for 1 hour
OLLAMA_KEEP_ALIVE=3600 ollama serve

# Keep model loaded indefinitely
OLLAMA_KEEP_ALIVE=-1 ollama serve

# Unload immediately after each request (saves memory)
OLLAMA_KEEP_ALIVE=0 ollama serve

NVIDIA RTX-optimering

NVIDIA har udgivet optimerede builds af Gemma 4 til RTX-GPU'er. Disse optimeringer inkluderer:

Brugerdefinerede CUDA-kerner til Gemma 4's attention-mekanisme
TensorRT-LLM integration for hurtigere inferens
Flash Attention understøttelse for reduceret hukommelsesforbrug under inferens med lang kontekst
Optimeret KV cache-styring for bedre gennemløb

Installation af NVIDIA-optimeret Gemma 4

Hvis du har en RTX 4000- eller 5000-serie GPU:

# Check your GPU
nvidia-smi

# Pull the NVIDIA-optimized version (if available in Ollama)
ollama pull gemma4:31b-nvidia

Alternativt kan du bruge NVIDIA's AI Workbench eller TensorRT-LLM direkte for maksimal ydeevne. De NVIDIA-optimerede versioner kan give 30-50% hurtigere inferens på RTX-GPU'er sammenlignet med standard Ollama-builds.

Benchmarks for ydeevne i den virkelige verden

Målt på almindelige hardwarekonfigurationer:

Tokens pr. sekund (genereringshastighed)

Model	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 læsehastighed er cirka 4-5 tokens pr. sekund. Enhver model, der genererer over 10 tok/s, føles "øjeblikkelig" til interaktiv brug. E2B- og E4B-modellerne er hurtige nok til streaming i realtid på næsten enhver hardware.

Tid til første token (latens)

Model	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 applikationer betyder tiden til det første token mere end genereringshastigheden. E2B- og E4B-modellerne begynder at generere næsten øjeblikkeligt selv på CPU, hvilket gør dem ideelle til chat-interfaces i realtid.

Almindelige anvendelsesscenarier

Lokal kodningsassistent

Brug Gemma 4 som en privat kodningsassistent, der aldrig sender din kode 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."

Par dette med VS Code-udvidelser som Continue eller Twinny, der understøtter Ollama som backend.

Dokumentanalyse

Behandl følsomme 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 op til ~750 sider — tilstrækkeligt til de fleste kontrakter, forskningsartikler og teknisk dokumentation.

Lokal RAG (Retrieval-Augmented Generation)

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

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

Indbygning af AI-funktioner i applikationer

For udviklere, der bygger applikationer med AI-kapaciteter, er kørsel af Gemma 4 lokalt via Ollama's API den hurtigste vej til en fungerende prototype. Det OpenAI-kompatible API betyder, at du kan starte med lokal Gemma 4 til udvikling og skifte til cloud-API'er til produktion uden at ændre applikationskoden.

Platforme som ZBuild kan håndtere applikationsinfrastrukturen — frontend, backend, autentificering, database — mens du fokuserer på AI-integrationslaget. Peg din applikations AI-slutpunkt mod localhost:11434 under udvikling og skift til et cloud-slutpunkt, når du er klar til at skalere.

Fejlfinding

"Out of memory" fejl

Hvis du ser hukommelsesfejl:

Prøv en mindre kvantisering: ollama pull gemma4:31b-q3_K_M
Reducer kontekstvinduet: --num-ctx 4096
Luk andre GPU-intensive applikationer
Skift til en mindre model: 26B MoE leverer kvalitet tæt på 31B med lavere hukommelsesomkostninger

Langsom genereringshastighed

Hvis genereringen er langsommere end forventet:

Tjek GPU-udnyttelse: nvidia-smi (bør vise høj GPU-brug)
Sørg for, at modellen passer helt i VRAM — delvis CPU-offloading er betydeligt langsommere
Reducer --num-ctx for at frigøre VRAM til beregning
Tjek om andre processer bruger GPU'en

Model ikke fundet

Hvis ollama run gemma4:26b-moe fejler:

# List available models
ollama list

# Search for Gemma 4 models
ollama search gemma4

# Pull the specific model
ollama pull gemma4:26b-moe

API-forbindelse afvist

Hvis applikationer ikke kan oprette forbindelse til localhost:11434:

# Check if Ollama is running
ollama list

# Start the Ollama server manually
ollama serve

# Check the port
curl http://localhost:11434/api/tags

Beslutningstræ til modelvalg

Brug dette til hurtigt at vælge den rigtige model:

Har du en dedikeret GPU med 16GB+ VRAM?

Ja → Ønsker du maksimal kvalitet eller maksimal effektivitet?
- Maksimal kvalitet → gemma4:31b (Q4_K_M, kræver 20GB)
- Maksimal effektivitet → gemma4:26b-moe (Q4_K_M, kræver 18GB)
Nej → Har du 8GB+ RAM?
- Ja → gemma4:e4b (Q4_K_M, bedre kvalitet)
- Nej → gemma4:e2b (Q4_K_M, kører på 5GB)

For de fleste udviklere med en moderne stationær eller gaming-PC: Start med gemma4:26b-moe. Den tilbyder det bedste forhold mellem kvalitet og ressourcer i hele Gemma 4-familien.

Hvad du kan bygge

Med Gemma 4 kørende lokalt har du en AI-backend uden omkostninger til:

Chat-applikationer med fuldt privatliv for samtaler
Kodningsanalyseværktøjer, der fungerer på proprietære kodebaser
Dokumentbehandlings-pipelines til følsomme data
Lokale AI-assistenter, der fungerer offline
Prototype AI-funktioner før du forpligter dig til cloud API-omkostninger
Finetunede modeller til domænespecifikke opgaver (Apache 2.0 tillader dette frit)

Apache 2.0-licensen betyder, at alt det, du bygger, er dit — ingen brugsbegrænsninger, ingen indtægtsdeling, ingen godkendelse nødvendig. Kør det lokalt, udrul det på dine egne servere, indbyg det i dine produkter. Dette er, hvordan ægte åben AI ser ud.

Kør Gemma 4 lokalt på 5 minutter: Komplet Ollama installationsguide (2026)