Update app.py

app.py

@@ -1,201 +1,256 @@
+import gradio as gr
 import os
-import logging
-import traceback
+from langchain_community.vectorstores import FAISS
+from langchain_together import TogetherEmbeddings, Together
+from langchain.prompts import ChatPromptTemplate
+from langchain.schema.runnable import RunnablePassthrough
+from langchain.schema.output_parser import StrOutputParser
+from langchain.memory import ConversationBufferMemory
 from typing import List, Tuple
+import re
 
-import gradio as gr
-from dotenv import load_dotenv
-
-from langchain.document_loaders import TextLoader
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain.embeddings import OpenAIEmbeddings
-from langchain.vectorstores import FAISS
-from langchain.chat_models import ChatOpenAI
-from langchain.chains import RetrievalQA
-from langchain.prompts import PromptTemplate
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Load environment variables
-load_dotenv()
-
-class RAGChatbot:
-    def __init__(self, document_path):
-        """
-        Initialize RAG Chatbot with document vectorization
-        
-        :param document_path: Path to the input document
-        """
-        self.openai_api_key = os.getenv('OPENAI_API_KEY')
-        
-        if not self.openai_api_key:
-            raise ValueError("OpenAI API Key is not set. Please add it to environment variables.")
-        
-        self.document_path = document_path
-        self.vectorstore = self._load_or_create_vector_store()
-        self.qa_system = self._create_qa_system()
+TOGETHER_API_KEY = os.getenv('TOGETHER_API_KEY')
 
-    def _load_or_create_vector_store(self):
-        """
-        Load existing FAISS index or create a new one
-        
-        :return: FAISS vector store
-        """
-        try:
-            embeddings = OpenAIEmbeddings(openai_api_key=self.openai_api_key)
-            
-            # Check if index exists
-            if os.path.exists('faiss_index'):
-                logger.info("Loading existing vector store...")
-                return FAISS.load_local('faiss_index', embeddings)
-            
-            # Create new vector store
-            logger.info("Creating new vector store...")
-            loader = TextLoader(self.document_path, encoding='utf-8')
-            documents = loader.load()
-            
-            text_splitter = RecursiveCharacterTextSplitter(
-                chunk_size=3000,
-                chunk_overlap=600,
-                separators=["\n\n\n", "\n\n", "\n", ".", " ", ""]
-            )
-            texts = text_splitter.split_documents(documents)
-            
-            vectorstore = FAISS.from_documents(texts, embeddings)
-            
-            # Ensure faiss_index directory exists
-            os.makedirs('faiss_index', exist_ok=True)
-            vectorstore.save_local('faiss_index')
-            
-            return vectorstore
-        
-        except Exception as e:
-            logger.error(f"Vector store creation error: {e}")
-            logger.error(traceback.format_exc())
-            raise
 
-    def _create_qa_system(self):
-        """
-        Create Question-Answering system with custom prompt
-        
-        :return: RetrievalQA chain
-        """
-        custom_prompt = PromptTemplate(
-            input_variables=["context", "question"],
-            template="""You are an expert AI assistant for Beeline Uzbekistan tariffs. 
-            Provide clear, precise answers based on the context. 
-            Respond in the language of the question.
-            
-            Context: {context}
-            Question: {question}
-            
-            Comprehensive Answer:"""
+class ChatBot:
+    def __init__(self):
+        self.embeddings = TogetherEmbeddings(
+            model="togethercomputer/m2-bert-80M-32k-retrieval",
+            together_api_key=TOGETHER_API_KEY
         )
+
+
+
+
+
+
+
+
+
+
+
+
+
         
-        llm = ChatOpenAI(
-            model_name="gpt-3.5-turbo",
-            openai_api_key=self.openai_api_key,
-            temperature=0.1
+        self.vectorstore = FAISS.load_local(
+            ".",
+            embeddings=self.embeddings,
+            allow_dangerous_deserialization=True  
         )
+        self.retriever = self.vectorstore.as_retriever()
         
-        return RetrievalQA.from_chain_type(
-            llm=llm,
-            chain_type="stuff",
-            retriever=self.vectorstore.as_retriever(
-                search_type="mmr",
-                search_kwargs={"k": 4, "fetch_k": 10}
-            ),
-            chain_type_kwargs={"prompt": custom_prompt}
+        self.model = Together(
+            model="meta-llama/Llama-3.3-70B-Instruct-Turbo",
+            temperature=0.4,
+            max_tokens=256,
+            top_k=30,
+            together_api_key=TOGETHER_API_KEY
         )
-
-    def chat(self, message: str, history: List[Tuple[str, str]]) -> str:
-        """
-        Main chat method with multilingual support
         
-        :param message: User input message
-        :param history: Chat history
-        :return: Bot response
-        """
-        # Handle initial greeting
-        if message.lower() in ['init', 'start', 'begin']:
-            return "Assalomu alaykum! 📱 Beeline tarifları haqida qanday ma'lumot kerak? (Hello! What Beeline tariff information do you need?)"
+        self.memory = ConversationBufferMemory(
+            return_messages=True,
+            memory_key="chat_history",
+            output_key="answer"
+        )
         
-        # Multilingual greeting handling
-        greetings = {
-            'uz': ['salom', 'assalomu alaykum', 'hammaga salom'],
-            'ru': ['привет', 'здравствуйте', 'hi', 'hello'],
-            'en': ['hi', 'hello', 'hey']
-        }
+        self.template = """Quyidagi ko'rsatmalarga qat'iy rioya qiling:
+
+
+
+1. Faqat o'zbek tilida javob bering
+2. Faqat berilgan ma'lumotlar asosida javob bering
+3. Agar savol tushunarsiz bo'lsa yoki ma'lumot bo'lmasa, "Kechirasiz, bu haqida ma'lumotga ega emasman" deb javob bering
+4. O'zingizdan savol bermang
+5. Javobni takrorlamang
+6. Salomlashish uchun "Assalomu alaykum" yoki "Vaalaykum assalom" dan foydalaning
+
+Kontekst: {context}
+Suhbat Tarixi: {chat_history}
+Savol: {question}
+
+Javob:"""
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        self.prompt = ChatPromptTemplate.from_template(self.template)
         
-        for lang, greeting_list in greetings.items():
-            if message.lower() in greeting_list:
-                return {
-                    'uz': "Salom! Sizga qanday yordam bera olaman? 🤖",
-                    'ru': "Привет! Чем могу помочь? 🤖",
-                    'en': "Hello! How can I assist you today about Beeline tariffs? 🤖"
-                }[lang]
+        self.chain = (
+            {
+                "context": self.retriever,
+                "chat_history": lambda x: self.get_chat_history(),
+                "question": RunnablePassthrough()
+            }
+            | self.prompt
+            | self.model
+            | StrOutputParser()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        )
+
+    def get_chat_history(self) -> str:
+        messages = self.memory.load_memory_variables({})["chat_history"]
+        return "\n".join([f"{m.type}: {m.content}" for m in messages])
+    
+    def process_response(self, response: str) -> str:
+        unwanted_tags = ["[INST]", "[/INST]", "<s>", "</s>"]
+        for tag in unwanted_tags:
+            response = response.replace(tag, "")
         
+        response = re.sub(r"```.*?```", "", response, flags=re.DOTALL)
+        response = re.sub(r"print\(.*?\)", "", response)
+        response = re.sub(r'\s+', ' ', response)
+    
+        return response.strip()
+
+    def chat(self, message: str, history: List[Tuple[str, str]]) -> str:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
         try:
-            # Query the document
-            response = self.qa_system.run(message)
+
+
             
-            # Add conversational touch
-            response += "\n\n📞 Yana bir nima so'rashingizni xohlar edingizmi? (Would you like to ask anything else?)"
+            if message == "__init__":
+                return "Assalomu alaykum. Sizga qanday yordam bera olaman?"
+                
+            self.memory.chat_memory.add_user_message(message)
+            response = self.chain.invoke(message)
+            clean_response = self.process_response(response)
             
-            return response
-        
+            if not clean_response or len(clean_response.split()) < 3:
+                clean_response = "Kechirasiz, savolingizni tushunolmadim. Iltimos, batafsilroq savol bering."
+            
+            self.memory.chat_memory.add_ai_message(clean_response)
+            return clean_response
         except Exception as e:
-            logger.error(f"Chat processing error: {e}")
-            logger.error(traceback.format_exc())
-            return "Kechirasiz, so'rovingizni qayta ishlashda xatolik yuz berdi. Iltimos, qaytadan urinib ko'ring. (Sorry, there was an error processing your request. Please try again.)"
+            return f"Xatolik yuz berdi: {str(e)}"
+
+    def reset_chat(self) -> List[Tuple[str, str]]:
+        self.memory.clear()
+        return []
 
 def create_demo() -> gr.Interface:
-    """
-    Create Gradio interface for the chatbot
-    
-    :return: Gradio demo
-    """
-    # Initialize chatbot with document
-    chatbot = RAGChatbot('12.txt')
+    chatbot = ChatBot()
+
+
+
+
+
+
     
     with gr.Blocks() as demo:
-        gr.Markdown("# 📱 Beeline Uzbekistan Tariff Assistant")
+        gr.Markdown("""# RAG Chatbot
+        Beeline Uzbekistanning jismoniy shaxslar uchun tariflari haqida ma'lumotlar beruvchi bot""")
+        
         
         chatbot_interface = gr.Chatbot(
-            height=600, 
+            height=600,
             show_copy_button=True,
-            avatar_images=["🤔", "🤖"]  # User and Bot avatars
+
         )
         
         with gr.Row():
             msg = gr.Textbox(
-                show_label=False, 
-                placeholder="Beeline tariffları haqida so'rang... (Ask about Beeline tariffs...)", 
+                show_label=False,
+                placeholder="Xabaringizni shu yerda yozing",
                 container=False
             )
-            submit = gr.Button("Yuborish (Send)", variant="primary")
-            clear = gr.Button("Yangi suhbat (New Chat)")
+            submit = gr.Button("Xabarni yuborish", variant="primary")
+        
+        clear = gr.Button("Yangi suhbat")
         
         def respond(message, chat_history):
+            message = message.strip()
+            if not message:
+                return "", chat_history
+            
             bot_message = chatbot.chat(message, chat_history)
             chat_history.append((message, bot_message))
             return "", chat_history
         
         def init_chat():
-            initial_greeting = chatbot.chat("init", [])
+            
+            initial_greeting = chatbot.chat("__init__", [])
             return [("", initial_greeting)]
         
-        # Event handlers
+
         submit.click(respond, [msg, chatbot_interface], [msg, chatbot_interface])
         msg.submit(respond, [msg, chatbot_interface], [msg, chatbot_interface])
-        clear.click(fn=init_chat, inputs=None, outputs=chatbot_interface)
-        demo.load(init_chat, inputs=None, outputs=chatbot_interface)
+        clear.click(init_chat, None, chatbot_interface)
+        
+        
+        demo.load(init_chat, None, chatbot_interface)
     
     return demo
 
-# Main execution
+
 demo = create_demo()
+
 if __name__ == "__main__":
-    demo.launch(debug=True)
+    demo.launch()