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.

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.

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.

Yerelde RAG Kurulumu: Ollama ve FAISS ile Belgelerinizden Akıllı Arama

RAG nedir, neden yerel çalıştırmalıyım?

Büyük dil modelleri etkileyici cevaplar üretebiliyor ancak kaynaklara dayanmayan “halüsinasyon” üretme eğilimleri var. Retrieval-Augmented Generation (RAG), modelin yanıtlarını gerçek belgelerinizden çekilen parçalarla destekleyerek bu sorunu azaltır. Yerel RAG, tüm süreci bilgisayarınızda çalıştırarak gizlilik, düşük gecikme ve maliyet avantajı sağlar. Bu yazıda Ollama + FAISS ikilisiyle, PDF’leriniz, notlarınız veya wiki sayfalarınız üzerinde çalışan pratik bir yerel RAG kurulumunun yolunu göstereceğim.

Mimari bileşenler

1) LLM (Yanıtlayıcı): Yerelde çalıştırmak için Ollama üzerinden Llama 3, Mistral veya benzeri açık modellerden birini seçebilirsiniz. Kuantize edilmiş sürümler (ör. Q4_K_M) düşük donanımda bile kabul edilebilir hız sunar.

2) Vektörleştirici (Embedding): Metni sabit boyutlu vektörlere dönüştürür. Türkçe desteği güçlü olan bge veya e5 tabanlı modeller iyi sonuç verir. Embedding modeli LLM’den ayrı olabilir; bu esneklik performansı artırır.

3) Vektör Veritabanı (FAISS): Belgelerinizin vektörlerini indeksleyip en benzer parçaları hızla getirir. FAISS hafif, açık kaynak ve yerel kurulum için idealdir.

4) Orkestrasyon: Basit bir RAG için ek çerçeve şart değil. Sıra; sorguyu vektörleştir, FAISS’ten en yakın doküman parçalarını getir, bu parçaları bağlam olarak LLM’e ver ve yanıtı oluştur şeklinde ilerler. İsterseniz LangChain veya LlamaIndex kullanabilirsiniz; ancak bu yazı minimal ve anlaşılır yaklaşımı tercih ediyor.

Adım adım kurulum

Önkoşullar: 8–16 GB RAM, modern bir CPU yeterli. GPU varsa daha hızlı olur. İşletim sistemi olarak macOS, Windows (WSL dahil) veya Linux uygundur.

1) Ollama’yı kurun: Ollama resmi sitesinden sisteminize uygun kurulum paketini indirin ve kurun. Terminalde “ollama run llama3” gibi bir komutla modeli test edebilirsiniz. İlk çalıştırmada model indirilecektir.

2) Embedding modelini hazırlayın: Python ortamı kurup sentence-transformers gibi bir kütüphane ile bge veya e5 tabanlı çok dilli bir modeli indirin. Türkçe metinler için bu aileler genellikle dengeli sonuç verir. Üretimde aynı tokenizer ve model sürümünü koruyarak tutarlılık sağlayın.

3) Belgeleri içe aktarın ve parçalara bölün: PDF, Markdown veya HTML kaynaklarınızı metne dönüştürün. Chunking stratejinizi belirleyin: 400–800 kelime aralığı ve %10–20 örtüşme (overlap) çoğu senaryo için iyi bir başlangıçtır. Başlık, bölüm, sayfa numarası gibi meta verileri saklamayı unutmayın.

4) FAISS ile indeks oluşturun: Her parçayı embedding modele verip vektörünü alın ve FAISS’e ekleyin. Büyük veri için IVF+PQ gibi yapılandırmalar disk ve bellek kullanımını dengeler. Küçük veri setlerinde düz L2 veya kosinüs benzerliği yeterli olur.

5) Sorgu akışı: Kullanıcı sorusunu embedding’e çevirin, FAISS’ten top-k (ör. k=5) en yakın parçayı çekin. Bu parçaları bir “bağlam” şablonunda birleştirip Ollama’ya aktarın. Prompt içinde “Sadece aşağıdaki bağlamdan yararlan” gibi net yönergeler verin. Yanıtı kaynak bağlantılarıyla birlikte sunmak güven yaratır.

6) Hafif bir API ekleyin: FastAPI gibi bir çerçeveyle tek uç noktalı bir servis hazırlayabilirsiniz. İstek geldiğinde sorguyu vektörleştirir, FAISS’ten bağlamı getirir, Ollama’ya iletir ve akışlı yanıtı geri döndürür. Böylece masaüstü, web veya mobil istemciler kolayca entegre olur.

7) Değerlendirme ve iyileştirme: Kaliteyi ölçmek için sık sorulan 20–30 soruluk bir test seti hazırlayın. Cevap doğruluğu, kaynak kapsama (coverage) ve ilk token gecikmesi gibi metrikleri izleyin. Top-k, chunk boyutu, MMR (çeşitlilik odaklı getirme) ve sıcaklık (temperature) ayarlarını kademeli değiştirerek A/B testleri yapın.

Performans ve pratik ipuçları

Kuantizasyon: LLM’i Q4 seviyesinde çalıştırmak performans/kalite dengesini iyileştirir. CPU’da dahi kabul edilebilir yanıt hızları elde edilir.

Prompt mühendisliği: Türkçe bağlam sağladığınızda, talimatları da Türkçe verin. “Kaynaklardan alıntı yap, emin değilsen belirt” gibi yönlendirmeler halüsinasyonu azaltır.

Önbellekleme: Sık soruların embedding ve arama sonuçlarını disk üzerinde önbelleğe alın. Bu, hem gecikmeyi hem de CPU yükünü düşürür.

Filtreler: FAISS yanında meta veri filtreleri tutarak tarih, yazar, kategori gibi sınırlamalarla daha doğru sonuçlar alabilirsiniz.

Türkçe desteği: Embedding modelinin Türkçe kapsaması kritiktir. İlk denemelerde Türkçe/multilingual modelleri karşılaştırın; bazen küçük ama iyi eğitilmiş bir embedding modeli büyük bir fark yaratır.

Gizlilik, güvenlik ve bakım

Yerel RAG’in en büyük artısı, belgelerinizin makine dışına çıkmamasıdır. Yine de PII içeren veri setlerini şifreli depolamak, cihazınızda tam disk şifreleme kullanmak ve indeks dosyalarına erişimi kısıtlamak önemlidir. Modelleri ve bağımlılıkları düzenli güncelleyin; embedding modelini değiştirdiğinizde indeksinizi yeniden oluşturmanız gerektiğini unutmayın.

Sorun giderme

İndeks tutarsızlığı: Farklı embedding model veya sürüm değişikliği, alakasız sonuçlar doğurur. Tek sürüm standardı belirleyin.

Dil karışması: Çok dilli veri setlerinde karışık diller zayıf eşleşmeye yol açabilir. Belgeleri dil bazında ayrı indekslemek kaliteyi yükseltir.

Kaynak tüketimi: RAM yetmiyorsa daha agresif chunking veya IVF+PQ yapılandırmasına geçin. LLM tarafında daha küçük bir model deneyin.

Sonuç

Ollama ve FAISS ile kurulan yerel RAG, gizliliğe duyarlı ortamlarda hızlı ve güvenilir bir bilgi erişim katmanı sunar. Doğru embedding seçimi, iyi bir chunking stratejisi ve disiplinli değerlendirmeyle; şirket içi dokümantasyondan akademik arşivlere kadar pek çok kullanım senaryosunda arama ve soru-cevap kalitesini belirgin biçimde artırabilirsiniz. Küçük adımlarla başlayın, metriklerle ölçün ve yapı taşlarını gerektikçe büyütün; kısa sürede günlük iş akışınızda fark yaratacaktır.

RAG ile Türkçe Dokümanlarınıza Özel Yapay Zekâ Asistanı Kurulumu (2025 Rehberi)

RAG nedir ve neden gerekli?

Kurumsal veriler üzerine çalışan yapay zekâ asistanlarının en büyük sorunlarından biri, modelin eğitim verisinde olmayan bilgiler hakkında uydurma (hallucination) üretmesidir. RAG (Retrieval-Augmented Generation) yaklaşımı, üretken modelden önce güvenilir kaynaklardan ilgili parçaları arayıp getirir, ardından bu bağlam ile yanıt oluşturur. Böylece cevaplar hem daha doğru hem de kaynaklanabilir olur. Bu yazıda, Türkçe dokümanlarınız için RAG tabanlı bir asistanı sıfırdan nasıl kurabileceğinizi adım adım anlatıyorum.

Mimari bileşenler

1) Doküman alımı ve ayrıştırma: PDF, Word, e-posta arşivi ya da Confluence/Jira gibi bilgi tabanlarından veriyi çekin. PDF’lerde metin çıkarımı için OCR gerekebilir. Tablo ve görselleri metne dönüştürürken bağlamı kaybetmemeye dikkat edin.

2) Temizleme ve parçalama (chunking): Türkçe metinlerde noktalama ve büyük/küçük harf (İ/ı) uyumuna dikkat edin. Belgeyi 300–500 kelimelik, %10–15 örtüşmeli parçalara ayırın. Başlık ve bölüm bilgilerini her parçaya meta veri olarak ekleyin.

3) Vektörleştirme (embedding): Türkçe desteği güçlü gömlemeler kullanın. Bulut tabanlı text-embedding-3-large (OpenAI) veya açık kaynak bge-m3 ve multilingual-e5-large iyi seçeneklerdir. Gizlilik gereksinimi yüksekse modeli yerelde çalıştırın.

4) Vektör veritabanı: Chroma, Qdrant, Milvus ya da FAISS ile arama yapın. Üretim ortamı için Qdrant/Milvus, prototip için Chroma/FAISS tercih edilebilir. Metadata alanlarında belge tipi, sayfa, bölüm gibi sahaları tutun.

5) Sorgu işleme: Yalnızca vektör araması yerine hibrit arama (BM25 + vektör) ve bir yeniden sıralayıcı (ör. bge-reranker) ekleyin. Bu, Türkçe uzun sorgularda isabeti ciddi şekilde artırır.

6) Üretken model (LLM): Bulutta GPT-4o mini gibi hızlı/uygun maliyetli bir model veya yerelde Llama 3.1 8B, Mistral 7B gibi modelleri Ollama üzerinden çalıştırabilirsiniz.

Adım adım kurulum

Adım 1 – Ortam: Python 3.11 ile bir sanal ortam kurun. Gerekliyse Docker ile Qdrant/Milvus çalıştırın. Projede LangChain veya LlamaIndex gibi bir çatı kullanmanız geliştirmeyi hızlandırır.

Adım 2 – Veri toplama: Belgeleri tek bir dizinde toplayın. Yetkisiz içerikleri ayıklayın; erişim seviyesine göre dizinleri bölmek ileride yetkilendirme için işinize yarar.

Adım 3 – Ön işleme: PDF sayfa kırıkları, dipnotlar ve sayfa numaralarını temizleyin. Türkçe’de noktalama ve karakter dönüşümlerini (ör. apostrof, tırnak) normalize edin. Gereksiz boşlukları ve tarih/sürüm kalıntılarını ayıklayın.

Adım 4 – Parçalama: İçerik türüne göre strateji belirleyin. Teknik belgelerde başlık bazlı, SSS’lerde soru-cevap bazlı, politikalar/prosedürlerde paragraf bazlı parçalama daha başarılı olur. Her parçaya kaynak_linki, belge_türü, bölüm gibi meta verileri ekleyin.

Adım 5 – Embedding seçimi: Türkçe performansı yüksek bir modelle test yapın. Aynı veri üzerinde 10–20 örnek sorgu ile top-k isabetini ölçerek model seçimi yapın. Gizlilik gereksinimi varsa açık kaynak bir modelle yerelde kalın.

Adım 6 – Vektör veritabanı kurulumu: Chroma ile hızlı prototip, Qdrant/Milvus ile üretim kurulumu yapın. İndeks parametrelerinde HNSW grafı ve uygun M, efConstruction değerlerini deneyerek gecikme-doğruluk dengesini bulun.

Adım 7 – İndeksleme: Parçaları gömleyip veritabanına yazın. Versiyonlama yapın; her yüklemeye bir batch_id vererek geri alım (rollback) kolaylığı sağlayın. Büyük yüklemelerde artımlı (incremental) indekslemeyi tercih edin.

Adım 8 – Sorgu boru hattı: Kullanıcı sorgusunu önce query rewriting ile netleştirin (gerekiyorsa çoklu sorgu üretimi). Ardından hibrit arama yapın, ilk 20 sonucu alın, bir reranker ile en iyi 5–7 bağlamı seçin. MMR ile çeşitlilik sağlayın.

Adım 9 – Prompt tasarımı: Sistem mesajına “Sadece verilen bağlamdan yanıtla, emin değilsen ‘elimdeki kaynaklarda yok’ de” gibi kurallar koyun. Yanıt sonunda Kaynaklar bölümünde belge adı ve bölüm başlığını listeleyin.

Adım 10 – Değerlendirme: 50–100 soruluk altın set hazırlayın. Ölçütler: cevap alaka puanı, bağlam isabeti, kaynak doğruluğu, gecikme, maliyet. Otomatik değerlendirme için küçük bir script ile yanıt-kaynak uyuşumunu ölçebilirsiniz.

Adım 11 – Yayına alma: FastAPI ile bir servis oluşturun. Redis önbellekle sık soruların yanıtlarını tutun. Yüksek trafikte rate limit ve tamamlama uzunluğu sınırlamaları önemli. Gözlemlenebilirlik için OpenTelemetry ile izleme kurun.

Adım 12 – Güvenlik ve gizlilik: Hassas verileri indekslemeden önce PII maskesi uygulayın. Vektör veritabanını özel ağda tutun. Kullanıcı bazlı yetkilendirme yapıyorsanız sorgu sırasında metadata filtreleri ile erişim kısıtlayın.

Performans ipuçları

- Top-k değerini rastgele yükseltmek yerine hibrit arama + reranker kullanın; maliyeti ve gecikmeyi düşürür.

- Çok uzun bağlamlar yerine 5–7 yüksek kaliteli pasaj verin; LLM’ler daha odaklı yanıtlar üretir.

- Maliyet kritikse önce hızlı bir modelle taslak, ardından önemli akışlarda daha güçlü bir modelle doğrulama yapın.

- Türkçe’de eşanlam ve ekler önemlidir; sorgu genişletme (synonym expansion) ve kök bulma (stemming/lemmatization) deneyin.

Sık karşılaşılan hatalar

- Kaynak sızıntısı: Yanıtlarda kapalı belge adlarının görünmesi. Çözüm: metadata’yı kullanıcı rolüne göre filtreleyin ve prompt’ta kaynak gösterimini maskeleyin.

- Aşırı uzun parçalar: Gömlemelerin ayrıştırıcılığı düşer. 300–500 kelime aralığını aşmamaya çalışın.

- Zayıf gömleme modeli: Çok dilli ama Türkçe’de zayıf bir model, arama kalitesini bozar. Küçük bir değerlendirme seti ile model seçimi yapın.

Sonuç

RAG, Türkçe kurumsal dokümanlarda güvenilir ve kaynaklanabilir yanıtlar üretmenin en pratik yolu. Doğru gömleme, hibrit arama, reranking ve titiz prompt tasarımıyla, hem doğruluğu hem de kullanıcı güvenini önemli ölçüde artırabilirsiniz. Küçük bir prototiple başlayıp ölçümlere göre adım adım optimize edin; doğru mimariyle RAG tabanlı asistanınız kısa sürede üretim kalitesine ulaşacaktır.

RAG Tabanlı Kendi Yapay Zekâ Asistanınızı Kurun: LangChain ve LlamaIndex ile Adım Adım Rehber

Üretken yapay zekâ (GenAI) uygulamaları hızla yaygınlaşırken, doğru ve güncel bilgiye dayalı yanıtlar üretmek için en çok konuşulan yaklaşım RAG (Retrieval-Augmented Generation) oldu. Bu yazıda, RAG nedir, hangi durumlarda kullanılır, hangi araçları tercih etmelisiniz ve LangChain ile LlamaIndex kullanarak nasıl adım adım bir RAG hattı (pipeline) kurabilirsiniz sorularına pratik ve güncel bir rehberle yanıt vereceğim.

RAG nedir ve neden önemli? Klasik büyük dil modelleri yalnızca eğitim verisiyle sınırlıdır ve güncelliği hızla kaybedebilir. RAG, modelin yanıt üretmeden önce bir vektör veritabanından ilgili belgeleri geri çağırmasını (retrieval) sağlar. Bu sayede hem güncel hem de şirket içi özel bilgilere dayalı doğru, kaynaklı ve denetlenebilir yanıtlar üretirsiniz. Özellikle doküman asistanları, müşteri destek botları, teknik bilgi tabanı arayüzleri ve kurumsal arama projelerinde RAG çok etkili bir çözümdür.

Gereksinimler ve genel mimari Basit bir RAG hattı için üç bileşen gerekir: (1) Metinlerinizi parçalara (chunk) ayırıp sayısal vektörlere dönüştüren bir gömme (embedding) modeli; (2) Bu vektörleri saklayıp benzerlik araması yapan bir vektör veritabanı; (3) Geri çağrılan metinleri kullanıp yanıt üreten bir LLM. Ek olarak, yeniden sıralama (reranking), sorgu genişletme (query expansion) ve değerlendirme (eval) katmanlarıyla kaliteyi artırabilirsiniz.

Vektör veritabanı seçimi Başlangıç için gömülü ve kurulumu kolay Chroma iyi bir seçenek. Hafif, hızlı ve yerelde deney yapmak için ideal. FAISS, tek makinede yüksek performanslı aramalar için tercih edilebilir. Üretim ortamlarında ise Pinecone, Weaviate, Qdrant gibi servisler ölçeklenebilirlik ve yönetim kolaylığı sunar. Seçimde verinizin büyüklüğü, gecikme ihtiyaçları, bütçe ve regülasyon gereksinimlerini dikkate alın.

Embedding modeli seçimi Ücretli ve yüksek kaliteli bir seçenek arıyorsanız OpenAI’nin text-embedding-3-large modeli güçlü bir taban sunar. Açık kaynak tarafta bge-large, e5-large veya instructor-xl aileleri yaygın ve iyi sonuç veriyor. Türkçe performansı kritikse çok dilli destek sunan modelleri tercih edin ve mümkünse küçük bir doğrulama kümesi üzerinde kısa bir A/B testi yapın.

Parçalama stratejisi (chunking) Parça boyutu ve bindirme (overlap) kaliteyi doğrudan etkiler. 300–800 karakter aralığı genelde güvenli bir başlangıçtır; teknik belgelerde 1000–1500 karaktere çıkmak bağlam bütünlüğünü korumaya yardımcı olabilir. 10–20% arası bindirme, cümlelerin iki parça arasında bölünmesini yumuşatır.

LangChain ile hızlı başlangıç

LangChain, veri yükleme, parçalama, embedding, vektör dizinleme ve sorgulama adımlarını modüler şekilde birleştirmenizi kolaylaştırır. Pratik akış şu şekildedir: Belgeleri yükleyin, metinleri parçalara ayırın, embedding üretin, Chroma’ya kaydedin, ardından bir RetrievalQA zinciri oluşturun. Örnek kurulum adımı olarak komut satırında pip install langchain chromadb sentence-transformers komutunu kullanabilirsiniz. Basit bir sorgu akışı ise şu mantıkta ilerler: retriever.get_relevant_documents(soru) ile ilgili parçaları alın, ardından llm.invoke(prompt + bağlam) ile yanıt üretin. LangChain’in Runnable ve LCEL (LangChain Expression Language) soyutlamaları, üretim ortamında gözlemlenebilir, loglanabilir ve test edilebilir zincirler kurmayı kolaylaştırır.

Artıları: Zengin entegrasyon ekosistemi, güçlü zincir soyutlamaları, hızlı prototipleme. Eksileri: Çok modüllü yapı karmaşıklığa yol açabilir; versiyon uyumluluğuna dikkat etmek gerekir.

LlamaIndex ile belgeden yanıta

LlamaIndex, endekse odaklı bir tasarım sunar ve doküman odaklı akışlarda sade bir deneyim sağlar. Document ve Node yapılarıyla parça yönetimi şeffaftır; ServiceContext ile LLM ve embedding ayarlarını merkezi olarak kontrol edersiniz. Özet akış şudur: Belgeleri okuyun, VectorStoreIndex oluşturun, ardından query_engine veya chat_engine üzerinden sorgulayın. Basit bir kurulum için pip install llama-index chromadb yeterlidir. LlamaIndex ayrıca reranker ve response synthesizer yapılarıyla çıktı kalitesini artırmak için gömülü seçenekler sunar.

Artıları: Doküman merkezli tasarım, hızlı “belgeden yanıta” kurulum, iyi dokümantasyon. Eksileri: Çok özel iş akışlarında esneklik için ek özelleştirme gerekebilir; bazı ileri seviye özellikler sürümlere göre değişebilir.

Kaliteyi artırma teknikleri

Sorgu genişletme: Kullanıcının kısa sorusunu, olası eşanlamlılar ve bağlamla zenginleştirerek arama kalitesini artırabilirsiniz. RAG-Fusion veya çoklu sorgu tekniğiyle farklı varyantları arayıp birleştirmek iyi sonuç verir.

HyDE (Hypothetical Document Embeddings): Modelden, soruya dair “varsayımsal bir cevap” üretmesini isteyip bunu embedding’e çevirerek arama yapın; özellikle belgenin dili ile soru dili farklı olduğunda işe yarar.

Yeniden sıralama (Reranking): İlk 10 sonucu aldıktan sonra bir reranker modeliyle en iyi 3–5 sonucu seçin. Açık kaynak bge-reranker veya bulut tabanlı hizmetler (ör. Cohere Rerank) yaygın tercih edilir.

İstem (prompt) şablonları: Kaynakları listelemeyi zorunlu kılan, halüsinasyonu azaltan net yönergeler kullanın. Örnek: “Yanıtlarken yalnızca verilen bağlamı kullan. Emin değilsen ‘Bu bilgi bağlamda yok’ de. En sonda kullandığın kaynak başlıklarını sırala.”

Değerlendirme ve gözlemlenebilirlik

RAG projelerinde değerlendirme kritik önemdedir. Küçük ama temsil gücü yüksek bir test seti oluşturun. Doğruluk, alaka, kaynak kapsamı, yanıt uzunluğu ve gecikme gibi metrikleri izleyin. RAGAS gibi değerlendirme çerçeveleri yararlıdır. Üretimde ise isabet oranı, geri çağırma (recall), oturum başına iyi yanıt oranı ve kullanıcı memnuniyeti (thumbs up/down) gibi iş metriklerini takip edin.

Güvenlik, maliyet ve gizlilik

Kurumsal verilerle çalışırken erişim kontrolü, PII maskeleme ve denetim kayıtları (audit logs) şarttır. Maliyet tarafında embedding üretimi ve vektör arama en büyük kalemler olabilir; partisyonlama, sıkıştırma (PQ/IVF) ve önbellekleme ile maliyeti düşürün. Gizlilik gereksinimi yüksekse açık kaynak embedding ve yerel vektör veritabanı ile tamamen şirket içi (on-prem) kurulum yapılabilir.

Sonuç RAG, üretken yapay zekâyı pratik ve güvenilir hale getiren güçlü bir yöntemdir. Hızlı prototipleme için LangChain ve LlamaIndex iki sağlam seçenektir: İlki geniş entegrasyonları ve zincir mimarisiyle esneklik sunarken, ikincisi doküman odaklı basitliğiyle hızlı değer üretir. Doğru embedding, uygun vektör veritabanı, dikkatli chunking ve iyi bir değerlendirme disipliniyle kısa sürede, şirket verinizle konuşabilen sağlam bir asistan inşa edebilirsiniz.