visual-rag-toolkit 0.1.1__py3-none-any.whl

demo/indexing.py

@@ -0,0 +1,286 @@
+"""Indexing runner with UI updates."""
+
+import hashlib
+import json
+import time
+import traceback
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+import numpy as np
+import streamlit as st
+import torch
+
+from visual_rag import VisualEmbedder
+
+
+TORCH_DTYPE_MAP = {
+    "float16": torch.float16,
+    "float32": torch.float32,
+    "bfloat16": torch.bfloat16,
+}
+from visual_rag.indexing import QdrantIndexer
+from benchmarks.vidore_tatdqa_test.dataset_loader import 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)."""
+    hex_str = hashlib.sha256(text.encode("utf-8")).hexdigest()[:32]
+    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:
+    """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}")
+
+
+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")
+    recreate = config.get("recreate", False)
+    torch_dtype = config.get("torch_dtype", "float16")
+    qdrant_vector_dtype = config.get("qdrant_vector_dtype", "float16")
+    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}")
+    
+    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
+            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})")
+            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 = QdrantIndexer(
+                url=url,
+                api_key=api_key,
+                collection_name=collection,
+                prefer_grpc=prefer_grpc,
+                vector_datatype=qdrant_vector_dtype,
+            )
+            print(f"[INDEX] Connected to Qdrant")
+            indexer_status.success(f"✅ 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")
+            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,
+                                "doc_id": doc_id,
+                                "source_doc_id": source_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")
+        
+        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,
+            )
+        
+    except Exception as e:
+        print(f"[INDEX] ERROR: {e}")
+        st.error(f"❌ Error: {e}")
+        with st.expander("🔍 Full Error Details"):
+            st.code(traceback.format_exc(), language="text")

demo/qdrant_utils.py

@@ -0,0 +1,211 @@
+"""Qdrant connection and utility functions."""
+
+import os
+import traceback
+from typing import Any, Dict, List, Optional, Tuple
+
+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")
+        or os.getenv("QDRANT_API_KEY")
+    )
+    return url, api_key
+
+
+def init_qdrant_client_with_creds(url: str, api_key: str):
+    try:
+        from qdrant_client import QdrantClient
+        if not url:
+            return None, "QDRANT_URL not configured"
+        client = QdrantClient(url=url, api_key=api_key, timeout=60)
+        client.get_collections()
+        return client, None
+    except Exception as e:
+        return None, str(e)
+
+
+@st.cache_resource(show_spinner="Connecting to Qdrant...")
+def init_qdrant_client():
+    url, api_key = get_qdrant_credentials()
+    return init_qdrant_client_with_creds(url, api_key)
+
+
+@st.cache_resource(show_spinner="Loading embedding model...")
+def init_embedder(model_name: str):
+    try:
+        from visual_rag import VisualEmbedder
+        return VisualEmbedder(model_name=model_name), None
+    except Exception as e:
+        return None, f"{e}\n\n{traceback.format_exc()}"
+
+
+@st.cache_data(ttl=300, show_spinner="Fetching collections...")
+def get_collections(_url: str, _api_key: str) -> List[str]:
+    client, err = init_qdrant_client_with_creds(_url, _api_key)
+    if client is None:
+        return []
+    try:
+        collections = client.get_collections().collections
+        return sorted([c.name for c in collections])
+    except Exception:
+        return []
+
+
+@st.cache_data(ttl=120, show_spinner="Loading collection stats...")
+def get_collection_stats(collection_name: str) -> Dict[str, Any]:
+    url, api_key = get_qdrant_credentials()
+    client, err = init_qdrant_client_with_creds(url, api_key)
+    if client is None:
+        return {"error": err}
+    try:
+        info = client.get_collection(collection_name)
+        vectors_config = getattr(getattr(getattr(info, "config", None), "params", None), "vectors", None)
+        vector_info = {}
+        if vectors_config is not None:
+            if hasattr(vectors_config, "items"):
+                for name, cfg in vectors_config.items():
+                    size = getattr(cfg, "size", None)
+                    multivec = getattr(cfg, "multivector_config", None)
+                    on_disk = getattr(cfg, "on_disk", None)
+                    datatype = str(getattr(cfg, "datatype", "Float32")).replace("Datatype.", "")
+                    quantization = getattr(cfg, "quantization_config", None)
+                    num_vectors = 1
+                    if multivec is not None:
+                        comparator = getattr(multivec, "comparator", None)
+                        num_vectors = "N" if comparator else 1
+                    vector_info[name] = {
+                        "size": size,
+                        "num_vectors": num_vectors,
+                        "is_multivector": multivec is not None,
+                        "on_disk": on_disk,
+                        "datatype": datatype,
+                        "quantization": quantization is not None,
+                    }
+            elif hasattr(vectors_config, "size"):
+                on_disk = getattr(vectors_config, "on_disk", None)
+                datatype = str(getattr(vectors_config, "datatype", "Float32")).replace("Datatype.", "")
+                multivec = getattr(vectors_config, "multivector_config", None)
+                vector_info["default"] = {
+                    "size": getattr(vectors_config, "size", None),
+                    "num_vectors": "N" if multivec else 1,
+                    "is_multivector": multivec is not None,
+                    "on_disk": on_disk,
+                    "datatype": datatype,
+                }
+        return {
+            "points_count": getattr(info, "points_count", 0),
+            "vectors_count": getattr(info, "vectors_count", getattr(info, "points_count", 0)),
+            "status": str(getattr(info, "status", "unknown")),
+            "vector_info": vector_info,
+            "indexed_vectors_count": getattr(info, "indexed_vectors_count", None),
+        }
+    except Exception as e:
+        return {"error": f"{e}\n\n{traceback.format_exc()}"}
+
+
+@st.cache_data(ttl=60)
+def sample_points_cached(collection_name: str, n: int, seed: int, _url: str, _api_key: str) -> List[Dict[str, Any]]:
+    client, err = init_qdrant_client_with_creds(_url, _api_key)
+    if client is None:
+        return []
+    try:
+        import random
+        rng = random.Random(seed)
+        points, _ = client.scroll(
+            collection_name=collection_name,
+            limit=min(n * 10, 100),
+            with_payload=True,
+            with_vectors=False,
+        )
+        if not points:
+            return []
+        sampled = rng.sample(points, min(n, len(points)))
+        results = []
+        for p in sampled:
+            payload = dict(p.payload) if p.payload else {}
+            results.append({
+                "id": str(p.id),
+                "payload": payload,
+            })
+        return results
+    except Exception:
+        return []
+
+
+@st.cache_data(ttl=300)
+def get_vector_sizes(collection_name: str, _url: str, _api_key: str) -> Dict[str, int]:
+    client, err = init_qdrant_client_with_creds(_url, _api_key)
+    if client is None:
+        return {}
+    try:
+        points, _ = client.scroll(
+            collection_name=collection_name,
+            limit=1,
+            with_payload=False,
+            with_vectors=True,
+        )
+        if not points:
+            return {}
+        vectors = points[0].vector
+        sizes = {}
+        if isinstance(vectors, dict):
+            for name, vec in vectors.items():
+                if isinstance(vec, list):
+                    if vec and isinstance(vec[0], list):
+                        sizes[name] = len(vec)
+                    else:
+                        sizes[name] = 1
+                else:
+                    sizes[name] = 1
+        return sizes
+    except Exception:
+        return {}
+
+
+def search_collection(
+    collection_name: str,
+    query: str,
+    top_k: int = 10,
+    mode: str = "single_full",
+    prefetch_k: int = 256,
+    stage1_mode: str = "tokens_vs_tiles",
+    stage1_k: int = 1000,
+    stage2_k: int = 300,
+    model_name: str = "vidore/colSmol-500M",
+) -> Tuple[List[Dict[str, Any]], Optional[str]]:
+    try:
+        import traceback
+        from visual_rag.retrieval import MultiVectorRetriever
+        retriever = MultiVectorRetriever(
+            collection_name=collection_name,
+            model_name=model_name,
+        )
+        if mode == "three_stage":
+            q_emb = retriever.embedder.embed_query(query)
+            if hasattr(q_emb, "cpu"):
+                q_emb = q_emb.cpu().numpy()
+            results = retriever.search_embedded(
+                query_embedding=q_emb,
+                top_k=top_k,
+                mode=mode,
+                stage1_k=stage1_k,
+                stage2_k=stage2_k,
+            )
+        else:
+            results = retriever.search(
+                query=query,
+                top_k=top_k,
+                mode=mode,
+                prefetch_k=prefetch_k,
+                stage1_mode=stage1_mode,
+            )
+        return results, None
+    except Exception as e:
+        import traceback
+        return [], f"{e}\n\n{traceback.format_exc()}"

demo/results.py

@@ -0,0 +1,35 @@
+"""Results file handling utilities."""
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+def load_results_file(path: Path) -> Optional[Dict[str, Any]]:
+    try:
+        with open(path, "r") as f:
+            return json.load(f)
+    except Exception:
+        return None
+
+
+def get_available_results() -> List[Path]:
+    results_dir = Path(__file__).parent.parent / "results"
+    if not results_dir.exists():
+        return []
+    results = []
+    for subdir in results_dir.iterdir():
+        if subdir.is_dir():
+            for f in subdir.glob("*.json"):
+                if "index_failures" not in f.name:
+                    results.append(f)
+    return sorted(results, key=lambda x: x.stat().st_mtime, reverse=True)
+
+
+def find_main_result_file(collection: str, mode: str) -> Optional[Path]:
+    results = get_available_results()
+    for r in results:
+        if collection in str(r) and mode in r.name:
+            if "__vidore_" not in r.name:
+                return r
+    return results[0] if results else None

demo/test_qdrant_connection.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""Test Qdrant connection and collection creation."""
+
+import os
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from dotenv import load_dotenv
+load_dotenv(Path(__file__).parent.parent / ".env")
+load_dotenv(Path(__file__).parent.parent.parent / ".env")
+
+def test_connection():
+    from qdrant_client import QdrantClient
+    from qdrant_client.http import models
+    
+    url = os.getenv("QDRANT_URL")
+    api_key = os.getenv("QDRANT_API_KEY")
+    
+    print(f"URL: {url}")
+    print(f"API Key: {'***' + api_key[-4:] if api_key else 'NOT SET'}")
+    
+    if not url or not api_key:
+        print("ERROR: QDRANT_URL or QDRANT_API_KEY not set")
+        return
+    
+    print("\n1. Creating client...")
+    client = QdrantClient(url=url, api_key=api_key, timeout=60)
+    
+    print("\n2. Getting collections...")
+    try:
+        collections = client.get_collections()
+        print(f"   Found {len(collections.collections)} collections:")
+        for c in collections.collections:
+            print(f"     - {c.name}")
+    except Exception as e:
+        print(f"   ERROR: {e}")
+        return
+    
+    test_collection = "_test_visual_rag_toolkit"
+    
+    print(f"\n3. Checking if '{test_collection}' exists...")
+    exists = any(c.name == test_collection for c in collections.collections)
+    print(f"   Exists: {exists}")
+    
+    if exists:
+        print(f"\n4. Deleting test collection...")
+        try:
+            client.delete_collection(test_collection)
+            print("   Deleted")
+        except Exception as e:
+            print(f"   ERROR: {e}")
+    
+    print(f"\n5. Creating SIMPLE collection (single vector)...")
+    try:
+        client.create_collection(
+            collection_name=test_collection,
+            vectors_config=models.VectorParams(
+                size=128,
+                distance=models.Distance.COSINE,
+            ),
+        )
+        print("   SUCCESS: Simple collection created")
+    except Exception as e:
+        print(f"   ERROR: {e}")
+        print("\n   This means basic collection creation is failing.")
+        print("   Check your Qdrant Cloud cluster status/limits.")
+        return
+    
+    print(f"\n6. Deleting test collection...")
+    try:
+        client.delete_collection(test_collection)
+        print("   Deleted")
+    except Exception as e:
+        print(f"   ERROR: {e}")
+    
+    print(f"\n7. Creating MULTI-VECTOR collection (like visual-rag)...")
+    try:
+        client.create_collection(
+            collection_name=test_collection,
+            vectors_config={
+                "initial": models.VectorParams(
+                    size=128,
+                    distance=models.Distance.COSINE,
+                    multivector_config=models.MultiVectorConfig(
+                        comparator=models.MultiVectorComparator.MAX_SIM
+                    ),
+                ),
+                "mean_pooling": models.VectorParams(
+                    size=128,
+                    distance=models.Distance.COSINE,
+                    multivector_config=models.MultiVectorConfig(
+                        comparator=models.MultiVectorComparator.MAX_SIM
+                    ),
+                ),
+            },
+        )
+        print("   SUCCESS: Multi-vector collection created")
+    except Exception as e:
+        print(f"   ERROR: {e}")
+        print("\n   Multi-vector collection failed but simple worked.")
+        print("   Your Qdrant version may not support multi-vector.")
+        return
+    
+    print(f"\n8. Final cleanup...")
+    try:
+        client.delete_collection(test_collection)
+        print("   Deleted")
+    except Exception as e:
+        print(f"   ERROR: {e}")
+    
+    print("\n" + "="*50)
+    print("ALL TESTS PASSED - Qdrant connection is working!")
+    print("="*50)
+
+
+if __name__ == "__main__":
+    test_connection()

demo/ui/__init__.py

@@ -0,0 +1,15 @@
+"""UI components for the demo app."""
+
+from demo.ui.header import render_header
+from demo.ui.sidebar import render_sidebar
+from demo.ui.upload import render_upload_tab
+from demo.ui.playground import render_playground_tab
+from demo.ui.benchmark import render_benchmark_tab
+
+__all__ = [
+    "render_header",
+    "render_sidebar",
+    "render_upload_tab",
+    "render_playground_tab",
+    "render_benchmark_tab",
+]