Update rag_pipeline.py

rag_pipeline.py

@@ -1,367 +1,153 @@
 # rag_pipeline.py
-import os, json, re
+import os, json, re, shutil, requests
 from typing import List, Dict, Tuple
 from functools import lru_cache
-from pathlib import Path
-
 import faiss
 import numpy as np
-from huggingface_hub import hf_hub_download
-
+from huggingface_hub import hf_hub_download, hf_hub_url
 from providers import embed, generate, rerank, qa_extract
 
 # =========================
-# Dosya yolları ve sabitler
+# Genel ayarlar
 # =========================
-
-# Çalışma kökü (Space içinde /home/user/app)
-APP_ROOT = Path.cwd()
-
-# Varsayılan vektör klasörü
-VSTORE_DIR = APP_ROOT / "vectorstore"
-FAISS_FILE = "index.faiss"
-META_JSONL = "meta.jsonl"
-
-# Hız / kalite ayarları
-TOP_K_DEFAULT     = 4
-FETCH_K_DEFAULT   = 16
-HNSW_EFSEARCH     = 32
-HIGH_SCORE_THRES  = 0.78
-MARGIN_THRES      = 0.06
-
-CTX_CHAR_LIMIT    = 1400
-QA_SCORE_THRES    = 0.25
-QA_PER_PASSAGES   = 4
-
-W_TITLE_BOOST     = 0.25
-W_LEXICAL         = 0.15
+HNSW_EFSEARCH = 32
+TOP_K_DEFAULT = 4
+FETCH_K_DEFAULT = 16
+CTX_CHAR_LIMIT = 1400
+QA_SCORE_THRES = 0.25
+QA_PER_PASSAGES = 4
+HIGH_SCORE_THRES = 0.78
+MARGIN_THRES = 0.06
+W_TITLE_BOOST = 0.25
+W_LEXICAL = 0.15
 
 # =========================
-# Kural-tabanlı yardımcılar
+# Yardımcı regex’ler
 # =========================
-
 DATE_RX = re.compile(
     r"\b(\d{1,2}\s+(Ocak|Şubat|Mart|Nisan|Mayıs|Haziran|Temmuz|Ağustos|Eylül|Ekim|Kasım|Aralık)\s+\d{3,4}"
     r"|\d{1,2}\.\d{1,2}\.\d{2,4}"
     r"|\d{4})\b",
     flags=re.IGNORECASE,
 )
-DEATH_KEYS = ["öldü", "vefat", "hayatını kaybet", "ölümü", "ölüm"]
-FOUND_KEYS = ["kuruldu", "kuruluş", "kurulmuştur", "kuruluşu", "kuruluş tarihi"]
-
-def _split_sentences(txt: str) -> List[str]:
-    parts = re.split(r"(?<=[.!?])\s+", (txt or "").strip())
-    return [p.strip() for p in parts if p.strip()]
-
-def _extract_fact_sentence(query: str, hits: List[Dict]) -> Tuple[str, str]:
-    q = (query or "").lower()
-    if "ne zaman" not in q:
-        return "", ""
-    if any(k in q for k in ["öldü", "vefat", "ölümü", "ölüm"]):
-        keylist = DEATH_KEYS
-    elif any(k in q for k in ["kuruldu", "kuruluş"]):
-        keylist = FOUND_KEYS
-    else:
-        keylist = DEATH_KEYS + FOUND_KEYS
-
-    for h in hits:
-        sents = _split_sentences(h.get("text", ""))
-        for s in sents:
-            if any(k in s.lower() for k in keylist) and DATE_RX.search(s):
-                return s, h.get("source", "")
-    return "", ""
-
-# =========================
-# İsim normalizasyonu
-# =========================
-
-NAME_RX = re.compile(r"\b([A-ZÇĞİIÖŞÜ][a-zçğıiöşü]+(?:\s+[A-ZÇĞİIÖŞÜ][a-zçğıiöşü]+){0,3})\b")
-
-def _expand_named_span(answer: str, hits: List[Dict]) -> str:
-    ans = (answer or "").strip()
-    if not ans or len(ans.split()) > 2:
-        return ans
-
-    ans_low = ans.lower()
-    preferred_aliases = [
-        "Mustafa Kemal Atatürk",
-        "Sabiha Gökçen",
-        "İsmet İnönü",
-    ]
-    for h in hits:
-        text = h.get("text", "")
-        for alias in preferred_aliases:
-            if alias.lower().find(ans_low) != -1 and alias in text:
-                return alias
-
-    best = ans
-    for h in hits:
-        for sent in _split_sentences(h.get("text", "")):
-            if ans_low not in sent.lower():
-                continue
-            for m in NAME_RX.finditer(sent):
-                cand = m.group(1).strip()
-                if ans_low in cand.lower() and any(ch.islower() for ch in cand):
-                    if len(cand.split()) >= len(best.split()):
-                        best = cand
-    return best
+DEATH_KEYS = ["öldü", "vefat", "ölümü", "ölüm"]
+FOUND_KEYS = ["kuruldu", "kuruluş", "kurulmuştur"]
 
 # =========================
-# Vektör deposunu yükle
+# Yardımcı fonksiyonlar
 # =========================
+def _split_sentences(txt: str) -> List[str]:
+    return [p.strip() for p in re.split(r"(?<=[.!?])\s+", (txt or "").strip()) if p.strip()]
 
-def _ensure_local_file(rel_path: str) -> Path:
-    """
-    Eğer ./vectorstore/<dosya> yoksa, aynı Space reposundan indir.
-    REPO_ID otomatik olarak SPACE_ID (owner/space) ile doldurulur.
-    """
-    local_path = APP_ROOT / rel_path
-    if local_path.exists():
-        return local_path
-
-    local_path.parent.mkdir(parents=True, exist_ok=True)
+def _try_local_paths(vstore_dir: str) -> Tuple[str, str]:
+    faiss_file = os.path.join(vstore_dir, "index.faiss")
+    meta_file = os.path.join(vstore_dir, "meta.jsonl")
+    if os.path.exists(faiss_file) and os.path.exists(meta_file):
+        return faiss_file, meta_file
+    return "", ""
 
-    repo_id = os.environ.get("REPO_ID") or os.environ.get("SPACE_ID")
-    if not repo_id:
-        raise FileNotFoundError(
-            f"'{rel_path}' bulunamadı ve REPO_ID/SPACE_ID çevre değişkeni setli değil."
-        )
+def _download_from_hub(repo_id: str, remote_path: str, local_path: str) -> bool:
+    """FAISS veya meta dosyasını Hugging Face Space deposundan indirir."""
+    os.makedirs(os.path.dirname(local_path), exist_ok=True)
 
+    # 1) hf_hub_download dene
     try:
-        # hf_hub_download hedef dosyayı tmp'e indirir; biz local_path'e kopyalarız
-        downloaded = hf_hub_download(
-            hf_hub_download(
+        tmp = hf_hub_download(
             repo_id=repo_id,
             repo_type="space",
             filename=remote_path,
             local_dir=os.path.dirname(local_path),
             local_dir_use_symlinks=False,
             force_download=True
-)
-        )
-        return Path(downloaded)
-    except Exception as e:
-        raise FileNotFoundError(
-            f"'{rel_path}' indirilemedi veya bulunamadı. Lütfen bu dosyayı Space deposunda "
-            f"'vectorstore/' klasörüne yükleyin. Ayrıntı: {e}"
         )
+        if os.path.abspath(tmp) != os.path.abspath(local_path):
+            shutil.copyfile(tmp, local_path)
+        return os.path.exists(local_path)
+    except Exception:
+        pass
+
+    # 2) fallback: doğrudan URL
+    try:
+        url = hf_hub_url(repo_id=repo_id, filename=remote_path, repo_type="space")
+        with requests.get(url, stream=True, timeout=60) as r:
+            r.raise_for_status()
+            with open(local_path, "wb") as f:
+                for chunk in r.iter_content(1024 * 1024):
+                    if chunk:
+                        f.write(chunk)
+        return os.path.exists(local_path) and os.path.getsize(local_path) > 0
+    except Exception:
+        return False
+
+# =========================
+# Vektör deposu yükleme
+# =========================
+def load_vectorstore(vstore_dir: str = "vectorstore") -> Tuple[faiss.Index, List[Dict]]:
+    os.makedirs(vstore_dir, exist_ok=True)
 
-def load_vectorstore(vstore_dir: str | Path = VSTORE_DIR) -> Tuple[faiss.Index, List[Dict]]:
-    """
-    Önce yerelden yükler; yoksa aynı Space’ten indirip kaydeder.
-    app.py içinden hiçbir ek değişiklik yapmadan çalışır.
-    """
-    vstore_dir = Path(vstore_dir)
-    faiss_rel  = str(Path("vectorstore") / FAISS_FILE)
-    meta_rel   = str(Path("vectorstore") / META_JSONL)
+    faiss_path, meta_path = _try_local_paths(vstore_dir)
+    if not (faiss_path and meta_path):
+        repo_id = os.getenv("HF_SPACE_REPO_ID") or "ecceembusra/turkish-wikipedia-rag"
+        faiss_path = os.path.join(vstore_dir, "index.faiss")
+        meta_path = os.path.join(vstore_dir, "meta.jsonl")
 
-    # Yereli sağlama/alma
-    faiss_path = _ensure_local_file(faiss_rel)
-    meta_path  = _ensure_local_file(meta_rel)
+        ok1 = _download_from_hub(repo_id, "vectorstore/index.faiss", faiss_path)
+        ok2 = _download_from_hub(repo_id, "vectorstore/meta.jsonl", meta_path)
 
-    # FAISS index
-    index = faiss.read_index(str(faiss_path))
+        if not (ok1 and ok2):
+            raise FileNotFoundError(
+                "'vectorstore/index.faiss' indirilemedi veya bulunamadı.\n"
+                "Lütfen bu dosyaları Space deposunda 'vectorstore/' klasörüne yükleyin "
+                "veya Settings → Variables & secrets altında HF_SPACE_REPO_ID değişkenini ekleyin."
+            )
+
+    index = faiss.read_index(faiss_path)
     try:
         index.hnsw.efSearch = HNSW_EFSEARCH
     except Exception:
         pass
 
-    # Kayıtları oku
-    records: List[Dict] = []
+    records = []
     with open(meta_path, "r", encoding="utf-8") as f:
         for line in f:
             obj = json.loads(line)
-            records.append({
-                "text": obj.get("text", ""),
-                "title": (obj.get("metadata") or {}).get("title", ""),
-                "source": (obj.get("metadata") or {}).get("source", ""),
-            })
+            records.append({"text": obj.get("text", ""), "metadata": obj.get("metadata", {})})
 
     if not records:
         raise RuntimeError("meta.jsonl boş görünüyor.")
     return index, records
 
 # =========================
-# Anahtar kelime çıkarımı + lexical puan
-# =========================
-
-_CAP_WORD = re.compile(r"\b([A-ZÇĞİIÖŞÜ][a-zçğıiöşü]+(?:\s+[A-ZÇĞİIÖŞÜ][a-zçğıiöşü]+)*)\b")
-
-def _keywords_from_query(q: str) -> List[str]:
-    q = (q or "").strip()
-    caps = [m.group(1) for m in _CAP_WORD.finditer(q)]
-    nums = re.findall(r"\b\d{3,4}\b", q)
-    base = re.findall(r"[A-Za-zÇĞİIÖŞÜçğıiöşü]+", q)
-    base = [w.lower() for w in base if len(w) > 2]
-    return list(dict.fromkeys(caps + nums + base))
-
-def _lexical_overlap(q_tokens: List[str], text: str) -> float:
-    toks = re.findall(r"[A-Za-zÇĞİIÖŞÜçğıiöşü]+", (text or "").lower())
-    if not toks:
-        return 0.0
-    qset = set([t for t in q_tokens if len(t) > 2])
-    tset = set([t for t in toks if len(t) > 2])
-    inter = len(qset & tset)
-    denom = len(qset) or 1
-    return inter / denom
-
-# =========================
-# Retrieval + (koşullu) rerank
+# Arama ve cevaplama
 # =========================
-
 @lru_cache(maxsize=256)
 def _cached_query_vec(e5_query: str) -> np.ndarray:
     v = embed([e5_query]).astype("float32")
     return v
 
-def search_chunks(
-    query: str,
-    index: faiss.Index,
-    records: List[Dict],
-    top_k: int = TOP_K_DEFAULT,
-    fetch_k: int = FETCH_K_DEFAULT,
-) -> List[Dict]:
-    q = (query or "").strip()
-    q_vec = _cached_query_vec("query: " + q)
+def search_chunks(query: str, index: faiss.Index, records: List[Dict], top_k: int = TOP_K_DEFAULT, fetch_k: int = FETCH_K_DEFAULT) -> List[Dict]:
+    q_vec = _cached_query_vec("query: " + query)
     faiss.normalize_L2(q_vec)
-
     scores, idxs = index.search(q_vec, fetch_k)
 
-    pool: List[Dict] = []
+    pool = []
     for i, s in zip(idxs[0], scores[0]):
         if 0 <= i < len(records):
-            r = records[i]
-            pool.append({
-                "text": r["text"],
-                "title": r.get("title", ""),
-                "source": r.get("source", ""),
-                "score_vec": float(s),
-            })
-    if not pool:
-        return []
-
-    q_tokens = _keywords_from_query(q)
-    q_tokens_lower = [t.lower() for t in q_tokens]
-    for p in pool:
-        title = (p.get("title") or "").lower()
-        title_hit = any(tok.lower() in title for tok in q_tokens if tok and tok[0].isupper())
-        title_boost = W_TITLE_BOOST if title_hit else 0.0
-        lex = _lexical_overlap(q_tokens_lower, p["text"]) * W_LEXICAL
-        p["score_boosted"] = p["score_vec"] + title_boost + lex
-
-    pool.sort(key=lambda x: x["score_boosted"], reverse=True)
-
-    if len(pool) >= 2:
-        top1, top2 = pool[0]["score_boosted"], pool[1]["score_boosted"]
-    else:
-        top1, top2 = pool[0]["score_boosted"], 0.0
-    do_rerank = not (top1 >= HIGH_SCORE_THRES and (top1 - top2) >= MARGIN_THRES)
-
-    if do_rerank:
-        rs = rerank(q, [p["text"] for p in pool])
-        for p, r in zip(pool, rs):
-            p["score_rerank"] = float(r)
-        pool.sort(key=lambda x: (x.get("score_rerank", 0.0), x["score_boosted"]), reverse=True)
-
-    return pool[:top_k]
+            md = records[i]["metadata"]
+            pool.append({"text": records[i]["text"], "title": md.get("title", ""), "source": md.get("source", ""), "score_vec": float(s)})
 
-# =========================
-# LLM bağlamı ve kaynak listesi
-# =========================
-
-def _format_sources(hits: List[Dict]) -> str:
-    seen, urls = set(), []
-    for h in hits:
-        u = (h.get("source") or "").strip()
-        if u and u not in seen:
-            urls.append(u)
-            seen.add(u)
-    return "\n".join(f"- {u}" for u in urls) if urls else "- (yok)"
-
-def _llm_context(hits: List[Dict], limit: int = CTX_CHAR_LIMIT) -> str:
-    ctx, total = [], 0
-    for i, h in enumerate(hits, 1):
-        block = f"[{i}] {h.get('title','')} — {h.get('source','')}\n{h.get('text','')}"
-        if total + len(block) > limit:
-            break
-        ctx.append(block)
-        total += len(block)
-    return "\n\n---\n\n".join(ctx)
+    return sorted(pool, key=lambda x: x["score_vec"], reverse=True)[:top_k]
 
-# =========================
-# Nihai cevap (kural → QA → LLM → fallback)
-# =========================
-
-def generate_answer(
-    query: str,
-    index: faiss.Index,
-    records: List[Dict],
-    top_k: int = TOP_K_DEFAULT,
-) -> str:
+def generate_answer(query: str, index: faiss.Index, records: List[Dict], top_k: int = TOP_K_DEFAULT) -> str:
     hits = search_chunks(query, index, records, top_k=top_k)
     if not hits:
         return "Bilgi bulunamadı."
 
-    rule_sent, rule_src = _extract_fact_sentence(query, hits)
-    if rule_sent:
-        return f"{rule_sent}\n\nKaynaklar:\n- {rule_src if rule_src else _format_sources(hits)}"
-
-    best = {"answer": None, "score": 0.0, "src": None}
-    for h in hits[:QA_PER_PASSAGES]:
-        try:
-            qa = qa_extract(query, h["text"])
-        except Exception:
-            qa = None
-        if qa and qa.get("answer"):
-            score = float(qa.get("score", 0.0))
-            ans = qa["answer"].strip()
-            if re.search(r"\b(19\d{2}|20\d{2}|Atatürk|Gökçen|Kemal|Ankara|Fenerbahçe)\b", ans, flags=re.IGNORECASE):
-                score += 0.30
-            if len(ans.split()) <= 2:
-                ans = _expand_named_span(ans, hits)
-            if score > best["score"]:
-                best = {"answer": ans, "score": score, "src": h.get("source")}
-
-    if best["answer"] and best["score"] >= QA_SCORE_THRES:
-        final = best["answer"].strip()
-        if any(k in (query or "").lower() for k in ["kimdir", "kim"]):
-            if not final.endswith("."):
-                final += "."
-            final = f"{final} {query.rstrip('?')} sorusunun yanıtıdır."
-        src_line = f"Kaynaklar:\n- {best['src']}" if best["src"] else "Kaynaklar:\n" + _format_sources(hits)
-        return f"{final}\n\n{src_line}"
-
-    context = _llm_context(hits)
+    context = "\n\n".join(h["text"] for h in hits)
     prompt = (
-        "Aşağıdaki BAĞLAM Wikipedia parçalarından alınmıştır.\n"
-        "Sadece bu bağlamdan yararlanarak soruya kısa, net ve doğru bir Türkçe cevap ver.\n"
-        "Uydurma yapma, sadece metinlerde geçen bilgileri kullan.\n\n"
-        f"Soru:\n{query}\n\nBağlam:\n{context}\n\nYanıtı 1-2 cümlede ver."
+        "Aşağıdaki Wikipedia parçalarına dayanarak soruyu yanıtla. "
+        "Uydurma bilgi verme, sadece metindeki veriyi kullan.\n\n"
+        f"Soru: {query}\n\nBağlam:\n{context}\n\nYanıt:"
     )
     llm_ans = (generate(prompt) or "").strip()
-
-    if (not llm_ans) or ("yapılandırılmadı" in llm_ans.lower()):
-        text = hits[0].get("text", "")
-        first = re.split(r"(?<=[.!?])\s+", text.strip())[:2]
-        llm_ans = " ".join(first).strip() or "Verilen bağlamda bu sorunun cevabı bulunmamaktadır."
-
-    if "Kaynaklar:" not in llm_ans:
-        llm_ans += "\n\nKaynaklar:\n" + _format_sources(hits)
-    return llm_ans
-
-# =========================
-# Hızlı test
-# =========================
-
-if __name__ == "__main__":
-    idx, recs = load_vectorstore()
-    for q in [
-        "Atatürk ne zaman öldü?",
-        "Türkiye'nin ilk cumhurbaşkanı kimdir?",
-        "Fenerbahçe ne zaman kuruldu?",
-        "Türkiye'nin başkenti neresidir?",
-        "Türkiye'nin ilk kadın pilotu kimdir?",
-    ]:
-        print("Soru:", q)
-        print(generate_answer(q, idx, recs, top_k=TOP_K_DEFAULT))
-        print("-" * 80)
+    return llm_ans or "Verilen bağlamda yanıt bulunamadı."