Update app/database.py

app/database.py

@@ -8,84 +8,88 @@ logger = logging.getLogger(__name__)
 
 class VectorDatabase:
     def __init__(self):
-        self.pc = Pinecone(api_key=settings.PINECONE_API_KEY)
-        self.index_name = settings.PINECONE_INDEX_NAME
-        self.index = None
-        self._initialize_index()
-    
+        try:
+            self.pc = Pinecone(api_key=settings.PINECONE_API_KEY)
+            self.index_name = settings.PINECONE_INDEX_NAME
+            self.index = None
+            self._initialize_index()
+        except Exception as e:
+            logger.error(f"Error initializing Pinecone client: {str(e)}")
+            raise
+
     def _initialize_index(self):
         """Initialize or connect to Pinecone index"""
         try:
-            # Check if index exists
+            # Get list of indexes
             existing_indexes = self.pc.list_indexes()
             index_names = [idx.name for idx in existing_indexes]
             
+            # Create index if not found
             if self.index_name not in index_names:
-                logger.info(f"Creating new index: {self.index_name}")
+                logger.info(f"Creating new Pinecone index: {self.index_name}")
                 self.pc.create_index(
                     name=self.index_name,
-                    dimension=settings.PINECONE_DIMENSION,
+                    dimension=settings.PINECONE_DIMENSION,  # e.g., 768 or 1536
                     metric="cosine",
-                    spec=ServerlessSpec(
-                        cloud="aws",
-                        region=settings.PINECONE_ENVIRONMENT.split('-')[0] + "-" + 
-                               settings.PINECONE_ENVIRONMENT.split('-')[1] + "-" +
-                               settings.PINECONE_ENVIRONMENT.split('-')[2]
-                    )
+                    spec=ServerlessSpec(cloud="aws", region=settings.PINECONE_REGION)
                 )
-                # Wait for index to be ready
-                time.sleep(5)
-            
+                time.sleep(10)  # Give time for index to initialize
+
             self.index = self.pc.Index(self.index_name)
-            logger.info(f"Connected to index: {self.index_name}")
-            
+            logger.info(f"Connected to Pinecone index: {self.index_name}")
+
         except Exception as e:
-            logger.error(f"Error initializing Pinecone index: {str(e)}")
+            logger.error(f"Error creating or connecting to Pinecone index: {str(e)}")
             raise
-    
+
     def upsert_vectors(self, vectors: List[tuple]):
         """
-        Upsert vectors to Pinecone
-        vectors: List of tuples (id, embedding, metadata)
+        Upsert vectors into Pinecone.
+        Format: [(id, embedding, metadata)]
         """
         try:
+            if not vectors:
+                logger.warning("No vectors provided for upsert.")
+                return
+
             self.index.upsert(vectors=vectors)
-            logger.info(f"Upserted {len(vectors)} vectors")
+            logger.info(f"✅ Successfully upserted {len(vectors)} vectors to Pinecone.")
         except Exception as e:
-            logger.error(f"Error upserting vectors: {str(e)}")
+            logger.error(f"❌ Error upserting vectors to Pinecone: {str(e)}")
             raise
-    
-    def query_vectors(self, query_vector: List[float], top_k: int = 5, 
-                     filter_dict: Dict = None) -> List[Dict[str, Any]]:
-        """Query similar vectors from Pinecone"""
+
+    def query_vectors(self, query_vector: List[float], top_k: int = 5, filter_dict: Dict = None):
+        """Query the Pinecone index for similar vectors."""
         try:
-            results = self.index.query(
+            response = self.index.query(
                 vector=query_vector,
                 top_k=top_k,
                 include_metadata=True,
-                filter=filter_dict
+                filter=filter_dict or {}
             )
-            return results.matches
+            return response.matches
         except Exception as e:
-            logger.error(f"Error querying vectors: {str(e)}")
+            logger.error(f"❌ Error querying Pinecone: {str(e)}")
             raise
-    
+
     def delete_all(self):
-        """Delete all vectors from index"""
+        """Delete all vectors in the index."""
         try:
             self.index.delete(delete_all=True)
-            logger.info("Deleted all vectors from index")
+            logger.info("🗑️ All vectors deleted from Pinecone index.")
         except Exception as e:
             logger.error(f"Error deleting vectors: {str(e)}")
             raise
-    
+
     def get_stats(self):
-        """Get index statistics"""
+        """Fetch index statistics."""
         try:
-            return self.index.describe_index_stats()
+            stats = self.index.describe_index_stats()
+            return stats
         except Exception as e:
-            logger.error(f"Error getting stats: {str(e)}")
+            logger.error(f"Error getting index stats: {str(e)}")
             raise
 
-# Global instance
-vector_db = VectorDatabase()
+
+# Create global instance
+vector_db = VectorDatabase()