yerel LLM etiketine sahip kayıtlar gösteriliyor. Tüm kayıtları göster
yerel LLM etiketine sahip kayıtlar gösteriliyor. Tüm kayıtları göster

16 Aralık 2025 Salı

Yerelde RAG Asistanı Kurulumu: Python, FAISS ve FastAPI ile Adım Adım

RAG nedir ve neden yerelde kurmalısınız?

RAG (Retrieval-Augmented Generation), bir büyük dil modelinin (LLM) yanıt üretmeden önce kendi veritabanınızdan veya belgeliklerinizden ilgili parçaları çekmesini sağlayan bir yaklaşım. Böylece model, güncel ve doğrulanabilir bilgiye dayanarak cevap verir, halüsinasyon oranı düşer ve alanınıza özgü bir asistan elde edersiniz. Bu yazıda, internete kapalı bir ortamda, Python, FAISS ve FastAPI kullanarak hızlı ve hafif bir RAG asistanını nasıl kurabileceğinizi adım adım anlatıyorum.

Mimari bileşenler ve gereksinimler

Minimal bir RAG sistemi dört temel bileşenden oluşur: metin ön işleme ve parçalara ayırma, embedding üretimi, vektör dizin (FAISS) ve yanıt üretici (LLM). Yerel kurulum için Python 3.10+ bir ortam, sentence-transformers ile çok dilli bir embedding modeli, faiss-cpu dizini ve HTTP üzerinden istek alıp yanıtlamak için FastAPI yeterli. İsterseniz yanıt üretici olarak Ollama üzerinden Llama 3 ailesi gibi bir yerel modeli kullanabilir, ya da sisteminize uygun bir başka LLM’i bağlayabilirsiniz.

Kurulum adımları: ortam, paketler ve veri hazırlığı

Önce izole bir Python sanal ortamı oluşturun ve temel paketleri kurun. Gerekli çekirdek paketler tipik olarak fastapi, uvicorn, faiss-cpu, sentence-transformers, pydantic ve metin işleme için regex/unidecode gibi küçük yardımcılar olur. Eğer yerel bir model kullanacaksanız Ollama’yı yükleyip örneğin “llama3” veya “mistral” gibi bir modeli indirin. Belgelerinizi tek bir klasörde toplayın; PDF, DOCX ve düz metinleri mümkünse metne dönüştürüp temizleyin. Tekrarlayan başlıklar, sayfa dipnotları ve tablolar metni kirlettiği için önceden sadeleştirme yapmak ileride kaliteyi ciddi biçimde artırır.

Embedding üretimi ve FAISS ile dizinleme

RAG’in çekirdeği, metni anlam uzayına taşıyan embedding’lerdir. Türkçe ağırlıklı bir kurulum için çok dilli bir model seçmek pratik olur. intfloat/multilingual-e5-base veya sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2 iyi başlangıç seçenekleridir. Belgeleri 500–800 karakter aralığında, 50–100 karakter örtüşmeli parçalara bölerseniz hem hatırlama oranı hem bağlam bütünlüğü dengelenir. Her parçayı embedding modelinden geçirip bir vektör matrisi üretin; ardından FAISS’te IndexFlatIP (cosine benzeri iç çarpım) veya daha büyük veri için HNSW/IVF tabanlı bir dizin kurun. Dizin ve meta verileri (ör. belge kimliği, başlık, sayfa numarası) disk üzerinde saklayarak soğuk başlatma sürelerini azaltabilirsiniz.

Sorgu işleme hattı: geri getirme, yeniden sıralama ve yanıt üretimi

İstemci bir soru sorduğunda önce soruyu embedding modellerinden geçirip FAISS’e benzerlik araması yapın. İlk aşamada genellikle top-k=5–8 yeterlidir. Sonuçları kalite için hafif bir yeniden sıralama (re-rank) aşamasından geçirmek özellikle uzun ve benzer parçalarda fark yaratır; isterseniz küçük bir cross-encoder veya basit bir skor birleştirme (benzerlik + anahtar kelime çakışması) yaklaşımı kullanın. Son olarak en iyi 3–5 parçayı bir prompt şablonunda LLM’e vererek yanıt üretin. İyi bir şablon, modele “yalnızca verilen bağlama dayanması”, “kaynakları listelemesi” ve “emin olmadığı noktalarda netçe belirtmesi” yönünde talimatlar içerir. Bu aşamada streaming yanıt (chunk bazlı) hem his olarak daha hızlıdır hem de istemci tarafında kullanıcı deneyimini iyileştirir.

FastAPI ile uç noktalar ve basit bir API tasarımı

Sunucu tarafında iki temel uç nokta yeterlidir: /index ve /query. İlk uç nokta yeni belge eklemeyi, embedding ve dizine yazmayı üstlenir. İkincisi kullanıcı sorusunu alır, geri getirme ve yeniden sıralama yapar, LLM’den gelen yanıtı döndürür. Yanıta kaynak parçaların kimliklerini ve güven puanlarını dahil ederseniz istemci tarafında “bu cevabın kanıtı” şeritleri gösterebilirsiniz. Üretim ortamında CORS ayarlarını, basit bir oran sınırlama (rate limit) ve temel kimlik doğrulamayı eklemeyi unutmayın.

Performans, kalite ve bakım ipuçları

İlk indekslemeyi hızlandırmak için toplu gömme (batch) boyutunu donanımınıza göre ayarlayın; CPU’da 16–64 arası genelde güvenlidir. Dizin aramasında hız/kalite dengesini sağlamak üzere IVF ya da HNSW gibi yaklaşık yakın komşu (ANN) yapılarını deneyin ve geri getirme anında efSearch benzeri parametreleri kademeli artırın. Kalite için chunk boyutu ve örtüşmesini alanınıza göre yeniden ayarlayın; teknik dökümanlarda daha uzun, SSS türü içerikte ise daha kısa parçalar daha iyi sonuç verir. Ayrıca yinelenen metinleri, versiyonlanmış kopyaları ve tarih geçmişlerini indeks dışında tutmak, cevapların tekrara düşmesini engeller.

Düzenli bir değerlendirme seti oluşturun: 30–50 soruluk, doğru cevap ve kaynak eşleşmesi içeren bir küçük benchmark ile sürümler arasında regresyon olup olmadığını görebilirsiniz. Ölçüt olarak geri getirme için recall@k, cevap üretimi için ise doğruluk, faydalılık ve kaynak isabetini manuel etiketleme ile kontrol etmek etkilidir. Basit bir geri bildirim mekanizması (kullanıcı oylaması, “yanlıştı/düzelt” düğmesi) gerçek kullanımda iyileştirme fırsatlarını hızla ortaya çıkarır.

Güvenlik, gizlilik ve dağıtım

Yerel RAG sistemleri çoğu zaman hassas verilerle çalışır. Bu nedenle PII tespiti ve maskeleme, uçtan uca TLS, erişim loglarının minimal ve anonim tutulması önemlidir. Küçük bir ek katman olarak belirli sorgulara kural tabanlı filtre uygulayabilir, gizli etiketli içerikleri yanıt bağlamına girmeden önce temizleyebilirsiniz. Dağıtım için hafif bir konteyner imajı, tek bir health-check uç noktası ve kalıcı depolama bağlanmış bir FAISS dizini çoğu ekip için yeterli, ölçeklenebilir ve sürdürülebilir bir başlangıç sunar.

Sonuç

Python, FAISS ve FastAPI ile yerelde çalışan bir RAG asistanı kurmak sanıldığından daha erişilebilir. Doğru embedding modeli, düzenli bir parçalara ayırma stratejisi ve iyi tasarlanmış bir prompt ile, alanınıza özel, hızlı ve güvenilir bir bilgi asistanına sahip olursunuz. İlk sürümü basit tutun, kullanım verisi geldikçe yeniden sıralama ve değerlendirme mekanizmasını güçlendirin; böylece hem maliyeti hem karmaşıklığı kontrol altında tutarken yüksek kaliteli cevaplar üreten bir sistem inşa edebilirsiniz.

12 Aralık 2025 Cuma

Docker ile Yerel LLM Kurulumu: Ollama + Open WebUI (GPU Hızlandırmalı Adım Adım Rehber)

Giriş

Yerel büyük dil modeli (LLM) çalıştırmak; gizliliği korumak, gecikmeyi düşürmek ve kullanım maliyetini kontrol etmek için harika bir yöntem. Son dönemde Ollama ve Open WebUI, Docker ile birlikte kullanıldığında zahmetsiz bir kurulum ve modern bir arayüz sunuyor. Bu rehberde, Ollama + Open WebUI ikilisini Docker üzerinde kurup, mümkünse GPU hızlandırma ile performansı nasıl katlayacağınızı adım adım anlatıyorum.

Neler Kuracağız?

Ollama, Llama 3, Mistral, Qwen gibi açık modelleri kolayca indirip çalıştırmanızı sağlar. Open WebUI ise sohbet, dosya yükleme, RAG eklentileri ve çoklu model yönetimi gibi özelliklerle modern bir ara yüz sunar. Docker sayesinde bu iki bileşen birbirinden izole, tekrar üretilebilir ve kolay güncellenebilir hale gelir.

Gereksinimler

- İşletim sistemi: Linux (Ubuntu 22.04+ önerilir), Windows 11 (WSL2 ile), veya macOS. CPU ile çalışır; GPU hızlandırma için donanım ve sürücü şarttır.

- Donanım: En az 16 GB RAM öneririm. 8B sınıfı modeller için 6–8 GB VRAM ile kuantize sürümler rahatlar; daha büyük modeller için 12 GB+ VRAM faydalıdır.

- Docker: Linux’ta Docker Engine + Docker Compose plugin; Windows/macOS’ta Docker Desktop.

Hızlı Başlangıç: Docker Compose ile Ollama + Open WebUI

Önce iki kalıcı disk alanı (volume) ve ortak bir ağ üzerinde iki servis ayağa kaldıracağız. Aşağıdaki dosyayı docker-compose.yml adıyla kaydedin:

version: "3.8"
services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    restart: unless-stopped
    ports:
      - "11434:11434"
    volumes:
      - ollama:/root/.ollama
    environment:
      - OLLAMA_KEEP_ALIVE=24h
    # GPU için not: Aşağıdaki 'GPU Hızlandırma' bölümüne bakın.

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

volumes:
  ollama:
  openwebui:

Komutlar: Bulunduğunuz klasörde docker compose up -d deyin. Ardından tarayıcıdan http://localhost:3000 adresine giderek Open WebUI arayüzünü açın.

Model İndirme ve Test

Open WebUI içinden model menüsünde “Pull” diyerek llama3:8b, qwen2:7b veya mistral:7b gibi kuantize seçenekleri indirebilirsiniz. Terminal tercih ederseniz:

docker exec -it ollama ollama pull llama3:8b
docker exec -it ollama ollama run llama3:8b "Merhaba, nasılsın?"

Her şey yolundaysa, modelden metin çıktısı almaya hemen başlayabilirsiniz.

GPU Hızlandırma (NVIDIA, AMD, Apple Silicon)

NVIDIA (Linux/WSL2): Sunucuda uyumlu sürücü ve nvidia-container-toolkit kurulu olmalı. Özet akış:

# Sürücü kurulumu sonrası:
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | \
 sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -fsSL https://nvidia.github.io/libnvidia-container/$distribution/libnvidia-container.list | \
 sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

Ardından Ollama’yı GPU ile başlatın:

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

Compose kullanacaksanız, mevcut servisi durdurup bu komutla GPU’lu Ollama kapsayıcısını başlatabilir veya Docker Compose V2’de desteklenen GPU ayarlarını kullanabilirsiniz. Sürüm farklılıkları nedeniyle en sorunsuz yöntem genellikle yukarıdaki docker run satırıdır.

AMD ROCm (Linux): ROCm destekli kart ve sürücülerle Ollama GPU hızlandırma çalışır. Konteyner içinde ROCm erişimi için ROCm runtime ve /dev/kfd, /dev/dri cihazlarına erişim gerekebilir. Pratikte, GPU hızlandırma istiyorsanız ROCm tarafında host’a kurulu Ollama’yı, Open WebUI’yi ise Docker’da tutmak çoğu kullanıcı için daha az sorun çıkarır.

Apple Silicon (macOS): Ollama, Metal ile GPU hızlandırmayı yerel kurulumda otomatik kullanır. Docker konteyneri macOS’ta Metal’e doğrudan erişemeyeceğinden, Mac kullanıcılarına Ollama’yı host’a, Open WebUI’yi Docker’a kurmalarını öneririm. Open WebUI’nin OLLAMA_BASE_URL değerini host’taki Ollama adresine işaret edecek şekilde değiştirin.

Performans İpuçları

- Kuantizasyon: q4_k_m gibi kuantize modeller VRAM/RAM kullanımını dramatik biçimde azaltır. İlk denemelerde 7–8B modellerin kuantize sürümleri idealdir.

- Eşzamanlılık: OLLAMA_NUM_PARALLEL ve OLLAMA_BATCH gibi değişkenlerle paralellik ve batch boyutunu ayarlayabilirsiniz. Makinenizin sınırlarını test ederek en iyi kombinasyonu bulun.

- Disk I/O: Modeller büyük dosyalardır; SSD kullanımı ve yeterli boş alan önemlidir.

Open WebUI Özelliklerine Kısa Bakış

Open WebUI, konuşma geçmişi, istem (prompt) şablonları, çoklu model seçimi, rol tanımları ve RAG için belge yükleme gibi pratik özellikler sunar. Takım içinde kullanacaksanız, kullanıcı oturumları ve rol bazlı ayarlarla basit bir “self-hosted” sohbet platformu oluşturabilirsiniz.

Güvenlik ve Ağ

Bu kurulumu internetten erişilebilir hale getirecekseniz, ters proxy arkasında HTTPS zorunludur. Open WebUI’de dahili oturum açma mekanizmasını etkin tutun. Ollama API’sini (11434) doğrudan dış dünyaya açmayın; sadece iç ağda veya reverse proxy üzerinden eriştirin.

Sorun Giderme

- CUDA hatası: Sürücü ve nvidia-container-toolkit sürüm uyumsuz olabilir. nvidia-smi çıktısını kontrol edin, Docker daemon’ı yeniden başlatın.

- Model çekilemiyor: Ağ veya DNS sorunları; tekrar deneyin, mümkünse farklı bir ağa geçin.

- Open WebUI, Ollama’ya bağlanamıyor: OLLAMA_BASE_URL’in doğru olduğundan emin olun. Compose içinde servis adları (ollama) DNS ile çözülür; dışarıdan erişiliyorsa host IP’sini kullanın.

Sonuç

Docker ile Ollama + Open WebUI kurmak, yerel LLM deneyimini dakikalar içinde erişilebilir kılıyor. GPU hızlandırma ile yanıt süresi ve akıcılık ciddi ölçüde iyileşiyor. Küçük bir masaüstünde bile kuantize modellerle harika sonuçlar alabilir, belgelerinizi yerelde işleyebilir ve verinizi bulut servislerine göndermeden üretkenlik sağlayabilirsiniz. İhtiyacınıza göre 7–8B modellerle başlayıp, daha güçlü bir GPU’ya geçtiğinizde 13B/70B sınıfına doğru kademeli büyüyebilirsiniz.

21 Ekim 2025 Salı

Yerel LLM Kurulumu: Ollama ve Open WebUI ile Hızlı ve Güvenli Yapılandırma Rehberi

Giriş: Neden Yerel LLM?

Gizlilik, düşük gecikme ve maliyet kontrolü, büyük dil modellerini (LLM) yerelde çalıştırmanın en önemli avantajları. Bu rehberde, açık kaynak ekosistemde hızla popülerleşen Ollama ile modelleri nasıl indireceğinizi ve Open WebUI üzerinden nasıl yöneteceğinizi adım adım göstereceğim. Amaç, teknik bariyeri düşük tutarak pratik bir kurulum sağlamak ve GPU hızlandırma, belge tabanlı arama (RAG) gibi ileri kullanım senaryolarına hızlıca geçebilmek.

Ön Koşullar ve Mimari

Ollama; macOS’ta Metal, Linux’ta CUDA/ROCm, Windows’ta DirectML/CUDA (uyum durumuna göre) ile çalışır. Open WebUI, Ollama’nın sunduğu yerel API’ye (varsayılan http://localhost:11434) bağlanarak tarayıcı tabanlı bir arayüz sunar. İkisini tek makinede koşturabilir, Docker ile izole edebilir veya sunucuya taşıyabilirsiniz.

Kurulum: Ollama

macOS: Homebrew ile brew install ollama komutunu çalıştırın. Ardından ollama serve ile servisi başlatın. Apple Silicon’da GPU hızlandırma otomatik devreye girer.

Linux: Terminalde curl -fsSL https://ollama.com/install.sh | sh komutunu çalıştırın. NVIDIA GPU için sürücü ve CUDA kurulumu yaptığınızdan emin olun. Servisi systemctl enable --now ollama ile kalıcılaştırabilirsiniz.

Windows: Resmi .msi yükleyicisiyle kurulum yapın. Ollama Tray ile servis başlatılabilir. GPU hızlandırma için güncel sürücüler ve desteklenen backend gereklidir.

İlk Modeli İndirme ve Çalıştırma

Popüler ve hızlı bir başlangıç için ollama pull llama3:8b veya ollama pull mistral:7b komutlarını kullanın. Ardından ollama run llama3:8b diyerek etkileşime geçin. Soruları terminalden yazabilir veya REST API ile programatik çağrılar yapabilirsiniz.

API örneği: curl http://localhost:11434/api/generate -d '{"model":"llama3:8b","prompt":"Merhaba, bugünün tarihi?"}'. Yanıtlarda gecikme görürseniz daha düşük quantizasyon (ör. q4_K_M) indirmeyi değerlendirin.

Open WebUI ile Grafik Arayüz

Open WebUI, sohbet geçmişi, çoklu model, belge ekleme ve RAG gibi özellikleri tek ekranda sunar. Docker ile hızlı kurulum için iki konteyner yeterlidir.

Ollama (Docker): docker run -d --name ollama -p 11434:11434 --gpus all -v ollama:/root/.ollama ollama/ollama

Open WebUI: Linux’ta Ollama’ya erişim için host gateway ekleyin: docker run -d --name open-webui -p 3000:8080 --add-host=host.docker.internal:host-gateway -e OLLAMA_API_BASE_URL=http://host.docker.internal:11434 -v open-webui:/app/backend/data open-webui/open-webui:latest

Windows/macOS’ta genellikle host.docker.internal otomatik çalışır. Tarayıcıdan http://localhost:3000 adresine giderek arayüze ulaşabilirsiniz.

RAG: Belgelerle Akıllı Yanıtlar

Open WebUI içinde “Knowledge” veya “Documents” bölümünden PDF, Markdown, TXT gibi belgeleri ekleyebilir ve indeksleyebilirsiniz. Ardından sohbet penceresinde ilgili bilgi tabanını seçtiğinizde model, cevaplarını bu içeriklere dayandırır. Küçük veri kümelerinde arama oldukça hızlıdır; büyük koleksiyonlarda bellek yükünü azaltmak için daha düşük boyutlu modeller ve hafif embedding’ler tercih edin.

Performans ve İnce Ayar

- Quantization: q4 varyantları RAM ve VRAM kullanımını düşürür; kalite/akıcılık dengesi için q5 veya q6 deneyin.
- İş Parçacığı: OLLAMA_NUM_PARALLEL ile eşzamanlı istek sayısını, --num-ctx ile bağlam penceresini ayarlayın.
- GPU Paylaşımı: Birden fazla model kullanıyorsanız aynı anda çalıştırmak yerine sıraya almayı tercih edin. GPU belleği dolarsa CPU’ya düşerek performans keskin biçimde azalabilir.
- Model Seçimi: Kod tamamlama için “Coder” varyantları; uzun bağlam gerektiren işlerde “Instruct” ve geniş context pencereli sürümler daha verimlidir.

Güvenlik ve Ağ Erişimi

Ollama’nın API’sini dış dünyaya açacaksanız bir ters vekil (ör. Caddy, Nginx) arkasında temel kimlik doğrulama uygulayın. Ev ağı senaryosunda sadece localhost’a bağlayın ve 11434 portunu yönlendirmeyin. Open WebUI kullanıcı hesapları oluşturmanıza izin verir; rol tabanlı erişimle modellerin kimler tarafından kullanılabileceğini sınırlayın.

Sorun Giderme

- Yavaş yanıt: Daha küçük modeli veya düşük quantizasyonu deneyin; CPU moduna düşmediğinizden emin olun.
- GPU tanınmıyor: Sürücü/CUDA güncellemelerini kontrol edin. Docker’da --gpus all bayrağı ve NVIDIA Container Toolkit gereklidir.
- Bağlantı hatası: Open WebUI’de OLLAMA_API_BASE_URL değerini ve ağ köprüsünü doğrulayın; Linux’ta --add-host parametresini eklemeyi unutmayın.
- Disk doluyor: Kullanmadığınız modelleri ollama rm model-adı ile kaldırın; hacim boyutlarını düzenli izleyin.

Sonuç

Ollama + Open WebUI ikilisiyle yerel LLM deneyimi, hem bireysel üretkenlik hem de kurumsal prototipleme için güçlü bir zemin sunuyor. Kurulum basit, yönetim pratik ve maliyet öngörülebilir. Başlangıçta hafif bir modelle ilerleyip ihtiyaçlara göre ölçeklendirmek, GPU kaynaklarını dikkatle planlamak ve güvenlik katmanlarını erken eklemek uzun vadede en sağlıklı yaklaşım olacaktır.

6 Ekim 2025 Pazartesi

Yerel LLM Rehberi: Ollama ile Llama 3.1’i Bilgisayarınızda Çalıştırma, GPU Hızlandırma ve RAG

Yerelde LLM çalıştırmanın avantajları

Büyük dil modellerini (LLM) bulut yerine kendi bilgisayarınızda çalıştırmak; gizliliği artırır, gecikmeyi düşürür ve yoğun denemelerde maliyeti kontrol altına alır. Son dönemde popülerleşen Ollama, Llama 3.1, Qwen, Mistral gibi açık modelleri tek komutla indirip çalıştırmanızı sağlayan hafif ve pratik bir platformdur. Bu yazıda, Llama 3.1’i Ollama ile yerelde kurmayı, GPU hızlandırmayı devreye almayı ve RAG (Retrieval-Augmented Generation) mimarisine giden kısa bir yol haritasını adım adım anlatıyorum.

Gereksinimler ve model seçimi

LLM’lerin RAM ve VRAM iştahı, model boyutuna ve sıkıştırma (quantization) düzeyine göre değişir. 8B (8 milyar parametre) sınıfı modeller güncel tüketici bilgisayarlarda iyi bir denge sunar. 16 GB RAM ve tercihen en az 8 GB VRAM, akıcı kullanım için idealdir. Daha büyük 13B veya 70B modeller daha yüksek kalite verse de donanım talebi ciddi artar. Ollama, modelleri quantized (ör. 4-bit) olarak sunabildiği için daha düşük bellekle de tatmin edici performans elde edilebilir. Kural basit: RAM/VRAM yetmiyorsa daha küçük model veya daha agresif sıkıştırma seçin.

Kurulum: macOS, Windows ve Linux

macOS: Apple Silicon için Metal hızlandırma desteği hazır gelir. Homebrew ile kurabilirsiniz: “brew install ollama”. Kurulum sonrası menü çubuğundaki Ollama simgesinden servis durumunu kontrol edebilirsiniz.

Windows: Ollama’nın resmi kurulum paketini indirip çalıştırın. Kurulumla birlikte Ollama servisi otomatik başlatılır. PowerShell veya Komut İstemi üzerinden komutları çalıştırabilirsiniz.

Linux: Resmi kurulum betiği pratik bir yoldur: “curl -fsSL https://ollama.com/install.sh | sh”. NVIDIA GPU kullanacaksanız sistemde güncel CUDA sürümü yüklü olmalı (sürücü ve CUDA 12.x tavsiye edilir).

İlk model: Llama 3.1’i indirme ve çalıştırma

Kurulumdan sonra ilk test için komut satırında şu komutu verin: “ollama run llama3.1:8b”. İlk çağrıda model otomatik indirilecektir. Ardından terminalde bir istem (prompt) göreceksiniz; bir soru yazıp Enter’a basın. Çıkmak için Ctrl+C kullanabilirsiniz. Modeli önceden indirmek isterseniz “ollama pull llama3.1:8b” komutunu çalıştırmanız yeterli.

Performans/kalite dengesini değiştirmek için farklı varyantları deneyin. Daha küçük bellekli sistemlerde 8B sınıfı daha rahat çalışırken, güçlü GPU’larda 13B ve üzeri modeller daha iyi sonuç verebilir. Türkçe performansı sizin için kritikse, Qwen veya Mistral ailesinin Türkçe kapsama oranı yüksek sürümlerini de test etmeyi düşünebilirsiniz.

GPU hızlandırma: CUDA, Metal ve ROCm

Ollama, uygun GPU’yu otomatik algılar. Apple Silicon’da Metal, NVIDIA’da CUDA, Linux’ta bazı AMD kartlarda ROCm ile ivme kazanırsınız. GPU’nun gerçekten kullanıldığını doğrulamak için macOS’ta Etkinlik İzleyici’de, Linux’ta “nvidia-smi” çıktısında veya Windows’ta Görev Yöneticisi’nde GPU kullanımını kontrol edebilirsiniz. Eğer sistem otomatik olarak CPU’ya düşüyorsa sürücü/kitaplık sürümlerinizi güncelleyin ve yeniden deneyin.

Bellek hataları alırsanız, daha küçük bir model seçin veya sıkıştırma derecesini yükseltin. Uzun bağlam (context) isteyen uygulamalarda context penceresi büyüdükçe hem RAM hem VRAM tüketimi artar; bu durumda promptunuzu kısaltın veya daha geniş VRAM’e sahip bir GPU kullanın.

Modelfile ile özelleştirme

Ollama, Modelfile ile model davranışını özelleştirmenize izin verir. Klasörünüzde “Modelfile” adlı bir dosya oluşturup aşağıdaki gibi sade bir yapı yazabilirsiniz:

FROM llama3.1:8b
PARAMETER temperature 0.2
SYSTEM Şirket içi belge asistanısın. Kısa ve net yanıtlar ver.

Ardından “ollama create kurumsal-asistan -f Modelfile” komutuyla yeni bir yerel model varyantı oluşturun ve “ollama run kurumsal-asistan” ile çalıştırın. Bu yöntemle sıcaklık, sistem mesajı, durdurma token’ları gibi ayarları kalıcı hâle getirebilirsiniz.

HTTP API ile entegrasyon

Ollama, varsayılan olarak “http://localhost:11434” üzerinde bir API sunar. Basit bir metin üretimi için “/api/generate” uç noktasına şu gövdede bir POST isteği gönderebilirsiniz: { "model": "llama3.1:8b", "prompt": "Merhaba, bugün hava nasıl?" }. Akışlı (stream) yanıtları desteklediği için gerçek zamanlı token üretimini arayüzünüze yansıtabilirsiniz. Benzer şekilde “/api/embeddings” uç noktasıyla yerel embedding üretip vektör veri tabanlarına yazmanız mümkündür.

RAG (Retrieval-Augmented Generation) hızlı başlangıç

Yerel kurulumun en güçlü senaryolarından biri, belgelerinizle konuşan bir asistan oluşturmaktır. Özet adımlar şöyle: (1) Belgelerinizi parçalara ayırın (chunking), (2) Her parça için embeddings üretin (“/api/embeddings” veya LangChain/LlamaIndex ile Ollama backend), (3) Embedding’leri bir vektör veritabanına (Chroma, FAISS, Milvus vb.) kaydedin, (4) Kullanıcı sorusunu embed edip en yakın parçaları bulun ve (5) Bu parçaları prompt’un “context” bölümüne enjekte ederek modelden yanıt isteyin. Böylece modelin parametre içi bilgisini güncellemeden, belgenize dayalı güncel ve kaynaklı cevaplar üretirsiniz.

İpuçları ve sorun giderme

- Uzun süreli oturumlar için keep-alive süresini artırarak modelin bellekte kalmasını sağlayın; yükleme gecikmesi azalır. Sunucu yeniden başlarken otomatik model yüklenmesini istemiyorsanız keep-alive’ı düşürebilirsiniz.
- Yanıt kalitesi dalgalanıyorsa temperature’ı düşürüp (0.2–0.5) deterministikliği artırın; yaratıcılık istiyorsanız 0.7+ deneyin.
- Türkçe çıktı kalitesi, sistem mesajınız ve örneklerle (few-shot) ciddi iyileşir. Kısa, görev odaklı bir SYSTEM ve birkaç örnek diyaloğu eklemeyi deneyin.
- Performans sınırına yaklaştığınızda bağlam penceresini (ör. 4K yerine 2K token) küçültmek, hız ve kararlılığı belirgin artırır.
- Yeni sürümlerle birlikte çekirdek hızlandırmalar (FlashAttention benzeri optimizasyonlar) ve bellek kullanımı iyileşiyor; Ollama’yı ve sürücüleri güncel tutun.

Sonuç

Ollama, yerelde LLM çalıştırmayı herkes için erişilebilir kılıyor. Llama 3.1’in 8B sınıfı, günlük asistan görevlerinden hızlı prototiplemeye kadar pek çok kullanımda tatmin edici sonuç veriyor. GPU hızlandırma ve RAG ile birleştirildiğinde, şirket içi gizli verilerle çalışan, düşük gecikmeli ve kontrol edilebilir üretken yapay zekâ deneyimleri inşa etmek mümkün. Küçük başlayın, donanım ve kullanım senaryonuza göre modeli ve ayarları kademeli olarak büyütün; elde edeceğiniz verim, bulut tabanlı çözümlerle rahatlıkla yarışacaktır.

17 Eylül 2025 Çarşamba

Docker Compose ile Yerel LLM Kurulumu: Ollama ve Open WebUI (Llama 3.1 8B Rehberi)

Özet ve Amaç

Yerel büyük dil modeli (LLM) çalıştırmak artık sadece veri bilimi ekiplerinin değil, geliştiricilerin ve meraklı kullanıcıların da gündeminde. Bu rehberde, Docker Compose kullanarak Ollama ve Open WebUI ile bilgisayarınızda Llama 3.1 8B modelini nasıl çalıştıracağınızı adım adım anlatıyorum. Kurulum tamamen yerel olduğu için gizlilik avantajı sağlar, gecikme süresini düşürür ve internet erişimi olmadan üretken yapay zeka deneyimi yaşatır.

Gereksinimler

- İşletim sistemi: Linux, macOS veya Windows (Windows için WSL2 önerilir).
- Donanım: En az 16 GB RAM önerilir. GPU şart değil; olsa da performans artar. NVIDIA GPU hızlandırması için Linux + NVIDIA Container Toolkit gerekir.
- Yazılım: Docker ve Docker Compose (Docker Desktop içerir).
- İnternet: İlk model indirme için gerekli.

Adım 1: Docker’ı Hazırlayın

Docker yüklü değilse Docker Desktop’ı kurun. Kurulum sonrası aşağıdaki komutlarla sürümü doğrulayın:
docker --version
docker compose version
Her iki komut da sürüm döndürüyorsa hazırsınız.

Adım 2: Proje Klasörü ve Compose Dosyası

Boş bir klasör oluşturun ve kök dizine docker-compose.yml dosyasını ekleyin. Aşağıdaki içerik, Ollama ve Open WebUI’yi tek komutla ayağa kaldırır. WebUI, Ollama’yı dahili ağ üzerinden görecek şekilde ayarlanmıştır.

version: "3.9"
services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama:/root/.ollama
    restart: unless-stopped

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

volumes:
  ollama:
  openwebui:

Not: GPU hızlandırması istiyorsanız Linux’ta NVIDIA Container Toolkit kurup Ollama servisini GPU ile çalıştırabilirsiniz. Compose tarafında farklı varyasyonlar olsa da en sorunsuz yol genellikle tek servis için docker run --gpus all ... kullanmaktır. Bu rehber CPU’da sorunsuz çalışan kurulum üzerine odaklanır.

Adım 3: Servisleri Başlatın

Proje klasörünüzde şu komutu çalıştırın:
docker compose up -d
İlk kurulumda imajlar indirileceği için biraz zaman alabilir. Durumu görmek için:
docker compose ps ve docker compose logs -f ollama komutlarını kullanabilirsiniz.

Adım 4: Modeli İndirin (Llama 3.1 8B)

Ollama konteynerine girip modeli çekin:
docker exec -it ollama bash
ollama pull llama3.1:8b
İlk indirme birkaç GB olabilir. Sisteminizin RAM ve disk durumuna göre indirip hazırlayacaktır. Daha az bellek kullanan kuantize sürümler için Ollama içindeki etiketleri inceleyebilir veya ollama run llama3.1:8b ile doğrudan test edebilirsiniz.

Adım 5: Open WebUI ile Görsel Arayüz

Tarayıcınızda http://localhost:3000 adresine gidin. İlk açılışta basit bir kayıt formu çıkabilir. Ardından sol alttaki model listesinden llama3.1:8b seçin. Eğer listede görünmüyorsa OLLAMA_BASE_URL ayarının http://ollama:11434 olduğundan ve Ollama servisinin çalışma durumundan emin olun. Alternatif olarak “Add Model” bölümünden ismi elle girebilirsiniz.

Performans İpuçları

- Kuantize modeller: 8B modellerde q4 veya q5 gibi kuantizasyonlar RAM kullanımını ciddi azaltır. Doğruluk bir miktar düşse de masaüstü sistemlerde büyük fark yaratır.
- Bağlam penceresi: Gerekli değilse yüksek context length kullanmayın. Daha az bellek tüketir ve yanıtlar hızlanır.
- Paralellik: Aynı anda çok istek göndermeyin. OLLAMA_NUM_PARALLEL=1 bırakmak çoğu sistemde daha kararlı sonuç verir.

Sorun Giderme

- Port çakışması: 11434 veya 3000 kullanımda ise compose dosyasındaki portları değiştirin (ör. 3001:8080).
- Yavaş ilk yanıt: Model ilk yüklemede belleğe alınır; ikinci istekler daha hızlı olacaktır.
- Bellek yetersiz: Kuantize sürüme geçin veya daha küçük bir model seçin (ör. 7B/8B yerine 3B-4B familyası).
- Güncelleme: docker compose pull ardından docker compose up -d ile imajları güncel tutun.

Güvenlik ve Ağ

Bu kurulum yerel geliştirme içindir. Portları internetten erişilebilir yapmayın. Uzak erişim gerekiyorsa ters proxy ve kimlik doğrulama koyun. Verileriniz container volume’larında tutulur; hassas içerik paylaşıyorsanız yedekleme ve şifreleme politikalarınızı belirleyin.

Sonuç

Dakikalar içinde Docker Compose ile Ollama ve Open WebUI’yi kurup Llama 3.1 8B gibi güncel bir LLM’i yerelde çalıştırabilirsiniz. Bu yaklaşım, gizlilik, kontrol ve düşük gecikme avantajları sunar. İhtiyaçlarınıza göre kuantize modellerle bellek kullanımını düşürüp verimi artırabilir, ileride GPU desteği ekleyerek daha hızlı sonuçlar alabilirsiniz. Yerel LLM ile prototipleme, dahili araç geliştirme ve offline kullanım senaryoları çok daha erişilebilir hale geliyor.

9 Eylül 2025 Salı

Ollama ve ChromaDB ile Yerel RAG Sistemi Kurulumu: Adım Adım Geliştirici Rehberi (2025)

RAG nedir ve neden yerelde kurmalısınız?

Retrieval-Augmented Generation (RAG), büyük dil modellerinin (LLM) kurumsal veya özel verilerle beslendiğinde daha güncel, doğru ve izlenebilir cevaplar üretmesini sağlayan bir yaklaşım. Kısaca, önce vektör veritabanı üzerinden ilgili doküman parçalarını buluyor, sonra bu parçaları modelin istemine ekleyerek yanıt oluşturuyoruz. Yerel RAG ise verinizin cihazınızda kalmasına, maliyetin düşmesine ve düşük gecikme ile çalışmanıza olanak tanır. Bu yazıda Ollama, ChromaDB ve açık kaynak modellerle tamamen yerel bir RAG sistemi kuracağız.

Mimari ve gereksinimler

Mimari: (1) Gömme (embedding) modeli ile dokümanları vektörleştir, (2) ChromaDB’ye kaydet, (3) Soru geldiğinde en alakalı parçaları geri getir (retrieve), (4) LLM’e bu bağlamı vererek cevabı üret.

Gereksinimler: 8 GB+ RAM (tercihen 16 GB), modern CPU; GPU varsa daha iyi. macOS, Linux veya Windows üzerinde çalışabilir. Python 3.10+, ve terminal erişimi gerekir.

Kurulum: Ollama, model ve ChromaDB

1) Ollama kurulum
macOS: brew install ollama
Linux: curl -fsSL https://ollama.com/install.sh | sh
Windows: Resmi MSI kurulum paketini indirip çalıştırın
Ardından servis: ollama serve

2) Modelleri indir
ollama pull llama3.1:8b-instruct
ollama pull nomic-embed-text
Not: Kaynaklar kısıtlıysa daha ufak bir model (ör. llama3.2:3b-instruct) seçebilirsiniz. Embed modeli olarak mxbai-embed-large da iyi sonuç verir.

3) Python bağımlılıkları
python -m venv .venv && source .venv/bin/activate
pip install chromadb fastapi uvicorn pydantic
İsteğe bağlı: yeniden sıralama (re-ranking) için pip install sentence-transformers

Veri yükleme ve vektörleştirme

Dokümanlarınızı data/ klasörüne (PDF, TXT, MD) yerleştirdiğinizi varsayalım. Basitlik için düz metin örnekliyoruz. Üretim ortamında PDF parçalama (chunking) ve OCR katmanı düşünebilirsiniz.

Basit Python ingestor
import os, requests, uuid
import chromadb
from chromadb.utils import embedding_functions

OLLAMA_URL = "http://localhost:11434/api/embeddings"
EMBED_MODEL = "nomic-embed-text"

def embed_texts(texts):
  vecs = []
  for t in texts:
    r = requests.post(OLLAMA_URL, json={"model": EMBED_MODEL, "input": t})
    r.raise_for_status()
    vecs.append(r.json()["embedding"])
  return vecs

client = chromadb.PersistentClient(path="chroma_store")
collection = client.get_or_create_collection(name="docs", embedding_function=embed_texts)

def chunk(text, size=700, overlap=120):
  out=[]; i=0
  while i < len(text):
    out.append(text[i:i+size])
    i += size - overlap
  return out

docs_dir = "data"
for fname in os.listdir(docs_dir):
  path = os.path.join(docs_dir, fname)
  if not os.path.isfile(path): continue
  text = open(path, "r", encoding="utf-8").read()
  chunks = chunk(text)
  ids = [str(uuid.uuid4()) for _ in chunks]
  metas = [{"source": fname} for _ in chunks]
  collection.add(documents=chunks, metadatas=metas, ids=ids)
print("Indeksleme tamam.")

Sorgulama ve yanıt üretimi

Sorguda, ChromaDB’den en alakalı parçaları çekip bunları LLM istemine ekleyeceğiz. Ollama’nın üretim API’sini kullanacağız.

Basit sorgu/cevap
import requests
GEN_URL = "http://localhost:11434/api/generate"

def ask(query, k=4):
  res = collection.query(query_texts=[query], n_results=k)
  contexts = [d for d in res["documents"][0]]
  sources = [m["source"] for m in res["metadatas"][0]]
  context_block = "\\n\\n".join([f"[{i+1}] {c}" for i,c in enumerate(contexts)])
  prompt = f"Kontekstten yararlanarak yanıtla. Bilgiyi uydurma. Kaynak numaralarını belirt.\\nKontekst:\\n{context_block}\\n\\nSoru: {query}\\nCevap:"
  r = requests.post(GEN_URL, json={"model":"llama3.1:8b-instruct","prompt":prompt,"stream":False,"options":{"temperature":0.2}})
  r.raise_for_status()
  answer = r.json()["response"]
  return answer, list(set(sources))

print(ask("Şirketimizin yedekleme politikası nedir?"))

FastAPI ile basit REST API

Uygulamanızı diğer servislerin kullanabilmesi için REST olarak sunabilirsiniz.

from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()

class Q(BaseModel):
  query: str

@app.post("/ask")
def api_ask(q: Q):
  answer, sources = ask(q.query)
  return {"answer": answer, "sources": sources}

# Çalıştır: uvicorn app:app --reload --port 8000

Doğrulama, kalite ve ölçüm

- Halüsinasyonları azaltmak için sıcaklığı 0.0–0.3 aralığında tutun, prompt’a “bilgiyi uydurma, bilmiyorsan söyle” ifadesini ekleyin.
- Geri getirilen parça sayısını (k) 3–8 arası deneyin; çok yüksek k, gürültü katar.
- Parça boyutu (chunk size) 500–1000 arası genelde iyi sonuç verir, 10–15% örtüşme koruyun.
- Yeniden sıralama: Sentence-Transformers ile cross-encoder/ms-marco-MiniLM-L-6-v2 gibi bir re-ranker, isabeti belirgin artırabilir.
- Değerlendirme: Küçük bir altın soru-cevap seti hazırlayın; doğru kaynağa referans verilip verilmediğini ölçün.

Performans ve maliyet ipuçları

- Kantizasyon: Ollama’da llama3.1:8b-instruct-q4_K_M gibi kantize varyantlar RAM tüketimini düşürür.
- Önbellek: Sorgu → bağlam → cevap üçlüsünü dosya veya Redis ile önbelleğe alın. Yinelenen sorularda gecikme dramatik düşer.
- GPU: Metal (macOS) veya CUDA (Linux/Windows) desteği varsa model çıkarımı hızlanır.
- İndeks: ChromaDB’de kalıcı depolama (PersistentClient) ile büyük koleksiyonlarda yeniden başlatma maliyeti azalır.

Güvenlik ve uyumluluk

Yerel RAG’in en büyük artısı veri egemenliği. Yine de şu tedbirleri alın: hassas alanları maskeyle; kaynak metaverileri log’layın; modeli “yanlış kullanım” prompt’larına karşı kıstırın; uç noktalara (FastAPI) kimlik doğrulama ekleyin; yedekleri şifreleyin.

Hata ayıklama ve sık görülen problemler

- Bağlantı hatası: Ollama servisinin 11434 portunda çalıştığını doğrulayın (curl localhost:11434).
- Out-of-memory: Daha küçük/quantize model çekin; eşzamanlı istekleri düşürün.
- Alakasız sonuçlar: Farklı embedding modeli deneyin; chunk’ları daha iyi bölün; re-ranker ekleyin.
- Dil karışması: Prompt’u Türkçe olarak sabitleyin ve cevabı Türkçe isteyin.

Sonuç

Bu rehberle, Ollama ve ChromaDB kullanarak tamamen yerelde çalışan, ölçeklenebilir ve gizlilik dostu bir RAG sistemi kurdunuz. Temeller oturduktan sonra re-ranking, çoklu koleksiyon, rol tabanlı erişim ve kullanım analitiği gibi katmanları ekleyerek üretim kalitesine taşıyabilirsiniz. Küçük bir dizüstü bilgisayarda bile tatmin edici yanıtlar alınabildiğini görmek, RAG’in 2025’te neden “uygulamaya dönük yapay zekânın” omurgası olduğunu net biçimde gösteriyor.

8 Eylül 2025 Pazartesi

Dizüstünüzde Yerel Yapay Zeka: Ollama ile LLM Çalıştırma ve API Entegrasyonu (Güncel Rehber)

Giriş

Yerel olarak çalışan büyük dil modelleri (LLM), gizlilik, gecikme süresi ve maliyet açısından bulut tabanlı çözümlere güçlü bir alternatif sunuyor. Özellikle geliştiriciler, veri güvenliği kritik olan kurumlar ve offline çalışması gereken uygulamalar için yerel LLM’ler ciddi avantaj sağlıyor. Bu rehberde, açık kaynak odaklı Ollama ile Windows, macOS ve Linux üzerinde LLM çalıştırmayı, ilk model indirme ve etkileşim, API entegrasyonu ve performans ipuçlarını adım adım anlatıyorum.

Neden Yerel LLM?

Gizlilik ve kontrol: Veriniz makinenizden çıkmaz. Hassas dokümanlar, müşteri bilgileri veya fikri mülkiyet içerikleri buluta gönderilmeden işlenir.

Düşük gecikme: İnternet bağlantısı ve servis yoğunluğundan bağımsız, tutarlı yanıt süreleri elde edilir.

Maliyet: Deney, prototip ve düşük trafikli senaryolarda API maliyetleri olmadan ilerleme şansı sağlar.

Özelleştirme: Modeli ve çalışma parametrelerini dilediğiniz gibi ayarlayabilir, hatta kendi verilerinizle yerelde ince ayar (LoRA) yapabilirsiniz.

Önkoşullar ve Donanım Notları

- RAM: 8 GB minimum; 16 GB ve üzeri rahat bir deneyim sunar. Büyük bağlam pencereleri (context) için daha fazla RAM yararlıdır.

- GPU/VRAM: GPU hızlandırma şart değil, ancak 6–8 GB VRAM orta boy modellerde belirgin hız kazandırır. Apple Silicon (M1/M2/M3) cihazlarda Metal hızlandırma iyi sonuç verir.

- Disk: Modellerin boyutu kuantizasyona göre değişir. 4–10 GB arası tek bir model için tipik bir aralıktır; birden fazla model planlıyorsanız boş alanı buna göre düşünün.

Ollama Kurulumu

macOS: Homebrew kullanıyorsanız brew install ollama komutuyla kurulum yapabilirsiniz. Alternatif olarak resmi sitedeki yönergeleri izleyebilirsiniz.

Windows: Resmi yükleyiciyi indirip çalıştırın. Kurulumdan sonra Ollama hizmeti arka planda çalışmaya başlar.

Linux: Dağıtımınıza uygun olarak resmi kurulum komutunu kullanın. Tipik kurulum için: curl -fsSL https://ollama.com/install.sh | sh. Ardından servisi başlatın: ollama serve.

İlk Modeli Çalıştırma

Ollama, “komut ver, model çekilsin ve çalışsın” deneyimi sunar. Örneğin:

ollama run mistral

Komut, ilgili modeli indirir ve etkileşimli bir kabuk açar. Alternatif olarak bir başka popüler seçenek:

ollama run llama3

İlk mesajınızı yazıp Enter’a basmanız yeterli. Çıkmak için /bye kullanabilirsiniz.

Model Yönetimi ve Faydalı Komutlar

ollama list — İndirilen modelleri ve boyutlarını listeler.

ollama pull MODEL_ADI — Modeli önceden indirir (ör. ollama pull llama3).

ollama show MODEL_ADI — Parametreler ve etiketler hakkında bilgi verir.

ollama rm MODEL_ADI — İlgili modeli diskten kaldırır.

API ile Entegrasyon

Ollama yerelde bir HTTP API sunar. Varsayılan uç nokta: http://localhost:11434. Basit bir üretim (generate) çağrısı için:

curl http://localhost:11434/api/generate -d '{ "model": "mistral", "prompt": "Merhaba! Bugün hava nasıl?" }'

Streaming yanıt almak için istemcinizde chunk’ları işleyebilir veya HTTP/2 ile daha pürüzsüz bir akış sağlayabilirsiniz. Çoğu dilde basit bir fetch/requests ile entegrasyon dakikalar içinde tamamlanır. Parametreler (ör. temperature, top_p, num_ctx) aynı JSON içinde belirtilebilir.

Performans İpuçları

Kuantizasyon seçimi: Küçük disk izi ve hızlı ilk token için Q4 serisi (ör. q4_k_m) iyi bir başlangıçtır; kalite gerekirse Q5/Q6 düşünebilirsiniz. Ollama çoğu model için mantıklı bir varsayılan indirir.

Bağlam penceresi (num_ctx): Daha büyük bağlam, daha çok RAM/VRAM kullanır. İhtiyacınıza göre 4K–16K aralığında deneyin.

GPU kullanımı: Uygunsa GPU hızlandırmayı etkinleştirin. NVIDIA için sürücü/CUDA tarafı düzenli; Apple Silicon’da Metal otomatikleşmiştir. Çalışma anında performans farkını kolayca hissedersiniz.

İlk token süresi: Soğuk başlangıçta üst seviye modeller birkaç saniye geç yanıt verebilir. Sık kullanılan modelleri “sıcak” tutmak için servis açık kalsın.

Kaliteyi Artırma: İpuçları ve Prompt Tasarımı

Sistem talimatı: Yanıtı kısıtlamayan, görev odaklı net bir sistem mesajı üretim kalitesini yükseltir.

Yapılandırılmış çıktı: JSON şema, maddeler veya adım adım çözüm isteyin. Örneğin: “Lütfen JSON döndür: {title, summary, keywords}”.

Kısa bağlamlar: Gereksiz detayları azaltıp örnek odaklı içerik verin; yerel modellerde bağlam ekonomisi fark yaratır.

Güvenlik ve Kurumsal Kullanım

Yerelde çalışma, veri sızıntısı riskini doğal olarak azaltır. Yine de uygulama düzeyinde giriş/çıkış filtreleri, PII maskeleme ve log politikasını konumlandırın. Paylaşılan iş istasyonlarında model dizinlerinin erişim izinlerini düzenlemek iyi bir fikirdir.

Sorun Giderme

Model indirme yavaş: Ayna (mirror) seçeneklerini kullanın ya da indirmeyi önceden planlayın. Ağ kesintilerinde indirme tekrar başlatılabilir.

Yüksek bellek kullanımı: Daha agresif kuantizasyon seçin, num_ctx değerini düşürün veya daha küçük bir model deneyin.

Yanıt kalitesi yetersiz: Talimatı netleştirin, örnek verin, gerekirse farklı bir model ailesi (mistral, llama, phi, qwen) deneyin.

Sonuç

Ollama, yerel LLM çalıştırmayı basit bir komutla mümkün kılıyor. Geliştirici bilgisayarında hızlı prototip, kurum içinde gizli veriyle güvenli deneme veya offline asistan gibi senaryolarda verimli bir temel sunuyor. Kurulumu tamamlayıp ilk modeli koşturduktan sonra, API üzerinden uygulamanıza entegre etmek yalnızca birkaç satır kod. Doğru kuantizasyon ve bağlam ayarıyla, oldukça akıcı ve ekonomik bir yapay zeka deneyimi elde edebilirsiniz.

5 Eylül 2025 Cuma

Ollama ile Yerelde LLM Çalıştırma Rehberi: Kurulum, GPU Hızlandırma ve İpuçları

Giriş: Neden Yerelde LLM Çalıştırmalı?

Bulut maliyetlerinin arttığı, veri gizliliğinin ise daha kritik hale geldiği bir dönemde, büyük dil modellerini (LLM) yerel makinenizde çalıştırmak hem hızlı deney imkânı hem de verilerinizi cihazınızdan dışarı çıkarmadan çalışma rahatlığı sağlar. Ollama, GGUF formatındaki modern modelleri tek komutla indirip kullanmanıza olanak veren hafif ve kullanımı kolay bir araçtır. Bu rehberde Windows, macOS ve Linux üzerinde Ollama kurulumunu, GPU hızlandırmasını, performans ayarlarını ve uygulamanıza entegre etmenin pratik yollarını anlatıyorum.

Ön Koşullar ve Donanım Gereksinimleri

LLM’leri yerelde çalıştırırken CPU, RAM ve özellikle GPU VRAM kapasitesi önemlidir. 7B parametreli, 4-bit sıkıştırılmış (quantized) bir model için genellikle 6–8 GB VRAM ve en az 8–16 GB sistem RAM tavsiye edilir. 13B için 12 GB ve üzeri VRAM ideal; 70B gibi devasa modeller ise çoğunlukla masaüstü sınıfını aşar. Yine de Ollama, VRAM yetersizse katmanların bir kısmını CPU’ya taşıyabilir; bu durumda yanıt süresi uzar.

Kurulum: Windows, macOS ve Linux

- Windows: En kolay yol resmi yükleyici veya winget ile kurulumdur. Komut satırına winget install Ollama.Ollama yazın. Kurulum bittiğinde ollama komutuna erişebiliyor olmalısınız.

- macOS: Homebrew kullanıyorsanız brew install ollama yeterlidir. Apple Silicon (M1/M2/M3) üzerinde Metal hızlandırma ile iyi performans alırsınız.

- Linux: Resmi sitedeki script ile kurabilirsiniz: curl -fsSL https://ollama.com/install.sh | sh. Ardından servis otomatik başlatılır ve http://localhost:11434’te API hazır olur.

Model İndirme ve İlk Çalıştırma

Ollama, modelleri depodan çekmek için pull, etkileşimli çalıştırmak için run komutlarını kullanır. Örneğin 8B boyutlu bir Llama 3 varyantını denemek için: ollama pull llama3:8b ve ardından ollama run llama3:8b. İlk indirme birkaç dakika sürebilir. Türkçe için Llama 3 ailesi, Mistral veya Gemma tabanlı GGUF modelleri de tercih edilebilir. Komut satırında sistem yönergeleri (system prompt) verebilir, çıktıyı kısaltmak için Ctrl+C ile durdurabilirsiniz.

GPU Hızlandırma ve İnce Ayar

Uygun sürücüler yüklüyse Ollama GPU’yu otomatik kullanır: Windows/NVIDIA için CUDA, macOS için Metal, Linux/AMD için ROCm desteğiyle çalışır. Performans düşükse modelin kuantizasyon varyantını değiştirin. Örneğin Q4_K_M daha az VRAM kullanır, Q6_K veya Q8_0 kaliteyi artırır ama daha fazla bellek ister. Bazı durumlarda GPU kullanımını sınırlamak için model seçeneklerinde gpu_layers değerini düşürmek yararlı olabilir.

Akıcı diyaloglar için bağlam penceresini artırabilirsiniz. Örnek seçenekler: num_ctx (bağlam uzunluğu), temperature, top_p ve repeat_penalty. Uzun dökümanlarla çalışırken num_ctx’i yükseltmek gerekir; ancak bu bellek kullanımını artırır. Sık tekrarlanan ifadeleri azaltmak için repeat_penalty değerini 1.1–1.2 aralığında deneyebilirsiniz.

API ile Entegrasyon: cURL ve Python

Ollama, varsayılan olarak http://localhost:11434 adresinde REST API sunar. Basit bir metin üretimi için cURL ile örnek istek:

curl -X POST http://localhost:11434/api/generate -d '{ "model": "llama3:8b", "prompt": "Türkçe olarak üç maddede kuantizasyonu açıkla.", "options": { "num_ctx": 4096, "temperature": 0.7 } }'

Python tarafında requests ile akışlı (stream) yanıtlar alabilirsiniz. İstek gövdesine stream: true eklerseniz kelime kelime akan sonuçları terminale yazdırabilirsiniz. Bu sayede sohbet uygulaması kurmak veya web arayüzünde canlı çıktı göstermek kolaylaşır.

Performans İpuçları ve Model Seçimi

- Doğru boyut: 7B–8B modeller, dizüstüler için tatlı noktadır. 13B daha kaliteli yanıtlar verse de masaüstü GPU’ları gerektirebilir.

- Kuantizasyon: Q4 aileleri hızlı ve hafif; Q5–Q8 kaliteyi artırır. Uygulama senaryonuza göre dengeyi bulun.

- Önbellek: Model, bağlam önbelleğini (KV cache) kullanır. Aynı yönergelerle tekrar çalışırken hızlanma görürsünüz. Uzun oturumlarda bağlam yönetimi (önemli kısımları sabitleme) fayda sağlar.

- Türkçe doğruluğu: Modelden Türkçe üretim istemek için yönergenizi açık yazın (örn. “Lütfen Türkçe yanıtla”). Gerekirse sistem mesajına yazım kurallarına uyma ve kısa/uzun yanıt tercihlerinizi ekleyin.

Gizlilik, Ağ Erişimi ve Güvenlik

Varsayılan yapılandırmada API sadece yerel cihaza (localhost) açıktır. Uzaktan erişime açmak istiyorsanız güçlü bir parola/kapsayıcı ağ politikası, ters proxy ve gerekiyorsa VPN kullanın. Yerelde çalıştığınız için metinleriniz buluta gitmez; yine de günlükleri ve uygulama kayıtlarını şirket politikalarına uygun konumlarda saklayın.

Sorun Giderme

- Model yüklenmiyor: Disk alanını ve indirme bütünlüğünü kontrol edin. Gerekirse ollama rm ile modeli silip tekrar indirin.

- VRAM hataları: Daha düşük bir kuantizasyon seçin (Q4), gpu_layers’ı azaltın veya bağlam penceresini küçültün. Ollama çoğu durumda otomatik olarak CPU’ya düşer, ancak bu performansı etkiler.

- Windows’ta sürücü: NVIDIA sürücülerinin güncel olduğundan emin olun. Performans sorunları genellikle eksik ya da eski sürücülerden kaynaklanır.

- Çakışan port: 11434 portunu kullanan başka bir servis varsa kapatın veya Ollama’yı farklı bir portta başlatın.

Sonuç

Ollama, yerelde LLM çalıştırmayı birkaç komuta indirgeyerek hızlı prototipleme ve gizlilik odaklı üretim senaryolarını mümkün kılıyor. Doğru model boyutu ve kuantizasyon seçimiyle dizüstü bilgisayarda dahi tatmin edici Türkçe sonuçlar alabilirsiniz. GPU hızlandırması, bağlam ayarları ve API entegrasyonu ile dakikalar içinde chatbot, özetleyici veya kod asistanı geliştirmek elinizde. Küçük adımlarla başlayın, ölçümleyin ve kullanım amacınıza en uygun yapılandırmayı kademeli olarak bulun.