Hur mycket RAM behöver jag för att köra Gemma 4 lokalt?

Gemma 4 E2B och E4B körs på så lite som 5GB RAM med 4-bit quantization — vilken modern laptop som helst räcker. 26B MoE-modellen behöver cirka 18GB RAM (får plats i en RTX 4090:s 24GB VRAM). 31B Dense-modellen behöver cirka 20GB RAM. För CPU-only-exekvering bör du lägga till 20–30 % mer RAM än modellens storlek.

Vilken Gemma 4-modell ska jag välja för lokal användning?

För laptops utan en dedikerad GPU: E2B (snabbast, lättast). För laptops med GPU eller stationära datorer: E4B (bättre kvalitet, fortfarande lättviktig). För stationära datorer med en RTX 4090 eller motsvarande: 26B MoE (bäst förhållande mellan kvalitet och beräkningskraft). För workstations med 24GB+ VRAM: 31B Dense (högsta kvalitet). 26B MoE är det bästa valet för de flesta utvecklare.

Är Gemma 4 gratis att använda lokalt?

Ja. Gemma 4 släpps under Apache 2.0, vilket tillåter obegränsad användning inklusive kommersiella applikationer. Ollama är också gratis och open source. Den enda kostnaden är din hårdvara. Det finns inga API-avgifter, inga användningsgränser och inga licensrestriktioner.

Hur snabb är Gemma 4 lokalt jämfört med cloud APIs?

På en RTX 4090 genererar Gemma 4 E4B 80–120 tokens per sekund. 26B MoE genererar 30–50 tokens/sek. 31B Dense genererar 20–35 tokens/sek. Cloud APIs som Google AI Studio kan vara snabbare för de största modellerna men tillför en nätverkslatens på 100–500ms per förfrågan. För interaktiv användning känns lokal inference på de mindre modellerna omedelbar.

Kan jag använda Gemma 4 lokalt som ett API för mina applikationer?

Ja. Ollama exponerar ett lokalt REST API på port 11434 som är kompatibelt med OpenAI API-formatet. Alla applikationer, ramverk eller verktyg som stöder OpenAI API kan ansluta till lokal Gemma 4 genom att peka base URL till http://localhost:11434/v1. Detta inkluderar Python, Node.js och de flesta AI-ramverk.

Stöder Gemma 4 GPU-acceleration med Ollama?

Ja. Ollama detekterar och använder automatiskt NVIDIA-GPU:er (CUDA), Apple Silicon (Metal) och AMD-GPU:er (ROCm). Ingen ytterligare konfiguration behövs — om din GPU har tillräckligt med VRAM för att rymma modellen kommer Ollama att använda den automatiskt. NVIDIA har också släppt RTX-optimerade versioner av Gemma 4 för ytterligare prestandavinster.

Viktigaste slutsatser

Att köra Gemma 4 lokalt tar mindre än 5 minuter med Ollama: installera Ollama, kör ett kommando, och du har en fullt kapabel AI-modell som körs på din egen hårdvara med noll API-kostnader, noll data som lämnar din maskin och noll användningsrestriktioner under Apache 2.0. E2B-modellen körs på vilken bärbar dator som helst. 26B MoE-modellen får plats på ett enda RTX 4090 och levererar kvalitet som rivaliserar med modeller som har 10x fler aktiva parametrar.

Kör Gemma 4 lokalt: Den kompletta guiden

Varför köra Gemma 4 lokalt?

Innan vi går in på installationen, här är varför lokal inferens är viktigt 2026:

Integritet — Din data lämnar aldrig din maskin. Inga prompts skickas till externa servrar. Avgörande för proprietär kod, juridiska dokument, medicinsk data eller annan känslig information.
Kostnad — Noll kostnad per token efter den engångsinvestering hårdvaran innebär. Storanvändare sparar hundratals dollar per månad jämfört med API-prissättning.
Latens — Inga nätverksanrop fram och tillbaka. E2B- och E4B-modellerna svarar på millisekunder på modern hårdvara.
Tillförlitlighet — Inga API-begränsningar, inga avbrott, inga ändringar i leverantörens policyer. Din modell är alltid tillgänglig.
Anpassning — Finjustera, kvantisera och modifiera modellen fritt under Apache 2.0.
Offline-åtkomst — Fungerar utan internetanslutning när modellen väl är nedladdad.

Gemma 4 är särskilt väl lämpad för lokal distribution eftersom Google designade de mindre modellerna specifikt för edge- och enhetsanvändning. E2B- och E4B-modellerna är inte efterhandskonstruktioner — de är förstklassiga modeller optimerade för begränsningarna i lokal hårdvara.

Förutsättningar

Hårdvarukrav per modell

Modell	Minsta RAM	Rekommenderat VRAM	Fungerar med enbart CPU?	Diskutrymme
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	Långsamt	~9 GB
26B MoE (4-bit)	18 GB	16 GB	Mycket långsamt	~15 GB
26B MoE (FP16)	52 GB	48 GB	Nej	~52 GB
31B Dense (4-bit)	20 GB	18 GB	Mycket långsamt	~18 GB
31B Dense (FP16)	62 GB	48 GB+	Nej	~62 GB

Viktig slutsats: Om du har en bärbar dator tillverkad efter 2022 kan du köra E2B eller E4B. Om du har ett RTX 4090 (24GB VRAM) eller en Apple M-serie Mac med 32GB+ RAM, kan du köra 26B MoE eller 31B Dense med 4-bit kvantisering.

Programvarukrav

Operativsystem: macOS, Linux eller Windows
Ollama: Version 0.6+ (ladda ner från ollama.com)
GPU-drivrutiner (valfritt): NVIDIA CUDA 12+ för NVIDIA-GPU:er, inga extra drivrutiner krävs för Apple Silicon

Steg 1: Installera Ollama

macOS

Ladda ner från ollama.com/download eller använd Homebrew:

brew install ollama

Linux

Installationsskript via en rad:

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

Windows

Ladda ner installationsprogrammet från ollama.com/download och kör det. Ollama körs som en bakgrundstjänst på Windows.

Verifiera installationen

ollama --version

Du bör se ollama version 0.6.x eller högre. Om du ser ett versionsnummer är Ollama korrekt installerat.

Källa: Ollama installationsguide

Steg 2: Hämta en Gemma 4-modell

Välj den modell som matchar din hårdvara:

För bärbara datorer och lätta arbetsbelastningar

# Minsta modellen — körs på alla moderna bärbara datorer (5GB RAM)
ollama pull gemma4:e2b

# Liten modell med bredare förmåga (5-9GB RAM)
ollama pull gemma4:e4b

För stationära datorer med en dedikerad GPU

# Bästa effektivitet — flaggskeppskvalitet med 3.8B aktiva parametrar (18GB RAM)
ollama pull gemma4:26b-moe

# Högsta kvalitet — fullständiga 31B parametrar (20GB RAM)
ollama pull gemma4:31b

Specificera kvantisering

Som standard hämtar Ollama den rekommenderade kvantiseringen för varje modell (vanligtvis Q4_K_M för bra balans mellan kvalitet och storlek). Du kan specificera andra kvantiseringar:

# Högre kvalitet, större storlek
ollama pull gemma4:31b-q5_K_M

# Mindre storlek, något lägre kvalitet
ollama pull gemma4:31b-q3_K_M

# Full precision (kräver mycket mer RAM)
ollama pull gemma4:31b-fp16

Nedladdningen tar några minuter beroende på din internetanslutning. Modellstorlekar varierar från ~1.5GB (E2B 4-bit) till ~62GB (31B FP16).

Steg 3: Kör Gemma 4

Interaktiv chatt

ollama run gemma4:e4b

Detta öppnar en interaktiv chattsession. Skriv din prompt och tryck på Enter:

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

Modellen svarar direkt i din terminal. Skriv /bye för att avsluta.

Enstaka prompt (icke-interaktiv)

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

Med Thinking-läge

Gemma 4 stöder konfigurerbart Thinking-läge för komplexa uppgifter. Aktivera det genom att lägga till en system-prompt:

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

För matematik, logik och komplexa analysuppgifter förbättrar Thinking-läget svarskvaliteten avsevärt. Modellen kommer att generera 4,000+ tokens av interna resonemang innan den producerar sitt slutgiltiga svar.

Steg 4: Använd det lokala API:et

Ollama exponerar ett REST API på localhost:11434 som är kompatibelt med OpenAI API-formatet. Detta innebär att alla verktyg eller bibliotek som stöder OpenAI:s API kan ansluta till din lokala Gemma 4 med en enkel ändring av URL.

Testa 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-kompatibel endpoint

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

Källa: Ollama API-dokumentation

Steg 5: Integrera 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"]

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

Python med OpenAI SDK

from openai import OpenAI

# Peka på lokala Ollama istället för OpenAI
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # Ollama kräver inte en riktig API-nyckel
)

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

Användning 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)

Användning 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)

Förklaring av kvantiseringsalternativ

Kvantisering minskar modellens storlek och minnesanvändning genom att använda tal med lägre precision för att representera modellvikter. Avvägningen sker mellan kvalitet och resursanvändning:

Kvantisering	Bitar per vikt	Kvalitetspåverkan	Minnesbesparing	Bäst för
FP16	16 bits	Ingen (full kvalitet)	Baslinje	Servrar med gott om VRAM
Q8_0	8 bits	Försumbar	~50%	Högkvalitativ lokal inferens
Q6_K	6 bits	Mycket liten	~62%	Kvalitetsfokuserad lokal användning
Q5_K_M	5 bits	Liten	~69%	Bra balans
Q4_K_M	4 bits	Liten	~75%	Rekommenderad standard
Q3_K_M	3 bits	Måttlig	~81%	Begränsad hårdvara
Q2_K	2 bits	Betydande	~87%	Extrema begränsningar

Q4_K_M är den optimala punkten för de flesta användare. Qualitätsskillnaden från FP16 är så pass liten att de flesta uppgifter ger omärkbara resultat, medan minnesbesparingen på 75% utgör skillnaden mellan "behöver en server" och "körs på min bärbara dator".

Att välja rätt kvantisering

För Gemma 4 E2B/E4B: Använd standard (Q4_K_M). Dessa modeller är redan tillräckligt små för att högre kvantisering inte ska förändra användarupplevelsen nämnvärt.

För Gemma 4 26B MoE: Q4_K_M får plats i 18GB RAM, vilket ryms inom ett RTX 4090:s 24GB VRAM med utrymme kvar för KV cache. Om du har 48GB+ VRAM (A6000, dubbla GPU:er), överväg Q8_0 för marginellt bättre kvalitet.

För Gemma 4 31B Dense: Q4_K_M på 20GB får plats i ett RTX 4090 med snäva marginaler. Q5_K_M ger något bättre resultat men kräver ~24GB, vilket förbrukar allt tillgängligt VRAM. Om du har 32GB+ VRAM (RTX 5090, A6000) är Q6_K eller Q8_0 värda uppgraderingen.

Prestandaoptimering

GPU Offloading

Ollama flyttar automatiskt över modellager till GPU:n när VRAM finns tillgängligt. Om endast en del av modellen får plats i VRAM, delar Ollama upp den mellan GPU och CPU. Du kan kontrollera detta:

# Tvinga alla lager till GPU (misslyckas vid otillräckligt VRAM)
OLLAMA_NUM_GPU=999 ollama run gemma4:26b-moe

# Tvinga enbart CPU (användbart för testning)
OLLAMA_NUM_GPU=0 ollama run gemma4:e4b

Konfiguration av kontextfönster

Som standard använder Ollama ett kontextfönster på 2048 tokens för effektivitet. För att utnyttja Gemma 4:s fulla kontextkapacitet:

# Sätt kontextfönstret till 32K tokens
ollama run gemma4:26b-moe --num-ctx 32768

# Sätt kontextfönstret till 128K tokens (kräver mer RAM)
ollama run gemma4:26b-moe --num-ctx 131072

Viktigt: Större kontextfönster förbrukar mer RAM för KV cache. Ett 128K kontextfönster på 31B-modellen kan kräva 8-16GB extra RAM utöver modellvikterna. Börja med 32K och öka endast om ditt användningsfall kräver det.

Samtidiga anrop

Ollama stöder hantering av flera anrop samtidigt:

# Tillåt upp till 4 samtidiga anrop
OLLAMA_NUM_PARALLEL=4 ollama serve

Varje samtidigt anrop lägger till minnesbelastning för sin KV cache. På en 24GB GPU som kör 26B MoE med Q4_K_M (~18GB), har du ungefär 6GB marginal — tillräckligt för 2-3 samtidiga anrop med korta kontexter.

Keep-Alive inställningar

Som standard behåller Ollama modeller laddade i minnet i 5 minuter efter det senaste anropet. Justera detta för ditt användningsfall:

# Behåll modellen laddad i 1 timme
OLLAMA_KEEP_ALIVE=3600 ollama serve

# Behåll modellen laddad obestämd tid
OLLAMA_KEEP_ALIVE=-1 ollama serve

# Avlasta omedelbart efter varje anrop (sparar minne)
OLLAMA_KEEP_ALIVE=0 ollama serve

NVIDIA RTX Optimering

NVIDIA har släppt optimerade versioner av Gemma 4 för RTX-GPU:er. Dessa optimeringar inkluderar:

Anpassade CUDA-kärnor för Gemma 4:s attention-mekanism
TensorRT-LLM integration för snabbare inferens
Flash Attention stöd för minskad minnesanvändning vid inferens med lång kontext
Optimerad KV cache-hantering för bättre genomströmning

Installera NVIDIA-optimerad Gemma 4

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

# Kontrollera din GPU
nvidia-smi

# Hämta den NVIDIA-optimerade versionen (om tillgänglig i Ollama)
ollama pull gemma4:31b-nvidia

Alternativt kan du använda NVIDIA:s AI Workbench eller TensorRT-LLM direkt för maximal prestanda. De NVIDIA-optimerade versionerna kan ge 30-50% snabbare inferens på RTX-GPU:er jämfört med standardversioner av Ollama.

Prestandatester i verkligheten

Uppmätt på vanliga hårdvarukonfigurationer:

Tokens per sekund (genereringshastighet)

Modell	RTX 4090 (24GB)	RTX 3090 (24GB)	M3 Max (36GB)	Enbart 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: Mänsklig läshastighet är ungefär 4-5 tokens per sekund. Varje modell som genererar över 10 tok/s känns "omedelbar" vid interaktiv användning. E2B- och E4B-modellerna är snabba nog för streaming i realtid på nästan vilken hårdvara som helst.

Tid till första token (latens)

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

För interaktiva applikationer är tiden till första token viktigare än genereringshastigheten. E2B- och E4B-modellerna börjar generera nästan omedelbart även på CPU, vilket gör dem idealiska för chattgränssnitt i realtid.

Vanliga användningsområden

Lokal kodningsassistent

Använd Gemma 4 som en privat kodningsassistent som aldrig skickar din kod till externa servrar:

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

Para ihop detta med VS Code-tillägg som Continue eller Twinny som stöder Ollama som backend.

Dokumentanalys

Bearbeta känsliga dokument lokalt:

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

Med 256K kontext kan 31B-modellen bearbeta dokument på upp till ~750 sidor — tillräckligt för de flesta kontrakt, forskningsrapporter och teknisk dokumentation.

Lokal RAG (Retrieval-Augmented Generation)

Kombinera Gemma 4 med en lokal vektordatabas för ett helt privat RAG-system:

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

# Använd Gemma 4 för både embeddings och generering
embeddings = OllamaEmbeddings(model="gemma4:e4b")
llm = Ollama(model="gemma4:26b-moe")

# Skapa vector store från dina dokument
vectorstore = Chroma.from_documents(documents, embeddings)

# Fråga 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?")

Bygg AI-funktioner i applikationer

För utvecklare som bygger applikationer med AI-funktioner är körning av Gemma 4 lokalt via Ollama:s API den snabbaste vägen till en fungerande prototyp. Det OpenAI-kompatibla API:et innebär att du kan börja med lokala Gemma 4 för utveckling och byta till moln-API:er för produktion utan att ändra applikationskoden.

Plattformar som ZBuild kan hantera applikationsinfrastrukturen — frontend, backend, autentisering, databas — medan du fokuserar på AI-integrationslagret. Peka din applikations AI-endpoint mot localhost:11434 under utveckling och byt till en moln-endpoint när du är redo att skala upp.

Felsökning

"Out of memory"-fel

Om du ser minnesfel:

Prova en mindre kvantisering: ollama pull gemma4:31b-q3_K_M
Minska kontextfönstret: --num-ctx 4096
Stäng andra GPU-intensiva applikationer
Byt till en mindre modell: 26B MoE levererar kvalitet nära 31B till en lägre minneskostnad

Långsam genereringshastighet

Om genereringen är långsammare än förväntat:

Kontrollera GPU-användning: nvidia-smi (bör visa hög GPU-användning)
Säkerställ att modellen får plats helt i VRAM — partiell CPU-avlastning är dramatiskt långsammare
Minska --num-ctx för att frigöra VRAM för beräkningar
Kontrollera om andra processer använder GPU:n

Modellen hittades inte

Om ollama run gemma4:26b-moe misslyckas:

# Lista tillgängliga modeller
ollama list

# Sök efter Gemma 4-modeller
ollama search gemma4

# Hämta den specifika modellen
ollama pull gemma4:26b-moe

API-anslutning nekad

Om applikationer inte kan ansluta till localhost:11434:

# Kontrollera om Ollama körs
ollama list

# Starta Ollama-servern manuellt
ollama serve

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

Beslutsträd för modellval

Använd detta för att snabbt välja rätt modell:

Har du en dedikerad GPU med 16GB+ VRAM?

Ja → Vill du ha maximal kvalitet eller maximal effektivitet?
- Maximal kvalitet → gemma4:31b (Q4_K_M, kräver 20GB)
- Maximal effektivitet → gemma4:26b-moe (Q4_K_M, kräver 18GB)
Nej → Har du 8GB+ RAM?
- Ja → gemma4:e4b (Q4_K_M, bättre kvalitet)
- Nej → gemma4:e2b (Q4_K_M, körs på 5GB)

För de flesta utvecklare med en modern stationär dator eller gaming-PC: Börja med gemma4:26b-moe. Den erbjuder det bästa förhållandet mellan kvalitet och resurser i hela Gemma 4-familjen.

Vad du kan bygga

Med Gemma 4 körandes lokalt har du en kostnadsfri AI-backend för:

Chattapplikationer med fullständig integritet för konversationer
Kodanalysverktyg som fungerar på proprietära kodbaser
Pipelines för dokumentbehandling för känslig data
Lokala AI-assistenter som fungerar offline
Prototyper av AI-funktioner innan du förbinder dig till API-kostnader i molnet
Finjusterade modeller för domänspecifika uppgifter (Apache 2.0 tillåter detta fritt)

Apache 2.0-licensen innebär att allt du bygger är ditt — inga användningsrestriktioner, ingen vinstdelning, inget godkännande krävs. Kör det lokalt, distribuera det på dina servrar, bädda in det i dina produkter. Det här är vad sann öppen AI ser ut som.

Kör Gemma 4 lokalt på 5 minuter: Komplett Ollama-installationsguide (2026)