Ollama - Run large language models locally

Ollama - Uruchamianie dużych modeli językowych lokalnie na swoim komputerze

Czy zdarzyło ci się chcieć porozmawiać z AI, ale nie mogłeś wysłać danych do chmury? Albo chciałeś poeksperymentować z różnymi modelami bez płacenia za tokeny? A może po prostu chciałeś mieć pełną kontrolę nad tym, co się dzieje z twoimi danymi?

Ollama rozwiązuje te problemy w najprostszy możliwy sposób. Jedna komenda i masz potężny model językowy działający lokalnie na twoim komputerze - bez chmury, bez subskrypcji, bez limitów tokenów.

Czym jest Ollama?

Ollama to darmowy, open-source framework do pobierania, uruchamiania i zarządzania dużymi modelami językowymi (LLM) na lokalnym komputerze. Działa jak Docker dla modeli AI - wpisujesz jedną komendę, a Ollama zajmuje się resztą: pobiera model, konfiguruje kwantyzację, zarządza pamięcią i uruchamia lokalny serwer API.

Pod maską Ollama opiera się na bibliotece llama.cpp, dostarczając warstwę abstrakcji, która ukrywa niskopoziomowe szczegóły i sprawia, że praca z lokalnymi modelami jest tak prosta jak ollama run llama3.2.

Projekt ma ponad 162 tysiące gwiazdek na GitHubie, 500+ kontrybutorów i licencję MIT. To jeden z najszybciej rozwijających się projektów open-source w ekosystemie AI.

Dlaczego Ollama?

Prywatność danych

To główny powód, dla którego ludzie sięgają po Ollama. Twoje dane nigdy nie opuszczają twojego komputera. Żadne promptu, żadne odpowiedzi, żadne pliki nie są wysyłane do żadnej chmury. Dla firm pracujących z wrażliwymi danymi, kodem źródłowym czy dokumentacją wewnętrzną - to game changer.

Zero kosztów operacyjnych

Po pobraniu modelu nie płacisz za tokeny, za API calls, za subskrypcje. Model działa na twoim sprzęcie, a jedyny koszt to energia elektryczna. Jeśli dużo korzystasz z AI w pracy, oszczędności mogą być znaczące.

Prostota

Ollama robi jedną rzecz i robi ją dobrze. Nie ma skomplikowanej konfiguracji, nie ma dashboardów, nie ma setup wizardów. Instalacja to jedna komenda, uruchomienie modelu to jedna komenda, integracja z aplikacjami to jedno ustawienie URL.

Praca offline

Raz pobrany model działa bez internetu. Idealnie sprawdza się w samolotach, w miejscach bez WiFi, czy w środowiskach z ograniczonym dostępem do sieci.

Porównanie z alternatywami

Instalacja

macOS

brew install ollama

Lub pobierz natywny instalator ze strony ollama.com.

Linux

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

Windows

Pobierz instalator ze strony ollama.com lub użyj WSL2:

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

Docker

docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

Z obsługą GPU (NVIDIA):

docker run -d --gpus=all -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

Pierwsze kroki

Uruchamianie modelu

Po instalacji wystarczy jedna komenda:

ollama run llama3.2

Ollama automatycznie pobierze model (jeśli nie był jeszcze pobrany) i uruchomi interaktywną sesję czatu. Możesz od razu pisać i dostawać odpowiedzi.

Podstawowe komendy

ollama run llama3.2         # Uruchom model i rozpocznij czat
ollama pull gemma3           # Pobierz model bez uruchamiania
ollama list                  # Wyświetl zainstalowane modele
ollama ps                    # Pokaż aktualnie działające modele
ollama rm llama3.2           # Usuń model
ollama show llama3.2         # Pokaż szczegóły modelu
ollama serve                 # Uruchom serwer API (bez GUI)

Praca z modelem

W trybie interaktywnym możesz normalnie rozmawiać z modelem:

>>> Wyjaśnij mi czym jest TypeScript w 3 zdaniach

TypeScript to nadzbiór JavaScriptu, który dodaje statyczne typowanie do języka.
Pozwala wykrywać błędy na etapie kompilacji, zanim kod trafi do przeglądarki
lub środowiska Node.js. Jest rozwijany przez Microsoft i stał się standardem
w dużych projektach front-endowych i back-endowych.

Tryb multimodalny

Modele z obsługą wizji (np. Llama 3.2 Vision) pozwalają analizować obrazy:

ollama run llama3.2-vision
>>> What's in this image? /path/to/screenshot.png

Biblioteka modeli

Ollama udostępnia ponad 100 modeli w swojej bibliotece na ollama.com/library. Oto najważniejsze:

Modele ogólnego przeznaczenia

Modele do kodowania

Modele wizyjne

Modele embeddingowe

Jak wybrać model?

• 8 GB RAM: Llama 3.2 3B, Gemma 3 1B, Phi-3 3.8B
• 16 GB RAM: Llama 3.1 8B, Gemma 3 4B, Mistral 7B
• 32 GB RAM: Gemma 3 12B-27B, DeepSeek-R1 14B
• 64+ GB RAM: Llama 3.1 70B, DeepSeek-R1 32B+

Ogólna zasada: zacznij od mniejszego modelu (3B-8B) i zwiększaj rozmiar w zależności od potrzeb i dostępnego sprzętu.

REST API

Ollama uruchamia lokalny serwer API na porcie 11434, kompatybilny z formatem OpenAI. To oznacza, że wiele istniejących narzędzi i bibliotek może się z nim integrować bez zmian w kodzie.

Generowanie odpowiedzi

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Wyjaśnij czym jest React",
  "stream": false
}'

Chat API

curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [
    {"role": "system", "content": "Jesteś pomocnym asystentem programisty."},
    {"role": "user", "content": "Jak stworzyć hook w React?"}
  ],
  "stream": false
}'

Generowanie embeddingów

curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": "Ollama to framework do lokalnych LLM"
}'

OpenAI-compatible endpoint

Ollama oferuje endpoint kompatybilny z API OpenAI:

curl http://localhost:11434/v1/chat/completions -d '{
  "model": "llama3.2",
  "messages": [
    {"role": "user", "content": "Hello!"}
  ]
}'

Dzięki temu wystarczy zmienić base_url w istniejącym kodzie:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

response = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "Czym jest TypeScript?"}]
)
print(response.choices[0].message.content)

Tryb JSON

Wymuszenie odpowiedzi w formacie JSON:

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Podaj 3 frameworki JavaScript jako JSON array",
  "format": "json",
  "stream": false
}'

Biblioteki klienckie

Python

pip install ollama

import ollama

response = ollama.chat(
    model="llama3.2",
    messages=[{"role": "user", "content": "Czym jest Rust?"}]
)
print(response["message"]["content"])

Streaming:

import ollama

stream = ollama.chat(
    model="llama3.2",
    messages=[{"role": "user", "content": "Napisz wiersz o programowaniu"}],
    stream=True
)
for chunk in stream:
    print(chunk["message"]["content"], end="", flush=True)

JavaScript/TypeScript

npm install ollama

import { Ollama } from "ollama"

const ollama = new Ollama({ host: "http://localhost:11434" })

const response = await ollama.chat({
  model: "llama3.2",
  messages: [{ role: "user", content: "What is Next.js?" }],
})
console.log(response.message.content)

Modelfile - Tworzenie własnych modeli

Modelfile to plik konfiguracyjny (podobny do Dockerfile), który pozwala tworzyć niestandardowe warianty modeli. Możesz zmienić system prompt, parametry generowania, a nawet połączyć bazowy model z własnymi wagami.

Podstawowy Modelfile

FROM llama3.2

PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER num_ctx 4096

SYSTEM """
Jesteś doświadczonym programistą TypeScript i React.
Odpowiadasz zwięźle i podajesz praktyczne przykłady kodu.
Zawsze używasz najnowszych wzorców i best practices.
"""

Tworzenie i uruchamianie

ollama create typescript-helper -f Modelfile
ollama run typescript-helper

Zaawansowany Modelfile

FROM llama3.2

PARAMETER temperature 0.2
PARAMETER top_p 0.85
PARAMETER repeat_penalty 1.1
PARAMETER num_ctx 8192

TEMPLATE """
{{ if .System }}<|start_header_id|>system<|end_header_id|>
{{ .System }}<|eot_id|>{{ end }}{{ if .Prompt }}<|start_header_id|>user<|end_header_id|>
{{ .Prompt }}<|eot_id|>{{ end }}<|start_header_id|>assistant<|end_header_id|>
{{ .Response }}<|eot_id|>
"""

SYSTEM """
You are a code review assistant. Analyze code for bugs, security issues,
and performance problems. Always suggest specific improvements with code examples.
"""

Import modeli GGUF

Jeśli masz model w formacie GGUF (np. z Hugging Face), możesz go zaimportować:

FROM ./my-model-q4_K_M.gguf

PARAMETER temperature 0.8
SYSTEM "You are a helpful assistant."

ollama create my-custom-model -f Modelfile

Akceleracja GPU

Ollama automatycznie wykrywa i wykorzystuje dostępne GPU:

NVIDIA (CUDA)

Wymagania: compute capability 5.0+, sterownik 531+

ollama run llama3.2

Ollama automatycznie użyje CUDA jeśli jest dostępne. Dla wielu GPU:

CUDA_VISIBLE_DEVICES=0,1 ollama serve

Apple Silicon (Metal)

Na Macach z chipami M1/M2/M3/M4 Ollama automatycznie korzysta z Metal. Apple Silicon jest szczególnie dobrze obsługiwany - zunifikowana pamięć sprawia, że nawet większe modele działają płynnie.

AMD (ROCm)

Obsługiwane karty AMD z ROCm. Flash attention jest automatycznie włączany.

Wydajność GPU

Przybliżona prędkość generowania (tokeny/s) dla Llama 3.1 8B:

Docker i deployment produkcyjny

Podstawowy Docker Compose

services:
  ollama:
    image: ollama/ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama-data:/root/.ollama
    restart: unless-stopped
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

volumes:
  ollama-data:

Z Open WebUI

Popularna kombinacja - Ollama jako backend + Open WebUI jako interfejs graficzny:

services:
  ollama:
    image: ollama/ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama-data:/root/.ollama
    restart: unless-stopped

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    volumes:
      - open-webui-data:/app/backend/data
    depends_on:
      - ollama
    restart: unless-stopped

volumes:
  ollama-data:
  open-webui-data:

Preload modeli w Docker

FROM ollama/ollama

RUN ollama serve & sleep 5 && ollama pull llama3.2 && ollama pull nomic-embed-text

Konfiguracja

Zmienne środowiskowe

Udostępnianie w sieci lokalnej

Domyślnie Ollama słucha tylko na localhost. Żeby udostępnić w sieci:

OLLAMA_HOST=0.0.0.0:11434 ollama serve

Zmiana katalogu modeli

Modele mogą zajmować dużo miejsca. Żeby przenieść je na inny dysk:

OLLAMA_MODELS=/mnt/ssd/ollama/models ollama serve

Integracje

Ekosystem Ollama obejmuje 50+ integracji:

Interfejsy graficzne

• Open WebUI - najbardziej popularny interfejs webowy, wygląda jak ChatGPT
• LibreChat - wieloproviderowy czat z obsługą wielu modeli
• Chatbox - desktopowa aplikacja wieloplatformowa
• Enchanted - natywna aplikacja macOS
• Lobe Chat - nowoczesny interfejs z pluginami

Frameworki AI

• LangChain - budowanie pipeline'ów RAG, agentów, łańcuchów
• LlamaIndex - indeksowanie dokumentów i wyszukiwanie semantyczne
• CrewAI - orkiestracja zespołów agentów AI
• AutoGen - multi-agentowe konwersacje

Narzędzia deweloperskie

• Continue - asystent kodowania w VS Code i JetBrains
• Aider - AI pair programming w terminalu
• Cody - Sourcegraph AI coding assistant
• GitHub Copilot (self-hosted backend) - przez OpenAI-compatible API

RAG i wyszukiwanie

• RAGFlow - silnik RAG z obsługą dokumentów
• AnythingLLM - all-in-one AI z RAG
• PrivateGPT - prywatne Q&A po dokumentach

Praktyczne zastosowania

Asystent kodowania

ollama create code-assistant -f - <<EOF
FROM codellama:13b
PARAMETER temperature 0.3
SYSTEM "You are a senior software engineer. Write clean, well-tested code. Always include error handling."
EOF

ollama run code-assistant
>>> Write a TypeScript function that fetches data with retry logic

Analiza kodu źródłowego

cat src/components/App.tsx | ollama run llama3.2 "Review this React component for potential issues"

Generowanie dokumentacji

cat src/utils/helpers.ts | ollama run llama3.2 "Generate JSDoc documentation for these functions"

Lokalne tłumaczenia

ollama run llama3.2 "Translate to Polish: The quick brown fox jumps over the lazy dog"

RAG z własnymi dokumentami

Połączenie Ollama z LlamaIndex do wyszukiwania po własnych dokumentach:

from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

llm = Ollama(model="llama3.2", request_timeout=120)
embed = OllamaEmbedding(model_name="nomic-embed-text")

documents = SimpleDirectoryReader("./docs").load_data()
index = VectorStoreIndex.from_documents(documents, embed_model=embed)
query_engine = index.as_query_engine(llm=llm)

response = query_engine.query("Jak skonfigurować autentykację?")
print(response)

Wymagania sprzętowe

Minimalne

• RAM: 8 GB (modele 1B-3B)
• Dysk: 5-10 GB na model
• CPU: Dowolny współczesny procesor x86_64 lub ARM64
• GPU: Opcjonalnie (znacząco przyspiesza)

Rekomendowane

• RAM: 16-32 GB (modele 7B-13B)
• Dysk: SSD z min. 50 GB wolnego miejsca
• GPU: NVIDIA RTX 3060+ (12GB VRAM) lub Apple Silicon M1+
• CPU: 8+ rdzeni

Dla dużych modeli (70B+)

• RAM: 64-128 GB
• GPU: NVIDIA RTX 4090 (24GB) lub 2x RTX 3090
• Dysk: NVMe SSD

Wskazówki i triki

Szybkie komendy pipe

echo "Explain Docker in one paragraph" | ollama run llama3.2

cat error.log | ollama run llama3.2 "What's causing these errors?"

git diff | ollama run llama3.2 "Summarize these code changes"

Utrzymywanie modelu w pamięci

OLLAMA_KEEP_ALIVE=-1 ollama serve

Wartość -1 trzyma model w pamięci nieskończenie, eliminując czas ładowania.

Równoległe żądania

OLLAMA_NUM_PARALLEL=4 ollama serve

Pozwala obsłużyć 4 żądania jednocześnie - przydatne gdy wielu użytkowników korzysta z jednego serwera.

Monitoring

ollama ps

Wyświetla aktualnie załadowane modele, zużycie pamięci i czas ostatniego użycia.

FAQ

Czy Ollama jest darmowe?

Tak, Ollama jest w pełni darmowe i open-source pod licencją MIT. Nie ma żadnych płatnych planów, limitów ani ukrytych kosztów.

Jakie GPU są obsługiwane?

NVIDIA z CUDA (compute capability 5.0+), Apple Silicon z Metal, AMD z ROCm, oraz Vulkan jako fallback.

Czy mogę uruchomić model bez GPU?

Tak, ale będzie znacznie wolniejsze. CPU inference działa, szczególnie dla mniejszych modeli (1B-7B).

Ile miejsca na dysku potrzebuję?

Zależy od modelu. Llama 3.2 3B to ~2 GB, Llama 3.1 8B to ~4.7 GB, Llama 3.1 70B to ~40 GB.

Czy mogę używać modeli z Hugging Face?

Tak, Ollama obsługuje import modeli w formacie GGUF przez Modelfile. Wiele modeli z Hugging Face jest też dostępnych bezpośrednio w bibliotece Ollama.

Jak udostępnić Ollama innym w sieci?

Ustaw OLLAMA_HOST=0.0.0.0:11434 i upewnij się, że port jest otwarty w firewallu.

Czy Ollama obsługuje function calling?

Tak, nowsze wersje Ollama wspierają tool calling, co pozwala modelom wywoływać zewnętrzne funkcje.

Czym różni się od ChatGPT/Claude?

ChatGPT i Claude to usługi w chmurze - twoje dane trafiają na serwery OpenAI/Anthropic. Ollama uruchamia modele lokalnie - dane nigdy nie opuszczają twojego komputera. Modele lokalne są zazwyczaj mniejsze i mniej zdolne niż najlepsze modele chmurowe, ale zapewniają pełną prywatność.

Czy mogę uruchomić wiele modeli jednocześnie?

Tak, ustaw OLLAMA_MAX_LOADED_MODELS na żądaną liczbę. Każdy model zajmuje osobną pamięć RAM/VRAM.

Podsumowanie

Ollama demokratyzuje dostęp do dużych modeli językowych. Zamiast polegać na chmurowych API, możesz uruchomić potężne modele AI na własnym komputerze - z pełną prywatnością, bez kosztów operacyjnych i z kompletną kontrolą.

Dla developerów Ollama to idealne narzędzie do prototypowania aplikacji AI, testowania integracji LLM, budowania pipeline'ów RAG i eksperymentowania z różnymi modelami. Dla firm to sposób na wdrożenie AI bez wysyłania danych do chmury.

Jedna komenda - ollama run llama3.2 - i masz AI działające lokalnie. Trudno o prostsze wejście w świat lokalnych modeli językowych.

Ollama - Running large language models locally on your computer

Have you ever wanted to chat with AI but couldn't send your data to the cloud? Or wanted to experiment with different models without paying for tokens? Or maybe you just wanted full control over what happens with your data?

Ollama solves these problems in the simplest way possible. One command and you have a powerful language model running locally on your computer - no cloud, no subscription, no token limits.

What is Ollama?

Ollama is a free, open-source framework for downloading, running, and managing large language models (LLMs) on your local computer. It works like Docker for AI models - you type one command, and Ollama takes care of the rest: downloads the model, configures quantization, manages memory, and starts a local API server.

Under the hood, Ollama is built on the llama.cpp library, providing an abstraction layer that hides low-level details and makes working with local models as simple as ollama run llama3.2.

The project has over 162 thousand stars on GitHub, 500+ contributors, and an MIT license. It's one of the fastest-growing open-source projects in the AI ecosystem.

Why Ollama?

Data privacy

This is the main reason people reach for Ollama. Your data never leaves your computer. No prompts, no responses, no files are sent to any cloud. For companies working with sensitive data, source code, or internal documentation - it's a game changer.

Zero operational costs

After downloading a model, you don't pay for tokens, API calls, or subscriptions. The model runs on your hardware, and the only cost is electricity. If you use AI extensively at work, the savings can be significant.

Simplicity

Ollama does one thing and does it well. There's no complicated configuration, no dashboards, no setup wizards. Installation is one command, running a model is one command, integrating with applications is one URL setting.

Offline work

Once downloaded, a model works without internet. It's perfect on airplanes, in places without WiFi, or in environments with restricted network access.

Comparison with alternatives

Installation

macOS

brew install ollama

Or download the native installer from ollama.com.

Linux

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

Windows

Download the installer from ollama.com or use WSL2:

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

Docker

docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

With GPU support (NVIDIA):

docker run -d --gpus=all -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

Getting started

Running a model

After installation, just one command:

ollama run llama3.2

Ollama will automatically download the model (if not already downloaded) and start an interactive chat session. You can start typing and getting responses right away.

Basic commands

ollama run llama3.2         # Run a model and start chatting
ollama pull gemma3           # Download a model without running it
ollama list                  # Show installed models
ollama ps                    # Show currently running models
ollama rm llama3.2           # Remove a model
ollama show llama3.2         # Show model details
ollama serve                 # Start the API server (without GUI)

Working with a model

In interactive mode, you can simply chat with the model:

>>> Explain what TypeScript is in 3 sentences

TypeScript is a superset of JavaScript that adds static typing to the language.
It allows catching errors at compile time, before the code reaches the browser
or Node.js environment. It's developed by Microsoft and has become the standard
in large frontend and backend projects.

Multimodal mode

Models with vision support (e.g., Llama 3.2 Vision) allow image analysis:

ollama run llama3.2-vision
>>> What's in this image? /path/to/screenshot.png

Model library

Ollama offers over 100 models in its library at ollama.com/library. Here are the most important ones:

General-purpose models

Coding models

Vision models

Embedding models

How to choose a model?

• 8 GB RAM: Llama 3.2 3B, Gemma 3 1B, Phi-3 3.8B
• 16 GB RAM: Llama 3.1 8B, Gemma 3 4B, Mistral 7B
• 32 GB RAM: Gemma 3 12B-27B, DeepSeek-R1 14B
• 64+ GB RAM: Llama 3.1 70B, DeepSeek-R1 32B+

General rule: start with a smaller model (3B-8B) and scale up based on your needs and available hardware.

REST API

Ollama runs a local API server on port 11434, compatible with the OpenAI format. This means many existing tools and libraries can integrate with it without code changes.

Generating responses

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Explain what React is",
  "stream": false
}'

Chat API

curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [
    {"role": "system", "content": "You are a helpful programming assistant."},
    {"role": "user", "content": "How do I create a hook in React?"}
  ],
  "stream": false
}'

Generating embeddings

curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": "Ollama is a framework for local LLMs"
}'

OpenAI-compatible endpoint

Ollama offers an endpoint compatible with the OpenAI API:

curl http://localhost:11434/v1/chat/completions -d '{
  "model": "llama3.2",
  "messages": [
    {"role": "user", "content": "Hello!"}
  ]
}'

This means you just need to change the base_url in existing code:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

response = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "What is TypeScript?"}]
)
print(response.choices[0].message.content)

JSON mode

Forcing responses in JSON format:

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "List 3 JavaScript frameworks as a JSON array",
  "format": "json",
  "stream": false
}'

Client libraries

Python

pip install ollama

import ollama

response = ollama.chat(
    model="llama3.2",
    messages=[{"role": "user", "content": "What is Rust?"}]
)
print(response["message"]["content"])

Streaming:

import ollama

stream = ollama.chat(
    model="llama3.2",
    messages=[{"role": "user", "content": "Write a poem about programming"}],
    stream=True
)
for chunk in stream:
    print(chunk["message"]["content"], end="", flush=True)

JavaScript/TypeScript

npm install ollama

import { Ollama } from "ollama"

const ollama = new Ollama({ host: "http://localhost:11434" })

const response = await ollama.chat({
  model: "llama3.2",
  messages: [{ role: "user", content: "What is Next.js?" }],
})
console.log(response.message.content)

Modelfile - Creating custom models

A Modelfile is a configuration file (similar to a Dockerfile) that lets you create custom model variants. You can change the system prompt, generation parameters, and even combine a base model with your own weights.

Basic Modelfile

FROM llama3.2

PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER num_ctx 4096

SYSTEM """
You are an experienced TypeScript and React developer.
You respond concisely and provide practical code examples.
You always use the latest patterns and best practices.
"""

Creating and running

ollama create typescript-helper -f Modelfile
ollama run typescript-helper

Advanced Modelfile

FROM llama3.2

PARAMETER temperature 0.2
PARAMETER top_p 0.85
PARAMETER repeat_penalty 1.1
PARAMETER num_ctx 8192

TEMPLATE """
{{ if .System }}<|start_header_id|>system<|end_header_id|>
{{ .System }}<|eot_id|>{{ end }}{{ if .Prompt }}<|start_header_id|>user<|end_header_id|>
{{ .Prompt }}<|eot_id|>{{ end }}<|start_header_id|>assistant<|end_header_id|>
{{ .Response }}<|eot_id|>
"""

SYSTEM """
You are a code review assistant. Analyze code for bugs, security issues,
and performance problems. Always suggest specific improvements with code examples.
"""

Importing GGUF models

If you have a model in GGUF format (e.g., from Hugging Face), you can import it:

FROM ./my-model-q4_K_M.gguf

PARAMETER temperature 0.8
SYSTEM "You are a helpful assistant."

ollama create my-custom-model -f Modelfile

GPU acceleration

Ollama automatically detects and uses available GPUs:

NVIDIA (CUDA)

Requirements: compute capability 5.0+, driver 531+

ollama run llama3.2

Ollama automatically uses CUDA if available. For multiple GPUs:

CUDA_VISIBLE_DEVICES=0,1 ollama serve

Apple Silicon (Metal)

On Macs with M1/M2/M3/M4 chips, Ollama automatically uses Metal. Apple Silicon is particularly well supported - unified memory means even larger models run smoothly.

AMD (ROCm)

Supported AMD cards with ROCm. Flash attention is automatically enabled.

GPU performance

Approximate generation speed (tokens/s) for Llama 3.1 8B:

Docker and production deployment

Basic Docker Compose

services:
  ollama:
    image: ollama/ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama-data:/root/.ollama
    restart: unless-stopped
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

volumes:
  ollama-data:

With Open WebUI

A popular combination - Ollama as backend + Open WebUI as a graphical interface:

services:
  ollama:
    image: ollama/ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama-data:/root/.ollama
    restart: unless-stopped

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    volumes:
      - open-webui-data:/app/backend/data
    depends_on:
      - ollama
    restart: unless-stopped

volumes:
  ollama-data:
  open-webui-data:

Preloading models in Docker

FROM ollama/ollama

RUN ollama serve & sleep 5 && ollama pull llama3.2 && ollama pull nomic-embed-text

Configuration

Environment variables

Sharing on local network

By default, Ollama only listens on localhost. To share on the network:

OLLAMA_HOST=0.0.0.0:11434 ollama serve

Changing the model directory

Models can take up a lot of space. To move them to another drive:

OLLAMA_MODELS=/mnt/ssd/ollama/models ollama serve

Integrations

The Ollama ecosystem includes 50+ integrations:

Graphical interfaces

• Open WebUI - the most popular web interface, looks like ChatGPT
• LibreChat - multi-provider chat with multiple model support
• Chatbox - cross-platform desktop application
• Enchanted - native macOS app
• Lobe Chat - modern interface with plugins

AI frameworks

• LangChain - building RAG pipelines, agents, chains
• LlamaIndex - document indexing and semantic search
• CrewAI - orchestration of AI agent teams
• AutoGen - multi-agent conversations

Developer tools

• Continue - coding assistant in VS Code and JetBrains
• Aider - AI pair programming in the terminal
• Cody - Sourcegraph AI coding assistant
• GitHub Copilot (self-hosted backend) - via OpenAI-compatible API

RAG and search

• RAGFlow - RAG engine with document support
• AnythingLLM - all-in-one AI with RAG
• PrivateGPT - private Q&A over documents

Practical use cases

Coding assistant

ollama create code-assistant -f - <<EOF
FROM codellama:13b
PARAMETER temperature 0.3
SYSTEM "You are a senior software engineer. Write clean, well-tested code. Always include error handling."
EOF

ollama run code-assistant
>>> Write a TypeScript function that fetches data with retry logic

Source code analysis

cat src/components/App.tsx | ollama run llama3.2 "Review this React component for potential issues"

Documentation generation

cat src/utils/helpers.ts | ollama run llama3.2 "Generate JSDoc documentation for these functions"

Local translations

ollama run llama3.2 "Translate to Polish: The quick brown fox jumps over the lazy dog"

RAG with your own documents

Combining Ollama with LlamaIndex for searching your own documents:

from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

llm = Ollama(model="llama3.2", request_timeout=120)
embed = OllamaEmbedding(model_name="nomic-embed-text")

documents = SimpleDirectoryReader("./docs").load_data()
index = VectorStoreIndex.from_documents(documents, embed_model=embed)
query_engine = index.as_query_engine(llm=llm)

response = query_engine.query("How do I configure authentication?")
print(response)

Hardware requirements

Minimum

• RAM: 8 GB (1B-3B models)
• Disk: 5-10 GB per model
• CPU: Any modern x86_64 or ARM64 processor
• GPU: Optional (significantly speeds things up)

Recommended

• RAM: 16-32 GB (7B-13B models)
• Disk: SSD with at least 50 GB free space
• GPU: NVIDIA RTX 3060+ (12GB VRAM) or Apple Silicon M1+
• CPU: 8+ cores

For large models (70B+)

• RAM: 64-128 GB
• GPU: NVIDIA RTX 4090 (24GB) or 2x RTX 3090
• Disk: NVMe SSD

Tips and tricks

Quick pipe commands

echo "Explain Docker in one paragraph" | ollama run llama3.2

cat error.log | ollama run llama3.2 "What's causing these errors?"

git diff | ollama run llama3.2 "Summarize these code changes"

Keeping the model in memory

OLLAMA_KEEP_ALIVE=-1 ollama serve

A value of -1 keeps the model in memory indefinitely, eliminating loading time.

Parallel requests

OLLAMA_NUM_PARALLEL=4 ollama serve

Allows handling 4 requests simultaneously - useful when multiple users share one server.

Monitoring

ollama ps

Shows currently loaded models, memory usage, and last use time.

FAQ

Is Ollama free?

Yes, Ollama is completely free and open-source under the MIT license. There are no paid plans, limits, or hidden costs.

Which GPUs are supported?

NVIDIA with CUDA (compute capability 5.0+), Apple Silicon with Metal, AMD with ROCm, and Vulkan as a fallback.

Can I run a model without a GPU?

Yes, but it will be significantly slower. CPU inference works, especially for smaller models (1B-7B).

How much disk space do I need?

Depends on the model. Llama 3.2 3B is ~2 GB, Llama 3.1 8B is ~4.7 GB, Llama 3.1 70B is ~40 GB.

Can I use models from Hugging Face?

Yes, Ollama supports importing GGUF format models via Modelfile. Many Hugging Face models are also available directly in the Ollama library.

How do I share Ollama with others on the network?

Set OLLAMA_HOST=0.0.0.0:11434 and make sure the port is open in your firewall.

Does Ollama support function calling?

Yes, newer versions of Ollama support tool calling, allowing models to invoke external functions.

How does it differ from ChatGPT/Claude?

ChatGPT and Claude are cloud services - your data goes to OpenAI/Anthropic servers. Ollama runs models locally - data never leaves your computer. Local models are typically smaller and less capable than top cloud models, but they provide complete privacy.

Can I run multiple models simultaneously?

Yes, set OLLAMA_MAX_LOADED_MODELS to the desired number. Each model uses separate RAM/VRAM.

Summary

Ollama democratizes access to large language models. Instead of relying on cloud APIs, you can run powerful AI models on your own computer - with full privacy, no operational costs, and complete control.

For developers, Ollama is the ideal tool for prototyping AI applications, testing LLM integrations, building RAG pipelines, and experimenting with different models. For companies, it's a way to deploy AI without sending data to the cloud.

One command - ollama run llama3.2 - and you have AI running locally. It's hard to find a simpler entry point into the world of local language models.