Update app.py

app.py

@@ -1,593 +1,844 @@
-# app.py - Enhanced UI with animations
+# app.py - Optimized for Hugging Face Spaces
 import os
+import tempfile
 import shutil
+import PyPDF2
 import streamlit as st
 import torch
-import atexit
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import FAISS
+from langchain.chains import RetrievalQA
+from langchain.docstore.document import Document
+from langchain.prompts import PromptTemplate
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_community.llms import HuggingFaceHub
 import time
-from advanced_rag import AdvancedRAG
-from metamask_component import metamask_connector
-from voice_component import voice_input_component
+import psutil
+import uuid
+import atexit
+import json
+import hashlib
+from web3 import Web3
 
-# Custom CSS for enhanced UI
-def load_custom_css():
+# Set page configuration
+st.set_page_config(
+    page_title="RAG System",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for better UI
+def load_css():
     st.markdown("""
     <style>
-    /* Main container styling */
+    /* Main layout styling */
     .main {
         background-color: #f9fafb;
     }
     
     /* Card styling */
-    .stCard {
-        border-radius: 12px !important;
-        box-shadow: 0 6px 16px rgba(0,0,0,0.05) !important;
-        transition: all 0.3s ease !important;
-    }
-    .stCard:hover {
-        transform: translateY(-2px);
-        box-shadow: 0 12px 24px rgba(0,0,0,0.08) !important;
+    .card {
+        border-radius: 10px;
+        background-color: white;
+        padding: 20px;
+        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.05);
+        margin-bottom: 20px;
     }
     
-    /* Chat message styling */
-    .chat-message {
-        padding: 16px;
-        border-radius: 12px;
-        margin-bottom: 10px;
-        animation: fadeIn 0.5s ease;
-    }
-    .user-message {
-        background-color: #f0f7ff;
-        border-left: 5px solid #3b82f6;
+    /* Two-column layout */
+    .answer-section {
+        background-color: white;
+        border-radius: 10px;
+        padding: 20px;
+        margin-bottom: 15px;
+        border-left: 4px solid #4CAF50;
+        box-shadow: 0 2px 5px rgba(0, 0, 0, 0.05);
     }
-    .assistant-message {
-        background-color: #f0fdf4;
-        border-left: 5px solid #22c55e;
+    
+    .sources-section {
+        background-color: white;
+        border-radius: 10px;
+        padding: 15px;
+        margin-bottom: 15px;
+        border-left: 4px solid #2196F3;
+        box-shadow: 0 2px 5px rgba(0, 0, 0, 0.05);
     }
     
-    /* Source section styling */
     .source-item {
-        padding: 12px;
-        border-radius: 8px;
-        background-color: #f8fafc;
-        border: 1px solid #e2e8f0;
+        padding: 10px;
+        border-radius: 5px;
+        background-color: #f8f9fa;
         margin-bottom: 10px;
-        transition: all 0.2s ease;
-    }
-    .source-item:hover {
-        border-color: #cbd5e1;
-        background-color: #f1f5f9;
+        border: 1px solid #eee;
     }
+    
     .source-header {
-        font-weight: 600;
+        font-weight: bold;
+        margin-bottom: 5px;
         display: flex;
         justify-content: space-between;
-        margin-bottom: 8px;
-        align-items: center;
-    }
-    .source-content {
-        font-size: 0.9em;
-        color: #475569;
-        max-height: 200px;
-        overflow-y: auto;
     }
+    
     .verified-badge {
-        background-color: #10b981;
+        background-color: #4CAF50;
         color: white;
         padding: 2px 8px;
-        border-radius: 12px;
-        font-size: 0.7em;
-        display: inline-flex;
-        align-items: center;
-        gap: 4px;
-    }
-    
-    /* Animated loader */
-    @keyframes pulse-animation {
-        0% { box-shadow: 0 0 0 0 rgba(59, 130, 246, 0.7); }
-        70% { box-shadow: 0 0 0 10px rgba(59, 130, 246, 0); }
-        100% { box-shadow: 0 0 0 0 rgba(59, 130, 246, 0); }
-    }
-    .pulse {
-        animation: pulse-animation 2s infinite;
+        border-radius: 10px;
+        font-size: 0.8em;
     }
     
-    /* Fade in animation */
-    @keyframes fadeIn {
-        from { opacity: 0; transform: translateY(10px); }
-        to { opacity: 1; transform: translateY(0); }
+    /* Method selection styling */
+    .method-container {
+        display: flex;
+        gap: 10px;
+        margin-bottom: 15px;
     }
     
-    /* Method selection buttons */
     .method-button {
-        border-radius: 8px;
-        padding: 8px 16px;
-        transition: all 0.3s ease;
-        border: none;
+        flex: 1;
+        text-align: center;
+        padding: 10px;
+        border-radius: 5px;
         cursor: pointer;
-        font-weight: 500;
-        display: inline-flex;
-        align-items: center;
-        gap: 8px;
+        transition: all 0.3s;
     }
-    .method-direct {
-        background-color: #e0f2fe;
-        color: #0284c7;
+    
+    .direct-method {
+        background-color: #e3f2fd;
+        border: 1px solid #bbdefb;
+        color: #1976D2;
     }
-    .method-direct:hover {
-        background-color: #bae6fd;
+    
+    .direct-method:hover {
+        background-color: #bbdefb;
     }
-    .method-enhanced {
-        background-color: #dbeafe;
-        color: #2563eb;
+    
+    .enhanced-method {
+        background-color: #e8f5e9;
+        border: 1px solid #c8e6c9;
+        color: #388E3C;
     }
-    .method-enhanced:hover {
-        background-color: #bfdbfe;
+    
+    .enhanced-method:hover {
+        background-color: #c8e6c9;
     }
+    
     .method-active {
-        box-shadow: 0 0 0 2px #3b82f6;
+        box-shadow: 0 0 0 2px #3f51b5;
     }
     
-    /* Two-column layout for answer and sources */
-    .answer-container {
-        border-radius: 12px;
-        background-color: white;
-        padding: 20px;
-        box-shadow: 0 4px 12px rgba(0,0,0,0.05);
-        margin-bottom: 20px;
-    }
-    .answer-header {
-        margin-bottom: 16px;
-        color: #1e293b;
-        font-weight: 600;
-        font-size: 1.1em;
-    }
-    .answer-content {
-        font-size: 1em;
-        line-height: 1.6;
-        color: #334155;
+    /* Voice button styling */
+    .voice-button {
+        width: 50px;
+        height: 50px;
+        border-radius: 50%;
+        background-color: #f44336;
+        color: white;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        cursor: pointer;
+        box-shadow: 0 2px 5px rgba(0, 0, 0, 0.2);
+        transition: all 0.3s;
+        margin: 0 auto;
     }
-    .sources-container {
-        border-radius: 12px;
-        background-color: white;
-        padding: 20px;
-        box-shadow: 0 4px 12px rgba(0,0,0,0.05);
+    
+    .voice-button:hover {
+        transform: scale(1.05);
+        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.3);
     }
-    .sources-header {
-        margin-bottom: 16px;
-        color: #1e293b;
-        font-weight: 600;
-        font-size: 1.1em;
+    
+    /* Header styling */
+    h1, h2, h3 {
+        color: #333;
     }
     
-    /* Section animations */
-    .animate-section {
-        animation: fadeIn 0.5s ease;
+    /* Button styling */
+    .stButton>button {
+        border-radius: 5px;
+        font-weight: 500;
     }
     </style>
     """, unsafe_allow_html=True)
 
+# Simple blockchain utility
+class BlockchainVerifier:
+    def __init__(self, contract_address=None):
+        self.contract_address = contract_address
+        self.is_connected = False
+        self.user_address = None
+        
+    def connect_wallet(self, wallet_address):
+        """Simulate connecting to a wallet"""
+        self.is_connected = True
+        self.user_address = wallet_address
+        return True
+        
+    def compute_file_hash(self, file_path):
+        """Compute SHA-256 hash of file"""
+        sha256_hash = hashlib.sha256()
+        with open(file_path, "rb") as f:
+            for byte_block in iter(lambda: f.read(4096), b""):
+                sha256_hash.update(byte_block)
+        return sha256_hash.hexdigest()
+    
+    def verify_document(self, document_id, file_path):
+        """Simulate document verification on blockchain"""
+        if not self.is_connected:
+            return {"status": False, "error": "Wallet not connected"}
+            
+        # Calculate hash
+        document_hash = self.compute_file_hash(file_path)
+        
+        # Simulate transaction
+        tx_hash = "0x" + "".join([format(i, "02x") for i in os.urandom(32)])
+        
+        return {
+            "status": True,
+            "tx_hash": tx_hash,
+            "document_id": document_id,
+            "document_hash": document_hash,
+            "block_number": 12345678
+        }
+    
+    def log_query(self, query_text, answer_text):
+        """Simulate logging a query on blockchain"""
+        if not self.is_connected:
+            return {"status": False, "error": "Wallet not connected"}
+            
+        # Create query data and hash
+        query_id = f"query_{int(time.time())}"
+        query_data = {
+            "query": query_text,
+            "answer": answer_text,
+            "timestamp": int(time.time())
+        }
+        query_hash = hashlib.sha256(json.dumps(query_data).encode()).hexdigest()
+        
+        # Simulate transaction
+        tx_hash = "0x" + "".join([format(i, "02x") for i in os.urandom(32)])
+        
+        return {
+            "status": True,
+            "tx_hash": tx_hash,
+            "query_id": query_id,
+            "query_hash": query_hash,
+            "block_number": 12345678
+        }
+
+# RAG System Class
+class OptimizedRAG:
+    def __init__(self, 
+                 llm_model_name="google/flan-t5-base",
+                 embedding_model_name="sentence-transformers/all-MiniLM-L6-v2",
+                 chunk_size=1000,
+                 chunk_overlap=200,
+                 use_gpu=True,
+                 use_blockchain=False,
+                 contract_address=None):
+        """
+        Initialize the RAG system optimized for Hugging Face Spaces
+        """
+        self.llm_model_name = llm_model_name
+        self.embedding_model_name = embedding_model_name
+        self.use_gpu = use_gpu and torch.cuda.is_available()
+        self.use_blockchain = use_blockchain
+        
+        # Device selection for embeddings
+        self.device = "cuda" if self.use_gpu else "cpu"
+        
+        # Initialize text splitter
+        self.text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=chunk_size,
+            chunk_overlap=chunk_overlap,
+            length_function=len,
+        )
+        
+        # Initialize embeddings model
+        self.embeddings = HuggingFaceEmbeddings(
+            model_name=embedding_model_name,
+            model_kwargs={"device": self.device}
+        )
+        
+        # Initialize LLM using HuggingFaceHub
+        try:
+            # Use HF_TOKEN from environment variables
+            hf_token = os.environ.get("HF_TOKEN")
+            if not hf_token:
+                st.warning("No HuggingFace token found. Using model without authentication.")
+                
+            self.llm = HuggingFaceHub(
+                repo_id=llm_model_name,
+                huggingfacehub_api_token=hf_token,
+                model_kwargs={"temperature": 0.7, "max_length": 512}
+            )
+        except Exception as e:
+            st.error(f"Error initializing LLM: {str(e)}")
+            st.info("Trying to initialize with default model...")
+            # Fallback to a smaller model
+            self.llm = HuggingFaceHub(
+                repo_id="google/flan-t5-small",
+                model_kwargs={"temperature": 0.7, "max_length": 256}
+            )
+        
+        # Initialize vector store and stats
+        self.vector_store = None
+        self.documents_processed = 0
+        self.processing_times = {}
+        
+        # Initialize blockchain verifier
+        self.blockchain = None
+        if use_blockchain:
+            self.blockchain = BlockchainVerifier(contract_address=contract_address)
+
+    def connect_wallet(self, wallet_address):
+        """Connect wallet for blockchain verification"""
+        if self.blockchain:
+            return self.blockchain.connect_wallet(wallet_address)
+        return False
+
+    def process_pdfs(self, pdf_files):
+        """Process PDF files and create vector store"""
+        all_docs = []
+        
+        with st.status("Processing PDF files...") as status:
+            # Create temporary directory
+            temp_dir = tempfile.mkdtemp()
+            st.session_state['temp_dir'] = temp_dir
+            
+            # Track processing stats
+            start_time = time.time()
+            mem_before = psutil.virtual_memory().used / (1024 * 1024 * 1024)  # GB
+            
+            # Process each PDF
+            for i, pdf_file in enumerate(pdf_files):
+                try:
+                    # Save uploaded file
+                    pdf_path = os.path.join(temp_dir, pdf_file.name)
+                    with open(pdf_path, "wb") as f:
+                        f.write(pdf_file.getbuffer())
+                    
+                    status.update(label=f"Processing {pdf_file.name} ({i+1}/{len(pdf_files)})...")
+                    
+                    # Extract text from PDF
+                    text = ""
+                    with open(pdf_path, "rb") as f:
+                        pdf = PyPDF2.PdfReader(f)
+                        for page_num in range(len(pdf.pages)):
+                            page = pdf.pages[page_num]
+                            page_text = page.extract_text()
+                            if page_text:
+                                text += page_text + "\n\n"
+                    
+                    # Create and split documents
+                    docs = [Document(page_content=text, metadata={"source": pdf_file.name})]
+                    split_docs = self.text_splitter.split_documents(docs)
+                    all_docs.extend(split_docs)
+                    
+                    # Verify on blockchain if enabled
+                    if self.use_blockchain and self.blockchain and self.blockchain.is_connected:
+                        document_id = f"{pdf_file.name}_{uuid.uuid4().hex[:8]}"
+                        verification = self.blockchain.verify_document(document_id, pdf_path)
+                        
+                        if verification.get('status'):
+                            st.sidebar.success(f"✅ {pdf_file.name} verified on blockchain")
+                            
+                            # Add blockchain metadata
+                            for doc in split_docs:
+                                doc.metadata["blockchain"] = {
+                                    "verified": True,
+                                    "document_id": document_id,
+                                    "document_hash": verification.get("document_hash", ""),
+                                    "tx_hash": verification.get("tx_hash", ""),
+                                    "block_number": verification.get("block_number", 0)
+                                }
+                                
+                except Exception as e:
+                    st.sidebar.error(f"Error processing {pdf_file.name}: {str(e)}")
+            
+            # Create vector store
+            if all_docs:
+                status.update(label="Building vector index...")
+                try:
+                    index_start_time = time.time()
+                    self.vector_store = FAISS.from_documents(all_docs, self.embeddings)
+                    index_time = time.time() - index_start_time
+                    
+                    # Track memory usage
+                    mem_after = psutil.virtual_memory().used / (1024 * 1024 * 1024)
+                    mem_used = mem_after - mem_before
+                    
+                    # Save performance metrics
+                    total_time = time.time() - start_time
+                    self.processing_times["index_building"] = index_time
+                    self.processing_times["total_time"] = total_time
+                    self.processing_times["memory_used_gb"] = mem_used
+                    self.documents_processed = len(all_docs)
+                    
+                    status.update(label=f"Completed processing {len(all_docs)} chunks", state="complete")
+                    return True
+                except Exception as e:
+                    st.error(f"Error creating vector store: {str(e)}")
+                    return False
+            else:
+                status.update(label="No content extracted from PDFs", state="error")
+                return False
+
+    def direct_retrieval(self, query):
+        """Direct retrieval method - returns raw document chunks"""
+        if not self.vector_store:
+            return "Please upload and process PDF files first."
+            
+        try:
+            # Start timing
+            query_start_time = time.time()
+            
+            # Retrieve relevant documents
+            retriever = self.vector_store.as_retriever(search_kwargs={"k": 5})
+            docs = retriever.get_relevant_documents(query)
+            
+            # Format sources and answer
+            sources = []
+            answer = "Here are the most relevant passages:\n\n"
+            
+            for i, doc in enumerate(docs):
+                # Get blockchain info if available
+                blockchain_info = None
+                if "blockchain" in doc.metadata:
+                    blockchain_info = {
+                        "verified": doc.metadata["blockchain"]["verified"],
+                        "document_id": doc.metadata["blockchain"]["document_id"],
+                        "tx_hash": doc.metadata["blockchain"]["tx_hash"]
+                    }
+                
+                # Add to answer and sources
+                answer += f"Passage {i+1} (from {doc.metadata.get('source', 'Unknown')}):\n{doc.page_content}\n\n"
+                sources.append({
+                    "content": doc.page_content,
+                    "source": doc.metadata.get("source", "Unknown"),
+                    "blockchain": blockchain_info
+                })
+            
+            # Calculate query time
+            query_time = time.time() - query_start_time
+            
+            # Log query to blockchain if enabled
+            blockchain_log = None
+            if self.use_blockchain and self.blockchain and self.blockchain.is_connected:
+                log_result = self.blockchain.log_query(query, answer)
+                if log_result.get("status"):
+                    blockchain_log = {
+                        "logged": True,
+                        "query_id": log_result.get("query_id", ""),
+                        "tx_hash": log_result.get("tx_hash", "")
+                    }
+            
+            return {
+                "answer": answer,
+                "sources": sources,
+                "query_time": query_time,
+                "blockchain_log": blockchain_log,
+                "method": "direct"
+            }
+                
+        except Exception as e:
+            st.error(f"Error in direct retrieval: {str(e)}")
+            return f"Error: {str(e)}"
+
+    def enhanced_retrieval(self, query):
+        """Enhanced retrieval - processes through LLM for better answers"""
+        if not self.vector_store:
+            return "Please upload and process PDF files first."
+            
+        try:
+            # Create prompt template
+            prompt_template = """
+            Answer the question based on the context below.
+            
+            Context:
+            {context}
+            
+            Question: {question}
+            
+            Answer:
+            """
+            PROMPT = PromptTemplate(
+                template=prompt_template, 
+                input_variables=["context", "question"]
+            )
+            
+            # Start timing
+            query_start_time = time.time()
+            
+            # Create QA chain
+            qa = RetrievalQA.from_chain_type(
+                llm=self.llm,
+                chain_type="stuff",
+                retriever=self.vector_store.as_retriever(search_kwargs={"k": 4}),
+                chain_type_kwargs={"prompt": PROMPT},
+                return_source_documents=True
+            )
+            
+            # Get answer
+            response = qa({"query": query})
+            answer = response["result"]
+            source_docs = response["source_documents"]
+            
+            # Calculate query time
+            query_time = time.time() - query_start_time
+            
+            # Format sources
+            sources = []
+            for i, doc in enumerate(source_docs):
+                # Get blockchain info if available
+                blockchain_info = None
+                if "blockchain" in doc.metadata:
+                    blockchain_info = {
+                        "verified": doc.metadata["blockchain"]["verified"],
+                        "document_id": doc.metadata["blockchain"]["document_id"],
+                        "tx_hash": doc.metadata["blockchain"]["tx_hash"]
+                    }
+                
+                sources.append({
+                    "content": doc.page_content,
+                    "source": doc.metadata.get("source", "Unknown"),
+                    "blockchain": blockchain_info
+                })
+            
+            # Log query to blockchain if enabled
+            blockchain_log = None
+            if self.use_blockchain and self.blockchain and self.blockchain.is_connected:
+                log_result = self.blockchain.log_query(query, answer)
+                if log_result.get("status"):
+                    blockchain_log = {
+                        "logged": True,
+                        "query_id": log_result.get("query_id", ""),
+                        "tx_hash": log_result.get("tx_hash", "")
+                    }
+            
+            return {
+                "answer": answer,
+                "sources": sources,
+                "query_time": query_time,
+                "blockchain_log": blockchain_log,
+                "method": "enhanced"
+            }
+                
+        except Exception as e:
+            st.error(f"Error in enhanced retrieval: {str(e)}")
+            return f"Error: {str(e)}"
+
+    def ask(self, query, method="enhanced"):
+        """Ask a question using the specified method"""
+        if method == "direct":
+            return self.direct_retrieval(query)
+        else:
+            return self.enhanced_retrieval(query)
+
 # Helper function to initialize session state
 def initialize_session_state():
-    """Initialize Streamlit session state variables."""
+    """Initialize Streamlit session state variables"""
     if "rag" not in st.session_state:
         st.session_state.rag = None
     if "messages" not in st.session_state:
         st.session_state.messages = []
     if "temp_dir" not in st.session_state:
         st.session_state.temp_dir = None
-    if "metamask_connected" not in st.session_state:
-        st.session_state.metamask_connected = False
+    if "wallet_connected" not in st.session_state:
+        st.session_state.wallet_connected = False
+    if "wallet_address" not in st.session_state:
+        st.session_state.wallet_address = None
     if "retrieval_method" not in st.session_state:
         st.session_state.retrieval_method = "enhanced"
-    if "voice_transcript" not in st.session_state:
-        st.session_state.voice_transcript = ""
     if "current_answer" not in st.session_state:
         st.session_state.current_answer = None
 
 # Helper function to clean up temporary files
 def cleanup_temp_files():
-    """Clean up temporary files when application exits."""
+    """Clean up temporary files when application exits"""
     if st.session_state.get('temp_dir') and os.path.exists(st.session_state.temp_dir):
         try:
             shutil.rmtree(st.session_state.temp_dir)
-            print(f"Cleaned up temporary directory: {st.session_state.temp_dir}")
         except Exception as e:
             print(f"Error cleaning up temporary directory: {e}")
 
-# Create an animated loading spinner
-def animated_loader(text="Processing..."):
-    with st.spinner(text):
-        # Add a pulsing animation while processing
-        st.markdown("""
-        <div style="display: flex; justify-content: center; margin: 20px 0;">
-            <div class="pulse" style="width: 20px; height: 20px; border-radius: 50%; background-color: #3b82f6;"></div>
-        </div>
-        """, unsafe_allow_html=True)
-        
-# Animated section container
-def animated_section(key):
-    return st.container(key=f"animated_{key}")
-
-# Create a method selection button with animation
-def method_button(label, icon, method, current_method):
-    active_class = "method-active" if method == current_method else ""
-    method_class = "method-direct" if method == "direct" else "method-enhanced"
+# Create a simple wallet connector UI
+def wallet_connector():
+    st.sidebar.subheader("🔗 Blockchain Connection")
     
-    button_html = f"""
-    <button class="method-button {method_class} {active_class}">
-        {icon} {label}
-    </button>
-    """
-    return button_html
+    if st.session_state.wallet_connected:
+        st.sidebar.success(f"✅ Connected: {st.session_state.wallet_address[:10]}...")
+        if st.sidebar.button("Disconnect Wallet"):
+            st.session_state.wallet_connected = False
+            st.session_state.wallet_address = None
+            st.rerun()
+    else:
+        st.sidebar.info("Connect wallet to verify documents on blockchain")
+        if st.sidebar.button("Connect Wallet"):
+            # Generate a mock wallet address
+            wallet_address = "0x" + "".join([format(i, "02x") for i in os.urandom(20)])
+            st.session_state.wallet_address = wallet_address
+            st.session_state.wallet_connected = True
+            
+            # Connect to RAG system if initialized
+            if st.session_state.rag:
+                st.session_state.rag.connect_wallet(wallet_address)
+            
+            st.rerun()
 
-# Streamlit UI
+# Main application UI
 def main():
-    st.set_page_config(
-        page_title="Advanced RAG System",
-        layout="wide",
-        initial_sidebar_state="expanded"
-    )
-    
-    # Load custom CSS
-    load_custom_css()
-    
-    # Page header with animation
-    with animated_section("header"):
-        st.title("🚀 Advanced RAG System")
-        st.markdown("""
-        <div style="display: flex; gap: 15px; margin-bottom: 20px;">
-            <div style="background-color: #e0f2fe; color: #0284c7; padding: 8px 16px; border-radius: 20px; font-size: 0.9em; display: flex; align-items: center; gap: 8px;">
-                <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polygon points="12 2 15.09 8.26 22 9.27 17 14.14 18.18 21.02 12 17.77 5.82 21.02 7 14.14 2 9.27 8.91 8.26 12 2"></polygon></svg>
-                Document Analysis
-            </div>
-            <div style="background-color: #f0fdf4; color: #16a34a; padding: 8px 16px; border-radius: 20px; font-size: 0.9em; display: flex; align-items: center; gap: 8px;">
-                <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="11" width="18" height="11" rx="2" ry="2"></rect><path d="M7 11V7a5 5 0 0 1 10 0v4"></path></svg>
-                Blockchain Verification
-            </div>
-            <div style="background-color: #fef2f2; color: #dc2626; padding: 8px 16px; border-radius: 20px; font-size: 0.9em; display: flex; align-items: center; gap: 8px;">
-                <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M12 2a3 3 0 0 0-3 3v7a3 3 0 0 0 6 0V5a3 3 0 0 0-3-3Z"></path><path d="M19 10v2a7 7 0 0 1-14 0v-2"></path><line x1="12" y1="19" x2="12" y2="22"></line></svg>
-                Voice Input
-            </div>
-        </div>
-        """, unsafe_allow_html=True)
+    # Load CSS
+    load_css()
     
     # Initialize session state
     initialize_session_state()
     
-    # Sidebar for configuration and file upload
+    # Page header
+    st.title("📚 Advanced RAG System")
+    st.markdown("""
+    <div style="display: flex; gap: 10px; margin-bottom: 20px;">
+        <div style="background-color: #e3f2fd; padding: 5px 10px; border-radius: 15px; font-size: 0.9em;">
+            📄 Document Analysis
+        </div>
+        <div style="background-color: #e8f5e9; padding: 5px 10px; border-radius: 15px; font-size: 0.9em;">
+            🔗 Blockchain Verification
+        </div>
+        <div style="background-color: #fff3e0; padding: 5px 10px; border-radius: 15px; font-size: 0.9em;">
+            🎤 Voice Input
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Sidebar for configuration
     with st.sidebar:
-        with animated_section("sidebar_header"):
-            st.header("System Configuration")
-            st.markdown("""
-            <div style="margin-bottom: 15px; padding: 10px; border-radius: 8px; background-color: #f1f5f9; border-left: 4px solid #3b82f6;">
-                Configure your RAG system and upload documents
-            </div>
-            """, unsafe_allow_html=True)
+        # Wallet connector
+        wallet_connector()
         
-        # MetaMask Connection
-        with animated_section("metamask"):
-            st.subheader("🦊 MetaMask Connection")
-            
-            # Add MetaMask connector and get connection info
-            metamask_info = metamask_connector()
-            
-            # Display MetaMask connection status
-            if metamask_info and metamask_info.get("connected"):
-                st.success(f"✅ Connected: {metamask_info.get('address')[:10]}...{metamask_info.get('address')[-6:]}")
-                st.info(f"Network: {metamask_info.get('network_name')}")
-                st.session_state.metamask_connected = True
-            else:
-                st.warning("⚠️ MetaMask not connected")
-                st.session_state.metamask_connected = False
-            
-            # Update RAG system with MetaMask connection if needed
-            if st.session_state.rag and metamask_info:
-                is_connected = st.session_state.rag.update_blockchain_connection(metamask_info)
-                if is_connected:
-                    st.success("RAG system updated with MetaMask connection")
+        # System configuration
+        st.sidebar.subheader("⚙️ System Configuration")
         
-        # System Configuration
-        with animated_section("config"):
-            st.subheader("⚙️ System Configuration")
-            
-            # GPU Detection
-            gpu_available = torch.cuda.is_available()
-            if gpu_available:
-                try:
-                    gpu_info = torch.cuda.get_device_properties(0)
-                    st.markdown(f"""
-                    <div style="display: flex; align-items: center; gap: 8px; padding: 8px 12px; background-color: #ecfdf5; border-radius: 8px; margin-bottom: 15px;">
-                        <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="#10b981" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M17 18a5 5 0 0 1-10 0"></path><line x1="12" y1="2" x2="12" y2="9"></line><line x1="4.22" y1="10.22" x2="5.64" y2="11.64"></line><line x1="1" y1="18" x2="3" y2="18"></line><line x1="21" y1="18" x2="23" y2="18"></line><line x1="18.36" y1="11.64" x2="19.78" y2="10.22"></line><line x1="23" y1="22" x2="1" y2="22"></line><polyline points="8 6 12 2 16 6"></polyline></svg>
-                        <span style="color: #10b981; font-weight: 500;">GPU: {gpu_info.name} ({gpu_info.total_memory / 1024**3:.1f} GB)</span>
-                    </div>
-                    """, unsafe_allow_html=True)
-                except Exception as e:
-                    st.warning(f"GPU detected but couldn't get properties")
-            else:
-                st.warning("No GPU detected. Running in CPU mode.")
-            
-            # Model selection
-            llm_model = st.selectbox(
-                "LLM Model",
-                options=[
-                    "mistralai/Mistral-7B-Instruct-v0.2",
-                    "google/gemma-7b-it",
-                    "google/flan-t5-xl",
-                    "Salesforce/xgen-7b-8k-inst",
-                    "tiiuae/falcon-7b-instruct"
-                ],
-                index=0
-            )
-            
-            embedding_model = st.selectbox(
-                "Embedding Model",
-                options=[
-                    "sentence-transformers/all-mpnet-base-v2",
-                    "sentence-transformers/all-MiniLM-L6-v2",
-                    "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
-                ],
-                index=1
-            )
-            
-            use_gpu = st.checkbox("Use GPU Acceleration", value=gpu_available)
-            
-            # Blockchain configuration
-            use_blockchain = st.checkbox("Enable Blockchain Verification", value=True)
-            
-            if use_blockchain:
-                # Hardcoded contract address - replace with your deployed contract
-                contract_address = os.environ.get("CONTRACT_ADDRESS", "0x123abc...")  # Your pre-deployed contract
-                
-                st.info(f"Using contract: {contract_address[:10]}...")
-            
-            # Advanced options
-            with st.expander("Advanced Options"):
-                chunk_size = st.slider("Chunk Size", 100, 2000, 1000)
-                chunk_overlap = st.slider("Chunk Overlap", 0, 500, 200)
-            
-            # Initialize button with animation
-            if st.button("Initialize System", key="init_button"):
-                with st.spinner("Initializing..."):
-                    animated_loader("Setting up RAG system...")
-                    
-                    if use_blockchain and not contract_address:
-                        st.error("Contract address is required for blockchain integration")
-                    else:
-                        st.session_state.rag = AdvancedRAG(
-                            llm_model_name=llm_model,
-                            embedding_model_name=embedding_model,
-                            chunk_size=chunk_size,
-                            chunk_overlap=chunk_overlap,
-                            use_gpu=use_gpu and gpu_available,
-                            use_blockchain=use_blockchain,
-                            contract_address=contract_address if use_blockchain else None
-                        )
-                        
-                        # Update with current MetaMask connection if available
-                        if use_blockchain and metamask_info:
-                            st.session_state.rag.update_blockchain_connection(metamask_info)
-                        
-                        st.success(f"System initialized with {embedding_model}")
+        # GPU Detection
+        gpu_available = torch.cuda.is_available()
+        if gpu_available:
+            st.sidebar.success(f"GPU detected and available")
+        else:
+            st.sidebar.warning("No GPU detected. Running in CPU mode.")
         
-        # Document Upload
-        with animated_section("upload"):
-            st.subheader("📄 Document Upload")
-            uploaded_files = st.file_uploader("Select PDFs", type="pdf", accept_multiple_files=True)
-            
-            if uploaded_files and st.button("Process PDFs", key="process_button"):
-                if not st.session_state.rag:
-                    with st.spinner("Initializing system first..."):
-                        animated_loader("Setting up RAG system...")
-                        
-                        st.session_state.rag = AdvancedRAG(
-                            llm_model_name=llm_model,
-                            embedding_model_name=embedding_model,
-                            chunk_size=chunk_size,
-                            chunk_overlap=chunk_overlap,
-                            use_gpu=use_gpu and gpu_available,
-                            use_blockchain=use_blockchain,
-                            contract_address=contract_address if use_blockchain else None
-                        )
-                        
-                        # Update with current MetaMask connection if available
-                        if use_blockchain and metamask_info:
-                            st.session_state.rag.update_blockchain_connection(metamask_info)
+        # Model selection with faster models
+        llm_model = st.sidebar.selectbox(
+            "LLM Model",
+            options=[
+                "google/flan-t5-base",
+                "google/flan-t5-small",
+                "distilbert/distilgpt2",
+                "google/flan-ul2"
+            ],
+            index=0
+        )
+        
+        embedding_model = st.sidebar.selectbox(
+            "Embedding Model",
+            options=[
+                "sentence-transformers/all-MiniLM-L6-v2",
+                "sentence-transformers/paraphrase-MiniLM-L3-v2",
+                "sentence-transformers/all-mpnet-base-v2"
+            ],
+            index=0
+        )
+        
+        use_gpu = st.sidebar.checkbox("Use GPU Acceleration", value=gpu_available)
+        use_blockchain = st.sidebar.checkbox("Enable Blockchain", value=True)
+        
+        # Contract address - hardcoded for simplicity
+        contract_address = "0x123abc..." # Your pre-deployed contract
+        
+        # Initialize button
+        if st.sidebar.button("Initialize System"):
+            with st.spinner("Setting up RAG system..."):
+                st.session_state.rag = OptimizedRAG(
+                    llm_model_name=llm_model,
+                    embedding_model_name=embedding_model,
+                    chunk_size=1000,
+                    chunk_overlap=200,
+                    use_gpu=use_gpu and gpu_available,
+                    use_blockchain=use_blockchain,
+                    contract_address=contract_address if use_blockchain else None
+                )
+                
+                # Connect wallet if already connected
+                if st.session_state.wallet_connected:
+                    st.session_state.rag.connect_wallet(st.session_state.wallet_address)
                 
-                with st.spinner("Processing documents..."):
-                    animated_loader("Analyzing and indexing PDFs...")
+                st.sidebar.success(f"✅ System initialized!")
+        
+        # Document upload
+        st.sidebar.subheader("📄 Document Upload")
+        uploaded_files = st.sidebar.file_uploader("Select PDFs", type="pdf", accept_multiple_files=True)
+        
+        if uploaded_files and st.sidebar.button("Process Documents"):
+            if not st.session_state.rag:
+                with st.spinner("Initializing system first..."):
+                    st.session_state.rag = OptimizedRAG(
+                        llm_model_name=llm_model,
+                        embedding_model_name=embedding_model,
+                        chunk_size=1000,
+                        chunk_overlap=200,
+                        use_gpu=use_gpu and gpu_available,
+                        use_blockchain=use_blockchain,
+                        contract_address=contract_address if use_blockchain else None
+                    )
                     
-                    success = st.session_state.rag.process_pdfs(uploaded_files)
-                    if success:
-                        metrics = st.session_state.rag.get_performance_metrics()
-                        if metrics:
-                            st.success("📄 PDFs processed successfully!")
-                            with st.expander("💹 Performance Metrics"):
-                                st.markdown(f"**Documents processed:** {metrics['documents_processed']} chunks")
-                                st.markdown(f"**Index building time:** {metrics['index_building_time']:.2f} seconds")
-                                st.markdown(f"**Total processing time:** {metrics['total_processing_time']:.2f} seconds")
+                    # Connect wallet if already connected
+                    if st.session_state.wallet_connected:
+                        st.session_state.rag.connect_wallet(st.session_state.wallet_address)
+            
+            success = st.session_state.rag.process_pdfs(uploaded_files)
+            if success:
+                st.sidebar.success("📄 Documents processed successfully!")
     
-    # Main content area - Two column layout
-    main_col1, main_col2 = st.columns([2, 1])
+    # Method Selection
+    st.markdown("### Retrieval Method")
+    col1, col2 = st.columns(2)
     
-    # Left column - Chat and Answer section
-    with main_col1:
-        # Method Selection
-        with animated_section("method_selection"):
-            st.markdown("### Answer Method")
-            col1, col2 = st.columns(2)
-            
-            with col1:
-                direct_html = method_button(
-                    "Direct Retrieval", 
-                    '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="11" cy="11" r="8"></circle><line x1="21" y1="21" x2="16.65" y2="16.65"></line></svg>',
-                    "direct",
-                    st.session_state.retrieval_method
-                )
-                if st.markdown(direct_html, unsafe_allow_html=True):
-                    st.session_state.retrieval_method = "direct"
-                    st.rerun()
-            
-            with col2:
-                enhanced_html = method_button(
-                    "Enhanced Answers", 
-                    '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polygon points="13 2 3 14 12 14 11 22 21 10 12 10 13 2"></polygon></svg>',
-                    "enhanced",
-                    st.session_state.retrieval_method
-                )
-                if st.markdown(enhanced_html, unsafe_allow_html=True):
-                    st.session_state.retrieval_method = "enhanced"
-                    st.rerun()
+    with col1:
+        direct_class = "method-button direct-method"
+        if st.session_state.retrieval_method == "direct":
+            direct_class += " method-active"
+        
+        if st.markdown(f"""
+        <div class="{direct_class}" onclick="this.classList.add('method-active')">
+            🔍 Direct Retrieval
+        </div>
+        """, unsafe_allow_html=True):
+            st.session_state.retrieval_method = "direct"
+            st.rerun()
+    
+    with col2:
+        enhanced_class = "method-button enhanced-method"
+        if st.session_state.retrieval_method == "enhanced":
+            enhanced_class += " method-active"
             
-            # Show current method description
-            if st.session_state.retrieval_method == "direct":
-                st.info("🔍 **Direct Retrieval**: Shows raw document passages without processing. Fast and transparent.")
-            else:
-                st.info("💡 **Enhanced Answers**: Processes content through AI for comprehensive answers. Better quality.")
+        if st.markdown(f"""
+        <div class="{enhanced_class}" onclick="this.classList.add('method-active')">
+            💡 Enhanced Answers
+        </div>
+        """, unsafe_allow_html=True):
+            st.session_state.retrieval_method = "enhanced"
+            st.rerun()
+    
+    # Method description
+    if st.session_state.retrieval_method == "direct":
+        st.info("🔍 **Direct Retrieval**: Shows raw document passages. Fast and transparent.")
+    else:
+        st.info("💡 **Enhanced Answers**: Processes content through AI for better quality answers.")
+    
+    # Main Two-Column Layout
+    answer_col, sources_col = st.columns([2, 1])
+    
+    # Answer column
+    with answer_col:
+        st.markdown("### Ask a Question")
         
-        # Voice Input Section
-        with animated_section("voice_input"):
-            st.markdown("### Ask with Voice")
-            voice_transcript = voice_input_component()
-            
-            # Update session state with voice transcript if not empty
-            if voice_transcript and voice_transcript.strip():
-                st.session_state.voice_transcript = voice_transcript.strip()
-                st.experimental_rerun()
+        # Text input
+        user_input = st.text_input("Enter your question about the documents")
         
-        # Text Input Section
-        with animated_section("text_input"):
-            st.markdown("### Or Type a Question")
-            # Chat input - show the voice transcript in the text input
-            user_input = st.text_input(
-                "Ask a question about your documents",
-                value=st.session_state.voice_transcript,
-                key="text_question"
-            )
+        # Simple voice input simulation
+        voice_toggle = st.checkbox("Enable voice input")
+        if voice_toggle:
+            st.markdown("""
+            <div style="display: flex; flex-direction: column; align-items: center; margin: 15px 0;">
+                <div class="voice-button">🎤</div>
+                <div style="margin-top: 10px; color: #666;">Click to speak</div>
+            </div>
+            """, unsafe_allow_html=True)
             
-            # Process user input (from text or voice)
-            if user_input or st.session_state.voice_transcript:
-                # Prioritize text input over voice input
-                if user_input:
-                    query = user_input
-                else:
-                    query = st.session_state.voice_transcript
-                    # Clear voice transcript after using it
-                    st.session_state.voice_transcript = ""
-                
-                # Add user message to chat history
-                st.session_state.messages.append({"role": "user", "content": query})
-                
-                # Check if system is initialized
-                if not st.session_state.rag:
-                    st.error("Please initialize the system and process PDFs first.")
-                    st.session_state.messages.append({
-                        "role": "assistant", 
-                        "content": "Please initialize the system and process PDFs first."
-                    })
+            if st.button("Simulate Voice Input"):
+                user_input = "What are the main topics covered in the documents?"
+                st.info(f"Voice input received: {user_input}")
+                st.rerun()
+        
+        # Process query
+        if user_input:
+            # Add user message to history
+            st.session_state.messages.append({"role": "user", "content": user_input})
+            
+            # Check if system is initialized
+            if not st.session_state.rag:
+                st.error("Please initialize the system and process PDFs first.")
                 
-                # Get response if vector store is ready
-                elif st.session_state.rag.vector_store:
-                    with st.spinner("Generating answer..."):
-                        animated_loader("Searching documents and generating answer...")
-                        
-                        # Get retrieval method
-                        method = st.session_state.retrieval_method
-                        
-                        # Get response using specified method
-                        response = st.session_state.rag.ask(query, method=method)
-                        st.session_state.messages.append({"role": "assistant", "content": response})
-                        
-                        # Store current answer for display
-                        st.session_state.current_answer = response
-                        
-                        # Rerun to update the UI
-                        st.experimental_rerun()
-                else:
-                    st.error("Please upload and process PDF files first.")
-                    st.session_state.messages.append({
-                        "role": "assistant", 
-                        "content": "Please upload and process PDF files first."
-                    })
+            # Get response if vector store is ready
+            elif st.session_state.rag.vector_store:
+                with st.spinner("Generating answer..."):
+                    # Get retrieval method
+                    method = st.session_state.retrieval_method
+                    
+                    # Get answer
+                    response = st.session_state.rag.ask(user_input, method=method)
+                    st.session_state.messages.append({"role": "assistant", "content": response})
+                    
+                    # Store current answer
+                    st.session_state.current_answer = response
+                    
+                    # Rerun to update UI
+                    st.rerun()
+            else:
+                st.error("Please upload and process PDF files first.")
         
-        # Answer Display Section
+        # Display current answer
         if st.session_state.current_answer and isinstance(st.session_state.current_answer, dict):
-            with animated_section("answer_display"):
-                answer = st.session_state.current_answer
-                
-                st.markdown("""
-                <div class="answer-container animate-section">
-                    <div class="answer-header">
-                        <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="margin-right: 8px;"><circle cx="12" cy="12" r="10"></circle><path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3"></path><line x1="12" y1="17" x2="12.01" y2="17"></line></svg>
-                        Answer
-                    </div>
-                    <div class="answer-content">
-                        {answer_text}
-                    </div>
+            answer = st.session_state.current_answer
+            
+            st.markdown("""
+            <div class="answer-section">
+                <h3>Answer</h3>
+                <div style="white-space: pre-line;">
+                    {answer_text}
                 </div>
-                """.format(answer_text=answer["answer"]), unsafe_allow_html=True)
-                
-                # Display metadata
-                meta_cols = st.columns(3)
-                with meta_cols[0]:
-                    method_name = "Direct Retrieval" if answer["method"] == "direct" else "Enhanced Answer"
-                    st.caption(f"Method: {method_name}")
-                with meta_cols[1]:
-                    st.caption(f"Time: {answer['query_time']:.2f} seconds")
-                with meta_cols[2]:
-                    if "blockchain_log" in answer and answer["blockchain_log"]:
-                        blockchain_log = answer["blockchain_log"]
-                        st.caption(f"📝 Logged on blockchain: {blockchain_log['tx_hash'][:8]}...")
+                <div style="margin-top: 10px; font-size: 0.8em; color: #666;">
+                    Method: {method_name} | Time: {query_time:.2f}s
+                </div>
+            </div>
+            """.format(
+                answer_text=answer["answer"],
+                method_name="Direct Retrieval" if answer["method"] == "direct" else "Enhanced Answer",
+                query_time=answer["query_time"]
+            ), unsafe_allow_html=True)
+            
+            # Blockchain verification display
+            if "blockchain_log" in answer and answer["blockchain_log"]:
+                blockchain_log = answer["blockchain_log"]
+                st.success(f"✅ Query logged on blockchain | Transaction: {blockchain_log['tx_hash'][:10]}...")
     
-    # Right column - Sources section
-    with main_col2:
+    # Sources column
+    with sources_col:
+        st.markdown("### Sources")
+        
         if st.session_state.current_answer and isinstance(st.session_state.current_answer, dict):
-            with animated_section("sources_display"):
-                answer = st.session_state.current_answer
-                
-                st.markdown("""
-                <div class="sources-container animate-section">
-                    <div class="sources-header">
-                        <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="margin-right: 8px;"><path d="M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z"></path><path d="M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z"></path></svg>
-                        Sources
-                    </div>
-                """, unsafe_allow_html=True)
-                
-                # Display sources
-                if "sources" in answer and answer["sources"]:
-                    for i, source in enumerate(answer["sources"]):
-                        verified_badge = ""
-                        if source.get("blockchain"):
-                            verified_badge = f"""
-                            <div class="verified-badge">
-                                <svg xmlns="http://www.w3.org/2000/svg" width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M22 11.08V12a10 10 0 1 1-5.93-9.14"></path><polyline points="22 4 12 14.01 9 11.01"></polyline></svg>
-                                Verified
-                            </div>
-                            """
-                        
-                        st.markdown(f"""
-                        <div class="source-item">
-                            <div class="source-header">
-                                <div>Source {i+1}: {source['source']}</div>
-                                {verified_badge}
-                            </div>
-                            <div class="source-content">
-                                {source['content']}
-                            </div>
+            answer = st.session_state.current_answer
+            
+            # Display sources
+            if "sources" in answer and answer["sources"]:
+                for i, source in enumerate(answer["sources"]):
+                    verified_badge = ""
+                    if source.get("blockchain"):
+                        verified_badge = '<span class="verified-badge">✓ Verified</span>'
+                    
+                    st.markdown(f"""
+                    <div class="source-item">
+                        <div class="source-header">
+                            Source {i+1}: {source['source']}
+                            {verified_badge}
                         </div>
-                        """, unsafe_allow_html=True)
-                
-                st.markdown("</div>", unsafe_allow_html=True)
+                        <div style="font-size: 0.9em;">
+                            {source['content'][:200]}...
+                        </div>
+                    </div>
+                    """, unsafe_allow_html=True)
+            else:
+                st.info("No sources available for this query.")
         else:
-            # Placeholder when no sources to display
-            st.markdown("""
-            <div style="height: 300px; display: flex; justify-content: center; align-items: center; background-color: white; border-radius: 12px; margin-top: 30px;">
-                <div style="text-align: center; color: #94a3b8;">
-                    <svg xmlns="http://www.w3.org/2000/svg" width="40" height="40" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="margin: 0 auto 15px;"><circle cx="12" cy="12" r="10"></circle><path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3"></path><line x1="12" y1="17" x2="12.01" y2="17"></line></svg>
-                    <p>Ask a question to see document sources here</p>
-                </div>
-            </div>
-            """, unsafe_allow_html=True)
+            st.info("Ask a question to see sources here.")
 
 # Main entry point
 if __name__ == "__main__":