Fix in-memory Qdrant initialization for T4 deployment

- Added support for in-memory Qdrant mode when host is None
- Auto-initialize collection and upload vectors for in-memory mode
- Load embeddings from data/vectors/embeddings.npy
- Batch upload vectors to prevent memory issues

src/retrieval/hybrid_retriever.py

@@ -72,8 +72,8 @@ class HybridRetriever:
     CPT_PATTERN = re.compile(r'\b\d{5}\b')
     
     def __init__(self, 
-                 qdrant_host: str = "localhost",
-                 qdrant_port: int = 6333,
+                 qdrant_host: Optional[str] = "localhost",
+                 qdrant_port: Optional[int] = 6333,
                  collection_name: str = "ip_medcpt",
                  chunks_file: str = "data/chunks/chunks.jsonl",
                  cpt_index_file: str = "data/term_index/cpt_codes.jsonl",
@@ -84,8 +84,8 @@ class HybridRetriever:
         Initialize hybrid retriever.
         
         Args:
-            qdrant_host: Qdrant server host
-            qdrant_port: Qdrant server port
+            qdrant_host: Qdrant server host (None for in-memory)
+            qdrant_port: Qdrant server port (None for in-memory)
             collection_name: Name of Qdrant collection
             chunks_file: Path to chunks JSONL file
             cpt_index_file: Path to CPT codes index
@@ -93,8 +93,11 @@ class HybridRetriever:
             query_encoder_model: Model for query encoding
             reranker_model: Cross-encoder for reranking
         """
-        # Initialize Qdrant client
-        self.qdrant = QdrantClient(host=qdrant_host, port=qdrant_port)
+        # Initialize Qdrant client (in-memory if host is None)
+        if qdrant_host is None:
+            self.qdrant = QdrantClient(":memory:")
+        else:
+            self.qdrant = QdrantClient(host=qdrant_host, port=qdrant_port)
         self.collection_name = collection_name
         
         # Load chunks for BM25 and metadata
@@ -130,8 +133,70 @@ class HybridRetriever:
         print(f"Loading reranker: {reranker_model}")
         self.reranker = CrossEncoder(reranker_model)
         
+        # Initialize in-memory collection if needed
+        if qdrant_host is None:
+            self._initialize_inmemory_collection()
+        
         print("Hybrid retriever initialized")
     
+    def _initialize_inmemory_collection(self):
+        """Initialize in-memory Qdrant collection with vectors."""
+        print("Initializing in-memory Qdrant collection...")
+        
+        from qdrant_client.models import Distance, VectorParams, PointStruct
+        
+        # Create collection
+        try:
+            self.qdrant.create_collection(
+                collection_name=self.collection_name,
+                vectors_config=VectorParams(size=768, distance=Distance.COSINE)
+            )
+            print(f"Created collection: {self.collection_name}")
+        except Exception as e:
+            print(f"Collection might already exist: {e}")
+        
+        # Load embeddings if available
+        embeddings_file = Path("data/vectors/embeddings.npy")
+        if embeddings_file.exists():
+            print("Loading embeddings...")
+            embeddings = np.load(embeddings_file)
+            
+            # Prepare points for upload
+            points = []
+            for i, (chunk, embedding) in enumerate(zip(self.chunks[:len(embeddings)], embeddings)):
+                # Use chunk_id if available, otherwise use index
+                chunk_id = chunk.get('chunk_id', chunk.get('id', str(i)))
+                
+                point = PointStruct(
+                    id=i,
+                    vector=embedding.tolist(),
+                    payload={
+                        "chunk_id": chunk_id,
+                        "text": chunk.get('text', ''),
+                        "doc_id": chunk.get('doc_id', ''),
+                        "section_title": chunk.get('section_title', ''),
+                        "authority_tier": chunk.get('authority_tier', 'A4'),
+                        "evidence_level": chunk.get('evidence_level', 'H4'),
+                        "year": chunk.get('year', 2020),
+                        "doc_type": chunk.get('doc_type', 'article')
+                    }
+                )
+                points.append(point)
+            
+            # Upload in batches
+            batch_size = 100
+            for i in range(0, len(points), batch_size):
+                batch = points[i:i+batch_size]
+                self.qdrant.upsert(
+                    collection_name=self.collection_name,
+                    points=batch
+                )
+                print(f"Uploaded batch {i//batch_size + 1}/{(len(points) + batch_size - 1)//batch_size}")
+            
+            print(f"Uploaded {len(points)} vectors to in-memory collection")
+        else:
+            print("Warning: No embeddings file found. Semantic search will not work.")
+    
     def _load_term_index(self, index_file: str) -> Dict[str, List[str]]:
         """Load term index from JSONL file."""
         index = defaultdict(list)