visual-rag-toolkit 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

demo/app.py

@@ -1,13 +1,23 @@
 """Main entry point for the Visual RAG Toolkit demo application."""
 
+import os
 import sys
 from pathlib import Path
 
-ROOT_DIR = Path(__file__).parent.parent
-sys.path.insert(0, str(ROOT_DIR))
+# Ensure repo root is in sys.path for local development
+# (In HF Space / Docker, PYTHONPATH is already set correctly)
+_app_dir = Path(__file__).resolve().parent
+_repo_root = _app_dir.parent
+if str(_repo_root) not in sys.path:
+    sys.path.insert(0, str(_repo_root))
 
 from dotenv import load_dotenv
-load_dotenv(ROOT_DIR / ".env")
+
+# Load .env from the repo root (works both locally and in Docker)
+if (_repo_root / ".env").exists():
+    load_dotenv(_repo_root / ".env")
+if (_app_dir / ".env").exists():
+    load_dotenv(_app_dir / ".env")
 
 import streamlit as st
 
@@ -28,15 +38,17 @@ from demo.ui.benchmark import render_benchmark_tab
 def main():
     render_header()
     render_sidebar()
-    
-    tab_upload, tab_playground, tab_benchmark = st.tabs(["📤 Upload", "🎮 Playground", "📊 Benchmarking"])
-    
+
+    tab_upload, tab_playground, tab_benchmark = st.tabs(
+        ["📤 Upload", "🎮 Playground", "📊 Benchmarking"]
+    )
+
     with tab_upload:
         render_upload_tab()
-    
+
     with tab_playground:
         render_playground_tab()
-    
+
     with tab_benchmark:
         render_benchmark_tab()
 

demo/evaluation.py

@@ -1,20 +1,23 @@
 """Evaluation runner with UI updates."""
 
 import hashlib
-import importlib.util
 import json
 import logging
 import time
 import traceback
 from datetime import datetime
-from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 import numpy as np
 import streamlit as st
 import torch
+from qdrant_client.models import FieldCondition, Filter, MatchValue
 
 from visual_rag import VisualEmbedder
+from visual_rag.retrieval import MultiVectorRetriever
+from benchmarks.vidore_tatdqa_test.dataset_loader import load_vidore_beir_dataset
+from benchmarks.vidore_tatdqa_test.metrics import ndcg_at_k, mrr_at_k, recall_at_k
+from demo.qdrant_utils import get_qdrant_credentials
 
 
 TORCH_DTYPE_MAP = {
@@ -22,49 +25,6 @@ TORCH_DTYPE_MAP = {
     "float32": torch.float32,
     "bfloat16": torch.bfloat16,
 }
-from qdrant_client.models import Filter, FieldCondition, MatchValue
-
-from visual_rag.retrieval import MultiVectorRetriever
-
-
-def _load_local_benchmark_module(module_filename: str):
-    """
-    Load `benchmarks/vidore_tatdqa_test/<module_filename>` via file path.
-
-    Motivation:
-    - Some environments (notably containers / Spaces) can have a third-party
-      `benchmarks` package installed, causing `import benchmarks...` to resolve
-      to the wrong module.
-    - This fallback guarantees we load the repo's benchmark utilities.
-    """
-    root = Path(__file__).resolve().parents[1]  # demo/.. = repo root
-    target = root / "benchmarks" / "vidore_tatdqa_test" / module_filename
-    if not target.exists():
-        raise ModuleNotFoundError(f"Missing local benchmark module file: {target}")
-
-    name = f"_visual_rag_toolkit_local_{target.stem}"
-    spec = importlib.util.spec_from_file_location(name, str(target))
-    if spec is None or spec.loader is None:
-        raise ModuleNotFoundError(f"Could not load module spec for: {target}")
-    mod = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(mod)  # type: ignore[attr-defined]
-    return mod
-
-
-try:
-    # Preferred: normal import
-    from benchmarks.vidore_tatdqa_test.dataset_loader import load_vidore_beir_dataset
-    from benchmarks.vidore_tatdqa_test.metrics import ndcg_at_k, mrr_at_k, recall_at_k
-except ModuleNotFoundError:
-    # Robust fallback: load from local file paths
-    _dl = _load_local_benchmark_module("dataset_loader.py")
-    _mx = _load_local_benchmark_module("metrics.py")
-    load_vidore_beir_dataset = _dl.load_vidore_beir_dataset
-    ndcg_at_k = _mx.ndcg_at_k
-    mrr_at_k = _mx.mrr_at_k
-    recall_at_k = _mx.recall_at_k
-
-from demo.qdrant_utils import get_qdrant_credentials
 
 logger = logging.getLogger(__name__)
 logging.basicConfig(level=logging.INFO, format="[%(levelname)s] %(message)s")

demo/indexing.py

@@ -1,12 +1,10 @@
 """Indexing runner with UI updates."""
 
 import hashlib
-import importlib.util
 import json
 import time
 import traceback
 from datetime import datetime
-from pathlib import Path
 from typing import Any, Dict, Optional
 
 import numpy as np
@@ -14,6 +12,10 @@ import streamlit as st
 import torch
 
 from visual_rag import VisualEmbedder
+from visual_rag.embedding.pooling import tile_level_mean_pooling
+from visual_rag.indexing.qdrant_indexer import QdrantIndexer
+from benchmarks.vidore_tatdqa_test.dataset_loader import load_vidore_beir_dataset
+from demo.qdrant_utils import get_qdrant_credentials
 
 
 TORCH_DTYPE_MAP = {
@@ -22,37 +24,6 @@ TORCH_DTYPE_MAP = {
     "bfloat16": torch.bfloat16,
 }
 
-# --- Robust imports (Spaces-friendly) ---
-# Some environments can have a third-party `benchmarks` package installed, or
-# resolve `visual_rag.indexing` oddly. These fallbacks keep the demo working.
-try:
-    from visual_rag.indexing import QdrantIndexer
-except Exception:  # pragma: no cover
-    from visual_rag.indexing.qdrant_indexer import QdrantIndexer
-
-
-def _load_local_benchmark_module(module_filename: str):
-    root = Path(__file__).resolve().parents[1]  # demo/.. = repo root
-    target = root / "benchmarks" / "vidore_tatdqa_test" / module_filename
-    if not target.exists():
-        raise ModuleNotFoundError(f"Missing local benchmark module file: {target}")
-    name = f"_visual_rag_toolkit_local_{target.stem}"
-    spec = importlib.util.spec_from_file_location(name, str(target))
-    if spec is None or spec.loader is None:
-        raise ModuleNotFoundError(f"Could not load module spec for: {target}")
-    mod = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(mod)  # type: ignore[attr-defined]
-    return mod
-
-
-try:
-    from benchmarks.vidore_tatdqa_test.dataset_loader import load_vidore_beir_dataset
-except ModuleNotFoundError:  # pragma: no cover
-    _dl = _load_local_benchmark_module("dataset_loader.py")
-    load_vidore_beir_dataset = _dl.load_vidore_beir_dataset
-
-from demo.qdrant_utils import get_qdrant_credentials
-
 
 def _stable_uuid(text: str) -> str:
     """Generate a stable UUID from text (same as benchmark script)."""
@@ -60,7 +31,9 @@ def _stable_uuid(text: str) -> str:
     return f"{hex_str[:8]}-{hex_str[8:12]}-{hex_str[12:16]}-{hex_str[16:20]}-{hex_str[20:32]}"
 
 
-def _union_point_id(*, dataset_name: str, source_doc_id: str, union_namespace: Optional[str]) -> str:
+def _union_point_id(
+    *, dataset_name: str, source_doc_id: str, union_namespace: Optional[str]
+) -> str:
     """Generate union point ID (same as benchmark script)."""
     ns = f"{union_namespace}::{dataset_name}" if union_namespace else dataset_name
     return _stable_uuid(f"{ns}::{source_doc_id}")
@@ -68,16 +41,16 @@ def _union_point_id(*, dataset_name: str, source_doc_id: str, union_namespace: O
 
 def run_indexing_with_ui(config: Dict[str, Any]):
     st.divider()
-    
+
     print("=" * 60)
     print("[INDEX] Starting indexing via UI")
     print("=" * 60)
-    
+
     url, api_key = get_qdrant_credentials()
     if not url:
         st.error("QDRANT_URL not configured")
         return
-    
+
     datasets = config.get("datasets", [])
     collection = config["collection"]
     model = config.get("model", "vidore/colpali-v1.3")
@@ -87,42 +60,50 @@ def run_indexing_with_ui(config: Dict[str, Any]):
     prefer_grpc = config.get("prefer_grpc", True)
     batch_size = config.get("batch_size", 4)
     max_docs = config.get("max_docs")
-    
+
     print(f"[INDEX] Config: collection={collection}, model={model}")
     print(f"[INDEX] Datasets: {datasets}")
-    print(f"[INDEX] max_docs={max_docs}, batch_size={batch_size}, recreate={recreate}")
-    print(f"[INDEX] torch_dtype={torch_dtype}, qdrant_dtype={qdrant_vector_dtype}, grpc={prefer_grpc}")
-    
+    print(
+        f"[INDEX] max_docs={max_docs}, batch_size={batch_size}, recreate={recreate}"
+    )
+    print(
+        f"[INDEX] torch_dtype={torch_dtype}, qdrant_dtype={qdrant_vector_dtype}, grpc={prefer_grpc}"
+    )
+
     phase1_container = st.container()
     phase2_container = st.container()
     phase3_container = st.container()
     results_container = st.container()
-    
+
     try:
         with phase1_container:
             st.markdown("##### 🤖 Phase 1: Loading Model")
             model_status = st.empty()
             model_status.info(f"Loading `{model.split('/')[-1]}`...")
-            
+
             print(f"[INDEX] Loading embedder: {model}")
             torch_dtype_obj = TORCH_DTYPE_MAP.get(torch_dtype, torch.float16)
-            output_dtype_obj = np.float16 if qdrant_vector_dtype == "float16" else np.float32
+            output_dtype_obj = (
+                np.float16 if qdrant_vector_dtype == "float16" else np.float32
+            )
             embedder = VisualEmbedder(
                 model_name=model,
                 torch_dtype=torch_dtype_obj,
                 output_dtype=output_dtype_obj,
             )
             embedder._load_model()
-            print(f"[INDEX] Embedder loaded (torch_dtype={torch_dtype}, output_dtype={qdrant_vector_dtype})")
+            print(
+                f"[INDEX] Embedder loaded (torch_dtype={torch_dtype}, output_dtype={qdrant_vector_dtype})"
+            )
             model_status.success(f"✅ Model `{model.split('/')[-1]}` loaded")
-        
+
         with phase2_container:
             st.markdown("##### 📦 Phase 2: Setting Up Collection")
-            
+
             indexer_status = st.empty()
-            indexer_status.info(f"Connecting to Qdrant...")
-            
-            print(f"[INDEX] Connecting to Qdrant...")
+            indexer_status.info("Connecting to Qdrant...")
+
+            print("[INDEX] Connecting to Qdrant...")
             indexer = QdrantIndexer(
                 url=url,
                 api_key=api_key,
@@ -130,186 +111,164 @@ def run_indexing_with_ui(config: Dict[str, Any]):
                 prefer_grpc=prefer_grpc,
                 vector_datatype=qdrant_vector_dtype,
             )
-            print(f"[INDEX] Connected to Qdrant")
-            indexer_status.success(f"✅ Connected to Qdrant")
-            
+            print("[INDEX] Connected to Qdrant")
+            indexer_status.success("✅ Connected to Qdrant")
+
             coll_status = st.empty()
             action = "Recreating" if recreate else "Creating/verifying"
             coll_status.info(f"{action} collection `{collection}`...")
-            
+
             print(f"[INDEX] {action} collection: {collection}")
             indexer.create_collection(force_recreate=recreate)
-            indexer.create_payload_indexes(fields=[
-                {"field": "dataset", "type": "keyword"},
-                {"field": "doc_id", "type": "keyword"},
-                {"field": "source_doc_id", "type": "keyword"},
-            ])
-            print(f"[INDEX] Collection ready")
+            indexer.create_payload_indexes(
+                fields=[
+                    {"field": "dataset", "type": "keyword"},
+                    {"field": "doc_id", "type": "keyword"},
+                    {"field": "source_doc_id", "type": "keyword"},
+                ]
+            )
+            print("[INDEX] Collection ready")
             coll_status.success(f"✅ Collection `{collection}` ready")
-        
+
         with phase3_container:
-            st.markdown("##### 🚀 Phase 3: Indexing Documents")
-            
-            total_uploaded = 0
-            total_docs = 0
-            total_time = 0
-            
-            for ds_name in datasets:
-                ds_short = ds_name.split("/")[-1]
-                ds_header = st.empty()
-                ds_header.info(f"📚 Loading `{ds_short}`...")
-                
-                print(f"[INDEX] Loading dataset: {ds_name}")
-                corpus, queries, qrels = load_vidore_beir_dataset(ds_name)
-                
-                if max_docs and max_docs > 0 and len(corpus) > max_docs:
-                    corpus = corpus[:max_docs]
-                    print(f"[INDEX] Limited to {len(corpus)} docs (max_docs={max_docs})")
-                
-                total_docs += len(corpus)
-                print(f"[INDEX] Dataset {ds_name}: {len(corpus)} documents to index")
-                ds_header.success(f"📚 `{ds_short}`: {len(corpus)} documents")
-                
-                progress_bar = st.progress(0.0)
-                batch_status = st.empty()
-                log_area = st.empty()
-                log_lines = []
-                
-                num_batches = (len(corpus) + batch_size - 1) // batch_size
-                ds_start = time.time()
-                
-                for i in range(0, len(corpus), batch_size):
-                    batch = corpus[i:i + batch_size]
-                    images = [doc.image for doc in batch if hasattr(doc, 'image') and doc.image]
-                    
-                    if not images:
-                        continue
-                    
-                    batch_num = i // batch_size + 1
-                    batch_status.info(f"Batch {batch_num}/{num_batches}: embedding & uploading...")
-                    
-                    batch_start = time.time()
-                    embeddings, token_infos = embedder.embed_images(images, return_token_info=True)
-                    embed_time = time.time() - batch_start
-                    
-                    points = []
-                    for j, (doc, emb, token_info) in enumerate(zip(batch, embeddings, token_infos)):
-                        doc_id = doc.doc_id if hasattr(doc, 'doc_id') else str(i + j)
-                        source_doc_id = str(doc.payload.get("source_doc_id", doc_id) if hasattr(doc, 'payload') else doc_id)
-                        
-                        union_doc_id = _union_point_id(
-                            dataset_name=ds_name,
-                            source_doc_id=source_doc_id,
-                            union_namespace=collection,
-                        )
-                        
-                        emb_np = emb.cpu().numpy() if hasattr(emb, 'cpu') else np.array(emb)
-                        visual_indices = token_info.get("visual_token_indices") or list(range(emb_np.shape[0]))
-                        visual_emb = emb_np[visual_indices].astype(embedder.output_dtype)
-                        
-                        tile_pooled = embedder.mean_pool_visual_embedding(visual_emb, token_info, target_vectors=32)
-                        experimental = embedder.experimental_pool_visual_embedding(
-                            visual_emb, token_info, target_vectors=32, mean_pool=tile_pooled
-                        )
-                        global_pooled = embedder.global_pool_from_mean_pool(tile_pooled)
-                        
-                        points.append({
-                            "id": union_doc_id,
-                            "visual_embedding": visual_emb,
-                            "tile_pooled_embedding": tile_pooled,
-                            "experimental_pooled_embedding": experimental,
-                            "global_pooled_embedding": global_pooled,
-                            "metadata": {
-                                "dataset": ds_name,
+            st.markdown("##### 📊 Phase 3: Processing Datasets")
+
+            all_results = []
+
+            for ds_idx, dataset_name in enumerate(datasets):
+                ds_short = dataset_name.split("/")[-1]
+                ds_container = st.container()
+
+                with ds_container:
+                    st.markdown(
+                        f"**Dataset {ds_idx + 1}/{len(datasets)}: `{ds_short}`**"
+                    )
+
+                    load_status = st.empty()
+                    load_status.info(f"Loading dataset `{ds_short}`...")
+
+                    print(f"[INDEX] Loading dataset: {dataset_name}")
+                    corpus, queries, qrels = load_vidore_beir_dataset(dataset_name)
+                    total_docs = len(corpus)
+                    print(f"[INDEX] Dataset loaded: {total_docs} docs")
+                    load_status.success(f"✅ Loaded {total_docs:,} documents")
+
+                    if max_docs and max_docs < total_docs:
+                        corpus = corpus[:max_docs]
+                        print(f"[INDEX] Limiting to {max_docs} docs")
+
+                    progress_bar = st.progress(0)
+                    status_text = st.empty()
+
+                    uploaded = 0
+                    failed = 0
+                    total = len(corpus)
+
+                    for i, doc in enumerate(corpus):
+                        try:
+                            doc_id = str(doc.doc_id)
+                            image = doc.image
+                            if image is None:
+                                failed += 1
+                                continue
+
+                            status_text.text(
+                                f"Processing {i + 1}/{total}: {doc_id[:30]}..."
+                            )
+
+                            embeddings, token_infos = embedder.embed_images(
+                                [image],
+                                return_token_info=True,
+                                show_progress=False,
+                            )
+                            emb = embeddings[0]
+                            token_info = token_infos[0] if token_infos else {}
+
+                            if hasattr(emb, "cpu"):
+                                emb = emb.cpu()
+                            emb_np = np.asarray(emb, dtype=output_dtype_obj)
+
+                            initial = emb_np.tolist()
+                            global_pool = emb_np.mean(axis=0).tolist()
+
+                            num_tiles = token_info.get("num_tiles")
+                            mean_pooling = None
+                            experimental_pooling = None
+
+                            if num_tiles and num_tiles > 0:
+                                try:
+                                    mean_pooling = tile_level_mean_pooling(
+                                        emb_np, num_tiles=num_tiles, patches_per_tile=64
+                                    ).tolist()
+                                except Exception:
+                                    pass
+
+                                try:
+                                    exp_pool = embedder.experimental_pool_visual_embedding(
+                                        emb_np, num_tiles=num_tiles
+                                    )
+                                    if exp_pool is not None:
+                                        experimental_pooling = exp_pool.tolist()
+                                except Exception:
+                                    pass
+
+                            union_doc_id = _union_point_id(
+                                dataset_name=dataset_name,
+                                source_doc_id=doc_id,
+                                union_namespace=collection,
+                            )
+
+                            payload = {
+                                "dataset": dataset_name,
                                 "doc_id": doc_id,
-                                "source_doc_id": source_doc_id,
+                                "source_doc_id": doc_id,
                                 "union_doc_id": union_doc_id,
-                            },
-                        })
-                    
-                    upload_start = time.time()
-                    indexer.upload_batch(points)
-                    upload_time = time.time() - upload_start
-                    total_uploaded += len(points)
-                    
-                    progress = (i + len(batch)) / len(corpus)
-                    progress_bar.progress(progress)
-                    batch_status.info(f"Batch {batch_num}/{num_batches} ({int(progress*100)}%) — embed: {embed_time:.1f}s, upload: {upload_time:.1f}s")
-                    
-                    log_interval = max(2, num_batches // 10)
-                    should_log = batch_num % log_interval == 0 or batch_num == num_batches
-                    
-                    if should_log and batch_num > 1:
-                        log_lines.append(f"[Batch {batch_num}/{num_batches}] +{len(points)} pts, total={total_uploaded}")
-                        log_area.code("\n".join(log_lines[-8:]), language="text")
-                        print(f"[INDEX] Batch {batch_num}/{num_batches}: +{len(points)} pts, total={total_uploaded}, embed={embed_time:.1f}s, upload={upload_time:.1f}s")
-                
-                ds_time = time.time() - ds_start
-                total_time += ds_time
-                progress_bar.progress(1.0)
-                batch_status.success(f"✅ `{ds_short}` indexed: {len(corpus)} docs in {ds_time:.1f}s")
-                print(f"[INDEX] Dataset {ds_name} complete: {len(corpus)} docs in {ds_time:.1f}s")
-        
+                                "num_tiles": num_tiles,
+                                "num_visual_tokens": token_info.get("num_visual_tokens"),
+                            }
+
+                            vectors = {"initial": initial, "global_pooling": global_pool}
+                            if mean_pooling:
+                                vectors["mean_pooling"] = mean_pooling
+                            if experimental_pooling:
+                                vectors["experimental_pooling"] = experimental_pooling
+
+                            indexer.upsert_point(
+                                point_id=union_doc_id,
+                                vectors=vectors,
+                                payload=payload,
+                            )
+
+                            uploaded += 1
+
+                        except Exception as e:
+                            print(f"[INDEX] Error on doc {i}: {e}")
+                            failed += 1
+
+                        progress_bar.progress((i + 1) / total)
+
+                    status_text.text(f"✅ Done: {uploaded} uploaded, {failed} failed")
+                    all_results.append(
+                        {
+                            "dataset": dataset_name,
+                            "total": total,
+                            "uploaded": uploaded,
+                            "failed": failed,
+                        }
+                    )
+
         with results_container:
-            st.markdown("##### 📊 Summary")
-            
-            docs_per_sec = total_uploaded / total_time if total_time > 0 else 0
-            
-            print("=" * 60)
-            print("[INDEX] INDEXING COMPLETE")
-            print(f"[INDEX]   Total Uploaded: {total_uploaded:,}")
-            print(f"[INDEX]   Datasets: {len(datasets)}")
-            print(f"[INDEX]   Collection: {collection}")
-            print(f"[INDEX]   Total Time: {total_time:.1f}s")
-            print(f"[INDEX]   Throughput: {docs_per_sec:.2f} docs/s")
-            print("=" * 60)
-            
-            c1, c2, c3, c4 = st.columns(4)
-            c1.metric("Total Uploaded", f"{total_uploaded:,}")
-            c2.metric("Datasets", len(datasets))
-            c3.metric("Total Time", f"{total_time:.1f}s")
-            c4.metric("Throughput", f"{docs_per_sec:.2f}/s")
-            
-            st.success(f"🎉 Indexing complete! {total_uploaded:,} documents indexed to `{collection}`")
-            
-            detailed_report = {
-                "generated_at": datetime.now().isoformat(),
-                "config": {
-                    "collection": collection,
-                    "model": model,
-                    "datasets": datasets,
-                    "batch_size": batch_size,
-                    "max_docs_per_dataset": max_docs,
-                    "recreate": recreate,
-                    "prefer_grpc": prefer_grpc,
-                    "torch_dtype": torch_dtype,
-                    "qdrant_vector_dtype": qdrant_vector_dtype,
-                },
-                "results": {
-                    "total_docs_uploaded": total_uploaded,
-                    "total_time_s": round(total_time, 2),
-                    "throughput_docs_per_s": round(docs_per_sec, 2),
-                    "num_datasets": len(datasets),
-                },
-            }
-            
-            with st.expander("📋 Full Summary"):
-                st.json(detailed_report)
-            
-            report_json = json.dumps(detailed_report, indent=2)
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            filename = f"index_report__{collection}__{timestamp}.json"
-            
-            st.download_button(
-                label="📥 Download Indexing Report",
-                data=report_json,
-                file_name=filename,
-                mime="application/json",
-                use_container_width=True,
-            )
-        
+            st.markdown("##### 📋 Results Summary")
+
+            for r in all_results:
+                st.write(
+                    f"**{r['dataset'].split('/')[-1]}**: {r['uploaded']:,} uploaded, {r['failed']:,} failed"
+                )
+
+            st.success("✅ Indexing complete!")
+
     except Exception as e:
+        st.error(f"Indexing error: {e}")
+        st.code(traceback.format_exc())
         print(f"[INDEX] ERROR: {e}")
-        st.error(f"❌ Error: {e}")
-        with st.expander("🔍 Full Error Details"):
-            st.code(traceback.format_exc(), language="text")
+        traceback.print_exc()

demo/qdrant_utils.py

@@ -8,12 +8,19 @@ import streamlit as st
 
 
 def get_qdrant_credentials() -> Tuple[Optional[str], Optional[str]]:
-    url = st.session_state.get("qdrant_url_input") or os.getenv("SIGIR_QDRANT_URL") or os.getenv("DEST_QDRANT_URL") or os.getenv("QDRANT_URL")
-    api_key = st.session_state.get("qdrant_key_input") or (
-        os.getenv("SIGIR_QDRANT_KEY")
-        or os.getenv("SIGIR_QDRANT_API_KEY")
-        or os.getenv("DEST_QDRANT_API_KEY")
+    """Get Qdrant credentials from session state or environment variables.
+    
+    Priority: session_state > QDRANT_URL/QDRANT_API_KEY > legacy env vars
+    """
+    url = (
+        st.session_state.get("qdrant_url_input")
+        or os.getenv("QDRANT_URL")
+        or os.getenv("SIGIR_QDRANT_URL")  # legacy
+    )
+    api_key = (
+        st.session_state.get("qdrant_key_input")
         or os.getenv("QDRANT_API_KEY")
+        or os.getenv("SIGIR_QDRANT_KEY")  # legacy
     )
     return url, api_key
 

demo/ui/playground.py

@@ -9,6 +9,7 @@ from demo.qdrant_utils import (
     sample_points_cached,
     search_collection,
 )
+from visual_rag.retrieval import MultiVectorRetriever
 
 
 def render_playground_tab():
@@ -46,7 +47,6 @@ def render_playground_tab():
         if not st.session_state.get("model_loaded"):
             with st.spinner(f"Loading {model_short}..."):
                 try:
-                    from visual_rag.retrieval import MultiVectorRetriever
                     _ = MultiVectorRetriever(collection_name=active_collection, model_name=model_name)
                     st.session_state["model_loaded"] = True
                     st.session_state["loaded_model_key"] = cache_key