Deploy from QUADRANT_RAG

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow 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

.gitignore

@@ -0,0 +1 @@
+/.venv

.streamlit/config.toml

@@ -0,0 +1,15 @@
+[server]
+port = 7860
+address = "0.0.0.0"
+headless = true
+enableCORS = false
+enableXsrfProtection = false
+
+[theme]
+primaryColor = "#2196f3"
+backgroundColor = "#ffffff"
+secondaryBackgroundColor = "#f0f2f6"
+textColor = "#262730"
+
+[browser]
+gatherUsageStats = false

README.md

@@ -1,10 +1,107 @@
----
-title: Pyqsprag
-emoji: 📚
-colorFrom: green
-colorTo: indigo
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🩺 QUADRANT RAG - Medical AI Assistant
+
+A sophisticated Retrieval-Augmented Generation (RAG) system optimized for medical education, specifically designed for MRCS, USMLE, and NEET-PG exam preparation.
+
+## 🚀 Features
+
+- **🌐 Cloud-Native**: Uses Qdrant Cloud for scalable vector storage
+- **🧠 Advanced AI**: Powered by OpenAI GPT-4o-mini for medical responses
+- **📚 Medical-Optimized**: Specialized for Harrison's Principles and medical textbooks
+- **🔍 Semantic Search**: Advanced embedding-based document retrieval
+- **📖 Citation System**: Proper source attribution with page references
+- **💊 Clinical Pearls**: Highlights crucial practical medical insights
+
+## 🛠️ Technology Stack
+
+- **Frontend**: Streamlit (optimized for HuggingFace Spaces)
+- **Vector Database**: Qdrant Cloud
+- **LLM**: OpenAI GPT-4o-mini
+- **Embeddings**: sentence-transformers/all-MiniLM-L6-v2
+- **PDF Processing**: pypdf with medical text optimization
+
+## 🔧 Setup
+
+### Environment Variables
+
+Create a `.env` file with your credentials:
+
+```env
+# OpenAI Configuration
+OPENAI_API_KEY=your-openai-api-key-here
+
+# Qdrant Cloud Configuration
+QDRANT_URL=https://your-cluster-url.qdrant.tech
+QDRANT_API_KEY=your-qdrant-api-key-here
+QDRANT_COLLECTION_NAME=documents
+
+# Application Configuration
+USE_MEMORY_DB=false
+STREAMLIT_SERVER_PORT=7860
+STREAMLIT_SERVER_ADDRESS=0.0.0.0
+```
+
+### Local Development
+
+```bash
+pip install -r requirements.txt
+streamlit run app.py
+```
+
+### HuggingFace Spaces Deployment
+
+1. Upload your repository to HuggingFace Spaces
+2. Set the environment variables in your Space settings
+3. The app will automatically deploy with Streamlit
+
+## 📖 Usage
+
+1. **Upload Documents**: Use the sidebar to upload medical PDF documents
+2. **Select Active Document**: Click on a document to make it active for querying
+3. **Ask Medical Questions**: Type natural language medical queries
+4. **Review Responses**: Get structured, exam-focused answers with citations
+
+### Sample Questions
+
+- "What are the diagnostic criteria for fever of unknown origin?"
+- "Explain the differential diagnosis of anion gap metabolic acidosis"
+- "What is the workup for neutropenic fever?"
+- "Describe the MUDPILES mnemonic for metabolic acidosis"
+
+## 🏥 Medical Education Focus
+
+The system is specifically optimized for:
+
+- **Structured Learning**: Organized responses by clinical categories
+- **Exam Preparation**: MRCS, USMLE, NEET-PG focused content
+- **Clinical Pearls**: Highlighted practical insights
+- **Evidence-Based**: Citations from authoritative medical texts
+- **Differential Diagnosis**: Systematic approach to medical conditions
+
+## 🔐 Security & Privacy
+
+- API keys are stored securely in environment variables
+- No medical data is persistently stored
+- All processing happens in secure cloud infrastructure
+- Compliant with medical education standards
+
+## 📊 System Architecture
+
+```
+PDF Upload → Text Extraction → Chunking → Embedding → Qdrant Cloud
+                                                           ↓
+User Query → Query Expansion → Vector Search → Context Retrieval
+                                                           ↓
+Context + Query → GPT-4o-mini → Medical Response → Citations
+```
+
+## 🤝 Contributing
+
+This system is designed for medical education and research purposes. Contributions focused on improving medical accuracy and educational value are welcome.
+
+## ⚠️ Disclaimer
+
+This tool is for educational purposes only and should not be used for actual clinical decision-making. Always consult authoritative medical sources and qualified healthcare professionals for patient care decisions.
+
+## 📄 License
+
+Educational and research use only. Please respect medical education licensing and copyright requirements.

app.py

@@ -0,0 +1,768 @@
+#!/usr/bin/env python3
+"""
+QUADRANT RAG System - Enhanced UI v2 with Document Library
+Professional chat interface with persistent document storage
+"""
+
+import os
+import streamlit as st
+import json
+import uuid
+import time
+from typing import List, Dict, Any, Optional
+from pathlib import Path
+from datetime import datetime, timezone
+import tempfile
+import base64
+
+# Load environment variables first
+import os
+from dotenv import load_dotenv
+load_dotenv()
+
+# Import RAG components
+from rag_core import DynamicRAG, extract_pdf_pages, create_chunks
+
+# Page configuration
+st.set_page_config(
+    page_title="QUADRANT RAG - AI Document Assistant",
+    page_icon="🤖",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Enhanced CSS for modern UI
+st.markdown("""
+<style>
+    /* CSS Variables for theme */
+    :root {
+        --primary-color: #5468ff;
+        --secondary-color: #6c63ff;
+        --accent-color: #00d4ff;
+        --background-color: #f8f9fa;
+        --card-background: #ffffff;
+        --text-primary: #2c3e50;
+        --text-secondary: #718096;
+        --border-color: #e2e8f0;
+        --shadow-sm: 0 2px 4px rgba(0,0,0,0.05);
+        --shadow-md: 0 4px 12px rgba(0,0,0,0.08);
+        --shadow-lg: 0 10px 30px rgba(0,0,0,0.1);
+    }
+    
+    /* Reset and base styles */
+    .main {
+        padding: 0;
+        background-color: var(--background-color);
+    }
+    
+    .stApp {
+        background-color: var(--background-color);
+    }
+    
+    /* Sidebar styling */
+    section[data-testid="stSidebar"] {
+        background-color: var(--card-background);
+        border-right: 1px solid var(--border-color);
+        box-shadow: 2px 0 5px rgba(0,0,0,0.05);
+    }
+    
+    section[data-testid="stSidebar"] .block-container {
+        padding: 1.5rem 1rem;
+    }
+    
+    /* Header */
+    .main-header {
+        background: linear-gradient(135deg, var(--primary-color) 0%, var(--secondary-color) 100%);
+        color: white;
+        padding: 1.5rem 2rem;
+        margin: -1rem -1rem 1rem -1rem;
+        box-shadow: var(--shadow-md);
+    }
+    
+    .main-header h1 {
+        margin: 0;
+        font-size: 2rem;
+        font-weight: 700;
+    }
+    
+    .main-header p {
+        margin: 0.5rem 0 0 0;
+        opacity: 0.9;
+        font-size: 1.1rem;
+    }
+    
+    /* Document library styles */
+    .doc-library-header {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        margin: -1.5rem -1rem 1rem -1rem;
+        padding: 1.5rem 1rem;
+        color: white;
+    }
+    
+    .doc-library-header h3 {
+        margin: 0;
+        font-size: 1.3rem;
+        font-weight: 600;
+    }
+    
+    .doc-count {
+        font-size: 0.9rem;
+        opacity: 0.9;
+        margin-top: 0.25rem;
+    }
+    
+    /* Document cards in sidebar */
+    .doc-card {
+        background: var(--card-background);
+        border: 1px solid var(--border-color);
+        border-radius: 8px;
+        padding: 1rem;
+        margin-bottom: 0.75rem;
+        cursor: pointer;
+        transition: all 0.2s ease;
+    }
+    
+    .doc-card:hover {
+        transform: translateY(-2px);
+        box-shadow: var(--shadow-md);
+        border-color: var(--primary-color);
+    }
+    
+    .doc-card.active {
+        border-color: var(--primary-color);
+        background: linear-gradient(to right, #f0f4ff 0%, #ffffff 100%);
+        box-shadow: var(--shadow-md);
+    }
+    
+    .doc-card-title {
+        font-weight: 600;
+        color: var(--text-primary);
+        margin-bottom: 0.25rem;
+        font-size: 0.95rem;
+    }
+    
+    .doc-card-meta {
+        font-size: 0.8rem;
+        color: var(--text-secondary);
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+    }
+    
+    .doc-card-date {
+        font-size: 0.75rem;
+        color: var(--text-secondary);
+        margin-top: 0.25rem;
+    }
+    
+    /* Chat interface */
+    .chat-container {
+        height: calc(100vh - 200px);
+        display: flex;
+        flex-direction: column;
+        background: var(--card-background);
+        border-radius: 12px;
+        box-shadow: var(--shadow-lg);
+        margin: 1rem;
+        overflow: hidden;
+    }
+    
+    .chat-header {
+        background: linear-gradient(135deg, #f0f4ff 0%, #e8eeff 100%);
+        border-bottom: 1px solid var(--border-color);
+        padding: 1.5rem;
+    }
+    
+    .chat-header-title {
+        font-size: 1.1rem;
+        font-weight: 600;
+        color: var(--text-primary);
+        margin: 0;
+        white-space: nowrap;
+        overflow: hidden;
+        text-overflow: ellipsis;
+    }
+    
+    .chat-header-subtitle {
+        font-size: 0.9rem;
+        color: var(--text-secondary);
+        margin-top: 0.25rem;
+    }
+    
+    .chat-messages {
+        flex: 1;
+        overflow-y: auto;
+        padding: 1.5rem;
+        background: #fafbfc;
+    }
+    
+    /* Message styles */
+    .message {
+        margin-bottom: 1.5rem;
+        animation: fadeInUp 0.3s ease;
+    }
+    
+    @keyframes fadeInUp {
+        from {
+            opacity: 0;
+            transform: translateY(10px);
+        }
+        to {
+            opacity: 1;
+            transform: translateY(0);
+        }
+    }
+    
+    .message.user {
+        display: flex;
+        justify-content: flex-end;
+    }
+    
+    .message.assistant {
+        display: flex;
+        justify-content: flex-start;
+    }
+    
+    .message-content {
+        max-width: 70%;
+        padding: 1rem 1.25rem;
+        border-radius: 18px;
+        position: relative;
+        animation: scaleIn 0.2s ease;
+    }
+    
+    @keyframes scaleIn {
+        from {
+            transform: scale(0.95);
+        }
+        to {
+            transform: scale(1);
+        }
+    }
+    
+    .message.user .message-content {
+        background: linear-gradient(135deg, var(--primary-color) 0%, var(--secondary-color) 100%);
+        color: white;
+        border-bottom-right-radius: 4px;
+    }
+    
+    .message.assistant .message-content {
+        background: white;
+        border: 1px solid var(--border-color);
+        color: var(--text-primary);
+        border-bottom-left-radius: 4px;
+    }
+    
+    /* Avatar */
+    .message-avatar {
+        width: 36px;
+        height: 36px;
+        border-radius: 50%;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        font-weight: 600;
+        margin: 0 0.75rem;
+    }
+    
+    .message.user .message-avatar {
+        background: linear-gradient(135deg, var(--primary-color) 0%, var(--secondary-color) 100%);
+        color: white;
+    }
+    
+    .message.assistant .message-avatar {
+        background: linear-gradient(135deg, #f0f4ff 0%, #e8eeff 100%);
+        color: var(--primary-color);
+    }
+    
+    /* Citations */
+    .citations {
+        margin-top: 0.75rem;
+        padding-top: 0.75rem;
+        border-top: 1px solid rgba(0,0,0,0.1);
+    }
+    
+    .citation-item {
+        background: rgba(0,0,0,0.05);
+        padding: 0.5rem 0.75rem;
+        border-radius: 8px;
+        margin-top: 0.5rem;
+        font-size: 0.85rem;
+        border-left: 3px solid var(--accent-color);
+    }
+    
+    /* Input area */
+    .chat-input-container {
+        border-top: 1px solid var(--border-color);
+        background: white;
+        padding: 1.5rem;
+    }
+    
+    .chat-input-wrapper {
+        display: flex;
+        gap: 0.75rem;
+        align-items: flex-end;
+    }
+    
+    .chat-input {
+        flex: 1;
+        background: var(--background-color);
+        border: 2px solid var(--border-color);
+        border-radius: 12px;
+        padding: 0.75rem 1rem;
+        font-size: 1rem;
+        transition: all 0.2s ease;
+        resize: none;
+        min-height: 50px;
+    }
+    
+    .chat-input:focus {
+        outline: none;
+        border-color: var(--primary-color);
+        background: white;
+    }
+    
+    .send-button {
+        background: linear-gradient(135deg, var(--primary-color) 0%, var(--secondary-color) 100%);
+        color: white;
+        border: none;
+        border-radius: 12px;
+        padding: 0.75rem 1.5rem;
+        font-size: 1rem;
+        font-weight: 600;
+        cursor: pointer;
+        transition: all 0.2s ease;
+        display: flex;
+        align-items: center;
+        gap: 0.5rem;
+    }
+    
+    .send-button:hover {
+        transform: translateY(-2px);
+        box-shadow: var(--shadow-md);
+    }
+    
+    .send-button:active {
+        transform: translateY(0);
+    }
+    
+    /* Typing indicator */
+    .typing-indicator {
+        display: inline-flex;
+        padding: 0.75rem 1rem;
+        background: white;
+        border-radius: 18px;
+        border: 1px solid var(--border-color);
+        gap: 4px;
+    }
+    
+    .typing-dot {
+        width: 8px;
+        height: 8px;
+        background: var(--primary-color);
+        border-radius: 50%;
+        animation: typing 1.4s infinite;
+    }
+    
+    .typing-dot:nth-child(1) { animation-delay: -0.32s; }
+    .typing-dot:nth-child(2) { animation-delay: -0.16s; }
+    
+    @keyframes typing {
+        0%, 80%, 100% {
+            opacity: 0.5;
+            transform: scale(0.8);
+        }
+        40% {
+            opacity: 1;
+            transform: scale(1);
+        }
+    }
+    
+    /* Upload area */
+    .upload-area {
+        border: 2px dashed var(--primary-color);
+        border-radius: 12px;
+        padding: 3rem;
+        text-align: center;
+        background: linear-gradient(to bottom, #f0f4ff 0%, #ffffff 100%);
+        transition: all 0.3s ease;
+        margin: 1rem;
+    }
+    
+    .upload-area:hover {
+        border-color: var(--secondary-color);
+        background: linear-gradient(to bottom, #e8eeff 0%, #f8f9ff 100%);
+    }
+    
+    .upload-icon {
+        font-size: 4rem;
+        color: var(--primary-color);
+        margin-bottom: 1rem;
+    }
+    
+    /* Empty state */
+    .empty-state {
+        text-align: center;
+        padding: 3rem;
+        color: var(--text-secondary);
+    }
+    
+    .empty-state-icon {
+        font-size: 4rem;
+        opacity: 0.3;
+        margin-bottom: 1rem;
+    }
+    
+    /* Buttons */
+    .stButton > button {
+        background: linear-gradient(135deg, var(--primary-color) 0%, var(--secondary-color) 100%);
+        color: white;
+        border: none;
+        padding: 0.75rem 1.5rem;
+        border-radius: 8px;
+        font-weight: 600;
+        transition: all 0.2s ease;
+    }
+    
+    .stButton > button:hover {
+        transform: translateY(-2px);
+        box-shadow: var(--shadow-md);
+    }
+    
+    /* Hide Streamlit defaults */
+    #MainMenu {visibility: hidden;}
+    footer {visibility: hidden;}
+    
+    /* Scrollbar */
+    ::-webkit-scrollbar {
+        width: 8px;
+        height: 8px;
+    }
+    
+    ::-webkit-scrollbar-track {
+        background: var(--background-color);
+    }
+    
+    ::-webkit-scrollbar-thumb {
+        background: var(--border-color);
+        border-radius: 4px;
+    }
+    
+    ::-webkit-scrollbar-thumb:hover {
+        background: var(--text-secondary);
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Initialize session state
+if 'rag_system' not in st.session_state:
+    st.session_state.rag_system = None
+if 'current_doc' not in st.session_state:
+    st.session_state.current_doc = None
+if 'chat_history' not in st.session_state:
+    st.session_state.chat_history = []
+if 'all_documents' not in st.session_state:
+    st.session_state.all_documents = []
+if 'processing' not in st.session_state:
+    st.session_state.processing = False
+if 'waiting_for_response' not in st.session_state:
+    st.session_state.waiting_for_response = False
+
+def init_rag_system():
+    """Initialize the RAG system"""
+    try:
+        # Check environment variables
+        from dotenv import load_dotenv
+        load_dotenv()  # Reload environment variables
+
+        openai_key = os.environ.get('OPENAI_API_KEY', '')
+        qdrant_url = os.environ.get('QDRANT_URL', '')
+        qdrant_key = os.environ.get('QDRANT_API_KEY', '')
+
+        if not openai_key or openai_key == 'your-openai-api-key-here':
+            st.error("❌ OpenAI API key not configured. Please set OPENAI_API_KEY in your environment.")
+            return False
+
+        if not qdrant_url or not qdrant_key:
+            st.warning("⚠️ Qdrant Cloud credentials not found. Using in-memory storage.")
+
+        with st.spinner("🔄 Initializing RAG System..."):
+            st.session_state.rag_system = DynamicRAG()
+            # Load all documents from Qdrant
+            st.session_state.all_documents = st.session_state.rag_system.get_all_documents()
+
+        st.success("✅ RAG System initialized successfully!")
+        return True
+    except Exception as e:
+        st.error(f"❌ Failed to initialize RAG system: {str(e)}")
+        return False
+
+def process_pdf_upload(uploaded_file) -> Optional[Dict[str, Any]]:
+    """Process uploaded PDF file"""
+    try:
+        st.session_state.processing = True
+        
+        # Save uploaded file
+        temp_path = Path(tempfile.gettempdir()) / f"{uuid.uuid4().hex}.pdf"
+        with open(temp_path, "wb") as f:
+            f.write(uploaded_file.getvalue())
+        
+        # Extract text
+        pages = extract_pdf_pages(str(temp_path))
+        
+        # Create chunks
+        chunks = create_chunks(pages, chunk_size=3000, overlap=200)
+        
+        # Generate document ID
+        doc_id = f"{uploaded_file.name.replace('.pdf', '')}_{int(time.time())}"
+        
+        # Store in Qdrant
+        st.session_state.rag_system.store_document(doc_id, chunks)
+        
+        # Create document info
+        doc_info = {
+            'doc_id': doc_id,
+            'title': uploaded_file.name,
+            'pages': len(pages),
+            'chunks': len(chunks),
+            'upload_time': datetime.now(timezone.utc).isoformat()
+        }
+        
+        # Update documents list
+        st.session_state.all_documents = st.session_state.rag_system.get_all_documents()
+        
+        # Clean up
+        temp_path.unlink()
+        
+        return doc_info
+        
+    except Exception as e:
+        st.error(f"Error processing PDF: {str(e)}")
+        return None
+    finally:
+        st.session_state.processing = False
+
+def query_document(question: str) -> tuple[str, List[Dict[str, Any]]]:
+    """Query the current document"""
+    try:
+        if not st.session_state.current_doc:
+            return "Please select a document first.", []
+        
+        # Search in current document - increased for better coverage
+        search_results = st.session_state.rag_system.search(
+            query=question,
+            doc_id=st.session_state.current_doc['doc_id'],
+            top_k=10
+        )
+        
+        if not search_results:
+            return "I couldn't find relevant information about that in the document.", []
+        
+        # Generate answer
+        answer = st.session_state.rag_system.generate_answer(question, search_results)
+        
+        # Check if the answer indicates insufficient evidence
+        insufficient_keywords = ["insufficient evidence", "couldn't find", "no relevant information", "cannot answer"]
+        
+        # Prepare citations only if the answer has sufficient evidence
+        citations = []
+        if not any(keyword in answer.lower() for keyword in insufficient_keywords):
+            for i, result in enumerate(search_results[:3]):
+                citations.append({
+                    'page': result['page'],
+                    'text': result['text'][:150] + "..." if len(result['text']) > 150 else result['text'],
+                    'score': round(result['score'], 3)
+                })
+        
+        return answer, citations
+        
+    except Exception as e:
+        return f"Sorry, I encountered an error: {str(e)}", []
+
+def render_sidebar():
+    """Render the document library sidebar"""
+    with st.sidebar:
+        # Header
+        st.markdown("""
+        <div class="doc-library-header">
+            <h3>📚 Document Library</h3>
+            <div class="doc-count">{} documents stored</div>
+        </div>
+        """.format(len(st.session_state.all_documents)), unsafe_allow_html=True)
+        
+        # Upload new document
+        with st.expander("📤 Upload New Document", expanded=False):
+            uploaded_file = st.file_uploader(
+                "Choose a PDF file",
+                type=['pdf'],
+                label_visibility="collapsed",
+                disabled=st.session_state.processing
+            )
+            
+            if uploaded_file and st.button("Upload", type="primary", use_container_width=True):
+                with st.spinner("Processing..."):
+                    doc = process_pdf_upload(uploaded_file)
+                    if doc:
+                        st.success("✅ Document uploaded successfully!")
+                        st.rerun()
+        
+        # Document list
+        if st.session_state.all_documents:
+            st.markdown("### Your Documents")
+            
+            for doc in st.session_state.all_documents:
+                # Check if this is the current document
+                is_active = (st.session_state.current_doc and 
+                           doc['doc_id'] == st.session_state.current_doc['doc_id'])
+                
+                # Document card
+                card_class = "doc-card active" if is_active else "doc-card"
+                
+                col1, col2 = st.columns([5, 1])
+                
+                with col1:
+                    if st.button(
+                        f"📄 **{doc['title'][:30]}{'...' if len(doc['title']) > 30 else ''}**\n\n"
+                        f"📊 {doc['pages']} pages • {doc['chunks']} chunks",
+                        key=f"doc_{doc['doc_id']}",
+                        use_container_width=True
+                    ):
+                        st.session_state.current_doc = doc
+                        st.session_state.chat_history = []
+                        st.rerun()
+                
+                with col2:
+                    if st.button("🗑️", key=f"del_{doc['doc_id']}", 
+                               help="Delete this document"):
+                        if st.session_state.rag_system.delete_document(doc['doc_id']):
+                            st.session_state.all_documents = st.session_state.rag_system.get_all_documents()
+                            if (st.session_state.current_doc and 
+                                doc['doc_id'] == st.session_state.current_doc['doc_id']):
+                                st.session_state.current_doc = None
+                                st.session_state.chat_history = []
+                            st.rerun()
+            
+        else:
+            st.markdown("""
+            <div class="empty-state">
+                <div class="empty-state-icon">📭</div>
+                <p>No documents yet</p>
+                <p style="font-size: 0.85rem;">Upload your first PDF to get started</p>
+            </div>
+            """, unsafe_allow_html=True)
+
+def render_chat_interface():
+    """Render the main chat interface"""
+    if not st.session_state.current_doc:
+        # No document selected
+        st.markdown("""
+        <div class="upload-area">
+            <div class="upload-icon">📚</div>
+            <h2>Welcome to QUADRANT RAG Medical Assistant</h2>
+            <p style="font-size: 1.1rem; color: #718096; margin-top: 1rem;">
+                Upload medical documents or select from your library to start AI-powered medical Q&A
+            </p>
+            <p style="font-size: 0.95rem; color: #a0aec0; margin-top: 0.5rem;">
+                ✨ Powered by OpenAI GPT-5-mini & Qdrant Cloud • Optimized for Medical Education
+            </p>
+        </div>
+        """, unsafe_allow_html=True)
+    else:
+        # Chat interface
+        title = st.session_state.current_doc['title']
+        # Truncate overly long titles for cleaner UI
+        display_title = (title[:100] + "…") if len(title) > 100 else title
+        pages = st.session_state.current_doc['pages']
+        chunks = st.session_state.current_doc['chunks']
+        st.markdown(
+            f"""
+            <div class=\"chat-header\">
+                <div class=\"chat-header-title\" title=\"{title}\">💬 Chatting with: {display_title}</div>
+                <div class=\"chat-header-subtitle\">{pages} pages • {chunks} chunks • Ask anything about this document</div>
+            </div>
+            """,
+            unsafe_allow_html=True,
+        )
+
+        # New chat UI using Streamlit's native components
+        if not st.session_state.chat_history:
+            st.info("Start a conversation about your document. Ask me to explain, summarize, or find specifics.")
+
+        for msg in st.session_state.chat_history:
+            if msg['type'] == 'user':
+                with st.chat_message("user"):
+                    st.markdown(msg['content'])
+            else:
+                with st.chat_message("assistant"):
+                    st.markdown(msg['content'])
+                    if msg.get('citations'):
+                        with st.expander(f"📚 {len(msg['citations'])} Sources"):
+                            for i, cite in enumerate(msg['citations'], 1):
+                                st.markdown(f"**[{i}] Page {cite['page']}** (Relevance: {cite['score']:.3f})")
+                                st.text(cite['text'][:200] + "..." if len(cite['text']) > 200 else cite['text'])
+                                st.divider()
+
+        # Chat input and immediate handling
+        if prompt := st.chat_input("Ask anything about this document…"):
+            st.session_state.chat_history.append({'type': 'user', 'content': prompt})
+            with st.chat_message("assistant"):
+                with st.spinner("Thinking..."):
+                    answer, citations = query_document(prompt)
+                    st.session_state.chat_history.append({
+                        'type': 'assistant',
+                        'content': answer,
+                        'citations': citations if citations else None
+                    })
+                    st.markdown(answer)
+                    if citations:
+                        with st.expander(f"📚 {len(citations)} Sources"):
+                            for i, cite in enumerate(citations, 1):
+                                st.markdown(f"**[{i}] Page {cite['page']}** (Relevance: {cite['score']:.3f})")
+                                st.text(cite['text'][:200] + "..." if len(cite['text']) > 200 else cite['text'])
+                                st.divider()
+
+        # Prevent legacy UI from rendering below
+        return
+        
+
+def main():
+    # Configuration section for missing environment variables
+    openai_key = os.environ.get('OPENAI_API_KEY', '')
+    if not openai_key or openai_key == 'your-openai-api-key-here':
+        st.error("🔑 **OpenAI API Key Required**")
+        st.markdown("""
+        Please set your OpenAI API key:
+        1. Add `OPENAI_API_KEY=your-key-here` to the `.env` file, OR
+        2. Set it as an environment variable in your deployment platform
+        """)
+
+        # Quick input for testing
+        with st.expander("💡 Quick Setup (for testing)"):
+            key_input = st.text_input("Enter OpenAI API Key:", type="password")
+            if st.button("Set API Key") and key_input:
+                os.environ['OPENAI_API_KEY'] = key_input
+                st.success("✅ API Key set! Initializing system...")
+                st.rerun()
+        st.stop()
+
+    # Initialize system
+    if not st.session_state.rag_system:
+        if not init_rag_system():
+            st.stop()
+    
+    # Header
+    st.markdown("""
+    <div class="main-header">
+        <h1>🤖 QUADRANT RAG - Document AI Assistant</h1>
+        <p>Powered by Qdrant Vector Database & OpenAI GPT-5-mini</p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Sidebar
+    render_sidebar()
+    
+    # Main content
+    render_chat_interface()
+
+if __name__ == "__main__":
+    main()

data/docs.json

@@ -0,0 +1,393 @@
+{
+  "docs": [
+    {
+      "id": "f3dd7bef91b9",
+      "title": "[https___github.com_niki-amini-naieni_CountVid](ht.pdf",
+      "filename": "f3dd7bef91b9.pdf",
+      "path": "/Users/athulnambiar/Desktop/PROJECTS/QUADRANT_RAG/uploads/f3dd7bef91b9.pdf",
+      "pages": 4,
+      "created_at": "2025-09-22T17:04:06.943407Z"
+    },
+    {
+      "id": "639a85dd8f1f",
+      "title": "AI-Powered Company Classification Tool_ Technical Architecture & Data Flow-2.pdf",
+      "filename": "639a85dd8f1f.pdf",
+      "path": "/Users/athulnambiar/Desktop/PROJECTS/QUADRANT_RAG/uploads/639a85dd8f1f.pdf",
+      "pages": 2,
+      "created_at": "2025-09-22T18:26:30.613458Z"
+    },
+    {
+      "id": "50f6dc85d40b",
+      "title": "2262041-Athul Nambiar Final-2.pdf",
+      "filename": "50f6dc85d40b.pdf",
+      "pages": 30,
+      "chunks": 24,
+      "created_at": "2025-09-23T17:16:16.652638",
+      "enhanced": true,
+      "medical_optimized": true
+    },
+    {
+      "id": "be191882380f",
+      "title": "MVP Development for AI-Powered Company Classification Tool.pdf",
+      "filename": "be191882380f.pdf",
+      "pages": 4,
+      "chunks": 11,
+      "created_at": "2025-09-23T17:37:46.782738+00:00",
+      "dynamic_rag": true,
+      "vector_db": "qdrant",
+      "llm_model": "gpt-4o-mini"
+    },
+    {
+      "id": "ff610e38e8b3",
+      "title": "1. Christ University Policy on Research Internships for Undergraduate and Postgraduate Students.pdf",
+      "filename": "ff610e38e8b3.pdf",
+      "pages": 4,
+      "chunks": 12,
+      "created_at": "2025-09-25T19:04:11.467669+00:00",
+      "dynamic_rag": true,
+      "vector_db": "qdrant",
+      "llm_model": "gpt-4o-mini"
+    },
+    {
+      "id": "bec87b0367ac",
+      "title": "Mini-project Report front page_Image and Video Analytics.pdf",
+      "filename": "bec87b0367ac.pdf",
+      "pages": 7,
+      "chunks": 6,
+      "created_at": "2025-09-25T19:16:09.040014+00:00",
+      "dynamic_rag": true,
+      "vector_db": "qdrant",
+      "llm_model": "gpt-4o-mini"
+    },
+    {
+      "id": "0fd6df206ce2",
+      "title": "Mini-project Report front page_Image and Video Analytics.pdf",
+      "filename": "0fd6df206ce2.pdf",
+      "pages": 7,
+      "chunks": 6,
+      "created_at": "2025-09-25T19:19:09.454543+00:00",
+      "dynamic_rag": true,
+      "vector_db": "qdrant",
+      "llm_model": "gpt-4o-mini"
+    },
+    {
+      "id": "9ef4a5805de2",
+      "title": "Harrison\u2019s Principles of Internal Medicine, 21st edition -- By Joseph Loscalzo, Anthony Fauci, Dennis Kasper, Stephen -- 21th edition, New York, -- 9781259644030 -- 201ae48755c6d5e6625a0d4018a77f49 -- Anna\u2019s Archive_split-merge.pdf",
+      "filename": "9ef4a5805de2.pdf",
+      "pages": 51,
+      "chunks": 491,
+      "created_at": "2025-09-25T19:21:14.181613+00:00",
+      "dynamic_rag": true,
+      "vector_db": "qdrant",
+      "llm_model": "gpt-4o-mini"
+    },
+    {
+      "id": "83c48ac2fa2f",
+      "title": "Harrison\u2019s Principles of Internal Medicine, 21st edition -- By Joseph Loscalzo, Anthony Fauci, Dennis Kasper, Stephen -- 21th edition, New York, -- 9781259644030 -- 201ae48755c6d5e6625a0d4018a77f49 -- Anna\u2019s Archive_split-merge.pdf",
+      "filename": "83c48ac2fa2f.pdf",
+      "pages": 51,
+      "chunks": 491,
+      "created_at": "2025-09-26T07:13:09.540473+00:00",
+      "dynamic_rag": true,
+      "vector_db": "qdrant",
+      "llm_model": "gpt-4o-mini"
+    },
+    {
+      "id": "3d5f4faa9630",
+      "title": "Harrison\u2019s Principles of Internal Medicine, 21st edition -- By Joseph Loscalzo, Anthony Fauci, Dennis Kasper, Stephen -- 21th edition, New York, -- 9781259644030 -- 201ae48755c6d5e6625a0d4018a77f49 -- Anna\u2019s Archive_split-merge.pdf",
+      "filename": "3d5f4faa9630.pdf",
+      "pages": 51,
+      "chunks": 491,
+      "created_at": "2025-09-26T11:37:30.064125+00:00",
+      "dynamic_rag": true,
+      "vector_db": "qdrant",
+      "llm_model": "gpt-4o-mini"
+    },
+    {
+      "id": "91e53cac0db8",
+      "title": "Harrison\u2019s Principles of Internal Medicine, 21st edition -- By Joseph Loscalzo, Anthony Fauci, Dennis Kasper, Stephen -- 21th edition, New York, -- 9781259644030 -- 201ae48755c6d5e6625a0d4018a77f49 -- Anna\u2019s Archive_split-merge.pdf",
+      "filename": "91e53cac0db8.pdf",
+      "pages": 51,
+      "chunks": 247,
+      "created_at": "2025-09-26T14:50:49.748305+00:00",
+      "dynamic_rag": true,
+      "vector_db": "qdrant",
+      "llm_model": "gpt-4o-mini"
+    },
+    {
+      "id": "e42111b7b18b",
+      "title": "Harrison\u2019s Principles of Internal Medicine, 21st edition -- By Joseph Loscalzo, Anthony Fauci, Dennis Kasper, Stephen -- 21th edition, New York, -- 9781259644030 -- 201ae48755c6d5e6625a0d4018a77f49 -- Anna\u2019s Archive_split-merge.pdf",
+      "filename": "e42111b7b18b.pdf",
+      "pages": 51,
+      "chunks": 247,
+      "created_at": "2025-09-26T14:54:02.811504+00:00",
+      "dynamic_rag": true,
+      "vector_db": "qdrant",
+      "llm_model": "gpt-4o-mini"
+    },
+    {
+      "id": "b78c65d6b361",
+      "title": "Harrison\u2019s Principles of Internal Medicine, 21st edition -- By Joseph Loscalzo, Anthony Fauci, Dennis Kasper, Stephen -- 21th edition, New York, -- 9781259644030 -- 201ae48755c6d5e6625a0d4018a77f49 -- Anna\u2019s Archive_split-merge.pdf",
+      "filename": "b78c65d6b361.pdf",
+      "pages": 51,
+      "chunks": 247,
+      "created_at": "2025-09-26T14:54:03.053592+00:00",
+      "dynamic_rag": true,
+      "vector_db": "qdrant",
+      "llm_model": "gpt-4o-mini"
+    },
+    {
+      "id": "6200aee12faa",
+      "title": "Harrison\u2019s Principles of Internal Medicine, 21st edition -- By Joseph Loscalzo, Anthony Fauci, Dennis Kasper, Stephen -- 21th edition, New York, -- 9781259644030 -- 201ae48755c6d5e6625a0d4018a77f49 -- Anna\u2019s Archive_split-merge.pdf",
+      "filename": "6200aee12faa.pdf",
+      "pages": 51,
+      "chunks": 247,
+      "created_at": "2025-09-26T15:29:57.820092+00:00",
+      "dynamic_rag": true,
+      "vector_db": "qdrant",
+      "llm_model": "gpt-4o-mini"
+    },
+    {
+      "id": "8888d36bfc6e",
+      "title": "Harrison\u2019s Principles of Internal Medicine, 21st edition -- By Joseph Loscalzo, Anthony Fauci, Dennis Kasper, Stephen -- 21th edition, New York, -- 9781259644030 -- 201ae48755c6d5e6625a0d4018a77f49 -- Anna\u2019s Archive_split-merge.pdf",
+      "filename": "8888d36bfc6e.pdf",
+      "pages": 51,
+      "chunks": 247,
+      "created_at": "2025-09-29T16:24:46.915516+00:00",
+      "dynamic_rag": true,
+      "vector_db": "qdrant",
+      "llm_model": "gpt-4o-mini"
+    },
+    {
+      "id": "9b2ccd8b9cc9",
+      "title": "Harrison\u2019s Principles of Internal Medicine, 21st edition -- By Joseph Loscalzo, Anthony Fauci, Dennis Kasper, Stephen -- 21th edition, New York, -- 9781259644030 -- 201ae48755c6d5e6625a0d4018a77f49 -- Anna\u2019s Archive_split-merge.pdf",
+      "filename": "9b2ccd8b9cc9.pdf",
+      "pages": 51,
+      "chunks": 247,
+      "created_at": "2025-09-29T16:42:35.313291+00:00",
+      "dynamic_rag": true,
+      "vector_db": "qdrant",
+      "llm_model": "gpt-4o-mini"
+    }
+  ],
+  "chunks": {
+    "50f6dc85d40b": [
+      {
+        "id": "50f6dc85d40b_0",
+        "text": "SORCOVA HEALTH DEV AN INTERNSHIP REPORT Submitted by ATHUL NAMBIAR (2262041) In partial fulfilment of the requirements for the degree of BACHELOR OF TECHNOLOGY IN COMPUTER SCIENCE AND ENGINEERING (Artificial Intelligence and Machine Learning) UNDER THE GUIDANCE OF PROF. CHAITRA P C Department of Computer Science and Engineering, School of Engineering and Technology CHRIST (Deemed to be University) Kumbalgodu, 560074 August 2025",
+        "page": 1,
+        "section_title": "Introduction",
+        "medical_terms": [],
+        "chunk_type": "general",
+        "relevance_score": 0.0
+      },
+      {
+        "id": "50f6dc85d40b_1",
+        "text": "Department of Computer Science and Engineering School of Engineering and Technology CHRIST (Deemed to be University) BONAFIDE CERTIFICATE This is to certify that ATHUL NAMBIAR (2262041) has successfully completed his summer internship work entitled \u201cSORCOVA HEALTH DEV\u201d in Sorcova Health located at 60 Avenue Charles de Gaulle, 92200 Neuilly-sur-Seine, France from 03-03-2025 to 31-05-2025 for a duration of 3 Months and submitted on 14-08-2025 in partial fulfillment for the award of Bachelor of Technology in Computer Science and Engineering (Artificial Intelligence and Machine Learning) during the academic year . GUIDE (Signature with Date) HEAD OF THE DEPARTMENT (Signature with Seal) EXAMINER 1 (Name & Signature with Date) Examiner 2 (Name & Signature with Date) 2024-2025",
+        "page": 2,
+        "section_title": "Introduction",
+        "medical_terms": [],
+        "chunk_type": "general",
+        "relevance_score": 0.0
+      },
+      {
+        "id": "50f6dc85d40b_2",
+        "text": "ABSTRACT During my internship at Socvova Health as a Fullstack Developer, I gained invaluable experience by contributing to the development of an innovative technology networking platform. I enhanced my skills in advanced backend development, server-side optimisation, and API integration while collaborating with a dynamic team to drive technological innovation and connectivity among global tech enthusiasts. This experience allowed me to apply theoretical knowledge to real-world applications, solidifying my passion for backend development and inspiring me to pursue further innovation in this field. My work involved designing and testing server-side components, optimising performance, and ensuring code quality, which prepared me for future challenges in the tech industry.This hands-on experience not only enriched my technical expertise but also emphasised the importance of innovation and collaboration in the tech industry.",
+        "page": 3,
+        "section_title": "Introduction",
+        "medical_terms": [],
+        "chunk_type": "general",
+        "relevance_score": 0.0
+      },
+      {
+        "id": "50f6dc85d40b_3",
+        "text": "PREFACE During my internship at Socvova Health as a Fullstack Developer from March 03, 2025, to May 31, 2025, I had the opportunity to work with a dynamic team committed to technological innovation. This experience allowed me to apply my theoretical knowledge in Computer Science Engineering to real-world backend development projects. I contributed to the development of a global technology networking platform, enhancing my skills in Node.js and server-side optimisation. Collaborating with visionary leaders and talented colleagues provided invaluable insights into the tech industry, solidifying my passion for backend development and inspiring me to pursue further innovation in this field. This report encapsulates the skills and knowledge I gained, the challenges I encountered, and the solutions I implemented during this transformative period.",
+        "page": 4,
+        "section_title": "Introduction",
+        "medical_terms": [],
+        "chunk_type": "general",
+        "relevance_score": 0.0
+      },
+      {
+        "id": "50f6dc85d40b_4",
+        "text": "INDEX CONTENT PAGE NO. Abstract I Preface II List of Symbols and Abbreviations III List of Figures IV List of Tables V 1 Introduction 1 1.1. Objectives 1 1.2. Company Profile 2 2 Technical Description & Implementation 3 2.1. Actual Work 3 2.1.1. Prerequisites 3 2.1.2. Responsibilities 4 2.1.3. Challenges 4 2.1.4 Implementation Description 4 2.1.5 Methodology 2.2. Learning Outcomes & Key Takeaway 3 Conclusion & Future Scope 5 3.1. Conclusion 5 3.2. Future Scope 5 4 Appendixes A Acceptance letter 7 B Completion Certificate 8 C Code and screenshots 9 5 References 10",
+        "page": 5,
+        "section_title": "Introduction",
+        "medical_terms": [],
+        "chunk_type": "conclusion",
+        "relevance_score": 0.0
+      },
+      {
+        "id": "50f6dc85d40b_5",
+        "text": "1.2 COMPANY PROFILE Sorcova Health is a digital health platform registered in France focused on monitoring mental well-being, managing stress, and implementing personalized prevention strategies to mitigate chronic stress and burnout. Their mission is to address chronic stress, a significant risk factor for various non-communicable diseases, by using preventative health and lifestyle medicine approaches to improve long-term health outcomes and enhance overall quality of life.",
+        "page": 8,
+        "section_title": "4. Troubleshooting and Support: Performed troubles",
+        "medical_terms": [],
+        "chunk_type": "general",
+        "relevance_score": 0.0
+      },
+      {
+        "id": "50f6dc85d40b_6",
+        "text": "2.1.2 RESPONSIBILITIES My responsibilities included: During my internship as a Fullstack Developer at Sorcova Health, my primary responsibilities revolved around the successful execution of assigned tasks within specified deadlines. These tasks included designing, developing, and testing server-side components, ensuring optimal performance of database and front-end requests, and integrating server-side logic with user-side components. I was also responsible for writing clean, efficient, and reusable code, developing APIs as needed, and troubleshooting technical issues independently before seeking assistance. Maintaining consistent communication with my mentor through daily reports was crucial in tracking progress and ensuring alignment with project goals. This proactive approach fostered a sense of self-reliance and resourcefulness, enabling me to contribute effectively to the development of the Sorcova Health platform. Feel free to modify or expand on this as needed to better fit your personal experiences and contributions during your internship.",
+        "page": 10,
+        "section_title": "CHAPTER 2 TECHNICAL DESCRIPTION & IMPLEMENTATION 2",
+        "medical_terms": [],
+        "chunk_type": "general",
+        "relevance_score": 0.0
+      },
+      {
+        "id": "50f6dc85d40b_7",
+        "text": "2.1.3 CHALLENGES I encountered several challenges that tested my problem-solving skills and adaptability. One significant challenge was managing data inconsistencies and ensuring data integrity across the platform. This involved dealing with various data formats and ensuring seamless integration with existing systems. Another challenge was optimising server-side performance to handle high traffic efficiently, which required a deep understanding of backend architecture and careful resource management. Additionally, selecting the appropriate technologies and frameworks for developing scalable backend solutions was a complex task, as it involved balancing performance, security, and maintainability. These challenges, while demanding, provided valuable learning experiences and contributed to my growth as a backend developer. Feel free to adjust or expand on any specific details based on your personal experience during the internship.",
+        "page": 11,
+        "section_title": "CHAPTER 2 TECHNICAL DESCRIPTION & IMPLEMENTATION 2",
+        "medical_terms": [],
+        "chunk_type": "general",
+        "relevance_score": 0.0
+      },
+      {
+        "id": "50f6dc85d40b_8",
+        "text": "2.1.4 IMPLEMENTATION DESCRIPTION During the internship at Sorcova Health, the implementation primarily focused on developing and enhancing a technology networking platform, particularly its backend functionalities and API integrations. The core of the implementation involved leveraging Node.js for server-side development, as evidenced by the server.js file, which sets up the Express.js server, handles routing for users, emails, and comments, and integrates with dbConfigure.js for database connectivity. Key aspects included creating and managing RESTful APIs for various functionalities, such as retrieving, adding, updating, and deleting announcements, with specific endpoints for managing announcement views and counts. The implementation also incorporated real-time communication through Socket.io for features like instant announcement notifications. Database interactions, likely with a SQL database based on the structure of announcement.model.js and the use of SQL queries, were central to managing user data, announcements, and their seen/unseen status.",
+        "page": 12,
+        "section_title": "CHAPTER 2 TECHNICAL DESCRIPTION & IMPLEMENTATION 2",
+        "medical_terms": [],
+        "chunk_type": "general",
+        "relevance_score": 0.0
+      },
+      {
+        "id": "50f6dc85d40b_9",
+        "text": "al-time communication through Socket.io for features like instant announcement notifications. Database interactions, likely with a SQL database based on the structure of announcement.model.js and the use of SQL queries, were central to managing user data, announcements, and their seen/unseen status. Furthermore, the development process involved a focus on code quality, reusability, and performance optimization for both database and front-end requests, aiming to translate Figma designs into functional web applications. API testing was conducted using Postman to ensure the robustness and correctness of the implemented endpoints.",
+        "page": 12,
+        "section_title": "CHAPTER 2 TECHNICAL DESCRIPTION & IMPLEMENTATION 2",
+        "medical_terms": [],
+        "chunk_type": "general",
+        "relevance_score": 0.0
+      },
+      {
+        "id": "50f6dc85d40b_10",
+        "text": "2.1.5 METHODOLOGY The development process at Sorcova Health followed an agile methodology, emphasizing iterative development and continuous feedback to translate Figma workflow designs into functional web applications. Backend development was primarily conducted using Node.js and its Express.js framework for building robust RESTful APIs. For data persistence and retrieval, SQL databases were utilized, with database interactions managed through custom models and direct SQL queries to optimize performance and ensure data integrity. Version control was rigorously maintained using Git, facilitating collaborative development, code merging, and tracking changes. Real-time communication features, such as instant announcement notifications, were implemented using Socket.io. Throughout the implementation, a strong emphasis was placed on writing clean, efficient, and reusable code, while API testing was systematically performed using Postman to validate endpoint functionality and overall system reliability.",
+        "page": 13,
+        "section_title": "CHAPTER 2 TECHNICAL DESCRIPTION & IMPLEMENTATION 2",
+        "medical_terms": [],
+        "chunk_type": "general",
+        "relevance_score": 0.0
+      },
+      {
+        "id": "50f6dc85d40b_11",
+        "text": "C. CODE & SCREEN SHOT server.js require(\"dotenv\").config() var cors = require(\"cors\") const express = require(\"express\") const db = require(\"./configure/dbConfigure.js\") const logger = require(\"./logger\") const bodyParser = require(\"body-parser\") const https = require(\"http\") const { readFileSync } = require(\"fs\") const path = require(\"path\") const userRoutes = require(\"./routes/user\"); const emailRoutes = require(\"./routes/email.js\"); const commentRoutes = require('./routes/comments.js'); const app = express() app.use(bodyParser.json()) app.use(bodyParser.urlencoded({ extended: false, limit: \"2gb\" })) app.use(bodyParser.json({ type: \"application/*+json\" })) const sslserver = https.createServer( { key: readFileSync(path.join(__dirname, \"certs\", \"key.pem\")), cert: readFileSync(path.join(__dirname, \"certs\", \"cert.pem\")), }, app ) global.io = require(\"socket.io\")(sslserver, { cors: { origin: \"*\", methods: [\"GET\", \"POST\"], },",
+        "page": 17,
+        "section_title": "CHAPTER 3 CONCLUSION & FUTURE SCOPE 3.1 CONCLUSION",
+        "medical_terms": [],
+        "chunk_type": "general",
+        "relevance_score": 0.0
+      },
+      {
+        "id": "50f6dc85d40b_12",
+        "text": "}) app.use( cors({ origin: \"*\", }) ) app.use(function (req, res, next) { res.header(\"Access-Control-Allow-Origin\", [\"*\"]) res.header( \"Access-Control-Allow-Headers\", \"Origin,X-Requested-With, Content-Type, Accept\" ) next() }) app.use(express.urlencoded({ extended: true, limit: \"2gb\" })) app.use(express.json()) app.use(\"/users\", userRoutes) app.get(\"/testing\", (req, res) => { res.send(\"Hello Sorcova Healths\").status(200) }) app.get(\"/projection\", (req, res) => { res.send(\"this is the projection page\").status(200) }) app.use(express.static(path.join(__dirname, \"build\"))) //here is important thing - no static directory, because all static :) app.get(\"/*\", function (req, res) { res.sendFile(path.join(__dirname, \"index.html\")) })",
+        "page": 18,
+        "section_title": "CHAPTER 3 CONCLUSION & FUTURE SCOPE 3.1 CONCLUSION",
+        "medical_terms": [],
+        "chunk_type": "general",
+        "relevance_score": 0.0
+      },
+      {
+        "id": "50f6dc85d40b_13",
+        "text": "io.on(\"connection\", (socket) => { socket.on(\"announcementAdded\", () => { console.log(\"New announcement added\") io.emit(\"newAnnouncement\", \"New Announcement!\") }) }) const port = process.env.PORT || 8080 sslserver.listen(port, () => { logger.info(`server started at port : ${port}`) }) app.use('/email',emailRoutes); app.use('/comments', commentRoutes); sslserver.setTimeout(300000) Notification Controller API const AnnouncementsModel = require(\"../models/announcement.model\"); const logger = require(\"../logger\"); exports.socketAnnounce = (req, res) => { const {password} = req.body //Sorcova Health@2023 const hash = \"\" try{ io.emit(\"newAnnouncement\", \"New Announcement!\"); res.status(200).json({status:true, msg:\"announcement emitted\"}) }catch(err){ console.log(err) res.status(500).json({status:false, msg:\"failed to emmit announcement \"}) }",
+        "page": 19,
+        "section_title": "CHAPTER 3 CONCLUSION & FUTURE SCOPE 3.1 CONCLUSION",
+        "medical_terms": [],
+        "chunk_type": "general",
+        "relevance_score": 0.0
+      },
+      {
+        "id": "50f6dc85d40b_14",
+        "text": "} exports.getAllAnnouncements = (req, res) => { const mad_id = req.params.id; AnnouncementsModel.getAllAnnouncements(mad_id,(err, result) => { try { if (err) { logger.error(\"Error: announcements >> error >>\", err); res.json({ response: err, status: { code: \"02\", status: \"failure\", message: \"error in fetching all announcements\", }, }); } else { res.json({ response: result, status: { code: \"00\", status: \"success\", message: \"Fetched all announcements successfully\", }, }); } } catch (err) { logger.error(\"Error: get All announcements >> error >>\", err); } }); }; exports.getAnnouncementById = (req, res) => { const announcement_id = req.params.id AnnouncementsModel.getAnnouncementById(announcement_id, (err, result) => {",
+        "page": 20,
+        "section_title": "CHAPTER 3 CONCLUSION & FUTURE SCOPE 3.1 CONCLUSION",
+        "medical_terms": [],
+        "chunk_type": "general",
+        "relevance_score": 0.0
+      },
+      {
+        "id": "50f6dc85d40b_15",
+        "text": "try { if (err) { logger.error(\"Error: announcements >> error >>\", err); res.json({ response: err, status: { code: \"02\", status: \"failure\", message: \"error in fetching announcement by id\", }, }); } else { res.json({ response: result, status: { code: \"00\", status: \"success\", message: \"Fetched announcement by id successfully\", }, }); } } catch (err) { logger.error(\"Error: get announcement by id >> error >>\", err); } }); }; exports.removeOutdatedAnnouncements = (req, res) => { AnnouncementsModel.removeOutdatedAnnouncements((err, result) => { try { if (err) { logger.error(\"Error: remove outdated announcements >> error >>\", err); res.json({ response: err, status: {",
+        "page": 21,
+        "section_title": "CHAPTER 3 CONCLUSION & FUTURE SCOPE 3.1 CONCLUSION",
+        "medical_terms": [],
+        "chunk_type": "general",
+        "relevance_score": 0.0
+      },
+      {
+        "id": "50f6dc85d40b_16",
+        "text": "code: \"02\", status: \"failure\", message: \"error in deleting expired Documents\", }, }); } else { res.json({ response: result, status: { code: \"00\", status: \"success\", message: \"Deleted outdated announcements successfully\", }, }); } } catch (err) { logger.error(\"Error: outdated announcements >> error >>\", err); } }); }; exports.deleteAnnouncementById = (req, res) => { const announcement_id = req.params.id; AnnouncementsModel.deleteAnnouncementById(announcement_id, (err, result) => { try { if (err) { logger.error(\"Error: remove outdated announcements >> error >>\", err); res.json({ response: err, status: { code: \"02\", status: \"failure\", message: \"error in deleting expired Documents\", }, });",
+        "page": 22,
+        "section_title": "CHAPTER 3 CONCLUSION & FUTURE SCOPE 3.1 CONCLUSION",
+        "medical_terms": [],
+        "chunk_type": "general",
+        "relevance_score": 0.0
+      },
+      {
+        "id": "50f6dc85d40b_17",
+        "text": "} else { res.json({ response: result, status: { code: \"00\", status: \"success\", message: \"Deleted outdated announcements successfully\", }, }); } } catch (err) { logger.error(\"Error: outdated announcements >> error >>\", err); } }); }; exports.getUnseenAnnouncementCount = (req, res) => { const mad_id = req.params.id; AnnouncementsModel.getUnseenAnnouncementCount(mad_id, (err, result) => { try { if (err) { logger.error(\"Error: get unseen announcements count >> error >>\", err); res.json({ response: err, status: { code: \"02\", status: \"failure\", message: \"error getting unseen announcements count\", }, }); } else { res.json({ response: result[0]??null, status: { code: \"00\", status: \"success\",",
+        "page": 23,
+        "section_title": "CHAPTER 3 CONCLUSION & FUTURE SCOPE 3.1 CONCLUSION",
+        "medical_terms": [],
+        "chunk_type": "general",
+        "relevance_score": 0.0
+      },
+      {
+        "id": "50f6dc85d40b_18",
+        "text": "message: \"successfully fetched unseen announcements count\", }, }); } } catch (err) { logger.error(\"Error: get unseen announcements count >> error >>\", err); } }); }; exports.markSeenAnnouncements = (req, res) => { const {announcement_ids, mad_id} = req.body AnnouncementsModel.markSeenAnnouncements(announcement_ids,mad_id, (err, result) => { try { if (err) { logger.error(\"Error: mark seen announcements >> error >>\", err); res.json({ response: err, status: { code: \"02\", status: \"failure\", message: \"error marking seen announcements\", }, }); } else { res.json({ response: result, status: { code: \"00\", status: \"success\", message: \"successfully marked seen announcements\", }, }); } } catch (err) {",
+        "page": 24,
+        "section_title": "CHAPTER 3 CONCLUSION & FUTURE SCOPE 3.1 CONCLUSION",
+        "medical_terms": [],
+        "chunk_type": "general",
+        "relevance_score": 0.0
+      },
+      {
+        "id": "50f6dc85d40b_19",
+        "text": "logger.error(\"Error: mark seen announcements >> error >>\", err); } }); }; DB SQL Model Schema const db = require(\"../configure/dbConfigure\"); const logger = require(\"../logger\"); const Announcements = function (announcement) { this.announcement_id = announcement.announcement_id; this.announcement_type = announcement.announcement_type; this.channel = announcement.channel; this.created_date = announcement.created_date; this.duration = announcement.duration; this.priority = announcement.priority; this.content = announcement.content; }; //old // Announcements.getAllAnnouncements = (mad_id, result) => { // var sql = `SELECT A.*,CASE WHEN Av.mad_id IS NOT NULL THEN 'seen' ELSE 'unseen' END AS seen_status // FROM announcements as A Left Join announcements_views as Av // ON A.announcement_id = Av.announcement_id And Av.mad_id = ${mad_id} // WHERE A.announcement_id NOT IN ( // SELECT announcement_id // FROM announcements // WHERE created_date < NOW() - INTERVAL 30 DAY) // ORDER BY A.created_date DESC;`;",
+        "page": 25,
+        "section_title": "CHAPTER 3 CONCLUSION & FUTURE SCOPE 3.1 CONCLUSION",
+        "medical_terms": [],
+        "chunk_type": "general",
+        "relevance_score": 0.0
+      },
+      {
+        "id": "50f6dc85d40b_20",
+        "text": "// db.query(sql, (err, res) => { // if (err) { // logger.error(err); // result(err, null); // } else { // result(null, res); // } // }); // }; //new - Test pending Announcements.getAllAnnouncements = (mad_id, result) => { var sql = `SELECT A.*, CASE WHEN Av.mad_id IS NOT NULL THEN 'seen' ELSE 'unseen' END AS seen_status FROM announcements AS A LEFT JOIN ( SELECT announcement_id FROM announcements_views WHERE mad_id = ${mad_id} ) AS Av ON A.announcement_id = Av.announcement_id WHERE A.created_date >= NOW() - INTERVAL 30 DAY OR Av.announcement_id IS NOT NULL ORDER BY A.created_date DESC;`; db.query(sql, (err, res) => { if (err) { logger.error(err); result(err, null); } else { result(null, res); } }); }; Announcements.getAnnouncementById = (announcement_id, result) => {",
+        "page": 26,
+        "section_title": "CHAPTER 3 CONCLUSION & FUTURE SCOPE 3.1 CONCLUSION",
+        "medical_terms": [],
+        "chunk_type": "general",
+        "relevance_score": 0.0
+      },
+      {
+        "id": "50f6dc85d40b_21",
+        "text": "const sql = `Select * from announcements where announcement_id = ${announcement_id}`; db.query(sql, (err, res) => { if (err) { logger.error(err); result(err, null); } else { result(null, res); } }); }; Announcements.removeOutdatedAnnouncements = (result) => { const sql = `DELETE from announcements WHERE created_date < NOW() - INTERVAL duration DAY;`; db.query(sql, (err, res) => { if (err) { logger.error(err); result(err, null); } else { result(null, res); } }); }; Announcements.deleteAnnouncementById = (announcement_id, result) => { const sql = `DELETE from announcements WHERE announcement_id = ${announcement_id}`; db.query(sql, (err, res) => { if (err) { logger.error(err); result(err, null); } else { result(null, res); } });",
+        "page": 27,
+        "section_title": "CHAPTER 3 CONCLUSION & FUTURE SCOPE 3.1 CONCLUSION",
+        "medical_terms": [],
+        "chunk_type": "general",
+        "relevance_score": 0.0
+      },
+      {
+        "id": "50f6dc85d40b_22",
+        "text": "}; // old // Announcements.getUnseenAnnouncementCount = (mad_id, result) => { // var sql = `SELECT count(*) as unseenCount // FROM announcements as A // WHERE A.announcement_id NOT IN ( // SELECT announcement_id // FROM announcements // WHERE created_date < NOW() - INTERVAL 30 DAY) // AND Not Exists (select * from announcements_views where announcement_id = A.announcement_id and mad_id = ${mad_id} ) // ORDER BY created_date DESC;`; // db.query(sql, (err, res) => { // if (err) { // logger.error(err); // result(err, null); // } else { // result(null, res); // } // }); // }; //new Announcements.getUnseenAnnouncementCount = (mad_id, result) => { var sql = `SELECT COUNT(*) AS unseenCount FROM announcements AS A LEFT JOIN ( SELECT announcement_id FROM announcements_views WHERE mad_id = ${mad_id} ) AS Av ON A.announcement_id = Av.announcement_id WHERE A.created_date >= NOW() - INTERVAL 30 DAY AND Av.announcement_id IS NULL;`;",
+        "page": 28,
+        "section_title": "CHAPTER 3 CONCLUSION & FUTURE SCOPE 3.1 CONCLUSION",
+        "medical_terms": [],
+        "chunk_type": "general",
+        "relevance_score": 0.0
+      },
+      {
+        "id": "50f6dc85d40b_23",
+        "text": "db.query(sql, (err, res) => { if (err) { logger.error(err); result(err, null); } else { result(null, res); } }); }; Announcements.markSeenAnnouncements = (announcement_ids,mad_id, result) => { var values = announcement_ids.map(announcement_id => `(${announcement_id}, ${mad_id})`).join(', '); var sql = `INSERT INTO announcements_views (announcement_id, mad_id) VALUES ${values}`; db.query(sql, (err, res) => { if (err) { logger.error(err); result(err, null); } else { result(null, res); } }); }; module.exports = Announcements;",
+        "page": 29,
+        "section_title": "CHAPTER 3 CONCLUSION & FUTURE SCOPE 3.1 CONCLUSION",
+        "medical_terms": [],
+        "chunk_type": "general",
+        "relevance_score": 0.0
+      }
+    ]
+  }
+}

rag_core.py

@@ -0,0 +1,685 @@
+#!/usr/bin/env python3
+"""
+QUADRANT RAG Core Module
+Clean RAG implementation without Flask dependencies
+Optimized for both Streamlit and Flask integration
+"""
+
+import os
+import json
+import uuid
+import re
+import time
+from typing import List, Dict, Any, Optional
+from pathlib import Path
+from datetime import datetime, timezone
+
+from dotenv import load_dotenv
+from qdrant_client import QdrantClient
+from qdrant_client.models import Distance, VectorParams, PointStruct, Filter, FieldCondition, MatchValue, PayloadSchemaType
+import openai
+
+# Load environment variables
+load_dotenv()
+
+class DynamicRAG:
+    """
+    Dynamic RAG System with Qdrant Vector Database and OpenAI GPT-4o-mini
+    Real semantic search with proper LLM responses
+    """
+
+    def __init__(self):
+        # Environment variables
+        self.openai_api_key = os.environ.get('OPENAI_API_KEY', 'your-openai-api-key-here')
+        self.use_memory_db = os.environ.get('USE_MEMORY_DB', 'false').lower() == 'true'
+        self.qdrant_url = os.environ.get('QDRANT_URL')
+        self.qdrant_api_key = os.environ.get('QDRANT_API_KEY')
+        self.collection_name = os.environ.get('QDRANT_COLLECTION_NAME', 'documents')
+
+        # Initialize clients
+        self._init_openai()
+        self._init_qdrant()
+        self._init_embedding_model()
+
+        # Ensure collection exists
+        self.ensure_collection()
+
+    def _init_openai(self):
+        """Initialize OpenAI client"""
+        try:
+            if not self.openai_api_key or self.openai_api_key == 'your-openai-api-key-here':
+                print("❌ OpenAI API key not provided. Please set OPENAI_API_KEY environment variable.")
+                self.openai_client = None
+                return
+
+            openai.api_key = self.openai_api_key
+            self.openai_client = openai.OpenAI(api_key=self.openai_api_key)
+            print("✅ OpenAI client initialized")
+        except Exception as e:
+            print(f"⚠️ OpenAI initialization error: {e}")
+            self.openai_client = None
+
+    def _init_qdrant(self):
+        """Initialize Qdrant client with cloud priority"""
+        try:
+            # Configure client timeouts and transport
+            qdrant_timeout = float(os.environ.get('QDRANT_TIMEOUT', '60'))
+            prefer_grpc = os.environ.get('QDRANT_PREFER_GRPC', 'true').lower() == 'true'
+            if self.qdrant_url and self.qdrant_api_key:
+                print(f"🌐 Using Qdrant Cloud: {self.qdrant_url}")
+                self.qdrant_client = QdrantClient(
+                    url=self.qdrant_url,
+                    api_key=self.qdrant_api_key,
+                    timeout=qdrant_timeout,
+                    prefer_grpc=prefer_grpc,
+                )
+            elif self.use_memory_db:
+                print("💾 Using in-memory Qdrant (development only)")
+                self.qdrant_client = QdrantClient(":memory:", timeout=qdrant_timeout)
+            else:
+                # Fallback to local file storage
+                storage_path = os.environ.get('QDRANT_STORAGE_PATH', './qdrant_storage')
+                print(f"🗄️ Using file-based Qdrant storage: {storage_path}")
+                self.qdrant_client = QdrantClient(path=storage_path, timeout=qdrant_timeout)
+
+            print(f"✅ Qdrant client initialized (timeout={qdrant_timeout}s, gRPC preferred={prefer_grpc})")
+        except Exception as e:
+            print(f"❌ Qdrant initialization error: {e}")
+            raise
+
+    def _init_embedding_model(self):
+        """Initialize OpenAI embedding model settings"""
+        try:
+            print("🔄 Configuring OpenAI embeddings...")
+            self.embedding_model_name = 'text-embedding-3-small'
+            self.embedding_size = 1536  # OpenAI text-embedding-3-small dimension
+            # Chat model can be overridden via env; default per user request
+            self.chat_model_name = os.environ.get('OPENAI_COMPLETIONS_MODEL', 'gpt-5-mini')
+            print("✅ OpenAI embeddings configured")
+        except Exception as e:
+            print(f"❌ Embedding configuration error: {e}")
+            raise
+
+    def ensure_collection(self):
+        """Create Qdrant collection if it doesn't exist"""
+        try:
+            collections = self.qdrant_client.get_collections().collections
+            collection_names = [c.name for c in collections]
+
+            if self.collection_name not in collection_names:
+                print(f"🔄 Creating Qdrant collection: {self.collection_name}")
+                self.qdrant_client.create_collection(
+                    collection_name=self.collection_name,
+                    vectors_config=VectorParams(size=self.embedding_size, distance=Distance.COSINE)
+                )
+                print("✅ Collection created")
+            else:
+                print(f"✅ Collection {self.collection_name} already exists")
+                
+            # Create payload index for doc_id to enable filtering
+            try:
+                self.qdrant_client.create_payload_index(
+                    collection_name=self.collection_name,
+                    field_name="doc_id",
+                    field_schema=PayloadSchemaType.KEYWORD
+                )
+                print("✅ Created index for doc_id field")
+            except Exception as e:
+                # Index might already exist, which is fine
+                if "already exists" not in str(e):
+                    print(f"⚠️ Note: Could not create index for doc_id: {e}")
+                    
+        except Exception as e:
+            print(f"⚠️ Error with collection: {e}")
+
+    def create_embeddings(self, texts: List[str]) -> List[List[float]]:
+        """Create embeddings for texts using OpenAI API with batch processing"""
+        # Handle empty texts
+        texts = [text if text.strip() else "empty" for text in texts]
+        
+        # Process in batches to avoid timeout
+        batch_size = 20  # OpenAI recommends smaller batches
+        all_embeddings = []
+        
+        for i in range(0, len(texts), batch_size):
+            batch = texts[i:i + batch_size]
+            retries = 3
+            
+            while retries > 0:
+                try:
+                    # Create embeddings for this batch
+                    response = self.openai_client.embeddings.create(
+                        model=self.embedding_model_name,
+                        input=batch
+                    )
+                    
+                    # Extract embedding vectors
+                    batch_embeddings = [data.embedding for data in response.data]
+                    all_embeddings.extend(batch_embeddings)
+                    
+                    # Show progress
+                    progress = min(i + batch_size, len(texts))
+                    print(f"  ✅ Processed {progress}/{len(texts)} texts")
+                    break
+                    
+                except Exception as e:
+                    retries -= 1
+                    if retries > 0:
+                        print(f"  ⚠️ Retry {3-retries}/3 for batch {i//batch_size + 1}: {str(e)}")
+                        time.sleep(2)  # Wait before retry
+                    else:
+                        print(f"  ❌ Failed batch {i//batch_size + 1}: {str(e)}")
+                        # Return zero vectors for failed batch
+                        all_embeddings.extend([[0.0] * self.embedding_size for _ in batch])
+        
+        return all_embeddings
+
+    def store_document(self, doc_id: str, chunks: List[Dict[str, Any]]):
+        """Store document chunks in Qdrant with embeddings"""
+        print(f"🔄 Processing {len(chunks)} chunks...")
+        
+        # Check if chunks already exist for this document
+        try:
+            existing = self.qdrant_client.scroll(
+                collection_name=self.collection_name,
+                scroll_filter=Filter(
+                    must=[FieldCondition(key="doc_id", match=MatchValue(value=doc_id))]
+                ),
+                limit=1
+            )
+            if existing[0]:
+                print(f"⚠️ Document {doc_id} already exists. Skipping...")
+                return
+        except:
+            pass  # Collection might be empty
+        
+        print(f"🧠 Creating embeddings for {len(chunks)} chunks...")
+        texts = [chunk['text'] for chunk in chunks]
+        embeddings = self.create_embeddings(texts)
+
+        print(f"📦 Preparing vectors for storage...")
+        points = []
+        upload_time = datetime.now(timezone.utc).isoformat()
+        
+        for i, (chunk, embedding) in enumerate(zip(chunks, embeddings)):
+            # Generate a proper UUID for each point
+            point_id = str(uuid.uuid4())
+            point = PointStruct(
+                id=point_id,
+                vector=embedding,
+                payload={
+                    "doc_id": doc_id,
+                    "chunk_id": i,
+                    "text": chunk['text'],
+                    "page": chunk['page'],
+                    "section": chunk.get('section', 'Unknown'),
+                    "upload_time": upload_time
+                }
+            )
+            points.append(point)
+
+        # Store in batches with retry and adaptive downsizing on timeout
+        default_batch_size = int(os.environ.get('QDRANT_UPSERT_BATCH', '32'))
+        i = 0
+        batch_index = 0
+        while i < len(points):
+            batch_size = min(default_batch_size, len(points) - i)
+            batch = points[i:i + batch_size]
+            attempts = 0
+            while attempts < 3:
+                try:
+                    self.qdrant_client.upsert(
+                        collection_name=self.collection_name,
+                        points=batch,
+                    )
+                    batch_index += 1
+                    print(f"📦 Stored batch {batch_index}/{(len(points)+default_batch_size-1)//default_batch_size} ({len(batch)} points)")
+                    i += batch_size
+                    break
+                except Exception as e:
+                    attempts += 1
+                    if 'Timeout' in str(e) or 'timed out' in str(e):
+                        # Halve the batch size and retry
+                        new_size = max(5, batch_size // 2)
+                        print(f"⚠️ Upsert timeout. Reducing batch from {batch_size} to {new_size} and retrying ({attempts}/3)...")
+                        batch_size = new_size
+                        batch = points[i:i + batch_size]
+                        time.sleep(1.0)
+                        continue
+                    else:
+                        print(f"❌ Upsert error on batch starting at {i}: {e}")
+                        raise
+
+        print(f"✅ Stored {len(chunks)} chunks in Qdrant")
+
+    def get_all_documents(self) -> List[Dict[str, Any]]:
+        """Retrieve all unique documents from Qdrant with metadata"""
+        try:
+            print("🔄 Fetching all documents from Qdrant...")
+            
+            # Use scroll to get all points
+            all_points = []
+            offset = None
+            limit = 100
+            
+            while True:
+                records, next_offset = self.qdrant_client.scroll(
+                    collection_name=self.collection_name,
+                    limit=limit,
+                    offset=offset,
+                    with_payload=True,
+                    with_vectors=False
+                )
+                
+                all_points.extend(records)
+                
+                if next_offset is None:
+                    break
+                    
+                offset = next_offset
+            
+            # Group by doc_id to get unique documents
+            documents = {}
+            for point in all_points:
+                doc_id = point.payload.get('doc_id')
+                if doc_id and doc_id not in documents:
+                    # Initialize document info
+                    documents[doc_id] = {
+                        'doc_id': doc_id,
+                        'title': doc_id.replace('_', ' ').replace('.pdf', ''),
+                        'chunks': 0,
+                        'pages': set(),
+                        'upload_time': point.payload.get('upload_time', 'Unknown')
+                    }
+                
+                if doc_id:
+                    # Update chunk count and pages
+                    documents[doc_id]['chunks'] += 1
+                    page = point.payload.get('page', 0)
+                    if page:
+                        documents[doc_id]['pages'].add(page)
+            
+            # Convert to list and finalize
+            result = []
+            for doc_id, doc_info in documents.items():
+                doc_info['pages'] = len(doc_info['pages'])  # Convert set to count
+                result.append(doc_info)
+            
+            # Sort by upload time (newest first)
+            result.sort(key=lambda x: x.get('upload_time', ''), reverse=True)
+            
+            print(f"✅ Found {len(result)} documents in Qdrant")
+            return result
+            
+        except Exception as e:
+            print(f"❌ Error retrieving documents: {e}")
+            return []
+    
+    def delete_document(self, doc_id: str) -> bool:
+        """Delete all chunks for a specific document"""
+        try:
+            print(f"🗑️ Deleting document {doc_id}...")
+            
+            self.qdrant_client.delete(
+                collection_name=self.collection_name,
+                points_selector=Filter(
+                    must=[FieldCondition(key="doc_id", match=MatchValue(value=doc_id))]
+                )
+            )
+            
+            print(f"✅ Deleted document {doc_id}")
+            return True
+            
+        except Exception as e:
+            print(f"❌ Error deleting document: {e}")
+            return False
+
+    def search(self, query: str, doc_id: str, top_k: int = 10) -> List[Dict[str, Any]]:
+        """Search for relevant chunks using vector similarity with improved retrieval"""
+        print(f"🔍 Searching for: '{query}'")
+
+        # Expand query for better medical term matching
+        expanded_query = self.expand_query(query)
+        print(f"🔍 Expanded query: '{expanded_query}'")
+
+        # Primary search with expanded query
+        results = self._perform_search(expanded_query, doc_id, top_k)
+
+        # If no good results, try fallback searches
+        if not results or len([r for r in results if r['score'] > 0.15]) == 0:
+            print("🔍 Trying fallback search with key terms...")
+            # Extract key medical terms for fallback search
+            key_terms = self._extract_key_terms(query)
+            for term in key_terms:
+                fallback_results = self._perform_search(term, doc_id, top_k//2)
+                results.extend(fallback_results)
+
+        # Remove duplicates and sort by score
+        seen_chunks = set()
+        unique_results = []
+        for result in results:
+            chunk_key = f"{result['chunk_id']}_{result['page']}"
+            if chunk_key not in seen_chunks:
+                seen_chunks.add(chunk_key)
+                unique_results.append(result)
+
+        # Sort by score descending
+        unique_results.sort(key=lambda x: x['score'], reverse=True)
+
+        # Filter results with minimum relevance score - very lenient threshold
+        filtered_results = [r for r in unique_results if r['score'] > 0.10]
+        print(f"📊 Found {len(filtered_results)} relevant chunks (score > 0.10)")
+
+        # If still no results, return top 5 results anyway for fallback
+        if not filtered_results and unique_results:
+            filtered_results = unique_results[:5]
+            print(f"📊 No high-relevance chunks found, using top {len(filtered_results)} results as fallback")
+
+        return filtered_results[:top_k]
+
+    def _perform_search(self, query: str, doc_id: str, limit: int) -> List[Dict[str, Any]]:
+        """Perform a single search operation"""
+        query_embedding = self.create_embeddings([query])[0]
+
+        # If doc_id is 'any' or we want to search all documents, don't filter
+        if doc_id == 'any':
+            search_results = self.qdrant_client.query_points(
+                collection_name=self.collection_name,
+                query=query_embedding,
+                limit=limit,
+                with_payload=True
+            )
+        else:
+            # Filter strictly by the provided doc_id; fallback to no filter on error
+            try:
+                search_results = self.qdrant_client.query_points(
+                    collection_name=self.collection_name,
+                    query=query_embedding,
+                    query_filter=Filter(
+                        must=[FieldCondition(key="doc_id", match=MatchValue(value=doc_id))]
+                    ),
+                    limit=limit,
+                    with_payload=True
+                )
+            except Exception:
+                search_results = self.qdrant_client.query_points(
+                    collection_name=self.collection_name,
+                    query=query_embedding,
+                    limit=limit,
+                    with_payload=True
+                )
+
+        results = []
+        for result in search_results.points:
+            results.append({
+                "text": result.payload["text"],
+                "page": result.payload["page"],
+                "section": result.payload["section"],
+                "score": float(result.score),
+                "chunk_id": result.payload["chunk_id"],
+                "doc_id": result.payload.get("doc_id", "unknown")
+            })
+        return results
+
+    def _extract_key_terms(self, query: str) -> List[str]:
+        """Extract key medical terms from query for fallback search"""
+        # Extract important terms
+        terms = []
+
+        # Medical abbreviations and key terms
+        medical_terms = ["acidosis", "RTA", "anion gap", "metabolic", "urine pH", "differential", "MUDPILES", "GOLDMARK"]
+
+        query_lower = query.lower()
+        for term in medical_terms:
+            if term.lower() in query_lower:
+                terms.append(term)
+
+        return terms[:3]  # Return top 3 terms
+
+    def expand_query(self, query: str) -> str:
+        """Expand query with synonyms and related terms for better search"""
+        # Common medical and general expansions
+        expansions = {
+            "fuo": "fever unknown origin fever of unknown origin pyrexia unexplained fever",
+            "classic": "classical traditional standard typical",
+            "nosocomial": "hospital acquired healthcare associated hospital-acquired",
+            "neutropenic": "neutropenia immunocompromised low neutrophil count",
+            "hiv": "human immunodeficiency virus AIDS HIV-associated",
+            "diagnostic": "diagnosis workup evaluation investigation",
+            "pet/ct": "PET-CT positron emission tomography computed tomography PET scan",
+            "pet": "positron emission tomography PET scan PET-CT",
+            "workup": "work up evaluation investigation diagnostic approach",
+            "first-line": "initial primary first line baseline",
+            "imaging": "radiologic radiology scan imaging studies",
+            "labs": "laboratory tests blood work investigations",
+            "categories": "types classifications groups subtypes",
+            "major": "main primary principal important key"
+        }
+
+        expanded = query.lower()
+        for term, expansion in expansions.items():
+            if term.lower() in expanded:
+                expanded = expanded.replace(term.lower(), f"{term.lower()} {expansion}")
+
+        return expanded
+
+    def generate_answer(self, query: str, context_chunks: List[Dict[str, Any]]) -> str:
+        """Generate answer using OpenAI GPT-4o-mini with improved context"""
+        print(f"🧠 generate_answer called with {len(context_chunks)} chunks")
+
+        if not self.openai_client:
+            print("❌ OpenAI client not initialized")
+            return "OpenAI client not initialized. Please check your API key."
+
+        if not context_chunks:
+            print("❌ No context chunks provided")
+            return "I couldn't find any relevant information in the document to answer your question."
+
+        # Use fewer but more relevant chunks with size limit
+        relevant_chunks = [chunk for chunk in context_chunks if chunk['score'] > 0.3][:5]
+        if not relevant_chunks:
+            relevant_chunks = context_chunks[:3]  # Fallback to top 3
+
+        context_parts = []
+        total_length = 0
+        max_context_length = 8000  # Limit context to 8K characters
+
+        # Derive source names from doc_id (strip trailing timestamp if present)
+        source_names = []
+        seen_sources = set()
+        for chunk in relevant_chunks:
+            doc_id = chunk.get('doc_id', 'unknown')
+            base = doc_id.rsplit('_', 1)[0] if '_' in doc_id else doc_id
+            if base and base not in seen_sources:
+                seen_sources.add(base)
+                source_names.append(base)
+
+        for chunk in relevant_chunks:
+            chunk_text = f"[Page {chunk['page']}, Score: {chunk['score']:.3f}] {chunk['text'][:1000]}..."
+            if total_length + len(chunk_text) > max_context_length:
+                break
+            context_parts.append(chunk_text)
+            total_length += len(chunk_text)
+
+        # Prepend sources and page summary to aid citations
+        sources_header = "; ".join(source_names) if source_names else "Unknown source"
+        page_list = sorted({c['page'] for c in relevant_chunks if 'page' in c})
+        pages_summary = ", ".join(str(p) for p in page_list)
+        context = (
+            f"Sources: {sources_header}\n"
+            f"Pages in retrieved context: {pages_summary}\n\n"
+            + "\n\n".join(context_parts)
+        )
+
+        print(f"📄 Context length: {len(context)} characters")
+        print(f"🔍 First chunk preview: {context_chunks[0]['text'][:100]}...")
+
+        # New system prompt (per user specification) + user content with context
+        system_prompt = (
+            "# Role and Objective\n"
+            "You are a senior medical tutor specializing in preparing students for Indian medical entrance exams (NEET-PG, INI-CET, FMGE).\n"
+            "# Instructions\n"
+            "- Always answer strictly based on information from standard textbooks (e.g., Harrison, Robbins, Bailey & Love, DC Dutta, Shaw, Park, Ganong, Guyton).\n"
+            "- If there is insufficient data available in these textbooks, respond: “Insufficient evidence from standard textbooks.”\n"
+            "- Do not fabricate or introduce non-standard material into your answers.\n"
+            "- Begin with a concise checklist (3-5 bullets) outlining the conceptual steps you will use to construct your answer (e.g., identify relevant information, reference textbooks, analyze options, format answer, cite sources).\n"
+            "## Output Format\n"
+            "- **Explanation:**\n"
+            "- Start with why the correct answer fits, using textbook references to support your explanation.\n"
+            "- **Why other options are wrong:**\n"
+            "- Briefly rule out each incorrect choice with textbook-based reasoning.\n"
+            "- **Clinical Pearl:**\n"
+            "- Highlight clinical pearls (e.g., “physiologic leucorrhea never causes pruritus,” “most common site of endometriosis = ovary”) as appropriate.\n"
+            "- **References:**\n"
+            "- Cite the textbook name, edition, and page number (if available). Place this section at the end of the answer, after all explanations and pearls.\n"
+            "- Keep explanations exam-friendly, high-yield, and structured (use short paragraphs or bullet points).\n"
+            "- If an image is provided, integrate it naturally into the reasoning but do not describe the image explicitly—only use it as a supportive clue.\n"
+            "- Keep answers concise but concept-rich, resembling a mini textbook explanation rather than a long essay.\n"
+            "## Reasoning Effort & Validation\n"
+            "- Set reasoning_effort=medium to ensure thorough but efficient explanations appropriate for exam-level concepts.\n"
+            "- After drafting the response, quickly validate whether all parts are completed as per the Output Format; if any part is missing or insufficiently referenced, self-correct before finalizing the answer."
+        )
+
+        user_content = (
+            f"Document Context (textbook excerpts):\n{context}\n\n"
+            f"Question: {query}\n\n"
+            "Use only the provided excerpts. When citing, include textbook name and exact page from the pages listed above."
+        )
+
+        try:
+            print("🔄 Making OpenAI API call...")
+            params = {
+                "model": self.chat_model_name,
+                "messages": [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_content},
+                ],
+            }
+            # gpt-5 models expect 'max_completion_tokens'; older models use 'max_tokens'
+            if str(self.chat_model_name).startswith("gpt-5"):
+                params["max_completion_tokens"] = 1500
+            else:
+                params["max_tokens"] = 1500
+                params["temperature"] = 0.0
+
+            response = self.openai_client.chat.completions.create(**params)
+
+            # Try to extract text safely
+            text = ""
+            try:
+                text = (response.choices[0].message.content or "").strip()
+            except Exception:
+                text = ""
+
+            # Fallback to Responses API when empty
+            if not text:
+                try:
+                    combined_input = system_prompt + "\n\n" + user_content
+                    resp2 = self.openai_client.responses.create(
+                        model=self.chat_model_name,
+                        input=combined_input,
+                        max_output_tokens=1500 if str(self.chat_model_name).startswith("gpt-5") else None,
+                    )
+                    if hasattr(resp2, "output_text") and resp2.output_text:
+                        text = resp2.output_text.strip()
+                    elif hasattr(resp2, "choices") and resp2.choices:
+                        m = getattr(resp2.choices[0], "message", None)
+                        if m and getattr(m, "content", None):
+                            text = m.content.strip()
+                except Exception as e2:
+                    print(f"⚠️ Responses API fallback error: {e2}")
+
+            if not text:
+                raise RuntimeError("Empty response content from model")
+
+            print(f"✅ OpenAI response received: {len(text)} characters")
+            print(f"📝 Answer preview: {text[:100]}...")
+            return text
+
+        except Exception as e:
+            print(f"❌ OpenAI API error: {e}")
+            error_message = f"I found relevant information but couldn't generate a proper response due to an API error: {str(e)}"
+            if context_chunks:
+                error_message += f"\n\nHere's what I found: {context_chunks[0]['text'][:300]}... [Page {context_chunks[0]['page']}]"
+            return error_message
+
+
+def extract_pdf_pages(pdf_path: str) -> List[str]:
+    """Extract text from PDF pages"""
+    try:
+        import pypdf
+        reader = pypdf.PdfReader(pdf_path)
+        pages = []
+        for page in reader.pages:
+            try:
+                text = page.extract_text() or ""
+                text = text.strip()
+                if text:
+                    pages.append(text)
+            except:
+                continue
+        return pages
+    except Exception as e:
+        print(f"PDF extraction error: {e}")
+        return []
+
+
+def create_chunks(pages: List[str], chunk_size: int = 3000, overlap: int = 500) -> List[Dict[str, Any]]:
+    """Create overlapping chunks from pages with optimized sizing"""
+    chunks = []
+    
+    print(f"📄 Processing {len(pages)} pages into chunks...")
+    
+    for page_num, page_text in enumerate(pages, 1):
+        if len(page_text) < 100:  # Skip very short pages
+            continue
+        
+        # For very long pages, split into smaller sections
+        if len(page_text) > chunk_size * 2:
+            # Split by paragraphs (double newline)
+            paragraphs = page_text.split('\n\n')
+            current_chunk = ""
+            
+            for para in paragraphs:
+                para = para.strip()
+                if not para:
+                    continue
+                
+                # If adding this paragraph exceeds chunk size, save current chunk
+                if len(current_chunk) + len(para) > chunk_size and current_chunk:
+                    chunk_text = current_chunk.strip()
+                    if len(chunk_text) > 200:  # Only save substantial chunks
+                        chunks.append({
+                            "text": chunk_text,
+                            "page": page_num,
+                            "section": f"Page {page_num}"
+                        })
+                    
+                    # Keep last part for context
+                    words = current_chunk.split()
+                    if len(words) > 100:
+                        overlap_text = ' '.join(words[-100:])
+                        current_chunk = overlap_text + "\n\n" + para
+                    else:
+                        current_chunk = para
+                else:
+                    current_chunk += "\n\n" + para if current_chunk else para
+            
+            # Add remaining content
+            if current_chunk.strip() and len(current_chunk.strip()) > 200:
+                chunks.append({
+                    "text": current_chunk.strip(),
+                    "page": page_num,
+                    "section": f"Page {page_num}"
+                })
+        else:
+            # For shorter pages, add the whole page as one chunk
+            if len(page_text.strip()) > 200:
+                chunks.append({
+                    "text": page_text.strip(),
+                    "page": page_num,
+                    "section": f"Page {page_num}"
+                })
+    
+    print(f"✅ Created {len(chunks)} chunks from {len(pages)} pages")
+    return chunks

requirements.txt

@@ -0,0 +1,7 @@
+streamlit>=1.28.0
+pypdf>=4.2.0
+qdrant-client>=1.7.0
+openai>=1.0.0
+python-dotenv>=1.0.0
+PyMuPDF>=1.23.0
+Pillow>=10.0.0

scripts/push_to_hf.sh

@@ -0,0 +1,65 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Simple deploy helper to push the current repo to a Hugging Face Space.
+# Usage:
+#   HF_USER=athulnambiar HF_SPACE=pyqsprag HF_TOKEN=hf_xxx ./scripts/push_to_hf.sh
+# Optional:
+#   BRANCH=main  QDRYRUN=1
+
+HF_USER=${HF_USER:-}
+HF_SPACE=${HF_SPACE:-}
+HF_TOKEN=${HF_TOKEN:-}
+BRANCH=${BRANCH:-main}
+
+if [[ -z "${HF_USER}" || -z "${HF_SPACE}" || -z "${HF_TOKEN}" ]]; then
+  echo "ERROR: Please set HF_USER, HF_SPACE, and HF_TOKEN environment variables." >&2
+  echo "Example: HF_USER=athulnambiar HF_SPACE=pyqsprag HF_TOKEN=hf_*** ./scripts/push_to_hf.sh" >&2
+  exit 1
+fi
+
+repo_url="https://${HF_USER}:${HF_TOKEN}@huggingface.co/spaces/${HF_USER}/${HF_SPACE}"
+
+workdir=$(mktemp -d)
+echo "Cloning Space into: ${workdir}" >&2
+git clone "${repo_url}" "${workdir}/space"
+
+# Ensure branch exists and is checked out
+pushd "${workdir}/space" >/dev/null
+git checkout -B "${BRANCH}"
+popd >/dev/null
+
+# Sync files from current repo into the Space, excluding local/dev artifacts
+rsync -av --delete \
+  --exclude ".git" \
+  --exclude ".venv" \
+  --exclude "__pycache__/" \
+  --exclude "qdrant_storage/" \
+  --exclude "uploads/" \
+  --exclude ".env" \
+  --exclude ".claude/" \
+  --exclude ".streamlit/secrets.toml" \
+  ./ "${workdir}/space/"
+
+pushd "${workdir}/space" >/dev/null
+
+# Make sure Streamlit apps deploy on Spaces
+if [[ ! -f requirements.txt ]]; then
+  echo "streamlit>=1.28.0" > requirements.txt
+fi
+
+# Commit and push
+git add -A
+if git diff --cached --quiet; then
+  echo "No changes to push."
+else
+  git commit -m "Deploy from QUADRANT_RAG"
+  if [[ "${QDRYRUN:-}" == "1" ]]; then
+    echo "Dry run enabled; skipping push." >&2
+  else
+    git push -u origin "${BRANCH}"
+  fi
+fi
+
+echo "Deploy complete. Space: https://huggingface.co/spaces/${HF_USER}/${HF_SPACE}" >&2
+