Claude Kullanarak RAG Sistemi Nasıl Oluşturulur: Kendi Verilerinizle Çalışan Bir Yapay Zeka (Tam Kılavuz)

Claude'a şirketiniz, notlarınız veya dosyalarınız hakkında soru sorduğunuzda boş bir cevap alırsınız. Claude onları hiç görmedi. Sadece eğitim sırasında öğrendiklerini bilir ve sizin bilgileriniz bunun bir parçası değildir.

Bir RAG sistemi bunu düzeltir. Claude hafızasından cevap vermek yerine, önce belgelerinizde arar, önemli kısımları alır ve bulduklarına dayanarak cevap verir. Sizin veriniz, onun kaynağı, tahmin yok.

Neden dosyaları doğrudan sohbete yapıştırmaktan daha iyidir:

Ölçeklenebilir. Tüm bilgi birikiminiz tek bir sohbete sığmaz. RAG her şeyi depolar ve her soru için yalnızca gerekeni çeker.

Daha ucuzdur. Bir dosyayı yapıştırmak, Claude'un her soruda tüm dosyayı yeniden okuması anlamına gelir. RAG ise dosyayı bir kez okur ve yalnızca ilgili kısmı getirir. Her seferinde 10.000 tokenlik bir kılavuz göndermek yerine, ihtiyacınız olan tam bölümün 500 tokenini gönderebilir. Gerçek kullanım senaryolarında token kullanımı %80 veya daha fazla azalır.

Daha keskindir. Modele devasa bir metin duvarı beslediğinizde ortadaki detayları kaybeder. Birkaç hassas parça verdiğinizde ise cevaplar daha doğru olur.

Güncel kalır. Dosyalarınızı bir kez güncellersiniz, sistem yeni sürümü kullanır. Tekrar yapıştırmaya gerek kalmaz.

Bu kılavuzun sonunda, kendi dosyalarınızda çalışan bir sisteme adım adım sahip olacaksınız. Doktora gerek yok.

İhtiyacınız olanlar

Herhangi bir koda dokunmadan önce, tam liste burada. İyi haber: bu sürüm yalnızca bir API anahtarı gerektiriyor ve geri kalan her şey kendi bilgisayarınızda ücretsiz çalışıyor.

1. Python 3.9 veya daha yenisi. Olup olmadığını kontrol etmek için terminalinizi açın (Mac'te Terminal, Windows'ta Komut İstemi) ve python --version yazın. 3.11 gibi bir şey görürseniz sorun yok. Değilse, python.org adresinden indirin ve yükleyiciyi çalıştırın. Windows'ta kurulum sırasında "Add Python to PATH" kutusunu işaretleyin, aksi takdirde aşağıdaki komutlar çalışmaz.

2. Bir Claude API anahtarı ve küçük bir bakiye. Bu, kılavuzun ihtiyaç duyduğu tek anahtar ve tek para. İşte tam yol, tıklama tıklama:

platform.claude.com adresine gidin ve orada oturum açın (veya kaydolun).

API'nin çalışması için pozitif bir bakiyeye ihtiyacı vardır, bu yüzden önce fon ekleyin. İstendiğinde, kredilerin kendiniz için mi yoksa bir şirket için mi olduğunu seçin, ardından ödeme ekranına gelirsiniz. $5 "Başlangıç" seçeneğini seçin. Bu fazlasıyla yeterli: bu kılavuzdaki her şey ücretsiz ve yerel, bu nedenle para harcayan tek şey Claude ve her soru size bir sentin çok küçük bir kısmına mal olur. Krediler satın alma tarihinden itibaren bir yıl sonra sona erer.

Ödeme yaptıktan sonra Konsol panelinize yönlendirileceksiniz. Bakiyenizi (örneğin $5.00) sol üstte "Kuruluş kredileri" altında görmelisiniz.

Şimdi anahtarı alın. API Anahtarı Al'a (sağ üst) ve ardından Anahtar Oluştur'a tıklayın. İstediğiniz bir ad verin (örneğin rag-anahtarim) ve çalışma alanını Varsayılan olarak bırakın. Oluştur'a tıklayın ve size gösterilen dizeyi kopyalayın. sk-ant- ile başlar ve yalnızca bir kez görürsünüz, bu yüzden bir dakikalığına güvenli bir yere yapıştırın.

Tüm kurulum bu kadar.

Adım 1: Anahtarınızı ekleyin ve dosyalarınızı yükleyin

1. Proje klasörünü oluşturun. Masaüstünüzde yeni bir klasör oluşturun ve adını rag-projesi koyun. Her şey buraya gidecek.

2. Terminalinizi açın. Mac'te: Cmd+Boşluk, Terminal yazın, enter. Windows'ta: Başlat düğmesi, cmd yazın, enter.

3. Terminali klasörünüze yönlendirin. cd ve bir boşluk yazın, ardından rag-projesi klasörünü terminal penceresine sürükleyin ve enter tuşuna basın. Aşağıdaki her komut bu klasörün içinden çalıştırılır.

1cd Desktop/rag-projesi

4. Araçları yükleyin. Bunu terminalinize yapıştırın ve enter tuşuna basın (ilk çalıştırma bir dakika sürebilir):

1pip install anthropic chromadb sentence-transformers pypdf python-dotenv

pip: komut bulunamadı hatası alırsanız, pip yerine pip3 kullanın. Terminal kırmızı hata olmadan yeni bir satır gösterdiğinde işlem tamamdır.

5. Kod dosyanızı oluşturun. rag-projesi klasörünün içinde, tam olarak rag.py adında boş bir dosya oluşturun. Herhangi bir metin düzenleyicide açın.

6. Anahtar dosyanızı oluşturun. Aynı klasörde, tam olarak .env adında bir dosya oluşturun (nokta ile başlar, önünde ad yok). Bunun içine, kurulum sırasında oluşturduğunuz gerçek anahtarı = işaretinden sonra, boşluk veya tırnak işareti olmadan yapıştırın:

1ANTHROPIC_API_KEY=sk-ant-gercek-anahtarinizi-buraya-yapistirin

Anahtarı .env dosyasında tutmak, kodu paylaşırsanız veya GitHub'a koyarsanız sızmasını engeller.

7. Anahtarı yükleyin. Bunu rag.py dosyasının en üstüne koyun:

1import os
2from dotenv import load_dotenv
3
4load_dotenv()  # .env dosyanızı okur
5api_key = os.getenv("ANTHROPIC_API_KEY")

8. Bilgi tabanınızı oluşturun. rag-projesi klasörünün içinde belgeler adında bir klasör oluşturun. İçine .txt, .md veya .pdf dosyaları atın: notlarınız, bir ürün belgesi, toplantı özetleri, herhangi bir şey.

8.1. Henüz dosyanız yoksa bu test dosyasını kullanın. belgeler klasörünün içinde notes.txt dosyası oluşturun ve bunu yapıştırın:

Kuzey Yıldızı Projesi, müşteri geri bildirimlerini takip etmek için kullandığımız dahili araçtır. Mart 2026'da başlatılmıştır ve platform ekibi tarafından sürdürülmektedir. Baş mühendis Dana Reyes'tir. Geri bildirimler her Cuma gözden geçirilir. Kuzey Yıldızı, 2025 yılına kadar kullandığımız eski elektronik tablo sisteminin yerini almıştır.

Sonunda Claude'a Kuzey Yıldızı hakkında soru soracak ve bu dosyadan cevap verdiğini göreceksiniz.

9. Dosyalarınızı okuyan kodu ekleyin. rag.py dosyasında, 7. adımdaki kodun altına:

1from pathlib import Path
2from pypdf import PdfReader
3
4def belgeleri_yukle(klasor="belgeler"):
5    belgeler = []
6    for dosya in Path(klasor).iterdir():
7        if dosya.suffix in [".txt", ".md"]:
8            metin = dosya.read_text(encoding="utf-8")
9            belgeler.append({"kaynak": dosya.name, "metin": metin})
10        elif dosya.suffix == ".pdf":
11            okuyucu = PdfReader(str(dosya))
12            metin = "\n".join(sayfa.extract_text() or "" for sayfa in okuyucu.pages)
13            belgeler.append({"kaynak": dosya.name, "metin": metin})
14    return belgeler
15
16belgeler = belgeleri_yukle()
17print(f"{len(belgeler)} belge yüklendi.")

10. Çalıştırın. rag.py dosyasını kaydedin, ardından terminalinizde:

1python rag.py

Şunu görmelisiniz:

1 belge yüklendi.

0 belge yüklendi yazıyorsa, belgeler klasörü boş veya yanlış yerdedir. Doğrudan rag-projesi klasörünün içinde, rag.py dosyasının yanında olmalıdır.

Adım 2: Dosyalarınızı parçalara bölün

Şu anda her dosya büyük bir metin bloğudur. Arama yapabilmemiz için, onları parçacıklar adı verilen daha küçük parçalara ayırmamız gerekiyor. İşte nedeni: bir soru sorulduğunda, sistem eşleşen parçacıkları bulur ve yalnızca bunları Claude'a gönderir. Parçacıklarınız 50 sayfalık belgeler ise çok fazla gönderirsiniz. Tek cümle iseler bağlamı kaybederler. Küçük paragraflar ideal noktadır.

1. Parçalama kodunu ekleyin. rag.py dosyasında, 10. adımdaki kodun altına:

1def metni_parcala(metin, parca_boyutu=500, ortusme=100):
2    kelimeler = metin.split()
3    parcalar = []
4    baslangic = 0
5    while baslangic < len(kelimeler):
6        bitis = baslangic + parca_boyutu
7        parca = " ".join(kelimeler[baslangic:bitis])
8        parcalar.append(parca)
9        baslangic = bitis - ortusme  # biraz geriye git, böylece parçalar örtüşür
10    return parcalar

Burada anlaşılması gereken iki sayı var, sade anlatımla:

• parca_boyutu=500 her parçanın yaklaşık 500 kelime olduğu anlamına gelir. Tam bir fikri taşıyacak kadar büyük, hassas kalacak kadar küçük.
• ortusme=100 her parçanın kendinden öncekinin son 100 kelimesini tekrarladığı anlamına gelir. Bu önemlidir çünkü bir cevap, iki parçanın birleştiği çizgide olabilir. Örtüşme olmazsa, ortadan ikiye bölünmüş bir cümle kaybolabilir. Örtüşme, hiçbir fikrin boşluğa düşmemesini sağlar.

2. Her belgeyi parçalara dönüştürün. Bunu altına ekleyin:

1tum_parcalar = []
2for belge in belgeler:
3    for parca in metni_parcala(belge["metin"]):
4        tum_parcalar.append({"kaynak": belge["kaynak"], "metin": parca})
5
6print(f"{len(belgeler)} belgeden {len(tum_parcalar)} parça oluşturuldu.")

Her parçanın kaynağını (hangi dosyadan geldiğini) taşıdığına dikkat edin. Bunu yol boyunca bağlı tutarız, böylece Claude daha sonra cevap verirken cevabın hangi dosyadan geldiğini söyleyebilir.

3. Çalıştırın. rag.py dosyasını kaydedin, ardından terminalinizde:

1python rag.py

Şuna benzer bir şey görmelisiniz:

1 belge yüklendi.

1 belgeden 1 parça oluşturuldu.

Küçük test dosyası kısa olduğu için yalnızca bir parça haline gelir. Gerçek belgeler çok sayıda parça üretecektir. Klasöre uzun bir PDF attıysanız, düzinelerce veya yüzlerce parça görebilirsiniz ki bu tam da istediğiniz şeydir.

Adım 3: Parçalarınızı gömme vektörlerine dönüştürün

Bu, bilgisayarın tam kelime eşleşmesi yerine anlam bazında arama yapmasını sağlayan adımdır. Her parça, ne hakkında olduğunu yakalayan bir sayı listesine (bir gömme vektörü) dönüştürülür. Benzer anlama sahip parçalar benzer sayılarla sonuçlanır. Daha sonra, bir soru geldiğinde, soruyu da sayılara dönüştürür ve en yakın eşleşmeleri buluruz.

Bunu yapan model, kendi bilgisayarınızda yerel olarak çalışır. Bir kez indirilir, ardından çevrimdışı ve ücretsiz çalışır ve dosyalarınız asla bilgisayarınızdan ayrılmaz.

1. Gömme modelini yükleyin. rag.py dosyasında, 2. adımdaki kodun altına:

1from sentence_transformers import SentenceTransformer
2
3print("Gömme modeli yükleniyor (ilk çalıştırmada indirilir, yaklaşık 90 MB)...")
4gommeler = SentenceTransformer("all-MiniLM-L6-v2")

Bunu ilk çalıştırdığınızda model indirilir, bu yüzden biraz bekleyin. Sonraki her çalıştırma anında olur çünkü model zaten bilgisayarınızdadır.

2. Her parçayı bir gömme vektörüne dönüştürün. Bunu altına ekleyin:

1parca_metinleri = [parca["metin"] for parca in tum_parcalar]
2vektorler = gommeler.encode(parca_metinleri)
3
4print(f"{len(vektorler)} gömme vektörü oluşturuldu.")
5print(f"Her gömme vektörü {len(vektorler[0])} sayıdan oluşan bir listedir.")

gommeler.encode(...) parça metinlerinizin listesini alır ve her parça için bir gömme vektörü döndürür. Bu kadar basit.

3. Çalıştırın. rag.py dosyasını kaydedin, ardından terminalinizde:

1python rag.py

İlk çalıştırma model indirilirken duraklar, ardından şuna benzer bir şey görmelisiniz:

1 belge yüklendi.

1 belgeden 1 parça oluşturuldu.

Gömme modeli yükleniyor (ilk çalıştırmada indirilir, yaklaşık 90 MB)...

1 gömme vektörü oluşturuldu.

Her gömme vektörü 384 sayıdan oluşan bir listedir.

Bu "384 sayı" satırı, fikrin görünür hale geldiği yerdir: metniniz artık bilgisayarın karşılaştırabileceği bir sayı satırıdır. Bu sayıları kendiniz okumanız veya anlamanız gerekmez. Bir sonraki adımdaki veritabanı tüm karşılaştırmaları sizin için halleder.

İndirme bir bağlantı hatasıyla başarısız olursa, komutu tekrar çalıştırmanız yeterlidir. Kaldığı yerden devam eder.

Adım 4: Her şeyi vektör veritabanınızda saklayın

Şimdi parçaları ve gömme vektörlerini Chroma'ya, yani yerel veritabanınıza koyuyoruz. Aramayı hızlı yapan şey budur: sorunuzu her seferinde elle her parçayla karşılaştırmak yerine, Chroma onları hazır bir şekilde saklar ve eşleştirmeyi sizin için yapar. Bilgisayarınızda bir klasöre kaydeder, bu yüzden onu yalnızca bir kez oluşturursunuz.

1. Veritabanını kurun. rag.py dosyasında, 3. adımdaki kodun altına:

1import chromadb
2
3istemci = chromadb.PersistentClient(path="chroma_vt")
4koleksiyon = istemci.get_or_create_collection("belgelerim")

PersistentClient(path="chroma_vt") Chroma'ya chroma_vt adlı bir klasöre kaydetmesini söyler (otomatik olarak oluşturur, betiğinizin hemen yanında). Diske kaydedildiği için verileriniz betik bittikten sonra da kalır. Bir koleksiyon, parçalarınızın yaşadığı adlandırılmış kutudur.

2. Parçalarınızı veritabanına ekleyin. Bunu altına ekleyin:

1koleksiyon.add(
2    ids=[str(i) for i in range(len(tum_parcalar))],
3    embeddings=[vektor.tolist() for vektor in vektorler],
4    documents=[parca["metin"] for parca in tum_parcalar],
5    metadatas=[{"kaynak": parca["kaynak"]} for parca in tum_parcalar],
6)
7
8print(f"Veritabanında {koleksiyon.count()} parça saklandı.")

İşte her satırın Chroma'ya ne verdiği, sade anlatımla: ids her parçaya benzersiz bir etiket verir (0, 1, 2...), embeddings 3. adımdaki sayılardır, documents gerçek parça metnidir ve metadatas kaynağı daha sonra gösterebilmemiz için dosya adını taşır. Chroma dördünü de birbirine bağlı tutar.

3. Çalıştırın. rag.py dosyasını kaydedin, ardından terminalinizde:

1python rag.py

Şunu görmelisiniz:

Veritabanında 1 parça saklandı.

Daha sonra bilmeniz gereken bir şey. Betiği her çalıştırdığınızda parçaları tekrar ekler, bu nedenle sayılar tekrarlanan çalıştırmalarda artabilir (1, sonra 2, sonra 3...). Bunu inşa ederken sorun yok. Temiz başlamak için chroma_vt klasörünü silin ve bir kez daha çalıştırın. Son sürümde bunu düzgün bir şekilde ele alacağız, böylece ikiye katlanmaz.

Adım 5: Belgelerinizde arama yapın

Bu, RAG'ın "getirme" kısmıdır, adındaki R harfi. Bir soruyu alırız, parçalarla yaptığımız gibi bir gömme vektörüne dönüştürürüz ve Chroma'dan anlamca en yakın olan parçaları isteriz. Bu eşleşen parçalar, bir sonraki adımda Claude'a vereceğimiz şeylerdir.

1. Arama fonksiyonunu ekleyin. rag.py dosyasında, 4. adımdaki kodun altına:

1def ara(soru, n_sonuc=3):
2    soru_vektoru = gommeler.encode([soru])[0]
3    sonuclar = koleksiyon.query(
4        query_embeddings=[soru_vektoru.tolist()],
5        n_results=n_sonuc,
6    )
7    return sonuclar

Bunun ne yaptığı, satır satır sade anlatımla: soruyu parçalarınızda kullandığınız modelle aynı modelle sayılara dönüştürür (bu önemlidir, ikisi de aynı "sayı dilini" konuşmalıdır), ardından Chroma'dan en yakın eşleşmeleri ister. n_results=3 "bana en alakalı 3 parçayı ver" anlamına gelir. Üç iyi bir varsayılandır: yeterli bağlam, token israfı yapacak kadar fazla değil.

2. Bir arama deneyin. Test etmek için bunu altına ekleyin:

1soru = "Kuzey Yıldızı'nı kim yönetiyor ve geri bildirimler ne zaman gözden geçiriliyor?"
2sonuclar = ara(soru)
3
4for i, belge in enumerate(sonuclar["documents"][0]):
5    kaynak = sonuclar["metadatas"][0][i]["kaynak"]
6    print(f"\n--- Eşleşme {i+1} ({kaynak} kaynağından) ---")
7    print(belge)

Bu, veritabanınıza karşı gerçek bir soru çalıştırır ve bulduğu parçaları, her birinin hangi dosyadan geldiğiyle birlikte yazdırır.

3. Çalıştırın. rag.py dosyasını kaydedin, ardından terminalinizde:

1python rag.py

Kuzey Yıldızı test dosyasıyla, eşleşen parçayı geri getirdiğini görmelisiniz, şöyle bir şey:

--- Eşleşme 1 (notes.txt kaynağından) ---

Kuzey Yıldızı Projesi, müşteri geri bildirimlerini takip etmek için kullandığımız dahili araçtır. Mart 2026'da başlatılmıştır ve platform ekibi tarafından sürdürülmektedir. Baş mühendis Dana Reyes'tir. Geri bildirimler her Cuma gözden geçirilir. Kuzey Yıldızı, 2025 yılına kadar kullandığımız eski elektronik tablo sisteminin yerini almıştır.

Az önce ne olduğuna dikkat edin: sorunuz "kim yönetiyor" ve "gözden geçiriliyor" kelimelerini kullandı, ancak dosyada "baş mühendis" ve "her Cuma gözden geçirilir" yazıyor. Yine de eşleşti, çünkü arama tam kelimeler üzerinden değil, anlam üzerinden çalışır. Gömme vektörlerinin tüm amacı budur ve bu nedenle dosyalarınızda yapılan düz bir anahtar kelime aramasından (Ctrl+F) daha iyidir.

Daha fazla dosyanız varsa, en yakın eşleşmeye göre sıralanmış, tüm dosyalardan ilk 3 parçayı göreceksiniz.

Adım 6: Claude'un bulduklarından cevap vermesini sağlayın

Bu, "üretim" kısmıdır, RAG'daki G harfi. 5. adımdaki parçaları alırız, bunları Claude Opus 4.8'e soruyla birlikte veririz ve yalnızca bu bağlamı kullanarak cevap vermesini söyleriz. Tahmin yapmasını engelleyen şey budur: Claude kendi hafızasından değil, dosyalarınızdan cevap verir ve hangi dosyayı kullandığını söyler.

1. Cevap fonksiyonunu ekleyin. rag.py dosyasında, 5. adımdaki kodun altına:

1import anthropic
2
3claude = anthropic.Anthropic(api_key=api_key)
4
5def cevapla(soru):
6    sonuclar = ara(soru)
7    parcalar = sonuclar["documents"][0]
8    kaynaklar = [m["kaynak"] for m in sonuclar["metadatas"][0]]
9
10    baglam = ""
11    for i, parca in enumerate(parcalar):
12        baglam += f"[{kaynaklar[i]} kaynağından]\n{parca}\n\n"
13
14    mesaj = claude.messages.create(
15        model="claude-opus-4-8",
16        max_tokens=1024,
17        system=(
18            "Soruları yalnızca sağlanan bağlamı kullanarak yanıtlıyorsun. "
19            "Cevap bağlamda yoksa bilmediğini söyle. "
20            "Cevabının hangi dosyadan geldiğini her zaman belirt."
21        ),
22        messages=[
23            {
24                "role": "user",
25                "content": f"Bağlam:\n{baglam}\nSoru: {soru}",
26            }
27        ],
28    )
29    return mesaj.content[0].text

Burada olanlar, sade anlatımla: ilgili parçaları ararız, bunları tek bir bağlam bloğu halinde birleştiririz (her biri dosya adıyla etiketlenir), ardından bu bloğu soruyla birlikte Claude'a göndeririz. system talimatı anahtar kısımdır. Claude'a üç şey söyler: yalnızca bağlamdan cevap ver, cevap orada değilse kabul et ve kaynak dosyayı adlandır. Bu üç kural, cevapları uydurma yerine güvenilir kılan şeydir.

model="claude-opus-4-8" tam model adıdır (tireler, nokta değil). max_tokens=1024 cevabın ne kadar uzun olabileceğini sınırlar.

2. Bir soru sorun. Bunu altına ekleyin:

1soru = "Kuzey Yıldızı'nı kim yönetiyor ve geri bildirimler ne zaman gözden geçiriliyor?"
2print(cevapla(soru))

3. Çalıştırın. rag.py dosyasını kaydedin, ardından terminalinizde:

1python rag.py

Dosyanızdan oluşturulmuş gerçek bir cevap almalısınız, şöyle bir şey:

Kuzey Yıldızı Projesi'ni yöneten baş mühendis Dana Reyes'tir ve geri bildirimler her Cuma gözden geçirilir. (Kaynak: notes.txt)

Bu, çalışan tam bir RAG sistemidir. Claude bu dosyayı eğitim sırasında hiç görmedi, Dana Reyes'in kim olduğunu bilemez, ancak doğru cevap verdi ve cevabın tam olarak nereden geldiğini söyledi. Dosyalarınızda olmayan bir şey sorun, cevabı uydurmak yerine bilmediğini söyleyecektir. Bu "bilmiyorum" bir özelliktir, bir hata değil: güvenebileceğiniz bir araç ile tahmin yapan bir araç arasındaki farktır.

Adım 7: Gerçekten kullanabileceğiniz bir şeye dönüştürün

Şu anda her soru sormak istediğinizde kodu düzenlemeniz ve tüm betiği yeniden çalıştırmanız gerekiyor. Daha da kötüsü, her çalıştırma dosyalarınızı yeniden okur ve veritabanına yeniden ekler, böylece parçalar birikir. İkisini de düzeltelim: veritabanını yalnızca bir kez oluşturun, ardından soruları döngü halinde, doğrudan terminale yazarak sorun.

1. Çift eklemeyi düzeltin. 4. adımdan parçaları ekleyen bloğu bulun (koleksiyon.add(...) kısmı) ve bunu, veritabanını yalnızca boşsa oluşturan bu sürümle değiştirin:

1if koleksiyon.count() == 0:
2    koleksiyon.add(
3        ids=[str(i) for i in range(len(tum_parcalar))],
4        embeddings=[vektor.tolist() for vektor in vektorler],
5        documents=[parca["metin"] for parca in tum_parcalar],
6        metadatas=[{"kaynak": parca["kaynak"]} for parca in tum_parcalar],
7    )
8    print(f"Veritabanında {koleksiyon.count()} parça saklandı.")
9else:
10    print(f"Veritabanında zaten {koleksiyon.count()} parça var, yeniden oluşturma atlanıyor.")

Artık ağır iş (dosyaları okuma, gömme vektörleri oluşturma, veritabanını doldurma) yalnızca ilk seferde olur. Sonraki çalıştırmalar doğrudan cevaplamaya geçer.

2. Soru döngüsünü ekleyin. rag.py dosyasının en altında, 6. adımdaki tek test sorusunu bununla değiştirin:

1print("\nBelgeleriniz hakkında bir soru sorun (çıkmak için 'quit' yazın).\n")
2
3while True:
4    soru = input("Siz: ")
5    if soru.lower() in ["quit", "exit"]:
6        break
7    print("\nClaude: " + cevapla(soru) + "\n")

input("Siz: ") bir soru yazıp enter tuşuna basmanızı bekler. while True devam etmesini sağlar, böylece istediğiniz kadar soru sorabilirsiniz. quit yazmak durdurur.

3. Çalıştırın. rag.py dosyasını kaydedin, ardından terminalinizde:

1python rag.py

Artık dosyalarınızla konuşabilirsiniz:

Belgeleriniz hakkında bir soru sorun (çıkmak için 'quit' yazın).

Siz: Kuzey Yıldızı'ndaki baş mühendis kim?

Claude: Kuzey Yıldızı Projesi'ndeki baş mühendis Dana Reyes'tir. (Kaynak: notes.txt)

Siz: neyin yerini aldı?

Claude: Kuzey Yıldızı, 2025 yılına kadar kullanılan eski elektronik tablo sisteminin yerini aldı. (Kaynak: notes.txt)

Siz: quit

Bu, tamamlanmış RAG sisteminizdir. Dosyalarınızı bir kez okur, hatırlar ve onlar hakkında sorulan soruları her seferinde kaynağıyla birlikte anında yanıtlar.

Yeni dosyalar eklediğinizde bilmeniz gereken bir şey. Veritabanı artık yalnızca bir kez oluşturulduğu için, belgeler klasörüne yeni dosyalar atmak otomatik olarak görünmez. Yeni dosyaları yüklemek için chroma_vt klasörünü silin ve betiği bir kez çalıştırın. Klasördeki her şeyle sıfırdan yeniden oluşturur.

İsteğe bağlı: Tarayıcınızda bir sohbet penceresi verin

Terminal işe yarar, ancak gerçek bir sohbet penceresi istiyorsanız, Streamlit yaklaşık 20 satırda bir tane ekler.

1. Yükleyin. Terminalinizde:

1pip install streamlit

2. Aynı klasörde app.py dosyası oluşturun ve bunu yapıştırın. rag.py dosyanızdaki cevapla fonksiyonunu yeniden kullanır:

1import streamlit as st
2from rag import cevapla
3
4st.title("Belgelerinizle sohbet edin")
5
6if "gecmis" not in st.session_state:
7    st.session_state.gecmis = []
8
9soru = st.chat_input("Dosyalarınız hakkında sorun...")
10
11if soru:
12    yanit = cevapla(soru)
13    st.session_state.gecmis.append((soru, yanit))
14
15for s, y in st.session_state.gecmis:
16    st.chat_message("user").write(s)
17    st.chat_message("assistant").write(y)

3. Çalıştırın. Terminalinizde (not: streamlit run, python değil):

1streamlit run app.py

Tarayıcınızda otomatik olarak bir sohbet penceresi açar. Bir soru yazın, kaynağıyla birlikte cevap alın, tıpkı terminal gibi ama görünüşü daha hoş.

Bir not: bunun çalışması için, 7. adımdaki soru döngüsünün içe aktarma sırasında çalışmaması gerekir. rag.py dosyasının altındaki bu döngüyü if __name__ == "__main__": ile sarın, böylece yalnızca rag.py dosyasını doğrudan çalıştırdığınızda tetiklenir, app.py onu içe aktardığında değil.

Genel soruları da yanıtlamasına izin verme

Genel soruları da yanıtlamasını istiyorsanız. Şu anda sistem yalnızca dosyalarınızdan yanıt verir, bu nedenle "Venezuela'nın başkenti neresidir?" gibi bir soru "belgelerde yok" yanıtını alır, oysa Claude cevabı bilir. Kendi bilgisini kullanmasını istiyorsanız, rag.py dosyasını açın, 6. adımdaki system=(...) bloğunu bulun ve şu satırı değiştirin:

1"Cevap bağlamda değilse, bilmediğini söyle."

bunun için:

1"Cevap bağlamda değilse, kendi genel bilginden yanıtla ama bunu yaptığını söyle."

Kaydet ve yeniden çalıştır. Artık önce dosyalarından yanıt verir, dosyalar kapsamadığında genel bilgiye başvurur ve hangisini kullandığını söyler.

Toparlarken

Az önce çalışan bir RAG sistemi inşa ettin. Kendi dosyalarını okur, önemli kısımları bulur ve Claude'a her seferinde tam kaynağıyla birlikte onlardan yanıt vermesini sağlar. Aynı kurulum, birkaç nottan tüm bilgi tabanına kadar ölçeklenir.

Buradan itibaren istediğin yere yönlendirebilirsin: Obsidian depon, iş belgelerin, kaydettiğin araştırmalar. Dosyaları içine at, bir kez yeniden oluştur ve sormaya başla. Burada öğrendiğin her şey, parçalar, gömme işlemleri, arama, yanıt, gördüğün her 'belgelerinle sohbet' aracının arkasındaki aynı temel yapı.

Bu faydalı olduysa, profilime git ve takip et. Teknoloji, yapay zeka ve gerçekten çalışan sistemler hakkında yazıyorum.

Ciao,

@undefinedKi