Initial commit with LlamaIndex-based agent

app.py

@@ -43,6 +43,7 @@ class SmartAgent:
         model_options = [
             "microsoft/DialoGPT-medium",  # Much smaller, works well for chat
             "google/flan-t5-base",        # Good for reasoning tasks
+            "microsoft/DialoGPT-small",   # Smallest fallback
             "HuggingFaceH4/zephyr-7b-beta"  # Original (may fail in limited memory)
         ]
         
@@ -54,12 +55,13 @@ class SmartAgent:
             self.llm = HuggingFaceLLM(
                 model_name=model_name,
                 tokenizer_name=model_name,
-                context_window=512,  # Reduced context window
-                max_new_tokens=128,  # Reduced max tokens
+                context_window=1024,  # Increased for better reasoning
+                max_new_tokens=256,   # Increased for better responses
                 generate_kwargs={
-                    "temperature": 0.7, 
+                    "temperature": 0.3,   # Lower temperature for more focused responses
                     "do_sample": True,
-                    "pad_token_id": 0  # Prevent padding issues
+                    "top_p": 0.9,
+                    "repetition_penalty": 1.1
                 },
                 device_map="auto",
                 # Add memory optimization parameters
@@ -67,7 +69,9 @@ class SmartAgent:
                     "torch_dtype": torch.float16,  # Use half precision
                     "low_cpu_mem_usage": True,
                     "load_in_8bit": True,  # Enable 8-bit quantization if available
-                }
+                },
+                # Add system message for better instruction following
+                system_message="You are a helpful AI assistant that can search the web and perform calculations. Always provide detailed, accurate answers."
             )
             print(f"Successfully loaded model: {model_name}")
             
@@ -88,8 +92,24 @@ class SmartAgent:
                 )
                 print(f"Successfully loaded fallback model: {fallback_model}")
             except Exception as e2:
-                print(f"All model loading attempts failed: {e2}")
-                raise Exception("Unable to load any language model")
+                print(f"Flan-T5 also failed: {e2}")
+                # Try an even more basic approach with a very small model
+                try:
+                    basic_model = "microsoft/DialoGPT-small"
+                    print(f"Final fallback to: {basic_model}")
+                    self.llm = HuggingFaceLLM(
+                        model_name=basic_model,
+                        tokenizer_name=basic_model,
+                        context_window=512,
+                        max_new_tokens=128,
+                        generate_kwargs={"temperature": 0.3, "do_sample": True},
+                        device_map="cpu",  # Force CPU to avoid memory issues
+                        model_kwargs={"low_cpu_mem_usage": True}
+                    )
+                    print(f"Successfully loaded final fallback: {basic_model}")
+                except Exception as e3:
+                    print(f"All model loading attempts failed: {e3}")
+                    raise Exception("Unable to load any language model")
         
         # Define tools with real implementations
         self.tools = [
@@ -129,20 +149,21 @@ class SmartAgent:
         
         try:
             with DDGS() as ddgs:
-                results = list(ddgs.text(query, max_results=3))
+                results = list(ddgs.text(query, max_results=5))  # Get more results
                 if results:
                     formatted_results = []
                     for i, r in enumerate(results, 1):
                         title = r.get('title', 'No title')
-                        body = r.get('body', 'No description')[:200]
+                        body = r.get('body', 'No description')[:300]  # More context
                         url = r.get('href', '')
-                        formatted_results.append(f"{i}. {title}\n{body}...\nSource: {url}")
+                        formatted_results.append(f"{i}. **{title}**\n{body}...\nSource: {url}")
+                    
                     return "\n\n".join(formatted_results)
                 else:
-                    return "No search results found for the query."
+                    return f"No search results found for '{query}'. Try rephrasing your search terms."
         except Exception as e:
             print(f"Web search error: {e}")
-            return f"Error during web search: {str(e)}"
+            return f"Error during web search for '{query}': {str(e)}"
 
     def math_calculator(self, expression: str) -> str:
         """Safe math evaluation using SymPy"""
@@ -171,34 +192,81 @@ class SmartAgent:
 
     def __call__(self, question: str) -> str:
         print(f"Processing question (first 50 chars): {question[:50]}...")
+        
+        # Enhanced reasoning approach
+        question_lower = question.lower()
+        
+        # Check if we need to analyze files
+        if any(word in question_lower for word in ['file', 'excel', 'csv', 'spreadsheet', 'data', 'attached']):
+            return "I cannot access attached files in this environment. Please ensure the file is accessible via a direct URL or describe the data content directly in your question."
+        
+        # Check if we need web search
+        needs_web_search = any(word in question_lower for word in [
+            'current', 'latest', 'recent', 'today', 'news', 'who is', 'what is',
+            'competition', 'winner', 'recipient', 'nationality', 'country',
+            'malko', 'century', 'award', 'born', 'died'
+        ])
+        
+        # Check if we need math calculation
+        needs_calculation = any(word in question_lower for word in [
+            'calculate', 'compute', 'sum', 'total', 'average', 'percentage',
+            'equation', 'solve', 'math', 'number'
+        ]) or any(char in question for char in '+-*/=()0123456789')
+        
         try:
             if self.agent:
+                # Try using the ReAct agent first
                 response = self.agent.query(question)
-                return str(response)
-            else:
-                # Fallback: Direct tool usage based on question content
-                question_lower = question.lower()
-                if any(word in question_lower for word in ['calculate', 'math', 'equation', '+', '-', '*', '/', '=']):
-                    # Try math calculator
-                    math_terms = []
-                    for word in question.split():
-                        if any(char in word for char in '0123456789+-*/()'):
-                            math_terms.append(word)
-                    if math_terms:
-                        expression = ' '.join(math_terms)
-                        return self.math_calculator(expression)
+                response_str = str(response)
                 
-                if any(word in question_lower for word in ['search', 'find', 'what is', 'current', 'latest', 'news']):
-                    # Try web search
-                    return self.web_search(question)
+                # Check if the response is too short or nonsensical
+                if len(response_str.strip()) < 3 or response_str.strip() in ['!', '?', 'what', 'I', 'The', 'A']:
+                    print("Agent gave a poor response, trying direct tool approach...")
+                    return self._direct_tool_approach(question, needs_web_search, needs_calculation)
                 
-                # Default response
-                return f"I understand you're asking: {question[:100]}... However, I'm having trouble processing this with the current model configuration. Please try rephrasing your question or breaking it into smaller parts."
+                return response_str
+            else:
+                # Use direct tool approach
+                return self._direct_tool_approach(question, needs_web_search, needs_calculation)
                 
         except Exception as e:
             print(f"Agent error: {str(e)}")
             print(f"Full traceback: {traceback.format_exc()}")
-            return f"Error processing question: {str(e)}"
+            # Try direct tool approach as fallback
+            try:
+                return self._direct_tool_approach(question, needs_web_search, needs_calculation)
+            except:
+                return f"I apologize, but I'm having technical difficulties processing your question. The question appears to be: {question[:100]}..."
+    
+    def _direct_tool_approach(self, question: str, needs_web_search: bool, needs_calculation: bool) -> str:
+        """Direct tool usage when agent fails"""
+        
+        if needs_web_search:
+            # Extract key search terms
+            search_terms = []
+            important_words = question.split()
+            for word in important_words:
+                if len(word) > 3 and word.lower() not in ['what', 'when', 'where', 'who', 'how', 'the', 'and', 'or', 'but', 'from', 'with']:
+                    search_terms.append(word)
+            
+            search_query = ' '.join(search_terms[:5])  # Limit to 5 key terms
+            print(f"Performing web search for: {search_query}")
+            
+            search_result = self.web_search(search_query)
+            return f"Based on my web search for '{search_query}':\n\n{search_result}\n\nPlease review the search results above to find the specific information you're looking for."
+        
+        if needs_calculation:
+            # Try to extract mathematical expressions
+            import re
+            # Look for mathematical expressions
+            math_patterns = re.findall(r'[\d+\-*/().\s]+', question)
+            for pattern in math_patterns:
+                if any(char in pattern for char in '+-*/') and any(char.isdigit() for char in pattern):
+                    result = self.math_calculator(pattern.strip())
+                    return f"Mathematical calculation result: {result}"
+        
+        # Default response with better reasoning
+        return f"I understand you're asking about: {question[:150]}... However, I need more specific information or context to provide an accurate answer. Could you please rephrase your question or provide additional details?"
 
 
 # --- Memory cleanup function ---