Docker ile Lokal Yapay Zekâ Modeli Çalıştırma: Ollama Kurulumu ve Open WebUI ile Web Arayüzü

Giriş: Bulutta Değil, Kendi Bilgisayarında Yapay Zekâ

Yapay zekâ modellerini denemek için çoğu kişi web servislerine yöneliyor. Ancak hem gizlilik hem de maliyet açısından, modeli kendi bilgisayarında çalıştırmak ciddi avantaj sağlayabiliyor. Bu rehberde güncel ve pratik bir yaklaşımı ele alacağım: Ollama ile yerel (local) LLM çalıştırmak ve bunu Docker üzerinden Open WebUI ile şık bir web arayüzüne bağlamak. Sonuçta tarayıcıdan sohbet edebileceğiniz, API erişimi sunan ve tamamen sizin kontrolünüzde bir kurulum elde edeceksiniz.

Ön Gereksinimler

Kuruluma başlamadan önce şunlara ihtiyacınız var: Docker (Docker Desktop ya da Linux üzerinde Docker Engine), temel terminal kullanımı, en az 8 GB RAM (tercihen 16 GB ve üzeri) ve yeterli disk alanı. Modeller boyuta göre 2–10+ GB arası yer kaplayabiliyor. GPU şart değil; CPU ile de çalışır ama performans beklentinizi buna göre ayarlamanız gerekir.

Adım 1: Ollama Kurulumu (Host Üzerinde)

Ollama, popüler açık kaynak modelleri yerel ortamda kolayca indirip çalıştırmanızı sağlayan bir araç. Windows ve macOS için yükleyicisi var; Linux tarafında ise resmi kurulum komutu ile hızlıca kurulabiliyor. Kurulumdan sonra Ollama varsayılan olarak 11434 portunda bir servis gibi çalışır ve API sağlar.

Kurulumun doğru yapıldığını test etmek için terminalden bir model çalıştırabilirsiniz. Örneğin: ollama run llama3.1. İlk çalıştırmada model indirileceği için bekleme süresi internet hızınıza bağlı olarak değişir. İndirme tamamlandığında komut satırında doğrudan sohbet edebildiğinizi görürsünüz.

Adım 2: Docker ile Open WebUI Kurulumu

Komut satırından sohbet etmek iş görse de çoğu kullanıcı için tarayıcı tabanlı bir arayüz daha konforlu. Open WebUI bu noktada devreye giriyor: modern bir arayüz, sohbet geçmişi ve model seçimi gibi özellikleri tek yerde topluyor. Open WebUI’yi Docker ile çalıştırmak hem güncellemeyi kolaylaştırır hem de sisteminizi “temiz” tutar.

Aşağıdaki örnek komut, Open WebUI konteynerini ayağa kaldırır. Buradaki kritik nokta, Open WebUI’nin Ollama API’sine erişebilmesi. Eğer Ollama host üzerinde çalışıyorsa, Docker konteynerinden host’a erişim yöntemi işletim sistemine göre değişebilir. Docker Desktop (Windows/macOS) için genellikle host.docker.internal kullanılabilir.

Örnek Docker komutu:
docker run -d --name open-webui -p 3000:8080 -e OLLAMA_BASE_URL=http://host.docker.internal:11434 -v open-webui:/app/backend/data --restart unless-stopped ghcr.io/open-webui/open-webui:main

Adım 3: Linux Kullanıcıları İçin Host Erişimi

Linux’ta host.docker.internal her zaman otomatik gelmeyebilir. Bu durumda iki pratik seçenek var: (1) Ollama’yı da Docker içinde çalıştırmak, (2) konteynerin host ağına erişimini ayarlamak. En basit yaklaşım çoğu senaryoda Ollama’yı da Docker’a almak olur; fakat rehberin amacında “host üzerinde Ollama + Docker’da arayüz” olduğu için, Linux’ta genellikle host IP’sini ya da ağ yapılandırmasını kullanmak gerekir. Örneğin host’un yerel IP’si 192.168.1.10 ise OLLAMA_BASE_URL değeri http://192.168.1.10:11434 olabilir.

Diğer bir yöntem, bazı Docker sürümlerinde ekstra parametreyle host ismini çözümletmektir. Ancak ağ yapılandırmaları sistemden sisteme değiştiği için, en stabil yöntem çoğu kullanıcı için host IP’sini kullanmaktır.

Adım 4: Open WebUI Üzerinden Model Yönetimi

Konteyner çalıştıktan sonra tarayıcıdan http://localhost:3000 adresine gidin. İlk açılışta bir kullanıcı oluşturmanız istenir. Ardından ayarlarda Ollama bağlantısını doğrulayabilir, indirdiğiniz modelleri listede görebilirsiniz. Eğer listede model görünmüyorsa genellikle iki sebep olur: OLLAMA_BASE_URL yanlış girilmiştir ya da Ollama servisi çalışmıyordur.

Model seçerken donanımınıza uygun boyutta kalmak önemli. Daha küçük modeller (ör. 7B civarı) günlük kullanımda daha akıcı yanıt verir. Daha büyük modeller daha iyi muhakeme sağlayabilir ama RAM ve işlemciye yük bindirir. Open WebUI, aynı anda birden fazla sohbet oturumu açmanıza da izin verir; bu da farklı “denemeleri” yan yana götürmek için kullanışlıdır.

Performans ve Güvenlik İpuçları

Yerel yapay zekâ kurulumunda performansı etkileyen en büyük faktör, modelin boyutu ve sistem kaynaklarıdır. Arka planda gereksiz uygulamaları kapatmak, modeli ilk kez çalıştırdıktan sonra sistemin “ısınmasına” izin vermek ve mümkünse SSD üzerinde çalışmak hız kazandırır. Ayrıca bu kurulumun güzel tarafı, verilerinizin dışarı çıkmamasıdır; ancak yine de Open WebUI’yi internetten erişilebilir hale getirecekseniz güçlü parola, ters proxy ve HTTPS gibi temel önlemleri almalısınız.

Son olarak, Docker ile çalıştığınız için güncelleme oldukça basit: yeni imajı çekip konteyneri yeniden oluşturabilirsiniz. Veri kaybı yaşamamak için volume kullanımını (örnekte open-webui:/app/backend/data) ihmal etmeyin.

Sonuç

Ollama + Open WebUI ikilisi, yerel yapay zekâ deneyimini “kur, çalıştır ve yönet” seviyesine taşıyor. Bulut maliyetlerine girmeden, API ve web arayüzü rahatlığını aynı anda elde etmek mümkün. Eğer geliştirme yapıyorsanız, Ollama’nın sunduğu yerel API ile uygulamalarınıza hızlıca entegrasyon da ekleyebilirsiniz. Kendi bilgisayarınızda, kendi kurallarınızla çalışan bir LLM kurulumu için bu yaklaşım güncel ve oldukça pratik bir seçenek.

Docker ile Yerel LLM Çalıştırma: Ollama Kurulumu, Model Yönetimi ve API ile Entegrasyon

Yerelde yapay zekâ neden bu kadar popüler oldu?

Bulut tabanlı yapay zekâ servisleri hızlı ve pratik; ancak maliyet, gecikme, veri gizliliği ve entegrasyon esnekliği gibi başlıklarda her zaman ideal değiller. Özellikle hassas verilerle çalışan ekipler için yerelde (lokalde) çalışan büyük dil modelleri (LLM) ciddi bir avantaj sağlıyor. Son dönemde bu ihtiyacı en pratik şekilde karşılayan araçlardan biri de Ollama. Bu yazıda, Ollama’yı Docker ile kurup yerelde model çalıştırmayı, model yönetimini ve basit bir API kullanımını adım adım ele alıyorum.

Ollama nedir, ne işimize yarar?

Ollama, LLM’leri bilgisayarınızda çalıştırmayı kolaylaştıran bir çalışma zamanı ve model yönetim katmanı gibi düşünebilirsiniz. “Modeli indir, çalıştır, API üzerinden çağır” akışını sadeleştirir. Birçok model ailesini desteklemesi ve komut satırı üzerinden hızlı bir deneyim sunması sayesinde geliştiriciler arasında hızla yayıldı. Ayrıca yerel bir HTTP API sunduğu için, kendi uygulamanızdan bu modeli sanki bir servis gibi tüketebilirsiniz.

Kurulum ön koşulları

Bu rehberde Docker tabanlı bir kurulum anlatacağım. İhtiyacınız olanlar: Docker (ve mümkünse Docker Compose), yeterli disk alanı (model boyutuna göre 5–20 GB+), ve tercihen güçlü bir CPU/GPU. GPU hızlandırma her sistemde aynı kolaylıkta olmasa da, CPU ile de temel denemeler yapılabilir. Komutlar Linux/macOS için uygundur; Windows’ta WSL2 ile benzer şekilde ilerleyebilirsiniz.

Docker ile Ollama’yı çalıştırma

Önce kalıcı bir veri dizini kullanmak iyi bir fikirdir; çünkü modeller indirildiğinde container silinse bile tekrar indirmek zorunda kalmazsınız. Aşağıdaki komut, Ollama’yı arka planda ayağa kaldırır ve varsayılan API portunu (11434) dışarı açar:

Komut:

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

Bu noktada servis çalışır durumdadır. Kontrol etmek için:

docker logs -f ollama

İlk modelinizi indirme ve çalıştırma

Ollama, model yönetimini komut satırından çok kolaylaştırır. Container içine girip bir model çekebilir veya doğrudan “exec” ile komut çalıştırabilirsiniz. Örneğin küçük ve hızlı bir modelle başlamak mantıklıdır. Aşağıdaki örnekte bir modeli indirip interaktif şekilde çalıştırıyoruz:

docker exec -it ollama ollama run llama3

İlk çalıştırmada model indirileceği için biraz bekleyebilirsiniz. İndirme bittiğinde sohbet ekranı açılır; Türkçe istem (prompt) verip yanıt alabilirsiniz. Daha iyi yanıtlar için isteminizi net tutun: amaç, bağlam, çıktı formatı gibi detayları belirtin.

Model yönetimi: listeleme, silme, güncelleme

Disk alanı yerel LLM dünyasında hızlı tükenir. Bu yüzden indirilen modelleri düzenli yönetmek önemli. Yüklü modelleri listelemek için:

docker exec -it ollama ollama list

Kullanmadığınız bir modeli silmek için:

docker exec -it ollama ollama rm llama3

Modeli tekrar çekmek/güncellemek için aynı “run” komutu ya da ilgili pull akışı kullanılabilir. Ayrıca aynı modelin farklı varyantları (ör. boyut, quantization) performans ve kaliteyi ciddi etkiler. Daha küçük quantization daha hızlıdır ama doğruluk ve akıcılık düşebilir. Bu dengeyi kendi kullanım senaryonuza göre test ederek bulmanız gerekir.

HTTP API ile entegrasyon: uygulamaya bağlamak

Ollama’nın en büyük artılarından biri, yerelde bir servis gibi davranmasıdır. Böylece herhangi bir dille HTTP isteği atarak yanıt alabilirsiniz. Basit bir “prompt gönder, yanıt al” testi için terminalde şu isteği deneyin:

curl http://localhost:11434/api/generate -d '{ "model": "llama3", "prompt": "Bana 5 maddede SEO uyumlu blog yazısı ipucu ver.", "stream": false }'

Yanıtta genellikle modelin ürettiği metin ve bazı ek alanlar döner. Uygulama tarafında JSON parse edip “response” benzeri alanı kullanıcıya gösterebilirsiniz. stream seçeneğini açtığınızda token token akış alarak daha hızlı bir kullanıcı deneyimi sağlayabilirsiniz.

Performans ipuçları ve güvenlik notları

Yerel LLM çalıştırırken performans iki şeye bakar: donanım ve model seçimi. Eğer yalnızca metin özetleme, e-posta taslağı, basit kod yardımı gibi işler yapacaksanız daha küçük modeller yeterli olabilir. Daha karmaşık muhakeme ve uzun bağlam ihtiyaçlarında ise daha büyük modeller gerekebilir; bu da RAM/VRAM ve disk tüketimini artırır. Ayrıca Ollama’yı yalnızca kendi makinenizde kullanacaksanız portu dış dünyaya açmamak iyi bir güvenlik alışkanlığıdır. Sunucuda kullanıyorsanız, ters proxy ve erişim kontrolü (ör. yalnızca VPN içinden erişim) planlayın.

Sonuç: Yerelde LLM denemek artık zor değil

Docker ile Ollama kurulumunu yaptıktan sonra model indirmek, çalıştırmak ve API üzerinden uygulamaya bağlamak oldukça akıcı bir süreç. Bu yaklaşım; kişisel projeler, kurum içi araçlar, gizlilik odaklı metin işleme senaryoları ve düşük gecikme isteyen otomasyonlar için iyi bir seçenek. Bir sonraki adım olarak farklı model varyantlarını test edebilir, istem mühendisliğiyle çıktıları standardize edebilir ve kendi uygulamanızda bir “yerel yapay zekâ asistanı” deneyimi oluşturabilirsiniz.

Docker ile Yerel LLM Çalıştırma: Ollama + Open WebUI Kurulumu ve İnce Ayarları

Yerelde Yapay Zekâ: Neden Ollama?

Bulut tabanlı yapay zekâ servisleri pratik olsa da her proje için ideal değil. Gizlilik, maliyet, gecikme ve internet bağımlılığı gibi konular devreye girdiğinde yerel (local) LLM çalıştırmak çok daha mantıklı hale geliyor. Bu yazıda, güncel ve popüler bir yöntemle Ollama üzerinden bir dil modelini yerelde çalıştırmayı, ardından da Open WebUI ile web arayüzü ekleyerek kullanımı “ChatGPT benzeri” bir seviyeye taşımayı adım adım anlatacağım. Kurulumun odağı Docker olacak; böylece sisteminizi kirletmeden, taşınabilir bir kurulum elde edeceksiniz.

Gereksinimler ve Kısa Hazırlık

Bu rehber, Windows 11 + WSL2, macOS veya Linux üzerinde uygulanabilir. Docker yaklaşımı sayesinde dağıtım farklılıkları minimuma iner. İhtiyacınız olanlar: Docker (Docker Desktop veya Engine), en az 8 GB RAM (14B ve üzeri modellerde 16–32 GB daha rahat), yeterli disk alanı (model boyutuna göre 5–20 GB arası) ve tercihen modern bir CPU. NVIDIA GPU’nuz varsa hız artışı mümkün, ancak bu yazı CPU odaklı ve genel bir kurulum sunuyor.

1) Docker ile Ollama Kurulumu

Önce Ollama’yı bir konteyner olarak ayağa kaldıralım. Aşağıdaki komut, Ollama servisini 11434 portunda yayınlar ve model verisini kalıcı tutmak için volume kullanır:

Komut:

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

Kurulum tamamlandıktan sonra çalıştığını doğrulamak için:

docker logs -f ollama

Log akışı sorunsuzsa bir sonraki adım modele karar vermek. Ollama’nın güçlü yanı, modeli tek satır komutla indirip çalıştırabilmesi. Örneğin hafif ve hızlı bir başlangıç için:

docker exec -it ollama ollama run llama3.1

Bu komut, model yoksa indirir ve ardından etkileşimli sohbet başlatır. İndirme süresi internet hızınıza ve model boyutuna bağlıdır.

2) Open WebUI ile Web Arayüzü Eklemek

Terminalde konuşmak tamam, ama günlük kullanımda web arayüzü büyük rahatlık. Open WebUI, Ollama ile çok iyi çalışan modern bir arayüz sunuyor. Aynı makinede çalışacak şekilde şu komutu kullanabilirsiniz:

docker run -d --name open-webui -p 3000:8080 -e OLLAMA_BASE_URL=http://host.docker.internal:11434 -v open-webui:/app/backend/data ghcr.io/open-webui/open-webui:main

Linux üzerinde host.docker.internal her zaman hazır gelmeyebilir. Böyle bir durumda iki pratik seçenek var: (1) Ollama ve Open WebUI’yi aynı Docker ağına almak, (2) Ollama’yı doğrudan makinenin IP’si üzerinden çağırmak. En temiz yöntem, iki servisi aynı ağda koşturmaktır. Örneğin:

docker network create llm-net

docker network connect llm-net ollama

docker rm -f open-webui

docker run -d --name open-webui --network llm-net -p 3000:8080 -e OLLAMA_BASE_URL=http://ollama:11434 -v open-webui:/app/backend/data ghcr.io/open-webui/open-webui:main

Ardından tarayıcıdan http://localhost:3000 adresine giderek arayüzü açın. İlk girişte kullanıcı oluşturmanız istenir. Sonrasında “Models” bölümünden Ollama’da hazır olan modeli seçerek sohbet edebilirsiniz.

3) Performans ve Kalite İçin İnce Ayarlar

Yerel LLM deneyimini iyi yapan şey sadece kurulum değil; doğru model ve doğru ayarlar. Öncelikle model seçimi: Hafif kullanım için 7B–8B sınıfı modeller, kod üretimi için “code” odaklı varyantlar, daha yüksek kalite için 14B ve üzeri tercih edilebilir. RAM sınırlıysa daha küçük modelle başlayın; aksi halde sistem “swap” kullanmaya başlar ve hız dramatik biçimde düşer.

İkinci kritik konu: context (bağlam) uzunluğu. Daha uzun bağlam daha iyi “hatırlama” sağlar, fakat RAM tüketimini artırır. Open WebUI tarafında model ayarlarından bağlam ve üretim parametrelerini (örneğin temperature) dengeli seçmek önemli. Örneğin teknik dokümantasyon, özetleme gibi işlerde daha düşük temperature daha tutarlı sonuç verir.

Üçüncü konu: veri kalıcılığı. Burada hem Ollama hem Open WebUI için volume kullandığımızdan, konteyneri silseniz bile modeller ve sohbet geçmişi (kurulumunuza bağlı olarak) korunur. Bu, Blogger okurları için pratik bir detay: “kur-düşür-kur” senaryolarında zaman kaybetmezsiniz.

4) Basit Bir Sorun Giderme Listesi

Port çakışması: 11434 veya 3000 doluysa, komutlarda host portunu değiştirin (ör. 3001:8080). Model inmiyor: Docker’ın internet erişimini ve disk alanını kontrol edin. Open WebUI model görmüyor: OLLAMA_BASE_URL değerinin doğru olduğundan emin olun; aynı ağdaysa “http://ollama:11434” kullanın. Performans düşük: Daha küçük modele geçin, bağlam uzunluğunu azaltın veya arka planda ağır uygulamaları kapatın.

Sonuç: Yerel LLM ile Kontrol Sizde

Ollama + Open WebUI kombinasyonu, yerelde LLM çalıştırmayı şaşırtıcı derecede erişilebilir hale getiriyor. Docker ile kurulum hem temiz hem de taşınabilir; üstelik gizlilik ve maliyet avantajları da cabası. İster kişisel notlarınızı özetlemek, ister kod fikirleri almak, ister kapalı ağda çalışan bir asistan kurmak isteyin, bu yapı sağlam bir temel sunuyor. Bir sonraki adım olarak farklı modelleri deneyip, Open WebUI’de sistem yönergeleri (system prompt) ve şablonlarla kendi kullanım senaryonuza göre ince ayar yapabilirsiniz.

Docker Compose ile Yerel LLM (Ollama) Kurulumu ve Open WebUI Üzerinden ChatGPT Benzeri Arayüz

Yerelde LLM Çalıştırmak Neden Gündemde?

Bulut tabanlı yapay zekâ servisleri pratik olsa da, veri gizliliği, maliyet ve gecikme (latency) gibi konular birçok kişiyi yerel (local) çözümlere yönlendiriyor. Son dönemde öne çıkan yaklaşımlardan biri, LLM modellerini bilgisayarında veya ev sunucunda çalıştırıp, web arayüzü üzerinden sohbet edebilmek. Bu yazıda, Ollama ile yerel model çalıştırmayı ve Open WebUI ile tarayıcıdan kullanmayı Docker Compose üzerinden adım adım kuracağız. Hedefimiz: birkaç komutla, sürdürülebilir ve güncellenebilir bir kurulum yapmak.

Ön Koşullar ve Sistem Notları

Kurulum Linux tabanlı bir sistemde (Ubuntu/Debian gibi) en sorunsuz şekilde ilerler. macOS ve Windows üzerinde de Docker ile yapılabilir; ancak GPU kullanımı (özellikle NVIDIA) için Linux tarafı daha stabil. Minimumda 8 GB RAM ile küçük modeller çalıştırılabilir; 16 GB ve üzeri daha rahat olur. GPU’nuz varsa performans belirgin şekilde artar. Gerekenler: Docker, Docker Compose ve internete erişim (modeli ilk kez indirirken).

Mimari: Ollama + Open WebUI Nasıl Çalışır?

Ollama, LLM modellerini indirip yerelde servis eden bir katman gibi düşünülebilir. Siz “modeli indir, çalıştır” dersiniz; o da arka tarafta bir API üzerinden yanıt üretir. Open WebUI ise bu API’ye bağlanan modern bir web arayüzüdür. Böylece tarayıcıdan sohbet edebilir, model seçebilir, geçmiş konuşmaları saklayabilir ve temel ayarları yönetebilirsiniz. İkisini Docker Compose ile yönetmek, güncelleme ve taşınabilirlik açısından büyük kolaylık sağlar.

Adım 1: Docker Compose Dosyasını Oluşturma

Önce bir klasör açın ve içine docker-compose.yml dosyası oluşturun. Örnek içerik aşağıdaki gibi olabilir. Bu yapı iki servisi çalıştırır: Ollama ve Open WebUI. Open WebUI, Ollama’nın API’sine bağlanır ve 3000 portundan yayın yapar.

docker-compose.yml:

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

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

volumes:
  ollama:
  openwebui:

Not: Bu örnek temel kurulumdur. NVIDIA GPU ile hızlandırma isterseniz Docker’ın GPU runtime ayarlarını ayrıca yapılandırmanız gerekebilir. CPU ile de çalışır; sadece daha yavaş yanıt alırsınız.

Adım 2: Servisleri Ayağa Kaldırma

Compose dosyasının bulunduğu klasörde şu komutu çalıştırın:

docker compose up -d

Ardından konteynerlerin durumunu kontrol edin:

docker ps

Her şey yolundaysa tarayıcıdan http://localhost:3000 adresine gidin. İlk açılışta Open WebUI sizden bir kullanıcı oluşturmanızı isteyebilir; bu normaldir.

Adım 3: Model İndirme ve İlk Çalıştırma

Ollama tarafında bir model indirmek için iki yol var: Open WebUI içinden model çekmek veya terminalden indirmek. Terminal üzerinden daha kontrol edilebilir olduğu için şu komutla başlayabilirsiniz:

docker exec -it ollama ollama pull llama3.1

Model adı zamanla değişebilir; Ollama’nın desteklediği güncel isimleri kontrol etmek gerekebilir. İndirme bittiğinde Open WebUI’ye dönün. Model seçimi bölümünde indirdiğiniz modeli görüp sohbet başlatabilirsiniz. İlk yanıtlar biraz yavaş gelebilir; modelin “ısınması” ve CPU/GPU durumuna göre performans değişir.

İpuçları: Performans, Depolama ve Güvenlik

Depolama: Modeller büyük yer kaplar. Compose dosyasında tanımlı volume’lar sayesinde konteyner silinse bile modelleriniz kalır. Disk alanınızı izlemek için düzenli kontrol edin.

Performans: Daha küçük bir model seçmek (ör. daha düşük parametreli sürümler) yanıt süresini ciddi biçimde iyileştirir. Ayrıca aynı anda çok uzun bağlam (context) kullanmak RAM tüketimini artırır.

Güvenlik: Kurulumu ev ağı dışına açacaksanız (port yönlendirme gibi), mutlaka ters proxy + HTTPS ve kimlik doğrulama kullanın. Varsayılan şekilde yerelde kullanmak daha güvenlidir.

Sık Karşılaşılan Sorunlar

Open WebUI model görmüyor: OLLAMA_BASE_URL değişkeninin doğru olduğundan emin olun. Compose içinde servis adı “ollama” ise URL de “http://ollama:11434” olmalı. Ayrıca konteynerlerin aynı network’te olması gerekir; Compose bunu varsayılan olarak sağlar.

Yanıtlar çok yavaş: CPU ile çalışıyorsanız bu normal olabilir. Daha küçük model deneyin, arka planda çalışan uygulamaları azaltın. GPU kurulumuna geçmek ciddi fark yaratır.

Port çakışması: 3000 veya 11434 portu başka bir uygulama tarafından kullanılıyorsa, compose dosyasında sol taraftaki portu değiştirin (ör. “3001:8080”).

Sonuç

Docker Compose ile Ollama ve Open WebUI kurmak, yerel LLM dünyasına hızlı bir giriş sunuyor. Kurulum hem taşınabilir hem de güncellemesi kolay: yeni sürümler için genellikle docker compose pull ve docker compose up -d yeterli. En önemlisi, sohbet veriniz ve model kullanımı sizin kontrolünüzde kalıyor. Eğer hedefiniz gizlilik odaklı bir “yerel yapay zekâ asistanı” ise bu ikili, güncel ve pratik bir başlangıç noktası.

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.

Ollama, LangChain ve ChromaDB ile Yerel RAG Chatbotu Kurulum Rehberi

Özet

Bu rehberde, internet bağlantısına ihtiyaç duymadan çalışan bir RAG (Retrieval-Augmented Generation) chatbotunu yerelde nasıl kurabileceğinizi adım adım anlatıyorum. Kullandığımız bileşenler: Ollama (yerel LLM çalıştırma), LangChain (zincirleme ve orkestrasyon), ChromaDB (vektör veritabanı) ve yerel gömlemeler. Amaç; PDF, teknik doküman veya notlarınızı indeksleyip, LLM modeline belgelerden alıntı yaparak daha doğru yanıtlar ürettirmek.

Neden Yerel RAG?

RAG yaklaşımı, dil modelinin yanıtlarını belgelerinizle zenginleştirerek halüsinasyonları azaltır ve güncel bilgi sağlar. İşin “yerel” tarafı ise verinin bilgisayarınızdan çıkmaması, maliyetin düşük ve sistemin offline çalışabilmesi demek. Özellikle kurumsal dokümanlar, Ar-Ge notları veya gizli veriler için bu yaklaşım idealdir.

Gereksinimler

- 16 GB RAM önerilir (8 GB ile küçük modeller çalışabilir).
- macOS, Linux veya Windows (WSL destekli).
- Python 3.10+.
- Temel terminal bilgisi.
- Bazı modellerde GPU varsa hız artar (Metal/CUDA desteği).

Adım 1: Ollama ve Modelleri Kurma

Ollama, LLM modellerini tek komutla indirip yerelde çalıştırmanızı sağlar. Sisteminizde kurulu değilse resmi talimatları izleyerek kurun. Linux için tipik kurulum şu şekildedir:

curl -fsSL https://ollama.com/install.sh | sh
# Servisi başlat (Linux)
ollama serve

Şimdi bir sohbet modeli ve bir gömleme modeli çekelim. Küçük ve hızlı bir sohbet modeli için Llama 3.1 8B iyi bir başlangıçtır. Gömlemeler için “nomic-embed-text” yaygın ve hızlıdır:

ollama pull llama3.1:8b
ollama pull nomic-embed-text

Model adlarını ihtiyacınıza göre değiştirebilirsiniz (örn. mistral veya phi-3). Büyük modeller daha iyi kalite, daha fazla RAM/GPU kullanımı demektir. İlk denemelerde 7B–8B aralığı pratik bir seçimdir.

Adım 2: Python Ortamını Hazırlama

Proje klasörünüzü oluşturup sanal ortam açın ve gerekli paketleri yükleyin. LangChain ile Ollama’nın entegrasyonu için “langchain-ollama” paketini kullanalım. Vektör veritabanı için Chroma’yı ekleyelim.

python -m venv .venv
source .venv/bin/activate  # Windows: .venv\Scripts\activate
pip install --upgrade pip
pip install langchain langchain-community langchain-ollama chromadb pydantic

Basit metin dosyalarıyla başlayacağız. PDF’ler için ekstra dönüştürücüler (örn. pypdf, unstructured) ekleyebilirsiniz.

Adım 3: Belgeleri İndeksleme ve RAG Zinciri

Aşağıdaki örnekte, “docs/” klasöründeki metin dosyalarını parçalara ayırıp Chroma’ya yükleyeceğiz. Ardından bir sorgu geldiğinde ilgili parçaları geri çağırıp modelin bağlamıyla birlikte yanıtlamasını sağlayacağız.

# rag_app.py
from langchain_community.document_loaders import DirectoryLoader, TextLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain_ollama import ChatOllama, OllamaEmbeddings
from langchain.prompts import PromptTemplate
from langchain.schema import Document

# 1) Belgeleri yükle
loader = DirectoryLoader("docs", glob="**/*.txt", loader_cls=TextLoader, show_progress=True, use_multithreading=True)
docs = loader.load()

# 2) Parçala
splitter = RecursiveCharacterTextSplitter(chunk_size=800, chunk_overlap=120)
chunks = splitter.split_documents(docs)

# 3) Gömleme ve vektör veritabanı
embeddings = OllamaEmbeddings(model="nomic-embed-text")
vectordb = Chroma.from_documents(chunks, embedding=embeddings, collection_name="yerel_rag")

# 4) Retriever ve LLM
retriever = vectordb.as_retriever(search_kwargs={"k": 4})
llm = ChatOllama(model="llama3.1:8b", temperature=0.2)

# 5) İstem şablonu
template = """Aşağıdaki bağlamı KESİNLİKLE dikkate alarak soruyu yanıtla.
Bağlam:
{context}

Soru: {question}
Cevap: """
prompt = PromptTemplate.from_template(template)

def ask(question: str):
    # İlgili parçaları getir
    rel_docs = retriever.get_relevant_documents(question)
    context = "\n\n".join([d.page_content for d in rel_docs])
    # İstemi oluştur ve yanıtı al
    final_prompt = prompt.format(context=context, question=question)
    return llm.invoke(final_prompt).content

if __name__ == "__main__":
    print(ask("Bu belgelerde performans optimizasyonu için öneriler neler?"))

Uygulamayı çalıştırmadan önce “docs/” klasörüne örnek metinler koymayı unutmayın. Eğer PDF kullanacaksanız “pypdf” ile yükleyebilir veya metne dönüştürüp aynı adımları uygulayabilirsiniz.

Performans ve Kalite İpuçları

Gömleme modeli seçimi: “nomic-embed-text” hızlı ve yeterli doğruluk sağlıyor. Çok dilli dokümanlarda “bge-m3” gibi çok dilli gömlemelere bakabilirsiniz.

Parça boyutu ve örtüşme: chunk_size=600–1200, chunk_overlap=80–200 aralığı pratik. Metin türüne göre ayarlayın. Uzun form teknik belgelerde daha büyük parçalar, soru-cevap notlarında daha küçük parçalar işe yarar.

Arama türü: Chroma varsayılan kosinüs benzerliği ile iyi çalışır. Farklı “k” değerlerini deneyin. Çok sayıda belge olduğunda metadata filtreleri eklemek doğruluğu artırır.

İstem mühendisliği: Şablona “Cevabın sonunda kaynak alıntısı ver” gibi kurallar eklemek kullanıcı güvenini artırır. Yanıt formatını (madde işaretleri, kısa özet + detaylar) açıkça belirtin.

Model ve nicemleme: Ollama üzerinde “:q4_0” gibi nicemlenmiş sürümler daha az RAM kullanır ve hızlanır; kalite az da olsa düşebilir. GPU mevcutsa GPU kullanımını etkinleştirmek büyük fark yaratır.

Güvenlik ve Gizlilik

Yerel RAG’in en önemli avantajı verilerin cihazınızda kalmasıdır. Ancak indeks dizininizi şifreli disk üzerinde tutmak, yedekleri güvenli almak ve işletim sistemi düzeyinde erişim izinlerini doğru ayarlamak gerekir. Paylaşılan makinelerde servis portlarını dışa açmayın.

Sorun Giderme

- “Connection refused”: Ollama servisi çalışmıyor olabilir. “ollama serve” komutunu kontrol edin.
- “CUDA/Metal hataları”: Sürücü/güncelleme gerekli olabilir. Geçici olarak CPU ile deneyin.
- “Bellek yetersiz”: Daha küçük model deneyin (ör. 3B–7B) veya nicemlenmiş varyant çekin.
- “Cevaplar ilgisiz”: chunk_size ve k değerlerini ayarlayın, gömleme modelini değiştirin, istemi netleştirin.

Sonuç

Bu kurulumla, Ollama + LangChain + Chroma üçlüsü sayesinde tamamen yerel çalışan bir RAG chatbotu elde ettiniz. Küçük boyutlu bir modelle bile belgeye dayalı arama ve yanıt üretiminde tatmin edici sonuçlar alabilirsiniz. Zamanla daha iyi gömlemeler, gelişmiş istem şablonları ve daha hızlı modellerle doğruluğu ve hızı artırabilirsiniz. Sonraki adım olarak bir REST API ekleyip (ör. FastAPI) web arayüzü veya Slack/Teams entegrasyonu kurmayı düşünebilirsiniz.

Laptopta Yerel LLM Çalıştırma Rehberi: Ollama ile GPU Hızlandırmalı RAG Kurulumu (2025)

Giriş

Üretken yapay zekâ servislerini bulut yerine kendi bilgisayarınızda çalıştırmak hem gizliliği artırıyor hem de maliyeti düşürüyor. Son aylarda adını sıkça duyduğumuz Ollama, yerel LLM çalıştırmayı son derece pratik hâle getiriyor. Bu rehberde, laptop veya masaüstünüzde GPU hızlandırmalı bir kurulum yapacak, ardından basit bir RAG (Retrieval Augmented Generation) akışı kurgulayarak kendi belgeleriniz üzerinde akıllı arama ve soru-cevap deneyimi oluşturacağız. Tüm adımlar sade ve SEO dostu bir “how-to” olarak planlandı.

Sistem Gereksinimleri ve Model Seçimi

Modern bir CPU ve en az 16 GB RAM önerilir. GPU tarafında NVIDIA (CUDA) veya Apple Silicon (Metal) destekleri performansı ciddi biçimde artırır. Disk alanınızın en az 10–20 GB boş olması faydalıdır. Model seçerken boyut-kalite dengesine dikkat edin: llama3:8b veya mistral:7b gibi 7–8B modeller, 4-bit kuantizasyonla çoğu senaryoda iyi sonuç verir. Daha ciddi analizler için 13B üstü modellere yönelebilirsiniz, ancak VRAM ve RAM kullanımınız artacaktır.

Ollama Kurulumu

macOS üzerinde brew install ollama ile kurulumu tamamlayabilirsiniz. Windows için resmi yükleyiciyi tercih edin (Ollama sitesinden .exe indirerek). Linux’ta ise curl -fsSL https://ollama.com/install.sh | sh komutu işinizi görecektir. Kurulumdan sonra servisi başlatmak için ollama serve komutunu çalıştırın; arka planda http://localhost:11434 adresinde bir API sunucusu açılır.

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

Örnek olarak Llama 3’ün 8B sürümünü indirelim: ollama pull llama3:8b. Ardından hızlı bir test için ollama run llama3:8b komutunu çalıştırın. Komut satırında modele doğrudan soru sorabilirsiniz. Türkçe anlama ve yanıt üretimi konusunda tatmin edici sonuçlar için sistem talimatını kısa bir bağlamla başlatmanız iyi olur; örneğin “Türkçe, kısa ve teknik yanıt ver” gibi bir içerikle diyaloğu yönlendirin.

GPU Hızlandırma İpuçları

Apple Silicon (M1/M2/M3) cihazlarda Metal desteği otomatik devreye girer. NVIDIA tarafında en iyi sonuç için güncel CUDA ve cuDNN sürümlerini kurun, ardından ortam değişkenleriyle ince ayar yapın. Örneğin, OLLAMA_NUM_GPU=1 ile kaç GPU kullanılacağını sınırlandırabilir, OLLAMA_MAX_LOADED_MODELS=1 ile aynı anda yüklenen model sayısını azaltarak VRAM taşmalarını önleyebilirsiniz. Ayrıca 4-bit kuantize sürümler (Q4_K_M benzeri) daha az bellek tüketir; ilk denemelerde bunları tercih etmek stabilite sağlar.

RAG Nedir ve Neden Gerekli?

RAG, modelin kendi parametrelerinde olmayan güncel veya özel bilgiyi, harici bir bilgi tabanından anlık olarak alıp yanıtları zenginleştirmesini sağlar. Örneğin, şirket içi dokümanlarınızı veya notlarınızı vektör dizinine (vector store) dönüştürür, sorgu anında en uygun parçaları çekip modele “bağlam” olarak verirsiniz. Böylece hallucination azalır, doğruluk artar.

Basit RAG Akışı: Adım Adım

1) Belgeleri Hazırla: PDF, Markdown veya düz metin dosyalarınızı tek bir klasörde toplayın. Büyük dosyaları ~500–1000 token’lık parçalara bölmek arama kalitesini artırır.

2) Embedding Modelini Çek: Ollama içinden bir gömme modeli indirin: ollama pull nomic-embed-text veya çok dilli kullanım için all-minilm benzeri alternatifleri deneyin.

3) Vektör Üret: Hızlı bir test için Ollama’nın HTTP API’sini kullanabilirsiniz. Örnek bir istek: curl -s http://localhost:11434/api/embeddings -d '{"model":"nomic-embed-text","input":"Merhaba dünya"}'. Script ile belgelerinizi satır satır embed ederek bir JSONL çıktısı oluşturabilirsiniz.

4) Vektör Dizini Kur: Hafif bir çözüme ihtiyaç varsa Chroma veya FAISS gibi kütüphaneleri tercih edin. Python tarafında pip install chromadb ile başlayabilir, vektörleri ve metin parçalarını koleksiyonlara ekleyebilirsiniz. Alternatif olarak SQLite tabanlı vektör eklentileri (ör. sqlite-vss) yerel, dosya tabanlı bir yaklaşım sunar.

5) Sorgu ve Geri Getirme: Kullanıcı sorgusunu aynı embedding modeliyle vektöre çevirin, en benzer N doküman parçasını bulun ve bu parçaları model istemine (prompt) “bağlam” olarak ekleyin. Ardından curl -s http://localhost:11434/api/generate veya ollama run llama3:8b üzerinden, oluşturduğunuz bağlamı içeren bir istemle yanıt üretin.

Performans ve Doğruluk İçin İnce Ayar

- Daha hızlı yanıt için kısa bağlam ve az sayıda parça ile deneyin; gerekirse N değerini 3–5 aralığında tutun. Uzun bağlamlar, özellikle küçük modellerde kaliteyi bazen düşürebilir.

- Top-k ve top-p örnekleme ayarları ile yaratıcılık/kararlılık dengesini kurun. Kritik teknik metinlerde deterministikliğe yakın ayarlar tercih edin.

- Kaynak parçaları yanıtın sonunda listeler veya dipnotlar olarak ekletin. Bu hem şeffaflık sağlar hem de güveni artırır. İstemde “Kaynaklardan alıntı yap ve bağlantı ver” gibi net talimatlar verin.

Güvenlik ve Gizlilik

Yerel kurulumun en büyük artısı verilerin bilgisayarı terk etmemesidir. Yine de hassas belgelerle çalışırken disk şifrelemesi, güçlü oturum açma yöntemleri ve düzenli yedekleme kullanın. Eğer API’nizi ağ üzerinden açacaksanız bir ters proxy arkasında kimlik doğrulama ekleyin. Model ve embedding versiyonlarını not edin; üretim senaryosunda değişikliklerin etkisini takip etmek için versiyonlama kritiktir.

Sonuç

Ollama ile yerel LLM kurmak, düşündüğünüzden daha hızlı ve verimli. Küçük bir embedding modeli ve hafif bir vektör diziniyle kuracağınız RAG katmanı, kişisel notlarınızdan teknik dokümanlara kadar geniş bir bilgi tabanını akıllıca sorgulamanıza imkân tanır. Donanımınıza göre doğru model ve kuantizasyonu seçip GPU hızlandırmayı aktifleştirdiğinizde, bulut bağımlılığını azaltan, düşük gecikmeli ve gizlilik dostu bir üretken yapay zekâ deneyimi elde edersiniz. İlk POC’yi başarıyla tamamladıktan sonra; bir REST arayüzü ekleyip arka planda planlanmış yeniden indeksleme görevleri ve log analiziyle yapınızı olgunlaştırabilirsiniz.

Yerel LLM ile RAG: Ollama + LangChain + ChromaDB ile Türkçe Soru-Cevap Sistemi Kurulumu (2025 Rehberi)

RAG nedir, neden yerel?

RAG (Retrieval-Augmented Generation), büyük dil modellerini (LLM) kendi verinizle güçlendirmenin en pratik yollarından biridir. Model, önce vektör veritabanından ilgili pasajları arar (retrieval), ardından yanıtı bu pasajları referans alarak üretir (generation). Bu yaklaşım, hem doğruluk hem de güncellik sağlar. Yerel (on-prem/edge) kurulum ise hassas veriyi dışarı çıkarmadan çalıştığı için KVKK uyumu, gecikme ve maliyet açısından avantajlıdır.

Mimari genel bakış

Ollama yerel LLM’i (ör. Qwen2.5 7B) çalıştırır, LangChain iş akışını yönetir, ChromaDB vektör veritabanı olarak belgeleri tutar, Sentence-Transformers ise Türkçe uyumlu gömme (embedding) üretir. Sorgu akışı: Kullanıcı sorusu → Embedding → Chroma’dan benzer parçaların bulunması → Seçilmiş LLM ile bağlamsal yanıt.

Gereksinimler ve ortam

- İşletim sistemi: macOS, Linux veya WSL2’li Windows
- Python 3.10+
- 16 GB RAM önerilir (8 GB ile quantize modeller çalışır).
- GPU hızlandırma varsa avantajlı; yoksa 4-bit quantize modelleri tercih edin.

Kurulum adımları

1) Ollama’yı kurun ve modeli çekin:
curl -fsSL https://ollama.com/install.sh | sh
ollama pull qwen2.5:7b
Qwen2.5 çok dilli yapısıyla Türkçe’de başarılıdır. Daha hafif bir seçenek gerekiyorsa qwen2.5:3b veya llama3.1:8b-instruct da tercih edilebilir.

2) Python ortamını hazırlayın:
python -m venv .venv && source .venv/bin/activate
pip install langchain langchain-community chromadb sentence-transformers pypdf fastapi uvicorn
Embedding için Türkçe’de güçlü bir seçenek: intfloat/multilingual-e5-base veya sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2.

Veri hazırlama ve indeksleme

Belgelerinizi data/ klasörüne koyun (PDF, TXT, MD). PDF’ler için pypdf ile metin çıkarabilirsiniz. Amaç, büyük belgeleri 500–1000 karakterlik, 50–100 karakter örtüşmeli parçalara ayırmaktır. Bu sayede arama daha isabetli olur ve bağlam penceresini verimli kullanırsınız.

Örnek akış (özet):
- Belgeleri yükle: PDF/TXT okuma
- Parçala: 800 karakter, 120 örtüşme
- Embedding üret: multilingual-e5-base
- ChromaDB’ye yaz: kalıcı (persist) bir dizinde tut

Basit bir betik iskeleti:
from langchain_community.document_loaders import PyPDFLoader, TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain_community.embeddings import HuggingFaceEmbeddings
loader = PyPDFLoader("data/rapor.pdf")
docs = loader.load()
splitter = RecursiveCharacterTextSplitter(chunk_size=800, chunk_overlap=120)
chunks = splitter.split_documents(docs)
emb = HuggingFaceEmbeddings(model_name="intfloat/multilingual-e5-base")
vect = Chroma.from_documents(chunks, emb, persist_directory="chroma_store")
vect.persist()

Arama + üretim zinciri

LangChain ile basit bir RAG zinciri kurabilirsiniz. Retriever’ı Chroma’dan oluşturun, Ollama LLM’i bağlayın ve istem (prompt) şablonu ile bağlamı enjekte edin. MMR (Maximal Marginal Relevance) ve top_k gibi ayarlarla oynayarak tekrar eden içerikleri azaltın ve çeşitliliği artırın.

Örnek sorgulama iskeleti:
from langchain_community.llms import Ollama
from langchain.prompts import PromptTemplate
vect = Chroma(persist_directory="chroma_store", embedding_function=emb)
retriever = vect.as_retriever(search_type="mmr", search_kwargs={"k": 5, "fetch_k": 20})
llm = Ollama(model="qwen2.5:7b", temperature=0.2)
template = ("Aşağıdaki bağlama dayanarak Türkçe, kaynaklara sadık ve kısa bir yanıt ver. "
"Bağlam:\n{context}\n\nSoru: {question}\nYanıt:")
prompt = PromptTemplate.from_template(template)
docs = retriever.get_relevant_documents("2024 finansal özet nedir?")
context = "\n\n".join([d.page_content for d in docs])
print(llm.invoke(prompt.format(context=context, question="2024 finansal özet nedir?")))

Doğruluk ve optimizasyon

- Chunk boyutu: 600–1000 karakter arası pratik. Daha küçük parça daha hassas arama, daha fazla parçayı LLM’e göndermek demektir. Bağlam penceresiyle dengeleme yapın.
- Reranker: GPU’nuz varsa bge-reranker-large gibi çapraz-encoder modeller ekleyerek bağlam kalitesini artırın.
- Top-k: 3–8 arası iyi bir başlangıç. Soru karmaşıksa artırın.
- Sıcaklık (temperature): 0.1–0.3 arası daha tutarlı, kaynaklara sadık yanıt sağlar.
- GYS/Değerlendirme: Küçük bir altın veri kümesi ile doğruluk ölçün. RAGAS gibi metriklerle bağlamsal doğruluğu takip edin.

Üretimde çalıştırma

Basit bir API için FastAPI idealdir. İsteğe göre streaming açarak ilk token’ı daha hızlı iletebilirsiniz. Chroma’yı kalıcı dizinle (persist_directory) başlatın ve yalnızca “okuma” modunda koşturun. Döküman güncellemeleri için zamanlanmış yeniden indeksleme (ör. günlük) stratejisi belirleyin.

Örnek uç nokta iskeleti:
from fastapi import FastAPI
app = FastAPI()
@app.get("/ask")
def ask(q: str):
  docs = retriever.get_relevant_documents(q)
  ctx = "\n\n".join(d.page_content for d in docs)
  ans = llm.invoke(prompt.format(context=ctx, question=q))
  return {"answer": ans}
uvicorn main:app --reload

Güvenlik, maliyet ve lisans notları

- Veri gizliliği: PII içeren alanları maskeleyin; loglarda ham sorgu ve belgeleri tutmayın. Diskte Chroma klasörünü şifreli bir birimde saklayın.
- Lisans: Kullandığınız model ve embedding lisansını kontrol edin; ticarî kullanımlarda kısıtlar olabilir.
- Maliyet: Yerel kurulum bulut token maliyetini düşürür, ancak donanım kaynağına ihtiyaç duyar. 4-bit quantize modeller düşük RAM’de dengeli performans sağlar.

Sorun giderme

- Yavaş yanıt: Embedding modelini daha hafife çekin (MiniLM), top_k’yı düşürün, quantize LLM kullanın.
- Alakasız bağlam: Chunk boyutunu artırın, MMR’ı açın, gerekirse reranker ekleyin.
- Bozuk indeks: chroma_store klasörünü temizleyip yeniden indeksleyin; gömme modelini değiştirdiyseniz indeksin de değişmesi gerekir.
- Hallüsinasyon: Prompt’a “Kaynak verilmeyen bilgiyi üretme” kuralını ekleyin, temperature’ı düşürün ve bağlamı zenginleştirin.

Sonuç

Bu rehberde Ollama + LangChain + ChromaDB ve çok dilli embedding’lerle yerel bir Türkçe RAG sistemi kurmanın hızlı yolunu gördünüz. Doğru chunking, iyi bir retriever ve tutarlı istem tasarımıyla, Türkçe dokümanlarınıza dayalı güvenilir bir soru-cevap deneyimi sağlayabilirsiniz. İhtiyaca göre model boyutunu, indeks ayarlarını ve dağıtım mimarisini optimize ederek sistemi üretim kalitesine taşıyın.

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.

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.

Ollama ile Yerel LLM Kurulumu: Llama 3.1 ve Mistral’i Bilgisayarınızda Çalıştırma Rehberi

Giriş

Yapay zekâ araçlarını bulutta kullanmak pratik olsa da, gizlilik, maliyet ve hız gibi konularda sınırlamalar yaratabiliyor. Ollama, güncel büyük dil modellerini (LLM) bilgisayarınızda, internet bağlantısı olmadan ve düşük kurulum maliyetiyle çalıştırmanızı sağlayan hafif bir platform. Bu rehberde, Llama 3.1 ve Mistral gibi modelleri Ollama ile nasıl kuracağınızı, yerel API’yi nasıl kullanacağınızı ve performansı artırmak için dikkat etmeniz gereken noktaları adım adım anlatıyorum.

Neden Yerel LLM?

Yerel LLM çalıştırmanın en büyük avantajı verilerinizin bilgisayarı terk etmemesi. Özellikle müşteri verileri, kaynak kodu veya şirket içi belgelerle çalışıyorsanız gizlilik kritik hale gelir. Ek olarak, isteğe bağlı kullanımda bulut maliyetleri hızla artabilir. Yerel kurulumda ise bir kez model dosyasını indirip, dilediğiniz kadar kullanabilirsiniz. Son olarak, kısa sorgularda gecikme (latency) dramatik şekilde düşer; ağ gecikmesi olmadığı için yanıtlar daha akıcı gelir.

Sistem Gereksinimleri

Minimum gereksinimler modele göre değişse de pratik bir başlangıç için 16 GB RAM önerilir. 7B-8B parametreli modellerde 8-12 GB RAM ile de çalışabilirsiniz. GPU’nuz varsa (NVIDIA, Apple Silicon veya yeni nesil AMD) performans çarpıcı biçimde artar; VRAM miktarı ne kadar yüksekse, model o kadar hızlı ve akıcı yanıt verir. Diskte en az 10-20 GB boş alan ayırın; model dosyaları büyük olabilir. Windows, macOS ve Linux platformları desteklenir.

Kurulum

Ollama’yı ollama.com üzerinden işletim sisteminize uygun yükleyiciyi indirerek kurabilirsiniz. Kurulum tamamlandıktan sonra Ollama arka planda bir hizmet olarak çalışır. Terminal veya Komut İstemi’ni açıp basit bir komutla test edebilirsiniz. Eğer Windows kullanıyorsanız en güncel sürümü tercih edin; GPU desteği ve kararlılık son dönemde hızla iyileştirildi.

Model İndirme ve Çalıştırma

Ollama’nın en pratik yanı model yönetimini tek komutla yapabilmesi. Örneğin Llama 3.1’i denemek için terminalde şu komutu çalıştırın: ollama run llama3.1. Bu komut ilk seferde modeli indirir ve etkileşimli bir oturum başlatır. Benzer şekilde, hızlı ve hafif bir alternatif için: ollama run mistral. Oturumdayken sorularınızı yazıp anında yanıt alabilirsiniz. Çıkmak için Ctrl+C yeterli.

Belirli bir kullanım senaryosu için farklı boyut seçenekleri mevcut olabilir (örneğin 8B, 13B, 70B). Boyut büyüdükçe doğruluk ve bağlam yönetimi gelişir; ancak RAM/VRAM ihtiyacı artar. İlk denemelerde 7B-8B sınıfı modellerle başlayıp, donanımınız el verdiği ölçüde daha büyük modellere geçmeniz iyi bir stratejidir.

Yerel API ile Entegrasyon

Ollama bir REST API sunar. Kendi uygulamanızdan yerel modele istek atmak için http://localhost:11434 adresini kullanabilirsiniz. Temel uç noktalardan biri /api/generate’tir. Gövdeye prompt, model adı ve opsiyonel parametreler (maksimum token, sıcaklık gibi) göndererek yanıt alırsınız. Örnek akışta, yanıtlar parça parça (stream) dönebilir; bu sayede sohbet arayüzlerinde yazı yazılırken canlı akış efektini rahatça sağlayabilirsiniz.

Geliştiriciler için pratik bir yöntem de araya bir istemci kütüphanesi koymak. JavaScript, Python veya Go gibi dillerdeki minimal HTTP istekleriyle hızlıca prototip yapabilirsiniz. Mevcut sohbet uygulamanıza veya dahili araçlarınıza bir “yerel asistan” eklemek için bu yöntem idealdir.

Modelfile ile Özelleştirme

Ollama’nın Modelfile yapısı, bir modelin nasıl başlatılacağını, sistem yönergelerini ve ek kaynakları tanımlamanıza olanak tanır. Örneğin bir kurumsal asistanda “şirket politikasına uygun, kısa ve güvenli yanıtlar ver” gibi bir sistem talimatını kalıcı hale getirebilirsiniz. Bu dosyayı oluşturarak ollama create komutuyla adını verdiğiniz özel modeli yayınlayabilir, ekip içinde aynı profili paylaşabilirsiniz.

Performans İpuçları

- GPU kullanın: Mümkünse modele ayrılan katmanları GPU’ya offload edin; bu, yanıt süresini dratik biçimde azaltır. Apple Silicon’da Metal hızlandırma, NVIDIA’da CUDA desteği ciddi fark yaratır.

- Hafif kuantizasyon: 4-bit veya 5-bit kuantize modeller RAM/VRAM baskısını düşürürken kabul edilebilir doğruluk sunar. İlk kurulumda Q4 veya Q5 sürümlerini deneyebilirsiniz.

- Maksimum token ve sıcaklık: Uzun yanıtlar kaynak tüketimini artırır. Maksimum token değerini ihtiyaca göre sınırlayıp, sıcaklığı 0.2-0.7 aralığında ayarlamak denge sağlar.

Güvenlik, Gizlilik ve Bakım

Yerel çalıştırmada veriler cihazınızda kaldığından gizlilik avantajı elde edersiniz. Yine de hassas içerikleri disk şifreleme ve kullanıcı erişim kısıtlarıyla korumayı unutmayın. Modelleri güncel tutmak önemlidir; yeni sürümler hem kaliteyi artırır hem de hataları giderir. Ayrıca, şirket içi kullanımda model davranışını izlemek ve denetim kayıtları tutmak uyumluluk açısından faydalıdır.

Karşılaşılan Yaygın Sorunlar

- Yetersiz bellek: Model yüklenemiyorsa daha küçük bir varyant deneyin veya kuantize sürüme geçin. Arka planda çalışan ağır uygulamaları kapatın.

- Yavaş yanıt: GPU hızlandırmayı açın, akış (stream) modunu kullanın, maksimum token değerini düşürün.

- Uygulama entegrasyonu: API uç noktalarını doğrulayın, istek gövdesindeki parametreleri (prompt, model) doğru gönderdiğinizden emin olun.

Sonuç

Ollama ile Llama 3.1 ve Mistral gibi modelleri yerel olarak çalıştırmak, hem geliştiriciler hem de içerik üreticileri için esnek, hızlı ve güvenli bir çözüm sunuyor. Basit kurulum adımları, tek komutla model yönetimi ve REST API sayesinde, deneme-yanılma döngüleri kısalıyor ve üretkenlik artıyor. Donanımınıza uygun model boyutunu seçip, Modelfile ile özelleştirme ve kuantizasyon gibi teknikleri kullanarak kısa sürede verimli bir yerel yapay zekâ ortamı oluşturabilirsiniz.

Ollama ve ChromaDB ile RAG: Kendi Verinizle Yerel Yapay Zekâ Sohbet Botu Nasıl Kurulur?

RAG nedir ve neden önemli?

Retrieval-Augmented Generation (RAG), bir dil modelinin cevap üretmeden önce bir vektör veritabanından ilgili parçaları geri çağırdığı, bu sayede daha doğru ve kaynaklı yanıtlar ürettiği bir yaklaşımdır. Güncel kurumsal ihtiyaçlarda gizlilik, maliyet kontrolü ve özelleştirme kritik hale geldiği için RAG, özellikle şirket içi dokümanlar, bilgi tabanları ve politikalar üzerinde çalışan sohbet botları için en verimli yöntemlerden biri olarak öne çıkıyor.

Bu rehberde, tamamen yerel çalışan bir kurulumla Ollama (yerel LLM çalıştırma), ChromaDB (vektör veritabanı) ve Python kullanarak adım adım bir RAG sistemi kurulumu yapacağız. Amaç, Türkçe metinlerle yüksek doğrulukta, düşük gecikmeli ve veri gizliliği korunan bir sohbet deneyimi sunmak.

Gerekenler ve mimari

Bileşenler: Ollama (Llama 3 veya benzeri açık kaynak model), ChromaDB (kalıcı vektör deposu), bir gömme (embedding) modeli (örn. intfloat/multilingual-e5-base), Python 3.10+, LangChain veya minimal kendi kodunuz. İsteğe bağlı olarak PDF/Word dosyaları için pypdf veya docx desteği ekleyebilirsiniz.

Akış: Dokümanları parçalara ayır → Embedding ile vektörleştir → ChromaDB’de indeksle → Soru geldiğinde benzer parçaları getir → Model için talimat şablonuna (prompt) enjekte et → Yanıtı oluştur ve kaynakları göster.

Kurulum adımları

1) Ollama’yı kurun. Resmi site üzerinden işletim sisteminize uygun paketi indirin. Model indirmek için komut satırında şu adımı uygulayın:
ollama pull llama3
Ardından test amaçlı kısa bir deneme yapabilirsiniz:
ollama run llama3

2) Python ortamını hazırlayın. Ayrı bir sanal ortam tercih edin:
python -m venv .venv && source .venv/bin/activate (Windows için .venv\Scripts\activate)
pip install chromadb sentence-transformers langchain langchain-community pypdf

Veri hazırlığı: parçalama ve temizleme

İyi bir RAG’in temeli, doğru parça boyutları ve temiz veridir. Türkçe belgelerde 300–500 token’lık parçalar pratikte iyi sonuç verir. Parçaları ayırırken başlık bilgilerini ve içerik konusunu korumaya çalışın. Örneğin bir politika belgesinde bölüm başlığını her parçaya meta veri olarak ekleyin. Bu, hem geri çağırmayı hem de kaynakları kullanıcıya göstermeyi kolaylaştırır.

Temizlik aşamasında gereksiz boşlukları, tekrar eden sayfa altbilgilerini ve tablo görsellerinden gelen çöp metinleri temizleyin. PDF okuyucu olarak pypdf kullanabilir, Markdown veya HTML dokümanlarını doğrudan metne dönüştürebilirsiniz.

ChromaDB ile vektör indeksleme

Embedding için çok dilli ve Türkçe performansı yüksek bir model seçin. “intfloat/multilingual-e5-base”, hız/doğruluk dengesiyle güvenilir bir tercih. Basit bir akış şöyle olabilir: Belgeleri oku → Böl → Her parça için embedding hesapla → ChromaDB’ye “persist_directory” ile kalıcı olarak yaz. Bu sayede uygulama yeniden başladığında indeksi tekrar oluşturmadan kullanabilirsiniz.

Koleksiyonlarınızı konuya göre ayırın (örn. “insan_kaynaklari”, “urun_dokumantasyonu”). Meta veriye kaynak adı, sayfa numarası, bölüm ve tarih gibi alanlar eklemek, yanıtların izlenebilirliğini artırır.

Sorgulama: RAG adım adım

Kullanıcıdan gelen soruyu önce bir sorgu embedding’ine dönüştürün, ardından ChromaDB’den en ilgili 3–5 parçayı çekin. Bu parçaları modelinize şu yapıda verin: kısa bir talimat + kullanıcı sorusu + “bağlam” bölümü (geri çağrılan parçalar). Örnek şablon yaklaşımı: “Aşağıdaki bağlamdan faydalanarak soruya kısa ve kaynaklı bir yanıt ver. Bağlamda yoksa tahmin yürütme.”

Ollama tarafında llama3 modelini çağırırken sıcaklık (temperature) düşük (0.1–0.3) tutulduğunda halüsinasyon azalır. Yanıtın sonuna “Kaynaklar” başlığı ile geri çağrılan parçaların referanslarını eklemek, güven inşa eder ve SEO açısından “uzman” hissiyatı yaratır.

İyileştirme: yeniden sıralama ve çoklu sorgu

Bazı senaryolarda temel benzerlik araması yeterli olmaz. Açık kaynak yeniden sıralayıcılar (örn. bge-reranker-large) ile ilk 20 sonucu alıp en iyi 5’ini rerank ederek doğruluğu yükseltebilirsiniz. Ayrıca multi-query tekniği ile kullanıcı sorusunu farklı biçimlerde genişletip (eş anlamlılar, farklı bağlamlar) birleştirilmiş sonuçlar elde etmek de hatırlamayı artırır.

Soru ön-işleme katmanında yazım hatalarını düzeltmek, alan terimlerini sözlükten normalleştirmek ve tarih-sayı gibi varlıkları standart forma getirmek, özellikle kurumsal dokümanlarda fark yaratır. Halüsinasyonları azaltmak için “sadece bağlamdan yanıt ver, bağlam yoksa ‘yok’ de” gibi net kurallar koyun.

Performans, güvenlik ve üretime alma

CPU ile başlayıp gerekirse GPU’ya geçin. Düşük bellekli sistemlerde quantized (örneğin Q4_0) model varyantları iyi sonuç verir. ChromaDB tarafında kalıcı dizin SSD üzerinde olmalı ve düzenli olarak koleksiyon boyutu ile gecikmeyi izleyin. Top_k değerini 3–8 arasında test ederek doğruluk/performans dengesini bulun.

Üretim ortamında bir FastAPI uç noktası ile sorgulama zincirinizi sunabilirsiniz. Yanıtları ve kullanılan kaynakları log’layarak kalite ölçümü yapın. Kişisel veriler içeren dokümanlarda yerel çalışmanın avantajı büyüktür; ağ dışına veri çıkarmadan kurumsal uyumluluk hedeflerine yaklaşabilirsiniz.

Sonuç

Ollama + ChromaDB ile kurulan yerel RAG yığını, maliyeti düşük, gizliliği yüksek ve yönetilebilir bir yapay zekâ çözümü sunar. Doğru parça boyutu, iyi bir embedding modeli ve dikkatli şablonlama ile Türkçe içerikte dahi oldukça isabetli yanıtlar elde edebilirsiniz. Bu rehberi temel alarak önce küçük bir pilot oluşturun, ardından veri kapsamını ve değerlendirme metriklerini (doğruluk, geri çağırma, MRR) aşamalı olarak genişletin. Böylece güncel ve ileri seviye bir deneyimi, tamamen kendi verinizle kontrol ederek hayata geçirebilirsiniz.

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.

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.

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.