HF Spaces deploy: temiz tek-commit history, chroma_db Git LFS üzerinden

.gitattributes

@@ -0,0 +1,5 @@
+* text=auto eol=lf
+
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.sqlite3 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,20 @@
+venv/
+.env
+__pycache__/
+tests/
+pdfs/
+logs/
+output.txt
+allpdfs/
+cleanpdfs/
+test_chunk_output.txt
+resp_samples.html
+resp_sample.html
+
+# dev/inceleme dosyaları HF deploy'a girmesin (main branch'ta tutuluyor)
+test_*.py
+check_patterns.py
+download_tablet_kt.py
+ilac_chatbot_colab.ipynb
+drugs_list.txt
+manifest.json

README.md

@@ -0,0 +1,101 @@
+---
+title: ilacChat
+emoji: 💊
+colorFrom: blue
+colorTo: green
+sdk: gradio
+app_file: app.py
+pinned: false
+---
+
+# Huggingface Space : [emrecn/ilacChatBot](https://huggingface.co/spaces/emrecn/ilacChatBot)
+
+<img width="2390" height="434" alt="mermaid-diagram" src="https://github.com/user-attachments/assets/1ba2f96c-0bfc-4d5d-80f2-c06752615501" />
+
+
+# ilacChatBot
+
+Turkce ilac kullanma talimatlarindan bilgi alan, PDF tabanli bir RAG sohbet uygulamasidir.
+Uygulama, prospektusleri okuyup vektor veritabanina kaydeder; kullanici sorularini bu bilgi tabanina gore yanitlar.
+
+## ÖNEMLİ !! Doküman olarak kullandığım pdflerin ait olduğu ilaçların adları drug_list.text belgesinin içerisinde yazmaktadır. Model sadece bu ilaçlarla ilgili cevap verebilir.
+
+## Özellikler
+
+- PDF kullanma talimatlarindan otomatik veri cekme
+- Regex tabanli metin temizleme ve bolum ayirma
+- ChromaDB ile vektor arama
+- Google Gemini ile yanit olusturma
+- Jina Embeddings ile semantik temsil
+- Gradio tabanli web arayuzu
+- Hafizasiz, tek soruluk RAG akisi
+
+## Kullanılan Teknolojiler
+
+- Python
+- LangChain
+- ChromaDB
+- Gradio
+- Google Gemini API
+- Jina Embeddings
+- PyPDF
+- Hugging Face Spaces
+
+## Proje Yapisi
+
+```text
+.
+├── app.py
+├── app/
+│   ├── __init__.py
+│   ├── ingest.py
+│   ├── retrieval.py
+│   └── ui.py
+├── chroma_db/
+├── pdfs/
+├── requirements.txt
+├── manifest.json
+└── drugs_list.txt
+```
+
+## Yerel Kurulum
+
+1. Sanal ortam olusturun ve bagimliliklari yukleyin.
+
+```bash
+python -m venv venv
+.\venv\Scripts\activate
+pip install -r requirements.txt
+```
+
+2. Koku dizinde `.env` dosyasi olusturun ve API anahtarlarini ekleyin.
+
+```ini
+GOOGLE_API_KEY=your_gemini_key
+JINA_API_KEY=your_jina_key
+```
+
+3. PDF dosyalarinizi `pdfs/` klasorune koyun ve vektor veritabanini olusturun.
+
+```bash
+python -m app.ingest --pdf-dir ./pdfs --mode full
+```
+
+4. Uygulamayi calistirin.
+
+```bash
+python app.py
+```
+
+
+## Geliştirilecek Özellikler
+
+- Daha iyi bolum tespiti ve chunk kalitesi
+- Benzer ilaclar icin akilli eslestirme ve yeniden sorgulama
+- Kaynak gosterimini daha okunabilir hale getirme
+- Soru-cevap gecmisini opsiyonel hale getirme
+- PDF disinda ilac kutu bilgileri ve prospektus metadata destegi
+- Kullanici arayuzu icin daha gelismis filtreleme ve sonuc ozetleri
+- Toplu PDF yukleme ve otomatik yeniden indeksleme
+- Hata izleme ve log kaydi iyilestirmeleri
+

app.py

@@ -0,0 +1,7 @@
+import os
+from app.ui import main, demo  # `demo` module-level export — `gradio app.py` hot reload için
+
+if __name__ == "__main__":
+    # Hugging Face Spaces üzerinden çalışırken share=False ve host=0.0.0.0 olmalıdır.
+    # Gradio HF spaces tarafında varsayılan 7860 portunu kullanır.
+    main(host="0.0.0.0", port=7860, share=False)

app/ingest.py

@@ -0,0 +1,322 @@
+import argparse
+import os
+import re
+import hashlib
+import json
+from pathlib import Path
+from typing import Optional
+from langchain_core.documents import Document
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_community.embeddings import JinaEmbeddings
+from langchain_community.vectorstores import Chroma
+from dotenv import load_dotenv
+from app.logger import get_logger
+
+load_dotenv()
+
+logger = get_logger("ingest")
+
+CHROMA_DB_DIR = "./chroma_db"
+MANIFEST_PATH = "./manifest.json"
+
+
+def _loose(phrase: str) -> str:
+    """Bir ifadeyi, PDF çıkarımında kelime içine serpilmiş rastgele
+    boşluklara ('Ku llanm a') toleranslı bir regex'e çevirir.
+
+    Boşluklar \\s+, diğer tokenlar arasına \\s* eklenir. '.' -> \\.?,
+    ':' -> :?, '?' önceki tokenı opsiyonel yapmak yerine literal
+    bırakmaz (opsiyonel karakterler nokta/:).
+    Karakter sınıfları ([ıi] gibi) tek token sayılır.
+    """
+    out: list[str] = []
+    i, n = 0, len(phrase)
+    while i < n:
+        c = phrase[i]
+        if c.isspace():
+            out.append(r"\s+")
+            while i < n and phrase[i].isspace():
+                i += 1
+            continue
+        if c == "[":
+            j = phrase.index("]", i)
+            token = phrase[i : j + 1]
+            i = j + 1
+        elif c == ".":
+            if out and out[-1] == r"\s*":
+                out.pop()
+            out.append(r"\.?")
+            i += 1
+            continue
+        elif c == ":":
+            if out and out[-1] == r"\s*":
+                out.pop()
+            out.append(r":?")
+            i += 1
+            continue
+        elif c == "?":
+            i += 1
+            continue
+        else:
+            token = c
+            i += 1
+        if out and not out[-1].endswith(r"\s+"):
+            out.append(r"\s*")
+        out.append(token)
+    return "".join(out)
+
+def get_file_hash(filepath: Path) -> str:
+    hasher = hashlib.md5()
+    with open(filepath, 'rb') as f:
+        buf = f.read()
+        hasher.update(buf)
+    return hasher.hexdigest()
+
+def _extract_drug_id_from_filename(filepath: Path) -> Optional[str]:
+    """Dosya adından ilaç adını çeker. Format: {İLAÇ ADI}__{random}.pdf"""
+    stem = filepath.stem
+    if '__' in stem:
+        part = stem.split('__')[0].strip()
+        part = re.sub(r'\s+', ' ', part)
+        if part:
+            return part
+    return None
+
+def extract_drug_id(doc_path: Path, first_page_text: str) -> str:
+    # 1. Ana yöntem: Dosya adından çek (ilaç adı __ ayracından önceki kısım)
+    drug_name = _extract_drug_id_from_filename(doc_path)
+    if drug_name:
+        logger.info(f"Dosya adından tespit edildi: {doc_path.name} → {drug_name}")
+        return drug_name
+
+    # 2. KULLANMA TALİMATI başlığından sonra ilaç adını topla
+    lines = first_page_text.split('\n')
+    start_collecting = False
+    drug_name_lines = []
+
+    stop_prefixes = [
+        "ağız", "oral", "deri", "kas", "damar",
+        "etkin madde", "yardımcı madde",
+        "ağızdan", "kas içine", "damar içine",
+        "cilt üzerine", "deri altına",
+        "bu kullanma talimatında", "kullanmadan önce"
+    ]
+
+    for line in lines:
+        clean_line = line.strip()
+
+        if not start_collecting:
+            if "KULLANMA TALİMATI" in clean_line.upper():
+                start_collecting = True
+            continue
+
+        if not clean_line:
+            continue
+
+        lower_line = clean_line.lower().lstrip("•.-* ")
+
+        if any(lower_line.startswith(prefix) for prefix in stop_prefixes):
+            break
+
+        drug_name_lines.append(clean_line)
+
+    if drug_name_lines:
+        result = " ".join(drug_name_lines).replace("®", "").strip()
+        logger.warning(f"KULLANMA TALİMATI yöntemi kullanıldı: {doc_path.name} → {result}")
+        return result
+
+    # 3. Regex: İlk sayfada "mg", "tablet", "kapsül" vb. içeren satırları ara
+    drug_pattern = re.compile(
+        r'^(.+(?:mg|mcg|mikrogram|ml|IU).+(?:tablet|kapsül|kapsul|film|şurup|surup|jel|krem|damla|flakon|süspansiyon|suspansiyon|sprey|ampul|enjektabl).*?)$',
+        re.IGNORECASE | re.MULTILINE
+    )
+    match = drug_pattern.search(first_page_text[:1000])
+    if match:
+        result = match.group(1).replace("®", "").strip()
+        logger.warning(f"Regex yöntemi kullanıldı: {doc_path.name} → {result}")
+        return result
+
+    # 4. Tespit edilemedi — None döndür, process_pdfs atlayacak
+    logger.warning(f"İlaç adı tespit edilemedi, atlanıyor: {doc_path.name}")
+    return None
+
+def split_kt_by_sections(text: str, drug_id: str, file_hash: str) -> "list[Document]":
+    # Başlıkları yakalayacak esnek regex desenleri
+    patterns = {
+        "1. İlaç nedir ve ne için kullanılır?": r"(?m)^\s*1\.\s+(?!\").*nedir\s+ve\s+ne\s+için\s+kullanılır[^)\"]*$",
+        "2. Kullanmadan önce dikkat edilmesi gerekenler": r"(?m)^\s*2\.\s+(?!\").*kullanmadan\s+önce\s+dikkat\s+edilmesi\s+gerekenler[^)\"]*$",
+        "3. Nasıl kullanılır?": r"(?m)^\s*3\.\s+(?!\").*nasıl\s+kullanılır[^)\"]*$",
+        "4. Olası yan etkiler nelerdir?": r"(?m)^\s*4\.\s+(?!\").*olası\s+yan\s+etkiler[^)\"]*$",
+        "5. Saklama koşulları": r"(?m)^\s*5\.\s+(?!\").*saklanması[^)\"]*$"
+    }
+
+    matches = []
+    for section_name, pattern in patterns.items():
+        # İlk eşleşmeyi bul
+        match = re.search(pattern, text, re.IGNORECASE)
+        if match:
+            matches.append({"name": section_name, "start": match.start()})
+            
+    # Başlangıç indeksine göre sırala
+    matches.sort(key=lambda x: x["start"])
+    
+    sections = []
+    if not matches:
+        # Hiç başlık bulunamazsa tüm metni tek bir genel bölüm olarak al
+        sections.append({"name": "Genel Bilgiler", "content": text.strip()})
+    else:       
+        # Bulunan bölümleri ayır
+        for i in range(len(matches)):
+            # İlk başlıktan önceki metni (prelude) giriş bölümü yapmak yerine ilk bölümün başına dahil ediyoruz
+            start_index = 0 if i == 0 else matches[i]["start"]
+            end_index = matches[i+1]["start"] if i + 1 < len(matches) else len(text)
+            sections.append({
+                "name": matches[i]["name"],
+                "content": text[start_index:end_index].strip()
+            })
+            
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=1800,
+        chunk_overlap=300,
+        separators=["\n\n", "\n", ". ", "! ", "? ", " ", ""]
+    )
+    
+    docs = []
+    for sec in sections:
+        chunks = text_splitter.split_text(sec["content"])
+        for chunk in chunks:
+            # RAG performansını artırmak için ilaç adını bölüm başlığının başına ekliyoruz
+            chunk_text = f"[{drug_id} - {sec['name']}]\n\n{chunk}"
+            docs.append(Document(
+                page_content=chunk_text,
+                metadata={
+                    "drug_id": drug_id,
+                    "section": sec["name"],
+                    "file_hash": file_hash
+                }
+            ))
+            
+    return docs
+
+def _generate_drugs_list(db):
+    """ChromaDB'den unique drug_id'leri çekip drugs_list.txt'ye yazar."""
+    try:
+        collection = db._collection
+        results = collection.get(include=["metadatas"])
+        drug_ids = set()
+        for meta in results["metadatas"]:
+            did = meta.get("drug_id", "")
+            if did and did != "SKIP":
+                drug_ids.add(did)
+
+        sorted_drugs = sorted(drug_ids, key=lambda x: x.lower())
+        with open("drugs_list.txt", "w", encoding="utf-8") as f:
+            for drug in sorted_drugs:
+                f.write(f"{drug}\n")
+        logger.info(f"drugs_list.txt güncellendi: {len(sorted_drugs)} ilaç")
+    except Exception as e:
+        logger.error(f"drugs_list.txt oluşturma hatası: {e}")
+
+def process_pdfs(pdf_dir: str, mode: str):
+    import time
+
+    pdf_dir_path = Path(pdf_dir)
+    manifest = {}
+    if os.path.exists(MANIFEST_PATH):
+        with open(MANIFEST_PATH, "r") as f:
+            manifest = json.load(f)
+
+    db = Chroma(persist_directory=CHROMA_DB_DIR, embedding_function=JinaEmbeddings(jina_api_key=os.environ.get("JINA_API_KEY"), model_name="jina-embeddings-v3"))
+
+    for filepath in pdf_dir_path.glob("*.pdf"):
+        file_hash = get_file_hash(filepath)
+        old_hash = manifest.get(str(filepath))
+
+        if mode == "incremental" and old_hash == file_hash:
+            logger.debug(f"Atlanıyor (değişiklik yok): {filepath.name}")
+            continue
+
+        logger.info(f"İşleniyor: {filepath.name}")
+        loader = PyPDFLoader(str(filepath))
+        docs = loader.load()
+        if not docs:
+            logger.warning(f"Boş PDF: {filepath.name}")
+            continue
+
+        # Tüm sayfalarda temizleme — _loose sayesinde PDF'den gelen
+        # 'Ku llanm a Talim atında' gibi kelime-içi boşluklara toleranslı.
+        p1 = re.compile(
+            r"(?:" + _loose("bu ilac[ıi] kullanmaya ba[şs]lamadan [öo]nce") + r"\s+)?" +
+            _loose("bu kullanma tal[iı]mat[ıi]n[ıi]") +
+            r".*?" +
+            _loose("y[üu]ksek veya d[üu][şs][üu]k doz kullanmay[ıi]n[ıi]z."),
+            re.IGNORECASE | re.DOTALL
+        )
+        p2 = re.compile(
+            _loose("bu kullanma tal[iı]mat[ıi]nda:") +
+            r".*?" +
+            _loose("ba[şs]l[ıi]klar[ıi] yer almaktad[ıi]r."),
+            re.IGNORECASE | re.DOTALL
+        )
+        try:
+            for doc in docs:
+                cleaned = p1.sub("", doc.page_content)
+                cleaned = p2.sub("", cleaned)
+                cleaned = re.sub(r'^\s*\d+\s*$', '', cleaned, flags=re.MULTILINE)
+                cleaned = re.sub(r'^\s*\d+\s*/\s*\d+\s*$', '', cleaned, flags=re.MULTILINE)
+                cleaned = re.sub(r'\n{3,}', '\n\n', cleaned)
+                doc.page_content = cleaned.strip()
+        except Exception as e:
+            logger.error(f"İçerik temizleme hatası ({filepath.name}): {e}")
+
+        drug_id = extract_drug_id(filepath, docs[0].page_content)
+
+        if drug_id is None:
+            continue
+
+        logger.info(f"İlaç tespit edildi: {drug_id}")
+
+        full_text = "\n".join(doc.page_content for doc in docs)
+
+        chunks = split_kt_by_sections(full_text, drug_id, file_hash)
+        logger.info(f"Chunk sayısı: {len(chunks)}")
+
+        # Eski chunk'ları sil (stale data önleme)
+        if old_hash:
+            try:
+                db._collection.delete(where={"file_hash": old_hash})
+                logger.info(f"Eski chunk'lar silindi (hash: {old_hash[:12]}...)")
+            except Exception as e:
+                logger.warning(f"Eski chunk silme hatası: {e}")
+
+        batch_size = 50
+        for i in range(0, len(chunks), batch_size):
+            batch = chunks[i:i+batch_size]
+            try:
+                db.add_documents(batch)
+                time.sleep(2)
+            except Exception as e:
+                logger.error(f"Embedding hatası (bekleniyor...): {e}")
+                time.sleep(10)
+                try:
+                    db.add_documents(batch)
+                except Exception as inner_e:
+                    logger.error(f"Retry başarısız, atlanıyor: {inner_e}")
+
+        manifest[str(filepath)] = file_hash
+
+    with open(MANIFEST_PATH, "w") as f:
+        json.dump(manifest, f)
+
+    # İlaç listesini ChromaDB'den otomatik oluştur
+    _generate_drugs_list(db)
+
+    logger.info("Ingestion tamamlandı.")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--pdf-dir", type=str, required=True)
+    parser.add_argument("--mode", type=str, choices=["incremental", "full"], default="full", help="Ingestion mode: 'incremental' to only process changed files, 'full' to reprocess all files")
+    args = parser.parse_args()
+    process_pdfs(args.pdf_dir, args.mode)

app/logger.py

@@ -0,0 +1,63 @@
+import logging
+import os
+from logging.handlers import RotatingFileHandler
+
+LOG_DIR = "./logs"
+
+def get_logger(name: str) -> logging.Logger:
+    os.makedirs(LOG_DIR, exist_ok=True)
+
+    logger = logging.getLogger(name)
+
+    if logger.handlers:
+        return logger
+
+    logger.setLevel(logging.DEBUG)
+
+    # Dosya handler — 5MB, max 3 dosya
+    file_handler = RotatingFileHandler(
+        os.path.join(LOG_DIR, f"{name}.log"),
+        maxBytes=5 * 1024 * 1024,
+        backupCount=3,
+        encoding="utf-8"
+    )
+    file_handler.setLevel(logging.DEBUG)
+    file_fmt = logging.Formatter("%(asctime)s | %(levelname)-8s | %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
+    file_handler.setFormatter(file_fmt)
+
+    # Console handler
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.INFO)
+    console_fmt = logging.Formatter("%(levelname)-8s | %(message)s")
+    console_handler.setFormatter(console_fmt)
+
+    logger.addHandler(file_handler)
+    logger.addHandler(console_handler)
+
+    return logger
+
+
+def get_jsonl_logger(name: str) -> logging.Logger:
+    """Returns a logger that writes raw JSON lines (no prefix) to logs/{name}.jsonl.
+    Intended for machine-readable per-query traces."""
+    os.makedirs(LOG_DIR, exist_ok=True)
+
+    logger = logging.getLogger(f"jsonl.{name}")
+
+    if logger.handlers:
+        return logger
+
+    logger.setLevel(logging.INFO)
+    logger.propagate = False  # do not bubble up to root
+
+    file_handler = RotatingFileHandler(
+        os.path.join(LOG_DIR, f"{name}.jsonl"),
+        maxBytes=5 * 1024 * 1024,
+        backupCount=3,
+        encoding="utf-8"
+    )
+    file_handler.setLevel(logging.INFO)
+    file_handler.setFormatter(logging.Formatter("%(message)s"))
+    logger.addHandler(file_handler)
+
+    return logger

app/retrieval.py

@@ -0,0 +1,552 @@
+import json
+import os
+import re
+import time
+from collections import Counter
+from datetime import datetime, timezone
+from typing import Optional
+import requests
+from langchain_chroma import Chroma
+from langchain_community.embeddings import JinaEmbeddings
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_core.prompts import PromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from dotenv import load_dotenv
+from app.logger import get_logger, get_jsonl_logger
+
+load_dotenv()
+
+logger = get_logger("retrieval")
+query_logger = get_jsonl_logger("queries")
+
+CHROMA_DB_DIR = "./chroma_db"
+
+# ── Sabitler ────────────────────────────────────────────────────────────
+MAX_HISTORY_TURNS = 3
+LOW_CONFIDENCE_THRESHOLD = 0.2
+REFUSAL_MESSAGE = "Bu konu hakkında elimdeki kaynaklarda yeterli bilgi bulunmuyor."
+DISCLAIMER = "\n\n---\n*Bu bilgi genel bilgilendirme amaçlıdır. İlacı kullanmadan önce mutlaka doktorunuza veya eczacınıza danışın.*"
+DISCLAIMER_MARKER = "doktorunuza veya eczacınıza danışın"
+
+# Global objeler: RAG sistemi ve LLM her çağrıda yeniden oluşturulmaz (Performans Artışı)
+db = Chroma(persist_directory=CHROMA_DB_DIR, embedding_function=JinaEmbeddings(jina_api_key=os.environ.get("JINA_API_KEY"), model_name="jina-embeddings-v3"))
+
+
+def _load_drug_ids() -> list[str]:
+    """Chroma'daki benzersiz drug_id'leri döndürür (uzun ad önce sıralı,
+    böylece 'abizol 10 mg' eşleşmesi 'abizol'den önce denenir)."""
+    try:
+        metas = db._collection.get(include=["metadatas"])["metadatas"]
+        ids = {m.get("drug_id", "") for m in metas if m.get("drug_id")}
+        ids.discard("SKIP")
+        return sorted(ids, key=lambda s: (-len(s), s.lower()))
+    except Exception as e:
+        logger.warning(f"drug_id listesi yüklenemedi: {e}")
+        return []
+
+
+DRUG_IDS = _load_drug_ids()
+logger.info(f"Metadata filtering için {len(DRUG_IDS)} drug_id yüklendi")
+
+
+def _normalize(s: str) -> str:
+    """Türkçe karakter-duyarsız, noktalama-sız eşleştirme için normalize.
+    ÖNEMLİ: Python'da 'İ'.lower() = 'i\\u0307' (iki karakter) olduğundan,
+    Türkçe karakter mapping'i .lower()'dan ÖNCE yapılmalı."""
+    tr = str.maketrans("ıİşŞğĞüÜöÖçÇ", "iissgguuoocc")
+    s = s.translate(tr).lower()
+    return re.sub(r"[^a-z0-9\s]", " ", s)
+
+
+# ── Reranking ────────────────────────────────────────────────────────────
+# Vektör araması (embedding + cosine similarity) hızlıdır ama kaba bir
+# sıralama verir: anlamsal olarak yakın ama soruya tam cevap vermeyen
+# chunk'lar üst sıralara çıkabilir. Reranker, (query, chunk) çiftlerini
+# tek tek değerlendiren bir cross-encoder modelidir ve çok daha isabetli
+# sıralama üretir. Akış: similarity_search ile top-N aday al (örn. 20) →
+# Jina Reranker API'ye gönder → modelin skorlamasına göre en alakalı
+# top_n chunk'ı LLM'e ver. Böylece "doğru ilaç + doğru bölüm" isabeti
+# belirgin şekilde artar; karşılığında ~200-500 ms ek latency ve API
+# çağrısı maliyeti gelir.
+JINA_RERANK_URL = "https://api.jina.ai/v1/rerank"
+JINA_RERANK_MODEL = "jina-reranker-v2-base-multilingual"
+
+
+def rerank_jina_with_scores(query: str, docs: list, top_n: int = 5) -> tuple[list, list[float]]:
+    """Aday chunk'ları Jina Reranker v2 (multilingual) ile yeniden sıralar
+    ve relevance_score'larıyla birlikte döndürür. API hatasında orijinal
+    sıralamanın ilk top_n'ini boş skor listesiyle döndürür."""
+    if not docs:
+        return docs, []
+    api_key = os.environ.get("JINA_API_KEY")
+    if not api_key:
+        logger.warning("JINA_API_KEY yok, rerank atlandı")
+        return docs[:top_n], []
+    resp = requests.post(
+        JINA_RERANK_URL,
+        headers={
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+        },
+        json={
+            "model": JINA_RERANK_MODEL,
+            "query": query,
+            "documents": [d.page_content for d in docs],
+            "top_n": top_n,
+        },
+        timeout=15,
+    )
+    resp.raise_for_status()
+    results = resp.json().get("results", [])
+    reranked = [docs[r["index"]] for r in results]
+    scores = [float(r.get("relevance_score", 0.0)) for r in results]
+    logger.info(f"Rerank: {len(docs)} aday → {len(reranked)} chunk")
+    return reranked, scores
+
+
+def rerank_jina(query: str, docs: list, top_n: int = 5) -> list:
+    """Geriye dönük imza. Hata durumunda orijinal sıralama döner."""
+    try:
+        reranked, _ = rerank_jina_with_scores(query, docs, top_n)
+        return reranked
+    except Exception as e:
+        logger.warning(f"Rerank hatası, orijinal sıralama kullanılıyor: {e}")
+        return docs[:top_n]
+
+
+def detect_drug_id(query: str) -> Optional[str]:
+    """Sorguda geçen ilk (en uzun) drug_id'yi bulur. İsim tüm tokenları
+    sorguda geçiyorsa eşleşme sayılır."""
+    q_norm = _normalize(query)
+    q_tokens = set(q_norm.split())
+    for did in DRUG_IDS:
+        d_tokens = _normalize(did).split()
+        if d_tokens and all(t in q_tokens for t in d_tokens):
+            return did
+    # fallback: ilk token (marka adı) yeterli
+    for did in DRUG_IDS:
+        brand = _normalize(did).split()[0] if did else ""
+        if brand and brand in q_tokens:
+            return did
+    return None
+
+
+# ── Multi-turn yardımcıları ─────────────────────────────────────────────
+
+def build_history_block(history: list, max_turns: int = MAX_HISTORY_TURNS) -> str:
+    """Gradio history'sini (user, assistant) tuple listesinden son N turluk düz metin
+    bloğuna çevirir. Boşsa "" döner. Gradio bazı sürümlerde dict list de verebilir,
+    bu durum da desteklenir."""
+    if not history:
+        return ""
+    recent = history[-max_turns:]
+    lines = []
+    for turn in recent:
+        user_msg, assistant_msg = _extract_turn(turn)
+        if user_msg:
+            lines.append(f"Kullanıcı: {user_msg.strip()}")
+        if assistant_msg:
+            # Uzun geçmiş cevaplarını kırp — rewriter'ın bağlam penceresini şişirmesin
+            trimmed = assistant_msg.strip()
+            if len(trimmed) > 500:
+                trimmed = trimmed[:500] + "…"
+            lines.append(f"Asistan: {trimmed}")
+    return "\n".join(lines)
+
+
+def _extract_turn(turn) -> tuple[str, str]:
+    """Hem (user, assistant) tuple hem de {'role','content'} dict pair formatını destekler."""
+    if isinstance(turn, (list, tuple)) and len(turn) == 2:
+        return (turn[0] or ""), (turn[1] or "")
+    if isinstance(turn, dict):
+        role = turn.get("role", "")
+        content = turn.get("content", "") or ""
+        if role == "user":
+            return content, ""
+        if role == "assistant":
+            return "", content
+    return "", ""
+
+
+# ── Prompts ─────────────────────────────────────────────────────────────
+
+REWRITER_PROMPT = PromptTemplate.from_template("""Aşağıda bir sohbet geçmişi ve kullanıcının son mesajı var. Görevin: son mesajı, tek başına anlaşılır ve arama motoruna verilebilecek bağımsız bir Türkçe soruya dönüştürmek.
+
+KURALLAR:
+1. Son mesajda bir ilaç adı geçiyorsa onu koru; rastgele başka bir ilaç ekleme.
+2. Son mesajda ilaç adı geçmiyor ama geçmişte bir ilaç konuşulduysa VE son mesaj o ilacın bir özelliğini (yan etki, doz, etkileşim, hamilelik, yaş, saklama vb.) soran bir takip sorusuysa, o ilacın adını soruya ekle. "bu", "bu ilaç", "o", "o ilaç", "bunun", "onun", "ondan" gibi işaret zamirlerini geçmişteki ilacın adıyla DEĞİŞTİR (sadece ilaç adını eklemekle kalma, zamiri çıkar).
+3. "Bunlar", "bunlardan biri", "ikisi", "diğeri" gibi önceki cevaba atıf yapan ifadeleri, geçmişteki asistan cevabından ilgili konuya (yan etki, uyarı, kullanım vb.) çözerek yaz.
+4. Son mesaj farklı bir hastalık / durum / şikayet için ilaç ÖNERİSİ sorduğu bağımsız bir soruysa ("X için hangi ilaç", "X tedavisinde hangi ilaçlar kullanılır", "X durumunda ne alınmalı", "X olduğunda hangi ilaç"), geçmişteki ilacı SORUYA EKLEME — bu sorgu önceki ilacın bir özelliği değildir, yeni bir konudur. Soruyu olduğu gibi bırak.
+5. Son mesajda YENİ bir ilaç adı geçiyorsa normalde geçmişteki ilacı yok say ve yeni ilaçla devam et.
+6. ANCAK son mesaj karşılaştırma ifadesi içeriyorsa ("fark", "farkı", "farkı nedir", "arasındaki", "kıyasla", "göre", "hangisi", "hangisi daha"), hem geçmişteki ilacı hem yeni ilacı KORU ve karşılaştırma sorusunu bozmadan yaz.
+7. Hiçbir yerde ilaç adı yoksa ya da mesaj selamlaşma / teşekkür / onay ifadesi ise ("merhaba", "selam", "teşekkürler", "tamam", "anladım", "sağol"), soruyu/ifadeyi aynen aktar; zorla ilaç adı ekleme.
+8. Sadece yeniden yazılmış soruyu tek satır olarak döndür. Açıklama, başlık, tırnak işareti, ön-ek ekleme.
+
+ÖRNEKLER:
+
+Örnek 1 (takip sorusu — Kural 2):
+SOHBET GEÇMİŞİ:
+Kullanıcı: Parol ne için kullanılır?
+Asistan: Ağrı ve ateş düşürücü olarak kullanılır.
+SON MESAJ: Yan etkileri neler?
+YENİDEN YAZILMIŞ SORU: Parol'ün yan etkileri nelerdir?
+
+Örnek 2 (zamir çözümü — Kural 2):
+SOHBET GEÇMİŞİ:
+Kullanıcı: Majezik hakkında bilgi ver.
+Asistan: Majezik bir ağrı kesicidir...
+SON MESAJ: Bu ilaç hamilelikte kullanılabilir mi?
+YENİDEN YAZILMIŞ SORU: Majezik hamilelikte kullanılabilir mi?
+
+Örnek 3 (konu değişikliği — Kural 5):
+SOHBET GEÇMİŞİ:
+Kullanıcı: Parol hamilelikte kullanılır mı?
+Asistan: Doktor kontrolünde kullan��labilir.
+SON MESAJ: Peki Majezik?
+YENİDEN YAZILMIŞ SORU: Majezik hamilelikte kullanılır mı?
+
+Örnek 4 (yeni medikal konu — Kural 4, KRİTİK):
+SOHBET GEÇMİŞİ:
+Kullanıcı: COVADRİN hangi ilaçlarla birlikte kullanılmaz?
+Asistan: COVADRİN MAO inhibitörleri ve antidepresanlarla birlikte kullanılmamalıdır.
+SON MESAJ: El ve ayak tırnaklarındaki mantar enfeksiyonlarının tedavisinde hangi ilaçlar kullanılabilir?
+YENİDEN YAZILMIŞ SORU: El ve ayak tırnaklarındaki mantar enfeksiyonlarının tedavisinde hangi ilaçlar kullanılabilir?
+
+Örnek 5 (karşılaştırma — Kural 6, KRİTİK):
+SOHBET GEÇMİŞİ:
+Kullanıcı: Parol yan etkileri nelerdir?
+Asistan: Mide bulantısı, cilt döküntüsü gibi yan etkiler olabilir.
+SON MESAJ: Majezik'ten farkı nedir?
+YENİDEN YAZILMIŞ SORU: Parol ile Majezik arasındaki fark nedir?
+
+Örnek 6 (sohbet ifadesi — Kural 7):
+SOHBET GEÇMİŞİ:
+Kullanıcı: Parol ne için kullanılır?
+Asistan: Ağrı ve ateş düşürücü olarak kullanılır.
+SON MESAJ: Teşekkürler, çok faydalı oldu
+YENİDEN YAZILMIŞ SORU: Teşekkürler, çok faydalı oldu
+
+Örnek 7 (önceki cevaba atıf — Kural 3):
+SOHBET GEÇMİŞİ:
+Kullanıcı: Parol'ün yan etkileri nelerdir?
+Asistan: Mide bulantısı, cilt döküntüsü, baş ağrısı olabilir.
+SON MESAJ: Bunlardan biri çocuklarda görülürse ne yapmalı?
+YENİDEN YAZILMIŞ SORU: Parol'ün yan etkilerinden biri (mide bulantısı, cilt döküntüsü veya baş ağrısı) çocuklarda görülürse ne yapmalı?
+
+Şimdi aşağıdaki son mesajı yeniden yaz:
+
+SOHBET GEÇMİŞİ:
+{history}
+
+SON MESAJ: {query}
+
+YENİDEN YAZILMIŞ SORU:""")
+
+
+ANSWER_PROMPT = PromptTemplate.from_template("""Sen, Türkiye'de satılan ilaçların resmî "Kullanma Talimatı" (KT) belgelerine dayanarak bilgi veren bir sağlık bilgilendirme asistanısın.
+
+KURALLAR:
+1. Her zaman Türkçe yanıt ver.
+2. Yalnızca aşağıdaki BAĞLAM bölümünde verilen bilgileri kullan. Bağlamda geçmeyen hiçbir bilgiyi ASLA uydurma, tahmin yürütme veya genel tıp bilgisi ile tamamlama.
+3. Bağlamda yanıt için yeterli bilgi yoksa sadece "Bilmiyorum." yaz.
+4. Spesifik doz önerisi verme; kişiye özel teşhis koyma; tedavi başlatma/değiştirme önerme. Kullanıcı doz sorarsa KT'de yazan genel bilgiyi aktar ve "Dozaj kararı için doktor/eczacıya danışılmalıdır" de.
+5. Kısa, net ve doğrudan cevap ver. Bağlamda olan bilgiyi tekrar etme.
+6. GEÇMİŞ KONUŞMA'yı yalnızca kullanıcının sorusunu doğru anlamak için kullan; yanıtın içinde geçmişe atıf yapma.
+7. Yanıtın sonuna doktor/eczacıya danışma hatırlatmasını mutlaka ekle.
+
+GEÇMİŞ KONUŞMA:
+{history}
+
+BAĞLAM:
+{context}
+
+KULLANICININ SORUSU: {question}
+
+YANIT:""")
+
+
+llm = ChatGoogleGenerativeAI(model="gemini-flash-latest", temperature=0)
+
+rewriter_chain = REWRITER_PROMPT | llm | StrOutputParser()
+answer_chain = ANSWER_PROMPT | llm | StrOutputParser()
+
+
+def rewrite_query(raw_query: str, history: list) -> str:
+    """Geçmişi kullanarak sorguyu bağımsız bir soruya dönüştürür.
+    Geçmiş boş veya hata durumunda orijinal sorguyu döndürür."""
+    history_block = build_history_block(history)
+    if not history_block:
+        return raw_query
+    rewritten = rewriter_chain.invoke({"history": history_block, "query": raw_query})
+    rewritten = (rewritten or "").strip().strip('"').strip("'")
+    # İlk satırı al — model bazen açıklama ekleyebilir
+    rewritten = rewritten.split("\n", 1)[0].strip()
+    if not rewritten:
+        return raw_query
+    return rewritten
+
+
+# ── Kaynak + uyarı yardımcıları ─────────────────────────────────────────
+
+def format_sources(docs: list) -> str:
+    """Kullanılan chunk'ların bölüm + ilaç bilgisini sade liste halinde döndürür.
+    Aynı (bölüm, ilaç) tekrarları teke indirir."""
+    seen = set()
+    lines = []
+    for doc in docs:
+        section = doc.metadata.get("section", "Bilinmiyor")
+        drug = doc.metadata.get("drug_id", "Bilinmiyor")
+        key = (section, drug)
+        if key in seen:
+            continue
+        seen.add(key)
+        lines.append(f"- {section} — {drug}")
+    return "\n".join(lines)
+
+
+def append_disclaimer(answer: str) -> str:
+    """Doktor/eczacı uyarısını garanti altına alır."""
+    if DISCLAIMER_MARKER in answer:
+        return answer
+    return answer.rstrip() + DISCLAIMER
+
+
+def _is_bilmiyorum(text: str) -> bool:
+    return bool(re.fullmatch(
+        r'(?i)^[^\w]*(üzgünüm|maalesef|hayır)?[^\w]*bilmiyorum[^\w]*$',
+        text.strip()
+    ))
+
+
+def _is_quota_error(exc: Exception) -> bool:
+    """Google Gemini (veya benzeri) kota / rate-limit hatalarını tespit eder."""
+    msg = str(exc).lower()
+    return any(tok in msg for tok in (
+        "429",
+        "quota",
+        "resourceexhausted",
+        "resource_exhausted",
+        "rate limit",
+        "rate_limit",
+        "exceeded",
+    ))
+
+
+QUOTA_MESSAGE = (
+    "⚠️ **Servis geçici olarak yanıt veremiyor.**\n\n"
+    "Yapay zekâ modeli için kullanım kotası şu anda dolmuş görünüyor. "
+    "Lütfen birkaç dakika bekledikten sonra tekrar deneyin. "
+    "Sorun devam ederse günlük limit dolmuş olabilir; bu durumda 24 saat içinde otomatik olarak yenilenecektir."
+)
+
+
+def _build_chunks_debug_string(docs: list) -> str:
+    out = ""
+    for i, doc in enumerate(docs):
+        section_name = doc.metadata.get("section", "Bilinmiyor")
+        out += f"**Parça {i+1} ({section_name}):**\n```text\n{doc.page_content}\n```\n\n"
+    return out
+
+
+def _log_candidates_detail(candidates: list, distances: list[float]) -> None:
+    """Retrieval'dan gelen aday chunk'ları (rerank öncesi) retrieval.log'a yazar.
+    Distance: ChromaDB cosine distance (düşük değer = daha yakın eşleşme)."""
+    lines = ["", "═" * 70, f"RETRIEVAL ADAYLARI (RERANK ÖNCESİ) — {len(candidates)} chunk", "═" * 70]
+    for i, doc in enumerate(candidates):
+        dist = distances[i] if i < len(distances) else None
+        dist_str = f"{dist:.4f}" if dist is not None else "N/A"
+        lines.append(f"\n┌─ #{i+1}  distance={dist_str}")
+        lines.append(f"│  metadata: {doc.metadata}")
+        lines.append(f"├─ content ({len(doc.page_content)} karakter)")
+        lines.append(doc.page_content)
+        lines.append("└" + "─" * 69)
+    lines.append("═" * 70)
+    logger.info("\n".join(lines))
+
+
+def _log_chunks_detail(docs: list, scores: list[float]) -> None:
+    """Rerank sonrası seçilen chunk'ların tam detayını retrieval.log'a yazar.
+    Her chunk için: sıra, skor, tüm metadata, tam metin."""
+    lines = ["", "═" * 70, "RERANK SONRASI SEÇİLEN CHUNK'LAR", "═" * 70]
+    for i, doc in enumerate(docs):
+        score = scores[i] if i < len(scores) else None
+        score_str = f"{score:.4f}" if score is not None else "N/A"
+        lines.append(f"\n┌─ #{i+1}  score={score_str}")
+        lines.append(f"│  metadata: {doc.metadata}")
+        lines.append(f"├─ content ({len(doc.page_content)} karakter)")
+        lines.append(doc.page_content)
+        lines.append("└" + "─" * 69)
+    lines.append("═" * 70)
+    logger.info("\n".join(lines))
+
+
+def _log_query_json(payload: dict) -> None:
+    try:
+        query_logger.info(json.dumps(payload, ensure_ascii=False))
+    except Exception as e:
+        logger.warning(f"JSONL log hatası: {e}")
+
+
+# ── Ana akış ────────────────────────────────────────────────────────────
+
+def get_answer(query: str, history: list = None) -> tuple[str, str, str]:
+    t_total = time.perf_counter()
+    history = history or []
+    flags: list[str] = []
+    logger.info(f"Sorgu: {query}")
+
+    # 1) Query rewriting
+    t = time.perf_counter()
+    try:
+        rewritten = rewrite_query(query, history) if history else query
+    except Exception as e:
+        rewritten = query
+        flags.append("rewrite_failed")
+        logger.warning(f"Rewrite hatası: {e}")
+        if _is_quota_error(e):
+            flags.append("quota_exhausted")
+            t_rewrite_ms = (time.perf_counter() - t) * 1000
+            final = append_disclaimer(QUOTA_MESSAGE)
+            _emit_log(query, rewritten, None, [], [], final, flags,
+                      t_rewrite_ms, 0.0, 0.0, 0.0, t_total)
+            return final, "Tespit edilemedi", ""
+    t_rewrite_ms = (time.perf_counter() - t) * 1000
+    if rewritten != query:
+        logger.info(f"Yeniden yazılmış sorgu: {rewritten}")
+
+    # 2) Drug detect (yeniden yazılmış sorgu üzerinde)
+    detected = detect_drug_id(rewritten)
+
+    # 3) Retrieval
+    t = time.perf_counter()
+    search_kwargs: dict = {"k": 20}
+    if detected:
+        search_kwargs["filter"] = {"drug_id": detected}
+        logger.info(f"Metadata filtresi uygulandı: drug_id={detected!r}")
+    else:
+        logger.info("Sorguda ilaç tespit edilemedi, filtre uygulanmadı")
+    try:
+        candidates_with_scores = db.similarity_search_with_score(rewritten, **search_kwargs)
+        candidates = [d for d, _ in candidates_with_scores]
+        candidate_distances = [float(s) for _, s in candidates_with_scores]
+    except Exception as e:
+        t_retrieval_ms = (time.perf_counter() - t) * 1000
+        flags.append("retrieval_failed")
+        logger.error(f"Retrieval hatası (embedding/DB erişimi başarısız): {e}")
+        final = append_disclaimer(
+            "Şu anda arama servisine erişilemiyor. Lütfen internet bağlantınızı kontrol edip birkaç saniye sonra tekrar deneyin."
+        )
+        _emit_log(query, rewritten, detected, [], [], final, flags,
+                  t_rewrite_ms, t_retrieval_ms, 0.0, 0.0, t_total)
+        return final, detected or "Tespit edilemedi", ""
+    t_retrieval_ms = (time.perf_counter() - t) * 1000
+
+    logger.info(f"Retrieval: {len(candidates)} aday chunk")
+    _log_candidates_detail(candidates, candidate_distances)
+
+    # 4) Rerank (+ skorlar)
+    t = time.perf_counter()
+    try:
+        docs, scores = rerank_jina_with_scores(rewritten, candidates, top_n=5)
+    except Exception as e:
+        docs, scores = candidates[:5], []
+        flags.append("rerank_failed")
+        logger.warning(f"Rerank hatası, orijinal sıralama kullanılıyor: {e}")
+    t_rerank_ms = (time.perf_counter() - t) * 1000
+
+    top_score = max(scores) if scores else 0.0
+
+    # 5) Güven / boş kontrol
+    if not docs or (scores and top_score < LOW_CONFIDENCE_THRESHOLD):
+        flags.append("no_docs" if not docs else "low_confidence")
+        final = append_disclaimer(REFUSAL_MESSAGE)
+        _emit_log(query, rewritten, detected, docs, scores, final, flags,
+                  t_rewrite_ms, t_retrieval_ms, t_rerank_ms, 0.0, t_total)
+        return final, detected or "Tespit edilemedi", ""
+
+    drug_id = docs[0].metadata.get("drug_id", "Bilinmiyor")
+    unique_drugs = Counter(d.metadata.get("drug_id", "Bilinmiyor") for d in docs)
+    if len(unique_drugs) > 1:
+        logger.warning(
+            f"Chunk'lar farklı ilaçlardan geliyor ({len(unique_drugs)} farklı drug_id): "
+            f"{dict(unique_drugs)}. docs[0]={drug_id} (rerank'te en alakalı) seçildi."
+        )
+    logger.info(f"Tespit edilen ilaç: {drug_id} | Döküman sayısı: {len(docs)} | top_score={top_score:.3f}")
+
+    # Detaylı chunk log'u (retrieval.log'a)
+    _log_chunks_detail(docs, scores)
+
+    # 6) LLM çağrısı
+    context = "\n\n".join(d.page_content for d in docs)
+    history_block = build_history_block(history) or "(Geçmiş yok)"
+
+    t = time.perf_counter()
+    try:
+        raw_answer = answer_chain.invoke({
+            "context": context,
+            "history": history_block,
+            "question": rewritten,
+        })
+    except Exception as e:
+        flags.append("llm_failed")
+        logger.error(f"LLM hatası: {e}")
+        if _is_quota_error(e):
+            flags.append("quota_exhausted")
+            t_llm_ms = (time.perf_counter() - t) * 1000
+            final = append_disclaimer(QUOTA_MESSAGE)
+            _emit_log(query, rewritten, detected, docs, scores, final, flags,
+                      t_rewrite_ms, t_retrieval_ms, t_rerank_ms, t_llm_ms, t_total)
+            return final, detected or "Tespit edilemedi", ""
+        raw_answer = "Bilmiyorum."
+    t_llm_ms = (time.perf_counter() - t) * 1000
+
+    # 7) "Bilmiyorum" fail-safe + kaynak bloğu
+    if _is_bilmiyorum(raw_answer):
+        answer = "Bilmiyorum."
+        logger.info("Cevap: Bilmiyorum (fail-safe)")
+    else:
+        answer = raw_answer.strip() + "\n\n---\n**Kaynaklar:**\n" + format_sources(docs)
+
+    # 8) Doktor uyarısı — garanti
+    final = append_disclaimer(answer)
+
+    # 9) Log
+    _emit_log(query, rewritten, detected, docs, scores, final, flags,
+              t_rewrite_ms, t_retrieval_ms, t_rerank_ms, t_llm_ms, t_total)
+
+    logger.info(
+        f"Toplam süre: {(time.perf_counter() - t_total) * 1000:.0f}ms | "
+        f"Bağlam: {len(context)} karakter"
+    )
+
+    used_chunks_str = _build_chunks_debug_string(docs)
+    return final, drug_id, used_chunks_str
+
+
+def _emit_log(raw_query, rewritten, detected, docs, scores, final, flags,
+              t_rewrite_ms, t_retrieval_ms, t_rerank_ms, t_llm_ms, t_total_start):
+    payload = {
+        "ts": datetime.now(timezone.utc).isoformat(timespec="milliseconds").replace("+00:00", "Z"),
+        "raw_query": raw_query,
+        "rewritten_query": rewritten,
+        "detected_drug": detected,
+        "retrieved": [
+            {
+                "idx": i,
+                "rerank_score": round(scores[i], 4) if i < len(scores) else None,
+                "metadata": dict(d.metadata),
+                "content": d.page_content,
+            }
+            for i, d in enumerate(docs)
+        ],
+        "answer_preview": (final or "")[:200],
+        "latency_ms": {
+            "rewrite": round(t_rewrite_ms, 1),
+            "retrieval": round(t_retrieval_ms, 1),
+            "rerank": round(t_rerank_ms, 1),
+            "llm": round(t_llm_ms, 1),
+            "total": round((time.perf_counter() - t_total_start) * 1000, 1),
+        },
+        "flags": flags,
+    }
+    _log_query_json(payload)

app/ui.py

@@ -0,0 +1,105 @@
+import argparse
+import gradio as gr
+import dotenv
+from app.retrieval import get_answer, DRUG_IDS, _normalize
+
+dotenv.load_dotenv()
+
+DRUG_LIST_SORTED = sorted(DRUG_IDS, key=_normalize)
+DRUG_NORMALIZED = [(d, _normalize(d)) for d in DRUG_LIST_SORTED]
+DRUG_COUNT = len(DRUG_LIST_SORTED)
+MAX_LIST_DISPLAY = 100
+
+
+def filter_drugs(query: str) -> str:
+    q = _normalize(query or "").strip()
+    if not q:
+        shown = DRUG_LIST_SORTED[:MAX_LIST_DISPLAY]
+        body = "\n".join(f"- {d}" for d in shown)
+        if DRUG_COUNT > MAX_LIST_DISPLAY:
+            body += f"\n\n_İlk {len(shown)} ilaç gösteriliyor (toplam {DRUG_COUNT}). Daraltmak için yukarıya yazın._"
+        return body
+    matches = [d for d, n in DRUG_NORMALIZED if q in n]
+    if not matches:
+        return f"_Eşleşme bulunamadı: **{query}**_"
+    shown = matches[:MAX_LIST_DISPLAY]
+    body = "\n".join(f"- {d}" for d in shown)
+    if len(matches) > MAX_LIST_DISPLAY:
+        body += f"\n\n_{len(shown)} / {len(matches)} sonuç gösteriliyor._"
+    else:
+        body += f"\n\n_{len(matches)} sonuç_"
+    return body
+
+def chat_interface(message, history):
+    if not message:
+        return ""
+
+    # RAG sistemi 3 parametre dönüyor (Cevap, İlaç ID, Kullanılan Chunklar).
+    answer, drug_id, chunks_str = get_answer(message, history)
+
+    final_response = answer
+
+    # Text chunklarını Colab hücresinin çıktısına (console) yazdırıyoruz
+    """if chunks_str:
+        print("\n" + "="*60)
+        print(f"🧐 KULLANICI SORUSU: {message}")
+        print("-" * 60)
+        print(f"📄 MODELE GÖNDERİLEN KAYNAK METİNLER (CHUNKLAR):\n\n{chunks_str}")
+        print("="*60 + "\n")  """
+
+    return final_response
+
+FORCE_DARK_JS = """
+() => {
+    const url = new URL(window.location);
+    if (url.searchParams.get('__theme') !== 'dark') {
+        url.searchParams.set('__theme', 'dark');
+        window.location.href = url.href;
+    }
+}
+"""
+
+
+# Module-level demo — `gradio app/ui.py` ile hot-reload için gerekli
+with gr.Blocks(title="İlaç KT Chatbot", theme=gr.themes.Default(), js=FORCE_DARK_JS) as demo:
+    gr.Markdown("## İlaç Sohbet Botu RAG Q&A")
+
+    gr.Markdown("""
+    ⚠️ İLAC ADLARINI YAZARKEN DOĞRU ŞEKİLDE YAZIN. BU SAYEDE SİSTEMİN DOĞRU KULLANMA TALİMATI BELGESİNİ BULMASI VE DOĞRU CEVAPLAR VERMESİ DAHA MUHTEMEL OLUR. ÖRNEK SORU: **Parol hamilelikte kullanılır mı?**
+
+    ⚠️ Bu asistan yalnızca geliştirme amaçlıdır. Her tıbbi karar öncesinde mutlaka doktorunuza veya eczacınıza danışın.
+
+    """)
+
+    gr.Markdown(
+        f"""📋 Sistemimiz şu anda **{DRUG_COUNT}** TABLET ilacın resmî Kullanma Talimatı (KT) belgesini işliyor.\n
+Kullanılan model gemini-flash-latest free tier olduğu için, günlük istek limiti bulunmakta bu nedenle bazen cevap veremeyebilir."""
+    )
+
+    with gr.Accordion("İşlenen ilaçların tam listesi", open=False):
+        drug_search = gr.Textbox(
+            placeholder="İlaç ara... (örn: parol)",
+            show_label=False,
+            container=False,
+        )
+        drug_list_view = gr.Markdown(filter_drugs(""))
+        drug_search.change(fn=filter_drugs, inputs=drug_search, outputs=drug_list_view)
+
+    gr.ChatInterface(
+        fn=chat_interface,
+        chatbot=gr.Chatbot(height=400),
+        textbox=gr.Textbox(placeholder="İlacın adını belirterek sorunuzu girin... (Örn: Parol hamilelikte kullanılır mı?)", container=False, scale=7),
+        title="Sadece İlaç KT PDF'lerine Dayanarak Cevap Veren Asistan",
+    )
+
+
+def main(host, port, share=False):
+    demo.launch(server_name=host, server_port=port, share=share)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--host", type=str, default="0.0.0.0")
+    parser.add_argument("--port", type=int, default=7860)
+    parser.add_argument("--share", action="store_true", help="Create a public link for Gradio")
+    args = parser.parse_args()
+    main(args.host, args.port, True)

chroma_db/2ec18670-9ffc-4dd2-954a-ca8c9ffb8344/data_level0.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:acaa68f51810a4200141a4a28fc3f20c2ee36c6808f82334efd3d827b2048087
+size 123839460

chroma_db/2ec18670-9ffc-4dd2-954a-ca8c9ffb8344/header.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:977a57867dce5ff67ee0c97c820f9b3f5ec07c0456268eb503691ce55ebf710e
+size 100

chroma_db/2ec18670-9ffc-4dd2-954a-ca8c9ffb8344/index_metadata.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fb8613de51de13e55ebacb91b30e8b036ba6e371d872021512c1434f27e3d6f3
+size 2689864

chroma_db/2ec18670-9ffc-4dd2-954a-ca8c9ffb8344/length.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:69a54212939283e10aee649f98ef24718e348732a743947580428f9df669876d
+size 116940

chroma_db/2ec18670-9ffc-4dd2-954a-ca8c9ffb8344/link_lists.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e68fb7ca7679131a2afa708f8c52a1fb1330b558cc7038d05acfa442a738f3f8
+size 257020

chroma_db/chroma.sqlite3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1fc93b609ed18e9cdd4f5c52bb2643e76d2ff6c21b8114f22fdc13bb06840b6c
+size 405786624

requirements.txt

@@ -0,0 +1,16 @@
+greenlet<3.1; python_version < "3.10"
+langchain
+langchain-core
+langchain-community
+langchain-text-splitters
+langchain-google-genai
+langchain-openai
+langchain-chroma
+chromadb
+gradio
+huggingface_hub<1.0
+pypdf
+tiktoken
+pydantic
+python-dotenv
+unstructured