LLM'i Yerelde Çalıştırma Rehberi (2026): Donanım, Runtime, Model ve Kurulum

Kısa özet

"Yerel LLM" demek, bir büyük dil modelini (LLM) bir bulut API'sine istek atmak yerine kendi bilgisayarında ya da kendi sunucunda çalıştırmak demek. 2026 itibarıyla bu iş birkaç komuta indi: bir runtime kurarsın (çoğu kişi için Ollama), bir açık ağırlıklı model indirirsin, OpenAI uyumlu bir API'yle konuşursun.

Zor olan kısım kurulum değil, doğru boyutu seçmek: hangi model senin belleğine sığar, hangi quantization seviyesi kaliteyi bozmaz, bağlam penceresi büyüdükçe bellek nereye gider? Bu rehber bu soruları sırasıyla cevaplıyor, sonra adım adım kurulum, arayüz, sunucuya taşıma, performans ayarı ve sorun giderme ile bitiyor.

Not: Komutlar, varsayılan portlar ve ortam değişkenleri 24 Ekim 2026 itibarıyla resmî dokümantasyon ve GitHub README'lerinden kontrol edildi (o tarihteki son sürümler: Ollama v0.40.10, vLLM v0.32.0, Open WebUI v0.12.3, mlx-lm v0.32.2). Model boyutları Ollama kütüphanesindeki etiket sayfalarından alındı. Bu araçlar hızlı değişiyor; bir komut çalışmazsa önce resmî dokümana bak.

Runtime'ların her birinin ayrıntılı sayfası zaten var: Yerel AI araçları. Burada onları tekrar anlatmıyor, birbirine bağlıyoruz.

Neden yerelde çalıştırasın?

• Gizlilik ve veri egemenliği: Prompt'ların, belgelerin ve müşteri verin makineden çıkmaz. Kişisel veri işleyen ekipler için bu, KVKK açısından en somut fayda: veriyi yurt dışındaki bir API sağlayıcısına göndermek, KVKK'nın yurt dışına aktarım hükümleri (m.9) ve GDPR'ın uluslararası aktarım kuralları kapsamında ek değerlendirme gerektirebilir. Yerel kurulumda bu aktarım hiç olmaz. (Bu bir hukuki görüş değil; kendi durumun için uzmanına danış.)
• Öngörülebilir maliyet: Token başına ödeme yok. Yoğun ve tekrar eden iş yüklerinde (toplu sınıflandırma, embedding üretimi, iç arama) donanım bir kez ödenir. Bulutla karşılaştırmak için maliyet hesaplayıcısı işe yarar.
• Çevrimdışı çalışma: Uçakta, sahada, internet kısıtlı ağlarda çalışır.
• Kontrol: Model sürümü sen değiştirmedikçe değişmez. Sistem prompt'u, örnekleme ayarları ve bağlam uzunluğu tamamen sende.
• Öğrenme: Inference'ın gerçekte nasıl çalıştığını, KV cache'in neden bellek yediğini en iyi yerelde görürsün.

Bedeli de var: donanım, bakım, güvenlik ve en zor görevlerde bulut modellerinden geride kalan kalite. Sonda "Ne zaman yerelde çalıştırmamalı?" başlığında bunu açıkça tartıyoruz.

Donanım: belleği hesapla

Yerel LLM'de belirleyici kaynak bellektir: NVIDIA/AMD kartlarda VRAM, Apple Silicon'da birleşik bellek (unified memory), yalnız CPU'da sistem RAM'i. Model belleğe sığmıyorsa ya hiç çalışmaz ya da kısmen CPU'ya taşar ve ciddi yavaşlar.

Formül

Toplam bellek ≈ ağırlıklar + KV cache + runtime ek yükü

ağırlıklar ≈ parametre sayısı × (bit/ağırlık ÷ 8)
KV cache   ≈ 2 × katman × KV head × head_dim × bayt × token sayısı × eşzamanlı istek

Ağırlık başına bit değerleri llama.cpp'nin quantize README'sinden geliyor; orada Llama 3.1 8B üzerinde ölçülmüş resmî "bits/weight" tablosu var (Q4_K_M 4,89; Q5_K_M 5,70; Q6_K 6,56; Q8_0 8,50; Q3_K_M 4,00). Aynı README'ye göre Llama 3.1 70B'nin Q4_K_M dosyası 43,1 GB; Ollama'daki llama3.3:70b (q4_K_M) etiketi de 43 GB. Formül gerçek dosyalarla tutuyor.

Bit değerleri modelden modele biraz oynar (K-quant'lar bazı tensörleri daha yüksek bitte tutar). Tablo yalnız ağırlıkları gösteriyor ve yuvarlak değerler. Kesin hesap için sitedeki GPU / VRAM hesaplayıcısını kullan.

KV cache'i unutma

KV cache, modelin daha önce gördüğü token'lar için tuttuğu anahtar/değer tensörleridir ve bağlam uzunluğuyla doğrusal büyür. Örnek: Meta'nın llama-models deposundaki resmî mimari tanımına göre Llama 3.3 70B'de 80 katman, 64 dikkat head'i, 8 KV head ve 8192 gizli boyut var; head boyutu 8192 ÷ 64 = 128. F16'da token başına:

2 × 80 × 8 × 128 × 2 bayt = 327.680 bayt ≈ 0,31 MiB / token
32.768 token  → ~10 GiB
131.072 token → ~40 GiB

Yani 43 GB'lık bir modelin 128K bağlamla çalışması için ağırlıklar kadar daha bellek gerekebilir. KV cache'i 8-bit'e indirmek (q8_0) bunu Ollama dokümanına göre yaklaşık yarıya düşürür. Kayan pencere (sliding window) ya da hibrit dikkat kullanan yeni mimarilerde (örneğin Gemma 4'ün model kartında 1024 token'lık sliding window var) gerçek tüketim daha düşük olabilir; model kartına bak. Bağlam boyutunu planlamak için bağlam hesaplayıcısı da var.

Hangi donanım?

Ollama'nın GPU dokümanına göre NVIDIA tarafında compute capability 5.0 ve üstü, 550+ sürücü gerekiyor; Apple cihazlarda Metal üzerinden hızlandırma var.

Gerçek sayılar: llama.cpp deposunda topluluğun aynı testi (Llama 2 7B, Q4_0, llama-bench) farklı donanımlarda koşup paylaştığı iki tartışma var: Apple Silicon (#4167) ve NVIDIA CUDA (#15013). Birkaç satır (PP = prompt işleme, TG = token üretimi, token/saniye):

CUDA değerleri Flash Attention kapalı tablodan. Bunlar topluluk ölçümleri, farklı llama.cpp sürümleriyle alınmış ve 7B gibi her karta sığan küçük bir model kullanıyor; büyük modellerde tablo değişir (24 GB'a sığmayan bir model NVIDIA kartta CPU'ya taşar, yüksek bellekli Mac'te taşmaz). Yine de iki eğilimi net gösteriyor: prompt işlemede NVIDIA kartlar çok önde, token üretiminde fark daha küçük ve bant genişliğini izliyor.

Bir kural: Token üretim hızı (decode) çoğunlukla bellek bant genişliğiyle sınırlıdır. Kabaca bir üst sınır olarak bant genişliği ÷ her token'da okunan ağırlık baytı düşünebilirsin. Bu yüzden Mixture of Experts (MoE) modeller yerelde çok cazip: toplam parametresi büyük olsa da her token'da yalnız aktif uzmanları okur. Kendi donanımın için tahmini hızı throughput hesaplayıcısıyla görebilirsin. Bu bir tahmin; gerçek değer runtime, quantization ve bağlam uzunluğuna göre değişir.

Runtime seçimi

Runtime, model dosyasını belleğe yükleyip token üreten yazılım. Her birinin ayrıntılı sayfası Yerel AI bölümünde; özet:

Pratik karar:

• İlk kez deniyorsan: Ollama ya da LM Studio.
• Mac'tesin ve son damlayı istiyorsun: MLX (Ollama ve LM Studio da -mlx etiketli / MLX motorlu modeller sunuyor).
• Ekipte 5+ kişiye GPU sunucusundan servis edeceksin: vLLM.
• Garip bir donanım, CPU-only sunucu ya da her bayrağı kontrol etmek istiyorsun: llama.cpp.

Ollama ve LM Studio arka planda llama.cpp ailesi motorları kullandığı için GGUF dosyaları ve quantization adları (Q4_K_M vb.) üçünde de ortaktır.

Model seçimi

Ekim 2026 itibarıyla Ollama kütüphanesinde etiketleriyle doğruladığımız, yerelde çalışmaya uygun bazı aileler (boyutlar Ollama'nın varsayılan quantization'ı içindir):

Seçim ipuçları:

1. Belleğinin ~%70–80'ine sığanı seç, kalanı KV cache ve işletim sistemine bırak. 16 GB'lık bir kartta 8–14B sınıfı Q4 modeller ya da gemma4:12b rahat; 24 GB'ta 27–35B sınıfı Q4 modeller sığar ama uzun bağlam için yer daralır.
2. Önce MoE'ye bak: gemma4:26b, qwen3.6:35b-a3b, qwen3-coder:30b gibi modeller toplam boyut kadar bellek ister ama token başına çok daha az parametre okur; bu yüzden aynı bellekte yoğun eşdeğerlerinden genellikle daha hızlıdır.
3. Görev uyumu: Araç çağrısı (tool calling) gerekiyorsa Ollama sayfasında tools rozeti olan modeli seç; görsel girdi gerekiyorsa vision.
4. Küçük başla: 1–4B sınıfı küçük dil modelleri sınıflandırma, çıkarım ve yönlendirme için şaşırtıcı derecede iyi. Ayrıntılar: Küçük dil modelleri rehberi.
5. Lisansı oku: "Açık ağırlıklı" her zaman "her amaçla serbest" demek değil; ticari kullanım öncesi model kartındaki lisansı kontrol et.

Donanımına göre otomatik öneri almak için model öneri aracını, modelleri yan yana görmek için karşılaştırma aracını kullanabilirsin.

Hızlı başlangıç: Ollama ile 10 dakikada

1. Kur

# macOS ve Linux
curl -fsSL https://ollama.com/install.sh | sh

# Windows (PowerShell)
irm https://ollama.com/install.ps1 | iex

Docker tercih ediyorsan (NVIDIA GPU ile):

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

Resmî dokümandaki komut -p 11434:11434 kullanıyor; bu, portu makinenin tüm arayüzlerinde açar. Yukarıdaki 127.0.0.1: öneki portu yalnız yerel makineye bağlar.

2. Model indir ve konuş

ollama pull gemma4:e4b
ollama run gemma4:e4b

ollama run etkileşimli bir sohbet açar; /bye ile çıkarsın. Faydalı diğer komutlar:

ollama ls          # indirilen modeller
ollama ps          # yüklü modeller, GPU/CPU payı ve bağlam boyutu
ollama stop gemma4:e4b   # modeli bellekten hemen boşalt

3. OpenAI uyumlu API'yi çağır

Ollama http://localhost:11434/v1/ altında OpenAI uyumlu uç noktalar sunar (/v1/chat/completions, /v1/completions, /v1/models, /v1/embeddings, /v1/responses …).

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4:e4b",
    "messages": [
      {"role": "system", "content": "Kısa ve net cevap ver."},
      {"role": "user", "content": "KV cache nedir? İki cümleyle açıkla."}
    ]
  }'

Python'da resmî openai paketiyle:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1/",
    api_key="ollama",  # zorunlu ama Ollama tarafından yok sayılır
)

resp = client.chat.completions.create(
    model="gemma4:e4b",
    messages=[{"role": "user", "content": "Quantization'ı bir cümleyle anlat."}],
)
print(resp.choices[0].message.content)

Aynı kod LM Studio (http://localhost:1234/v1), vLLM (http://localhost:8000/v1) ya da mlx-lm sunucusu (http://localhost:8080/v1) ile yalnız base_url ve model adı değiştirilerek çalışır. Bulut API'si kullanan mevcut bir uygulamayı yerele taşımanın en kısa yolu budur.

Ollama'ya özgü ayarlar (örneğin num_ctx) için yerel API'yi kullan:

curl http://localhost:11434/api/chat -d '{
  "model": "gemma4:e4b",
  "messages": [{"role": "user", "content": "Merhaba"}],
  "options": {"num_ctx": 16384},
  "stream": false
}'

Diğer runtime'larla aynı adım

# llama.cpp: Hugging Face'ten GGUF indirip OpenAI uyumlu sunucu açar
llama serve -hf ggml-org/Qwen3.5-0.8B-GGUF

# vLLM: Hugging Face formatındaki modeli 8000 portunda servis eder
uv pip install vllm --torch-backend=auto
vllm serve Qwen/Qwen2.5-1.5B-Instruct

# MLX (Apple Silicon)
pip install mlx-lm
mlx_lm.server --model mlx-community/Mistral-7B-Instruct-v0.3-4bit

# LM Studio CLI ile sunucuyu başlat
lms server start

llama.cpp'nin güncel README'si kurulum için llama.app betiğini ve tek llama komutunu (llama cli, llama serve) gösteriyor; ayrı llama-server ikilisi de hâlâ derlenebiliyor. Eski rehberlerde gördüğün ./llama-server -m model.gguf biçimi bu yüzden hâlâ geçerli.

Arayüz ve kodlama araçlarını bağlama

Open WebUI

Open WebUI, ChatGPT benzeri, çok kullanıcılı, kendi barındırdığın bir arayüz. Ollama'yı ve OpenAI uyumlu her sunucuyu bağlayabilir. README'deki Docker komutu (Ollama aynı makinedeyken):

docker run -d -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui --restart always \
  ghcr.io/open-webui/open-webui:main

Sonra http://localhost:3000 adresini aç. Ollama başka bir makinedeyse -e OLLAMA_BASE_URL=http://sunucu-adresi:11434 ekle. Docker'sız kurulum için pip install open-webui ve open-webui serve (varsayılan http://localhost:8080).

Konteyner Ollama'ya ulaşamıyorsa README'nin önerisi --network=host kullanmak; bu durumda adres http://localhost:8080 olur.

Kodlama araçları

• Ollama entegrasyonları: Güncel Ollama README'si ollama launch komutuyla Claude Code, Codex, Copilot CLI, OpenCode ve Droid gibi araçları yerel ya da bulut modellere bağlamayı gösteriyor. Örneğin ollama launch claude, Claude Code'u Ollama'nın Anthropic uyumlu API'si üzerinden çalıştırır.
• OpenAI uyumlu her araç: "Custom OpenAI endpoint" ya da "base URL" ayarı olan editör eklentileri ve CLI'lar http://localhost:11434/v1 ile çalışır.
• Ajan iş yükleri için bağlam: Ollama dokümanı web araması, ajanlar ve kodlama araçları gibi uzun bağlam isteyen işler için en az 64.000 token bağlam öneriyor. Varsayılanla (aşağıya bak) bırakırsan ajan dosyaları "unutur".
• Araç bağlamak: Yerel modele kendi araçlarını MCP üzerinden verebilirsin; adım adım: Kendi MCP sunucunu yaz. Kendi belgelerinle konuşmak için RAG kur.

Unutma: küçük yerel modeller uzun, çok adımlı ajan görevlerinde büyük bulut modellerinden belirgin biçimde daha sık hata yapar. Kodlamada en iyi sonuç genellikle 27B+ sınıfı kodlama/ajan odaklı modellerle alınır (örneğin qwen3-coder:30b, qwen3.6:27b-coding); bu bir genel gözlem, kendi depolarında dene.

Sunucuya ve LAN'a taşıma (güvenlikle)

Ollama varsayılan olarak yalnız 127.0.0.1:11434 adresini dinler. Bu güvenli varsayılandır. Ağdaki diğer cihazlardan erişmek için OLLAMA_HOST değişkeni gerekir.

Linux (systemd)

sudo systemctl edit ollama

Açılan dosyaya:

[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"
Environment="OLLAMA_CONTEXT_LENGTH=32768"
Environment="OLLAMA_KEEP_ALIVE=30m"

Sonra:

sudo systemctl daemon-reload
sudo systemctl restart ollama
journalctl -e -u ollama   # loglar

macOS uygulamasında ortam değişkenleri launchctl setenv OLLAMA_HOST "0.0.0.0:11434" ile verilip uygulama yeniden başlatılır; Windows'ta kullanıcı ortam değişkenleri olarak eklenir. Modeller varsayılan olarak macOS'ta ~/.ollama/models, Linux'ta /usr/share/ollama/.ollama/models altında durur; disk yetmiyorsa OLLAMA_MODELS ile başka bir dizin göster.

Güvenlik kuralları

1. Kimlik doğrulamasız portu internete açma. Ollama'nın dokümanı ağa açmak için OLLAMA_HOST, Nginx gibi bir ters vekil sunucu (reverse proxy) ya da ngrok/Cloudflare Tunnel gibi tünelleri anlatıyor; yerel sunucu için bir API anahtarı ayarı tanımlamıyor. Kaynak kodda OLLAMA_AUTH adında bir değişken var, ancak api/client.go içinde istemci tarafında isteklerin imzalanması için kullanılıyor (ollama.com ile aynı yol); yerel API'yi parolayla koruyan bir ayar olarak belgelenmemiş. API anahtarı ve TLS desteği isteyen GitHub issue'su (#14003) Ekim 2026 itibarıyla açık. Kimlik doğrulamayı vekil katmanında sen kurmalısın. Açık bir LLM uç noktası, başkalarının senin GPU'nu bedava kullanması, modelleri silmesi ya da indirmesi demek.
2. 0.0.0.0 yerine mümkünse belirli arayüz: Yalnız LAN IP'sine ya da bir VPN arayüzüne (örneğin Tailscale/WireGuard) bağla. Güvenlik duvarında 11434'ü yalnız güvendiğin ağlara aç.
3. Docker'da port yayınlarken dikkat: -p 11434:11434 tüm arayüzlerde açar. Yalnız yerel erişim için -p 127.0.0.1:11434:11434.
4. Anahtar destekleyen sunucular: llama.cpp sunucusu --api-key (ya da LLAMA_API_KEY), vLLM --api-key (ya da VLLM_API_KEY) destekliyor. Yine de TLS için önüne bir vekil koy.
5. Arayüzü de kilitle: Open WebUI gibi bir arayüzü dışarı açıyorsan kullanıcı kaydını kontrol altında tut, HTTPS kullan.
6. Loglar kişisel veri içerir: Prompt ve cevap loglarının saklama süresini ve erişimini KVKK/GDPR yükümlülüklerine göre belirle. Yerel çalıştırmak, veri gizliliği sorumluluğunu ortadan kaldırmaz; sadece sana taşır.
7. Prompt injection yerelde de var: Modele araç ve dosya erişimi veriyorsan, güvenilmeyen içerik modelin davranışını yine ele geçirebilir.

Örnek Nginx vekil yapılandırması (Ollama FAQ'tan; kimlik doğrulama ve TLS'i sen eklemelisin):

server {
    listen 80;
    server_name example.com;
    location / {
        proxy_pass http://localhost:11434;
        proxy_set_header Host localhost:11434;
    }
}

Küçük sunucuda eşzamanlılık

• OLLAMA_NUM_PARALLEL: Model başına aynı anda işlenen istek sayısı (varsayılan 1). Gereken bellek OLLAMA_NUM_PARALLEL × OLLAMA_CONTEXT_LENGTH ile ölçeklenir.
• OLLAMA_MAX_LOADED_MODELS: Aynı anda yüklü model sayısı (varsayılan GPU sayısı × 3, CPU'da 3).
• OLLAMA_MAX_QUEUE: Meşgulken kuyruğa alınan istek sınırı (varsayılan 512).

Birden fazla kullanıcıya düzenli servis vereceksen vLLM bu iş için tasarlandı (sürekli batching, PagedAttention). Detaylar: /local-ai/vllm.

Performans ayarı

Quantization seviyesi

Quantization ağırlıkları daha az bitle saklar. Genel pratik: Q4_K_M bellek/kalite dengesinde güvenli varsayılan; bellek varsa Q5/Q6 ya da Q8_0 kaliteyi biraz artırır; Q3 ve altı küçük modellerde belirgin kalite kaybı yapabilir. llama.cpp'nin llama-quantize aracının kendi listesi, Llama-3-8B üzerinde F16'ya göre perplexity artışını şöyle veriyor: Q8_0 +0,003, Q6_K +0,022, Q5_K_M +0,057, Q4_K_M +0,175, Q3_K_M +0,657, Q2_K +3,52. Kayıp Q4'ün altında hızla büyüyor. Bellek darsa daha düşük bitli büyük bir model, yüksek bitli küçük bir modelden çoğu zaman daha iyi sonuç verir; ama bunu kendi görevinde ölç. Ollama'da quantization etiketle seçilir (llama3.3:70b-instruct-q4_K_M), llama.cpp'de -hf repo:Q5_K_M biçiminde (belirtmezsen varsayılan Q4_K_M).

Bağlam uzunluğu (num_ctx)

num_ctx, modelin bir istekte görebildiği token sayısı. Ollama'nın bağlam dokümanına göre varsayılan VRAM'e bağlı: 24 GiB altı 4K, 24–48 GiB arası 32K, 48 GiB ve üstü 256K. Uzun belge ya da ajan kullanıyorsan bunu bilinçli olarak yükselt:

# Sunucu genelinde
OLLAMA_CONTEXT_LENGTH=32768 ollama serve

# Sohbet içinde
/set parameter num_ctx 32768

Ya da kalıcı bir model varyantı oluştur:

# Modelfile
FROM gemma4:e4b
PARAMETER num_ctx 32768

ollama create gemma4-32k -f Modelfile

Gerçekten ayrılan bağlamı ollama ps çıktısındaki CONTEXT sütununda gör. Bağlam büyüdükçe KV cache büyür (yukarıdaki hesap); model GPU'dan taşmaya başlarsa hız düşer.

GPU'ya yüklenen katman sayısı (n_gpu_layers)

n_gpu_layers, modelin kaç katmanının GPU'da tutulacağı. llama.cpp'de -ngl (varsayılan auto; all ya da sayı verilebilir). Ollama bunu otomatik hesaplar; ollama ps çıktısında 100% GPU tamamen GPU'da, 48%/52% CPU/GPU gibi bir değer kısmen taşma demektir. Taşma varsa önce bağlamı küçült ya da daha küçük quantization seç; ancak sonra katman sayısıyla oyna.

Batch boyutu

Batch size, prompt işleme (prefill) sırasında tek seferde işlenen token sayısı. llama.cpp'de -b (mantıksal, varsayılan 2048) ve -ub (fiziksel, varsayılan 512). Büyük değerler uzun prompt'ları hızlandırabilir ama ek bellek ister. Ollama'da karşılığı num_batch seçeneği.

KV cache ve Flash Attention

• Flash Attention: Ollama, destekleyen arka uçlarda otomatik açar; zorlamak için OLLAMA_FLASH_ATTENTION=1. llama.cpp'de -fa auto|on|off (varsayılan auto).
• KV cache quantization: Ollama'da OLLAMA_KV_CACHE_TYPE=q8_0 (bellek ~1/2, kalite kaybı genellikle fark edilmez) ya da q4_0 (~1/4, uzun bağlamda kayıp daha belirgin olabilir). Varsayılan f16; ayar global, tüm modellere uygulanır. llama.cpp'de -ctk q8_0 -ctv q8_0. MLX sunucusunda --kv-bits, ancak mlx-lm dokümanına göre quantize KV cache batching'i desteklemiyor.

Modeli bellekte tut

Ollama modelleri varsayılan olarak 5 dakika boşta kalınca bellekten indirir; ilk istek bu yüzden yavaştır. OLLAMA_KEEP_ALIVE=30m (ya da -1 ile süresiz) ya da istek başına "keep_alive" parametresiyle değiştir.

Örnek: llama.cpp sunucusu tam ayarlı

llama-server -m ./models/model-Q4_K_M.gguf \
  -c 32768 -ngl all -fa on \
  -ctk q8_0 -ctv q8_0 \
  -b 2048 -ub 512 -np 2 \
  --host 127.0.0.1 --port 8080 \
  --api-key "$LLAMA_API_KEY"

Hangi ayarın ne kadar fark yarattığını kendi donanımında ölç; tek bir değişkeni değiştirip token/saniye'ye bak. Uzun prompt'larda token sayısını azaltmak da en ucuz hızlandırmadır: Token azaltma teknikleri.

Sorun giderme

Linux'ta loglar için journalctl -e -u ollama.

Ne zaman yerelde çalıştırmamalı?

• En zor görevlerde en iyi kalite gerekiyorsa: Uzun ajan döngüleri, karmaşık çok dosyalı kodlama, zor akıl yürütme. Tüketici donanımına sığan modeller burada genellikle en iyi bulut modellerinin gerisinde. Kendi test setinle karşılaştır.
• Kullanım düzensiz ve azsa: Ayda birkaç bin istek için donanım ve elektrik, API faturasından pahalı olabilir. Maliyet hesaplayıcısıyla kıyasla.
• Operasyon ekibin yoksa: Güncelleme, izleme, yedekleme, güvenlik yaması, kesinti yönetimi senin işin olur.
• Uyumluluk sertifikası gerekiyorsa: Bazı sektörlerde denetlenmiş, sözleşmeli bir bulut sağlayıcı (veri işleme sözleşmesi, bölgesel veri merkezi) kendi kurduğun sunucudan daha kolay belgelenebilir.
• Ölçek ani dalgalanıyorsa: Bir GPU sunucusu ani 50 katlık yükü karşılayamaz; bulut karşılar.

Çoğu ekip için en iyi cevap hibrit: hassas veri ve yüksek hacimli rutin işler yerelde, en zor ve seyrek işler bulutta. Aynı OpenAI uyumlu istemciyle iki uç nokta arasında yalnız base_url değiştirerek geçebilirsin.

Kontrol listesi

• Model + KV cache belleğin ~%80'ine sığıyor mu? (VRAM hesaplayıcısı)
• ollama ps çıktısında 100% GPU görüyor musun?
• Bağlam uzunluğu iş yüküne göre bilinçli ayarlandı mı?
• API yalnız 127.0.0.1'de mi, ya da kimlik doğrulamalı bir vekilin arkasında mı?
• Prompt/cevap loglarının saklama süresi belirlendi mi?
• Modelin lisansı kullanım amacına uygun mu?
• Bulut modeliyle kendi görevlerinde karşılaştırma yaptın mı?

Devamı için

• Yerel AI araçları: Ollama, llama.cpp, LM Studio, vLLM, MLX ayrıntılı sayfaları.
• Quantization, KV Cache, num_ctx, n_gpu_layers, Batch Size — performans ayarlarının kısa tanımları.
• Mixture of Experts — büyük modellerin yerelde neden hızlı olabildiği.
• Küçük dil modelleri rehberi — 1–4B modellerle neler yapılır.
• Araçlar: VRAM hesaplayıcısı, throughput, model önerisi, bağlam.

Kaynaklar

• Ollama README ve kurulum: https://github.com/ollama/ollama
• Ollama FAQ (OLLAMA_HOST, keep_alive, eşzamanlılık, KV cache, vekil sunucu): https://docs.ollama.com/faq
• Ollama bağlam uzunluğu: https://docs.ollama.com/context-length
• Ollama OpenAI uyumluluğu: https://docs.ollama.com/api/openai-compatibility
• Ollama GPU desteği: https://docs.ollama.com/gpu
• Ollama Linux ve Docker: https://docs.ollama.com/linux, https://docs.ollama.com/docker
• Ollama Claude Code entegrasyonu: https://docs.ollama.com/integrations/claude-code
• Ollama model kütüphanesi ve etiket sayfaları: https://ollama.com/library
• llama.cpp README ve sunucu dokümanı: https://github.com/ggml-org/llama.cpp, https://github.com/ggml-org/llama.cpp/tree/master/tools/server
• vLLM hızlı başlangıç: https://docs.vllm.ai/en/stable/getting_started/quickstart/
• mlx-lm README ve sunucu dokümanı: https://github.com/ml-explore/mlx-lm
• LM Studio yerel sunucu, CLI ve OpenAI uyumluluğu: https://lmstudio.ai/docs/developer/core/server, https://lmstudio.ai/docs/cli
• Open WebUI README: https://github.com/open-webui/open-webui
• Llama 3.3 70B mimari tanımı, Meta llama-models (KV cache hesabı): https://github.com/meta-llama/llama-models/blob/main/models/sku_list.py
• llama.cpp quantize README (bits/weight tablosu, Q4_K_M dosya boyutları): https://github.com/ggml-org/llama.cpp/blob/master/tools/quantize/README.md
• llama.cpp llama-quantize perplexity listesi: https://github.com/ggml-org/llama.cpp/blob/master/tools/quantize/quantize.cpp
• llama.cpp Apple Silicon performans tartışması: https://github.com/ggml-org/llama.cpp/discussions/4167
• llama.cpp NVIDIA CUDA performans tartışması: https://github.com/ggml-org/llama.cpp/discussions/15013
• Ollama istemci kodu (OLLAMA_AUTH): https://github.com/ollama/ollama/blob/main/api/client.go
• Ollama issue #14003 (API anahtarı ve TLS isteği): https://github.com/ollama/ollama/issues/14003

Sık sorulan sorular

Yerel LLM için kaç GB VRAM gerekir?

Kabaca parametre sayısı × ağırlık başına bayt artı KV cache kadar. 4-bit (Q4_K_M) bir modelde milyar parametre başına yaklaşık 0,6 GB hesaplayın: 8B model ~5 GB, 32B model ~20 GB, 70B model ~43 GB; üstüne bağlam uzunluğuna göre birkaç GB KV cache ekleyin.

Ollama ücretsiz mi?

Evet, Ollama MIT lisanslı açık kaynak bir yazılım ve yerelde çalıştırmak ücretsiz. Ollama ayrıca isteğe bağlı bulut modelleri de sunuyor; onlar kendi kullanım koşullarına tabi.

Ekran kartı olmadan LLM çalıştırılabilir mi?

Evet, llama.cpp ve Ollama yalnız CPU ile de çalışır. Ancak hız büyük ölçüde RAM bant genişliğine bağlıdır; 1-4B gibi küçük modeller veya az aktif parametreli MoE modeller CPU'da kullanılabilir hız verir, büyük yoğun modeller çok yavaş kalır.

Yerel LLM ChatGPT veya Claude kadar iyi mi?

Tüketici donanımına sığan modeller birçok günlük iş için yeterli, ancak en zor akıl yürütme ve uzun ajan görevlerinde büyük bulut modelleri genellikle hâlâ önde. Kendi görevlerinizle küçük bir test seti hazırlayıp karşılaştırmak en sağlıklı yol.

Ollama mı LM Studio mu llama.cpp mi?

Terminal ve API odaklı hızlı başlangıç için Ollama, grafik arayüz ve model keşfi için LM Studio, en ince ayar ve en geniş donanım desteği için llama.cpp. Çok kullanıcılı GPU sunucusunda vLLM, Mac'te en yerel performans için MLX tercih edilir.

Yerel LLM KVKK açısından daha mı güvenli?

Veri kendi altyapınızdan çıkmadığı için yurt dışına aktarım ve üçüncü taraf işleyen riskleri azalır. Ancak KVKK yükümlülükleri (erişim kontrolü, loglama, saklama süresi) yine sizde kalır; sunucuyu doğru kilitlemezseniz yerel kurulum da veri sızdırabilir.