Update app.py

app.py

@@ -16,66 +16,76 @@ MODEL_NAME = "HuggingFaceH4/zephyr-7b-beta"
 def initialize_system():
     # Validate documents folder
     if not os.path.exists(DOCS_DIR):
-        raise FileNotFoundError(f"Business documents folder '{DOCS_DIR}' not found")
+        raise FileNotFoundError(f"📁 Missing business documents folder: {DOCS_DIR}")
     
     # Load and process PDFs
     pdf_files = [os.path.join(DOCS_DIR, f) for f in os.listdir(DOCS_DIR) if f.endswith(".pdf")]
     if not pdf_files:
-        raise ValueError(f"No PDF files found in {DOCS_DIR} folder")
+        raise ValueError(f"❌ No PDFs found in {DOCS_DIR}")
 
+    # Process documents
     text_splitter = RecursiveCharacterTextSplitter(
-        chunk_size=1000,
-        chunk_overlap=200
+        chunk_size=800,  # Reduced for free tier memory
+        chunk_overlap=100
     )
     
     documents = []
     for pdf_path in pdf_files:
-        loader = PyPDFLoader(pdf_path)
-        documents.extend(loader.load_and_split(text_splitter))
+        try:
+            loader = PyPDFLoader(pdf_path)
+            documents.extend(loader.load_and_split(text_splitter))
+        except Exception as e:
+            print(f"⚠️ Error processing {pdf_path}: {str(e)}")
+    
+    # Create embeddings with explicit settings
+    embeddings = HuggingFaceEmbeddings(
+        model_name=EMBEDDING_MODEL,
+        model_kwargs={'device': 'cpu'},
+        encode_kwargs={'normalize_embeddings': True},
+        cache_folder="/tmp/sentence_transformers"
+    )
     
-    # Create embeddings
-    embeddings = HuggingFaceEmbeddings(model_name=EMBEDDING_MODEL)
     vector_store = FAISS.from_documents(documents, embeddings)
     
-    # Quantization config
+    # 4-bit quantization config
     bnb_config = BitsAndBytesConfig(
         load_in_4bit=True,
-        bnb_4bit_use_double_quant=True,
         bnb_4bit_quant_type="nf4",
         bnb_4bit_compute_dtype=torch.float16,
     )
     
-    # Load model and tokenizer
-    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
-    model = AutoModelForCausalLM.from_pretrained(
-        MODEL_NAME,
-        quantization_config=bnb_config,
-        device_map="auto",
-        trust_remote_code=True,
-        use_flash_attention_2=True 
-    )
+    # Load model with error handling
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+        model = AutoModelForCausalLM.from_pretrained(
+            MODEL_NAME,
+            quantization_config=bnb_config,
+            device_map="auto",
+            trust_remote_code=True
+        )
+    except Exception as e:
+        raise RuntimeError(f"🤖 Model loading failed: {str(e)}")
     
     return vector_store, model, tokenizer
 
-# Initialize system components
+# Initialize system
 try:
     vector_store, model, tokenizer = initialize_system()
-    print("✅ System initialized with business documents")
+    print("🚀 System ready with business documents")
 except Exception as e:
-    print(f"❌ Initialization failed: {str(e)}")
+    print(f"🔥 Critical error: {str(e)}")
     raise
 
 # Response Generation
 def generate_response(query):
     try:
-        # Retrieve relevant context
-        docs = vector_store.similarity_search(query, k=3)
-        context = "\n".join([doc.page_content for doc in docs])
+        # Context retrieval
+        docs = vector_store.similarity_search(query, k=2)  # Reduced context chunks
+        context = "\n".join([d.page_content for d in docs])
         
-        # Create formatted prompt
+        # Zephyr prompt template
         prompt = f"""<|system|>
-        You are a customer support assistant. Answer ONLY using the provided business documents.
-        If the answer isn't in the documents, respond: "I don't have that information."
+        Answer ONLY using the business documents. Unknown answers: "I don't have that information."
         
         Context: {context}</s>
         <|user|>
@@ -87,36 +97,33 @@ def generate_response(query):
         inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
         outputs = model.generate(
             inputs.input_ids,
-            max_new_tokens=512,
-            temperature=0.3,
+            max_new_tokens=256,  # Reduced for faster responses
+            temperature=0.2,
             do_sample=True,
             pad_token_id=tokenizer.eos_token_id
         )
         response = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        
-        # Extract only the assistant's response
         return response.split("<|assistant|>")[-1].strip()
     
     except Exception as e:
-        return f"⚠️ Error: {str(e)}"
+        return f"⚠️ Error: Please try again. Details: {str(e)[:100]}"
 
-# Chat Interface
+# Gradio Interface
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 📚 Business Document Assistant")
+    gr.Markdown("# 📞 Business Support Assistant")
     
     with gr.Row():
-        gr.Image("https://huggingface.co/datasets/huggingface/brand-assets/resolve/main/hf-logo.png", 
-                width=100)
-        gr.Markdown("Ask questions about our policies, products, and services!")
+        gr.Image(value="https://placehold.co/100x30?text=Company+Logo", width=100)
+        gr.Markdown("Ask questions about our services and policies")
     
-    chatbot = gr.Chatbot(height=400)
-    msg = gr.Textbox(label="Your Question", placeholder="Type your question here...")
+    chatbot = gr.Chatbot(height=350)
+    msg = gr.Textbox(placeholder="Type your question...", label="")
     clear = gr.Button("Clear History")
     
-    def respond(message, chat_history):
+    def respond(message, history):
         response = generate_response(message)
-        chat_history.append((message, response))
-        return "", chat_history
+        history.append((message, response))
+        return "", history
     
     msg.submit(respond, [msg, chatbot], [msg, chatbot])
     clear.click(lambda: None, None, chatbot, queue=False)