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.

Local AI Dönemi: Ollama ile Bilgisayarında LLM Çalıştırma ve Open WebUI ile ChatGPT Benzeri Arayüz Kurma

Yerelde LLM çalıştırmak neden yeniden gündemde?

Bulut tabanlı yapay zekâ servisleri hızlı ve pratik; ancak veri gizliliği, abonelik maliyetleri ve hız dalgalanmaları gibi konular yüzünden “yerel AI” tekrar yükselişte. Özellikle metin üretimi, kod yardımı, özetleme ve belge sorgulama gibi işlerde, bilgisayarında çalışan bir LLM (Large Language Model) çoğu senaryoda yeterli olabiliyor. Bu yazıda, Ollama ile yerel model çalıştırmayı ve Open WebUI ile tarayıcıdan erişilen modern bir sohbet arayüzü kurmayı adım adım anlatıyorum.

Ön koşullar: Donanım ve işletim sistemi

Ollama; macOS, Linux ve Windows üzerinde çalışabiliyor. Temel gereksinim RAM tarafında. Küçük modeller için 8 GB RAM ile başlanabilir; daha rahat kullanım için 16 GB ve üzeri önerilir. GPU şart değil, ancak güçlü bir GPU (özellikle NVIDIA) hız avantajı sağlar. Depolama tarafında ise model dosyaları birkaç GB’tan başlayıp çift haneli GB seviyelerine çıkabildiği için en az 20–30 GB boş alan iyi olur.

1) Ollama kurulumu

Ollama’nın amacı, yerel LLM çalıştırmayı “tek komut” kadar kolay hale getirmek. Kurulum yöntemleri işletim sistemine göre değişir; en güncel adımlar için Ollama’nın resmi sitesine göz atmak mantıklı. Kurulum tamamlandıktan sonra komut satırından Ollama’nın çalıştığını doğrulayabilirsiniz. macOS/Linux’ta genellikle Terminal, Windows’ta PowerShell kullanılır.

Kontrol adımı: Ollama servisinin arka planda çalıştığından emin olun. Bazı sistemlerde kurulumla birlikte servis otomatik başlar. Başlamadıysa Ollama uygulamasını/servisini çalıştırmanız gerekebilir.

2) İlk modeli indirme ve çalıştırma

Ollama’da mantık basit: Bir modeli indirir ve “run” ile sohbet başlatırsınız. Örnek olarak genel amaçlı bir model seçebilirsiniz. Aşağıdaki komut, modelin cihazınıza indirilmesini ve ardından etkileşimli sohbetin açılmasını sağlar:

Komut: ollama run llama3.1

İlk çalıştırmada indirme süresi internet hızınıza bağlıdır. Sohbet ekranı geldiğinde Türkçe de yazabilirsiniz. Eğer yanıtlar yavaşsa, daha küçük bir model deneyin veya bağlam (context) boyutunu düşük tutun. Yerel kullanımda performansı belirleyen ana etkenler; model boyutu, quantization seviyesi ve donanım kapasitesidir.

3) Open WebUI ile tarayıcıdan modern arayüz kurma

Komut satırı pratik olsa da günlük kullanım için web arayüzü daha konforlu. Open WebUI, Ollama ile çalışan ve ChatGPT benzeri bir deneyim sunan popüler bir seçenek. Kurulumun en temiz yolu çoğu sistemde Docker kullanmaktır. Docker yüklüyse, Open WebUI konteyneri birkaç komutla ayağa kalkar ve tarayıcıdan erişirsiniz.

Örnek Docker komutu (genel yaklaşım): Open WebUI konteynerini çalıştırıp Ollama’ya bağlayacak şekilde yapılandırın. Bu adımda, Ollama servisinin yerelde hangi adreste çalıştığı önemlidir. Aynı makinede çalışıyorsanız genellikle “localhost” üzerinden erişilir; ancak Docker ağ ayarları işletim sistemine göre farklılık gösterebilir.

Kurulum sonrası tarayıcıda Open WebUI’ye girip model seçebilir, sohbet geçmişini yönetebilir, sistem prompt’u tanımlayabilir ve farklı konuşma profilleri oluşturabilirsiniz. Bu, yerel LLM’yi sadece “denemelik” olmaktan çıkarıp günlük bir üretkenlik aracına dönüştürüyor.

4) İleri seviye ayarlar: Model seçimi, quantization ve bağlam

Yerel LLM’lerde “tek doğru model” yok. İhtiyacınıza göre seçim yapmalısınız. Kod yardımı için kod odaklı modeller, Türkçe metin üretimi için Türkçe başarımı iyi olan modeller daha uygun olabilir. Ayrıca quantization (ör. 4-bit/8-bit) modelin RAM kullanımını düşürür; genellikle küçük kalite kaybı karşılığında ciddi hız ve kapasite avantajı sağlar. Uzun dokümanlarla çalışıyorsanız bağlam penceresi (context window) büyüdükçe RAM ihtiyacı artar. Bu yüzden “uzun bağlam” ile “hız” arasında denge kurmak gerekir.

5) Güvenlik ve gizlilik: Yerelde çalıştırmanın gerçek avantajı

Yerel çalıştırmanın en büyük artısı, verinin cihazınızdan çıkmamasıdır. Özellikle müşteri notları, proje dokümanları, sözleşmeler veya şirket içi kodlar söz konusuysa, buluta veri göndermemek kritik olabilir. Yine de unutmayın: Yerelde bile çalışsanız, kullandığınız arayüzlerin eklenti/telemetri ayarlarını kontrol etmek ve makinenizi güncel tutmak önemlidir. Ayrıca Open WebUI’yi yerel ağda erişime açacaksanız parola/kimlik doğrulama ayarlarını mutlaka etkinleştirin.

6) Yaygın sorunlar ve hızlı çözümler

Yanıtlar çok yavaş: Daha küçük model deneyin, quantization kullanın, arka plandaki uygulamaları kapatın. GPU kullanımı mümkünse etkinleştirin.

RAM yetmiyor / sistem kasıyor: Model boyutunu düşürün, aynı anda tek model çalıştırın, bağlam penceresini küçültün. Swap kullanımı artıyorsa performans dramatik düşer.

Open WebUI Ollama’yı görmüyor: Docker ağ yapılandırmasını kontrol edin. Ollama servisinin çalıştığından ve doğru adrese/porta bağlandığınızdan emin olun.

Sonuç: Yerel AI’yı günlük akışa taşımak

Ollama + Open WebUI ikilisi, yerel LLM dünyasına giriş için en pratik yollardan biri. Bir yandan komut satırıyla esnek bir kullanım sunuyor, diğer yandan tarayıcı arayüzüyle ekip içi veya kişisel üretkenliği artırıyor. Doğru model seçimi ve donanımınıza uygun ayarlar ile; özetleme, e-posta taslağı, toplantı notu düzenleme, kod açıklama gibi işlerde bulut bağımlılığını azaltabilirsiniz. Yerel AI’nın asıl gücü, kontrolün sizde olması: hız, gizlilik ve özelleştirme bir araya geldiğinde ortaya gerçekten kullanışlı bir araç çıkıyor.

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ı.