Update app.py

app.py

@@ -1,7 +1,7 @@
 import gradio as gr
 import json
 import numpy as np
-from transformers import pipeline
+from transformers import pipeline, AutoTokenizer, AutoModel
 import torch
 import os
 from typing import List, Dict, Any
@@ -10,18 +10,10 @@ import requests
 import re
 import math
 from collections import defaultdict, Counter
-import logging
-
-# Import configuration
-from config import *
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
 
 # Configure device
-device = get_device()
-logger.info(f"Using device: {device}")
+device = "cuda" if torch.cuda.is_available() else "cpu"
+print(f"Using device: {device}")
 
 class HybridSearchRAGBot:
     def __init__(self):
@@ -30,15 +22,15 @@ class HybridSearchRAGBot:
         self.embeddings = []
         
         # BM25 components
-        self.term_frequencies = {}
-        self.document_frequency = {}
-        self.document_lengths = {}
+        self.term_frequencies = {}  # doc_id -> {term: frequency}
+        self.document_frequency = {}  # term -> number of docs containing term
+        self.document_lengths = {}  # doc_id -> document length
         self.average_doc_length = 0
         self.total_documents = 0
         
         # BM25 parameters
-        self.k1 = BM25_K1
-        self.b = BM25_B
+        self.k1 = 1.5  # Controls term frequency saturation
+        self.b = 0.75  # Controls document length normalization
         
         self.initialize_models()
         self.load_markdown_knowledge_base()
@@ -47,64 +39,84 @@ class HybridSearchRAGBot:
     def initialize_models(self):
         """Initialize the embedding model"""
         try:
-            logger.info("Loading embedding model...")
+            print("Loading embedding model...")
             self.embedder = pipeline(
                 'feature-extraction', 
-                EMBEDDING_MODEL,
+                'sentence-transformers/all-MiniLM-L6-v2',
                 device=0 if device == "cuda" else -1
             )
-            logger.info("✅ Embedding model loaded successfully")
+            print("✅ Embedding model loaded successfully")
         except Exception as e:
-            logger.error(f"❌ Error loading embedding model: {e}")
+            print(f"❌ Error loading embedding model: {e}")
             raise e
     
     def load_markdown_knowledge_base(self):
         """Load knowledge base from markdown files"""
-        logger.info("Loading knowledge base from markdown files...")
+        print("Loading knowledge base from markdown files...")
         
         # Reset knowledge base
         self.knowledge_base = []
         
-        for filename in KNOWLEDGE_BASE_FILES:
+        # Load all markdown files
+        markdown_files = [
+            'about.md',
+            'research_details.md', 
+            'publications_detailed.md',
+            'skills_expertise.md',
+            'experience_detailed.md',
+            'statistics.md'
+        ]
+        
+        for filename in markdown_files:
             try:
                 if os.path.exists(filename):
                     with open(filename, 'r', encoding='utf-8') as f:
                         content = f.read()
-                    self.process_markdown_file(content, os.path.basename(filename))
-                    logger.info(f"✅ Loaded {filename}")
+                    self.process_markdown_file(content, filename)
+                    print(f"✅ Loaded {filename}")
                 else:
-                    logger.warning(f"⚠️ File not found: {filename}")
+                    print(f"⚠️ File not found: {filename}")
             except Exception as e:
-                logger.error(f"❌ Error loading {filename}: {e}")
+                print(f"❌ Error loading {filename}: {e}")
         
         # Generate embeddings for knowledge base
-        logger.info("Generating embeddings for knowledge base...")
+        print("Generating embeddings for knowledge base...")
         self.embeddings = []
         for i, doc in enumerate(self.knowledge_base):
             try:
                 # Truncate content to avoid token limit issues
-                content = doc["content"][:500]
+                content = doc["content"][:500]  # Limit to 500 characters
                 embedding = self.embedder(content, return_tensors="pt")
                 # Convert to numpy and flatten
                 embedding_np = embedding[0].mean(dim=0).detach().cpu().numpy()
                 self.embeddings.append(embedding_np)
             except Exception as e:
-                logger.error(f"Error generating embedding for doc {doc['id']}: {e}")
+                print(f"Error generating embedding for doc {doc['id']}: {e}")
                 # Fallback to zero embedding
-                self.embeddings.append(np.zeros(EMBEDDING_DIM))
+                self.embeddings.append(np.zeros(384))
         
         self.total_documents = len(self.knowledge_base)
-        logger.info(f"✅ Knowledge base loaded with {len(self.knowledge_base)} documents")
+        print(f"✅ Knowledge base loaded with {len(self.knowledge_base)} documents")
     
     def process_markdown_file(self, content: str, filename: str):
         """Process a markdown file and extract sections"""
-        file_type, priority = FILE_TYPE_MAP.get(filename, ('general', 5))
+        # Determine file type and priority
+        file_type_map = {
+            'about.md': ('about', 10),
+            'research_details.md': ('research', 9),
+            'publications_detailed.md': ('publications', 8),
+            'skills_expertise.md': ('skills', 7),
+            'experience_detailed.md': ('experience', 8),
+            'statistics.md': ('statistics', 9)
+        }
+        
+        file_type, priority = file_type_map.get(filename, ('general', 5))
         
         # Split content into sections
         sections = self.split_markdown_into_sections(content)
         
         for section in sections:
-            if len(section['content'].strip()) > 100:
+            if len(section['content'].strip()) > 100:  # Only process substantial content
                 doc = {
                     "id": f"{filename}_{section['title']}_{len(self.knowledge_base)}",
                     "content": section['content'],
@@ -124,10 +136,14 @@ class HybridSearchRAGBot:
         current_section = {'title': 'Introduction', 'content': ''}
         
         for line in lines:
+            # Check if line is a header
             if line.startswith('#'):
+                # Save previous section if it has content
                 if current_section['content'].strip():
                     sections.append(current_section.copy())
                 
+                # Start new section
+                header_level = len(line) - len(line.lstrip('#'))
                 title = line.lstrip('#').strip()
                 current_section = {
                     'title': title,
@@ -136,6 +152,7 @@ class HybridSearchRAGBot:
             else:
                 current_section['content'] += line + '\n'
         
+        # Add the last section
         if current_section['content'].strip():
             sections.append(current_section)
         
@@ -143,7 +160,9 @@ class HybridSearchRAGBot:
     
     def tokenize(self, text: str) -> List[str]:
         """Tokenize text for BM25"""
+        # Convert to lowercase and remove punctuation
         text = re.sub(r'[^\w\s]', ' ', text.lower())
+        # Split into words and filter out short words and stop words
         words = [word for word in text.split() if len(word) > 2 and not self.is_stop_word(word)]
         return words
     
@@ -159,44 +178,54 @@ class HybridSearchRAGBot:
     
     def build_bm25_index(self):
         """Build BM25 index for all documents"""
-        logger.info("Building BM25 index...")
+        print("Building BM25 index...")
         
+        # Reset indexes
         self.term_frequencies = {}
         self.document_frequency = defaultdict(int)
         self.document_lengths = {}
         
         total_length = 0
         
+        # First pass: calculate term frequencies and document lengths
         for doc in self.knowledge_base:
             doc_id = doc['id']
             terms = self.tokenize(doc['content'])
             
+            # Calculate term frequencies for this document
             term_freq = Counter(terms)
             self.term_frequencies[doc_id] = dict(term_freq)
             
+            # Store document length
             doc_length = len(terms)
             self.document_lengths[doc_id] = doc_length
             total_length += doc_length
             
+            # Update document frequencies
             unique_terms = set(terms)
             for term in unique_terms:
                 self.document_frequency[term] += 1
         
+        # Calculate average document length
         self.average_doc_length = total_length / self.total_documents if self.total_documents > 0 else 0
         
-        logger.info(f"✅ BM25 index built: {len(self.document_frequency)} unique terms, avg doc length: {self.average_doc_length:.1f}")
+        print(f"✅ BM25 index built: {len(self.document_frequency)} unique terms, avg doc length: {self.average_doc_length:.1f}")
     
     def calculate_bm25_score(self, term: str, doc_id: str) -> float:
         """Calculate BM25 score for a term in a document"""
+        # Get term frequency in document
         tf = self.term_frequencies.get(doc_id, {}).get(term, 0)
         if tf == 0:
             return 0.0
         
+        # Get document frequency and document length
         df = self.document_frequency.get(term, 1)
         doc_length = self.document_lengths.get(doc_id, 0)
         
+        # Calculate IDF: log((N - df + 0.5) / (df + 0.5))
         idf = math.log((self.total_documents - df + 0.5) / (df + 0.5))
         
+        # Calculate BM25 score
         numerator = tf * (self.k1 + 1)
         denominator = tf + self.k1 * (1 - self.b + self.b * (doc_length / self.average_doc_length))
         
@@ -210,6 +239,7 @@ class HybridSearchRAGBot:
         
         scores = {}
         
+        # Calculate BM25 score for each document
         for doc in self.knowledge_base:
             doc_id = doc['id']
             score = 0.0
@@ -218,6 +248,7 @@ class HybridSearchRAGBot:
                 score += self.calculate_bm25_score(term, doc_id)
             
             if score > 0:
+                # Apply priority boost
                 priority_boost = 1 + (doc['metadata']['priority'] / 50)
                 final_score = score * priority_boost
                 
@@ -227,6 +258,7 @@ class HybridSearchRAGBot:
                     'search_type': 'bm25'
                 }
         
+        # Sort by score and return top_k
         sorted_results = sorted(scores.values(), key=lambda x: x['score'], reverse=True)
         return sorted_results[:top_k]
     
@@ -237,14 +269,17 @@ class HybridSearchRAGBot:
     def vector_search(self, query: str, top_k: int = 10) -> List[Dict]:
         """Perform vector similarity search"""
         try:
-            query_embedding = self.embedder(query[:500], return_tensors="pt")
+            # Generate query embedding
+            query_embedding = self.embedder(query[:500], return_tensors="pt")  # Truncate query
             query_vector = query_embedding[0].mean(dim=0).detach().cpu().numpy()
             
+            # Calculate similarities
             similarities = []
             for i, doc_embedding in enumerate(self.embeddings):
                 if doc_embedding is not None and len(doc_embedding) > 0:
                     similarity = self.cosine_similarity(query_vector, doc_embedding)
                     
+                    # Apply priority boost
                     priority_boost = 1 + (self.knowledge_base[i]['metadata']['priority'] / 100)
                     final_score = similarity * priority_boost
                     
@@ -254,20 +289,22 @@ class HybridSearchRAGBot:
                         'search_type': 'vector'
                     })
             
+            # Sort by similarity and return top_k
             similarities.sort(key=lambda x: x['score'], reverse=True)
             return similarities[:top_k]
             
         except Exception as e:
-            logger.error(f"Error in vector search: {e}")
+            print(f"Error in vector search: {e}")
             return []
     
     def hybrid_search(self, query: str, top_k: int = 10, vector_weight: float = 0.6, bm25_weight: float = 0.4) -> List[Dict]:
         """Perform hybrid search combining vector and BM25 results"""
         try:
-            vector_results = self.vector_search(query, top_k * 2)
+            # Get results from both search methods
+            vector_results = self.vector_search(query, top_k * 2)  # Get more results for better fusion
             bm25_results = self.bm25_search(query, top_k * 2)
             
-            # Normalize scores
+            # Normalize scores to [0, 1] range
             if vector_results:
                 max_vector_score = max(r['score'] for r in vector_results)
                 if max_vector_score > 0:
@@ -289,6 +326,7 @@ class HybridSearchRAGBot:
             # Combine results
             combined_scores = {}
             
+            # Add vector results
             for result in vector_results:
                 doc_id = result['document']['id']
                 combined_scores[doc_id] = {
@@ -298,6 +336,7 @@ class HybridSearchRAGBot:
                     'search_type': 'vector'
                 }
             
+            # Add BM25 results
             for result in bm25_results:
                 doc_id = result['document']['id']
                 if doc_id in combined_scores:
@@ -323,11 +362,13 @@ class HybridSearchRAGBot:
                     'search_type': data['search_type']
                 })
             
+            # Sort by hybrid score and return top_k
             final_results.sort(key=lambda x: x['score'], reverse=True)
             return final_results[:top_k]
             
         except Exception as e:
-            logger.error(f"Error in hybrid search: {e}")
+            print(f"Error in hybrid search: {e}")
+            # Fallback to vector search only
             return self.vector_search(query, top_k)
     
     def search_knowledge_base(self, query: str, top_k: int = 5, search_type: str = "hybrid") -> List[Dict]:
@@ -336,15 +377,15 @@ class HybridSearchRAGBot:
             return self.vector_search(query, top_k)
         elif search_type == "bm25":
             return self.bm25_search(query, top_k)
-        else:
+        else:  # hybrid
             return self.hybrid_search(query, top_k)
 
 # Initialize the bot
-logger.info("Initializing Hybrid Search RAGtim Bot...")
+print("Initializing Hybrid Search RAGtim Bot...")
 bot = HybridSearchRAGBot()
 
-# API Functions
-def search_api(query, top_k=5, search_type="hybrid", vector_weight=0.6, bm25_weight=0.4):
+# API Functions for Gradio Client
+def search_api(query: str, top_k: int = 5, search_type: str = "hybrid", vector_weight: float = 0.6, bm25_weight: float = 0.4):
     """API endpoint for hybrid search functionality"""
     try:
         if search_type == "hybrid":
@@ -366,12 +407,13 @@ def search_api(query, top_k=5, search_type="hybrid", vector_weight=0.6, bm25_wei
             }
         }
     except Exception as e:
-        logger.error(f"Error in search API: {e}")
+        print(f"Error in search API: {e}")
         return {"error": str(e), "results": []}
 
 def get_stats_api():
     """API endpoint for knowledge base statistics"""
     try:
+        # Calculate document distribution by type
         doc_types = {}
         sections_by_file = {}
         
@@ -386,8 +428,8 @@ def get_stats_api():
             "total_documents": len(bot.knowledge_base),
             "document_types": doc_types,
             "sections_by_file": sections_by_file,
-            "model_name": EMBEDDING_MODEL,
-            "embedding_dimension": EMBEDDING_DIM,
+            "model_name": "sentence-transformers/all-MiniLM-L6-v2",
+            "embedding_dimension": 384,
             "search_capabilities": [
                 "Hybrid Search (Vector + BM25)",
                 "Semantic Vector Search", 
@@ -406,7 +448,7 @@ def get_stats_api():
             "status": "healthy"
         }
     except Exception as e:
-        logger.error(f"Error in get_stats_api: {e}")
+        print(f"Error in get_stats_api: {e}")
         return {
             "error": str(e),
             "status": "error",
@@ -420,29 +462,35 @@ def chat_interface(message, history):
         return "Please ask me something about Raktim Mondol! I use hybrid search combining semantic similarity and keyword matching for the best results."
     
     try:
+        # Use hybrid search by default
         search_results = bot.hybrid_search(message, top_k=6)
         
         if search_results:
+            # Build comprehensive response
             response_parts = []
             response_parts.append(f"🔍 **Hybrid Search Results** (Vector + BM25 combination, found {len(search_results)} relevant sections):\n")
             
+            # Use the best match as primary response
             best_match = search_results[0]
             response_parts.append(f"**Primary Answer** (Hybrid Score: {best_match['score']:.3f}):")
             response_parts.append(f"📄 Source: {best_match['document']['metadata']['source']} - {best_match['document']['metadata']['section']}")
             response_parts.append(f"🔍 Search Type: {best_match['search_type'].upper()}")
             
+            # Show score breakdown for hybrid results
             if 'vector_score' in best_match and 'bm25_score' in best_match:
                 response_parts.append(f"📊 Vector Score: {best_match['vector_score']:.3f} | BM25 Score: {best_match['bm25_score']:.3f}")
             
             response_parts.append(f"\n{best_match['document']['content']}\n")
             
+            # Add additional context if available
             if len(search_results) > 1:
                 response_parts.append("**Additional Context:**")
-                for i, result in enumerate(search_results[1:3], 1):
+                for i, result in enumerate(search_results[1:3], 1):  # Show up to 2 additional results
                     section_info = f"{result['document']['metadata']['source']} - {result['document']['metadata']['section']}"
                     search_info = f"({result['search_type'].upper()}, Score: {result['score']:.3f})"
                     response_parts.append(f"{i}. {section_info} {search_info}")
                     
+                    # Add a brief excerpt
                     excerpt = result['document']['content'][:200] + "..." if len(result['document']['content']) > 200 else result['document']['content']
                     response_parts.append(f"   {excerpt}\n")
             
@@ -457,203 +505,66 @@ def chat_interface(message, history):
             return "I don't have specific information about that topic in my knowledge base. Could you please ask something else about Raktim Mondol?"
         
     except Exception as e:
-        logger.error(f"Error in chat interface: {e}")
+        print(f"Error in chat interface: {e}")
         return "I'm sorry, I encountered an error while processing your question. Please try again."
 
-# Gradio Interface
-css = """
-.gradio-container {
-    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
-}
-.search-type-radio .wrap {
-    display: flex;
-    gap: 10px;
-}
-.search-weights {
-    background: #f0f0f0;
-    padding: 10px;
-    border-radius: 5px;
-    margin: 10px 0;
-}
-"""
+# Create Gradio interfaces with proper API names
+print("Creating Gradio interface...")
 
-# Create the main chat interface
-with gr.Blocks(
+# Main chat interface
+chat_demo = gr.Interface(
+    fn=chat_interface,
+    inputs=[
+        gr.Textbox(label="Ask about Raktim Mondol", placeholder="What would you like to know about Raktim's research, skills, or experience?"),
+        gr.State([])  # For conversation history
+    ],
+    outputs=gr.Textbox(label="Response"),
     title="🔥 Hybrid Search RAGtim Bot",
-    css=css,
-    theme=gr.themes.Soft(
-        primary_hue="green",
-        secondary_hue="blue",
-        neutral_hue="slate"
-    )
-) as chat_demo:
-    gr.Markdown(f"""
-    # 🔥 Hybrid Search RAGtim Bot - Advanced Search Technology
-    
-    **🚀 Hybrid Search System**: This Space implements **true hybrid search** combining:
-    - 🧠 **Semantic Vector Search**: Transformer embeddings for conceptual similarity
-    - 🔍 **BM25 Keyword Search**: Advanced TF-IDF ranking for exact term matching
-    - ⚖️ **Intelligent Fusion**: Weighted combination for optimal relevance
-    
-    **📚 Knowledge Base**: **{len(bot.knowledge_base)} sections** from comprehensive markdown files
-    
-    **🔧 Search Parameters**:
-    - **BM25 Parameters**: k1={bot.k1}, b={bot.b}
-    - **Vocabulary**: {len(bot.document_frequency)} unique terms
-    - **Average Document Length**: {bot.average_doc_length:.1f} words
-    - **Embedding Model**: {EMBEDDING_MODEL} ({EMBEDDING_DIM}-dim)
-    
-    **Ask me anything about Raktim Mondol's research, expertise, and background!**
-    """)
-    
-    chatbot = gr.Chatbot(
-        height=500,
-        show_label=False,
-        container=True,
-        type="messages"
-    )
-    
-    with gr.Row():
-        msg = gr.Textbox(
-            placeholder="Ask about Raktim's research, LLM expertise, publications, statistical methods...",
-            container=False,
-            scale=7,
-            show_label=False
-        )
-        submit_btn = gr.Button("🔍 Hybrid Search", scale=1)
-    
-    # Example buttons
-    with gr.Row():
-        examples = [
-            "What is Raktim's LLM and RAG research?",
-            "Tell me about BioFusionNet statistical methods",
-            "What are his multimodal AI capabilities?",
-            "Describe his biostatistics expertise"
-        ]
-        for example in examples:
-            gr.Button(example, size="sm").click(
-                lambda x=example: x, outputs=msg
-            )
-    
-    def respond(message, history):
-        if not message.strip():
-            return history, ""
-        
-        history.append({"role": "user", "content": message})
-        bot_response = chat_interface(message, history)
-        history.append({"role": "assistant", "content": bot_response})
-        
-        return history, ""
-    
-    submit_btn.click(respond, [msg, chatbot], [chatbot, msg])
-    msg.submit(respond, [msg, chatbot], [chatbot, msg])
+    description="Ask me anything about Raktim Mondol! I use advanced hybrid search combining semantic similarity and keyword matching.",
+    api_name="chat"
+)
 
-# Advanced search interface
-with gr.Blocks(title="🔧 Advanced Hybrid Search") as search_demo:
-    gr.Markdown("# 🔧 Advanced Hybrid Search Configuration")
-    
-    with gr.Row():
-        with gr.Column(scale=2):
-            search_input = gr.Textbox(
-                label="Search Query", 
-                placeholder="Enter your search query about Raktim Mondol..."
-            )
-            
-            with gr.Row():
-                search_type = gr.Radio(
-                    choices=["hybrid", "vector", "bm25"],
-                    value="hybrid",
-                    label="Search Method"
-                )
-                top_k_slider = gr.Slider(
-                    minimum=1, 
-                    maximum=15, 
-                    value=5, 
-                    step=1, 
-                    label="Top K Results"
-                )
-            
-            with gr.Group(visible=True) as weight_group:
-                gr.Markdown("**Hybrid Search Weights**")
-                vector_weight = gr.Slider(
-                    minimum=0.0,
-                    maximum=1.0,
-                    value=0.6,
-                    step=0.1,
-                    label="Vector Weight (Semantic)"
-                )
-                bm25_weight = gr.Slider(
-                    minimum=0.0,
-                    maximum=1.0,
-                    value=0.4,
-                    step=0.1,
-                    label="BM25 Weight (Keyword)"
-                )
-        
-        with gr.Column(scale=1):
-            gr.Markdown("**Search Method Guide:**")
-            gr.Markdown("""
-            **🔥 Hybrid**: Combines semantic + keyword
-            - Best for most queries
-            - Balances meaning and exact terms
-            
-            **🧠 Vector**: Pure semantic similarity
-            - Good for conceptual questions
-            - Finds related concepts
-            
-            **🔍 BM25**: Pure keyword matching
-            - Good for specific terms
-            - Traditional search ranking
-            """)
-    
-    search_output = gr.JSON(label="Hybrid Search Results", height=400)
-    search_btn = gr.Button("🔍 Search with Custom Parameters", variant="primary")
-    
-    def update_weights_visibility(search_type):
-        return gr.Group(visible=(search_type == "hybrid"))
-    
-    search_type.change(update_weights_visibility, inputs=[search_type], outputs=[weight_group])
-    
-    def normalize_weights(vector_w, bm25_w):
-        total = vector_w + bm25_w
-        if total > 0:
-            return vector_w / total, bm25_w / total
-        return 0.6, 0.4
-    
-    def advanced_search(query, search_type, top_k, vector_w, bm25_w):
-        vector_weight, bm25_weight = normalize_weights(vector_w, bm25_w)
-        return search_api(query, top_k, search_type, vector_weight, bm25_weight)
-    
-    search_btn.click(
-        advanced_search,
-        inputs=[search_input, search_type, top_k_slider, vector_weight, bm25_weight],
-        outputs=search_output
-    )
+# Search API interface
+search_demo = gr.Interface(
+    fn=search_api,
+    inputs=[
+        gr.Textbox(label="Search Query", placeholder="Enter your search query"),
+        gr.Number(label="Top K Results", value=5, minimum=1, maximum=20),
+        gr.Radio(choices=["hybrid", "vector", "bm25"], value="hybrid", label="Search Type"),
+        gr.Slider(minimum=0.0, maximum=1.0, value=0.6, label="Vector Weight"),
+        gr.Slider(minimum=0.0, maximum=1.0, value=0.4, label="BM25 Weight")
+    ],
+    outputs=gr.JSON(label="Search Results"),
+    title="🔍 Hybrid Search API",
+    description="Direct access to the hybrid search functionality",
+    api_name="search"
+)
 
-# Stats interface
-with gr.Blocks(title="📊 System Statistics") as stats_demo:
-    gr.Markdown("# 📊 Hybrid Search System Statistics")
-    
-    stats_output = gr.JSON(label="System Statistics", height=500)
-    stats_btn = gr.Button("📊 Get System Statistics", variant="primary")
-    
-    stats_btn.click(get_stats_api, inputs=[], outputs=stats_output)
+# Stats API interface
+stats_demo = gr.Interface(
+    fn=get_stats_api,
+    inputs=[],
+    outputs=gr.JSON(label="System Statistics"),
+    title="📊 System Statistics",
+    description="Knowledge base and system information",
+    api_name="stats"
+)
 
-# Main demo with tabs
+# Combine interfaces
 demo = gr.TabbedInterface(
     [chat_demo, search_demo, stats_demo],
-    ["💬 Hybrid Chat", "🔧 Advanced Search", "📊 Statistics"],
+    ["💬 Chat", "🔍 Search API", "📊 Stats API"],
     title="🔥 Hybrid Search RAGtim Bot - Vector + BM25 Fusion"
 )
 
-# Launch the application
 if __name__ == "__main__":
-    logger.info("🚀 Launching Hybrid Search RAGtim Bot...")
-    logger.info(f"📚 Loaded {len(bot.knowledge_base)} sections from markdown files")
-    logger.info(f"🔍 BM25 index: {len(bot.document_frequency)} unique terms")
-    logger.info(f"🧠 Vector embeddings: {len(bot.embeddings)} documents")
-    logger.info("🔥 Hybrid search ready: Semantic + Keyword fusion!")
+    print("🚀 Launching Hybrid Search RAGtim Bot...")
+    print(f"📚 Loaded {len(bot.knowledge_base)} sections from markdown files")
+    print(f"🔍 BM25 index: {len(bot.document_frequency)} unique terms")
+    print(f"🧠 Vector embeddings: {len(bot.embeddings)} documents")
+    print("🔥 Hybrid search ready: Semantic + Keyword fusion!")
     
+    # Launch the main demo with API access
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,