Update app.py

app.py

@@ -3,9 +3,9 @@ import gradio as gr
 import faiss
 import numpy as np
 from sentence_transformers import SentenceTransformer
-from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments
-from peft import get_peft_model, LoraConfig, TaskType, PeftModel
-from datasets import Dataset
+from transformers import AutoTokenizer, AutoModelForCausalLM # TrainingArguments, LoraConfig, TaskType removed as not directly used for inference
+from peft import PeftModel # get_peft_model removed as not directly used for inference
+from datasets import Dataset # Not directly used in the provided snippet but kept for completeness
 import json
 import os
 from typing import List, Tuple
@@ -13,9 +13,9 @@ from functools import partial
 import random
 from datetime import datetime
 from collections import deque
-import requests
-from huggingface_hub import hf_hub_download
-import tempfile
+# import requests # Not directly used but kept for completeness
+# from huggingface_hub import hf_hub_download # Not directly used but kept for completeness
+# import tempfile # Not directly used but kept for completeness
 
 # === CSS ve Emoji Fonksiyonu ===
 current_css = """
@@ -71,11 +71,10 @@ def add_emojis(text: str) -> str:
     }
 
     found_emojis = []
-    words = text.split()
+    words = text.lower().replace('.', '').replace(',', '').replace('!', '').replace('?', '').split()
     for word in words:
-        clean_word = word.lower().strip(".,!?")
-        if clean_word in emoji_mapping:
-            found_emojis.append(emoji_mapping[clean_word])
+        if word in emoji_mapping:
+            found_emojis.append(emoji_mapping[word])
 
     unique_emojis = list(set(found_emojis))
     if unique_emojis:
@@ -85,31 +84,84 @@ def add_emojis(text: str) -> str:
 # === SABİTLER ===
 EMBEDDER_NAME = "paraphrase-multilingual-MiniLM-L12-v2"
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-FEEDBACK_FILE = "chatbot_feedback.jsonl"
-QA_PATH = "qa_dataset.jsonl"
-# Değişkenler global scope'da tanımlı
-BASE_MODEL = "ytu-ce-cosmos/turkish-gpt2-large"
-MODEL_PATH = "lordzukoiroh/montaggppt2lora"
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+FEEDBACK_FILE = "data/chatbot_feedback.jsonl" # Changed to a data directory
+QA_PATH = "data/qa_dataset.jsonl" # Changed to a data directory
+
+# Your original base model and fine-tuned model path (for reference)
+# BASE_MODEL = "ytu-ce-cosmos/turkish-gpt2-large"
+# MODEL_PATH = "lordzukoiroh/montaggppt2lora"
 
-def load_model_and_tokenizer():
-    tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL)
-    base_model = AutoModelForCausalLM.from_pretrained(BASE_MODEL).to(DEVICE)
-    model = PeftModel.from_pretrained(base_model, MODEL_PATH).to(DEVICE)
+# Using a smaller model for broader compatibility (e.g., Hugging Face Spaces free tier)
+BASE_MODEL_FOR_DEMO = "distilgpt2"
+
+# === GLOBAL DEĞİŞKENLER ===
+model = None
+tokenizer = None
+embedder = None
+paragraphs = []
+paragraph_embeddings = None # Store embeddings to avoid recomputing
+index = None
+rl_agent = None
+
+def load_model_and_tokenizer_func(base_model_name: str):
+    """Loads the base model and tokenizer."""
+    print(f"Model yükleniyor: {base_model_name}...")
+    tokenizer = AutoTokenizer.from_pretrained(base_model_name)
+    base_model = AutoModelForCausalLM.from_pretrained(base_model_name).to(DEVICE)
+
+    # If you were loading a fine-tuned LoRA model, you would uncomment and adjust this:
+    # model = PeftModel.from_pretrained(base_model, MODEL_PATH).to(DEVICE)
+    model_to_return = base_model # For this demo, we use the base model
 
     if tokenizer.pad_token is None:
         tokenizer.pad_token = tokenizer.eos_token
+    
+    model_to_return.eval()
+    print(f"Model {base_model_name} yüklendi.")
+    return model_to_return, tokenizer
 
-    model.eval()
-    return model, tokenizer
+def initialize_components():
+    global model, tokenizer, embedder, paragraphs, paragraph_embeddings, index, rl_agent
+    
+    try:
+        print("Model ve tokenizer yükleniyor...")
+        model, tokenizer = load_model_and_tokenizer_func(BASE_MODEL_FOR_DEMO)
+        
+        print("Embedder yükleniyor...")
+        embedder = SentenceTransformer(EMBEDDER_NAME)
+        print("Embedder yüklendi.")
 
-model, tokenizer = load_model_and_tokenizer()
+        print("Metin işleniyor...")
+        # Clean and filter paragraphs, ensure they are substantial enough for embedding
+        paragraphs = [p.strip() for p in FAHRENHEIT_451_TEXT.split("\n") if len(p.strip().split()) > 10]
+        
+        print(f"Toplam {len(paragraphs)} paragraf işlendi.")
+        if not paragraphs:
+            raise ValueError("No valid paragraphs extracted from the text.")
 
+        print("Embeddingler hesaplanıyor ve FAISS indeksi oluşturuluyor...")
+        paragraph_embeddings = embedder.encode(paragraphs, convert_to_numpy=True)
+        
+        # Ensure embeddings are float32 for FAISS
+        if paragraph_embeddings.dtype != np.float32:
+            paragraph_embeddings = paragraph_embeddings.astype(np.float32)
 
-#
+        index = faiss.IndexFlatL2(paragraph_embeddings.shape[1])
+        index.add(paragraph_embeddings)
+        print("Embeddingler ve FAISS indeksi hazır.")
+
+        print("RL Agent başlatılıyor...")
+        rl_agent = RLAgent(embedder.get_sentence_embedding_dimension())
+        print("RL Agent hazır.")
 
+        print("Tüm bileşenler başarıyla yüklendi!")
+        return True
+    except Exception as e:
+        print(f"Bileşenler yüklenirken hata: {e}")
+        return False
 
 # === Fahrenheit 451 Metni (Örnek paragraflar) ===
+# Moved up for clarity and scope if needed elsewhere, though it's already a global string.
 FAHRENHEIT_451_TEXT = """
 Montag mutlu değildi. Fark etmesi ancak kapısının önüne kadar gelmesi ile oldu. Gece yarısı vakti, sokağın sonunda çevresine yayılan karanlık içinde duran ev, rüzgarın yaprak hışırtısı ve soluğunu görebilir kılacak kadar soğuk havada ev ona garip bir görüntü sunuyordu.
 
@@ -145,8 +197,6 @@ Montag şaşkınlıkla kızın yüzüne baktı. Karanlık gecenin ortasında, so
 
 "Niye yaptı bunu?" diye sordu Montag. "Bilmiyoruz," dedi teknisyen. "Belki çok mutsuzdu. Belki de kazayla oldu. Çok yaygın bir durum." "Yaygın mı?" "Evet. İnsanlar çok bunalıyor. Televizyonda her şey çok hızlı. Radyoda çok gürültü. Herkes koşuyor. Kimse durmuyor."
 
-Montag teknisyenlerin çalışmasını izledi. Karısının yüzü çok solgundu. Sanki ölmüş gibiydi. Ama nefes alıyordu. Teknisyenler işlerini bitirdiler. "Sabaha kadar uyuyacak," dediler. "Yarın normal olacak. Hiçbir şey hatırlamayacak."
-
 Montag yalnız kaldı. Karısına baktı. Çok solgun görünüyordu. Montag Clarisse'i düşündü. "Mutlu musun?" sorusu kafasına takıldı. Gerçekten mutlu muydu? Karısı niye böyle bir şey yapmıştı?
 
 Montag pencereye gitti. Dışarı baktı. Sokak çok sessizdi. Kimse yoktu. Sadece sokak lambaları yanıyordu. Montag Clarisse'in yüzünü düşündü. Kızın gözleri çok parlaktı. Çok canlıydı. Sanki her şeyi görüyordu.
@@ -198,6 +248,7 @@ Ve o gece, Montag çok önemli bir karar verdi. Bir kitap okumaya karar verdi. Y
 
 # === DOSYA KAYIT ===
 def save_feedback(user_question: str, answer: str, liked: bool, filepath: str = FEEDBACK_FILE):
+    os.makedirs(os.path.dirname(filepath), exist_ok=True) # Ensure directory exists
     feedback_entry = {
         "input": user_question,
         "output": answer,
@@ -225,8 +276,12 @@ class RLAgent:
     def record_experience(self, user_question: str, generated_answer: str, liked: bool):
         try:
             combined_text = f"Soru: {user_question} Cevap: {generated_answer}"
+            # Ensure embedder is available
+            if embedder is None:
+                print("Embedder not initialized, cannot record experience.")
+                return
             embedding = embedder.encode([combined_text], convert_to_tensor=True).squeeze(0).to(self.device)
-            reward = 1.0 if liked else -1.5
+            reward = 1.0 if liked else -1.5 # Adjusted negative reward for stronger signal
             self.experience_buffer.append((embedding, torch.tensor([reward], dtype=torch.float32).to(self.device)))
             self.train_reward_model()
         except Exception as e:
@@ -251,15 +306,18 @@ class RLAgent:
 
             avg_reward = rewards.mean().item() if rewards.numel() > 0 else 0
 
+            # Adjust parameters more subtly
             if avg_reward > 0.5:
-                self.current_temp = max(1.0, self.current_temp - self.learning_rate_reward * 0.1)
-                self.current_rep_penalty = max(1.1, self.current_rep_penalty - self.learning_rate_reward * 0.05)
+                self.current_temp = max(0.9, self.current_temp - self.learning_rate_reward * 0.05) # Lower temp for more deterministic good answers
+                self.current_rep_penalty = max(1.0, self.current_rep_penalty - self.learning_rate_reward * 0.02)
             elif avg_reward < -0.5:
-                self.current_temp = min(1.5, self.current_temp + self.learning_rate_reward * 0.2)
-                self.current_rep_penalty = min(2.0, self.current_rep_penalty + self.learning_rate_reward * 0.1)
+                self.current_temp = min(1.5, self.current_temp + self.learning_rate_reward * 0.05) # Higher temp for more exploration if bad
+                self.current_rep_penalty = min(2.0, self.current_rep_penalty + self.learning_rate_reward * 0.02)
 
             self.current_temp = float(np.clip(self.current_temp, 0.8, 1.8))
-            self.current_rep_penalty = float(np.clip(self.current_rep_penalty, 1.1, 2.5))
+            self.current_rep_penalty = float(np.clip(self.current_rep_penalty, 1.0, 2.5)) # Allow lower rep penalty
+            # print(f"INFO: Updated generation params - Temp: {self.current_temp:.2f}, Rep_Penalty: {self.current_rep_penalty:.2f}")
+
         except Exception as e:
             print(f"Error training reward model: {e}")
 
@@ -269,51 +327,20 @@ class RLAgent:
             "repetition_penalty": self.current_rep_penalty
         }
 
-# === GLOBAL DEĞİŞKENLER ===
-model = None
-tokenizer = None
-embedder = None
-paragraphs = []
-index = None
-rl_agent = None
-
-def initialize_components():
-    global model, tokenizer, embedder, paragraphs, index, rl_agent
-    
+def retrieve_context(query: str, k: int = 2) -> str:
+    """FAISS indeksini kullanarak sorguya en uygun paragrafları getirir."""
+    if index is None or embedder is None or not paragraphs:
+        print("WARNING: FAISS index, embedder or paragraphs not initialized for context retrieval.")
+        return "Bağlam bulunamadı."
     try:
-        print("Model yükleniyor...")
-        # Basit bir model kullanıyoruz - HF Space'te büyük modeller yüklenemeyebilir
-        tokenizer = AutoTokenizer.from_pretrained("distilgpt2")
-        model = AutoModelForCausalLM.from_pretrained("distilgpt2").to(DEVICE)
-        
-        if tokenizer.pad_token is None:
-            tokenizer.pad_token = tokenizer.eos_token
+        query_embedding = embedder.encode([query], convert_to_numpy=True).astype(np.float32)
+        D, I = index.search(query_embedding, k) # D: distances, I: indices
         
-        model.eval()
-        print("Model yüklendi.")
-
-        print("Embedder yükleniyor...")
-        embedder = SentenceTransformer(EMBEDDER_NAME)
-        print("Embedder yüklendi.")
-
-        print("Metin işleniyor...")
-        paragraphs = [p.strip() for p in FAHRENHEIT_451_TEXT.split("\n") if len(p.strip()) > 50]
-        
-        print("Embeddingler hesaplanıyor...")
-        paragraph_embeddings = embedder.encode(paragraphs, convert_to_numpy=True)
-        index = faiss.IndexFlatL2(paragraph_embeddings.shape[1])
-        index.add(paragraph_embeddings)
-        print("Embeddingler hazır.")
-
-        print("RL Agent başlatılıyor...")
-        rl_agent = RLAgent(embedder.get_sentence_embedding_dimension())
-        print("RL Agent hazır.")
-
-        print("Tüm bileşenler başarıyla yüklendi!")
-        return True
+        retrieved_texts = [paragraphs[i] for i in I[0] if i < len(paragraphs)]
+        return "\n".join(retrieved_texts)
     except Exception as e:
-        print(f"Bileşenler yüklenirken hata: {e}")
-        return False
+        print(f"Bağlam alınırken hata: {e}")
+        return "Bağlam alınırken bir sorun oluştu."
 
 # === MONTAG PERSONA ===
 MONTAG_PERSONA = (
@@ -323,11 +350,10 @@ MONTAG_PERSONA = (
     f"- Derin, felsefi ve düşündürücü cevaplar verirsin.\n"
     f"- Kitapların değerini çok iyi bilirsin ve onlara karşı gizli bir sevgi beslersin.\n"
     f"- Toplumun baskıcı yapısına karşı içten içe isyankarsın ve arayış içindesin.\n"
-    f"- Cevapların 2-5 cümle arasında, net, özgün ve akıcıdır. Bazen alaycı, sorgulayıcı veya melankolik bir ton kullanırsın.\n"
+    f"- Cevapların **2 ila 5 cümle** arasında, net, özgün ve akıcıdır. Bazen alaycı, sorgulayıcı veya melankolik bir ton kullanırsın.\n"
     f"- Asla kendini tekrarlamazsın ve genel geçer ifadelerden kaçınırsın.\n"
 )
 
-
 # === ALTERNATİF CEVAPLAR ===
 alternative_responses = [
     "Bu soru bana Clarisse'i hatırlattı... Onun da sorgulayan bir ruhu vardı, tıpkı şimdi senin sorduğun gibi.",
@@ -346,30 +372,36 @@ alternative_responses = [
     "Bir itfaiyeci olarak benim görevim yakmak... Ama bazen bir soru, yaktığım bin kitaptan daha çok aydınlatır.",
     "Clarisse'i ilk gördüğümde bana sorduğu o soruyu hatırladım. Senin bu sorun da o kadar masum ama yıkıcı."
 ]
+
 def generate_alternative_response(user_question: str) -> str:
     """Modelin cevap üretemediği veya yetersiz cevap verdiği durumlarda alternatif bir yanıt döndürür."""
-    # Montag persona'sına uygun, rastgele bir alternatif cevap seçelim
-    # user_question'ı doğrudan kullanmasak da, signature'da tutmak uygun olabilir
-    
     response = random.choice(alternative_responses)
-    
-    # Cevaba emoji ekleme mantığını da burada kullanabiliriz
     final_response = add_emojis(response)
     return final_response
     
 def generate_answer(question: str, chatbot_history: List[List[str]]) -> str:
+    if model is None or tokenizer is None or rl_agent is None:
+        print("ERROR: Model, tokenizer veya RL Agent başlatılmamış.")
+        return generate_alternative_response(question)
+
     try:
         gen_params = rl_agent.get_generation_params()
-        context = retrieve_context(question)
+        context = retrieve_context(question) # Call the correct retrieve_context
 
         history_text = ""
         if chatbot_history:
+            # Get last 3 turns to maintain short-term context
             recent_dialogue = []
-            for user_msg, assistant_msg in chatbot_history[-3:]:
+            for user_msg, assistant_msg in chatbot_history[-3:]: 
                 if user_msg:
-                    recent_dialogue.append(f"Kullanıcı: {user_msg.replace('📚', '').replace('🧠', '').replace('🔥', '').strip()}")
+                    # Clean emojis from history before passing to model
+                    cleaned_user_msg = user_msg.replace('📚', '').replace('🧠', '').replace('🔥', '').strip()
+                    if cleaned_user_msg:
+                        recent_dialogue.append(f"Kullanıcı: {cleaned_user_msg}")
                 if assistant_msg:
-                    recent_dialogue.append(f"Montag: {assistant_msg.replace('📚', '').replace('🧠', '').replace('🔥', '').strip()}")
+                    cleaned_assistant_msg = assistant_msg.replace('📚', '').replace('🧠', '').replace('🔥', '').strip()
+                    if cleaned_assistant_msg:
+                        recent_dialogue.append(f"Montag: {cleaned_assistant_msg}")
             history_text = "\n".join(recent_dialogue) + "\n"
 
         prompt = (
@@ -377,75 +409,71 @@ def generate_answer(question: str, chatbot_history: List[List[str]]) -> str:
             f"Bağlam:\n{context}\n\n"
             f"Önceki Sohbet:\n{history_text}\n"
             f"Soru: {question}\n"
-            f"Montag (tipik tarzında cevap verir):"
+            f"Montag (cevap 2 ila 5 cümle arasında olmalı):" # Explicitly tell model the sentence limit
         )
 
         inputs = tokenizer.encode(prompt, return_tensors="pt", truncation=True, max_length=512).to(DEVICE)
 
         outputs = model.generate(
             inputs,
-            max_new_tokens=150,
+            max_new_tokens=100, # Increased max_new_tokens to allow for 2-5 sentences
             do_sample=True,
             top_p=0.9,
             temperature=gen_params["temperature"],
             repetition_penalty=gen_params["repetition_penalty"],
-            no_repeat_ngram_size=3,
+            no_repeat_ngram_size=3, # Helps prevent direct repetition of phrases
             num_beams=1,
             pad_token_id=tokenizer.eos_token_id,
             eos_token_id=tokenizer.eos_token_id,
-            early_stopping=True
+            early_stopping=True # Stop when EOS token is generated
         )
-        
+
         response = tokenizer.decode(outputs[0], skip_special_tokens=True)
 
-        if "Montag (tipik tarzında cevap verir):" in response:
-            response = response.split("Montag (tipik tarzında cevap verir):")[-1].strip()
+        # Post-processing to extract Montag's specific response and trim prefix
+        if "Montag (cevap 2 ila 5 cümle arasında olmalı):" in response:
+            response = response.split("Montag (cevap 2 ila 5 cümle arasında olmalı):")[-1].strip()
         else:
-            prompt_start = " ".join(prompt.split()[:10])
-            if response.startswith(prompt_start):
-                response = response[len(prompt):].strip()
-
-        generic_phrases = [
-            "bilmiyorum", "emin değilim", "cevap veremem", "daha fazla bilgiye ihtiyacım var",
-            "ne düşünmem gerektiğini bilmiyorum", "anlamadım", "tekrar eder misin",
-            "evet", "hayır", "hmm", "sanırım", "bunu hiç düşünmemiştim", "düşünmem gerekiyor"
-        ]
-
-        is_generic_or_too_short = (
-            any(phrase in response.lower() for phrase in generic_phrases) or
-            len(response.split()) < 10 or
-            response.count('.') + response.count('?') + response.count('!') < 1 or
-            (response.count('.') + response.count('?') + response.count('!') == 1 and len(response.split()) < 15)
-        )
+            # Fallback if the marker isn't found (e.g., model truncated or ignored)
+            # Try to remove the prompt part from the beginning of the response
+            prompt_end_marker_len = len(f"Soru: {question}\nMontag (cevap 2 ila 5 cümle arasında olmalı):")
+            # This check is a bit tricky, but aims to remove the input prompt if it's echoed
+            if len(response) > len(prompt) and response.startswith(prompt[:-min(prompt_end_marker_len, len(prompt))]):
+                 response = response[len(prompt):].strip()
 
-        if is_generic_or_too_short:
-            print("INFO: Generic/Too short response detected, generating alternative.")
-            return generate_alternative_response(question)
 
+        # Ensure response adheres to 2-5 sentence structure and isn't too generic
         sentences = []
         current_sentence_parts = []
         sentence_count = 0
-
+        
+        # Simple sentence tokenization based on punctuation
         for char in response:
             current_sentence_parts.append(char)
             if char in ['.', '!', '?']:
                 sentence = "".join(current_sentence_parts).strip()
-                if sentence:
+                if sentence: # Add sentence if not empty
                     sentences.append(sentence)
                     sentence_count += 1
                 current_sentence_parts = []
-                if sentence_count >= 5:
+                if sentence_count >= 5: # Stop after 5 sentences
                     break
-
+        
+        # Add any remaining part as a sentence if it's not just whitespace
         if current_sentence_parts and "".join(current_sentence_parts).strip():
             final_part = "".join(current_sentence_parts).strip()
-            if final_part and (sentence_count < 5 or (sentence_count == 5 and len(sentences) < 5)):
-                 sentences.append(final_part)
+            if final_part and sentence_count < 5: # Only add if we haven't reached 5 sentences yet
+                sentences.append(final_part)
+            elif final_part and sentence_count == 5 and len(sentences) < 5: # Edge case: ensure 5th sentence is added if still building
+                sentences.append(final_part)
+
 
         response_cleaned = ' '.join(sentences).strip()
 
-        if not response_cleaned or len(response_cleaned.split()) < 5:
-            print("INFO: Post-processing resulted in too short response, generating alternative.")
+        # Final check for quality and length
+        # A good Montag response should be at least 15 words and have at least 2 sentences
+        if not response_cleaned or len(response_cleaned.split()) < 15 or sentence_count < 2:
+            print("INFO: Generated response is too short or malformed after processing. Generating alternative.")
             return generate_alternative_response(question)
 
         final_response = add_emojis(response_cleaned)
@@ -454,12 +482,6 @@ def generate_answer(question: str, chatbot_history: List[List[str]]) -> str:
     except Exception as e:
         print(f"Error generating answer: {e}")
         return generate_alternative_response(question)
-        
-def retrieve_context(question: str, top_k=3) -> str:
-    question_embedding = embedder.encode([question], convert_to_numpy=True)
-    D, I = index.search(question_embedding, top_k)
-    retrieved_paragraphs = [paragraphs[i] for i in I[0] if i < len(paragraphs)]
-    return "\n".join(retrieved_paragraphs)
 
 
 # === Gradio callback fonksiyonları ===
@@ -467,83 +489,66 @@ def respond(msg: str, chatbot_history: List[List[str]]) -> Tuple[str, List[List[
     if not msg.strip():
         return "", chatbot_history
 
-    # Tokenize et
-    input_ids = tokenizer.encode(msg, return_tensors="pt").to(DEVICE)
-
-    # Modelden cevap üret
-    output = model.generate(
-        input_ids=input_ids,
-        max_new_tokens=150,
-        temperature=0.8,
-        top_p=0.95,
-        top_k=50,
-        do_sample=True,
-        repetition_penalty=1.1,
-        pad_token_id=tokenizer.eos_token_id,
-        eos_token_id=tokenizer.eos_token_id
-    )
+    # This now correctly calls generate_answer, which handles RAG and RL parameters
+    answer = generate_answer(msg, chatbot_history)
 
-    # Tokenleri stringe çevir
-    answer = tokenizer.decode(output[0], skip_special_tokens=True)
-
-    # Sohbet geçmişine ekle
-    chatbot_history.append([msg, answer])
+    # Ensure no duplicate responses are appended (if user clicks send multiple times)
+    if not chatbot_history or chatbot_history[-1] != [msg, answer]:
+        chatbot_history.append([msg, answer])
 
     return "", chatbot_history
 
-
 def regenerate_answer(chatbot_history: List[List[str]]) -> Tuple[str, List[List[str]]]:
+    """Generates a new answer for the last user question using the main generation logic."""
     if not chatbot_history:
         return "", []
 
-    last_user_question = chatbot_history[-1][0]
+    last_user_question = chatbot_history[-1][0] # Get the last user question
 
     if last_user_question:
-        chatbot_history.pop()
+        # Remove the previous assistant answer to replace it
+        chatbot_history.pop() 
 
-        new_answer = generate_answer(last_user_question, chatbot_history)
-        chatbot_history.append([last_user_question, new_answer])
+        new_answer = generate_answer(last_user_question, chatbot_history) # Generate new answer
+        chatbot_history.append([last_user_question, new_answer]) # Add new answer
         return "", chatbot_history
     return "", chatbot_history
 
 
-def feedback_callback(chatbot_history: List[List[str]], liked: bool) -> None:
+def feedback_callback(chatbot_history: List[List[str]], liked: bool) -> str:
     if not chatbot_history:
-        return
-
-    last_pair = chatbot_history[-1]
-    if len(last_pair) != 2:
-        return
-
-    user_question, answer = last_pair
-    if user_question and answer:
-        save_feedback(user_question, answer, liked)
-        rl_agent.record_experience(user_question, answer, liked)
-
+        return "Önce bir sohbet gerçekleştirin."
 
     last_user_question = chatbot_history[-1][0]
     last_assistant_answer = chatbot_history[-1][1]
 
     if last_user_question and last_assistant_answer:
-        save_feedback(last_user_question, last_assistant_answer, liked, FEEDBACK_FILE)
+        # Clean emojis before saving feedback or passing to RL agent
+        cleaned_user_question = last_user_question.replace('📚', '').replace('🧠', '').replace('🔥', '').strip()
+        cleaned_assistant_answer = last_assistant_answer.replace('📚', '').replace('🧠', '').replace('🔥', '').strip()
+
+        # ONLY ONE CALL FOR SAVE AND RECORD
+        save_feedback(cleaned_user_question, cleaned_assistant_answer, liked, FEEDBACK_FILE)
 
         rl_agent.record_experience(
-            last_user_question.replace('📚', '').replace('🧠', '').replace('🔥', '').strip(),
-            last_assistant_answer.replace('📚', '').replace('🧠', '').replace('🔥', '').strip(),
+            cleaned_user_question,
+            cleaned_assistant_answer,
             liked
         )
 
         if liked:
-            qa_pair = {"question": last_user_question, "answer": last_assistant_answer, "liked": True}
+            # Save liked QA pairs for potential future fine-tuning or analysis
+            qa_pair = {"question": cleaned_user_question, "answer": cleaned_assistant_answer, "liked": True}
+            os.makedirs(os.path.dirname(QA_PATH), exist_ok=True)
             with open(QA_PATH, "a", encoding="utf-8") as f:
                 f.write(json.dumps(qa_pair, ensure_ascii=False) + "\n")
-
-        return "Geri bildiriminiz kaydedildi. Teşekkürler!"
+            return "Geri bildiriminiz kaydedildi. Teşekkürler! 👍"
+        else:
+            return "Geri bildiriminiz kaydedildi. Yeni bir yanıt denenecek. 👎"
     return "Geri bildirim kaydedilemedi. Geçmişte yeterli sohbet bulunmuyor."
 
 # === Gradio arayüzü == #
-current_css = """#chatbot { overflow-y: auto; }"""
-
+# current_css defined at the top of the file
 def create_chat_interface():
     with gr.Blocks(theme=gr.themes.Soft(), css=current_css) as demo:
         gr.Markdown("""
@@ -560,17 +565,25 @@ def create_chat_interface():
 
         with gr.Row():
             like_btn = gr.Button("👍 Beğendim")
-            dislike_btn = gr.Button("👎 Beğenmedim (Alternatif Cevap)")
+            dislike_btn = gr.Button("👎 Beğenmedim (Yeni Cevap Dene)")
 
         feedback_status_output = gr.Textbox(label="Geri Bildirim Durumu", interactive=False, max_lines=1)
 
         msg.submit(respond, [msg, chatbot], [msg, chatbot])
         submit_btn.click(respond, [msg, chatbot], [msg, chatbot])
-        clear_btn.click(lambda: [], None, chatbot, queue=False)
+        clear_btn.click(lambda: [], None, chatbot, queue=False) # Clear button resets the chat
 
+        # When "Like" is clicked, record feedback.
         like_btn.click(partial(feedback_callback, liked=True), [chatbot], [feedback_status_output])
+        
+        # When "Dislike" is clicked, record feedback AND regenerate the answer.
         dislike_btn.click(partial(feedback_callback, liked=False), [chatbot], [feedback_status_output])
-        dislike_btn.click(regenerate_answer, [chatbot], [msg, chatbot], queue=False)
+        dislike_btn.click(
+            regenerate_answer, 
+            [chatbot], 
+            [msg, chatbot], # msg for clearing input, chatbot for updating chat
+            queue=False # Important for immediate regeneration
+        )
     return demo
 
 
@@ -580,4 +593,4 @@ if __name__ == "__main__":
         demo = create_chat_interface()
         demo.launch()
     else:
-        print("Uygulama başlatılamadı: Bileşenler yüklenirken hata oluştu.")
+        print("Uygulama başlatılamadı: Bileşenler yüklenirken hata oluştu.")