Update app.py

app.py

@@ -13,11 +13,11 @@ import numpy as np
 from sklearn.feature_extraction.text import TfidfVectorizer
 from dotenv import load_dotenv
 
-#  Logger Configuration 
+# Logger Configuration
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-#  Simple TF-IDF Fallback Embeddings
+# Simple TF-IDF Fallback Embeddings
 class SimpleEmbeddings:
     def __init__(self):
         self.vectorizer = TfidfVectorizer(max_features=384, stop_words='english')
@@ -34,7 +34,7 @@ class SimpleEmbeddings:
             return [0.0] * 384
         return self.vectorizer.transform([text]).toarray()[0].tolist()
 
-# RAG Assistant Class 
+# RAG Assistant Class
 class RAGAssistant:
     def __init__(self, groq_api_key: str):
         self.groq_api_key = groq_api_key
@@ -58,7 +58,7 @@ class RAGAssistant:
                         model_kwargs={'device': 'cpu'},
                         encode_kwargs={'normalize_embeddings': False}
                     )
-                    print(f"Successfully loaded HuggingFace model: {model_name}")
+                    print(f"Loaded HuggingFace model: {model_name}")
                     return embeddings
                 except Exception as e:
                     print(f"Failed to load {model_name}: {e}")
@@ -79,7 +79,7 @@ class RAGAssistant:
                 collection_name="code_documentation"
             )
         except Exception as e:
-            logger.error(f"Error initializing vector stores: {str(e)}")
+            logger.error(f"Vector store init error: {str(e)}")
 
     def load_documents(self, files: List[str], assistant_type: str) -> str:
         try:
@@ -88,19 +88,24 @@ class RAGAssistant:
 
             for file_path in files:
                 print(f"Trying to load: {file_path}")
+                print("File exists?", os.path.exists(file_path))
                 try:
                     if file_path.lower().endswith('.pdf'):
                         loader = PyPDFLoader(file_path)
                     else:
                         loader = TextLoader(file_path, encoding='utf-8')
+
                     docs = loader.load()
+                    print(f"Loaded {len(docs)} docs from: {file_path}")
+                    for doc in docs[:1]:
+                        print("Preview:", doc.page_content[:100])
                     documents.extend(docs)
                 except Exception as e:
-                    print(f"Error loading {file_path}: {e}")
+                    logger.error(f"Error loading {file_path}: {e}")
                     continue
 
             if not documents:
-                return "No documents could be loaded. Please check your files."
+                return "❌ No documents could be loaded. Please check your file type or content."
 
             chunks = self.text_splitter.split_documents(documents)
             print(f"Total chunks created: {len(chunks)}")
@@ -115,16 +120,16 @@ class RAGAssistant:
                 self.code_vectorstore.add_documents(chunks)
                 self.code_vectorstore.persist()
 
-            return f"Successfully loaded {len(chunks)} chunks from {len(documents)} documents into {assistant_type} assistant."
+            return f"✅ Loaded {len(chunks)} chunks from {len(documents)} documents into {assistant_type} assistant."
 
         except Exception as e:
             logger.error(f"Error loading documents: {str(e)}")
-            return f"Error loading documents: {str(e)}"
+            return f"❌ Error loading documents: {str(e)}"
 
     def get_learning_tutor_response(self, question: str) -> str:
         try:
             if not self.learning_vectorstore:
-                return "Please upload some learning materials first."
+                return "⚠️ Please upload some learning materials first."
 
             qa_chain = RetrievalQA.from_chain_type(
                 llm=self.llm,
@@ -133,14 +138,7 @@ class RAGAssistant:
                 return_source_documents=True
             )
 
-            learning_prompt = f"""
-            You are an AI learning assistant helping students understand academic concepts.
-            Based on the provided materials, answer the student's question:
-
-            {question}
-            """
-
-            result = qa_chain({"query": learning_prompt})
+            result = qa_chain({"query": question})
             response = result['result']
 
             if result.get('source_documents'):
@@ -150,15 +148,14 @@ class RAGAssistant:
                     response += f"- {Path(source).name}\n"
 
             return response
-
         except Exception as e:
             logger.error(f"Error in learning tutor: {str(e)}")
-            return f"Error generating response: {str(e)}"
+            return f"❌ Error: {str(e)}"
 
     def get_code_helper_response(self, question: str) -> str:
         try:
             if not self.code_vectorstore:
-                return "Please upload some code documentation first."
+                return "⚠️ Please upload some code documentation first."
 
             qa_chain = RetrievalQA.from_chain_type(
                 llm=self.llm,
@@ -167,14 +164,7 @@ class RAGAssistant:
                 return_source_documents=True
             )
 
-            code_prompt = f"""
-            You are a code documentation assistant helping developers with APIs and codebases.
-            Based on the uploaded documentation, answer this question:
-
-            {question}
-            """
-
-            result = qa_chain({"query": code_prompt})
+            result = qa_chain({"query": question})
             response = result['result']
 
             if result.get('source_documents'):
@@ -184,23 +174,22 @@ class RAGAssistant:
                     response += f"- {Path(source).name}\n"
 
             return response
-
         except Exception as e:
             logger.error(f"Error in code helper: {str(e)}")
-            return f"Error generating response: {str(e)}"
+            return f"❌ Error: {str(e)}"
 
-# Gradio UI Interface 
+# Gradio UI
 def create_gradio_interface(assistant: RAGAssistant):
     def upload_learning_files(files):
         if not files:
             return "No files uploaded."
-        file_paths = [f.path for f in files]
+        file_paths = [f.name for f in files]  # ✅ FIXED HERE
         return assistant.load_documents(file_paths, "learning")
 
     def upload_code_files(files):
         if not files:
             return "No files uploaded."
-        file_paths = [f.path for f in files]
+        file_paths = [f.name for f in files]  # ✅ FIXED HERE
         return assistant.load_documents(file_paths, "code")
 
     def learning_chat(message, history):
@@ -218,57 +207,53 @@ def create_gradio_interface(assistant: RAGAssistant):
         return history, ""
 
     with gr.Blocks(title="RAG-Based Learning & Code Assistant", theme=gr.themes.Soft()) as demo:
-        gr.Markdown("# RAG-Based Learning & Code Assistant")
-        gr.Markdown("Upload documents and get smart, personalized answers.")
+        gr.Markdown("# 📚 RAG-Based Learning & Code Assistant")
 
         with gr.Tabs():
-            with gr.TabItem(" Learning Tutor"):
-                gr.Markdown("### Upload lecture notes or textbooks below:")
+            with gr.TabItem("📘 Learning Tutor"):
                 with gr.Row():
                     with gr.Column(scale=1):
                         learning_files = gr.File(label="Upload Materials", file_count="multiple", file_types=[".pdf", ".txt", ".md"])
                         learning_upload_btn = gr.Button("Upload", variant="primary")
                         learning_status = gr.Textbox(label="Upload Status", interactive=False)
                     with gr.Column(scale=2):
-                        learning_chatbot = gr.Chatbot(label="Tutor Chat", height=400)
-                        learning_input = gr.Textbox(label="Ask a question", placeholder="e.g., What is machine learning?")
+                        learning_chatbot = gr.Chatbot(label="Learning Chat", height=400)
+                        learning_input = gr.Textbox(label="Ask your question", placeholder="e.g. What is overfitting?")
                         learning_submit = gr.Button("Ask", variant="primary")
 
                 learning_upload_btn.click(upload_learning_files, inputs=[learning_files], outputs=[learning_status])
                 learning_submit.click(learning_chat, inputs=[learning_input, learning_chatbot], outputs=[learning_chatbot, learning_input])
                 learning_input.submit(learning_chat, inputs=[learning_input, learning_chatbot], outputs=[learning_chatbot, learning_input])
 
-            with gr.TabItem("Code Documentation Helper"):
-                gr.Markdown("### Upload code docs or API guides below:")
+            with gr.TabItem("💻 Code Helper"):
                 with gr.Row():
                     with gr.Column(scale=1):
-                        code_files = gr.File(label="Upload Docs", file_count="multiple", file_types=[".pdf", ".txt", ".md", ".py", ".js", ".json"])
+                        code_files = gr.File(label="Upload Docs", file_count="multiple", file_types=[".pdf", ".txt", ".md", ".py", ".json"])
                         code_upload_btn = gr.Button("Upload", variant="primary")
                         code_status = gr.Textbox(label="Upload Status", interactive=False)
                     with gr.Column(scale=2):
                         code_chatbot = gr.Chatbot(label="Code Chat", height=400)
-                        code_input = gr.Textbox(label="Ask about the codebase", placeholder="e.g., How does login work?")
+                        code_input = gr.Textbox(label="Ask question", placeholder="e.g. How to call this API?")
                         code_submit = gr.Button("Ask", variant="primary")
 
                 code_upload_btn.click(upload_code_files, inputs=[code_files], outputs=[code_status])
                 code_submit.click(code_chat, inputs=[code_input, code_chatbot], outputs=[code_chatbot, code_input])
                 code_input.submit(code_chat, inputs=[code_input, code_chatbot], outputs=[code_chatbot, code_input])
 
-        gr.Markdown("---")
-        gr.Markdown("Built with  using LangChain, ChromaDB, and Groq API")
+        gr.Markdown("Built with ❤️ using LangChain, ChromaDB, and Groq")
 
     return demo
 
-# Main Function
+# Main
 def main():
     load_dotenv()
     groq_api_key = os.getenv("GROQ_API_KEY")
     if not groq_api_key:
-        print("Set your GROQ_API_KEY in the .env file or environment.")
+        print("❌ Please set your GROQ_API_KEY in .env or environment.")
         return
     assistant = RAGAssistant(groq_api_key)
     demo = create_gradio_interface(assistant)
     demo.launch(server_name="0.0.0.0", server_port=7860, share=False, debug=True)
 
 if __name__ == "__main__":
-    main()
+    main()