add setting tab

app.py

@@ -524,7 +524,17 @@ def run_evaluation(queries_json: str, output_filename: str) -> Tuple[str, pd.Dat
 initialize_system()
 
 # Create Gradio interface
-with gr.Blocks(title="RAG Evaluation System") as demo:
+# Minimal CSS to keep layout stable when vertical scrollbar appears and improve mobile spacing
+APP_CSS = """
+html, body { scrollbar-gutter: stable both-edges; }
+body { overflow-y: scroll; }
+* { box-sizing: border-box; }
+@media (max-width: 768px) {
+  .gradio-container { padding-left: 8px; padding-right: 8px; }
+}
+"""
+
+with gr.Blocks(title="RAG Evaluation System", css=APP_CSS) as demo:
     gr.Markdown("# RAG Evaluation System: Hierarchical vs Standard RAG")
     
     with gr.Tab("Upload Documents"):
@@ -662,6 +672,71 @@ with gr.Blocks(title="RAG Evaluation System") as demo:
                     width=600,
                     height=400
                 )
+    with gr.Tab("Settings"):
+        gr.Markdown("## Settings")
+        gr.Markdown("Configure embedding models and system preferences.")
+        
+        with gr.Accordion("Embedding Configuration", open=True):
+            gr.Markdown("**Select the embedding provider and model.** Switching providers requires re-indexing your documents.")
+            
+            with gr.Row():
+                with gr.Column():
+                    emb_provider = gr.Radio(
+                        choices=["SentenceTransformers", "OpenAI"],
+                        value="SentenceTransformers",
+                        label="Embeddings Provider",
+                        info="Choose between local SentenceTransformers models or OpenAI embeddings (requires API key)"
+                    )
+                    
+                    with gr.Row():
+                        apply_embed_btn = gr.Button("Apply Embedding Settings", variant="primary")
+            
+            with gr.Row():
+                with gr.Column():
+                    st_model_in = gr.Textbox(
+                        label="SentenceTransformers Model",
+                        value=os.getenv("ST_EMBED_MODEL", "all-MiniLM-L6-v2"),
+                        interactive=False,
+                        info="Local embedding model (384 dimensions)"
+                    )
+                with gr.Column():
+                    oai_model_in = gr.Textbox(
+                        label="OpenAI Embedding Model",
+                        value=os.getenv("OPENAI_EMBED_MODEL", "text-embedding-3-small"),
+                        interactive=False,
+                        info="OpenAI embedding model (1536 dimensions for small, 3072 for large)"
+                    )
+            
+            embed_status = gr.Textbox(
+                label="Status",
+                lines=3,
+                interactive=False,
+                placeholder="Embedding configuration status will appear here..."
+            )
+        
+        # Define handler before wiring it
+        def _apply_embeddings(provider, st_model, oai_model):
+            try:
+                use_oai = (provider == "OpenAI")
+                rag_manager.vector_store.configure_embeddings(use_oai, openai_model=oai_model, st_model_name=st_model)
+                status_msg = f"✅ Embeddings successfully configured!\n\n"
+                status_msg += f"Provider: {provider}\n"
+                if use_oai:
+                    status_msg += f"Model: {oai_model} (OpenAI)\n"
+                    status_msg += f"Dimensions: {3072 if 'large' in oai_model.lower() else 1536}\n"
+                else:
+                    status_msg += f"Model: {st_model} (SentenceTransformers)\n"
+                    status_msg += f"Dimensions: ~384\n"
+                status_msg += f"\n⚠️ Note: If switching providers, reset and rebuild your index in the Upload tab."
+                return status_msg
+            except Exception as ex:
+                return f"❌ Failed to set embeddings: {ex}\n\nPlease check your configuration and try again."
+
+        apply_embed_btn.click(
+            fn=_apply_embeddings,
+            inputs=[emb_provider, st_model_in, oai_model_in],
+            outputs=embed_status
+        )
     
     # Event handlers
     build_btn.click(

core/index.py

@@ -26,28 +26,18 @@ class VectorStore:
         os.makedirs(persist_directory, exist_ok=True, mode=0o755)
         
         self.client = chromadb.PersistentClient(path=persist_directory)
-        # Configure embeddings provider (default: do NOT use OpenAI unless explicitly enabled)
-        self.use_openai = bool(os.getenv("USE_OPENAI_EMBEDDINGS", "").lower() in ("1", "true", "yes"))
-        if self.use_openai:
-            self.openai_client = _OpenAI()
-            self.openai_model = os.getenv("OPENAI_EMBED_MODEL", "text-embedding-3-small")
-            # Determine embedding dimension from known OpenAI models
-            if self.openai_model == "text-embedding-3-large":
-                self.embed_dim = 3072
-            else:
-                # default small model
-                self.embed_dim = 1536
-        else:
-            if SentenceTransformer is None:
-                raise RuntimeError("SentenceTransformer not available and OpenAI embeddings not configured.")
-            self.st_model_name = os.getenv("ST_EMBED_MODEL", "all-MiniLM-L6-v2")
-            self.embedding_model = SentenceTransformer(self.st_model_name)
-            # Get model output dimension
-            try:
-                self.embed_dim = int(getattr(self.embedding_model, "get_sentence_embedding_dimension")())
-            except Exception:
-                # Fallback: compute once
-                self.embed_dim = len(self.embedding_model.encode("test"))
+        # Default to SentenceTransformers; runtime switching handled via configure_embeddings()
+        self.use_openai = False
+        if SentenceTransformer is None:
+            raise RuntimeError("SentenceTransformers not available. Install sentence-transformers or switch to OpenAI via UI.")
+        self.st_model_name = os.getenv("ST_EMBED_MODEL", "all-MiniLM-L6-v2")
+        self.embedding_model = SentenceTransformer(self.st_model_name)
+        # Get model output dimension
+        try:
+            self.embed_dim = int(getattr(self.embedding_model, "get_sentence_embedding_dimension")())
+        except Exception:
+            # Fallback: compute once
+            self.embed_dim = len(self.embedding_model.encode("test"))
 
     def _reopen_client(self, new_path: str):
         os.makedirs(new_path, exist_ok=True, mode=0o755)
@@ -61,6 +51,34 @@ class VectorStore:
     def _resolve_collection_name(self, base_name: str) -> str:
         """Ensure separate collections per embedding dimension/provider to avoid mismatch."""
         return f"{base_name}__{self._collection_suffix()}"
+
+    def configure_embeddings(self, use_openai: bool, openai_model: Optional[str] = None, st_model_name: Optional[str] = None):
+        """Reconfigure embedding backend at runtime.
+        Switching providers/dimensions implies a new collection suffix; existing data remains under old suffix.
+        """
+        self.use_openai = bool(use_openai)
+        if self.use_openai:
+            # Check at call-time to avoid stale module-level flags
+            if not os.getenv("OPENAI_API_KEY"):
+                raise RuntimeError("OpenAI not available or API key missing.")
+            self.openai_client = _OpenAI()
+            self.openai_model = openai_model or os.getenv("OPENAI_EMBED_MODEL", "text-embedding-3-small")
+            if self.openai_model == "text-embedding-3-large":
+                self.embed_dim = 3072
+            else:
+                self.embed_dim = 1536
+        else:
+            if SentenceTransformer is None:
+                raise RuntimeError("SentenceTransformer not available.")
+            name = st_model_name or os.getenv("ST_EMBED_MODEL", "all-MiniLM-L6-v2")
+            # Only reload if changed
+            if not hasattr(self, 'st_model_name') or self.st_model_name != name:
+                self.st_model_name = name
+                self.embedding_model = SentenceTransformer(self.st_model_name)
+            try:
+                self.embed_dim = int(getattr(self.embedding_model, "get_sentence_embedding_dimension")())
+            except Exception:
+                self.embed_dim = len(self.embedding_model.encode("test"))
     
     def create_collection(self, name: str) -> chromadb.Collection:
         """Create or get collection, namespaced by embedding provider/dimension."""

core/ingest.py

@@ -106,7 +106,7 @@ class DocumentLoader:
                 except:
                     # If strict=False doesn't work, try normal reader
                     file.seek(0)
-                    reader = PyPDF2.PdfReader(file)
+                reader = PyPDF2.PdfReader(file)
                 
                 text = ""
                 for i, page in enumerate(reader.pages):
@@ -195,7 +195,7 @@ class DocumentChunker:
         """
         loader = DocumentLoader()
         content = loader.load_document(file_path)
-
+        
         # Auto-detect language if needed
         if not language or str(language).lower() == 'auto':
             # Prefer OpenAI if available
@@ -407,7 +407,7 @@ class DocumentChunker:
                 content=text_block,
                 metadata=final_md
             ))
-
+        
         return chunks
     
     def _generate_metadata(self, file_path: str, hierarchy_def: Dict[str, Any],
@@ -415,7 +415,7 @@ class DocumentChunker:
         """Generate hierarchical metadata for chunk"""
         # Simple rule-based classification with explicit label override
         content_lower = content.lower()
-
+        
         # 1) Try to honor explicit labels like "Domain:", "Section:", "Topic:"
         import re
         explicit_l1 = explicit_l2 = explicit_l3 = None