update

app/services/chat_processor.py

@@ -1,6 +1,7 @@
 from datetime import datetime, timezone
 from typing import Optional, Dict, Any
-from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from functools import lru_cache
 from yake import KeywordExtractor
 from app.services.chathistory import ChatSession
 from app.services.websearch import WebSearch
@@ -9,7 +10,10 @@ from app.services.environmental_condition import EnvironmentalData
 from app.services.prompts import *
 from app.services.vector_database_search import VectorDatabaseSearch
 import re
+
+# Create a singleton instance outside the class
 vectordb = VectorDatabaseSearch()
+model = Model()  # Reuse model instance
 
 class ChatProcessor:
     def __init__(self, token: str, session_id: Optional[str] = None, num_results: int = 3, num_images: int = 3):
@@ -23,18 +27,24 @@ class ChatProcessor:
         self.environment_data = EnvironmentalData(city)
         self.web_searcher = WebSearch(num_results=num_results, max_images=num_images)
         self.web_search_required = True
+        self._keyword_extractors = {}  # Cache keyword extractors
 
-    def extract_keywords_yake(self, text: str, language: str, max_ngram_size: int = 2, num_keywords: int = 4) -> list:
+    @lru_cache(maxsize=128)
+    def get_keyword_extractor(self, language: str, max_ngram_size: int, num_keywords: int):
+        """Cache keyword extractors for reuse"""
         lang_code = "en"
         if language.lower() == "urdu":
             lang_code = "ur"
-
-        kw_extractor = KeywordExtractor(
+            
+        return KeywordExtractor(
             lan=lang_code,
             n=max_ngram_size,
             top=num_keywords,
             features=None
         )
+
+    def extract_keywords_yake(self, text: str, language: str, max_ngram_size: int = 2, num_keywords: int = 4) -> list:
+        kw_extractor = self.get_keyword_extractor(language, max_ngram_size, num_keywords)
         keywords = kw_extractor.extract_keywords(text)
         return [kw[0] for kw in keywords]
 
@@ -54,36 +64,48 @@ class ChatProcessor:
 
     def process_chat(self, query: str) -> Dict[str, Any]:
         try:
-            profile = self.chat_session.get_name_and_age()
+            # Fetch profile and history in parallel
+            with ThreadPoolExecutor(max_workers=2) as executor:
+                future_profile = executor.submit(self.chat_session.get_name_and_age)
+                future_history = executor.submit(self.chat_session.load_chat_history)
+                
+                profile = future_profile.result()
+                future_history.result()  # Wait for history to load
+                
             name = profile['name']
             age = profile['age']
-            self.chat_session.load_chat_history()
-            self.chat_session.update_title(self.session_id,query)
+            
+            # Update title and get history format
+            self.chat_session.update_title(self.session_id, query)
             history = self.chat_session.format_history()
 
-            history_based_prompt = HISTORY_BASED_PROMPT.format(history=history,query= query)
-
-            enhanced_query = Model().send_message_openrouter(history_based_prompt)
+            # Get enhanced query 
+            history_based_prompt = HISTORY_BASED_PROMPT.format(history=history, query=query)
+            enhanced_query = model.send_message_openrouter(history_based_prompt)
 
+            # Ensure session and get user preferences
             self.session_id = self.ensure_valid_session(title=enhanced_query)
             permission = self.chat_session.get_user_preferences()
-            websearch_enabled  = permission.get('websearch', False)
+            
+            # Extract permissions
+            websearch_enabled = permission.get('websearch', False)
             env_recommendations = permission.get('environmental_recommendations', False)
             personalized_recommendations = permission.get('personalized_recommendations', False)
             keywords_permission = permission.get('keywords', False)
             reference_permission = permission.get('references', False)
             language = self.chat_session.get_language().lower()
 
+            language_prompt = LANGUAGE_RESPONSE_PROMPT.format(language=language)
 
-            language_prompt = LANGUAGE_RESPONSE_PROMPT.format(language = language)
-
-            if websearch_enabled :
+            if websearch_enabled:
+                # Run web and image search in parallel
                 with ThreadPoolExecutor(max_workers=2) as executor:
                     future_web = executor.submit(self.web_searcher.search, enhanced_query)
                     future_images = executor.submit(self.web_searcher.search_images, enhanced_query)
                     web_results = future_web.result()
                     image_results = future_images.result()
 
+                # Efficiently build context and references
                 context_parts = []
                 references = []
 
@@ -94,13 +116,27 @@ class ChatProcessor:
 
                 context = "\n".join(context_parts)
 
+                # Pre-fetch user details and environmental data in parallel if needed
+                if env_recommendations or personalized_recommendations:
+                    with ThreadPoolExecutor(max_workers=2) as executor:
+                        futures = {}
+                        if personalized_recommendations:
+                            futures['user_details'] = executor.submit(self.chat_session.get_personalized_recommendation)
+                        if env_recommendations:
+                            futures['env_data'] = executor.submit(self.environment_data.get_environmental_data)
+                        
+                        # Get results as they complete
+                        user_details = futures.get('user_details').result() if 'user_details' in futures else None
+                        env_data = futures.get('env_data').result() if 'env_data' in futures else None
+
+                # Select appropriate prompt
                 if env_recommendations and personalized_recommendations:
                     prompt = ENVIRONMENTAL_PERSONALIZED_PROMPT.format(
                         user_name=name,
                         user_age=age,
                         history=history,
-                        user_details=self.chat_session.get_personalized_recommendation(),
-                        environmental_condition=self.environment_data.get_environmental_data(),
+                        user_details=user_details,
+                        environmental_condition=env_data,
                         previous_history=history,
                         context=context,
                         current_query=enhanced_query
@@ -109,16 +145,16 @@ class ChatProcessor:
                     prompt = PERSONALIZED_PROMPT.format(
                         user_name=name,
                         user_age=age,
-                        user_details=self.chat_session.get_personalized_recommendation(),
+                        user_details=user_details,
                         previous_history=history,
                         context=context,
                         current_query=enhanced_query
                     )
-                elif env_recommendations :
+                elif env_recommendations:
                     prompt = ENVIRONMENTAL_PROMPT.format(
                         user_name=name,
                         user_age=age,
-                        environmental_condition=self.environment_data.get_environmental_data(),
+                        environmental_condition=env_data,
                         previous_history=history,
                         context=context,
                         current_query=enhanced_query
@@ -130,16 +166,12 @@ class ChatProcessor:
                         current_query=enhanced_query
                     )
 
-                prompt = prompt + language_prompt
+                prompt += language_prompt
+                response = model.llm(prompt, enhanced_query)
 
-                response = Model().llm(prompt,enhanced_query)
-
-                keywords = ""
-
-                if (keywords_permission):
-                    keywords = self.extract_keywords_yake(response, language=language)
-                if (not reference_permission):
-                    references = ""
+                # Process keywords only if needed
+                keywords = self.extract_keywords_yake(response, language=language) if keywords_permission else ""
+                references = "" if not reference_permission else references
 
                 chat_data = {
                     "query": enhanced_query,
@@ -158,42 +190,56 @@ class ChatProcessor:
                 return chat_data
             
             else:
-                attach_image = False
-
+                # Start RAG timing
+                start_time = datetime.now(timezone.utc)
+                
+                # Launch image search in the background while doing vector search
                 with ThreadPoolExecutor(max_workers=2) as executor:
                     future_images = executor.submit(self.web_searcher.search_images, enhanced_query)
+                    future_vector = executor.submit(vectordb.search, enhanced_query, 3)
+                    
+                    results = future_vector.result()
                     image_results = future_images.result()
 
-                start_time = datetime.now(timezone.utc)
-
-                results = vectordb.search( query=enhanced_query, top_k=3)
-
+                # Process vector search results
                 context_parts = []
                 references = []
-                seen_pages = set() 
+                seen_pages = set()
+                attach_image = False
 
                 for result in results:
                     confidence = result['confidence']
                     if confidence > 60:
                         context_parts.append(f"Content: {result['content']}")
                         page = result['page']
-                        if page not in seen_pages:  # Only append if page is not seen
+                        if page not in seen_pages:
                             references.append(f"Source: {result['source']}, Page: {page}")
                             seen_pages.add(page)
-                        attach_image = True 
-
-                context = "\n".join(context_parts)
-
-                if not context or len(context) < 10:
-                    context = "There is no context found unfortunately"
-
-                if env_recommendations  and personalized_recommendations:
+                        attach_image = True
+
+                context = "\n".join(context_parts) if context_parts else "There is no context found unfortunately"
+
+                # Pre-fetch user details and environmental data in parallel if needed
+                if env_recommendations or personalized_recommendations:
+                    with ThreadPoolExecutor(max_workers=2) as executor:
+                        futures = {}
+                        if personalized_recommendations:
+                            futures['user_details'] = executor.submit(self.chat_session.get_personalized_recommendation)
+                        if env_recommendations:
+                            futures['env_data'] = executor.submit(self.environment_data.get_environmental_data)
+                        
+                        # Get results as they complete
+                        user_details = futures.get('user_details').result() if 'user_details' in futures else None
+                        env_data = futures.get('env_data').result() if 'env_data' in futures else None
+
+                # Select appropriate prompt
+                if env_recommendations and personalized_recommendations:
                     prompt = ENVIRONMENTAL_PERSONALIZED_PROMPT.format(
                         user_name=name,
-                        user_age = age,
+                        user_age=age,
                         history=history,
-                        user_details=self.chat_session.get_personalized_recommendation(),
-                        environmental_condition=self.environment_data.get_environmental_data(),
+                        user_details=user_details,
+                        environmental_condition=env_data,
                         previous_history=history,
                         context=context,
                         current_query=enhanced_query
@@ -202,16 +248,16 @@ class ChatProcessor:
                     prompt = PERSONALIZED_PROMPT.format(
                         user_name=name,
                         user_age=age,
-                        user_details=self.chat_session.get_personalized_recommendation(),
+                        user_details=user_details,
                         previous_history=history,
                         context=context,
                         current_query=enhanced_query
                     )
-                elif env_recommendations :
+                elif env_recommendations:
                     prompt = ENVIRONMENTAL_PROMPT.format(
                         user_name=name,
                         user_age=age,
-                        environmental_condition=self.environment_data.get_environmental_data(),
+                        environmental_condition=env_data,
                         previous_history=history,
                         context=context,
                         current_query=enhanced_query
@@ -223,24 +269,23 @@ class ChatProcessor:
                         current_query=enhanced_query
                     )
 
-                prompt = prompt + language_prompt
-
-                response = Model().response = Model().llm(prompt,query)
-
+                prompt += language_prompt
+                response = model.llm(prompt, query)
                 end_time = datetime.now(timezone.utc)
 
+                # Process keywords only if needed
                 keywords = ""
-
-                if (keywords_permission):
+                if keywords_permission and attach_image:
                     keywords = self.extract_keywords_yake(response, language=language)
                     
-                if (not reference_permission):
-                    references = ""
+                references = "" if not reference_permission else references
+                image_results = "" if not attach_image else image_results
 
-                if  not attach_image:
-                    image_results = ""
-                    keywords = ""
+                # Find where to truncate the response if needed
+                match = re.search(r'(## Personal Recommendations|## Environmental Considerations)', response)
+                truncated_response = response[:match.start()].strip() if match else response
 
+                # Prepare chat data
                 chat_data = {
                     "query": enhanced_query,
                     "response": response,
@@ -252,15 +297,26 @@ class ChatProcessor:
                     "timestamp": datetime.now(timezone.utc).isoformat(),
                     "session_id": self.chat_session.session_id
                 }
-                match = re.search(r'(## Personal Recommendations|## Environmental Considerations)', response)
-                if match:
-                    truncated_response = response[:match.start()].strip()
-                else:
-                    truncated_response = response
-                if not self.chat_session.save_details(session_id=self.session_id , context= context , query= enhanced_query , response=truncated_response , rag_start_time=start_time  , rag_end_time=end_time ):
-                    raise ValueError("Failed to save the RAG details")
-                if not self.chat_session.save_chat(chat_data):
-                    raise ValueError("Failed to save chat message")
+
+                # Save in parallel
+                with ThreadPoolExecutor(max_workers=2) as executor:
+                    future_save_details = executor.submit(
+                        self.chat_session.save_details,
+                        session_id=self.session_id,
+                        context=context,
+                        query=enhanced_query,
+                        response=truncated_response,
+                        rag_start_time=start_time,
+                        rag_end_time=end_time
+                    )
+                    future_save_chat = executor.submit(self.chat_session.save_chat, chat_data)
+                    
+                    # Check results
+                    if not future_save_details.result():
+                        raise ValueError("Failed to save the RAG details")
+                    if not future_save_chat.result():
+                        raise ValueError("Failed to save chat message")
+                
                 return chat_data
 
         except Exception as e: