Upd imports

memory/memory.py

@@ -10,8 +10,8 @@ import logging
 from models.summarizer import summarizer
 
 _LLM_SMALL = "gemini-2.5-flash-lite-preview-06-17"
-# Load embedding model
-EMBED = SentenceTransformer("/app/model_cache", device="cpu").half()
+# Load embedding model - use standard model that downloads automatically
+EMBED = SentenceTransformer("all-MiniLM-L6-v2", device="cpu")
 logger = logging.getLogger("rag-agent")
 logging.basicConfig(level=logging.INFO, format="%(asctime)s — %(name)s — %(levelname)s — %(message)s", force=True) # Change INFO to DEBUG for full-ctx JSON loader
 

models/llama.py

@@ -11,7 +11,8 @@ class NVIDIALLamaClient:
     def __init__(self):
         self.api_key = os.getenv("NVIDIA_URI")
         if not self.api_key:
-            raise ValueError("NVIDIA_URI environment variable not set")
+            logger.warning("NVIDIA_URI not set - summarization will use fallback methods")
+            self.api_key = None
         
         # Correct NVIDIA Integrate API base
         self.base_url = "https://integrate.api.nvidia.com/v1"
@@ -19,11 +20,15 @@ class NVIDIALLamaClient:
         
     def generate_keywords(self, user_query: str) -> List[str]:
         """Use Llama to generate search keywords from user query"""
+        if not self.api_key:
+            # Fallback: extract keywords from query
+            return self._extract_keywords_fallback(user_query)
+        
         try:
-            prompt = f"""Given this medical question: "{user_query}"
+            prompt = f"""Given this cooking question: "{user_query}"
 
-Generate 3-5 specific search keywords that would help find relevant medical information online. 
-Focus on medical terms, symptoms, conditions, treatments, or procedures mentioned.
+Generate 3-5 specific search keywords that would help find relevant cooking information online. 
+Focus on cooking terms, ingredients, techniques, recipes, or culinary methods mentioned.
 Return only the keywords separated by commas, no explanations.
 
 Keywords:"""
@@ -37,7 +42,30 @@ Keywords:"""
             
         except Exception as e:
             logger.error(f"Failed to generate keywords: {e}")
-            return [user_query]  # Fallback to original query
+            return self._extract_keywords_fallback(user_query)
+    
+    def _extract_keywords_fallback(self, user_query: str) -> List[str]:
+        """Fallback keyword extraction when NVIDIA API is not available"""
+        # Simple keyword extraction from cooking terms
+        cooking_keywords = [
+            'recipe', 'cooking', 'baking', 'roasting', 'grilling', 'frying', 'boiling', 'steaming',
+            'ingredients', 'seasoning', 'spices', 'herbs', 'sauce', 'marinade', 'dressing',
+            'technique', 'method', 'temperature', 'timing', 'preparation', 'cooking time',
+            'oven', 'stovetop', 'grill', 'pan', 'pot', 'skillet', 'knife', 'cutting',
+            'vegetarian', 'vegan', 'gluten-free', 'dairy-free', 'keto', 'paleo', 'diet',
+            'appetizer', 'main course', 'dessert', 'breakfast', 'lunch', 'dinner',
+            'cuisine', 'italian', 'chinese', 'mexican', 'french', 'indian', 'thai'
+        ]
+        
+        query_lower = user_query.lower()
+        found_keywords = [kw for kw in cooking_keywords if kw in query_lower]
+        
+        # If no cooking keywords found, use first few words
+        if not found_keywords:
+            words = user_query.split()[:5]
+            found_keywords = [w for w in words if len(w) > 2]
+        
+        return found_keywords[:5]  # Limit to 5 keywords
     
     def summarize_documents(self, documents: List[Dict], user_query: str) -> Tuple[str, Dict[int, str]]:
         """Use Llama to summarize documents and return summary with URL mapping"""

models/summarizer.py

@@ -7,7 +7,11 @@ logger = logging.getLogger(__name__)
 
 class TextSummarizer:
     def __init__(self):
-        self.llama_client = NVIDIALLamaClient()
+        try:
+            self.llama_client = NVIDIALLamaClient()
+        except Exception as e:
+            logger.warning(f"Failed to initialize NVIDIA Llama client: {e}")
+            self.llama_client = None
     
     def clean_text(self, text: str) -> str:
         """Clean and normalize text for summarization"""
@@ -61,6 +65,9 @@ class TextSummarizer:
     
     def summarize_text(self, text: str, max_length: int = 200) -> str:
         """Summarize text using NVIDIA Llama model"""
+        if not self.llama_client:
+            return self._summarize_fallback(text, max_length)
+        
         try:
             if not text or len(text.strip()) < 50:
                 return text
@@ -94,13 +101,34 @@ Summary:"""
             
         except Exception as e:
             logger.error(f"Summarization failed: {e}")
-            # Fallback to simple truncation
-            return self.clean_text(text)[:max_length]
+            return self._summarize_fallback(text, max_length)
+    
+    def _summarize_fallback(self, text: str, max_length: int = 200) -> str:
+        """Fallback summarization when NVIDIA API is not available"""
+        if not text:
+            return ""
+        
+        cleaned_text = self.clean_text(text)
+        if len(cleaned_text) <= max_length:
+            return cleaned_text
+        
+        # Simple truncation with sentence boundary detection
+        sentences = cleaned_text.split('. ')
+        result = ""
+        for sentence in sentences:
+            if len(result + sentence) > max_length:
+                break
+            result += sentence + ". "
+        
+        return result.strip() or cleaned_text[:max_length] + "..."
 
     def summarize_for_query(self, text: str, query: str, max_length: int = 220) -> str:
         """Summarize text focusing strictly on information relevant to the query.
         Returns an empty string if nothing relevant is found.
         """
+        if not self.llama_client:
+            return self._summarize_for_query_fallback(text, query, max_length)
+        
         try:
             if not text:
                 return ""
@@ -125,7 +153,41 @@ Summary:"""
             return summary
         except Exception as e:
             logger.warning(f"Query-focused summarization failed: {e}")
+            return self._summarize_for_query_fallback(text, query, max_length)
+    
+    def _summarize_for_query_fallback(self, text: str, query: str, max_length: int = 220) -> str:
+        """Fallback query-focused summarization when NVIDIA API is not available"""
+        if not text:
+            return ""
+        
+        cleaned_text = self.clean_text(text)
+        if not cleaned_text:
+            return ""
+        
+        # Simple keyword matching for relevance
+        query_words = set(query.lower().split())
+        text_words = set(cleaned_text.lower().split())
+        
+        # Check if there's any overlap
+        overlap = query_words.intersection(text_words)
+        if not overlap:
             return ""
+        
+        # Return first few sentences that contain query words
+        sentences = cleaned_text.split('. ')
+        relevant_sentences = []
+        for sentence in sentences:
+            sentence_words = set(sentence.lower().split())
+            if query_words.intersection(sentence_words):
+                relevant_sentences.append(sentence)
+                if len('. '.join(relevant_sentences)) > max_length:
+                    break
+        
+        result = '. '.join(relevant_sentences)
+        if len(result) > max_length:
+            result = result[:max_length-3] + "..."
+        
+        return result
     
     def summarize_documents(self, documents: List[Dict], user_query: str) -> Tuple[str, Dict[int, str]]:
         """Summarize multiple documents with URL mapping"""