Update src/rag_system.py

src/rag_system.py

@@ -387,4 +387,230 @@ Summary (2-3 sentences maximum):"""
 
     def get_visual_summaries_log(self) -> List[Dict]:
         """Get all visual analysis logs"""
-        return self.visual_summaries_log
+        return self.visual_summaries_log
+
+
+class AnsweringRAG:
+    """
+    RAG system that:
+    1. Searches vector store for relevant content
+    2. ANALYZES search results
+    3. Generates intelligent answers based on context
+    """
+    
+    def __init__(self, api_key: str = None, debug: bool = True):
+        api_key = api_key or OPENAI_API_KEY
+        self.debug = debug
+        
+        self.llm = ChatOpenAI(
+            model_name="gpt-4o",  # Use gpt-4o for better understanding
+            api_key=api_key,
+            temperature=TEMPERATURE,
+            max_tokens=MAX_TOKENS,
+        )
+        
+        self.language = LANGUAGE
+        self.answer_log = []
+        
+        if self.debug:
+            print("✅ AnsweringRAG initialized with answer generation")
+
+    def _debug_print(self, label: str, data: any):
+        """Print debug information"""
+        if self.debug:
+            print(f"\n🔍 DEBUG [{label}]:")
+            if isinstance(data, (list, dict)):
+                print(f"  Type: {type(data).__name__}")
+                print(f"  Content: {str(data)[:300]}...")
+            else:
+                print(f"  {data}")
+
+    def analyze_and_answer(
+        self, 
+        question: str, 
+        search_results: List[Dict]
+    ) -> Dict:
+        """
+        Analyze search results and generate intelligent answer
+        
+        Returns:
+        {
+            'question': user question,
+            'answer': detailed answer,
+            'sources_used': number of sources,
+            'confidence': low/medium/high,
+            'search_results': original search results
+        }
+        """
+        
+        print(f"\n{'='*70}")
+        print(f"ANALYZING QUESTION & GENERATING ANSWER")
+        print(f"{'='*70}")
+        
+        print(f"\n❓ Question: {question}")
+        print(f"📊 Search Results Found: {len(search_results)}")
+        
+        # Check if we have search results
+        if not search_results:
+            print(f"⚠️  No search results found!")
+            answer = f"""I could not find relevant information in the document to answer your question: "{question}"
+
+Try:
+- Using different keywords
+- Breaking the question into smaller parts
+- Asking about other topics in the document"""
+            
+            result = {
+                'question': question,
+                'answer': answer,
+                'sources_used': 0,
+                'confidence': 'low',
+                'search_results': []
+            }
+            self.answer_log.append(result)
+            return result
+        
+        # Build context from search results
+        context_parts = []
+        for idx, result in enumerate(search_results, 1):
+            content = result.get('content', '')
+            metadata = result.get('metadata', {})
+            content_type = result.get('type', 'unknown')
+            distance = result.get('distance', 0)
+            relevance = 1 - distance if distance else 0
+            
+            context_parts.append(f"""
+[Source {idx} - {content_type.upper()} (relevance: {relevance:.1%})]
+{content}""")
+        
+        full_context = "\n".join(context_parts)
+        
+        self._debug_print("Context Prepared", f"{len(context_parts)} sources, {len(full_context)} chars")
+        
+        # Build prompt to analyze results and answer question
+        analysis_prompt = f"""You are a helpful assistant analyzing document content to answer user questions.
+
+USER QUESTION:
+"{question}"
+
+RELEVANT CONTENT FROM DOCUMENT:
+{full_context}
+
+INSTRUCTIONS:
+1. Analyze the provided content carefully
+2. Extract information relevant to the question
+3. Synthesize a clear, comprehensive answer in {self.language}
+4. If the content doesn't fully answer the question, explain what information is available
+5. Be specific and cite the content when relevant
+6. Structure your answer clearly with key points
+
+ANSWER:"""
+        
+        print(f"\n🔍 Analyzing search results...")
+        print(f"   Context size: {len(full_context)} characters")
+        print(f"   Sources: {len(search_results)}")
+        
+        try:
+            # Call LLM to analyze and answer
+            message = HumanMessage(content=analysis_prompt)
+            response = self.llm.invoke([message])
+            answer = response.content.strip()
+            
+            # Determine confidence level
+            confidence = self._estimate_confidence(len(search_results), answer)
+            
+            print(f"✅ Answer generated successfully")
+            print(f"   Confidence: {confidence}")
+            print(f"   Answer length: {len(answer)} characters")
+            
+            result = {
+                'question': question,
+                'answer': answer,
+                'sources_used': len(search_results),
+                'confidence': confidence,
+                'search_results': search_results
+            }
+            
+            self.answer_log.append(result)
+            return result
+            
+        except Exception as e:
+            print(f"❌ Error generating answer: {e}")
+            answer = f"I encountered an error while analyzing the search results. Please try again."
+            
+            result = {
+                'question': question,
+                'answer': answer,
+                'sources_used': len(search_results),
+                'confidence': 'low',
+                'error': str(e),
+                'search_results': search_results
+            }
+            
+            self.answer_log.append(result)
+            return result
+
+    def _estimate_confidence(self, sources_count: int, answer: str) -> str:
+        """Estimate confidence level of answer"""
+        answer_length = len(answer)
+        
+        # High confidence: multiple sources, substantial answer
+        if sources_count >= 3 and answer_length > 500:
+            return "high"
+        
+        # Medium confidence: some sources, decent answer
+        elif sources_count >= 2 and answer_length > 200:
+            return "medium"
+        
+        # Low confidence: few sources or short answer
+        else:
+            return "low"
+
+    def get_answer_with_sources(
+        self,
+        question: str,
+        search_results: List[Dict]
+    ) -> Dict:
+        """
+        Get answer AND properly formatted sources
+        Returns both answer and formatted source citations
+        """
+        
+        result = self.analyze_and_answer(question, search_results)
+        
+        # Format sources for display
+        formatted_sources = []
+        for idx, source in enumerate(result['search_results'], 1):
+            formatted_sources.append({
+                'index': idx,
+                'type': source.get('type', 'unknown'),
+                'content': source.get('content', ''),
+                'relevance': 1 - source.get('distance', 0) if source.get('distance') else 0
+            })
+        
+        result['formatted_sources'] = formatted_sources
+        return result
+
+    def get_answer_log(self) -> List[Dict]:
+        """Get all answer generation logs"""
+        return self.answer_log
+
+    def print_answer_with_sources(self, result: Dict, max_source_length: int = 300):
+        """Pretty print answer with sources"""
+        
+        print(f"\n{'='*70}")
+        print(f"ANSWER TO: {result['question']}")
+        print(f"{'='*70}")
+        
+        print(f"\n📝 ANSWER (Confidence: {result['confidence'].upper()}):")
+        print(f"{'-'*70}")
+        print(result['answer'])
+        print(f"{'-'*70}")
+        
+        if result.get('formatted_sources'):
+            print(f"\n📚 SOURCES USED ({len(result['formatted_sources'])} total):")
+            for source in result['formatted_sources']:
+                print(f"\n[Source {source['index']} - {source['type'].upper()} ({source['relevance']:.0%} relevant)]")
+                print(f"{source['content'][:max_source_length]}...")
+        
+        print(f"\n{'='*70}")