Update app.py

app.py

@@ -354,39 +354,82 @@ class ProductionRAGSystem:
             status_text.empty()
             return False
     
+    def expand_query_with_family_terms(self, query):
+        """Expand query to include family relationship synonyms"""
+        family_mappings = {
+            'mother': ['mama', 'mom', 'ammi'],
+            'mama': ['mother', 'mom', 'ammi'],
+            'father': ['papa', 'dad', 'abbu'],
+            'papa': ['father', 'dad', 'abbu'],
+            'brother': ['bhai', 'bro'],
+            'bhai': ['brother', 'bro'],
+            'sister': ['behn', 'sis'],
+            'behn': ['sister', 'sis']
+        }
+        
+        expanded_terms = [query]
+        query_lower = query.lower()
+        
+        for key, synonyms in family_mappings.items():
+            if key in query_lower:
+                for synonym in synonyms:
+                    expanded_terms.append(query_lower.replace(key, synonym))
+        
+        return expanded_terms
+    
     def search(self, query, n_results=5):
-        """Search for relevant chunks"""
+        """Search for relevant chunks with family relationship mapping"""
         if not self.model or not self.collection:
             return None
         
         try:
-            query_embedding = self.model.encode([query])[0].tolist()
+            # Expand query with family terms
+            expanded_queries = self.expand_query_with_family_terms(query)
+            all_results = []
             
-            results = self.collection.query(
-                query_embeddings=[query_embedding],
-                n_results=n_results
-            )
+            # Search with all expanded terms
+            for search_query in expanded_queries:
+                query_embedding = self.model.encode([search_query])[0].tolist()
+                
+                results = self.collection.query(
+                    query_embeddings=[query_embedding],
+                    n_results=n_results
+                )
+                
+                if results['documents'][0]:
+                    for chunk, distance, metadata in zip(
+                        results['documents'][0],
+                        results['distances'][0],
+                        results['metadatas'][0]
+                    ):
+                        similarity = max(0, 1 - distance)
+                        all_results.append({
+                            'content': chunk,
+                            'metadata': metadata,
+                            'similarity': similarity,
+                            'query_used': search_query
+                        })
             
-            if not results['documents'][0]:
+            if not all_results:
                 return None
             
-            search_results = []
-            for chunk, distance, metadata in zip(
-                results['documents'][0],
-                results['distances'][0],
-                results['metadatas'][0]
-            ):
-                similarity = max(0, 1 - distance)
-                search_results.append({
-                    'content': chunk,
-                    'metadata': metadata,
-                    'similarity': similarity
-                })
+            # Remove duplicates and sort by similarity
+            seen_chunks = set()
+            unique_results = []
+            for result in all_results:
+                chunk_id = f"{result['metadata']['source_file']}_{result['content'][:50]}"
+                if chunk_id not in seen_chunks:
+                    seen_chunks.add(chunk_id)
+                    unique_results.append(result)
+            
+            # Sort by similarity and take top results
+            unique_results.sort(key=lambda x: x['similarity'], reverse=True)
+            search_results = unique_results[:n_results]
             
             # Debug: Show search results for troubleshooting
-            print(f"Search for '{query}' found {len(search_results)} results")
+            print(f"Search for '{query}' (expanded to {len(expanded_queries)} terms) found {len(search_results)} results")
             for i, result in enumerate(search_results[:3]):
-                print(f"  {i+1}. Similarity: {result['similarity']:.3f} | Source: {result['metadata']['source_file']}")
+                print(f"  {i+1}. Similarity: {result['similarity']:.3f} | Source: {result['metadata']['source_file']} | Query: {result['query_used']}")
                 print(f"     Content preview: {result['content'][:100]}...")
             
             return search_results
@@ -462,25 +505,38 @@ class ProductionRAGSystem:
             context = "\n\n".join([f"Source: {r['metadata']['source_file']}\nContent: {r['content']}" 
                                  for r in search_results[:3]])
             
-            # Create focused prompt for concise, professional answers
+            # Create focused prompt for rich, engaging family responses
             if unlimited_tokens:
-                prompt = f"""Act as a helpful HR assistant for this company. Based on the document context below, provide a clear, concise, and professional answer to the employee's question.
-Document Context:
+                prompt = f"""You are a warm, caring family assistant who knows everyone well. Based on the family information below, provide a rich, detailed, and engaging response.
+
+Family Document Context:
 {context}
-Employee Question: {query}
+
+Question: {query}
+
 Instructions:
-- Give a direct, actionable answer
-- Use specific details from the documents
-- Keep it professional but friendly
-- Be concise and to the point
-- If policies have conditions or exceptions, mention them clearly"""
-                max_tokens = 300  # Balanced token limit
-                temperature = 0.2
+- Use the document information as your foundation
+- Expand with logical personality traits and qualities someone like this would have
+- Add 3-4 additional lines of thoughtful insights about their character
+- Use relevant emojis to make the response warm and engaging
+- Write in a caring, family-friend tone
+- If someone asks about relationships (like "mother" = "mama"), make those connections
+- Make the response feel personal and detailed, not just a basic fact
+- Include both strengths and endearing qualities
+- Keep it warm but informative (4-6 sentences total)
+
+Remember: You're helping someone learn about their family members in a meaningful way! 💝"""
+                max_tokens = 400  # Increased for richer responses
+                temperature = 0.3  # Slightly more creative
             else:
-                # Shorter prompt for conservative mode
-                prompt = f"Act as an HR assistant. Based on this info: {extracted_answer}\n\nEmployee asks: {query}\n\nGive a clear, helpful answer:"
-                max_tokens = 50  # Minimum token limit
-                temperature = 0.1
+                # Shorter but still enhanced prompt for conservative mode
+                prompt = f"""Based on this family info: {extracted_answer}
+
+Question: {query}
+
+Give a warm, detailed answer with emojis. Add 2-3 more qualities this person likely has. Make it caring and personal! 💝"""
+                max_tokens = 150  # Better than 50 for family context
+                temperature = 0.2
             
             try:
                 response = requests.post(
@@ -536,27 +592,31 @@ Instructions:
         }
 
 def get_general_ai_response(query, unlimited_tokens=False):
-    """Get AI response for general questions with proper token handling"""
+    """Get AI response for general questions with family-friendly enhancement"""
     openrouter_key = os.environ.get("OPENROUTER_API_KEY")
     
     if not openrouter_key:
-        return "I can only answer questions about your uploaded documents. Please add an OpenRouter API key for general conversations."
+        return "I can only answer questions about your family members from the uploaded documents. Please add an OpenRouter API key for general conversations. 💝"
     
     try:
         # Adjust parameters based on token availability
         if unlimited_tokens:
-            max_tokens = 300  # Balanced limit for good answers
-            temperature = 0.7
-            prompt = f"""Act as a knowledgeable assistant. Provide a helpful, clear, and concise answer to this question: {query}
-Keep your response:
-- Direct and actionable
-- Professional but conversational
-- Focused on the main points
-- Under 300 tokens"""
-        else:
-            max_tokens = 50  # Minimum for conservative mode
+            max_tokens = 350  # Good limit for detailed family responses
             temperature = 0.5
-            prompt = f"Briefly answer: {query[:100]}"  # Limit input length for token conservation
+            prompt = f"""You are a caring family assistant. Someone is asking about their family but I couldn't find specific information in their family documents.
+
+Question: {query}
+
+Please provide a warm, helpful response that:
+- Acknowledges I don't have specific information about their family member
+- Suggests they might want to add more details to their family profiles
+- Offers to help in other ways
+- Uses a caring, family-friendly tone with appropriate emojis
+- Keep it supportive and understanding 💝"""
+        else:
+            max_tokens = 100  # Reasonable for conservative mode
+            temperature = 0.4
+            prompt = f"Family question: {query[:100]} - I don't have info about this family member. Give a caring, helpful response with emojis 💝"
         
         response = requests.post(
             "https://openrouter.ai/api/v1/chat/completions",
@@ -750,13 +810,18 @@ with st.sidebar:
                 else:
                     st.error("Failed to index documents. Check your documents folder.")
         
-        # Show current documents
-        if os.path.exists("documents"):
+        # Show current documents (optional - can be hidden for privacy)
+        if st.checkbox("📄 Show Document List", value=False, help="Show/hide document filenames"):
+            if os.path.exists("documents"):
+                txt_files = [f for f in os.listdir("documents") if f.endswith('.txt')]
+                if txt_files:
+                    st.subheader("📄 Current Documents")
+                    for file in txt_files:
+                        st.text(f"• {file}")
+        elif os.path.exists("documents"):
             txt_files = [f for f in os.listdir("documents") if f.endswith('.txt')]
             if txt_files:
-                st.subheader("📄 Current Documents")
-                for file in txt_files:
-                    st.text(f"• {file}")
+                st.info(f"📄 {len(txt_files)} family profile documents loaded (hidden for privacy)")
         
         # Manual upload interface (fallback)
         st.subheader("📤 Manual Upload")