Lokalde LLM Çalıştırmak

ChatGPT'ye her mesajınız bir başkasının bilgisayarına gidiyor. Peki aynı sihri kendi makinenizde, internetsiz, ücretsiz ve kimseyle paylaşmadan koşturmak mümkün mü? Mümkün — ve düşündüğünüzden çok daha kolay.

Bu yazıya "LLM'in ne olduğunu aşağı yukarı biliyorum ama lokalde çalıştırmak bana uzak" diyerek geldiyseniz, tam yerindesiniz. Sonuna vardığınızda şunları biliyor olacaksınız: bir modelin bilgisayarınıza sığıp sığmayacağını hesaplayabileceksiniz, Q4_K_M gibi şifreli görünen isimleri okuyabileceksiniz, Ollama ile beş dakikada model kaldırabilecek, işler ciddileşince hangi araca geçeceğinizi bileceksiniz.
Bu alanda kendinizi sektöre hazır hale getirmek isterseniz: VBO AI&LLM Bootcamp size göre.

1. Neden Lokal Model?

Gizlilik (privacy): Lokal modelde prompt'unuz makinenizden dışarı çıkmaz. Sağlık, finans, hukuk gibi regülasyona tabi alanlarda ya da müşteri verisiyle çalışırken bu bir tercih değil, çoğu zaman zorunluluktur^[1]. Ethernet kablosunu çekin, model çalışmaya devam eder — bundan daha güçlü bir gizlilik garantisi yok.

Maliyet: API faturaları kullandıkça büyür; lokal donanım bir kez alınır. Yoğun kullanan tek bir geliştiricinin aylık API maliyeti binlerce dolara çıkabiliyor; günde ~2 milyon token civarında lokal altyapı başabaş noktasını geçiyor^[1]. Deney, prototip ve toplu işleme (batch processing) senaryolarında fark dramatik.

Kontrol ve öğrenme: Model ağırlıkları (weights) elinizde olunca kimse modeli bir gecede emekliye ayıramaz, davranışını değiştiremez. Sampling parametrelerinden ince ayara (fine-tuning) kadar her vida size açık. Ve itiraf edelim: LLM'lerin nasıl çalıştığını öğrenmenin en iyi yolu, birini kendi elinizle ayağa kaldırmak.

Gecikme (latency) ve çevrimdışılık: Ağ turu olmayınca ilk token'a ulaşma süresi (time to first token, TTFT) 100 ms'nin altına inebilir; bulut API'lerinde tipik olarak 300 ms üzeri ağ maliyeti eklenir^[1]. Uçakta, sahada, kapalı ağda — model hep yanınızda.

Ancak madalyonun öbür yüzü de var: lokalde çalıştırabileceğiniz modeller, GPT-5 ya da Claude gibi devlerin ham gücüne ulaşamaz. Ama açık ağırlıklı (open-weight) modeller son iki yılda öyle bir sıçradı ki, bugün 24 GB'lık bir ekran kartında koşan bir model, iki yıl öncenin en iyi bulut modelleriyle boy ölçüşüyor^[4]. Çoğu günlük iş için "yeterince iyi" çizgisi çoktan aşıldı.

2. Bilmeniz Gereken Kavramlar

Model: Bir LLM, disk üzerinde milyarlarca sayıdan (ağırlık, weight) oluşan bir dosyadır. "7B", "70B" gibi ifadeler parametre sayısını söyler: 7B = 7 milyar parametre. Model "çalışırken" yaptığı tek şey, bu sayılarla çarpma-toplama yaparak bir sonraki token'ı tahmin etmektir; buna çıkarım (inference) denir.

Token: Modelin işlediği metin parçacığı; kabaca bir kelimenin dörtte üçü. Hız birimi olarak token/saniye (tokens/sec) kullanılır. Saniyede 10 token'ın üzeri akıcı okuma hissi verir; 30+ token/s "anında" hissettirir.

GGUF: Lokal dünyanın standart model dosya formatı. llama.cpp ekosisteminin geliştirdiği bu format, model ağırlıklarını ve metadata'yı tek dosyada taşır; Hugging Face'te indireceğiniz lokal modellerin çoğu GGUF olarak dağıtılır^[3][24].

Context window (bağlam penceresi): Modelin aynı anda "aklında tutabildiği" token miktarı. Sohbet geçmişiniz + sorduğunuz soru + modelin cevabı bu pencereye sığmak zorunda. Birazdan göreceğiz: lokalde bağlam penceresi bedava değil, bellekten yer.

Quantization (nicemleme): Model ağırlıklarını daha az bit ile temsil ederek dosyayı küçültme sanatı. Lokal LLM dünyasının tek en önemli hilesi budur; kendine ayrılmış koca bir bölümü hak ediyor.

3. En Büyük Kısıt: Bellek

Lokal LLM'de asıl kısıt işlemci gücü değil, bellektir. İki soru her şeyi belirler: model belleğe sığıyor mu, ve o bellek ne kadar hızlı? Çünkü inference sırasında her yeni token için modelin tüm ağırlıkları bellekten okunur; yani token üretim hızınız kabaca bellek bant genişliği (memory bandwidth) bölü model boyutudur^[5][14]. GPU'ların CPU'lardan 10 kat hızlı olmasının sırrı çekirdek sayısından çok, VRAM'in çılgın bant genişliğidir.

Peki bir model ne kadar bellek ister? ^[2]:

Ağırlık belleği ≈ parametre sayısı × parametre başına bayt
  FP16  : 2    bayt/param   →  8B model ≈ 16 GB
  8-bit : 1    bayt/param   →  8B model ≈  8 GB
  4-bit : 0.5  bayt/param   →  8B model ≈  4 GB

Toplam ≈ Ağırlıklar × 1.15 (çalışma tamponları) + KV cache

Akılda kalsın diye altın kural: 4-bit'te her 1 milyar parametre ≈ 0.5 GB bellek^[1]. 8B model 4 bit'te ~4-5 GB, 32B model ~18-20 GB, 70B model ~40 GB ister. Ama hesap burada bitmiyor; bir de gizli bir kalem var: KV cache.

KV cache: bağlam penceresinin gizli faturası

Model, sohbetin her token'ı için ürettiği ara değerleri (key ve value tensörleri) bellekte tutar ki her yeni token'da tüm geçmişi baştan hesaplamasın. Bu depoya KV cache denir ve boyutu bağlam uzunluğuyla doğrusal büyür^[2][27]. Somut örnek: Llama 3.1 70B'de KV cache token başına ~0.33 MB'dır; 4K'lık sohbette masum bir 1.3 GB iken, 128K bağlamda tam 42 GB'a şişer — modelin kendisinden bile fazla^[2]! "Model sığdı ama uzun sohbette bellek patladı" şikâyetinin arkasındaki suçlu hep budur.

Buradan iki pratik ders çıkıyor. Birincisi: model seçerken kartınızın tamamını ağırlıklara vermeyin; VRAM'in ~%80'ini model için düşünüp gerisini KV cache'e ve tamponlara bırakın^[1]. İkincisi: çoğu araç KV cache'in kendisini de quantize etmeye izin verir (llama.cpp'de --cache-type-k q8_0 --cache-type-v q8_0 gibi) — bağlam bütçenizi bir hamlede ikiye katlar, kalite kaybı çoğu zaman hissedilmez^[2][27].

Donanım

NVIDIA GPU dünyası: En olgun ekosistem. Buradaki bir numaralı kural: VRAM kapasitesi, çip neslinden önce gelir. İkinci el 24 GB'lık RTX 3090, 16 GB'lık yepyeni bir karttan daha büyük model çalıştırır; model VRAM'e sığmayıp sistem RAM'ine taşarsa hız uçurumdan düşer^[1]. Kabaca merdiven: 8 GB VRAM ile 7-8B modeller, 16 GB ile 13-14B, 24 GB ile 27-32B sınıfı rahat eder^[1][4].

Apple Silicon dünyası: M serisi çiplerde CPU ve GPU tek bellek havuzunu paylaşır (unified memory); 64 GB'lık bir MacBook, PC tarafında iki ekran kartı gerektirecek modelleri tek başına yükleyebilir^[5]. Bant genişliği modele göre ~273 GB/s (Pro) ile ~800 GB/s (Ultra) arasında değişir; 64 GB'lık M4 Max, 70B'lik bir modeli 4-bit'te 12-15 token/s ile koşturur, MoE mimarili 30B'lik bir modeli ise 100+ token/s'ye çıkarabilir^[5]. Mac'te ayrıca Apple'ın MLX çatısı, llama.cpp'nin Metal arka ucundan çoğu işte %30-60 daha hızlıdır^[5][23].

Sadece CPU dünyası: Evet, ekran kartsız da olur — llama.cpp tam da bunun için doğdu. 7-8B sınıfı bir modeli 4-bit'te modern bir CPU + 16 GB RAM ile kullanılabilir hızda (5-15 token/s) çalıştırabilirsiniz. Daha büyüğü sabır işidir; ama "önce bir tadına bakayım" aşaması için sıfır maliyetli giriş kapısıdır^[20].

4. Quantization

Şimdi lokal dünyanın en büyük sihrine gelelim. Model ağırlıkları normalde 16-bit hassasiyetle tutulur; quantization bu sayıları 8, 5, 4 hatta 2-3 bit ile temsil eder. Sonuç: dosya boyutu dörtte bire iner, kalite kaybı ise şaşırtıcı derecede az olur^[3][11]. Hugging Face'te bir GGUF sayfası açtığınızda göreceğiniz o şifreli liste — Q4_K_M, Q5_K_M, Q8_0 — işte bu seviyelerin adlarıdır. Okuması basit: Q'dan sonraki sayı bit sayısıdır; K modern "k-quant" yöntemini, S/M/L varyantın küçük/orta/büyük halini gösterir. Tablo 7B'lik bir model için resmi netleştirir^[3]:

Sahadaki fiili standart Q4_K_M'dir: boyutu %70+ küçültürken kalitenin ~%95'ini korur^[1][3][26]. Kritik sır şurada: aynı bellekte, büyük modelin agresif quant'ı, küçük modelin hassas halini neredeyse her zaman yener. 8 GB'ınız varsa 7B'nin Q8'i yerine 13-14B'nin Q4'ünü tercih edin. Bir istisnayla: 4-bit'in altına inmek matematik ve kod gibi hassas işlerde belirgin bir kalite uçurumu yaratır; Q4 çizgisi boşuna herkesin durağı değil^[3].

İki modern incelik daha: imatrix (importance matrix) tabanlı IQ varyantları, hangi ağırlıkların kritik olduğunu bir kalibrasyon verisiyle ölçüp onları daha hassas saklar — IQ4_XS, daha küçük boyutta Q4_K_M kalitesine yaklaşabilir^[3]. Ve bazı yeni modeller (örneğin gpt-oss) zaten 4-bit civarı hassasiyetle (MXFP4) eğitilmiş olarak gelir; onları ayrıca quantize etmeye gerek kalmaz^[4]. GGUF dışında GPU-sunucu dünyasının AWQ ve GPTQ formatları da vardır; ama masaüstü lokal kullanımda yolunuz neredeyse hep GGUF'tan geçecek^[11].

5. Araç Kutusu: Ollama vs. vLLM

Lokal LLM ekosisteminde dört-beş isim öne çıkar ve güzel haber şu: hepsi aynı motorun etrafında ya da aynı standartla konuşuyor. Neredeyse tamamı OpenAI uyumlu bir API sunar; yani bir araçla yazdığınız kodu ötekine taşımak çoğu zaman tek satırlık adres değişikliğidir^[10][12].

Ollama, lokal dünyanın kapısıdır: kur, ollama run llama3.1 yaz, konuşmaya başla. Arka planda llama.cpp motorunu kullanır, modelleri kendi kütüphanesinden çeker, 11434 portunda API sunar^[19]. LM Studio aynı işi görsel arayüzle yapar: Hugging Face'ten GGUF ara, indir, sohbet et; hangi quant'ın kartınıza sığacağını arayüz söyler — kod yazmak istemeyenler için biçilmiş kaftan^[21]. llama.cpp ise bu ikisinin altındaki motorun ta kendisidir; doğrudan kullandığınızda GPU'ya kaç katman yükleneceğinden KV cache tipine kadar her vidaya erişirsiniz^[20].

vLLM başka bir ihtiyacın aracıdır: tek kullanıcı sohbetinde değil, aynı anda onlarca isteğe servis vermekte parlar. Sürekli batch'leme (continuous batching) ve PagedAttention sayesinde 100+ eşzamanlı kullanıcıda bile düşük gecikme korur; buna karşılık kurulumu ağırdır ve modeli tam GPU belleği ister^[1][15][22]. Kural basit: kendinize çalıştırıyorsanız Ollama/LM Studio/llama.cpp; başkalarına servis ediyorsanız vLLM. Bir ekip içi test, Ollama'nın 5 eşzamanlı kullanıcıda zorlanmaya başladığını, vLLM'in ise yüzlercesini taşıdığını gösteriyor^[15].

Üstüne bir de arayüz katmanı var: Open WebUI, Ollama'nın (ya da herhangi bir OpenAI uyumlu sunucunun) üzerine ChatGPT benzeri, çok kullanıcılı, doküman yükleyip konuşabildiğiniz (RAG) şık bir web arayüzü kurar^[25]. Ollama + Open WebUI ikilisi, ev/ofis kurulumlarının fiili standardı haline geldi.

6. Hangi Modeli İndireyim? 2026 Güncel Liste

Model dünyası hızlı değişir; o yüzden önce balık tutmayı öğrenelim, sonra bugünün balıklarını sayalım. Model seçerken üç eksene bakın: boyut sınıfı (donanımınıza hangi sınıf sığıyor?), mimari (dense mi MoE mi?) ve uzmanlık (genel sohbet, kod, muhakeme, görsel anlama?).

Mimari konusu yeni başlayana en yabancı gelen ama en çok kazandıran konu: MoE (mixture of experts, uzman karışımı) modelleri, toplam parametrenin yalnızca küçük bir kısmını her token'da aktif kullanır. Örneğin 30B toplam / 3B aktif bir MoE model, bellekte 30B'lik yer kaplar ama 3B'lik model hızında koşar^[4][5]. Bu yüzden Mac'lerde ve bol RAM'li sistemlerde MoE modeller uçar. Üstelik llama.cpp'nin --n-cpu-moe bayrağı, uzman katmanlarını sistem RAM'ine itip ortak katmanları GPU'da tutarak, VRAM'inize normalde sığmayacak MoE devlerini kullanılabilir hızda çalıştırmanıza izin verir — 8 GB'lık bir kartta 30B+ MoE koşturmak artık gerçekçi bir senaryo^[8][9][18].

Ağustos 2026 itibarıyla 24 GB sınıfı bir kart (ya da 32 GB'lık bir Mac) için öne çıkan isimler şunlar^[4][13]:

Daha mütevazı donanım için aynı ailelerin küçük kardeşleri var: 8 GB civarında Llama 3.x 8B, Qwen'in 7-8B'leri ve Gemma'nın küçük varyantları gayet iş görür; 4 GB'a kadar inen Phi ailesi kenar cihazlarda bile koşar^[1][13]. Kod için Qwen'in Coder varyantları lokal dünyanın açık ara favorisi^[1][5]. Muhakeme (reasoning) modelleri ise cevaptan önce uzun uzun "düşünür"; zor problemlerde kaliteyi ciddi yükseltir ama token üretimi — dolayısıyla bekleme — kat kat artar. Günlük iş için kapatılabilir düşünme modu olan modeller (Qwen3 gibi) bu yüzden pratiktir.

Pratik kural: Kararsız kaldığınızda donanımınıza sığan en büyük MoE modeli Q4_K_M ile indirin, kendi gerçek işlerinizden 5-10 örnekle test edin. Liderlik tablosu (leaderboard) puanı değil, sizin işinizdeki performans karar versin.

7. İnce Ayar Odası: Bağlam, Sampling ve Diğer Vidalar

Önce en meşhur tuzak: Ollama'nın kısa bağlamı

Ollama, bellek taşmasın diye modelleri varsayılan olarak kısaltılmış bağlam penceresiyle açar (uzun süre 2048, yeni sürümlerde 4096 token)^[19]. Model 128K destekliyor olsa bile! Uzun bir doküman yapıştırırsınız, model başını sessizce unutur ve siz "bu model kötüymüş" dersiniz. Değil — penceresi kısık. Çare tek satır:

# tek seferlik
ollama run qwen3 --ctx-size 16384   # ya da API çağrısında num_ctx parametresi

# llama.cpp tarafında
llama-server -m model.gguf -c 16384 --cache-type-k q8_0 --cache-type-v q8_0

Ama Şekil 1'i hatırlayın: bağlamı açtıkça KV cache büyür. Refleks olarak 128K açmayın; gerçekten gereken kadar açın, gerekiyorsa KV cache quantization ile dengeleyin^[2][27].

Sampling: modelin "mizacını" ayarlamak

Model her adımda olası token'lara olasılık dağıtır; sampling parametreleri bu dağılımdan nasıl seçileceğini belirler^[16]. Bilmeniz gereken üçlü: temperature dağılımı sivriltir ya da düzler (düşük = tutarlı ve tahmin edilebilir, yüksek = yaratıcı ve riskli); top_p kümülatif olasılığı belli eşiği aşan token'ları eler; min_p ise en olası token'a oranla çok zayıf kalanları atar — modern araçlarda top_k'nın yerini büyük ölçüde aldı çünkü her temperature değerinde anlamlı kalır^[6][16]. Ezbere değil reçeteyle gidelim^[6]:

Bir de modelin kartvizitini okumayı unutmayın: birçok model ailesi kendi önerdiği değerleri model kartında (model card) yayınlar; oradaki öneri her zaman genel reçetenin önündedir.

Hızın üç düğmesi daha

keep_alive: Ollama varsayılanda modeli 5 dakika hareketsizlikten sonra bellekten atar; sonraki soruda yeniden yükleme beklersiniz. Sık kullanıyorsanız süreyi uzatın^[1][19]. GPU katman paylaşımı: Model VRAM'e tam sığmıyorsa llama.cpp katmanların bir kısmını GPU'ya, kalanını CPU'ya dağıtabilir (-ngl bayrağı); tamamı sığmadığında bile kısmi yükleme belirgin hız kazandırır^[20]. Speculative decoding: Küçük bir "taslak" model önden tahmin yürütür, büyük model toplu doğrular; desteklendiği yerde bedavaya yakın %30-50 hız demektir^[20][22].

8. Güvenlik: "Lokal = Güvenli" Sanmayın

Lokal çalıştırmanın gizlilik vaadi, yanlış yapılandırmayla bir gecede tersine döner. Ollama'nın API'si varsayılanda kimlik doğrulamasızdır; sorun değil, çünkü yalnızca localhost'u dinler. Ama insanlar başka makineden erişmek için servisi 0.0.0.0'a bağlayıp router'da port açınca, internette herkese açık binlerce Ollama sunucusu oluştu — araştırmacılar bu açık uçlardan model çalmanın, keyfi kullanımın ve hatta modelin cevaplarını manipüle etmenin mümkün olduğunu gösterdi^[7][17].

Reçete kısa: servisi localhost'ta tutun; uzaktan erişim gerekiyorsa VPN (Tailscale gibi) ya da kimlik doğrulamalı bir reverse proxy arkasına koyun; 11434 portunu asla çıplak halde internete açmayın; ve indirdiğiniz modellere de tedarik zinciri gözüyle bakın — model ve araç sürümlerinizi güncel tutun^[7]. Bir de kurumsal not: lokal model çıktısı da sonuçta bir LLM çıktısıdır; prompt injection gibi uygulama katmanı riskleri lokalde de aynen geçerlidir.

9. Sahada Öğrenilen Dersler: En Sık Yapılan Hatalar

Bu bölüm, forumlarda binlerce kez sorulmuş soruların damıtılmış hali. Birincisi, VRAM'i taşırmak: model %10 bile taşsa hız 10 kata kadar düşebilir; "sığdı ama yavaş" diyorsanız muhtemelen taşıyorsunuz — bir küçük quant'a inin^[1]. İkincisi, bağlam penceresini unutmak: yukarıda anlattık; uzun sohbette "model aptallaştı" hissinin bir numaralı sebebi. Üçüncüsü, yanlış sohbet şablonu (chat template): her model kendi özel formatını bekler; ham llama.cpp kullanırken yanlış şablon, modelin anlamsız cevaplar vermesine yol açar — Ollama ve LM Studio bunu sizin için otomatik halleder, bu yüzden başlangıçta onlardan şaşmayın. Dördüncüsü, disk hızını küçümsemek: 20-40 GB'lık modelleri SATA diskten yüklemek dakikalar alır; NVMe SSD lokal LLM'in sessiz kahramanıdır^[1]. Beşincisi, benchmark peşinde savrulmak: her hafta "yeni kral" ilan edilir; kendi işinizde test etmeden model değiştirmeyin.

10. Ollama ile Hızlı Başlangıç

Teori tamam; şimdi biraz pratik. En hızlı yol:

# 1) Ollama'yı kur (macOS / Linux; Windows için site üzerinden installer)
curl -fsSL https://ollama.com/install.sh | sh

# 2) Donanımına uygun bir model çek ve konuş
ollama run qwen3            # 8 GB+ bellek için iyi bir başlangıç
ollama run gemma3:4b        # daha mütevazı makineler için

# 3) Bağlamı genişlet, API'den dene
curl http://localhost:11434/v1/chat/completions -d '{
  "model": "qwen3",
  "messages": [{"role":"user","content":"Merhaba! Kendini tanıt."}]
}'

# 4) İstersen üzerine ChatGPT benzeri arayüz: Open WebUI
docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data ghcr.io/open-webui/open-webui:main

Sonraki adımlarınız da belli: LM Studio'yu indirip farklı quant'ları yan yana deneyin; kartınıza sığan en büyük MoE modeli bulun; --ctx-size, temperature ve KV cache quantization ile oynayın; işiniz büyürse vLLM'e terfi edin. Her adımda bu yazıya dönüp "hangi vida neydi" diye bakabilirsiniz.

Kapanış

Toparlayalım. Lokal LLM'in bütün "sırrı" aslında üç cümleye sığıyor: bellek her şeydir — modeli ve bağlamı ona göre seçin. Q4_K_M ile başlayın — aynı bellekte büyük modelin agresif quant'ı, küçük modelin hassasını yener. Ollama ile girin, ihtiyaç sizi yönlendirsin — kontrol için llama.cpp, arayüz için LM Studio + Open WebUI, servis için vLLM. Gerisi, kendi makinenizde vızır vızır çalışan bir modelin verdiği o tarifsiz keyif. Deneyin, bozun, tekrar kurun — burası kendi laboratuvarınız; token'larınız hızlı, VRAM'iniz bol olsun!

Kaynaklar