# Ubuntu veya Debian'a Ollama kurulumu ve yerel LLM çalıştırma

> Ollama'yı resmi betik veya tarball ile Ubuntu ya da Debian'a kurun, modelleri CPU veya NVIDIA GPU'da çalıştırın, API'yi gizli tutun ve güvenle güncelleyin.

Zorluk: Başlangıç\
Denendiği sistemler: Ubuntu 24.04 LTS, Ubuntu 26.04 LTS, Debian 12, Debian 13

Ollama, açık büyük dil modellerini (LLM) indiren ve bunları basit bir komut satırı ile 11434 portundaki bir REST API üzerinden sunan bir çalışma ortamıdır. Llama, Gemma veya Qwen gibi modelleri kendi sunucunuzda çalıştırmanın en kolay yoludur ve Open WebUI dahil pek çok araç onunla doğrudan konuşur. Bu rehber Ollama'yı **resmi Linux kurulum betiğiyle** kurar, betiğin tam olarak neyi değiştirdiğini açıklar ve alternatif olarak elle tarball kurulumunu gösterir. Ardından ilk modelinizi CPU veya GPU üzerinde çalıştırır, API'yi `curl` ile test eder, model depolamasını taşır, API'yi gizli tutar ve servisi nasıl güncelleyeceğinizi, yedekleyeceğinizi ve sorunlarını nasıl gidereceğinizi öğrenirsiniz.

> **Not**
>
> Bu rehber Ollama'yı, Ollama belgelerinin Linux için anlattığı yöntemle doğrudan sunucuya bir systemd servisi olarak kurar. Docker alternatifi rehberin sonuna doğru gösterilir.

## Ön koşullar

- x86_64 (amd64) veya arm64 üzerinde **Ubuntu 24.04 LTS**, **Ubuntu 26.04 LTS**, **Debian 12** veya **Debian 13** çalıştıran bir sunucu.
- `sudo` yetkisi olan, root olmayan bir kullanıcı. Henüz oluşturmadıysanız önce [Yeni bir Linux sunucusunu güvenli hale getirin](/guides/secure-a-new-linux-server) ve [SSH anahtarlarını ayarlayın](/guides/ssh-keys) rehberlerini izleyin.
- İsteğe bağlı, GPU hızlandırması için: compute capability 5.0 veya üzeri ve 550 ya da daha yeni sürücülü bir NVIDIA GPU (compute capability 5.0 ile 6.2 arasındaki kartlar 570 veya daha yeni sürücü ister) ya da ROCm v7 sürücülü, desteklenen bir AMD Radeon veya Instinct GPU. Uygun donanım için [GPU sunucuları](/gpu-servers) sayfasına bakın.
- İndirmeyi planladığınız modeller için yeterli disk alanı.

| Kaynak | En düşük (resmi) | Önerilen başlangıç |
|---|---|---|
| CPU | Yayınlanmamış | Yalnızca CPU ile küçük modeller için 4 vCPU |
| RAM | Ollama kütüphanesi: 7B modeller genellikle en az 8 GB, 13B en az 16 GB, 70B en az 64 GB ister | Yaklaşık 8B parametreye kadar modeller için 16 GB |
| GPU (isteğe bağlı) | NVIDIA compute capability 5.0+ ve 550+ sürücü veya ROCm v7 ile AMD | Modelin tamamını alacak VRAM; böylece `ollama ps` %100 GPU gösterir |
| Disk | Yayınlanmamış | 50 GB boş alan; her model sayfası indirme boyutunu gösterir |

RAM değerleri Ollama'nın model kütüphanesinden gelir ve güncel model ailelerinden öncesine aittir; bunları alt sınır olarak görün. Önerilen değerler ölçüm sonucu değil, temkinli bir başlangıç noktasıdır. Bellek kullanımı bağlam uzunluğu ve paralel istek sayısıyla artar: belgelere göre gereken bellek `OLLAMA_NUM_PARALLEL` ile `OLLAMA_CONTEXT_LENGTH` çarpımıyla ölçeklenir. Bir ayar yapmazsanız Ollama varsayılan bağlam uzunluğunu mevcut VRAM'e göre seçer: 24 GiB altında 4k token, 24 ile 48 GiB arasında 32k token, 48 GiB ve üzerinde 256k token.

## Adım 1 — Sunucuyu hazırlayın

Kurulum betiği `curl`, `zstd` (Linux sürüm arşivleri `.tar.zst` dosyalarıdır) ve GPU aramak için `lspci` veya `lshw` ister. Bunları kurun:

```bash
sudo apt update
sudo apt install curl zstd pciutils
```

Sunucuda NVIDIA GPU varsa, hangi sürücü paketinin kullanılacağını kendiniz belirlemek için sürücüyü Ollama'dan önce kurun. Aşağıdaki komutlar NVIDIA'nın x86_64 sunucular için sürücü kurulum rehberini izler: NVIDIA'nın ağ deposunu ekler ve `nvidia-open` sürücüsünü kurar. Debian'da NVIDIA'nın rehberi ayrıca `contrib` bileşenini ister. Rehber bunu Debian 13'te artık bulunmayan `add-apt-repository` ile etkinleştirir; bu yüzden Debian komutlarını çalıştırmadan önce APT kaynaklarınızda `main` yanına `contrib` ekleyin (sisteminizin kullandığı dosyaya göre `/etc/apt/sources.list.d/debian.sources` içindeki `Components:` satırına veya `/etc/apt/sources.list` içindeki `deb` satırlarına).

**Ubuntu**

```bash
sudo apt install linux-headers-$(uname -r)
distro=ubuntu$(. /etc/os-release && echo "$VERSION_ID" | tr -d .)
wget https://developer.download.nvidia.com/compute/cuda/repos/$distro/x86_64/cuda-keyring_1.1-1_all.deb
sudo dpkg -i cuda-keyring_1.1-1_all.deb
sudo apt update
sudo apt install nvidia-open
sudo reboot
```
**Debian**

```bash
sudo apt install linux-headers-$(uname -r)
distro=debian$(. /etc/os-release && echo "$VERSION_ID")
wget https://developer.download.nvidia.com/compute/cuda/repos/$distro/x86_64/cuda-keyring_1.1-1_all.deb
sudo dpkg -i cuda-keyring_1.1-1_all.deb
sudo apt update
sudo apt -V install nvidia-open
sudo reboot
```

Yeniden başlatmanın ardından `nvidia-smi`, GPU'nuzu, sürücü sürümünü ve sürücünün desteklediği en yüksek CUDA sürümünü içeren bir tablo yazmalıdır. Bu adımı atlarsanız Ollama betiği, çalışan sürücüsü olmayan bir NVIDIA GPU algıladığında Ubuntu ve Debian'da CUDA sürücülerini kendisi kurar. AMD GPU'lar için ROCm v7 sürücüsünü AMD'nin ROCm belgelerinde anlatıldığı gibi `amdgpu-install` aracıyla kurun.

## Adım 2 — Kurulum betiğini indirin, inceleyin ve çalıştırın

Ollama'nın resmi Linux kurulum aracı bir kabuk betiğidir. Çalıştırmadan önce bir dosyaya indirip okuyun:

```bash
curl -fsSL https://ollama.com/install.sh -o ollama-install.sh
less ollama-install.sh
sh ollama-install.sh
```

Betiği `sudo` ile değil, normal sudo kullanıcınızla çalıştırın: root gerektiğinde `sudo`'yu kendisi çağırır ve betiği çalıştıran kullanıcıyı `ollama` grubuna ekler. Belgeler aynı kurulum aracını `curl -fsSL https://ollama.com/install.sh | sh` tek satırıyla gösterir; önce indirmek yalnızca betiği incelemenizi sağlar. Betik şunları yapar:

- CPU mimarinize uygun Ollama sürüm arşivini indirir ve önce eski kütüphaneleri silerek `/usr/local` altına açar (ikili dosya `/usr/local/bin`, kütüphaneler `/usr/local/lib/ollama` içinde);
- ev dizini `/usr/share/ollama` olan `ollama` adlı bir sistem kullanıcısı ve grubu oluşturur, varsa onu `render` ve `video` gruplarına ekler ve sizin kullanıcınızı `ollama` grubuna ekler;
- `ollama serve` komutunu `ollama` kullanıcısıyla ve `Restart=always` ayarıyla çalıştıran `/etc/systemd/system/ollama.service` dosyasını yazar, ardından servisi etkinleştirip başlatır;
- GPU arar: `nvidia-smi` çalışıyorsa NVIDIA GPU'yu bildirir, sürücüsüz bir NVIDIA kart bulursa NVIDIA deposundan CUDA sürücülerini kurar, AMD kartlar için ek ROCm kütüphanelerini indirir; aksi halde Ollama'nın yalnızca CPU modunda çalışacağı uyarısını verir.

Bittiğinde Ollama API'sinin `127.0.0.1:11434` adresinde hazır olduğunu yazar. Servisi ve ikili dosyayı doğrulayın:

```bash
systemctl status ollama --no-pager
ollama -v
curl http://127.0.0.1:11434/api/tags
```

Servis `active (running)` durumunda olmalı, `ollama -v` sürümü yazmalı ve API şimdilik boş olan bir JSON model listesi döndürmelidir.

### Alternatif: tarball ile elle kurulum

Betiği çalıştırmak istemiyorsanız sürüm arşivini kendiniz açın. Bu yöntem `/usr/local` yerine `/usr` altına kurar. arm64 sunucularda `ollama-linux-arm64.tar.zst` dosyasını kullanın; AMD GPU'lar için ayrıca `ollama-linux-amd64-rocm.tar.zst` dosyasını da aynı şekilde açın.

```bash
curl -fsSL https://ollama.com/download/ollama-linux-amd64.tar.zst | sudo tar x -C /usr
sudo useradd -r -s /bin/false -U -m -d /usr/share/ollama ollama
sudo usermod -a -G ollama $(whoami)
```

Ardından `/etc/systemd/system/ollama.service` servis dosyasını şu içerikle oluşturun:

```ini
[Unit]
Description=Ollama Service
After=network-online.target

[Service]
ExecStart=/usr/bin/ollama serve
User=ollama
Group=ollama
Restart=always
RestartSec=3
Environment="PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"

[Install]
WantedBy=multi-user.target
```

```bash
sudo systemctl daemon-reload
sudo systemctl enable --now ollama
```

## Adım 3 — Bir model indirip çalıştırın

Model kütüphanesine `ollama.com/library` adresinden göz atın ve her modelin indirme boyutunu kontrol edin. `llama3.2` gibi küçük bir model (3B sürümü 2,0 GB indirmedir) GPU olmadan da iyi bir ilk denemedir:

```bash
ollama pull llama3.2
ollama run llama3.2
```

`ollama run` etkileşimli bir istem açar; bir soru yazın, çıkmak için `/bye` yazın. İstemi doğrudan da verebilirsiniz, örneğin `ollama run llama3.2 "Explain DNS in one sentence"`. Modelleri şu komutlarla yönetin:

```bash
ollama list
ollama ps
ollama stop llama3.2
ollama rm llama3.2
```

`ollama list` indirilen modelleri, `ollama ps` ise yüklü modelleri gösterir. `ollama ps` çıktısındaki `PROCESSOR` sütunu modelin nerede çalıştığını söyler: `100% GPU` modelin tamamen VRAM'e sığdığı, `100% CPU` sistem belleğinden çalıştığı, `48%/52% CPU/GPU` gibi bir bölünme ise VRAM'e sığmadığı anlamına gelir. Modeller varsayılan olarak 5 dakika istek gelmezse bellekten çıkarılır.

## Adım 4 — REST API'yi test edin

Arayüzler ve kendi kodunuz API'yi kullanır. Akış (streaming) olmadan bir üretim isteği gönderin:

```bash
curl http://127.0.0.1:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Why is the sky blue?",
  "stream": false
}'
```

Ollama ayrıca `/v1` altında OpenAI uyumlu bir API sunar; OpenAI istemci kütüphaneleri, temel adresleri `http://127.0.0.1:11434/v1` olarak ayarlandığında çalışır. İstemci bir API anahtarı değeri ister, Ollama ise bu değeri yok sayar:

```bash
curl http://127.0.0.1:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model": "llama3.2", "messages": [{"role": "user", "content": "Say this is a test"}]}'
```

Modelin yanıtını içeren bir JSON görmelisiniz: yerel API'de `response`, OpenAI API'sinde `choices[0].message.content` alanında.

## Adım 5 — Servisi yapılandırın

Ollama ayarlarını ortam değişkenlerinden okur. Güncellemeler değişikliklerinizin üzerine yazmasın diye bunları unit dosyasını düzenlemek yerine bir override dosyasıyla systemd servisine verin:

```bash
sudo systemctl edit ollama
```

Açılan düzenleyicide ihtiyacınız olan değişkenleri `[Service]` bölümüne ekleyin, örneğin:

```ini
[Service]
Environment="OLLAMA_CONTEXT_LENGTH=8192"
Environment="OLLAMA_KEEP_ALIVE=10m"
```

```bash
sudo systemctl daemon-reload
sudo systemctl restart ollama
```

En çok ihtiyaç duyacağınız değişkenler:

| Değişken | Varsayılan | Ne yapar |
|---|---|---|
| `OLLAMA_HOST` | `127.0.0.1:11434` | API'nin dinlediği adres ve port |
| `OLLAMA_MODELS` | `/usr/share/ollama/.ollama/models` | Model depolama klasörü |
| `OLLAMA_CONTEXT_LENGTH` | VRAM'e göre (24 GiB altında 4k) | Token cinsinden varsayılan bağlam penceresi |
| `OLLAMA_KEEP_ALIVE` | `5m` | Son istekten sonra modelin bellekte kalma süresi |
| `OLLAMA_NUM_PARALLEL` | `1` | Model başına paralel istek sayısı |
| `OLLAMA_MAX_LOADED_MODELS` | GPU başına 3, CPU'da 3 | Aynı anda bellekte tutulan model sayısı |

Modelleri daha büyük bir diskte tutmak için servisi durdurun, mevcut modelleri kopyalayın, sahipliği `ollama` kullanıcısına verin ve `sudo systemctl edit ollama` ile `OLLAMA_MODELS` değişkenini yeni klasöre yönlendirin:

```bash
sudo systemctl stop ollama
sudo mkdir -p /srv/ollama/models
sudo cp -a /usr/share/ollama/.ollama/models/. /srv/ollama/models/
sudo chown -R ollama:ollama /srv/ollama
```

Override dosyasına `Environment="OLLAMA_MODELS=/srv/ollama/models"` satırını ekleyin, ardından Ollama'yı yeniden başlatın ve `ollama list` ile modellerinizin yerinde olduğunu doğrulayın.

## Adım 6 — API'yi gizli tutun ve güvenle erişin

Ollama yerel istekler için kimlik doğrulaması yapmaz. 11434 portuna ulaşabilen herkes model çalıştırabilir ve silebilir; bu nedenle `OLLAMA_HOST` değerini varsayılan `127.0.0.1:11434` olarak bırakın ve tüm adreslerde dinlemek yerine şu yöntemlerden birini seçin:

- **Kendi bilgisayarınızdan** bir SSH tüneli açın ve yerelde `http://localhost:11434` adresini kullanın: `ssh -L 11434:127.0.0.1:11434 user@203.0.113.10`.
- **Web tabanlı sohbet arayüzü için** Open WebUI'ı aynı sunucuda çalıştırın. [Open WebUI'ı Ollama ile çalıştırma](/guides/open-webui-ollama) rehberi, portu açmadan `127.0.0.1` üzerindeki Ollama'ya ulaşan bir kurulum gösterir.
- **Uzak API istemcileri için** Ollama'nın önüne Caddy koyun ve bir token isteyin. Token'ı `openssl rand -hex 32` ile üretin, ardından bir site bloğu ekleyin:

```caddyfile
ollama.example.com {
    @authorized header Authorization "Bearer change-me-long-random-token"
    handle @authorized {
        reverse_proxy 127.0.0.1:11434 {
            header_up Host localhost:11434
        }
    }
    handle {
        respond 401
    }
}
```

Caddy'yi `sudo systemctl reload caddy` ile yeniden yükleyin. `header_up Host` satırı önemlidir: Ollama belgeleri proxy örneklerinde Host başlığını `localhost:11434` olarak yeniden yazar; aksi halde yabancı bir alan adıyla gelen istekler reddedilir. İstemciler token'ınızı `Authorization: Bearer` başlığıyla gönderir; OpenAI uyumlu istemciler token'ı API anahtarı olarak ayarladığınızda bunu kendiliğinden yapar. Caddy kurulumu [Caddy ile reverse proxy](/guides/caddy-reverse-proxy) rehberinde anlatılır.

`OLLAMA_HOST` değerini (örneğin `0.0.0.0:11434` veya özel bir arayüz adresi) yalnızca başka bir sunucudaki veya ağdaki bir istemcinin gerçekten doğrudan erişmesi gerektiğinde değiştirin; bu durumda 11434 portunu ufw ile bilinen adreslerle sınırlayın, örneğin `sudo ufw allow from 10.0.0.0/24 to any port 11434 proto tcp`. Bunun dışında ufw'nin yalnızca OpenSSH, 80/tcp ve 443/tcp açık olacak şekilde etkin olduğundan emin olun.

> **Uyarı**
>
> Genel IP adresi olan bir sunucuda, 11434 portunu güvenilir adreslerle sınırlayan bir güvenlik duvarı kuralı olmadan asla `OLLAMA_HOST=0.0.0.0` ayarlamayın. Açık bir Ollama API'si herkesin sunucunuzun CPU veya GPU'sunu kullanmasına, model indirmesine veya silmesine izin verir.

## Ollama'yı Docker ile çalıştırma

Resmi imaj `ollama/ollama`'dır. Docker kurulu olduğunda ([Ubuntu](/guides/install-docker-ubuntu), [Debian](/guides/install-docker-debian)) ve NVIDIA GPU'lar için NVIDIA Container Toolkit hazırlandığında ([vLLM kurulumu](/guides/install-vllm) rehberinin 2. adımı resmi komutları gösterir), API'yi yalnızca loopback adresinde yayınlayarak başlatın:

```bash
docker run -d --gpus=all -v ollama:/root/.ollama -p 127.0.0.1:11434:11434 --restart unless-stopped --name ollama ollama/ollama
docker exec -it ollama ollama run llama3.2
```

Yalnızca CPU için `--gpus=all` seçeneğini çıkarın. AMD GPU'lar için belgeler bunun yerine `--device /dev/kfd --device /dev/dri` ile `ollama/ollama:rocm` imajını kullanır. Modeller `ollama` volume'unda saklanır. Konteyneri ve systemd servisini aynı anda aynı portta çalıştırmayın.

## Yedekleme ve geri yükleme

Modeller her zaman yeniden indirilebilir; bu yüzden yedeğin asıl konusu kendi emeğinizdir: `ollama create` ile oluşturduğunuz özel modeller ve Modelfile'ları, `/etc/systemd/system/ollama.service.d/` içindeki systemd override dosyası ve anahtar çiftini barındıran Ollama ev dizini. Ev dizinini servis durmuşken yedekleyin:

```bash
sudo mkdir -p /opt/backups
sudo systemctl stop ollama
sudo tar czf /opt/backups/ollama-$(date +%F).tar.gz /usr/share/ollama/.ollama /etc/systemd/system/ollama.service.d
sudo systemctl start ollama
```

Modelleri `OLLAMA_MODELS` ile taşıdıysanız o klasörü de arşive ekleyin ya da dışarıda bırakıp geri yüklemeden sonra modelleri yeniden indirin. Geri yüklemek için Ollama'yı kurun, servisi durdurun, arşivi kök dizinden açın ve sahipliği düzeltin:

```bash
sudo systemctl stop ollama
sudo tar xzf /opt/backups/ollama-YYYY-MM-DD.tar.gz -C /
sudo chown -R ollama:ollama /usr/share/ollama
sudo systemctl daemon-reload
sudo systemctl start ollama
```

Arşivleri sunucunun dışına da kopyalayın.

## Ollama'yı güncelleme

Önce Ollama'nın GitHub sürümler sayfasındaki sürüm notlarını okuyun. Güncellemek için kurulum betiğini yeniden çalıştırın veya elle kurduysanız yeni tarball'ı eski kurulumun üzerine açın. Betik yenilerini açmadan önce eski kütüphaneleri siler:

```bash
curl -fsSL https://ollama.com/install.sh -o ollama-install.sh
sh ollama-install.sh
ollama -v
```

Modelleriniz ve systemd override dosyanız korunur. Belirli bir sürümü kurmak, örneğin geri dönmek için `OLLAMA_VERSION` değişkenine sürümler sayfasındaki bir sürüm numarasını verin: `OLLAMA_VERSION=x.y.z sh ollama-install.sh`. Docker kurulumunda `docker pull ollama/ollama` çalıştırın, konteyneri silin ve aynı komutla yeniden başlatın.

## Sorun giderme

### Logları okuma

Ollama systemd günlüğüne yazar. Günlüğü `journalctl -u ollama --no-pager --follow --pager-end` ile izleyin. Daha fazla ayrıntı için `sudo systemctl edit ollama` ile `Environment="OLLAMA_DEBUG=1"` ekleyin, servisi yeniden başlatın ve sorunu tekrarlayın.

### GPU kullanılmıyor ve ollama ps %100 CPU gösteriyor

Önce sürücüyü `nvidia-smi` ile doğrulayın; hata veriyorsa sürücüyü düzeltip sunucuyu yeniden başlatın. Model VRAM'den büyükse Ollama onu CPU ile GPU arasında böler veya CPU'da çalıştırır; daha küçük bir model veya etiket seçin. Askıya alma ve devam etme döngüsünden sonra Ollama CPU'ya düşebilir; NVIDIA UVM sürücüsünü `sudo rmmod nvidia_uvm && sudo modprobe nvidia_uvm` ile yeniden yükleyin. GPU algılama sonucunu görmek için günlükteki başlangıç satırlarına bakın; AMD GPU'larda `ollama` kullanıcısının `render` ve `video` gruplarında olduğundan emin olun.

### model requires more system memory than is available

Model, bağlamı ve paralel istekler RAM'e sığmıyor. Daha küçük bir model veya daha yoğun nicemlenmiş (quantized) bir etiket kullanın, `OLLAMA_CONTEXT_LENGTH` veya `OLLAMA_NUM_PARALLEL` değerini düşürün, diğer modelleri `ollama stop` ile bellekten çıkarın ya da daha fazla belleği olan bir sunucuya geçin.

### Reverse proxy veya tünel üzerinden 403 Forbidden

Ollama 127.0.0.1 üzerinde dinlerken Host başlığı yerel bir adres olmayan istekleri reddeder. Başlığı proxy'nizde yeniden yazın; Adım 6'daki Caddy örneğinde olduğu gibi (`header_up Host localhost:11434`).

### ollama komutu sunucuya bağlanamıyor

Servis çalışmıyor veya başka bir adreste dinliyor. `systemctl status ollama` ile kontrol edin. `OLLAMA_HOST` değerini değiştirdiyseniz CLI'ın da aynı değere ihtiyacı vardır, örneğin `OLLAMA_HOST=10.0.0.5:11434 ollama list`.

## Sonraki adımlar

- [Open WebUI ve Ollama](/guides/open-webui-ollama) ile bir sohbet arayüzü ekleyin.
- GGUF modellerini ayrıntılı denetimle [llama.cpp sunucusu](/guides/llama-cpp-server) üzerinden sunun.
- NVIDIA GPU'larda yüksek kapasiteli API'ler için [vLLM kurulumu](/guides/install-vllm) rehberine bakın.
- Yerel modeller için sunucuları [Ollama hosting](/ollama-hosting) sayfasında karşılaştırın.
- Tüm ortam değişkenleri için https://docs.ollama.com adresindeki resmi belgeleri okuyun.

## Sık sorulan sorular

### Ollama API'sinin parolası veya API anahtarı var mı?

Hayır. Yerel Ollama sunucusu her isteği kimlik doğrulaması olmadan kabul eder; bu yüzden varsayılan olarak 127.0.0.1:11434 adresinde dinler. Bu ayarı koruyun; başka makinelerin erişmesi gerekiyorsa SSH tüneli, Open WebUI gibi bir arayüz veya token denetleyen bir reverse proxy kullanın.

### Ollama için GPU gerekli mi?

Hayır. Ollama desteklenen bir GPU bulamazsa modelleri CPU üzerinde çalıştırır; küçük modeller ve denemeler için bu yeterlidir. Daha büyük modeller ve daha hızlı yanıtlar için compute capability 5.0 veya üzeri ve 550 ya da daha yeni sürücülü bir NVIDIA GPU veya ROCm v7 sürücülü bir AMD GPU kullanın.

### Bir model için ne kadar RAM gerekir?

Ollama model kütüphanesine göre 7B modeller genellikle en az 8 GB, 13B modeller en az 16 GB, 70B modeller en az 64 GB RAM ister. Model sayfasındaki indirme boyutunu alt sınır kabul edin ve pay bırakın; uzun bağlam ve paralel istekler daha fazla bellek kullanır.

### Ollama modelleri nerede saklar, başka yere taşıyabilir miyim?

Linux kurulum betiğiyle modeller /usr/share/ollama/.ollama/models içinde durur. Başka bir klasör kullanmak için systemd override dosyasında OLLAMA_MODELS değişkenini ayarlayın ve klasörün sahipliğini ollama kullanıcısına verin.

### Ollama'yı modelleri kaybetmeden nasıl güncellerim?

Resmi kurulum betiğini yeniden çalıştırın veya yeni tarball'ı eskisinin üzerine açın. Model klasöründeki modeller korunur ve servis yeni sürümle yeniden başlar.

---

Kaynak: <https://hyperdc.com/tr/guides/tutorials/install-ollama>\
Son güncelleme: 2026-10-09