Update app/services/vector_service.py

app/services/vector_service.py

@@ -1,147 +1,32 @@
-import chromadb
-from chromadb.config import Settings
-import os
 from typing import List, Dict, Optional
 import logging
-import numpy as np
+from .pinecone_service import PineconeService
 
 logger = logging.getLogger(__name__)
 
 class VectorService:
+    """Vector service that uses Pinecone for production-ready vector storage"""
+    
     def __init__(self):
         try:
-            # Create absolute path for ChromaDB in HuggingFace Spaces
-            chroma_path = "/app/chroma_db"
-            os.makedirs(chroma_path, exist_ok=True)
-            
-            print(f"🔧 [CHROMA] Using database path: {chroma_path}", flush=True)
-            
-            # Use Client instead of PersistentClient for HuggingFace compatibility
-            self.client = chromadb.Client(Settings(
-                chroma_db_impl="duckdb+parquet",
-                persist_directory=chroma_path,
-                anonymized_telemetry=False,
-                allow_reset=True
-            ))
-            
-            print("✅ [CHROMA] ChromaDB client initialized successfully!", flush=True)
-            logger.info("🗄️ ChromaDB client initialized")
+            print("🚀 [VECTOR] Initializing production vector service with Pinecone", flush=True)
+            self.pinecone_service = PineconeService()
+            print("✅ [VECTOR] Vector service initialized successfully!", flush=True)
+            logger.info("🗄️ Vector service initialized with Pinecone")
             
         except Exception as e:
-            print(f"❌ [CHROMA] Failed to initialize ChromaDB: {e}", flush=True)
-            logger.error(f"❌ Failed to initialize ChromaDB: {e}")
-            raise Exception(f"Failed to initialize ChromaDB: {e}")
-    
-    def create_collection(self, repository_id: int) -> chromadb.Collection:
-        collection_name = f"repo_{repository_id}"
-        
-        try:
-            collection = self.client.get_collection(collection_name)
-            print(f"📚 [CHROMA] Using existing collection: {collection_name}", flush=True)
-            logger.info(f"📚 Using existing collection: {collection_name}")
-        except:
-            collection = self.client.create_collection(
-                name=collection_name,
-                metadata={"repository_id": repository_id}
-            )
-            print(f"🆕 [CHROMA] Created new collection: {collection_name}", flush=True)
-            logger.info(f"🆕 Created new collection: {collection_name}")
-        
-        return collection
+            print(f"❌ [VECTOR] Failed to initialize vector service: {e}", flush=True)
+            logger.error(f"❌ Failed to initialize vector service: {e}")
+            raise Exception(f"Failed to initialize vector service: {e}")
     
     async def store_embeddings(self, repository_id: int, embedded_chunks: List[Dict]):
-        print(f"💾 [CHROMA] Storing {len(embedded_chunks)} embeddings for repository {repository_id}", flush=True)
-        logger.info(f"💾 Storing {len(embedded_chunks)} embeddings for repository {repository_id}")
-        
-        collection = self.create_collection(repository_id)
-        
-        documents = []
-        embeddings = []
-        metadatas = []
-        ids = []
-        
-        for i, chunk in enumerate(embedded_chunks):
-            chunk_id = f"chunk_{repository_id}_{chunk['chunk_index']}_{i}"
-            
-            documents.append(chunk['content'])
-            embeddings.append(chunk['embedding'])
-            metadatas.append({
-                'file_path': chunk['file_path'],
-                'start_line': chunk['start_line'],
-                'end_line': chunk['end_line'],
-                'chunk_type': chunk['chunk_type'],
-                'content_length': chunk['content_length'],
-                'repository_id': repository_id
-            })
-            ids.append(chunk_id)
-        
-        batch_size = 100
-        total_batches = (len(documents) + batch_size - 1) // batch_size
-        
-        for batch_num, i in enumerate(range(0, len(documents), batch_size), 1):
-            end_idx = min(i + batch_size, len(documents))
-            
-            try:
-                collection.add(
-                    documents=documents[i:end_idx],
-                    embeddings=embeddings[i:end_idx],
-                    metadatas=metadatas[i:end_idx],
-                    ids=ids[i:end_idx]
-                )
-                
-                print(f"✅ [CHROMA] Stored batch {batch_num}/{total_batches} ({end_idx-i} embeddings)", flush=True)
-                
-            except Exception as e:
-                print(f"❌ [CHROMA] Error storing batch {batch_num}: {e}", flush=True)
-                raise
-        
-        print(f"🎉 [CHROMA] Successfully stored all {len(embedded_chunks)} embeddings for repository {repository_id}!", flush=True)
-        logger.info(f"✅ Successfully stored all embeddings for repository {repository_id}")
+        """Store embeddings using Pinecone"""
+        return await self.pinecone_service.store_embeddings(repository_id, embedded_chunks)
     
     async def search_similar_code(self, repository_id: int, query_embedding: List[float], top_k: int = 5) -> List[Dict]:
-        collection_name = f"repo_{repository_id}"
-        
-        try:
-            collection = self.client.get_collection(collection_name)
-        except:
-            logger.warning(f"⚠️ Collection {collection_name} not found")
-            return []
-        
-        results = collection.query(
-            query_embeddings=[query_embedding],
-            n_results=top_k,
-            include=['documents', 'metadatas', 'distances']
-        )
-        
-        search_results = []
-        for i in range(len(results['documents'][0])):
-            # Fix similarity calculation
-            distance = results['distances'][0][i]
-            # Convert distance to similarity (higher is better)
-            similarity = max(0.0, 1.0 - distance)  # Ensure positive similarity
-            
-            search_results.append({
-                'content': results['documents'][0][i],
-                'metadata': results['metadatas'][0][i],
-                'similarity': similarity,
-                'file_path': results['metadatas'][0][i]['file_path'],
-                'start_line': results['metadatas'][0][i]['start_line'],
-                'end_line': results['metadatas'][0][i]['end_line']
-            })
-        
-        # Sort by similarity (highest first)
-        search_results.sort(key=lambda x: x['similarity'], reverse=True)
-        
-        logger.info(f"🔍 Found {len(search_results)} similar code chunks")
-        return search_results
+        """Search for similar code using Pinecone"""
+        return await self.pinecone_service.search_similar_code(repository_id, query_embedding, top_k)
     
     async def delete_repository_data(self, repository_id: int):
-        collection_name = f"repo_{repository_id}"
-        
-        try:
-            self.client.delete_collection(collection_name)
-            print(f"🗑️ [CHROMA] Deleted collection: {collection_name}", flush=True)
-            logger.info(f"🗑️ Deleted collection: {collection_name}")
-        except Exception as e:
-            print(f"⚠️ [CHROMA] Collection {collection_name} not found for deletion: {e}", flush=True)
-            logger.warning(f"⚠️ Collection {collection_name} not found for deletion")
+        """Delete repository data using Pinecone"""
+        return await self.pinecone_service.delete_repository_data(repository_id)