Update app.py

app.py

@@ -1,49 +1,131 @@
 import os
+import streamlit as st
+import torch
+from typing import List, Dict, Any
 from langchain_core.prompts import ChatPromptTemplate
 from langchain_groq import ChatGroq
-from transformers import pipeline
-import torch
-from groq import Groq
 from langchain_community.vectorstores import Chroma
+from langchain_community.embeddings import HuggingFaceBgeEmbeddings
 from langchain.text_splitter import RecursiveCharacterTextSplitter
 from langchain.chains import RetrievalQA
-from langchain_community.embeddings import HuggingFaceBgeEmbeddings
-from langchain.prompts import PromptTemplate
-import streamlit as st
-
-# GROQ_API_KEY = os.getenv('GROQ_API_KEY')
-GROQ_API_KEY = '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'
-
-groq_client = Groq(api_key=GROQ_API_KEY)
-
-def configure_groq_llm(model_name="llama-3.3-70b-versatile", temperature=0.7, max_tokens=2048):
-    return ChatGroq(groq_api_key=GROQ_API_KEY, model_name=model_name, temperature=temperature, max_tokens=max_tokens)
-
-def get_embeddings(model_name="BAAI/bge-base-en"):
-    encode_kwargs = {'normalize_embeddings': True}
-    return HuggingFaceBgeEmbeddings(model_name=model_name, encode_kwargs=encode_kwargs)
-
-def create_llama_prompt():
-    template = """ Use the following context to answer the question: Context: {context} Question: {question} Helpful Answer:"""
-    return PromptTemplate(template=template, input_variables=["context", "question"])
-
-embeddings = get_embeddings()
-llm = configure_groq_llm()
-vector_db = Chroma(persist_directory='db', embedding_function=embeddings)
-retriever = vector_db.as_retriever(search_kwargs={"k": 5})
-prompt = create_llama_prompt()
+from langchain.memory import ConversationBufferMemory
+from langchain.chains import ConversationalRetrievalChain
+from transformers import pipeline
+from sentence_transformers import SentenceTransformer
+import numpy as np
 
-qa_chain = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=retriever, chain_type_kwargs={"prompt": prompt}, return_source_documents=True)
+class AdvancedRAGChatbot:
+    def __init__(self, 
+                 embedding_model: str = "BAAI/bge-large-en-v1.5",
+                 llm_model: str = "llama-3.3-70b-versatile",
+                 temperature: float = 0.7,
+                 retrieval_k: int = 5):
+        self.embeddings = self._configure_embeddings(embedding_model)
+        self.semantic_model = SentenceTransformer('all-MiniLM-L6-v2')
+        self.sentiment_analyzer = pipeline("sentiment-analysis")
+        self.ner_pipeline = pipeline("ner", aggregation_strategy="simple")
+        self.llm = self._configure_llm(llm_model, temperature)
+        self.vector_db = self._initialize_vector_database()
+        self.retriever = self._configure_retriever(retrieval_k)
+        self.memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
+        self.qa_chain = self._create_conversational_retrieval_chain()
+    
+    def _configure_embeddings(self, model_name: str):
+        encode_kwargs = {'normalize_embeddings': True, 'show_progress_bar': True}
+        return HuggingFaceBgeEmbeddings(model_name=model_name, encode_kwargs=encode_kwargs)
+    
+    def _configure_llm(self, model_name: str, temperature: float):
+        return ChatGroq(
+            model_name=model_name, 
+            temperature=temperature, 
+            max_tokens=4096,
+            streaming=True
+        )
+    
+    def _initialize_vector_database(self, persist_directory: str = 'vector_db'):
+        return Chroma(persist_directory=persist_directory, embedding_function=self.embeddings)
+    
+    def _configure_retriever(self, retrieval_k: int):
+        return self.vector_db.as_retriever(k=retrieval_k, search_type="mmr", fetch_k=20)
+    
+    def _create_conversational_retrieval_chain(self):
+        template = """
+        You are a helpful AI assistant. Use the following context and chat history to provide a precise answer.
+        
+        Context: {context}
+        Chat History: {chat_history}
+        Question: {question}
+        
+        Helpful Answer:"""
+        
+        prompt = ChatPromptTemplate.from_template(template)
+        return ConversationalRetrievalChain.from_llm(
+            llm=self.llm,
+            retriever=self.retriever,
+            memory=self.memory,
+            combine_docs_chain_kwargs={'prompt': prompt},
+            return_source_documents=True
+        )
+    
+    def process_query(self, query: str) -> Dict[str, Any]:
+        semantic_score = self.semantic_model.encode([query])[0]
+        sentiment_result = self.sentiment_analyzer(query)[0]
+        entities = self.ner_pipeline(query)
+        result = self.qa_chain({"question": query})
+        
+        response_data = {
+            "response": result['answer'],
+            "source_documents": result.get('source_documents', []),
+            "semantic_similarity": semantic_score.tolist(),
+            "sentiment": sentiment_result,
+            "named_entities": entities,
+            "contextual_information": result.get("source_documents", [])
+        }
+        return response_data
 
-def groq_nlp_chatbot():
-    st.title("Groq Llama 3.2 Chatbot")
-    user_input = st.text_input("Your Question:")
+def main():
+    st.set_page_config(page_title="Advanced NLP RAG Chatbot", layout="wide", initial_sidebar_state="expanded")
+    st.title("🧠 Advanced NLP RAG Chatbot")
+    
+    with st.sidebar:
+        st.header("Configuration")
+        embedding_model = st.selectbox(
+            "Embedding Model", 
+            ["BAAI/bge-large-en-v1.5", "sentence-transformers/all-MiniLM-L6-v2"]
+        )
+        temperature = st.slider("Model Temperature", 0.0, 1.0, 0.7)
+        retrieval_k = st.slider("Documents to Retrieve (k)", 1, 10, 5)
+    
+    chatbot = AdvancedRAGChatbot(
+        embedding_model=embedding_model,
+        temperature=temperature,
+        retrieval_k=retrieval_k
+    )
+    
+    st.markdown("### Chat with the AI Assistant")
+    query_col, response_col = st.columns(2)
+    
+    with query_col:
+        user_input = st.text_area("Ask your question:", placeholder="Type your question here...", height=150)
+    
     if user_input:
-        try:
-            response = qa_chain.invoke(user_input)
-            st.text_area("Bot's Response:", response['result'])
-        except Exception as e:
-            st.error(f"Error processing request: {e}")
-
+        with st.spinner("Processing your query..."):
+            response = chatbot.process_query(user_input)
+        
+        with response_col:
+            st.markdown("### Bot Response")
+            st.write(response['response'])
+            
+            st.markdown("### Sentiment Analysis")
+            st.write(f"Sentiment: {response['sentiment']['label']} ({response['sentiment']['score']:.2%})")
+            
+            st.markdown("### Named Entities")
+            for entity in response['named_entities']:
+                st.write(f"- {entity['word']} ({entity['entity']})")
+            
+            st.markdown("### Source Documents")
+            for doc in response['source_documents']:
+                st.text_area("Source Document", doc.page_content, height=100)
+    
 if __name__ == "__main__":
-    groq_nlp_chatbot()
+    main()