refactor

src/reviewsense/services/ReviewService.py

@@ -12,9 +12,9 @@ class ReviewService:
         """
         Initialize the review service with vector database and embeddings
         """
-        self.fetcher = ReviewFetcher(collection_name, embedding_model)
+        self.fetcher = ReviewFetcher()
         self.rater = ReviewRater()
-        self.adder = ReviewAdder(collection_name, embedding_model)
+        self.adder = ReviewAdder()
 
     def fetch_reviews(self, product_id: str, features: List[str], threshold: float = 0.6) -> Dict[str, List[str]]:
         return self.fetcher.fetch_reviews(product_id, features, threshold)

src/reviewsense/services/retrieval.py

+# src/reviewsense/core/database.py
+from functools import lru_cache
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_astradb import AstraDBVectorStore
+from reviewsense.core.config import get_settings
+
+@lru_cache(maxsize=1)
+def get_vector_store(
+    collection_name: str = "android_phone_reviews", 
+    embedding_model: str = "sentence-transformers/all-mpnet-base-v2"
+):
+    """
+    Create a singleton vector store instance
+    
+    Args:
+        collection_name (str): Database collection name
+        embedding_model (str): Embedding model to use
+    
+    Returns:
+        AstraDBVectorStore: Configured vector store instance
+    """
+    settings = get_settings()
+    
+    # Initialize embeddings
+    embeddings = HuggingFaceEmbeddings(model_name=embedding_model)
+    
+    # Create and return vector store
+    return AstraDBVectorStore(
+        collection_name=collection_name,
+        embedding=embeddings,
+        api_endpoint=settings.ASTRA_DB_API_ENDPOINT,
+        token=settings.ASTRA_DB_APPLICATION_TOKEN,
+        namespace=settings.ASTRA_DB_NAMESPACE,
+    )
\ No newline at end of file

src/reviewsense/services/review_adder.py

 # services/review_adder.py
 
 from langchain_community.docstore.document import Document
-from reviewsense.core.config import get_settings
-from langchain_huggingface import HuggingFaceEmbeddings
-from langchain_astradb import AstraDBVectorStore
+from .retrieval import get_vector_store
 
 class ReviewAdder:
     """Class for adding reviews to the vector store"""
 
-    def __init__(self, collection_name: str, embedding_model: str):
-        settings = get_settings()
-        self.embeddings = HuggingFaceEmbeddings(model_name=embedding_model)
-        self.vector_store = AstraDBVectorStore(
-            collection_name=collection_name,
-            embedding=self.embeddings,
-            api_endpoint=settings.ASTRA_DB_API_ENDPOINT,
-            token=settings.ASTRA_DB_APPLICATION_TOKEN,
-            namespace=settings.ASTRA_DB_NAMESPACE,
-        )
+    def __init__(self):
+        self.vector_store = get_vector_store()
 
     def add_review(self, product_id: str, review: str) -> str:
         review_document = Document(page_content=review, metadata={"title": product_id})

src/reviewsense/services/review_fetcher.py

 # services/review_fetcher.py
 
 from typing import List, Dict
-from reviewsense.core.config import get_settings
-from langchain_astradb import AstraDBVectorStore
-from langchain_huggingface import HuggingFaceEmbeddings
+from .retrieval import get_vector_store
 
 class ReviewFetcher:
     """Class for fetching reviews from the vector store"""
 
-    def __init__(self, collection_name: str, embedding_model: str):
-        settings = get_settings()
-        self.embeddings = HuggingFaceEmbeddings(model_name=embedding_model)
-        self.vector_store = AstraDBVectorStore(
-            collection_name=collection_name,
-            embedding=self.embeddings,
-            api_endpoint=settings.ASTRA_DB_API_ENDPOINT,
-            token=settings.ASTRA_DB_APPLICATION_TOKEN,
-            namespace=settings.ASTRA_DB_NAMESPACE,
-        )
+    def __init__(self):
+        self.vector_store = get_vector_store()
 
     def fetch_reviews(self, product_id: str, features: List[str], threshold: float = 0.6) -> Dict[str, List[str]]:
         feature_reviews = {}
 
         for feature in features:
             filter_criteria = {"title": product_id}
-            documents = self.vector_store.similarity_search_with_score_id(query=feature, k=100, filter=filter_criteria)
+            documents = self.vector_store.similarity_search_with_score_id(query=self.generate_feature_query(feature), k=100, filter=filter_criteria)
 
             filtered_reviews = [doc.page_content for doc, score, _ in documents if score > threshold]
             feature_reviews[feature] = filtered_reviews
 
         return feature_reviews
+    def generate_feature_query(self, feature: str) -> str:
+        """
+        Generate semantic search query for different product features
+        
+        Args:
+            feature (str): Product feature to search
+        
+        Returns:
+            str: Semantic search query
+        """
+        feature_queries = {
+            "battery": "battery performance, battery life, charging speed, power consumption, battery drain, long-lasting battery",
+            "backup": "data backup, storage capacity, backup options, cloud storage, data protection, file recovery",
+            "design": "build quality, aesthetic design, material, form factor, ergonomics, look and feel, physical appearance",
+            "display": "screen quality, display resolution, color accuracy, brightness, viewing angles, screen technology, display performance"
+        }
+        
+        # Default to feature name if not found
+        return feature_queries.get(feature.lower(), feature)