Kluczowy wniosek

Uruchamianie Gemma 4 lokalnie zajmuje mniej niż 5 minut z Ollama: zainstaluj Ollama, uruchom jedno polecenie i masz w pełni funkcjonalny model AI działający na własnym sprzęcie przy zero kosztów API, zero danych opuszczających Twoją maszynę i zero ograniczeń użytkowania w ramach Apache 2.0. Model E2B działa na dowolnym laptopie. Model 26B MoE mieści się na pojedynczym RTX 4090 i zapewnia jakość, która dorównuje modelom o 10x większej liczbie aktywnych parametrów.

Uruchom Gemma 4 lokalnie: Kompletny przewodnik

Dlaczego warto uruchamiać Gemma 4 lokalnie?

Zanim przejdziemy do konfiguracji, oto dlaczego lokalna inferencja ma znaczenie w 2026:

• Prywatność — Twoje dane nigdy nie opuszczają Twojej maszyny. Brak promptów wysyłanych do zewnętrznych serwerów. Krytyczne dla autorskiego kodu, dokumentów prawnych, danych medycznych lub jakichkolwiek wrażliwych informacji.
• Koszt — Zero kosztów per-token po jednorazowej inwestycji w sprzęt. Intensywni użytkownicy oszczędzają setki dolarów miesięcznie w porównaniu do cenników API.
• Opóźnienie — Brak opóźnień sieciowych. Modele E2B i E4B odpowiadają w milisekundach na nowoczesnym sprzęcie.
• Niezawodność — Brak limitów API, brak przerw w działaniu, brak zmian w polityce dostawców. Twój model jest zawsze dostępny.
• Personalizacja — Możliwość swobodnego dostrajania, wykonywania quantization i modyfikowania modelu na licencji Apache 2.0.
• Dostęp offline — Działa bez połączenia z internetem po pobraniu modelu.

Gemma 4 jest szczególnie dobrze przystosowana do lokalnego wdrażania, ponieważ Google zaprojektowało mniejsze modele specjalnie do użytku na krawędzi sieci (edge) i urządzeniach końcowych. Modele E2B i E4B nie są produktami ubocznymi — to modele najwyższej klasy zoptymalizowane pod kątem ograniczeń lokalnego sprzętu.

Wymagania wstępne

Wymagania sprzętowe według modelu

Kluczowy wniosek: Jeśli posiadasz laptop wyprodukowany po 2022, możesz uruchomić E2B lub E4B. Jeśli posiadasz RTX 4090 (24GB VRAM) lub Apple M-series Mac z 32GB+ RAM, możesz uruchomić 26B MoE lub 31B Dense przy 4-bit quantization.

Wymagania programowe

• System operacyjny: macOS, Linux lub Windows
• Ollama: Wersja 0.6+ (pobierz z ollama.com)
• Sterowniki GPU (opcjonalnie): NVIDIA CUDA 12+ dla kart NVIDIA, brak dodatkowych sterowników dla Apple Silicon

Krok 1: Zainstaluj Ollama

macOS

Pobierz z ollama.com/download/mac lub użyj Homebrew:

brew install ollama

Linux

Skrypt instalacyjny w jednej linii:

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

Windows

Pobierz instalator z ollama.com/download/windows i uruchom go. Ollama działa w systemie Windows jako usługa w tle.

Weryfikacja instalacji

ollama --version

Powinieneś zobaczyć ollama version 0.6.x lub wyższą. Jeśli widzisz numer wersji, Ollama została zainstalowana poprawnie.

Źródło: Instrukcja instalacji Ollama

Krok 2: Pobierz model Gemma 4

Wybierz model pasujący do Twojego sprzętu:

Dla laptopów i lekkich zadań

# Najmniejszy model — działa na każdym nowoczesnym laptopie (5GB RAM)
ollama pull gemma4:e2b

# Mały model z szerszymi możliwościami (5-9GB RAM)
ollama pull gemma4:e4b

Dla komputerów stacjonarnych z dedykowaną kartą GPU

# Najlepsza efektywność — jakość flagowca przy 3.8B aktywnych parametrach (18GB RAM)
ollama pull gemma4:26b-moe

# Najwyższa jakość — pełne 31B parametrów (20GB RAM)
ollama pull gemma4:31b

Określanie Quantization

Domyślnie Ollama pobiera zalecaną quantization dla każdego modelu (zazwyczaj Q4_K_M dla dobrego balansu jakości do rozmiaru). Możesz określić inne wersje quantization:

# Wyższa jakość, większy rozmiar
ollama pull gemma4:31b-q5_K_M

# Mniejszy rozmiar, nieco niższa jakość
ollama pull gemma4:31b-q3_K_M

# Pełna precyzja (wymaga znacznie więcej RAM)
ollama pull gemma4:31b-fp16

Pobieranie zajmie kilka minut w zależności od Twojego połączenia internetowego. Rozmiary modeli wahają się od ~1.5GB (E2B 4-bit) do ~62GB (31B FP16).

Krok 3: Uruchom Gemma 4

Interaktywny czat

ollama run gemma4:e4b

To otworzy interaktywną sesję czatu. Wpisz swój prompt i naciśnij Enter:

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

Model odpowie bezpośrednio w Twoim terminalu. Wpisz /bye, aby wyjść.

Pojedynczy prompt (nieinteraktywny)

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

Z trybem myślenia (Thinking Mode)

Gemma 4 obsługuje konfigurowalny tryb myślenia dla złożonych zadań. Włącz go, dodając system prompt:

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

W zadaniach matematycznych, logicznych i złożonych analizach tryb myślenia znacząco poprawia jakość odpowiedzi. Model wygeneruje ponad 4,000 tokens wewnętrznego rozumowania przed przedstawieniem ostatecznej odpowiedzi.

Krok 4: Użyj lokalnego API

Ollama udostępnia REST API pod adresem localhost:11434, które jest kompatybilne z formatem OpenAI API. Oznacza to, że każde narzędzie lub biblioteka wspierająca API OpenAI może połączyć się z Twoją lokalną Gemma 4 poprzez prostą zmianę adresu URL.

Przetestuj API za 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
}'

Punkt końcowy kompatybilny z OpenAI

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

Źródło: Dokumentacja API Ollama

Krok 5: Zintegruj ze swoją aplikacją

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

Użycie z 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)

Użycie z 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)

Wyjaśnienie opcji Quantization

Quantization zmniejsza rozmiar modelu i zużycie pamięci poprzez użycie liczb o niższej precyzji do reprezentowania wag modelu. Odbywa się to kosztem kompromisu między jakością a zużyciem zasobów:

Q4_K_M to optymalny punkt (sweet spot) dla większości użytkowników. Różnica w jakości w porównaniu do FP16 jest na tyle mała, że w większości zadań wyniki są nieodróżnialne, podczas gdy oszczędność pamięci rzędu 75% stanowi o różnicy między "wymaga serwera" a "działa na moim laptopie".

Wybór właściwej Quantization

Dla Gemma 4 E2B/E4B: Używaj domyślnej (Q4_K_M). Modele te są już na tyle małe, że wyższa quantization nie zmienia znacząco wrażeń użytkownika.

Dla Gemma 4 26B MoE: Q4_K_M mieści się w 18GB RAM, co mieści się w 24GB VRAM karty RTX 4090, pozostawiając miejsce na KV cache. Jeśli masz 48GB+ VRAM (A6000, dwie karty GPU), rozważ Q8_0 dla nieco lepszej jakości.

Dla Gemma 4 31B Dense: Q4_K_M przy 20GB mieści się na RTX 4090 z niewielkim marginesem. Q5_K_M daje nieco lepsze rezultaty, ale wymaga ~24GB, zużywając całą dostępną VRAM. Jeśli masz 32GB+ VRAM (RTX 5090, A6000), Q6_K lub Q8_0 są warte rozważenia.

Optymalizacja wydajności

Przenoszenie obliczeń na GPU (GPU Offloading)

Ollama automatycznie przenosi warstwy modelu na GPU, gdy VRAM jest dostępna. Jeśli tylko część modelu mieści się w VRAM, Ollama dzieli zadania między GPU i CPU. Możesz to kontrolować:

# Wymuś wszystkie warstwy na GPU (zakończy się błędem przy braku VRAM)
OLLAMA_NUM_GPU=999 ollama run gemma4:26b-moe

# Wymuś tylko CPU (przydatne do testów)
OLLAMA_NUM_GPU=0 ollama run gemma4:e4b

Konfiguracja okna kontekstowego (Context Window)

Domyślnie Ollama używa okna kontekstowego o rozmiarze 2048 tokens dla większej wydajności. Aby wykorzystać pełne możliwości kontekstu Gemma 4:

# Ustaw okno kontekstowe na 32K tokens
ollama run gemma4:26b-moe --num-ctx 32768

# Ustaw okno kontekstowe na 128K tokens (wymaga więcej RAM)
ollama run gemma4:26b-moe --num-ctx 131072

Ważne: Większe okna kontekstowe zużywają więcej RAM na KV cache. Okno 128K na modelu 31B może wymagać dodatkowych 8-16GB RAM poza wagami modelu. Zacznij od 32K i zwiększaj tylko, jeśli Twój przypadek użycia tego wymaga.

Równoczesne żądania

Ollama wspiera obsługę wielu żądań jednocześnie:

# Pozwól na do 4 równoczesnych żądań
OLLAMA_NUM_PARALLEL=4 ollama serve

Każde równoczesne żądanie zwiększa zużycie pamięci przez KV cache. Na GPU 24GB uruchamiającym 26B MoE przy Q4_K_M (~18GB), masz około 6GB zapasu — wystarczająco na 2-3 równoczesne żądania z krótkimi kontekstami.

Ustawienia Keep-Alive

Domyślnie Ollama trzyma modele załadowane w pamięci przez 5 minut po ostatnim żądaniu. Możesz to dostosować:

# Trzymaj model załadowany przez 1 godzinę
OLLAMA_KEEP_ALIVE=3600 ollama serve

# Trzymaj model załadowany bezterminowo
OLLAMA_KEEP_ALIVE=-1 ollama serve

# Usuń z pamięci natychmiast po każdym żądaniu (oszczędza pamięć)
OLLAMA_KEEP_ALIVE=0 ollama serve

Optymalizacja NVIDIA RTX

NVIDIA udostępniła zoptymalizowane wersje Gemma 4 dla kart graficznych RTX. Optymalizacje te obejmują:

• Niestandardowe jądra CUDA dla mechanizmu attention w Gemma 4
• Integrację TensorRT-LLM dla szybszej inferencji
• Wsparcie Flash Attention dla zmniejszenia zużycia pamięci podczas inferencji z długim kontekstem
• Zoptymalizowane zarządzanie KV cache dla lepszej przepustowości

Instalacja NVIDIA-Optimized Gemma 4

Jeśli posiadasz GPU z serii RTX 4000 lub 5000:

# Sprawdź swoje GPU
nvidia-smi

# Pobierz wersję zoptymalizowaną przez NVIDIA (jeśli dostępna w Ollama)
ollama pull gemma4:31b-nvidia

Alternatywnie możesz użyć NVIDIA AI Workbench lub bezpośrednio TensorRT-LLM dla maksymalnej wydajności. Wersje zoptymalizowane przez NVIDIA mogą zapewnić o 30-50% szybszą inferencję na kartach RTX w porównaniu do standardowych kompilacji Ollama.

Rzeczywiste testy wydajności

Zmierzone na popularnych konfiguracjach sprzętowych:

Tokeny na sekundę (Prędkość generowania)

Kontekst: Prędkość czytania człowieka to około 4-5 tokens na sekundę. Każdy model generujący powyżej 10 tok/s wydaje się "natychmiastowy" w interaktywnym użyciu. Modele E2B i E4B są wystarczająco szybkie do strumieniowania w czasie rzeczywistym na niemal każdym sprzęcie.

Czas do pierwszego tokena (Opóźnienie)

W aplikacjach interaktywnych czas do pierwszego tokena ma większe znaczenie niż prędkość generowania. Modele E2B i E4B zaczynają generować tekst niemal natychmiast nawet na CPU, co czyni je idealnymi do interfejsów czatu w czasie rzeczywistym.

Typowe przypadki użycia

Lokalny asystent kodowania

Używaj Gemma 4 jako prywatnego asystenta kodowania, który nigdy nie wysyła Twojego kodu na zewnętrzne serwery:

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

Połącz to z rozszerzeniami VS Code takimi jak Continue lub Twinny, które wspierają Ollama jako backend.

Analiza dokumentów

Przetwarzaj wrażliwe dokumenty lokalnie:

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

Dzięki kontekstowi 256K, model 31B może przetwarzać dokumenty o długości do ~750 stron — co jest wystarczające dla większości umów, prac badawczych i dokumentacji technicznej.

Lokalny RAG (Retrieval-Augmented Generation)

Połącz Gemma 4 z lokalną wektorową bazą danych dla w pełni prywatnego systemu RAG:

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

Budowanie funkcji AI w aplikacjach

Dla programistów budujących aplikacje z funkcjami AI, uruchamianie Gemma 4 lokalnie przez API Ollama jest najszybszą drogą do działającego prototypu. API kompatybilne z OpenAI oznacza, że możesz zacząć od lokalnej Gemma 4 podczas programowania i przełączyć się na chmurowe API w produkcji bez zmiany kodu aplikacji.

Platformy takie jak ZBuild mogą zająć się infrastrukturą aplikacji — frontendem, backendem, uwierzytelnianiem, bazą danych — podczas gdy Ty skupiasz się na warstwie integracji AI. Skieruj punkt końcowy AI swojej aplikacji na localhost:11434 podczas deweloperki i zamień go na punkt chmurowy, gdy będziesz gotowy do skalowania.

Rozwiązywanie problemów

Błędy "Out of memory"

Jeśli widzisz błędy pamięci:

1. Spróbuj mniejszej quantization: ollama pull gemma4:31b-q3_K_M
2. Zmniejsz okno kontekstowe: --num-ctx 4096
3. Zamknij inne aplikacje intensywnie korzystające z GPU
4. Przełącz się na mniejszy model: 26B MoE zapewnia jakość zbliżoną do 31B przy niższym koszcie pamięci

Niska prędkość generowania

Jeśli generowanie jest wolniejsze niż oczekiwano:

1. Sprawdź obciążenie GPU: nvidia-smi (powinno pokazywać wysokie użycie GPU)
2. Upewnij się, że model mieści się w całości w VRAM — częściowe przenoszenie na CPU jest drastycznie wolniejsze
3. Zmniejsz --num-ctx, aby zwolnić VRAM dla obliczeń
4. Sprawdź, czy inne procesy nie używają GPU

Model nie został znaleziony

Jeśli ollama run gemma4:26b-moe nie zadziała:

# List available models
ollama list

# Search for Gemma 4 models
ollama search gemma4

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

Połączenie z API odrzucone

Jeśli aplikacje nie mogą połączyć się z 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

Drzewo decyzyjne wyboru modelu

Użyj tego, aby szybko wybrać właściwy model:

Czy masz dedykowaną kartę GPU z 16GB+ VRAM?

• Tak → Czy zależy Ci na maksymalnej jakości, czy maksymalnej wydajności?
  • Maksymalna jakość → gemma4:31b (Q4_K_M, wymaga 20GB)
  • Maksymalna wydajność → gemma4:26b-moe (Q4_K_M, wymaga 18GB)
• Nie → Czy masz 8GB+ RAM?
  • Tak → gemma4:e4b (Q4_K_M, lepsza jakość)
  • Nie → gemma4:e2b (Q4_K_M, działa na 5GB)

Dla większości programistów z nowoczesnym komputerem stacjonarnym lub PC do gier: Zacznij od gemma4:26b-moe. Oferuje najlepszy stosunek jakości do zasobów w całej rodzinie Gemma 4.

Co możesz zbudować

Z Gemma 4 działającą lokalnie, masz darmowy backend AI dla:

• Aplikacji czatowych z pełną prywatnością rozmów
• Narzędzi do analizy kodu, które działają na autorskich bazach kodu
• Potoków przetwarzania dokumentów dla wrażliwych danych
• Lokalnych asystentów AI, którzy działają offline
• Prototypów funkcji AI przed zobowiązaniem się do kosztów API w chmurze
• Dostrojonych modeli (fine-tuned) do zadań specyficznych dla danej dziedziny (Apache 2.0 pozwala na to swobodnie)

Licencja Apache 2.0 oznacza, że wszystko, co zbudujesz, należy do Ciebie — brak ograniczeń użytkowania, brak dzielenia się przychodami, brak konieczności uzyskiwania zgody. Uruchamiaj lokalnie, wdrażaj na własnych serwerach, osadzaj w swoich produktach. Tak właśnie wygląda prawdziwie otwarte AI.

Źródła

• Gemma 4 Announcement - Google Blog
• Gemma 4 on Ollama
• Ollama Installation Guide
• Ollama API Documentation
• NVIDIA Gemma 4 RTX Optimization
• Gemma 4 Technical Report - Google DeepMind
• Gemma 4 Hugging Face Models
• Continue.dev - Local AI Code Assistant
• LangChain Ollama Integration
• Google AI for Developers - Gemma