Fix: Remove qdrant_service parameter from index_chunks_to_qdrant

Now uses module-level singleton throughout all initialization code

demo/main.py

@@ -13,7 +13,6 @@ if os.getenv("SPACE_ID"):  # Detect HF Spaces environment
 
 sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
 
-from scientific_rag.application.rag.pipeline import RAGPipeline
 from scientific_rag.scripts.index_qdrant import index_qdrant
 
 
@@ -28,15 +27,22 @@ def initialize_qdrant_on_hf_spaces():
         raise FileNotFoundError(f"Required file not found: {chunks_file}")
 
     logger.info("Initializing Qdrant with chunks from local script...")
-    index_qdrant(
-        chunks_file=chunks_file,
-        embedding_batch_size=32,
-        upload_batch_size=100,
-        create_collection=True,
-        process_batch_size=10000,
-    )
-    logger.info("✅ Qdrant initialization complete!")
+    try:
+        index_qdrant(
+            chunks_file=chunks_file,
+            embedding_batch_size=32,
+            upload_batch_size=100,
+            create_collection=True,
+            process_batch_size=10000,
+        )
+        logger.info("✅ Qdrant initialization complete!")
+    except Exception as e:
+        logger.error(f"Qdrant initialization failed: {e}", exc_info=True)
+        raise
+
 
+# Import RAGPipeline AFTER setting up Qdrant
+from scientific_rag.application.rag.pipeline import RAGPipeline
 
 MAIN_HEADER = """
 <div style="text-align: center; margin-bottom: 40px;">
@@ -217,7 +223,7 @@ try:
 
     rag_pipeline = RAGPipelineWrapper()
 except Exception as e:
-    logger.error(f"Failed to initialize RAG pipeline: {e}")
+    logger.error(f"Failed to initialize RAG pipeline: {e}", exc_info=True)
     rag_pipeline = None
 
 

src/scientific_rag/scripts/index_qdrant.py

@@ -1,5 +1,5 @@
-from collections.abc import Iterator
 import json
+from collections.abc import Iterator
 from pathlib import Path
 from typing import Any
 
@@ -9,11 +9,13 @@ from tqdm import tqdm
 
 from scientific_rag.application.embeddings.encoder import encoder
 from scientific_rag.domain.documents import PaperChunk
-from scientific_rag.infrastructure.qdrant import QdrantService
+from scientific_rag.infrastructure.qdrant import qdrant_service
 from scientific_rag.settings import settings
 
 
-def load_chunks_generator(chunks_file: Path, batch_size: int = 10000) -> Iterator[list[PaperChunk]]:
+def load_chunks_generator(
+    chunks_file: Path, batch_size: int = 10000
+) -> Iterator[list[PaperChunk]]:
     logger.info(f"Loading chunks from {chunks_file} in batches of {batch_size}")
 
     with open(chunks_file, encoding="utf-8") as f:
@@ -61,11 +63,15 @@ def embed_sparse_chunks(
     show_progress: bool = True,
 ) -> list[Any]:
     """Generate sparse BM25 embeddings for chunks."""
-    logger.info(f"Embedding {len(chunks)} chunks (Sparse BM25) with batch size {batch_size}")
+    logger.info(
+        f"Embedding {len(chunks)} chunks (Sparse BM25) with batch size {batch_size}"
+    )
 
     texts = [chunk.text for chunk in chunks]
 
-    sparse_embeddings = list(sparse_encoder.embed(documents=texts, batch_size=batch_size, parallel=None))
+    sparse_embeddings = list(
+        sparse_encoder.embed(documents=texts, batch_size=batch_size, parallel=None)
+    )
 
     logger.success(f"Generated sparse embeddings for {len(chunks)} chunks")
     return sparse_embeddings
@@ -74,14 +80,17 @@ def embed_sparse_chunks(
 def index_chunks_to_qdrant(
     chunks: list[PaperChunk],
     sparse_embeddings: list[Any],
-    qdrant_service: QdrantService,
     batch_size: int = 100,
     show_progress: bool = True,
 ) -> int:
     """Upload chunks to Qdrant in batches."""
     total_uploaded = 0
 
-    iterator = tqdm(range(0, len(chunks), batch_size), desc="Uploading to Qdrant", disable=not show_progress)
+    iterator = tqdm(
+        range(0, len(chunks), batch_size),
+        desc="Uploading to Qdrant",
+        disable=not show_progress,
+    )
     for i in iterator:
         batch_chunks = chunks[i : i + batch_size]
 
@@ -89,7 +98,9 @@ def index_chunks_to_qdrant(
         if sparse_embeddings:
             batch_sparse = sparse_embeddings[i : i + batch_size]
 
-        uploaded = qdrant_service.upsert_chunks(batch_chunks, sparse_embeddings=batch_sparse)
+        uploaded = qdrant_service.upsert_chunks(
+            batch_chunks, sparse_embeddings=batch_sparse
+        )
         total_uploaded += uploaded
 
     return total_uploaded
@@ -112,30 +123,43 @@ def index_qdrant(
         process_batch_size: Process chunks in batches of this size to manage memory
     """
     if chunks_file is None:
-        chunks_file = Path(settings.root_dir) / "data" / "processed" / f"chunks_{settings.dataset_split}.json"
+        chunks_file = (
+            Path(settings.root_dir)
+            / "data"
+            / "processed"
+            / f"chunks_{settings.dataset_split}.json"
+        )
     else:
         chunks_file = Path(chunks_file)
 
     if not chunks_file.exists():
         raise FileNotFoundError(f"Chunks file not found: {chunks_file}")
 
-    qdrant_service = QdrantService()
+    # Use the module-level singleton so in-memory Qdrant is shared
+    # between the indexer and the application runtime.
     if create_collection:
-        qdrant_service.create_collection(vector_size=encoder.embedding_dim)
+        vector_size = getattr(encoder, "embedding_dim", 384)
+        qdrant_service.create_collection(vector_size=vector_size)
 
     logger.info(f"Initializing Sparse Encoder: {settings.sparse_embedding_model_name}")
-    sparse_encoder = SparseTextEmbedding(model_name=settings.sparse_embedding_model_name)
+    sparse_encoder = SparseTextEmbedding(
+        model_name=settings.sparse_embedding_model_name
+    )
 
     logger.info("Processing chunks in streaming batches to manage memory...")
     total_uploaded = 0
     batch_num = 0
 
-    for batch_chunks in load_chunks_generator(chunks_file, batch_size=process_batch_size):
+    for batch_chunks in load_chunks_generator(
+        chunks_file, batch_size=process_batch_size
+    ):
         batch_num += 1
         batch_start = (batch_num - 1) * process_batch_size
         batch_end = batch_start + len(batch_chunks)
 
-        logger.info(f"--- Processing Batch {batch_num} (Chunks {batch_start}-{batch_end}) ---")
+        logger.info(
+            f"--- Processing Batch {batch_num} (Chunks {batch_start}-{batch_end}) ---"
+        )
 
         batch_chunks = embed_chunks(
             chunks=batch_chunks,
@@ -154,13 +178,14 @@ def index_qdrant(
         batch_uploaded = index_chunks_to_qdrant(
             chunks=batch_chunks,
             sparse_embeddings=batch_sparse,
-            qdrant_service=qdrant_service,
             batch_size=upload_batch_size,
             show_progress=True,
         )
         total_uploaded += batch_uploaded
 
-        logger.success(f"Batch {batch_num} complete: {batch_uploaded} chunks uploaded (Total: {total_uploaded})")
+        logger.success(
+            f"Batch {batch_num} complete: {batch_uploaded} chunks uploaded (Total: {total_uploaded})"
+        )
 
     logger.info("Getting final statistics...")
     collection_info = qdrant_service.get_collection_info()