Deploy Document Intelligence Chatbot

- Streamlit-based chatbot with PDF processing
- Local Hugging Face models (Flan-T5, Sentence Transformers)
- Smart query routing (documents vs web search)
- FAISS vector search for fast retrieval
- Optional web search integration

.gitattributes

@@ -1,35 +1,4 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
 *.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
 *.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.faiss filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,104 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# Environments
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Streamlit
+.streamlit/
+
+# FAISS index files
+*.faiss
+*_docs.pkl
+vector_index*
+
+# Downloaded models
+models/
+*.safetensors
+*.bin
+pytorch_model.bin
+config.json
+tokenizer.json
+tokenizer_config.json
+special_tokens_map.json
+vocab.txt
+
+# Temporary files
+*.tmp
+*.temp
+.DS_Store
+Thumbs.db
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Logs
+*.log
+logs/
+

.streamlit/config.toml

@@ -0,0 +1,15 @@
+[server]
+headless = true
+port = 8501
+enableCORS = false
+enableXsrfProtection = false
+
+[browser]
+gatherUsageStats = false
+
+[theme]
+primaryColor = "#6366f1"
+backgroundColor = "#0e1117"
+secondaryBackgroundColor = "#262730"
+textColor = "#fafafa"
+font = "sans serif"

README.md

@@ -1,20 +1,48 @@
 ---
-title: Document Intelligence Chatbot
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
+title: Universal Document Intelligence Chatbot
+emoji: 📚
+colorFrom: blue
+colorTo: purple
+sdk: streamlit
+sdk_version: 1.28.0
+app_file: app.py
 pinned: false
-short_description: Streamlit template space
 license: mit
 ---
 
-# Welcome to Streamlit!
+# 📚 Universal Document Intelligence Chatbot
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+[![Streamlit](https://img.shields.io/badge/Streamlit-FF4B4B?style=for-the-badge&logo=streamlit&logoColor=white)](https://streamlit.io)
+[![HuggingFace](https://img.shields.io/badge/🤗-Hugging%20Face-yellow?style=for-the-badge)](https://huggingface.co)
+[![Python](https://img.shields.io/badge/Python-3.10-blue?style=for-the-badge&logo=python)](https://python.org)
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+A simple, private, and powerful chatbot that can answer your questions using both your own documents and the web.
+
+## ✨ Features
+
+- **🔒 Runs locally**: Uses Hugging Face Transformers, so your data stays private
+- **⚡ Quick search**: Finds answers fast with Sentence Transformers and FAISS
+- **🧠 Smart routing**: Decides when to pull from your documents or from the web
+- **📄 Handles PDFs**: Upload PDFs and ask questions directly
+- **🌐 Stay up to date**: Can use web search for the latest information
+- **📦 No setup hassle**: Downloads models automatically the first time you use them
+
+## 🚀 Quick Start
+
+### Local Setup
+
+```bash
+# Create a virtual environment
+python -m venv venv
+
+# Activate it (Windows)
+venv\Scripts\activate.bat
+
+# Activate it (Mac/Linux)
+source venv/bin/activate
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Launch the app
+streamlit run app.py  

app.py

@@ -0,0 +1,435 @@
+import streamlit as st
+import os
+from typing import List, Dict
+import time
+
+# Import custom components
+from components.document_processor import DocumentProcessor
+from components.vector_store import VectorStore
+from components.query_router import QueryRouter, QueryType
+from components.web_search import WebSearcher
+from components.huggingface_client import HuggingFaceClient
+
+# Page configuration
+st.set_page_config(
+    page_title="Universal Document Intelligence Chatbot",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+@st.cache_resource
+def get_hf_client():
+    """Get or create HuggingFace client with caching"""
+    try:
+        print("Initializing cached HuggingFace client...")
+        client = HuggingFaceClient()
+        # Force model loading
+        success = client._load_model()
+        print(f"Model loading success: {success}")
+        print(f"Model is_loaded: {client.is_loaded}")
+        return client, success
+    except Exception as e:
+        print(f"Failed to initialize HuggingFace client: {str(e)}")
+        return None, False
+
+class DocumentChatbot:
+    """
+    Main chatbot application class
+    """
+    
+    def __init__(self):
+        self.doc_processor = DocumentProcessor()
+        self.vector_store = VectorStore()
+        self.query_router = QueryRouter()
+        self.web_searcher = None
+        
+        # Get cached HuggingFace client
+        self.hf_client, self.model_loaded = get_hf_client()
+        
+        # Initialize web searcher if API key is available
+        try:
+            self.web_searcher = WebSearcher()
+        except ValueError as e:
+            st.warning(f"Web search disabled: {str(e)}")
+        
+        # Load existing index if available
+        self.vector_store.load_index()
+    
+    def is_ai_model_available(self):
+        """Check if AI model is available"""
+        return self.hf_client is not None and self.hf_client.is_loaded
+    
+    def process_uploaded_files(self, uploaded_files):
+        """Process uploaded PDF files"""
+        if not uploaded_files:
+            return
+        
+        with st.spinner("Processing uploaded documents..."):
+            all_chunks = []
+            
+            for uploaded_file in uploaded_files:
+                try:
+                    # Process the PDF
+                    chunks = self.doc_processor.process_document(uploaded_file)
+                    all_chunks.extend(chunks)
+                    
+                    st.success(f"Processed {uploaded_file.name}: {len(chunks)} chunks")
+                    
+                except Exception as e:
+                    st.error(f"Error processing {uploaded_file.name}: {str(e)}")
+            
+            if all_chunks:
+                # Add to vector store
+                self.vector_store.add_documents(all_chunks)
+                self.vector_store.save_index()
+                
+                st.success(f"Successfully processed {len(all_chunks)} document chunks!")
+                
+                # Update session state
+                st.session_state.documents_loaded = True
+                st.session_state.vector_stats = self.vector_store.get_stats()
+    
+    def search_documents(self, query: str, k: int = 5) -> List[Dict]:
+        """Search documents using vector similarity"""
+        if self.vector_store.index is None or len(self.vector_store.documents) == 0:
+            print(f"No documents available - index: {self.vector_store.index is not None}, docs: {len(self.vector_store.documents) if hasattr(self.vector_store, 'documents') else 'N/A'}")
+            return []
+        
+        results = self.vector_store.search(query, k=k)
+        print(f"Document search for '{query}': found {len(results)} results")
+        if results:
+            scores = [r.get('score', 0) for r in results]
+            print(f"Score range: {min(scores):.3f} - {max(scores):.3f}")
+        return results
+    
+    def get_web_search_results(self, query: str) -> List[Dict]:
+        """Get web search results"""
+        if not self.web_searcher:
+            return []
+        
+        try:
+            return self.web_searcher.search_and_format(query, num_results=3)
+        except Exception as e:
+            st.error(f"Web search error: {str(e)}")
+            return []
+    
+    def generate_response(self, query: str) -> Dict:
+        """Generate response using smart routing and HuggingFace for LLM responses"""
+        response = {
+            'query': query,
+            'sources': [],
+            'answer': '',
+            'routing_info': '',
+            'search_strategy': 'unknown'
+        }
+        
+        # Search documents first, but respect query routing
+        doc_results = self.search_documents(query)
+        
+        # NEW: Use semantic-based routing instead of keyword-based
+        routing_analysis = self.query_router.analyze_query_semantic(query, self.vector_store, similarity_threshold=0.15)
+        
+        print(f"DEBUG: Semantic routing result: {routing_analysis}")
+        
+        # SMART ROUTING: Use semantic similarity to determine strategy
+        if routing_analysis['suggested_route'] == QueryType.WEB_SEARCH:
+            # Query is not relevant to documents - use web search
+            response['search_strategy'] = 'web_search'
+            response['routing_info'] = f"Strategy: web_search (reason: {routing_analysis['reasoning'][0] if routing_analysis['reasoning'] else 'semantic analysis'})"
+            print(f"DEBUG: Using web search for query: '{query}' (similarity: {routing_analysis.get('similarity_score', 0):.3f})")
+            web_results = self.get_web_search_results(query)
+            print(f"DEBUG: Web search returned {len(web_results) if web_results else 0} results")
+            
+            if web_results:
+                # Create context from web results
+                context = "Web search results:\n"
+                for i, result in enumerate(web_results[:3], 1):
+                    context += f"{i}. {result['title']}: {result['snippet']}\n"
+                    response['sources'].append({
+                        'type': 'web',
+                        'title': result['title'],
+                        'snippet': result['snippet'],
+                        'link': result.get('link', ''),
+                        'source': result.get('source', '')
+                    })
+                
+                print(f"DEBUG: Web context created, length: {len(context)}")
+                
+                # Generate response using HuggingFace
+                if self.is_ai_model_available():
+                    system_prompt = "You are a helpful AI assistant that answers questions based on web search results. Be accurate and cite sources when appropriate."
+                    ai_response = self.hf_client.generate_response(query, context, system_prompt)
+                    
+                    if len(ai_response.strip()) < 50 or "not sure" in ai_response.lower():
+                        response['answer'] = f"**🌐 Web Search Results:**\n{context}\n\n**🤖 AI Analysis:**\n{ai_response}"
+                    else:
+                        response['answer'] = f"**🤖 AI Analysis:**\n{ai_response}\n\n**🌐 Web Search Results:**\n{context}"
+                    response['ai_model_used'] = True
+                else:
+                    response['answer'] = f"**🌐 Web Search Results:**\n{context}"
+                    response['ai_model_used'] = False
+                
+                print(f"DEBUG: Returning web search response")
+                return response
+            else:
+                print("DEBUG: No web results, falling back to document search")
+        
+        # If semantic routing suggests documents, use them
+        elif routing_analysis['suggested_route'] == QueryType.DOCUMENT_ONLY and doc_results and len(doc_results) > 0:
+            best_score = max([r.get('score', 0) for r in doc_results])
+            
+            print(f"DEBUG: Using documents based on semantic routing: {len(doc_results)} results, best score: {best_score:.3f}")
+            
+            response['search_strategy'] = 'document_search'
+            response['routing_info'] = f"Strategy: document_search (semantic similarity: {routing_analysis.get('similarity_score', 0):.3f}, found {len(doc_results)} matches)"
+            
+            # Create context from document results
+            context = "Relevant information from your documents:\n"
+            for i, result in enumerate(doc_results[:3], 1):
+                doc = result['document']
+                score = result['score']
+                context += f"{i}. From {doc['metadata']['filename']} (relevance: {score:.2f}):\n{doc['text']}\n\n"
+                
+                response['sources'].append({
+                    'type': 'document',
+                    'filename': doc['metadata']['filename'],
+                    'text': doc['text'],
+                    'score': score,
+                    'chunk_id': doc['metadata'].get('chunk_index', 0)
+                })
+                
+            # Generate response using HuggingFace
+            if self.is_ai_model_available():
+                system_prompt = "You are a helpful AI assistant that answers questions based on provided document context. Be accurate and cite the source documents when appropriate."
+                print(f"DEBUG: Generating AI response for query: '{query[:50]}...'")
+                print(f"DEBUG: Context length: {len(context)}")
+                ai_response = self.hf_client.generate_response(query, context, system_prompt)
+                print(f"DEBUG: AI response received: '{ai_response[:100]}...'")
+                print(f"DEBUG: AI response length: {len(ai_response.strip())}")
+                
+                # Always combine AI response with document context for better user experience
+                if ai_response and len(ai_response.strip()) > 5:
+                    response['answer'] = f"**🤖 AI Summary:**\n{ai_response}\n\n**📄 Source Documents:**\n{context}"
+                    response['ai_model_used'] = True
+                else:
+                    # Fallback if AI response is empty
+                    response['answer'] = f"**📄 Source Documents:**\n{context}"
+                    response['ai_model_used'] = False
+            else:
+                print("DEBUG: AI model not available, using fallback")
+                # Fallback response if HuggingFace is not available
+                response['answer'] = f"**📄 Source Documents:**\n{context}"
+                response['ai_model_used'] = False
+            
+            return response
+        
+        # Fallback: Use web search if no relevant documents found
+        print("DEBUG: Using web search fallback")
+        response['search_strategy'] = 'web_search'
+        response['routing_info'] = f"Strategy: web_search (no relevant documents found or documents not relevant enough)"
+        web_results = self.get_web_search_results(query)
+        
+        if web_results:
+            # Create context from web results
+            context = "Web search results:\n"
+            for i, result in enumerate(web_results[:3], 1):
+                context += f"{i}. {result['title']}: {result['snippet']}\n"
+                response['sources'].append({
+                    'type': 'web',
+                    'title': result['title'],
+                    'snippet': result['snippet'],
+                    'link': result.get('link', ''),
+                    'source': result.get('source', '')
+                })
+            
+            # Generate response using HuggingFace
+            if self.is_ai_model_available():
+                system_prompt = "You are a helpful AI assistant. Answer the user's question based on the provided web search results. Be informative and cite your sources."
+                ai_response = self.hf_client.generate_response(query, context, system_prompt)
+                
+                if len(ai_response.strip()) < 50 or "not sure" in ai_response.lower():
+                    response['answer'] = f"**🌐 Web Search Results:**\n{context}\n\n**🤖 AI Analysis:**\n{ai_response}"
+                else:
+                    response['answer'] = f"**🤖 AI Analysis:**\n{ai_response}\n\n**🌐 Web Search Results:**\n{context}"
+                response['ai_model_used'] = True
+            else:
+                response['answer'] = f"**🌐 Web Search Results:**\n{context}"
+                response['ai_model_used'] = False
+        else:
+            response['answer'] = "I couldn't find relevant information in your documents or through web search. Please try rephrasing your question or upload more relevant documents."
+        
+        return response
+
+def main():
+    """Main application function"""
+    
+    # Initialize session state
+    if 'chatbot' not in st.session_state:
+        st.session_state.chatbot = DocumentChatbot()
+    
+    if 'chat_history' not in st.session_state:
+        st.session_state.chat_history = []
+    
+    if 'documents_loaded' not in st.session_state:
+        st.session_state.documents_loaded = False
+    
+    # Header
+    st.title("Universal Document Intelligence Chatbot")
+    st.markdown("*Upload documents and ask questions - get answers from your files or the web*")
+    
+    # Sidebar for document management
+    with st.sidebar:
+        st.header("Document Management")
+        
+        # File upload
+        uploaded_files = st.file_uploader(
+            "Upload PDF documents",
+            type=['pdf'],
+            accept_multiple_files=True,
+            help="Upload PDF files to create a knowledge base"
+        )
+        
+        # Process uploaded files
+        if uploaded_files:
+            if st.button("Process Documents", type="primary"):
+                st.session_state.chatbot.process_uploaded_files(uploaded_files)
+        
+        # Display statistics
+        if st.session_state.documents_loaded:
+            st.subheader("Knowledge Base Stats")
+            stats = st.session_state.chatbot.vector_store.get_stats()
+            st.metric("Documents", stats['total_documents'])
+            st.metric("Vector Dimension", stats['dimension'])
+            st.info(f"Model: {stats['model_name']}")
+        
+        # Clear documents
+        if st.session_state.documents_loaded:
+            if st.button("Clear All Documents", type="secondary"):
+                st.session_state.chatbot.vector_store.clear_index()
+                st.session_state.documents_loaded = False
+                st.session_state.chat_history = []
+                st.success("Documents cleared!")
+                st.rerun()
+        
+        # Web search status
+        st.subheader("AI Model Status")
+        if st.session_state.chatbot.hf_client and st.session_state.chatbot.hf_client.is_available():
+            st.success("✅ AI model loaded")
+        else:
+            st.error("❌ AI model not loaded")
+            if st.button("🔄 Load AI Model", type="primary"):
+                success = st.session_state.chatbot.initialize_ai_model()
+                if success:
+                    st.rerun()
+        
+        st.subheader("Web Search")
+        if st.session_state.chatbot.web_searcher:
+            st.success("Web search enabled")
+        else:
+            st.error("Web search disabled")
+            st.info("Add SERPER_API_KEY to .env file to enable web search")
+    
+    # Main chat interface
+    st.header("Chat Interface")
+    
+    # Display chat history
+    for i, chat in enumerate(st.session_state.chat_history):
+        with st.chat_message("user"):
+            st.write(chat['query'])
+        
+        with st.chat_message("assistant"):
+            st.write(chat['answer'])
+            
+            # Show routing info
+            if chat.get('routing_info'):
+                with st.expander("Search Strategy"):
+                    st.info(chat['routing_info'])
+            
+            # Show sources
+            if chat.get('sources'):
+                with st.expander(f"Sources ({len(chat['sources'])} found)"):
+                    for j, source in enumerate(chat['sources'], 1):
+                        if source['type'] == 'document':
+                            st.markdown(f"**{j}. Document Source:**")
+                            st.markdown(f"- **File:** {source['filename']}")
+                            st.markdown(f"- **Relevance:** {source['score']:.2f}")
+                            st.markdown(f"- **Text:** {source['text'][:200]}...")
+                        elif source['type'] == 'web':
+                            st.markdown(f"**{j}. Web Source:**")
+                            st.markdown(f"- **Title:** {source['title']}")
+                            st.markdown(f"- **Source:** {source.get('source', 'Unknown')}")
+                            if source.get('link'):
+                                st.markdown(f"- **Link:** {source['link']}")
+    
+    # Query input
+    query = st.chat_input("Ask a question about your documents or anything else...")
+    
+    if query:
+        # Add user message to chat
+        with st.chat_message("user"):
+            st.write(query)
+        
+        # Generate response
+        with st.chat_message("assistant"):
+            with st.spinner("Thinking..."):
+                response = st.session_state.chatbot.generate_response(query)
+            
+            st.write(response['answer'])
+            
+            # Show routing info
+            if response.get('routing_info'):
+                with st.expander("Search Strategy"):
+                    st.info(response['routing_info'])
+                    st.caption(f"Strategy used: {response['search_strategy']}")
+            
+            # Show sources
+            if response.get('sources'):
+                with st.expander(f"Sources ({len(response['sources'])} found)"):
+                    for j, source in enumerate(response['sources'], 1):
+                        if source['type'] == 'document':
+                            st.markdown(f"**{j}. Document Source:**")
+                            st.markdown(f"- **File:** {source['filename']}")
+                            st.markdown(f"- **Relevance:** {source['score']:.2f}")
+                            st.markdown(f"- **Text:** {source['text'][:200]}...")
+                        elif source['type'] == 'web':
+                            st.markdown(f"**{j}. Web Source:**")
+                            st.markdown(f"- **Title:** {source['title']}")
+                            st.markdown(f"- **Source:** {source.get('source', 'Unknown')}")
+                            if source.get('link'):
+                                st.markdown(f"- **Link:** {source['link']}")
+        
+        # Add to chat history
+        st.session_state.chat_history.append({
+            'query': query,
+            'answer': response['answer'],
+            'routing_info': response.get('routing_info'),
+            'sources': response.get('sources', []),
+            'search_strategy': response.get('search_strategy')
+        })
+    
+    # Instructions
+    if not st.session_state.chat_history:
+        st.markdown("""
+        ### Getting Started:
+        
+        1. **Upload PDFs** - Use the sidebar to add your documents
+        2. **Click Process** - This creates a searchable knowledge base
+        3. **Start Chatting** - Ask questions in the box below
+        
+        ### What you can ask:
+        
+        **About your documents:**
+        - "What does the report say about..."
+        - "Summarize the main points"
+        - "Find information about X"
+        
+        **General questions:**
+        - "What's the latest news on..."
+        - "How does X work?"
+        - "Compare A and B"
+        
+        The chatbot automatically decides whether to search your documents or the web.
+        """)
+
+if __name__ == "__main__":
+    main()

components/document_processor.py

@@ -0,0 +1,171 @@
+import PyPDF2
+import re
+from typing import List, Dict
+import io
+
+class DocumentProcessor:
+    """
+    Handles PDF document processing and intelligent text chunking
+    """
+    
+    def __init__(self, chunk_size: int = 1000, chunk_overlap: int = 200):
+        self.chunk_size = chunk_size
+        self.chunk_overlap = chunk_overlap
+    
+    def extract_text_from_pdf(self, pdf_file) -> Dict[str, any]:
+        """
+        Extract text from PDF file and preserve metadata
+        
+        Args:
+            pdf_file: Uploaded PDF file object
+            
+        Returns:
+            Dict containing extracted text, metadata, and page information
+        """
+        try:
+            # Read PDF using PyPDF2
+            pdf_reader = PyPDF2.PdfReader(pdf_file)
+            
+            # Extract metadata
+            metadata = {
+                'filename': pdf_file.name,
+                'num_pages': len(pdf_reader.pages),
+                'title': pdf_reader.metadata.get('/Title', '') if pdf_reader.metadata else '',
+                'author': pdf_reader.metadata.get('/Author', '') if pdf_reader.metadata else '',
+                'subject': pdf_reader.metadata.get('/Subject', '') if pdf_reader.metadata else ''
+            }
+            
+            # Extract text from each page
+            pages_text = []
+            full_text = ""
+            
+            for page_num, page in enumerate(pdf_reader.pages):
+                try:
+                    page_text = page.extract_text()
+                    if page_text.strip():  # Only add non-empty pages
+                        pages_text.append({
+                            'page_number': page_num + 1,
+                            'text': page_text.strip()
+                        })
+                        full_text += f"\n\n[Page {page_num + 1}]\n{page_text.strip()}"
+                except Exception as e:
+                    print(f"Error extracting text from page {page_num + 1}: {str(e)}")
+                    continue
+            
+            return {
+                'full_text': full_text.strip(),
+                'pages': pages_text,
+                'metadata': metadata
+            }
+            
+        except Exception as e:
+            raise Exception(f"Error processing PDF: {str(e)}")
+    
+    def clean_text(self, text: str) -> str:
+        """
+        Clean and normalize extracted text
+        
+        Args:
+            text: Raw extracted text
+            
+        Returns:
+            Cleaned text
+        """
+        # Remove excessive whitespace
+        text = re.sub(r'\s+', ' ', text)
+        
+        # Remove special characters but keep punctuation
+        text = re.sub(r'[^\w\s\.\,\;\:\!\?\-\(\)\[\]\"\'\/]', '', text)
+        
+        # Fix common PDF extraction issues
+        text = text.replace('�', '')  # Remove replacement characters
+        text = re.sub(r'([a-z])([A-Z])', r'\1 \2', text)  # Add space between words
+        
+        return text.strip()
+    
+    def chunk_text(self, text: str, metadata: Dict) -> List[Dict]:
+        """
+        Split text into overlapping chunks for better retrieval
+        
+        Args:
+            text: Full document text
+            metadata: Document metadata
+            
+        Returns:
+            List of text chunks with metadata
+        """
+        # Clean the text first
+        cleaned_text = self.clean_text(text)
+        
+        # Split into sentences for better chunking
+        sentences = re.split(r'(?<=[.!?])\s+', cleaned_text)
+        
+        chunks = []
+        current_chunk = ""
+        current_length = 0
+        chunk_id = 0
+        
+        for sentence in sentences:
+            sentence_length = len(sentence)
+            
+            # If adding this sentence would exceed chunk size, save current chunk
+            if current_length + sentence_length > self.chunk_size and current_chunk:
+                chunks.append({
+                    'chunk_id': chunk_id,
+                    'text': current_chunk.strip(),
+                    'metadata': {
+                        **metadata,
+                        'chunk_size': len(current_chunk),
+                        'chunk_index': chunk_id
+                    }
+                })
+                chunk_id += 1
+                
+                # Start new chunk with overlap
+                if self.chunk_overlap > 0:
+                    # Take last few sentences for overlap
+                    overlap_sentences = current_chunk.split('. ')[-2:]
+                    current_chunk = '. '.join(overlap_sentences) + '. ' + sentence
+                    current_length = len(current_chunk)
+                else:
+                    current_chunk = sentence
+                    current_length = sentence_length
+            else:
+                # Add sentence to current chunk
+                if current_chunk:
+                    current_chunk += " " + sentence
+                else:
+                    current_chunk = sentence
+                current_length += sentence_length
+        
+        # Add the last chunk if it exists
+        if current_chunk.strip():
+            chunks.append({
+                'chunk_id': chunk_id,
+                'text': current_chunk.strip(),
+                'metadata': {
+                    **metadata,
+                    'chunk_size': len(current_chunk),
+                    'chunk_index': chunk_id
+                }
+            })
+        
+        return chunks
+    
+    def process_document(self, pdf_file) -> List[Dict]:
+        """
+        Complete document processing pipeline
+        
+        Args:
+            pdf_file: Uploaded PDF file
+            
+        Returns:
+            List of processed text chunks with metadata
+        """
+        # Extract text and metadata
+        doc_data = self.extract_text_from_pdf(pdf_file)
+        
+        # Create chunks
+        chunks = self.chunk_text(doc_data['full_text'], doc_data['metadata'])
+        
+        return chunks

components/huggingface_client.py

@@ -0,0 +1,486 @@
+"""
+Local Hugging Face model integration with automatic model downloading
+"""
+
+import os
+import torch
+from typing import List, Dict, Optional
+import config
+import warnings
+
+# Suppress some warnings for cleaner output
+warnings.filterwarnings("ignore", category=UserWarning, module="transformers")
+
+class HuggingFaceClient:
+    """
+    Client for local Hugging Face models with automatic downloading
+    """
+    
+    def __init__(self, model_name: str = None, cache_dir: str = None):
+        self.model_name = model_name or config.CHAT_MODEL
+        self.cache_dir = cache_dir or config.MODEL_CACHE_DIR
+        self.max_length = config.MODEL_MAX_LENGTH
+        self.temperature = config.TEMPERATURE
+        
+        # Create cache directory if it doesn't exist
+        os.makedirs(self.cache_dir, exist_ok=True)
+        
+        # Initialize device
+        self.device = self._setup_device()
+        
+        # Initialize models (will be loaded on first use)
+        self.tokenizer = None
+        self.model = None
+        self.model_type = None  # Will be set during loading
+        self.is_loaded = False
+        
+        print(f"HuggingFace Client initialized")
+        print(f"Model: {self.model_name}")
+        print(f"Cache: {self.cache_dir}")
+        print(f"Device: {self.device}")
+    
+    def _setup_device(self):
+        """Setup computation device (CPU/GPU)"""
+        if config.DEVICE == "auto":
+            if config.USE_CUDA and torch.cuda.is_available():
+                device = "cuda"
+                print(f"Using GPU: {torch.cuda.get_device_name()}")
+            else:
+                device = "cpu"
+                print("Using CPU")
+        else:
+            device = config.DEVICE
+        
+        return device
+    
+    def _load_model(self):
+        """Load the model and tokenizer (downloads automatically if not cached)"""
+        if self.is_loaded:
+            return True
+        
+        try:
+            print(f"Loading model: {self.model_name}")
+            print("This might take a few minutes on first run (downloading model)...")
+
+            # Import here to avoid slow startup if not needed
+            from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForCausalLM
+            
+            # Load tokenizer
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                self.model_name,
+                cache_dir=self.cache_dir
+            )
+            
+            # Determine model type and load accordingly
+            is_t5_model = "t5" in self.model_name.lower() or "flan" in self.model_name.lower()
+            
+            if is_t5_model:
+                print("Loading T5/FLAN model for text-to-text generation...")
+                self.model = AutoModelForSeq2SeqLM.from_pretrained(
+                    self.model_name,
+                    cache_dir=self.cache_dir,
+                    torch_dtype=torch.float32,  # T5 works better with float32
+                    low_cpu_mem_usage=True,
+                    trust_remote_code=True
+                )
+                self.model_type = "seq2seq"
+                print("T5/FLAN model loaded successfully!")
+            else:
+                print("Loading causal language model...")
+                self.model = AutoModelForCausalLM.from_pretrained(
+                    self.model_name,
+                    cache_dir=self.cache_dir,
+                    torch_dtype=torch.float32,
+                    low_cpu_mem_usage=True,
+                    trust_remote_code=True
+                )
+                self.model_type = "causal"
+                
+                # Add pad token for causal models
+                if self.tokenizer.pad_token is None:
+                    self.tokenizer.pad_token = self.tokenizer.eos_token
+                print("Causal model loaded successfully!")
+            
+            self.model.eval()  # Set to evaluation mode
+            self.is_loaded = True
+
+            print(f"Model size: ~{self._get_model_size_mb():.1f} MB")
+            return True
+            
+        except Exception as e:
+            print(f"Error loading model: {str(e)}")
+            print("Model will run in offline mode - document search will still work!")
+            self.is_loaded = False
+            return False
+    
+    def _get_model_size_mb(self):
+        """Estimate model size in MB"""
+        if self.model is None:
+            return 0
+        
+        param_size = 0
+        for param in self.model.parameters():
+            param_size += param.nelement() * param.element_size()
+        
+        return param_size / 1024 / 1024
+    
+    def generate_response(self, query: str, context: str = "", system_prompt: str = "") -> str:
+        """Generate a response given a query and context with offline fallback"""
+        # Load model on first use
+        if not self.is_loaded:
+            success = self._load_model()
+            if not success:
+                # Return offline fallback response
+                return self._generate_offline_response(query, context)
+        
+        try:
+            # Prepare the input text based on model type
+            if hasattr(self, 'model_type') and self.model_type == "seq2seq":
+                # T5/FLAN models work better with instruction-style prompts
+                if context:
+                    # For document-based questions
+                    context_truncated = context[:800] if len(context) > 800 else context
+                    
+                    if any(word in query.lower() for word in ['summarize', 'summary', 'main points', 'key points', 'overview']):
+                        input_text = f"Summarize the following text: {context_truncated}"
+                    else:
+                        input_text = f"Answer the question based on the context.\nContext: {context_truncated}\nQuestion: {query}\nAnswer:"
+                else:
+                    input_text = f"Answer this question: {query}"
+                
+                # Tokenize for T5
+                input_ids = self.tokenizer.encode(input_text, return_tensors="pt", truncation=True, max_length=512)
+                
+                # Ensure input_ids are on the same device as the model
+                if hasattr(self.model, 'device'):
+                    model_device = next(self.model.parameters()).device
+                    input_ids = input_ids.to(model_device)
+                else:
+                    input_ids = input_ids.to(self.device)
+                
+                # Generate with T5/FLAN
+                with torch.no_grad():
+                    outputs = self.model.generate(
+                        input_ids,
+                        max_length=200,  # Good length for summaries
+                        min_length=20,   # Ensure substantial response
+                        temperature=0.7,
+                        do_sample=True,
+                        pad_token_id=self.tokenizer.pad_token_id,
+                        eos_token_id=self.tokenizer.eos_token_id,
+                        num_return_sequences=1,
+                        no_repeat_ngram_size=3,
+                        length_penalty=1.0
+                    )
+                
+                # Decode T5 response (T5 outputs only the generated text)
+                response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+                
+            else:
+                # Original logic for causal models (DialoGPT, etc.)
+                if context:
+                    context_truncated = context[:500] if len(context) > 500 else context
+                    
+                    if any(word in query.lower() for word in ['summarize', 'summary', 'main points', 'key points', 'overview']):
+                        input_text = f"Summarize this: {context_truncated}\nSummary:"
+                    else:
+                        input_text = f"Context: {context_truncated}\nQuestion: {query}\nAnswer:"
+                else:
+                    input_text = f"Question: {query}\nAnswer:"
+                
+                # Tokenize input with simpler approach
+                input_ids = self.tokenizer.encode(input_text, return_tensors="pt", truncation=True, max_length=300)
+                
+                # Ensure input_ids are on the same device as the model
+                if hasattr(self.model, 'device'):
+                    model_device = next(self.model.parameters()).device
+                    input_ids = input_ids.to(model_device)
+                else:
+                    input_ids = input_ids.to(self.device)
+                
+                # Generate response with causal model
+                with torch.no_grad():
+                    outputs = self.model.generate(
+                        input_ids,
+                        max_length=input_ids.shape[1] + 100,
+                        min_length=input_ids.shape[1] + 5,
+                        temperature=0.8,
+                        do_sample=True,
+                        pad_token_id=self.tokenizer.eos_token_id,
+                        eos_token_id=self.tokenizer.eos_token_id,
+                        num_return_sequences=1,
+                        no_repeat_ngram_size=2,
+                        repetition_penalty=1.1,
+                        length_penalty=1.0
+                    )
+                
+                # Decode causal model response
+                response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+                
+                # Extract only the new generated text for causal models
+                if response.startswith(input_text):
+                    response = response[len(input_text):].strip()
+                else:
+                    # Fallback: try to find the answer part
+                    for separator in ["Answer:", "Summary:", "\nBot:", "\n"]:
+                        if separator in response:
+                            parts = response.split(separator)
+                            if len(parts) > 1:
+                                response = parts[-1].strip()
+                                break
+            
+            print(f"Extracted response: '{response[:100]}...'")
+            
+            # Clean up the response
+            cleaned_response = self._clean_response(response)
+            
+            # Debug logging
+            print(f"Raw AI response length: {len(response)}")
+            print(f"Cleaned AI response length: {len(cleaned_response)}")
+            print(f"Cleaned response: '{cleaned_response[:100]}...'")
+            
+            # Be more lenient - if we have any response, use it
+            if cleaned_response and len(cleaned_response.strip()) > 0:
+                return cleaned_response
+            elif response and len(response.strip()) > 0:
+                # Use raw response if cleaning removed too much
+                return response.strip()
+            else:
+                # Try a simple fallback generation
+                print("Attempting fallback generation with simpler prompt...")
+                return self._try_simple_generation(query, context)
+            
+        except Exception as e:
+            print(f"Error generating response: {str(e)}")
+            # Fall back to offline response
+            return self._generate_offline_response(query, context)
+    
+    def _try_simple_generation(self, query: str, context: str = "") -> str:
+        """Try a very simple generation as last resort"""
+        try:
+            # Ultra-simple prompt
+            simple_prompt = f"{query}"
+            input_ids = self.tokenizer.encode(simple_prompt, return_tensors="pt", max_length=50)
+            
+            # Ensure input_ids are on the same device as the model
+            if hasattr(self.model, 'device'):
+                model_device = next(self.model.parameters()).device
+                input_ids = input_ids.to(model_device)
+            else:
+                input_ids = input_ids.to(self.device)
+            
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    input_ids,
+                    max_length=input_ids.shape[1] + 30,
+                    temperature=0.9,
+                    do_sample=True,
+                    pad_token_id=self.tokenizer.eos_token_id,
+                    num_return_sequences=1
+                )
+            
+            response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+            response = response[len(simple_prompt):].strip()
+            
+            if response and len(response) > 2:
+                return f"AI Response: {response}"
+            
+        except Exception as e:
+            print(f"Simple generation also failed: {e}")
+        
+        return self._generate_offline_response(query, context)
+    
+    def _generate_offline_response(self, query: str, context: str = "") -> str:
+        """Generate a structured response when AI model is unavailable or gives poor response"""
+        # Check if this is being called because model is unavailable or just poor response
+        model_available = self.is_loaded
+        note_suffix = "*Note: AI model generated poor response - showing raw content*" if model_available else "*Note: AI model unavailable - showing raw content*"
+        
+        if context:
+            if "Relevant information from your documents:" in context:
+                # Extract and format document content
+                lines = context.split('\n')
+                document_info = []
+                current_info = ""
+                
+                for line in lines:
+                    line = line.strip()
+                    if line.startswith("From ") and "relevance:" in line:
+                        if current_info:
+                            document_info.append(current_info)
+                        # Extract filename
+                        filename = line.split("(relevance:")[0].replace("From ", "").strip()
+                        current_info = f"**From {filename}:**"
+                    elif line and not line.startswith("Relevant information") and len(line) > 10:
+                        current_info += f"\n{line}"
+                
+                if current_info:
+                    document_info.append(current_info)
+                
+                if document_info:
+                    response = "Based on your uploaded documents:\n\n"
+                    for info in document_info[:2]:  # Show top 2 sources
+                        response += f"{info}\n\n"
+                    response += f"\n{note_suffix}"
+                    return response
+            
+            elif "Web search results:" in context:
+                # Format web search results
+                lines = context.split('\n')
+                search_results = []
+                
+                for line in lines:
+                    if line.strip() and not line.startswith('Web search results:'):
+                        search_results.append(line.strip())
+                
+                if search_results:
+                    response = "Based on web search results:\n\n"
+                    for i, result in enumerate(search_results[:3], 1):
+                        response += f"{i}. {result}\n"
+                    response += f"\n{note_suffix}"
+                    return response
+        
+        # No context or fallback case
+        if model_available:
+            return (f"I received your question: '{query}'\n\n"
+                    f"I'm having trouble generating a good response right now. "
+                    f"This might be due to the complexity of the question or model limitations.\n\n"
+                    f"Try:\n"
+                    f"• Rephrasing your question more simply\n"
+                    f"• Being more specific about what you want to know\n"
+                    f"• Uploading relevant documents for better context")
+        else:
+            return (f"I received your question: '{query}'\n\n"
+                    f"Unfortunately, I cannot provide a detailed answer because:\n"
+                    f"• The AI model failed to load (likely network connectivity issue)\n"
+                    f"• This appears to be a connection problem with huggingface.co\n\n"
+                    f"To resolve this:\n"
+                    f"• Check your internet connection\n"
+                    f"• Try again in a few minutes\n"
+                    f"• Consider using a VPN if there are regional restrictions\n\n"
+                    f"The app can still search your documents - try uploading PDFs and asking questions about them!")
+    
+    def _clean_response(self, response: str) -> str:
+        """Clean up the generated response"""
+        # Remove common artifacts
+        response = response.strip()
+        
+        # Stop at certain tokens that indicate end of response
+        stop_tokens = ["\nUser:", "\nBot:", "Question:", "Context:", "Answer:", "<|endoftext|>"]
+        for token in stop_tokens:
+            if token in response:
+                response = response.split(token)[0]
+        
+        # Remove repetitive patterns (but be more lenient)
+        lines = response.split('\n')
+        if len(lines) > 1:
+            unique_lines = []
+            for line in lines:
+                line = line.strip()
+                if line and line not in unique_lines:
+                    unique_lines.append(line)
+            response = ' '.join(unique_lines)
+        
+        # Only remove if response is very short (reduced threshold)
+        if len(response.strip()) < 3:
+            return ""
+        
+        return response.strip()
+    
+    def is_available(self) -> bool:
+        """Check if the model is available for use"""
+        try:
+            if not self.is_loaded:
+                success = self._load_model()
+                return success
+            return self.is_loaded
+        except Exception as e:
+            print(f"Error checking model availability: {str(e)}")
+            return False
+    
+    def get_model_info(self) -> Dict:
+        """Get information about the loaded model"""
+        return {
+            "model_name": self.model_name,
+            "device": self.device,
+            "is_loaded": self.is_loaded,
+            "cache_dir": self.cache_dir,
+            "size_mb": self._get_model_size_mb() if self.is_loaded else 0
+        }
+
+
+class HuggingFaceEmbeddingModel:
+    """
+    Embedding model using Sentence Transformers with automatic downloading
+    """
+    
+    def __init__(self, model_name: str = None, cache_dir: str = None):
+        self.model_name = model_name or config.EMBEDDING_MODEL
+        self.cache_dir = cache_dir or config.MODEL_CACHE_DIR
+        self.model = None
+        self.device = self._setup_device()
+        
+        # Create cache directory
+        os.makedirs(self.cache_dir, exist_ok=True)
+        
+        print(f"Embedding model: {self.model_name}")
+    
+    def _setup_device(self):
+        """Setup computation device"""
+        if config.USE_CUDA and torch.cuda.is_available():
+            return "cuda"
+        return "cpu"
+    
+    def _load_model(self):
+        """Load the sentence transformer model"""
+        if self.model is not None:
+            return
+        
+        try:
+            print(f"Loading embedding model: {self.model_name}")
+            from sentence_transformers import SentenceTransformer
+            
+            # Load with explicit device=None to let the library handle device assignment
+            self.model = SentenceTransformer(
+                self.model_name,
+                cache_folder=self.cache_dir,
+                device=None,  # Let the library choose the best device
+                trust_remote_code=True
+            )
+            
+            print(f"Embedding model loaded successfully!")
+        except Exception as e:
+            print(f"Error loading embedding model: {str(e)}")
+            raise e
+    
+    def encode(self, texts: List[str]) -> torch.Tensor:
+        """Encode texts to embeddings"""
+        if self.model is None:
+            self._load_model()
+        
+        try:
+            embeddings = self.model.encode(texts, convert_to_tensor=True)
+            return embeddings.cpu().numpy()
+        except Exception as e:
+            print(f"Error encoding texts: {str(e)}")
+            # Return dummy embeddings as fallback
+            import numpy as np
+            return np.random.rand(len(texts), 384).astype('float32')
+    
+    def get_dimension(self) -> int:
+        """Get embedding dimension"""
+        if self.model is None:
+            self._load_model()
+        
+        # Test with sample text
+        sample_embedding = self.encode(["sample text"])
+        return sample_embedding.shape[1]
+    
+    def is_available(self) -> bool:
+        """Check if embedding model is available"""
+        try:
+            if self.model is None:
+                self._load_model()
+            return self.model is not None
+        except:
+            return False

components/query_router.py

@@ -0,0 +1,304 @@
+import re
+from typing import Dict, List, Tuple, Optional
+from enum import Enum
+
+class QueryType(Enum):
+    DOCUMENT_ONLY = "document_only"
+    WEB_SEARCH = "web_search"
+    HYBRID = "hybrid"
+
+class QueryRouter:
+    """
+    Smart query routing logic to determine whether to use document search,
+    web search, or both based on query characteristics
+    """
+    
+    def __init__(self):
+        # Keywords that trigger web search
+        self.web_search_keywords = {
+            'temporal': [
+                'latest', 'recent', 'current', 'now', 'today', 'this year', 
+                '2024', '2025', 'new', 'updated', 'modern', 'contemporary'
+            ],
+            'explanatory': [
+                'explain', 'how does', 'how to', 'what is', 'what are',
+                'why does', 'why is', 'tell me about', 'describe'
+            ],
+            'comparative': [
+                'vs', 'versus', 'compare', 'comparison', 'difference between',
+                'alternatives to', 'better than', 'similar to', 'like'
+            ],
+            'current_data': [
+                'price', 'cost', 'stock', 'trend', 'trending', 'popular',
+                'market', 'value', 'rate', 'statistics', 'data'
+            ],
+            'specifications': [
+                'specs', 'specifications', 'features', 'details', 'technical',
+                'performance', 'benchmark', 'review'
+            ],
+            'superlatives': [
+                'slowest', 'biggest', 'smallest', 'best', 'worst',
+                'most', 'least', 'highest', 'lowest', 'top', 'bottom',
+                'largest', 'tallest', 'strongest', 'weakest'
+            ],
+            'factual_queries': [
+                'world record', 'world', 'global', 'worldwide', 'international',
+                'country', 'countries', 'nation', 'capital', 'population'
+            ]
+        }
+        
+        # Keywords that strongly suggest document search
+        self.document_keywords = [
+            'according to', 'in the document', 'from the file', 'mentioned',
+            'stated', 'written', 'document says', 'file contains',
+            'pdf', 'pdf about', 'this pdf', 'document about', 'file about',
+            'resume', 'cv', 'uploaded', 'this document', 'this file'
+        ]
+        
+        # General knowledge keywords that might need web search
+        self.general_knowledge_keywords = [
+            'definition', 'meaning', 'concept', 'theory', 'principle',
+            'history', 'background', 'overview', 'introduction'
+        ]
+    
+    def analyze_query(self, query: str) -> Dict:
+        """
+        Analyze query to determine routing strategy
+        
+        Args:
+            query: User query string
+            
+        Returns:
+            Dictionary with routing analysis
+        """
+        query_lower = query.lower()
+        
+        # Initialize analysis
+        analysis = {
+            'query': query,
+            'web_indicators': [],
+            'document_indicators': [],
+            'confidence_scores': {
+                'web_search': 0.0,
+                'document_search': 0.0
+            },
+            'suggested_route': QueryType.DOCUMENT_ONLY,
+            'reasoning': []
+        }
+        
+        # Check for web search indicators
+        web_score = 0
+        for category, keywords in self.web_search_keywords.items():
+            for keyword in keywords:
+                if keyword in query_lower:
+                    analysis['web_indicators'].append(f"{keyword} ({category})")
+                    web_score += self._get_keyword_weight(category)
+        
+        # Check for document indicators
+        doc_score = 0
+        for keyword in self.document_keywords:
+            if keyword in query_lower:
+                analysis['document_indicators'].append(keyword)
+                doc_score += 2.0  # High weight for explicit document references
+        
+        # Check for general knowledge that might need web search
+        for keyword in self.general_knowledge_keywords:
+            if keyword in query_lower:
+                analysis['web_indicators'].append(f"{keyword} (general_knowledge)")
+                web_score += 0.5
+        
+        # Question word analysis
+        question_words = ['how', 'what', 'why', 'when', 'where', 'who', 'which']
+        question_count = sum(1 for word in question_words if word in query_lower.split())
+        if question_count > 0:
+            web_score += 0.3 * question_count
+        
+        # Length analysis (longer queries often need more context)
+        if len(query.split()) > 10:
+            web_score += 0.2
+        
+        # Normalize scores
+        max_possible_score = 10.0
+        analysis['confidence_scores']['web_search'] = min(web_score / max_possible_score, 1.0)
+        analysis['confidence_scores']['document_search'] = min(doc_score / max_possible_score, 1.0)
+        
+        # If no explicit document indicators, boost document search slightly
+        if doc_score == 0:
+            analysis['confidence_scores']['document_search'] = 0.3
+        
+        # Determine routing strategy
+        web_confidence = analysis['confidence_scores']['web_search']
+        doc_confidence = analysis['confidence_scores']['document_search']
+        
+        if doc_confidence > 0.7:  # Strong document indicators
+            analysis['suggested_route'] = QueryType.DOCUMENT_ONLY
+            analysis['reasoning'].append("Strong document reference indicators")
+        elif web_confidence > 0.35:  # Even lower threshold for web search
+            analysis['suggested_route'] = QueryType.WEB_SEARCH
+            analysis['reasoning'].append("Web search indicators detected")
+        elif web_confidence > 0.25 and doc_confidence > 0.3:  # Mixed signals
+            analysis['suggested_route'] = QueryType.HYBRID
+            analysis['reasoning'].append("Mixed indicators suggest hybrid approach")
+        else:  # Default to document search when documents are available
+            analysis['suggested_route'] = QueryType.DOCUMENT_ONLY
+            analysis['reasoning'].append("Default to document search - prefer uploaded documents")
+        
+        return analysis
+    
+    def _get_keyword_weight(self, category: str) -> float:
+        """Get weight for different keyword categories"""
+        weights = {
+            'temporal': 1.5,        # Strong indicator for web search
+            'explanatory': 0.8,     # Medium indicator
+            'comparative': 1.2,     # Strong indicator  
+            'current_data': 1.5,    # Strong indicator
+            'specifications': 1.0,  # Medium indicator
+            'superlatives': 1.8,    # Very strong indicator for web search
+            'factual_queries': 1.6  # Strong indicator for web search
+        }
+        return weights.get(category, 0.5)
+    
+    def should_use_web_search(self, query: str, document_results: List = None) -> Tuple[bool, str]:
+        """
+        Determine if web search should be used based on query and document results
+        
+        Args:
+            query: User query
+            document_results: Results from document search (if any)
+            
+        Returns:
+            Tuple of (should_use_web, reasoning)
+        """
+        analysis = self.analyze_query(query)
+        
+        # Always use web search if suggested route is WEB_SEARCH
+        if analysis['suggested_route'] == QueryType.WEB_SEARCH:
+            return True, "Query indicates need for web search"
+        
+        # For hybrid queries, be more conservative - prefer documents when available
+        if analysis['suggested_route'] == QueryType.HYBRID:
+            if not document_results or len(document_results) == 0:
+                return True, "Hybrid query with no document results"
+            elif len(document_results) > 0:
+                # Check quality of document results - lowered threshold to prefer documents
+                best_score = max([r.get('score', 0) for r in document_results])
+                if best_score < 0.05:  # Very low similarity scores only
+                    return True, "Hybrid query with very low-quality document results"
+        
+        # For document-only queries, almost never use web search
+        if analysis['suggested_route'] == QueryType.DOCUMENT_ONLY:
+            # Only use web search if absolutely no document results
+            if document_results is not None and len(document_results) == 0:
+                return True, "No document results found, falling back to web search"
+        
+        return False, "Document search should be sufficient"
+    
+    def get_routing_explanation(self, query: str) -> str:
+        """
+        Get human-readable explanation of routing decision
+        
+        Args:
+            query: User query
+            
+        Returns:
+            Explanation string
+        """
+        analysis = self.analyze_query(query)
+        
+        explanation = f"**Query Analysis for:** {query}\n\n"
+        
+        if analysis['web_indicators']:
+            explanation += "**Web Search Indicators Found:**\n"
+            for indicator in analysis['web_indicators'][:3]:  # Show top 3
+                explanation += f"- {indicator}\n"
+            explanation += "\n"
+        
+        if analysis['document_indicators']:
+            explanation += "**Document Search Indicators Found:**\n"
+            for indicator in analysis['document_indicators']:
+                explanation += f"- {indicator}\n"
+            explanation += "\n"
+        
+        explanation += f"**Suggested Strategy:** {analysis['suggested_route'].value}\n\n"
+        
+        if analysis['reasoning']:
+            explanation += "**Reasoning:** " + ", ".join(analysis['reasoning'])
+        
+        return explanation
+    
+    def analyze_query_semantic(self, query: str, vector_store=None, similarity_threshold: float = 0.15) -> Dict:
+        """
+        Semantic-based query routing using embedding similarity to determine
+        if the query is relevant to indexed documents
+        
+        Args:
+            query: User's input query
+            vector_store: VectorStore instance with indexed documents
+            similarity_threshold: Minimum similarity score to prefer documents (0.0-1.0)
+            
+        Returns:
+            Dict with routing decision and reasoning
+        """
+        try:
+            # If no vector store or no documents, default to web search
+            if not vector_store or not hasattr(vector_store, 'search') or len(getattr(vector_store, 'documents', [])) == 0:
+                return {
+                    'suggested_route': QueryType.WEB_SEARCH,
+                    'reasoning': ['No documents available - using web search'],
+                    'similarity_score': 0.0
+                }
+            
+            # Still check for strong temporal indicators that should always use web search
+            temporal_keywords = ['latest', 'recent', 'current', 'now', 'today', 'this year', '2024', '2025', 'breaking', 'news']
+            query_lower = query.lower()
+            
+            for keyword in temporal_keywords:
+                if keyword in query_lower:
+                    return {
+                        'suggested_route': QueryType.WEB_SEARCH,
+                        'reasoning': [f'Temporal keyword "{keyword}" detected - using web search for current information'],
+                        'similarity_score': 0.0
+                    }
+            
+            # Get semantic similarity with documents
+            try:
+                # Search for similar documents
+                results = vector_store.search(query, k=3)
+                
+                if not results:
+                    return {
+                        'suggested_route': QueryType.WEB_SEARCH,
+                        'reasoning': ['No document matches found - using web search'],
+                        'similarity_score': 0.0
+                    }
+                
+                # Get the best similarity score
+                best_score = max([r.get('score', 0) for r in results])
+                
+                print(f"DEBUG: Semantic routing - Query: '{query[:50]}...', Best similarity: {best_score:.3f}, Threshold: {similarity_threshold}")
+                
+                if best_score >= similarity_threshold:
+                    return {
+                        'suggested_route': QueryType.DOCUMENT_ONLY,
+                        'reasoning': [f'High document relevance (score: {best_score:.3f}) - using document search'],
+                        'similarity_score': best_score
+                    }
+                else:
+                    return {
+                        'suggested_route': QueryType.WEB_SEARCH,
+                        'reasoning': [f'Low document relevance (score: {best_score:.3f}) - using web search'],
+                        'similarity_score': best_score
+                    }
+                    
+            except Exception as search_error:
+                print(f"DEBUG: Semantic search failed: {search_error}")
+                return {
+                    'suggested_route': QueryType.WEB_SEARCH,
+                    'reasoning': ['Document search failed - using web search'],
+                    'similarity_score': 0.0
+                }
+                
+        except Exception as e:
+            print(f"DEBUG: Semantic routing error: {e}")
+            # Fallback to keyword-based routing
+            return self.analyze_query(query)

components/vector_store.py

@@ -0,0 +1,379 @@
+import numpy as np
+import pickle
+import os
+from typing import List, Dict, Tuple
+import json
+import re
+from collections import Counter
+import math
+import config
+
+# Import torch for device handling
+try:
+    import torch
+    TORCH_AVAILABLE = True
+except ImportError:
+    TORCH_AVAILABLE = False
+
+# Import Hugging Face client
+try:
+    from .huggingface_client import HuggingFaceEmbeddingModel
+    HUGGINGFACE_AVAILABLE = True
+except ImportError:
+    HUGGINGFACE_AVAILABLE = False
+
+# Fallback to sentence transformers
+try:
+    import faiss
+    from sentence_transformers import SentenceTransformer
+    SENTENCE_TRANSFORMERS_AVAILABLE = True
+except ImportError:
+    SENTENCE_TRANSFORMERS_AVAILABLE = False
+    print("Sentence transformers not available. Using TF-IDF fallback.")
+
+class VectorStore:
+    """
+    Vector store using Sentence Transformers for embeddings and FAISS for similarity search
+    """
+    
+    def __init__(self, model_name: str = None, index_path: str = "vector_index"):
+        self.model_name = model_name or config.EMBEDDING_MODEL
+        self.index_path = index_path
+        self.embedding_model = None
+        self.index = None
+        self.documents = []
+        self.dimension = None
+        self.use_huggingface = HUGGINGFACE_AVAILABLE
+        self.use_sentence_transformers = SENTENCE_TRANSFORMERS_AVAILABLE
+        
+        if self.use_huggingface:
+            self._load_huggingface_model()
+        elif self.use_sentence_transformers:
+            self._load_sentence_transformer_model()
+        else:
+            self._init_simple_search()
+    
+    def _load_huggingface_model(self):
+        """Load the Hugging Face embedding model"""
+        try:
+            self.embedding_model = HuggingFaceEmbeddingModel(self.model_name)
+            # Get dimension
+            self.dimension = self.embedding_model.get_dimension()
+            print(f"Loaded HuggingFace embedding model: {self.model_name} (dimension: {self.dimension})")
+        except Exception as e:
+            print(f"Error loading HuggingFace model: {str(e)}")
+            self.use_huggingface = False
+            if self.use_sentence_transformers:
+                self._load_sentence_transformer_model()
+            else:
+                self._init_simple_search()
+    
+    def _load_sentence_transformer_model(self):
+        """Load the sentence transformer model for embeddings"""
+        try:
+            # Load with careful device handling - let the library handle device assignment
+            self.embedding_model = SentenceTransformer(
+                self.model_name, 
+                device=None,  # Let the library choose the best device
+                trust_remote_code=True
+            )
+            
+            # Get dimension from a sample embedding
+            sample_embedding = self.embedding_model.encode(["sample"])
+            self.dimension = sample_embedding.shape[1] if hasattr(sample_embedding, 'shape') else len(sample_embedding)
+            print(f"Loaded sentence transformer model: {self.model_name} (dimension: {self.dimension})")
+        except Exception as e:
+            print(f"Error loading sentence transformer model: {str(e)}")
+            self.use_sentence_transformers = False
+            self._init_simple_search()
+    
+    def _preprocess_text(self, text: str) -> List[str]:
+        """Simple text preprocessing for TF-IDF"""
+        # Convert to lowercase and remove punctuation
+        text = re.sub(r'[^\w\s]', ' ', text.lower())
+        # Split into words and remove empty strings
+        words = [word for word in text.split() if len(word) > 2]
+        return words
+    
+    def _compute_tf(self, words: List[str]) -> Dict[str, float]:
+        """Compute term frequency"""
+        word_count = len(words)
+        tf_dict = {}
+        for word in words:
+            tf_dict[word] = tf_dict.get(word, 0) + 1
+        # Normalize by total word count
+        for word in tf_dict:
+            tf_dict[word] = tf_dict[word] / word_count
+        return tf_dict
+    
+    def _compute_idf(self):
+        """Compute inverse document frequency for all terms"""
+        N = len(self.documents)
+        all_words = set()
+        for doc in self.documents:
+            words = self._preprocess_text(doc['text'])
+            all_words.update(set(words))
+        
+        for word in all_words:
+            containing_docs = sum(1 for doc in self.documents 
+                                if word in self._preprocess_text(doc['text']))
+            self.idf_scores[word] = math.log(N / containing_docs) if containing_docs > 0 else 0
+    
+    def _compute_tfidf_similarity(self, query: str, doc_text: str) -> float:
+        """Compute TF-IDF cosine similarity between query and document"""
+        query_words = self._preprocess_text(query)
+        doc_words = self._preprocess_text(doc_text)
+        
+        if not query_words or not doc_words:
+            return 0.0
+        
+        query_tf = self._compute_tf(query_words)
+        doc_tf = self._compute_tf(doc_words)
+        
+        # Get all unique words
+        all_words = set(query_words + doc_words)
+        
+        # Compute TF-IDF vectors
+        query_vector = []
+        doc_vector = []
+        
+        for word in all_words:
+            idf = self.idf_scores.get(word, 0)
+            query_tfidf = query_tf.get(word, 0) * idf
+            doc_tfidf = doc_tf.get(word, 0) * idf
+            query_vector.append(query_tfidf)
+            doc_vector.append(doc_tfidf)
+        
+        # Compute cosine similarity
+        if not query_vector or not doc_vector:
+            return 0.0
+        
+        dot_product = sum(a * b for a, b in zip(query_vector, doc_vector))
+        query_norm = math.sqrt(sum(a * a for a in query_vector))
+        doc_norm = math.sqrt(sum(a * a for a in doc_vector))
+        
+        if query_norm == 0 or doc_norm == 0:
+            return 0.0
+        
+        return dot_product / (query_norm * doc_norm)
+    
+    def _init_simple_search(self):
+        """Initialize simple TF-IDF search"""
+        self.vocabulary = {}
+        self.idf_scores = {}
+        print("Initialized simple TF-IDF search (advanced embeddings not available)")
+    
+    def create_embeddings(self, texts: List[str]) -> np.ndarray:
+        """Create embeddings for a list of texts"""
+        if self.use_huggingface or self.use_sentence_transformers:
+            try:
+                embeddings = self.embedding_model.encode(texts)
+                if hasattr(embeddings, 'numpy'):
+                    embeddings = embeddings.numpy()
+                return embeddings.astype('float32')
+            except Exception as e:
+                print(f"Error creating embeddings, falling back to simple search: {str(e)}")
+                self.use_huggingface = False
+                self.use_sentence_transformers = False
+                self._init_simple_search()
+        
+        # Return dummy embeddings for simple search
+        return np.zeros((len(texts), 100), dtype='float32')
+    
+    def initialize_index(self):
+        """Initialize FAISS index"""
+        if not (self.use_huggingface or self.use_sentence_transformers):
+            return
+        
+        if self.dimension is None:
+            raise Exception("Embedding model not properly loaded")
+        
+        # Use IndexFlatIP for cosine similarity (Inner Product)
+        self.index = faiss.IndexFlatIP(self.dimension)
+        print(f"Initialized FAISS index with dimension {self.dimension}")
+    
+    def add_documents(self, chunks: List[Dict]):
+        """Add document chunks to the vector store"""
+        if not chunks:
+            return
+        
+        # Store documents with metadata
+        for i, chunk in enumerate(chunks):
+            self.documents.append({
+                'id': len(self.documents),
+                'text': chunk['text'],
+                'metadata': chunk['metadata'],
+                'embedding_id': len(self.documents)
+            })
+        
+        if self.use_huggingface or self.use_sentence_transformers:
+            # Initialize index if not done
+            if self.index is None:
+                self.initialize_index()
+            
+            # Extract texts for embedding
+            texts = [chunk['text'] for chunk in chunks]
+            
+            # Create embeddings
+            embeddings = self.create_embeddings(texts)
+            
+            # Normalize embeddings for cosine similarity
+            faiss.normalize_L2(embeddings)
+            
+            # Add to FAISS index
+            self.index.add(embeddings)
+            
+            print(f"Added {len(chunks)} document chunks to FAISS vector store")
+        else:
+            # For simple search, compute IDF scores
+            self._compute_idf()
+            print(f"Added {len(chunks)} document chunks to simple vector store")
+    
+    def search(self, query: str, k: int = 5, similarity_threshold: float = 0.0) -> List[Dict]:
+        """Search for similar documents using semantic similarity with very low threshold"""
+        if len(self.documents) == 0:
+            return []
+
+        if (self.use_huggingface or self.use_sentence_transformers) and self.index is not None:
+            return self._advanced_search(query, k, similarity_threshold)
+        else:
+            return self._simple_search(query, k, similarity_threshold)
+    
+    def _advanced_search(self, query: str, k: int, similarity_threshold: float) -> List[Dict]:
+        """Advanced search using FAISS and sentence transformers"""
+        # Create query embedding
+        query_embedding = self.create_embeddings([query])
+        
+        # Normalize for cosine similarity
+        faiss.normalize_L2(query_embedding)
+        
+        # Search in FAISS index
+        scores, indices = self.index.search(query_embedding, min(k, len(self.documents)))
+        
+        results = []
+        for i, (score, idx) in enumerate(zip(scores[0], indices[0])):
+            # Filter by similarity threshold
+            if score >= similarity_threshold and idx < len(self.documents):
+                result = {
+                    'document': self.documents[idx],
+                    'score': float(score),
+                    'rank': i + 1
+                }
+                results.append(result)
+        
+        return results
+    
+    def _simple_search(self, query: str, k: int, similarity_threshold: float) -> List[Dict]:
+        """Simple search using improved TF-IDF similarity with better matching"""
+        if not self.documents:
+            return []
+        
+        # Compute similarities
+        similarities = []
+        for doc in self.documents:
+            # Calculate multiple similarity scores for better matching
+            tfidf_similarity = self._compute_tfidf_similarity(query, doc['text'])
+            keyword_similarity = self._compute_keyword_similarity(query, doc['text'])
+            combined_similarity = max(tfidf_similarity, keyword_similarity * 0.7)  # Boost keyword matches
+            
+            similarities.append({
+                'document': doc,
+                'score': combined_similarity,
+                'rank': 0  # Will be set after sorting
+            })
+        
+        # Sort by similarity score
+        similarities.sort(key=lambda x: x['score'], reverse=True)
+        
+        # Always return results, ignore similarity threshold for TF-IDF fallback
+        results = []
+        for i, result in enumerate(similarities[:k]):
+            result['rank'] = i + 1
+            results.append(result)
+        
+        return results
+    
+    def _compute_keyword_similarity(self, query: str, text: str) -> float:
+        """Compute simple keyword-based similarity"""
+        query_words = set(query.lower().split())
+        text_words = set(text.lower().split())
+        
+        if not query_words:
+            return 0.0
+        
+        # Calculate Jaccard similarity
+        intersection = query_words.intersection(text_words)
+        union = query_words.union(text_words)
+        
+        if not union:
+            return 0.0
+        
+        return len(intersection) / len(union)
+    
+    def save_index(self):
+        """Save vector store to disk"""
+        try:
+            if (self.use_huggingface or self.use_sentence_transformers) and self.index is not None:
+                # Save FAISS index
+                faiss.write_index(self.index, f"{self.index_path}.faiss")
+            
+            # Save documents and metadata
+            with open(f"{self.index_path}_docs.pkl", "wb") as f:
+                pickle.dump({
+                    'documents': self.documents,
+                    'dimension': self.dimension,
+                    'model_name': self.model_name,
+                    'use_huggingface': self.use_huggingface,
+                    'use_sentence_transformers': self.use_sentence_transformers,
+                    'vocabulary': getattr(self, 'vocabulary', {}),
+                    'idf_scores': getattr(self, 'idf_scores', {})
+                }, f)
+            
+            print(f"Saved vector index to {self.index_path}")
+        except Exception as e:
+            print(f"Error saving index: {str(e)}")
+    
+    def load_index(self):
+        """Load vector store from disk"""
+        try:
+            if os.path.exists(f"{self.index_path}_docs.pkl"):
+                # Load documents and metadata
+                with open(f"{self.index_path}_docs.pkl", "rb") as f:
+                    data = pickle.load(f)
+                    self.documents = data['documents']
+                    self.dimension = data.get('dimension')
+                    self.vocabulary = data.get('vocabulary', {})
+                    self.idf_scores = data.get('idf_scores', {})
+                    stored_use_hf = data.get('use_huggingface', False)
+                    stored_use_st = data.get('use_sentence_transformers', data.get('use_advanced', True))
+                
+                # Load FAISS index if available and we're using embeddings
+                if ((self.use_huggingface or self.use_sentence_transformers) and 
+                    (stored_use_hf or stored_use_st) and 
+                    os.path.exists(f"{self.index_path}.faiss")):
+                    self.index = faiss.read_index(f"{self.index_path}.faiss")
+                
+                print(f"Loaded vector index from {self.index_path}")
+                return True
+        except Exception as e:
+            print(f"Error loading index: {str(e)}")
+        
+        return False
+    
+    def clear_index(self):
+        """Clear the current index and documents"""
+        self.index = None
+        self.documents = []
+        self.vocabulary = {}
+        self.idf_scores = {}
+        print("Cleared vector index")
+    
+    def get_stats(self) -> Dict:
+        """Get statistics about the vector store"""
+        return {
+            'total_documents': len(self.documents),
+            'index_size': self.index.ntotal if ((self.use_huggingface or self.use_sentence_transformers) and self.index) else len(self.documents),
+            'dimension': self.dimension,
+            'model_name': self.model_name,
+            'search_type': 'HuggingFace Embeddings + FAISS' if self.use_huggingface else 'Sentence Transformers + FAISS' if self.use_sentence_transformers else 'Simple TF-IDF'
+        }

components/web_search.py

@@ -0,0 +1,172 @@
+import requests
+import json
+from typing import List, Dict, Optional
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+class WebSearcher:
+    """
+    Serper.dev API integration for web search functionality
+    """
+    
+    def __init__(self, api_key: Optional[str] = None):
+        self.api_key = api_key or os.getenv("SERPER_API_KEY")
+        self.base_url = "https://google.serper.dev/search"
+        
+        if not self.api_key:
+            raise ValueError("Serper API key is required. Please set SERPER_API_KEY in your .env file")
+    
+    def search(self, query: str, num_results: int = 5) -> Dict:
+        """
+        Perform web search using Serper API
+        
+        Args:
+            query: Search query
+            num_results: Number of results to return
+            
+        Returns:
+            Dictionary containing search results
+        """
+        headers = {
+            'X-API-KEY': self.api_key,
+            'Content-Type': 'application/json'
+        }
+        
+        payload = {
+            'q': query,
+            'num': num_results,
+            'page': 1
+        }
+        
+        try:
+            response = requests.post(
+                self.base_url,
+                headers=headers,
+                data=json.dumps(payload),
+                timeout=10
+            )
+            
+            response.raise_for_status()
+            return response.json()
+            
+        except requests.exceptions.RequestException as e:
+            raise Exception(f"Web search failed: {str(e)}")
+    
+    def format_search_results(self, search_response: Dict) -> List[Dict]:
+        """
+        Format search results into a standardized structure
+        
+        Args:
+            search_response: Raw response from Serper API
+            
+        Returns:
+            List of formatted search results
+        """
+        formatted_results = []
+        
+        # Process organic results
+        organic_results = search_response.get('organic', [])
+        
+        for i, result in enumerate(organic_results):
+            formatted_result = {
+                'rank': i + 1,
+                'title': result.get('title', ''),
+                'snippet': result.get('snippet', ''),
+                'link': result.get('link', ''),
+                'source': result.get('displayLink', ''),
+                'type': 'organic'
+            }
+            formatted_results.append(formatted_result)
+        
+        # Process answer box if available
+        answer_box = search_response.get('answerBox')
+        if answer_box:
+            formatted_result = {
+                'rank': 0,  # Answer box gets top priority
+                'title': answer_box.get('title', 'Direct Answer'),
+                'snippet': answer_box.get('answer', answer_box.get('snippet', '')),
+                'link': answer_box.get('link', ''),
+                'source': answer_box.get('displayLink', 'Google'),
+                'type': 'answer_box'
+            }
+            formatted_results.insert(0, formatted_result)
+        
+        # Process knowledge graph if available
+        knowledge_graph = search_response.get('knowledgeGraph')
+        if knowledge_graph:
+            formatted_result = {
+                'rank': 0,
+                'title': knowledge_graph.get('title', 'Knowledge Graph'),
+                'snippet': knowledge_graph.get('description', ''),
+                'link': knowledge_graph.get('descriptionLink', ''),
+                'source': knowledge_graph.get('source', 'Google Knowledge Graph'),
+                'type': 'knowledge_graph'
+            }
+            formatted_results.insert(0 if not answer_box else 1, formatted_result)
+        
+        return formatted_results
+    
+    def search_and_format(self, query: str, num_results: int = 5) -> List[Dict]:
+        """
+        Perform search and return formatted results
+        
+        Args:
+            query: Search query
+            num_results: Number of results to return
+            
+        Returns:
+            List of formatted search results
+        """
+        try:
+            # Perform search
+            search_response = self.search(query, num_results)
+            
+            # Format results
+            formatted_results = self.format_search_results(search_response)
+            
+            return formatted_results
+            
+        except Exception as e:
+            print(f"Error in web search: {str(e)}")
+            return []
+    
+    def create_search_summary(self, results: List[Dict], max_length: int = 1000) -> str:
+        """
+        Create a summary from search results
+        
+        Args:
+            results: List of search results
+            max_length: Maximum length of summary
+            
+        Returns:
+            Summary text with sources
+        """
+        if not results:
+            return "No web search results found."
+        
+        summary_parts = []
+        sources = []
+        current_length = 0
+        
+        for result in results[:3]:  # Use top 3 results for summary
+            snippet = result.get('snippet', '')
+            title = result.get('title', '')
+            source = result.get('source', '')
+            link = result.get('link', '')
+            
+            if snippet and current_length + len(snippet) < max_length:
+                summary_parts.append(f"**{title}**: {snippet}")
+                if source and link:
+                    sources.append(f"- [{source}]({link})")
+                current_length += len(snippet) + len(title) + 4
+        
+        # Combine summary parts
+        summary = "\n\n".join(summary_parts)
+        
+        if sources:
+            summary += "\n\n**Sources:**\n" + "\n".join(sources)
+        
+        return summary

config.py

@@ -0,0 +1,50 @@
+# Local Hugging Face Model Settings
+EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"  # Fast embedding model
+CHAT_MODEL = "google/flan-t5-base"  # Better for summarization and QA tasks
+
+# Alternative chat models you can use (just change CHAT_MODEL):
+# "google/flan-t5-small" (faster, smaller - 250MB)
+# "google/flan-t5-base" (good balance - 990MB) - RECOMMENDED
+# "google/flan-t5-large" (better quality, slower - 3GB)
+# "facebook/bart-large-cnn" (excellent for summarization but larger)
+# "t5-small" (good for summarization, 240MB)
+
+# Model Settings
+MODEL_MAX_LENGTH = 1000  # Maximum tokens for generation
+TEMPERATURE = 0.7  # Creativity (0.0 = deterministic, 1.0 = very creative)
+USE_CUDA = True  # Set to False if you don't have GPU
+DEVICE = "cpu"  # "auto", "cuda", "cpu"
+MODEL_CACHE_DIR = "./models"  # Local directory to cache downloaded models
+
+# Document Processing Settings
+CHUNK_SIZE = 1000
+CHUNK_OVERLAP = 200
+
+# Vector Store Settings
+SIMILARITY_THRESHOLD = 0.1
+MAX_SEARCH_RESULTS = 5
+
+# Web Search Settings
+WEB_SEARCH_RESULTS = 5
+WEB_SEARCH_TIMEOUT = 10
+
+# Query Routing Settings
+WEB_SEARCH_CONFIDENCE_THRESHOLD = 0.6
+DOCUMENT_SEARCH_CONFIDENCE_THRESHOLD = 0.7
+HYBRID_THRESHOLD = 0.3
+
+# Fallback Settings (if local OpenAI models are not available)
+USE_SENTENCE_TRANSFORMERS_FALLBACK = True
+FALLBACK_EMBEDDING_MODEL = "all-MiniLM-L6-v2"  # Sentence Transformers model
+
+# UI Settings
+PAGE_TITLE = "Universal Document Intelligence Chatbot"
+LAYOUT = "wide"
+
+# File Settings
+SUPPORTED_FILE_TYPES = ['pdf']
+MAX_FILE_SIZE_MB = 50
+
+# Response Settings
+MAX_RESPONSE_LENGTH = 2000
+MAX_SOURCES_DISPLAYED = 3

requirements.txt

@@ -1,3 +1,45 @@
-altair
-pandas
-streamlit
+# Core web framework
+streamlit==1.28.0
+
+# Machine Learning & AI
+torch==2.1.0
+transformers==4.35.2
+sentence-transformers==2.2.2
+accelerate==0.24.1
+
+# Vector Search & Embeddings
+faiss-cpu==1.7.4
+numpy==1.24.3
+
+# Document Processing
+PyPDF2==3.0.1
+
+# Data Processing
+pandas==2.0.3
+
+# Environment & Configuration
+python-dotenv==1.0.0
+
+# HTTP Requests
+requests==2.31.0
+
+# Image Processing (compatible with Streamlit)
+pillow>=7.1.0,<11.0.0
+
+# Package compatibility (compatible with Streamlit)
+packaging>=16.8,<24.0
+
+# Fast model downloads
+hf_xet>=1.1.0
+
+# Additional dependencies for sentence-transformers
+scikit-learn>=1.2.0
+scipy>=1.10.0
+nltk>=3.8
+sentencepiece>=0.1.96
+
+# For tokenization
+tokenizers>=0.13.0,<0.15.0
+
+# For HuggingFace Hub
+huggingface-hub>=0.16.0,<1.0.0