Update app.py

Changes to expand abilities

app.py

@@ -1,9 +1,10 @@
 import os
 import re
 import json
+import yaml
+import argparse
 from pathlib import Path
 from typing import List, Dict, Tuple, Optional
-import tempfile
 
 import numpy as np
 import faiss
@@ -14,22 +15,86 @@ from sentence_transformers import SentenceTransformer
 import PyPDF2
 import docx
 
-# ----------- Paths -----------
-KB_DIR = Path("./kb")
-INDEX_DIR = Path("./.index")
-INDEX_DIR.mkdir(exist_ok=True, parents=True)
-
-# ----------- Models (free) -----------
-EMBEDDING_MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
-READER_MODEL_NAME = "deepset/roberta-base-squad2"
-
-EMBEDDINGS_PATH = INDEX_DIR / "kb_embeddings.npy"
-METADATA_PATH = INDEX_DIR / "kb_metadata.json"
-FAISS_PATH = INDEX_DIR / "kb_faiss.index"
+# ----------- Configuration Loader -----------
+class Config:
+    """Load and manage configuration from YAML file."""
+    
+    def __init__(self, config_path: str = "config.yaml"):
+        with open(config_path, 'r', encoding='utf-8') as f:
+            self.data = yaml.safe_load(f)
+    
+    @property
+    def client_name(self) -> str:
+        return self.data.get('client', {}).get('name', 'RAG Assistant')
+    
+    @property
+    def client_description(self) -> str:
+        return self.data.get('client', {}).get('description', 'AI-powered Q&A with document retrieval and citation')
+    
+    @property
+    def client_logo(self) -> Optional[str]:
+        return self.data.get('client', {}).get('logo')
+    
+    @property
+    def theme_color(self) -> str:
+        return self.data.get('client', {}).get('theme_color', 'blue')
+    
+    @property
+    def kb_directory(self) -> Path:
+        return Path(self.data.get('kb', {}).get('directory', './kb'))
+    
+    @property
+    def index_directory(self) -> Path:
+        return Path(self.data.get('kb', {}).get('index_directory', './.index'))
+    
+    @property
+    def embedding_model(self) -> str:
+        return self.data.get('models', {}).get('embedding', 'sentence-transformers/all-MiniLM-L6-v2')
+    
+    @property
+    def qa_model(self) -> str:
+        return self.data.get('models', {}).get('qa', 'deepset/roberta-base-squad2')
+    
+    @property
+    def confidence_threshold(self) -> float:
+        return self.data.get('thresholds', {}).get('confidence', 0.25)
+    
+    @property
+    def similarity_threshold(self) -> float:
+        return self.data.get('thresholds', {}).get('similarity', 0.35)
+    
+    @property
+    def chunk_size(self) -> int:
+        return self.data.get('chunking', {}).get('chunk_size', 800)
+    
+    @property
+    def chunk_overlap(self) -> int:
+        return self.data.get('chunking', {}).get('overlap', 200)
+    
+    @property
+    def quick_actions(self) -> List[Tuple[str, str]]:
+        actions = self.data.get('quick_actions', [])
+        return [(a['label'], a['query']) for a in actions]
+    
+    @property
+    def welcome_message(self) -> str:
+        return self.data.get('messages', {}).get('welcome', 
+            '👋 How can I help? Ask me anything or use a quick action button below.')
+    
+    @property
+    def no_answer_message(self) -> str:
+        return self.data.get('messages', {}).get('no_answer',
+            "❌ **I don't know the answer to that** but if you have any document with details I can learn about it.")
+    
+    @property
+    def upload_prompt(self) -> str:
+        return self.data.get('messages', {}).get('upload_prompt',
+            '📤 Upload a relevant document above, and I\'ll be able to help you find the information you need!')
 
-HEADING_RE = re.compile(r"^(#{1,6})\s+(.*)$", re.MULTILINE)
+# Global config instance
+config = None
 
-# ----------- Load Documents -----------
+# ----------- Document Extraction -----------
 def extract_text_from_pdf(file_path: str) -> str:
     """Extract text from PDF file."""
     text = ""
@@ -60,10 +125,7 @@ def extract_text_from_txt(file_path: str) -> str:
         raise RuntimeError(f"Error reading TXT: {str(e)}")
 
 def extract_text_from_file(file_path: str) -> Tuple[str, str]:
-    """
-    Extract text from uploaded file based on extension.
-    Returns: (text_content, file_type)
-    """
+    """Extract text from uploaded file based on extension."""
     ext = Path(file_path).suffix.lower()
     
     if ext == '.pdf':
@@ -75,6 +137,9 @@ def extract_text_from_file(file_path: str) -> Tuple[str, str]:
     else:
         raise ValueError(f"Unsupported file type: {ext}. Supported: .pdf, .docx, .txt, .md")
 
+# ----------- Document Processing -----------
+HEADING_RE = re.compile(r"^(#{1,6})\s+(.*)$", re.MULTILINE)
+
 def read_markdown_files(kb_dir: Path) -> List[Dict]:
     """Read all markdown files from the knowledge base directory."""
     docs = []
@@ -92,11 +157,13 @@ def read_markdown_files(kb_dir: Path) -> List[Dict]:
         })
     return docs
 
-def chunk_markdown(doc: Dict, chunk_chars: int = 800, overlap: int = 200) -> List[Dict]:
-    """
-    Split markdown document into overlapping chunks for better retrieval.
-    Reduced chunk size and increased overlap for more precise matching.
-    """
+def chunk_markdown(doc: Dict, chunk_chars: int = None, overlap: int = None) -> List[Dict]:
+    """Split markdown document into overlapping chunks."""
+    if chunk_chars is None:
+        chunk_chars = config.chunk_size
+    if overlap is None:
+        overlap = config.chunk_overlap
+        
     text = doc["text"]
     sections = re.split(r"(?=^##\s+|\n##\s+|\n###\s+|^###\s+)", text, flags=re.MULTILINE)
     if len(sections) == 1:
@@ -105,19 +172,18 @@ def chunk_markdown(doc: Dict, chunk_chars: int = 800, overlap: int = 200) -> Lis
     chunks = []
     for sec in sections:
         sec = sec.strip()
-        if not sec or len(sec) < 50:  # Skip very short sections
+        if not sec or len(sec) < 50:
             continue
             
         heading_match = HEADING_RE.search(sec)
         section_heading = heading_match.group(2).strip() if heading_match else doc["title"]
 
-        # Better chunking logic
         start = 0
         while start < len(sec):
             end = min(start + chunk_chars, len(sec))
             chunk_text = sec[start:end].strip()
             
-            if len(chunk_text) > 50:  # Only keep substantial chunks
+            if len(chunk_text) > 50:
                 chunks.append({
                     "doc_title": doc["title"],
                     "filename": doc["filename"],
@@ -135,9 +201,9 @@ def chunk_markdown(doc: Dict, chunk_chars: int = 800, overlap: int = 200) -> Lis
 # ----------- KB Index -----------
 class KBIndex:
     def __init__(self):
-        self.embedder = SentenceTransformer(EMBEDDING_MODEL_NAME)
-        self.reader_tokenizer = AutoTokenizer.from_pretrained(READER_MODEL_NAME)
-        self.reader_model = AutoModelForQuestionAnswering.from_pretrained(READER_MODEL_NAME)
+        self.embedder = SentenceTransformer(config.embedding_model)
+        self.reader_tokenizer = AutoTokenizer.from_pretrained(config.qa_model)
+        self.reader_model = AutoModelForQuestionAnswering.from_pretrained(config.qa_model)
         self.reader = pipeline(
             "question-answering", 
             model=self.reader_model, 
@@ -149,7 +215,12 @@ class KBIndex:
         self.index = None
         self.embeddings = None
         self.metadata = []
-        self.uploaded_file_active = False  # Track if using uploaded file
+        self.uploaded_file_active = False
+        
+        # Paths based on config
+        self.embeddings_path = config.index_directory / "kb_embeddings.npy"
+        self.metadata_path = config.index_directory / "kb_metadata.json"
+        self.faiss_path = config.index_directory / "kb_faiss.index"
 
     def build(self, kb_dir: Path):
         """Build the FAISS index from markdown files."""
@@ -182,20 +253,21 @@ class KBIndex:
         self.metadata = all_chunks
         self.uploaded_file_active = False
 
-        np.save(EMBEDDINGS_PATH, embeddings)
-        with open(METADATA_PATH, "w", encoding="utf-8") as f:
+        # Ensure index directory exists
+        config.index_directory.mkdir(exist_ok=True, parents=True)
+        
+        np.save(self.embeddings_path, embeddings)
+        with open(self.metadata_path, "w", encoding="utf-8") as f:
             json.dump(self.metadata, f, ensure_ascii=False, indent=2)
-        faiss.write_index(index, str(FAISS_PATH))
+        faiss.write_index(index, str(self.faiss_path))
 
     def build_from_uploaded_file(self, file_path: str, filename: str):
         """Build temporary index from an uploaded file."""
-        # Extract text from file
         text_content, file_type = extract_text_from_file(file_path)
         
         if not text_content or len(text_content.strip()) < 100:
             raise RuntimeError("File appears to be empty or too short.")
         
-        # Create document structure
         doc = {
             "filepath": file_path,
             "filename": filename,
@@ -203,13 +275,11 @@ class KBIndex:
             "text": text_content
         }
         
-        # Chunk the document
         all_chunks = chunk_markdown(doc)
         
         if not all_chunks:
             raise RuntimeError("Could not extract meaningful content from file.")
         
-        # Build embeddings
         texts = [c["content"] for c in all_chunks]
         embeddings = self.embedder.encode(
             texts, 
@@ -219,7 +289,6 @@ class KBIndex:
         )
         faiss.normalize_L2(embeddings)
         
-        # Create new index
         dim = embeddings.shape[1]
         index = faiss.IndexFlatIP(dim)
         index.add(embeddings)
@@ -233,12 +302,12 @@ class KBIndex:
 
     def load(self) -> bool:
         """Load pre-built index from disk."""
-        if not (EMBEDDINGS_PATH.exists() and METADATA_PATH.exists() and FAISS_PATH.exists()):
+        if not (self.embeddings_path.exists() and self.metadata_path.exists() and self.faiss_path.exists()):
             return False
-        self.embeddings = np.load(EMBEDDINGS_PATH)
-        with open(METADATA_PATH, "r", encoding="utf-8") as f:
+        self.embeddings = np.load(self.embeddings_path)
+        with open(self.metadata_path, "r", encoding="utf-8") as f:
             self.metadata = json.load(f)
-        self.index = faiss.read_index(str(FAISS_PATH))
+        self.index = faiss.read_index(str(self.faiss_path))
         self.uploaded_file_active = False
         return True
 
@@ -250,10 +319,7 @@ class KBIndex:
         return list(zip(I[0].tolist(), D[0].tolist()))
 
     def answer(self, question: str, retrieved: List[Tuple[int, float]]) -> Tuple[Optional[str], float, List[Dict], float]:
-        """
-        Extract answer from retrieved chunks using QA model.
-        Returns: (answer_text, qa_score, citations, best_similarity)
-        """
+        """Extract answer from retrieved chunks using QA model."""
         candidates = []
         
         for idx, sim in retrieved:
@@ -265,9 +331,7 @@ class KBIndex:
                 score = float(out.get("score", 0.0))
                 answer_text = out.get("answer", "").strip()
                 
-                # Enhanced answer extraction with context
                 if answer_text and len(answer_text) > 3:
-                    # Try to expand the answer with surrounding context
                     expanded_answer = self._expand_answer(answer_text, ctx)
                     
                     candidates.append({
@@ -284,11 +348,9 @@ class KBIndex:
         if not candidates:
             return None, 0.0, [], max([s for _, s in retrieved]) if retrieved else 0.0
         
-        # Sort by combined score (QA score + similarity)
         candidates.sort(key=lambda x: x["score"] * 0.7 + x["sim"] * 0.3, reverse=True)
         best = candidates[0]
         
-        # Generate citations from top retrieved chunks
         citations = []
         seen = set()
         for idx, _ in retrieved[:3]:
@@ -307,44 +369,34 @@ class KBIndex:
         return best["text"], best["score"], citations, best_sim
     
     def _expand_answer(self, answer: str, context: str, max_chars: int = 300) -> str:
-        """
-        Expand the extracted answer with surrounding context to make it more complete.
-        """
-        # Find the answer in the context
+        """Expand the extracted answer with surrounding context."""
         answer_pos = context.lower().find(answer.lower())
         
         if answer_pos == -1:
             return answer
         
-        # Get sentence boundaries around the answer
         start = answer_pos
         end = answer_pos + len(answer)
         
-        # Expand backwards to sentence start
         while start > 0 and context[start - 1] not in '.!?\n':
             start -= 1
             if answer_pos - start > max_chars // 2:
                 break
         
-        # Expand forwards to sentence end
         while end < len(context) and context[end] not in '.!?\n':
             end += 1
             if end - answer_pos > max_chars // 2:
                 break
         
-        # Include the punctuation
         if end < len(context) and context[end] in '.!?':
             end += 1
         
         expanded = context[start:end].strip()
         
-        # If still too short, try to get the full sentence(s)
         if len(expanded) < 50:
-            # Look for complete sentences around the answer
             sentences = context.split('.')
             for i, sent in enumerate(sentences):
                 if answer.lower() in sent.lower():
-                    # Get this sentence and maybe the next one
                     result = sent.strip()
                     if i + 1 < len(sentences) and len(result) < 100:
                         result += ". " + sentences[i + 1].strip()
@@ -352,31 +404,18 @@ class KBIndex:
         
         return expanded
 
-# Initialize KB
-kb = KBIndex()
+# Initialize KB (will be done after config is loaded)
+kb = None
 
 def ensure_index():
     """Build index on first run or load from cache."""
     if not kb.load():
-        if KB_DIR.exists():
-            kb.build(KB_DIR)
+        if config.kb_directory.exists():
+            kb.build(config.kb_directory)
         else:
-            print(f"Warning: KB directory {KB_DIR} not found. Please create it and add markdown files.")
-
-ensure_index()
-
-# ----------- Guardrails -----------
-CONFIDENCE_THRESHOLD = 0.25
-SIMILARITY_THRESHOLD = 0.35
-
-QUICK_ACTIONS = [
-    ("🔗 Connect WhatsApp", "How do I connect my WhatsApp number?"),
-    ("🔑 Reset Password", "I can't sign in / forgot my password"),
-    ("⚡ First Automation", "How do I create my first automation?"),
-    ("💳 Billing & Invoices", "How do I download invoices for billing?"),
-    ("📸 Fix Instagram", "Why can't I connect Instagram?")
-]
+            print(f"Warning: KB directory {config.kb_directory} not found.")
 
+# ----------- Response Generation -----------
 def format_citations(citations: List[Dict]) -> str:
     """Format citations as markdown list."""
     if not citations:
@@ -391,47 +430,34 @@ def respond(user_msg: str, history: List, uploaded_file_info: str = None) -> str
     user_msg = (user_msg or "").strip()
     
     if not user_msg:
-        return "👋 How can I help? Ask me anything about the knowledge base, or use a quick action button below."
+        return config.welcome_message
 
-    # Check if we have an index
     if kb.index is None or len(kb.metadata) == 0:
-        return "❌ I don't know the answer to that but if you have any document with details I can learn about it. Please upload a file using the upload section above."
+        return f"{config.no_answer_message}\n\n{config.upload_prompt}"
 
-    # Add context about uploaded file
     source_info = f" in the uploaded file" if kb.uploaded_file_active and uploaded_file_info else " in the knowledge base"
 
-    # Retrieve relevant chunks
     retrieved = kb.retrieve(user_msg, top_k=6)
     
     if not retrieved or (retrieved and max([s for _, s in retrieved]) < 0.20):
-        # Very low similarity - clearly don't know the answer
-        return (
-            f"❌ **I don't know the answer to that** but if you have any document with details I can learn about it.\n\n"
-            f"📤 Upload a relevant document above, and I'll be able to help you find the information you need!"
-        )
+        return f"{config.no_answer_message}\n\n{config.upload_prompt}"
 
-    # Extract answer using QA model
     answer, qa_score, citations, best_sim = kb.answer(user_msg, retrieved)
     
-    # Stricter threshold for "I don't know" response
     if not answer or qa_score < 0.15 or best_sim < 0.25:
         return (
-            f"❌ **I don't know the answer to that** but if you have any document with details I can learn about it.\n\n"
+            f"{config.no_answer_message}\n\n"
             f"The question seems outside the scope of what I currently know{source_info}. "
             f"Try uploading a relevant document, or rephrase your question if you think the information might be here."
         )
 
-    # Clean up the answer text
     answer = answer.strip()
-    # Ensure answer ends with proper punctuation
     if answer and answer[-1] not in '.!?':
         answer += "."
 
-    # Check confidence
-    low_confidence = (qa_score < CONFIDENCE_THRESHOLD) or (best_sim < SIMILARITY_THRESHOLD)
+    low_confidence = (qa_score < config.confidence_threshold) or (best_sim < config.similarity_threshold)
     citations_md = format_citations(citations)
     
-    # Format response based on confidence
     if low_confidence:
         return (
             f"⚠️ **Answer (Low Confidence):**\n\n{answer}\n\n"
@@ -447,6 +473,7 @@ def respond(user_msg: str, history: List, uploaded_file_info: str = None) -> str
             f"💡 *Say \"show more details\" to see the full context.*"
         )
 
+# ----------- UI Handlers -----------
 def process_message(user_input: str, history: List, uploaded_file_info: str) -> Tuple[List, Dict]:
     """Process user message and return updated chat history."""
     user_input = (user_input or "").strip()
@@ -462,7 +489,7 @@ def process_message(user_input: str, history: List, uploaded_file_info: str) ->
 
 def process_quick(label: str, history: List, uploaded_file_info: str) -> Tuple[List, Dict]:
     """Process quick action button click."""
-    for btn_label, query in QUICK_ACTIONS:
+    for btn_label, query in config.quick_actions:
         if label == btn_label:
             return process_message(query, history, uploaded_file_info)
     return history, gr.update(value="")
@@ -503,129 +530,147 @@ def clear_uploaded_file():
 def rebuild_index_handler():
     """Rebuild the search index from KB directory."""
     try:
-        kb.build(KB_DIR)
+        kb.build(config.kb_directory)
         return "✅ Index rebuilt successfully! Ready to answer questions."
     except Exception as e:
         return f"❌ Error rebuilding index: {str(e)}"
 
 # ----------- Gradio UI -----------
-with gr.Blocks(
-    title="RAG Knowledge Assistant", 
-    theme=gr.themes.Soft(primary_hue="blue"),
-    css="""
-        .contain { max-width: 1200px; margin: auto; }
-        .quick-btn { min-width: 180px !important; }
-        .upload-section { border: 2px dashed #ccc; padding: 20px; border-radius: 8px; }
-    """
-) as demo:
+def create_interface():
+    """Create Gradio interface with configuration."""
     
-    # State to track uploaded file
-    uploaded_file_state = gr.State("")
-    
-    # Header
-    gr.Markdown(
-        """
-        # 🤖 RAG Knowledge Assistant
-        ### AI-powered Q&A with document retrieval and citation
-        Upload a document or use the knowledge base to get answers backed by relevant sources.
+    with gr.Blocks(
+        title=config.client_name,
+        theme=gr.themes.Soft(primary_hue=config.theme_color),
+        css="""
+            .contain { max-width: 1200px; margin: auto; }
+            .quick-btn { min-width: 180px !important; }
         """
-    )
-    
-    # File upload section
-    with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("### 📤 Upload Document")
-            file_upload = gr.File(
-                label="Upload PDF, DOCX, TXT, or MD file",
-                file_types=[".pdf", ".docx", ".txt", ".md"],
-                type="filepath"
-            )
-            upload_status = gr.Markdown("ℹ️ Upload a file to ask questions about it.")
-            with gr.Row():
-                clear_btn = gr.Button("🔄 Clear & Use KB", variant="secondary", size="sm")
-    
-    # Main chat interface
-    with gr.Row():
-        with gr.Column(scale=1):
-            chat = gr.Chatbot(
-                height=500,
-                show_copy_button=True,
-                type="messages",
-                avatar_images=(None, "https://em-content.zobj.net/source/twitter/376/robot_1f916.png")
+    ) as demo:
+        
+        uploaded_file_state = gr.State("")
+        
+        # Header
+        header_text = f"# 🤖 {config.client_name}\n### {config.client_description}"
+        if config.client_logo:
+            header_text += f"\n![Logo]({config.client_logo})"
+        
+        gr.Markdown(header_text)
+        
+        # File upload section
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 📤 Upload Document")
+                file_upload = gr.File(
+                    label="Upload PDF, DOCX, TXT, or MD file",
+                    file_types=[".pdf", ".docx", ".txt", ".md"],
+                    type="filepath"
+                )
+                upload_status = gr.Markdown("ℹ️ Upload a file to ask questions about it.")
+                with gr.Row():
+                    clear_btn = gr.Button("🔄 Clear & Use KB", variant="secondary", size="sm")
+        
+        # Main chat interface
+        with gr.Row():
+            with gr.Column(scale=1):
+                chat = gr.Chatbot(
+                    height=500,
+                    show_copy_button=True,
+                    type="messages",
+                    avatar_images=(None, "https://em-content.zobj.net/source/twitter/376/robot_1f916.png")
+                )
+                
+                with gr.Row():
+                    txt = gr.Textbox(
+                        placeholder="💬 Ask a question about the document or knowledge base...",
+                        scale=9,
+                        show_label=False,
+                        container=False
+                    )
+                    send = gr.Button("Send", variant="primary", scale=1)
+        
+        # Quick action buttons (if configured)
+        if config.quick_actions:
+            with gr.Accordion("⚡ Quick Actions", open=False):
+                with gr.Row():
+                    quick_buttons = []
+                    for label, _ in config.quick_actions:
+                        btn = gr.Button(label, elem_classes="quick-btn", size="sm")
+                        quick_buttons.append((btn, label))
+        
+        # Admin section
+        with gr.Accordion("🔧 Admin Panel", open=False):
+            gr.Markdown(
+                f"""
+                **Rebuild Index:** Use this after adding or modifying files in the `{config.kb_directory}` directory.  
+                The system will re-scan all markdown files and update the search index.
+                """
             )
-            
             with gr.Row():
-                txt = gr.Textbox(
-                    placeholder="💬 Ask a question about the document or knowledge base...",
-                    scale=9,
-                    show_label=False,
-                    container=False
+                rebuild_btn = gr.Button("🔄 Rebuild KB Index", variant="secondary")
+                status_msg = gr.Markdown("")
+        
+        # Event handlers
+        file_upload.change(
+            handle_file_upload,
+            inputs=[file_upload],
+            outputs=[upload_status, uploaded_file_state]
+        )
+        
+        clear_btn.click(
+            clear_uploaded_file,
+            outputs=[upload_status, uploaded_file_state, file_upload]
+        )
+        
+        send.click(
+            process_message, 
+            inputs=[txt, chat, uploaded_file_state], 
+            outputs=[chat, txt]
+        )
+        txt.submit(
+            process_message, 
+            inputs=[txt, chat, uploaded_file_state], 
+            outputs=[chat, txt]
+        )
+        
+        if config.quick_actions:
+            for btn, label in quick_buttons:
+                btn.click(
+                    process_quick, 
+                    inputs=[gr.State(label), chat, uploaded_file_state], 
+                    outputs=[chat, txt]
                 )
-                send = gr.Button("Send", variant="primary", scale=1)
-    
-    # Quick action buttons (only for KB mode)
-    with gr.Accordion("⚡ Quick Actions (Knowledge Base)", open=False):
-        with gr.Row():
-            quick_buttons = []
-            for label, _ in QUICK_ACTIONS:
-                btn = gr.Button(label, elem_classes="quick-btn", size="sm")
-                quick_buttons.append((btn, label))
-    
-    # Admin section
-    with gr.Accordion("🔧 Admin Panel", open=False):
+        
+        rebuild_btn.click(rebuild_index_handler, outputs=status_msg)
+        
+        # Footer
         gr.Markdown(
             """
-            **Rebuild Index:** Use this after adding or modifying files in the `/kb` directory.  
-            The system will re-scan all markdown files and update the search index.
+            ---
+            💡 **Tips:**
+            - Upload a document to ask questions specifically about that file
+            - Use "Clear & Use KB" to switch back to the knowledge base
+            - Be specific in your questions for better results
+            - Check the cited sources for full context
             """
         )
-        with gr.Row():
-            rebuild_btn = gr.Button("🔄 Rebuild KB Index", variant="secondary")
-            status_msg = gr.Markdown("")
     
-    # Event handlers
-    file_upload.change(
-        handle_file_upload,
-        inputs=[file_upload],
-        outputs=[upload_status, uploaded_file_state]
-    )
-    
-    clear_btn.click(
-        clear_uploaded_file,
-        outputs=[upload_status, uploaded_file_state, file_upload]
-    )
-    
-    send.click(
-        process_message, 
-        inputs=[txt, chat, uploaded_file_state], 
-        outputs=[chat, txt]
-    )
-    txt.submit(
-        process_message, 
-        inputs=[txt, chat, uploaded_file_state], 
-        outputs=[chat, txt]
-    )
+    return demo
+
+# ----------- Main Entry Point -----------
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Configurable RAG Assistant')
+    parser.add_argument('--config', type=str, default='config.yaml',
+                        help='Path to configuration YAML file (default: config.yaml)')
+    args = parser.parse_args()
     
-    for btn, label in quick_buttons:
-        btn.click(
-            process_quick, 
-            inputs=[gr.State(label), chat, uploaded_file_state], 
-            outputs=[chat, txt]
-        )
+    # Load configuration
+    config = Config(args.config)
     
-    rebuild_btn.click(rebuild_index_handler, outputs=status_msg)
+    # Initialize KB with config
+    kb = KBIndex()
+    ensure_index()
     
-    # Footer
-    gr.Markdown(
-        """
-        ---
-        💡 **Tips:**
-        - Upload a document to ask questions specifically about that file
-        - Use "Clear & Use KB" to switch back to the knowledge base
-        - Be specific in your questions for better results
-        - Check the cited sources for full context
-        """
-    )
-
-if __name__ == "__main__":
+    # Create and launch interface
+    demo = create_interface()
     demo.launch()