Add RAG Document Summarizer application

.dockerignore

@@ -0,0 +1,69 @@
+# Git
+.git
+.gitignore
+
+# Python
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+env
+pip-log.txt
+pip-delete-this-directory.txt
+.tox
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.log
+.git
+.mypy_cache
+.pytest_cache
+.hypothesis
+
+# Virtual environments
+venv/
+env/
+ENV/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Project specific
+uploaded_docs/*
+!uploaded_docs/.gitkeep
+offload/*
+!offload/.gitkeep
+*.zip
+*.pdf
+*.docx
+*.pptx
+
+# Docker
+.dockerignore
+
+# Documentation
+README.md
+IMPROVEMENTS.md
+*.md
+
+# Deployment scripts
+deploy.*
+
+pytesseract 

Dockerfile

@@ -0,0 +1,38 @@
+# Use official Python image
+FROM python:3.10-slim
+
+# System dependencies for OCR and PDF processing
+RUN apt-get update && \
+    apt-get install -y tesseract-ocr poppler-utils curl unzip libgl1 libglib2.0-0 && \
+    rm -rf /var/lib/apt/lists/*
+
+# Set workdir
+WORKDIR /app
+
+# Copy application code
+COPY app/ ./app
+COPY requirements.txt .
+RUN mkdir -p ./uploaded_docs
+
+# Install Python dependencies
+RUN pip install --upgrade pip && pip install -r requirements.txt
+
+# Download and install ngrok
+RUN curl -s https://bin.equinox.io/c/bNyj1mQVY4c/ngrok-v3-stable-linux-amd64.tgz | tar -xz -C /usr/local/bin
+
+# Expose FastAPI and ngrok dashboard ports
+EXPOSE 8000 4040
+
+# Copy entrypoint script
+COPY --from=busybox:latest /bin/sh /bin/sh
+COPY --from=busybox:latest /bin/sleep /bin/sleep
+
+# Entrypoint script to start both FastAPI and ngrok
+COPY docker-entrypoint.sh /docker-entrypoint.sh
+RUN chmod +x /docker-entrypoint.sh
+
+# Set environment variables (ngrok authtoken and Mistral API key can be set at runtime)
+ENV NGROK_AUTHTOKEN=""
+ENV MISTRAL_API_KEY=""
+
+ENTRYPOINT ["/docker-entrypoint.sh"]

README.md

@@ -1,12 +1,41 @@
 ---
-title: Doc Summarizer
-emoji: 😻
-colorFrom: pink
-colorTo: blue
+title: RAG Document Summarizer
+emoji: 📄
+colorFrom: blue
+colorTo: purple
 sdk: docker
 pinned: false
-license: apache-2.0
-short_description: AI document summarizer
+license: mit
+short_description: Advanced AI-powered document summarization and question answering using RAG
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# RAG Document Summarizer
+
+A modern, production-ready Retrieval-Augmented Generation (RAG) application for document summarization and question answering. Built with FastAPI, LangChain, and Mistral AI API, this project enables advanced document processing, chunking, vector search, and AI-powered summarization and querying.
+
+## Features
+- **Document Upload:** Supports PDF, DOCX, PPTX, and TXT files
+- **OCR Support:** Extracts text from scanned PDFs using Tesseract OCR
+- **Chunking:** Splits documents into manageable chunks for efficient processing
+- **Vector Store:** Embeds and stores chunks for fast similarity search
+- **AI Summarization:** Uses Mistral AI API for high-quality summaries and answers
+- **Modern UI:** Clean, responsive web interface
+
+## How to Use
+1. Upload your documents (PDF, DOCX, PPTX, TXT)
+2. The system will automatically process and chunk your documents
+3. Ask questions about your documents using the query interface
+4. Get AI-powered summaries and answers based on your document content
+
+## Technical Stack
+- **Backend:** FastAPI, Python 3.10+
+- **AI/ML:** LangChain, Mistral AI API, Sentence Transformers
+- **Vector Database:** ChromaDB
+- **Document Processing:** PyPDF2, pdfplumber, unstructured, pytesseract
+- **Frontend:** Modern HTML/CSS/JavaScript with Tailwind CSS
+
+## Environment Variables
+- `MISTRAL_API_KEY`: Required for AI-powered features (get from [Mistral AI](https://mistral.ai/))
+
+## License
+MIT License

app/__init__.py

@@ -0,0 +1 @@
+# This file makes the app directory a Python package 

app/chunking.py

@@ -0,0 +1,33 @@
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.schema import Document
+
+def chunk_text(text: str, chunk_size: int = 1000, chunk_overlap: int = 200) -> list:
+    """
+    Split text into chunks using RecursiveCharacterTextSplitter
+    
+    Args:
+        text: Text to split into chunks
+        chunk_size: Size of each chunk
+        chunk_overlap: Overlap between chunks
+        
+    Returns:
+        List of text chunks
+    """
+    try:
+        if not text or not text.strip():
+            print("[WARNING] Empty or None text provided for chunking")
+            return []
+        
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=chunk_size,
+            chunk_overlap=chunk_overlap,
+            length_function=len,
+        )
+        
+        chunks = text_splitter.split_text(text)
+        print(f"[INFO] Created {len(chunks)} chunks from text")
+        return chunks
+    except Exception as e:
+        print(f"[ERROR] Text chunking failed: {e}")
+        # Return the original text as a single chunk as fallback
+        return [text] if text else [] 

app/document_loader.py

@@ -0,0 +1,419 @@
+from langchain_community.document_loaders import PyPDFLoader, PDFPlumberLoader, UnstructuredPDFLoader, PyMuPDFLoader
+from langchain_community.document_loaders import UnstructuredPowerPointLoader
+from langchain_community.document_loaders import UnstructuredWordDocumentLoader
+from langchain_community.document_loaders import TextLoader
+from langchain.schema import Document
+import os
+import fitz  # PyMuPDF
+import pytesseract
+from PIL import Image
+import io
+import numpy as np
+import cv2
+from pdf2image import convert_from_path
+import tempfile
+import shutil
+
+class DocumentLoader:
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+        self.extension = os.path.splitext(file_path)[1].lower()
+
+    def load(self):
+        """Load documents with enhanced PDF processing for scanned documents"""
+        try:
+            if self.extension == ".pdf":
+                return self._load_pdf_with_ocr()
+            elif self.extension == ".pptx":
+                return UnstructuredPowerPointLoader(self.file_path).load()
+            elif self.extension == ".docx":
+                return UnstructuredWordDocumentLoader(self.file_path).load()
+            elif self.extension == ".txt":
+                return TextLoader(self.file_path).load()
+            else:
+                raise ValueError(f"Unsupported file type: {self.extension}")
+        except Exception as e:
+            print(f"[ERROR] Document loading failed for {self.file_path}: {e}")
+            # Return a basic error document
+            return [Document(
+                page_content=f"Error loading document: {str(e)}. Please ensure the file is not corrupted and is in a supported format.",
+                metadata={"page": 1, "source": self.file_path, "error": str(e)}
+            )]
+
+    def _load_pdf_with_ocr(self):
+        """Enhanced PDF loading with OCR support for scanned documents"""
+        try:
+            # First, try to extract text using PyMuPDF (most reliable for text-based PDFs)
+            print(f"[INFO] Attempting to extract text using PyMuPDF...")
+            documents = self._extract_text_with_pymupdf()
+            
+            # Check if we got meaningful text content
+            total_text = " ".join([doc.page_content for doc in documents])
+            if len(total_text.strip()) > 50:  # If we have substantial text, use it
+                print(f"[INFO] Successfully extracted {len(total_text)} characters using PyMuPDF")
+                return documents
+            
+            # If text extraction failed or returned minimal content, try OCR
+            print(f"[INFO] Text extraction returned minimal content ({len(total_text)} chars). Attempting OCR...")
+            documents = self._extract_text_with_ocr()
+            
+            if documents:
+                total_text = " ".join([doc.page_content for doc in documents])
+                print(f"[INFO] Successfully extracted {len(total_text)} characters using OCR")
+                return documents
+            
+            # If OCR also fails, try other PDF loaders as fallback
+            print(f"[INFO] OCR failed. Trying alternative PDF loaders...")
+            documents = self._try_alternative_pdf_loaders()
+            
+            if documents:
+                total_text = " ".join([doc.page_content for doc in documents])
+                print(f"[INFO] Successfully extracted {len(total_text)} characters using alternative loaders")
+                return documents
+            
+            # If all methods fail, create a placeholder document with instructions
+            print(f"[WARNING] All text extraction methods failed. Creating placeholder document.")
+            return [Document(
+                page_content="This appears to be a scanned document or image-based PDF. To enable full text extraction, please install Tesseract OCR. For now, you can still use the document for basic operations.",
+                metadata={"page": 1, "source": self.file_path, "method": "placeholder"}
+            )]
+            
+        except Exception as e:
+            print(f"[ERROR] PDF processing failed: {e}")
+            # Final fallback to basic PDF loader
+            return PyPDFLoader(self.file_path).load()
+
+    def _extract_text_with_pymupdf(self):
+        """Extract text using PyMuPDF (handles most PDF types well)"""
+        try:
+            doc = fitz.open(self.file_path)
+            documents = []
+            
+            for page_num in range(len(doc)):
+                page = doc.load_page(page_num)
+                
+                # Try to extract text
+                text = page.get_text()
+                
+                # If text is empty or very short, try to get text with more options
+                if not text or len(text.strip()) < 10:
+                    text = page.get_text("text")
+                
+                # If still no text, try to get text with layout preservation
+                if not text or len(text.strip()) < 10:
+                    text = page.get_text("dict")
+                    # Extract text from the dict structure
+                    if "blocks" in text:
+                        text_content = []
+                        for block in text["blocks"]:
+                            if "lines" in block:
+                                for line in block["lines"]:
+                                    for span in line["spans"]:
+                                        text_content.append(span["text"])
+                        text = " ".join(text_content)
+                
+                if text and len(text.strip()) > 0:
+                    documents.append(Document(
+                        page_content=text.strip(),
+                        metadata={"page": page_num + 1, "source": self.file_path}
+                    ))
+            
+            doc.close()
+            return documents
+            
+        except Exception as e:
+            print(f"[WARNING] PyMuPDF extraction failed: {e}")
+            return []
+
+    def _extract_text_with_ocr(self):
+        """Extract text from scanned PDFs using OCR"""
+        try:
+            # Check if Tesseract is available and configure it
+            try:
+                import pytesseract
+                
+                # Set Tesseract executable path explicitly
+                tesseract_path = r"C:\Program Files\Tesseract-OCR\tesseract.exe"
+                if os.path.exists(tesseract_path):
+                    pytesseract.pytesseract.tesseract_cmd = tesseract_path
+                    print(f"[INFO] Tesseract found at: {tesseract_path}")
+                else:
+                    # Try to find tesseract in PATH
+                    import subprocess
+                    try:
+                        result = subprocess.run(['tesseract', '--version'], capture_output=True, text=True)
+                        if result.returncode == 0:
+                            print("[INFO] Tesseract found in PATH")
+                        else:
+                            raise Exception("Tesseract not found in PATH")
+                    except:
+                        raise Exception("Tesseract executable not found")
+                
+                # Test if tesseract is working
+                version = pytesseract.get_tesseract_version()
+                print(f"[INFO] Tesseract version: {version}")
+                
+            except Exception as e:
+                print(f"[WARNING] Tesseract not available: {e}")
+                print("[INFO] Skipping OCR - Tesseract needs to be installed for OCR functionality")
+                return []
+            
+            # Convert PDF to images
+            print(f"[INFO] Converting PDF to images for OCR...")
+            # Specify the Poppler path explicitly
+            poppler_path = r"C:\poppler\poppler-23.11.0\Library\bin"
+            images = convert_from_path(self.file_path, dpi=300, poppler_path=poppler_path)
+            
+            documents = []
+            
+            for page_num, image in enumerate(images):
+                print(f"[INFO] Processing page {page_num + 1} with OCR...")
+                
+                # Convert PIL image to OpenCV format for preprocessing
+                img_cv = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+                
+                # Preprocess image for better OCR (returns multiple versions)
+                processed_images = self._preprocess_image_for_ocr(img_cv)
+                
+                # Convert all processed images to PIL format
+                pil_images = []
+                for processed_img in processed_images:
+                    try:
+                        pil_img = Image.fromarray(processed_img)
+                        pil_images.append(pil_img)
+                    except:
+                        # If conversion fails, use original image
+                        pil_images.append(image)
+                
+                # Perform OCR with multiple attempts and configurations
+                best_text = ""
+                best_length = 0
+                
+                # OCR configurations to try (in order of preference)
+                ocr_configs = [
+                    # Default configuration
+                    {"config": "--oem 3 --psm 6", "name": "default"},
+                    # Single uniform block of text
+                    {"config": "--oem 3 --psm 6 -c tessedit_char_whitelist=ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.,!?;:()[]{}'\"- ", "name": "alphanumeric"},
+                    # Sparse text with OSD
+                    {"config": "--oem 3 --psm 3", "name": "sparse_text"},
+                    # Single text line
+                    {"config": "--oem 3 --psm 7", "name": "single_line"},
+                    # Single word
+                    {"config": "--oem 3 --psm 8", "name": "single_word"},
+                    # Single word in a circle
+                    {"config": "--oem 3 --psm 9", "name": "circular_text"},
+                    # Single character
+                    {"config": "--oem 3 --psm 10", "name": "single_char"},
+                    # Sparse text
+                    {"config": "--oem 3 --psm 11", "name": "sparse_text_alt"},
+                    # Raw line
+                    {"config": "--oem 3 --psm 12", "name": "raw_line"},
+                    # Uniform block of text
+                    {"config": "--oem 3 --psm 13", "name": "uniform_block"}
+                ]
+                
+                try:
+                    # Try OCR on all preprocessed images with all configurations
+                    for img_idx, pil_image in enumerate(pil_images):
+                        for config in ocr_configs:
+                            try:
+                                text = pytesseract.image_to_string(
+                                    pil_image, 
+                                    config=config["config"],
+                                    lang='eng'  # Specify English language
+                                )
+                                
+                                # Clean the text
+                                cleaned_text = self._clean_ocr_text(text)
+                                
+                                # Check if this configuration produced better results
+                                if len(cleaned_text.strip()) > best_length:
+                                    best_text = cleaned_text
+                                    best_length = len(cleaned_text.strip())
+                                    print(f"[INFO] Better OCR result with image {img_idx+1}, config {config['name']}: {best_length} characters")
+                                
+                            except Exception as config_error:
+                                print(f"[DEBUG] OCR config {config['name']} failed for image {img_idx+1}: {config_error}")
+                                continue
+                    
+                    # Use the best result
+                    if best_text and len(best_text.strip()) > 10:
+                        documents.append(Document(
+                            page_content=best_text.strip(),
+                            metadata={"page": page_num + 1, "source": self.file_path, "method": "OCR"}
+                        ))
+                        print(f"[INFO] OCR extracted {len(best_text)} characters from page {page_num + 1}")
+                    else:
+                        print(f"[WARNING] OCR returned minimal text for page {page_num + 1} (best: {best_length} chars)")
+                        
+                except Exception as e:
+                    print(f"[WARNING] OCR failed for page {page_num + 1}: {e}")
+                    continue
+            
+            return documents
+            
+        except Exception as e:
+            print(f"[ERROR] OCR processing failed: {e}")
+            return []
+
+    def _preprocess_image_for_ocr(self, image):
+        """Preprocess image for better OCR results"""
+        try:
+            # Convert to grayscale
+            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+            
+            # Apply noise reduction
+            denoised = cv2.fastNlMeansDenoising(gray)
+            
+            # Try multiple preprocessing approaches
+            processed_images = []
+            
+            # Approach 1: Adaptive thresholding
+            try:
+                thresh1 = cv2.adaptiveThreshold(
+                    denoised, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2
+                )
+                processed_images.append(thresh1)
+            except:
+                pass
+            
+            # Approach 2: Otsu thresholding
+            try:
+                _, thresh2 = cv2.threshold(denoised, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+                processed_images.append(thresh2)
+            except:
+                pass
+            
+            # Approach 3: Simple thresholding
+            try:
+                _, thresh3 = cv2.threshold(denoised, 127, 255, cv2.THRESH_BINARY)
+                processed_images.append(thresh3)
+            except:
+                pass
+            
+            # Approach 4: Original grayscale (sometimes works better)
+            processed_images.append(denoised)
+            
+            # Apply morphological operations to clean up
+            cleaned_images = []
+            for img in processed_images:
+                try:
+                    # Small kernel for fine details
+                    kernel_small = cv2.getStructuringElement(cv2.MORPH_RECT, (1, 1))
+                    cleaned_small = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel_small)
+                    cleaned_images.append(cleaned_small)
+                    
+                    # Medium kernel for general cleaning
+                    kernel_medium = cv2.getStructuringElement(cv2.MORPH_RECT, (2, 2))
+                    cleaned_medium = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel_medium)
+                    cleaned_images.append(cleaned_medium)
+                    
+                except:
+                    cleaned_images.append(img)
+            
+            # Return all processed images for testing
+            return cleaned_images
+            
+        except Exception as e:
+            print(f"[WARNING] Image preprocessing failed: {e}")
+            return [image]
+
+    def _clean_ocr_text(self, text):
+        """Clean and improve OCR text"""
+        if not text:
+            return text
+        
+        # Remove excessive whitespace
+        text = ' '.join(text.split())
+        
+        # Fix common OCR errors
+        text = text.replace('|', 'I')  # Common OCR error
+        text = text.replace('0', 'O')  # Sometimes numbers are confused with letters
+        text = text.replace('1', 'l')  # Sometimes 1 is confused with l
+        text = text.replace('l', 'I')  # Sometimes l is confused with I
+        text = text.replace('rn', 'm')  # Common OCR error
+        text = text.replace('cl', 'd')  # Common OCR error
+        text = text.replace('vv', 'w')  # Common OCR error
+        
+        # Remove lines that are likely noise (very short lines)
+        lines = text.split('\n')
+        cleaned_lines = []
+        for line in lines:
+            line = line.strip()
+            # Keep lines with more than 2 characters and not just punctuation
+            if len(line) > 2 and not all(c in '.,!?;:()[]{}' for c in line):
+                cleaned_lines.append(line)
+        
+        # Join lines and clean up
+        result = '\n'.join(cleaned_lines)
+        
+        # Remove excessive newlines
+        result = '\n'.join(line for line in result.split('\n') if line.strip())
+        
+        return result
+
+    def _try_alternative_pdf_loaders(self):
+        """Try alternative PDF loaders if primary methods fail"""
+        loaders = [
+            ("PDFPlumberLoader", lambda: PDFPlumberLoader(self.file_path).load()),
+            ("UnstructuredPDFLoader", lambda: UnstructuredPDFLoader(self.file_path).load()),
+            ("PyPDFLoader", lambda: PyPDFLoader(self.file_path).load())
+        ]
+        
+        for loader_name, loader_func in loaders:
+            try:
+                print(f"[INFO] Trying {loader_name}...")
+                documents = loader_func()
+                total_text = " ".join([doc.page_content for doc in documents])
+                if len(total_text.strip()) > 10:
+                    print(f"[INFO] {loader_name} successfully extracted {len(total_text)} characters")
+                    return documents
+            except Exception as e:
+                print(f"[WARNING] {loader_name} failed: {e}")
+                continue
+        
+        return []
+
+    def get_page_count(self):
+        """Get page count for different document types"""
+        if self.extension == ".pdf":
+            try:
+                # Try PyMuPDF first (most reliable)
+                doc = fitz.open(self.file_path)
+                page_count = len(doc)
+                doc.close()
+                return page_count
+            except Exception:
+                try:
+                    # Fallback to PyPDF2
+                    import PyPDF2
+                    with open(self.file_path, "rb") as f:
+                        reader = PyPDF2.PdfReader(f)
+                        return len(reader.pages)
+                except Exception:
+                    return None
+        elif self.extension == ".pptx":
+            try:
+                from pptx import Presentation
+                prs = Presentation(self.file_path)
+                return len(prs.slides)
+            except Exception:
+                return None
+        elif self.extension == ".docx":
+            try:
+                from docx import Document as DocxDocument
+                doc = DocxDocument(self.file_path)
+                # DOCX doesn't have strict pages, but we can estimate by section breaks or paragraphs
+                return max(1, len(doc.paragraphs) // 30)  # Rough estimate: 30 paragraphs per page
+            except Exception:
+                return None
+        elif self.extension == ".txt":
+            try:
+                with open(self.file_path, "r", encoding="utf-8") as f:
+                    words = f.read().split()
+                    return max(1, len(words) // 500)
+            except Exception:
+                return None
+        else:
+            return None 

app/main.py

@@ -0,0 +1,882 @@
+from fastapi import FastAPI, UploadFile, File, Form
+from fastapi.responses import HTMLResponse, JSONResponse
+from typing import List, Optional
+import os
+from .document_loader import DocumentLoader
+from .chunking import chunk_text
+from .vector_store import add_to_vector_store, similarity_search
+from .summarizer import DocumentSummarizer, clean_markdown_formatting
+
+# Remove Qwen/transformers imports and model initialization
+
+app = FastAPI(title="RAG Document Summarizer", version="1.0.0")
+
+print("[INFO] RAG Application starting up...")
+
+# Global exception handler to ensure all errors return JSON
+@app.exception_handler(Exception)
+async def global_exception_handler(request, exc):
+    print(f"[ERROR] Unhandled exception: {exc}")
+    return JSONResponse(
+        status_code=500,
+        content={"error": f"Internal server error: {str(exc)}"}
+    )
+
+# Remove Qwen2-0.5B model instance for queries (CPU-optimized)
+
+def initialize_qwen_model():
+    """Initialize Qwen2-0.5B model for query responses (CPU-optimized)"""
+    # This function is no longer needed as Qwen model is removed.
+    # Keeping it for now, but it will not initialize the model.
+    print("[INFO] Qwen model is no longer available. Using simulated responses for queries.")
+    return False
+
+# Initialize model on startup (non-blocking)
+@app.on_event("startup")
+async def startup_event():
+    print("[INFO] Starting RAG application...")
+    # Initialize model in background to avoid blocking startup
+    import asyncio
+    asyncio.create_task(initialize_qwen_model_async())
+
+async def initialize_qwen_model_async():
+    """Initialize Qwen model asynchronously to avoid blocking startup"""
+    try:
+        initialize_qwen_model()
+    except Exception as e:
+        print(f"[WARNING] Model initialization failed: {e}")
+        print("[INFO] Application will continue with simulated responses")
+
+@app.get("/health")
+async def health_check():
+    """Simple health check endpoint"""
+    return {"status": "healthy", "message": "RAG application is running"}
+
+@app.get("/", response_class=HTMLResponse)
+async def read_root():
+    return """
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AI Document Summarizer & Query Resolver</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/pdf-lib/1.17.1/pdf-lib.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/mammoth/1.5.0/mammoth.browser.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js"></script>
+    <style>
+        @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+        
+        :root {
+            --pastel-blue: #89CFF0;
+            --pastel-green: #A8E6CF;
+            --pastel-purple: #D7A9E3;
+            --pastel-pink: #F5B7B1;
+        }
+        
+        * {
+            font-family: 'Inter', sans-serif;
+        }
+        
+        body {
+            background: linear-gradient(135deg, #1a1a1a 0%, #2a2a2a 100%);
+            color: #e0e0e0;
+            line-height: 1.6;
+        }
+        
+        .glass-effect {
+            background: rgba(0, 0, 0, 0.3);
+            border: 1px solid rgba(255, 255, 255, 0.1);
+            backdrop-filter: blur(10px);
+        }
+        
+        .file-upload-area {
+            background: linear-gradient(135deg, rgba(30, 30, 30, 0.5) 0%, rgba(50, 50, 50, 0.5) 100%);
+            border: 2px dashed rgba(255, 255, 255, 0.2);
+            transition: all 0.3s ease;
+        }
+        
+        .file-upload-area:hover {
+            border-color: var(--pastel-blue);
+        }
+        
+        .chunk-card {
+            background: linear-gradient(135deg, rgba(0, 0, 0, 0.2) 0%, rgba(0, 0, 0, 0.1) 100%);
+            border: 1px solid rgba(255, 255, 255, 0.1);
+        }
+        
+        .progress-bar {
+            background: linear-gradient(90deg, var(--pastel-blue) 0%, var(--pastel-green) 100%);
+        }
+        
+        @keyframes float {
+            0%, 100% { transform: translateY(0px); }
+            50% { transform: translateY(-5px); }
+        }
+        
+        .floating-element {
+            animation: float 5s ease-in-out infinite;
+        }
+        
+        .query-bubble {
+            background: linear-gradient(135deg, #333 0%, #444 100%);
+            border-radius: 20px 20px 5px 20px;
+        }
+        
+        .response-bubble {
+            background: linear-gradient(135deg, rgba(0, 0, 0, 0.2) 0%, rgba(0, 0, 0, 0.1) 100%);
+            border: 1px solid rgba(255, 255, 255, 0.1);
+            border-radius: 20px 20px 20px 5px;
+        }
+        
+        h1 {
+            font-size: 3.75rem;
+            font-weight: 700;
+        }
+        
+        h2 {
+            font-size: 2.25rem;
+            font-weight: 600;
+        }
+    </style>
+</head>
+<body>
+    <!-- Background Effects -->
+    <div class="fixed inset-0 overflow-hidden pointer-events-none">
+        <div class="absolute top-20 left-10 w-64 h-64 bg-[var(--pastel-blue)] rounded-full opacity-5 blur-3xl floating-element"></div>
+        <div class="absolute top-40 right-20 w-48 h-48 bg-[var(--pastel-green)] rounded-full opacity-5 blur-2xl floating-element" style="animation-delay: 1s;"></div>
+        <div class="absolute bottom-20 left-1/3 w-56 h-56 bg-[var(--pastel-purple)] rounded-full opacity-5 blur-3xl floating-element" style="animation-delay: 2s;"></div>
+    </div>
+
+    <!-- Header -->
+    <header class="relative z-10 py-8">
+        <div class="container mx-auto px-6">
+            <div class="text-center">
+                <h1 class="text-6xl font-bold mb-4">AI Document Summarizer</h1>
+                <p class="text-xl mb-6">Advanced Document Processing and Query Resolution</p>
+            </div>
+        </div>
+    </header>
+
+    <!-- Main Content -->
+    <main class="container mx-auto px-6 pb-16">
+        <!-- File Upload Section -->
+        <div class="glass-effect rounded-3xl p-10 mb-8">
+            <h2 class="text-4xl font-bold mb-6 text-center">Document Upload</h2>
+            
+            <div id="fileUploadArea" class="file-upload-area rounded-2xl p-12 text-center cursor-pointer">
+                <div class="mb-4">
+                    <svg class="w-16 h-16 mx-auto text-[var(--pastel-blue)] mb-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M7 16a4 4 0 01-.88-7.903A5 5 0 1115.9 6L16 6a5 5 0 011 9.9M15 13l-3-3m0 0l-3 3m3-3v12"></path>
+                    </svg>
+                </div>
+                <p class="text-2xl font-semibold mb-2">Drop your documents here</p>
+                <p class="text-gray-400 mb-4">or click to browse</p>
+                <div class="flex justify-center space-x-2 text-sm text-gray-500">
+                    <span>Supports: PDF, DOCX, PPTX, TXT</span>
+                    <span>•</span>
+                    <span>Max size: 100MB</span>
+                </div>
+            </div>
+            
+            <input type="file" id="fileInput" multiple accept=".pdf,.docx,.pptx,.txt" class="hidden">
+            
+            <!-- Processing Status -->
+            <div id="processingStatus" class="mt-6 hidden">
+                <div class="bg-gray-800 rounded-xl p-4">
+                    <div class="flex items-center justify-between mb-2">
+                        <span class="font-medium">Processing Document...</span>
+                        <span id="processingPercentage" class="text-[var(--pastel-blue)] font-bold">0%</span>
+                    </div>
+                    <div class="w-full bg-gray-700 rounded-full h-2">
+                        <div id="progressBar" class="progress-bar h-2 rounded-full" style="width: 0%"></div>
+                    </div>
+                    <div id="processingSteps" class="mt-4 space-y-2"></div>
+                </div>
+            </div>
+            
+            <!-- File List -->
+            <div id="fileList" class="mt-6 space-y-3"></div>
+        </div>
+
+        <!-- Document Analysis & Summary -->
+        <div id="documentAnalysis" class="glass-effect rounded-3xl p-10 mb-8 hidden">
+            <h2 class="text-4xl font-bold mb-6">Document Analysis</h2>
+            
+            <div class="grid md:grid-cols-2 lg:grid-cols-3 gap-6 mb-8">
+                <div class="chunk-card rounded-xl p-6">
+                    <h3 class="text-lg font-semibold mb-2">Document Type</h3>
+                    <p id="documentType" class="text-gray-400">-</p>
+                </div>
+                
+                <div class="chunk-card rounded-xl p-6">
+                    <h3 class="text-lg font-semibold mb-2">Page Count</h3>
+                    <p id="pageCount" class="text-gray-400">-</p>
+                </div>
+                
+                <div class="chunk-card rounded-xl p-6">
+                    <h3 class="text-lg font-semibold mb-2">Chunks Created</h3>
+                    <p id="chunkCount" class="text-gray-400">-</p>
+                </div>
+            </div>
+            
+            <div class="chunk-card rounded-xl p-6">
+                <h3 class="text-xl font-semibold mb-4">Document Summary</h3>
+                <div id="documentSummary" class="text-gray-400 leading-relaxed">
+                    <div class="processing-animation">Generating summary...</div>
+                </div>
+            </div>
+        </div>
+
+        <!-- Query Interface -->
+        <div class="glass-effect rounded-3xl p-10 mb-8">
+            <h2 class="text-4xl font-bold mb-6">Query Resolver</h2>
+            
+            <div class="mb-6">
+                <div class="relative">
+                    <input 
+                        type="text" 
+                        id="queryInput" 
+                        placeholder="Ask anything about your document..."
+                        class="w-full px-6 py-4 bg-gray-800 border border-gray-700 rounded-2xl text-white placeholder-gray-500 focus:outline-none focus:border-[var(--pastel-blue)]"
+                        disabled
+                    >
+                    <button 
+                        id="querySubmit" 
+                        class="absolute right-2 top-2 px-6 py-2 bg-gray-800 hover:bg-[var(--pastel-blue)]/20 rounded-xl text-white font-medium transition-all duration-200 disabled:opacity-50"
+                        disabled
+                    >
+                        Ask
+                    </button>
+                </div>
+                <div class="mt-3 flex flex-wrap gap-2">
+                    <button class="suggestion-btn px-4 py-2 bg-gray-800 hover:bg-[var(--pastel-blue)]/20 rounded-full text-sm text-gray-400 transition-all duration-200">
+                        What are the key points?
+                    </button>
+                    <button class="suggestion-btn px-4 py-2 bg-gray-800 hover:bg-[var(--pastel-blue)]/20 rounded-full text-sm text-gray-400 transition-all duration-200">
+                        Explain the main concepts
+                    </button>
+                    <button class="suggestion-btn px-4 py-2 bg-gray-800 hover:bg-[var(--pastel-blue)]/20 rounded-full text-sm text-gray-400 transition-all duration-200">
+                        What conclusions are drawn?
+                    </button>
+                </div>
+            </div>
+            
+            <div id="queryHistory" class="space-y-4 max-h-96 overflow-y-auto"></div>
+        </div>
+    </main>
+
+    <script>
+        // Global state
+        let documents = [];
+        let currentDocument = null;
+        let documentChunks = [];
+        let isProcessing = false;
+
+        // Initialize application
+        document.addEventListener('DOMContentLoaded', function() {
+            initializeFileUpload();
+            initializeQueryInterface();
+            initializeSuggestions();
+        });
+
+        function initializeFileUpload() {
+            const fileUploadArea = document.getElementById('fileUploadArea');
+            const fileInput = document.getElementById('fileInput');
+
+            fileUploadArea.addEventListener('click', () => {
+                if (!isProcessing) {
+                    fileInput.click();
+                }
+            });
+
+            fileInput.addEventListener('change', (e) => {
+                handleFiles(e.target.files);
+            });
+
+            fileUploadArea.addEventListener('dragover', (e) => {
+                e.preventDefault();
+                fileUploadArea.classList.add('dragover');
+            });
+
+            fileUploadArea.addEventListener('dragleave', () => {
+                fileUploadArea.classList.remove('dragover');
+            });
+
+            fileUploadArea.addEventListener('drop', (e) => {
+                e.preventDefault();
+                fileUploadArea.classList.remove('dragover');
+                handleFiles(e.dataTransfer.files);
+            });
+        }
+
+        function initializeQueryInterface() {
+            const queryInput = document.getElementById('queryInput');
+            const querySubmit = document.getElementById('querySubmit');
+
+            querySubmit.addEventListener('click', () => {
+                const query = queryInput.value.trim();
+                if (query) {
+                    processQuery(query);
+                    queryInput.value = '';
+                }
+            });
+
+            queryInput.addEventListener('keypress', (e) => {
+                if (e.key === 'Enter') {
+                    querySubmit.click();
+                }
+            });
+        }
+
+        function initializeSuggestions() {
+            document.querySelectorAll('.suggestion-btn').forEach(btn => {
+                btn.addEventListener('click', () => {
+                    const query = btn.textContent.trim();
+                    document.getElementById('queryInput').value = query;
+                    document.getElementById('querySubmit').click();
+                });
+            });
+        }
+
+        async function handleFiles(files) {
+            if (isProcessing) return;
+
+            for (const file of files) {
+                if (validateFile(file)) {
+                    await processDocument(file);
+                }
+            }
+        }
+
+        function validateFile(file) {
+            const allowedTypes = [
+                'application/pdf',
+                'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+                'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+                'text/plain'
+            ];
+
+            if (!allowedTypes.includes(file.type)) {
+                showNotification('Unsupported file type. Please upload PDF, DOCX, PPTX, or TXT files.', 'error');
+                return false;
+            }
+
+            if (file.size > 100 * 1024 * 1024) {
+                showNotification('File too large. Maximum size is 100MB.', 'error');
+                return false;
+            }
+
+            return true;
+        }
+
+        async function processDocument(file) {
+            isProcessing = true;
+            showProcessingStatus();
+
+            try {
+                updateProcessingStep('Uploading document...', 10);
+                
+                // Create FormData for file upload
+                const formData = new FormData();
+                formData.append('file', file);
+                
+                updateProcessingStep('Processing document...', 30);
+                
+                // Send file to backend
+                const response = await fetch('/upload', {
+                    method: 'POST',
+                    body: formData
+                });
+                
+                if (!response.ok) {
+                    let errorMessage = 'Upload failed';
+                    let errorText = '';
+                    try {
+                        // Try to parse as JSON
+                        const errorData = await response.json();
+                        errorMessage = errorData.error || 'Upload failed';
+                    } catch (jsonError) {
+                        // Only try to read as text if .json() fails and errorText is still empty
+                        if (!errorText) {
+                            errorText = await response.text();
+                            console.error('Non-JSON error response:', errorText);
+                        }
+                        errorMessage = `Server error (${response.status}): ${response.statusText}`;
+                    }
+                    throw new Error(errorMessage);
+                }
+                
+                updateProcessingStep('Analyzing content...', 70);
+                
+                // Only read the response body once
+                const result = await response.json();
+                
+                updateProcessingStep('Processing complete!', 100);
+                
+                const document = {
+                    id: Date.now(),
+                    name: file.name,
+                    type: getFileType(file.name),
+                    size: file.size,
+                    pageCount: result.page_estimate || 1,
+                    chunks: result.chunk_count || 0,
+                    summary: result.summary,
+                    classification: result.classification,
+                    processingMethod: result.processing_method
+                };
+                
+                documents.push(document);
+                currentDocument = document;
+                
+                displayDocumentInfo(document);
+                enableQueryInterface();
+                
+                setTimeout(() => {
+                    hideProcessingStatus();
+                    showNotification('Document processed successfully!', 'success');
+                }, 1000);
+                
+            } catch (error) {
+                console.error('Error processing document:', error);
+                showNotification('Error processing document: ' + error.message, 'error');
+                hideProcessingStatus();
+            }
+            
+            isProcessing = false;
+        }
+
+        function getFileType(filename) {
+            const extension = filename.split('.').pop().toLowerCase();
+            const typeMap = {
+                'pdf': 'PDF Document',
+                'docx': 'Word Document',
+                'pptx': 'PowerPoint Presentation',
+                'txt': 'Text Document'
+            };
+            return typeMap[extension] || 'Unknown';
+        }
+
+        function displayDocumentInfo(docData) {
+            document.getElementById('documentType').textContent = docData.type;
+            document.getElementById('pageCount').textContent = `${docData.pageCount} pages (${docData.classification})`;
+            document.getElementById('chunkCount').textContent = `${docData.chunks} chunks`;
+            
+            const summaryElement = document.getElementById('documentSummary');
+            summaryElement.innerHTML = '';
+            
+            let i = 0;
+            const summary = docData.summary;
+            const typeInterval = setInterval(() => {
+                if (i < summary.length) {
+                    summaryElement.textContent += summary.charAt(i);
+                    i++;
+                } else {
+                    clearInterval(typeInterval);
+                }
+            }, 20);
+            
+            document.getElementById('documentAnalysis').classList.remove('hidden');
+        }
+
+        function enableQueryInterface() {
+            document.getElementById('queryInput').disabled = false;
+            document.getElementById('querySubmit').disabled = false;
+            document.querySelectorAll('.suggestion-btn').forEach(btn => {
+                btn.disabled = false;
+            });
+        }
+
+        async function processQuery(query) {
+            if (!currentDocument) return;
+            
+            addQueryToHistory(query);
+            
+            try {
+                const formData = new FormData();
+                formData.append('filename', currentDocument.name);
+                formData.append('query', query);
+                
+                const response = await fetch('/query', {
+                    method: 'POST',
+                    body: formData
+                });
+                
+                if (!response.ok) {
+                    let errorMessage = 'Query failed';
+                    try {
+                        const errorData = await response.json();
+                        errorMessage = errorData.error || 'Query failed';
+                    } catch (jsonError) {
+                        // If response is not JSON (e.g., HTML error page), get text content
+                        const errorText = await response.text();
+                        console.error('Non-JSON error response:', errorText);
+                        errorMessage = `Server error (${response.status}): ${response.statusText}`;
+                    }
+                    throw new Error(errorMessage);
+                }
+                
+                const result = await response.json();
+                addResponseToHistory(result.answer);
+                
+            } catch (error) {
+                console.error('Error processing query:', error);
+                addResponseToHistory('Sorry, I encountered an error while processing your query. Please try again.');
+            }
+        }
+
+        function addQueryToHistory(query) {
+            const historyContainer = document.getElementById('queryHistory');
+            const queryElement = document.createElement('div');
+            queryElement.className = 'query-bubble p-4 ml-8';
+            queryElement.innerHTML = `
+                <div class="flex items-start">
+                    <div class="flex-shrink-0 w-8 h-8 bg-gray-700 rounded-full flex items-center justify-center mr-3 mt-1">
+                        <span class="text-sm">U</span>
+                    </div>
+                    <div class="flex-1">
+                        <p class="font-medium">${query}</p>
+                        <p class="text-sm text-gray-500 mt-1">${new Date().toLocaleTimeString()}</p>
+                    </div>
+                </div>
+            `;
+            historyContainer.appendChild(queryElement);
+            historyContainer.scrollTop = historyContainer.scrollHeight;
+        }
+
+        function addResponseToHistory(response) {
+            const historyContainer = document.getElementById('queryHistory');
+            const responseElement = document.createElement('div');
+            responseElement.className = 'response-bubble p-4 mr-8';
+            responseElement.innerHTML = `
+                <div class="flex items-start">
+                    <div class="flex-shrink-0 w-8 h-8 bg-[var(--pastel-blue)] rounded-full flex items-center justify-center mr-3 mt-1">
+                        <span class="text-sm">A</span>
+                    </div>
+                    <div class="flex-1">
+                        <div class="typing-indicator mb-2">
+                            <span class="inline-block w-2 h-2 bg-[var(--pastel-blue)] rounded-full animate-pulse"></span>
+                            <span class="inline-block w-2 h-2 bg-[var(--pastel-blue)] rounded-full animate-pulse ml-1" style="animation-delay: 0.2s;"></span>
+                            <span class="inline-block w-2 h-2 bg-[var(--pastel-blue)] rounded-full animate-pulse ml-1" style="animation-delay: 0.4s;"></span>
+                        </div>
+                        <p class="response-text hidden leading-relaxed"></p>
+                        <p class="text-sm text-gray-500 mt-2">${new Date().toLocaleTimeString()}</p>
+                    </div>
+                </div>
+            `;
+            historyContainer.appendChild(responseElement);
+            historyContainer.scrollTop = historyContainer.scrollHeight;
+            
+            setTimeout(() => {
+                const typingIndicator = responseElement.querySelector('.typing-indicator');
+                const responseText = responseElement.querySelector('.response-text');
+                
+                typingIndicator.classList.add('hidden');
+                responseText.classList.remove('hidden');
+                
+                let i = 0;
+                const typeInterval = setInterval(() => {
+                    if (i < response.length) {
+                        responseText.textContent += response.charAt(i);
+                        i++;
+                        historyContainer.scrollTop = historyContainer.scrollHeight;
+                    } else {
+                        clearInterval(typeInterval);
+                    }
+                }, 30);
+            }, 1500);
+        }
+
+        function showProcessingStatus() {
+            document.getElementById('processingStatus').classList.remove('hidden');
+            document.getElementById('fileUploadArea').style.opacity = '0.5';
+            document.getElementById('fileUploadArea').style.pointerEvents = 'none';
+        }
+
+        function hideProcessingStatus() {
+            document.getElementById('processingStatus').classList.add('hidden');
+            document.getElementById('fileUploadArea').style.opacity = '1';
+            document.getElementById('fileUploadArea').style.pointerEvents = 'auto';
+        }
+
+        function updateProcessingStep(message, percentage) {
+            const stepsContainer = document.getElementById('processingSteps');
+            const progressBar = document.getElementById('progressBar');
+            const percentageDisplay = document.getElementById('processingPercentage');
+            
+            progressBar.style.width = percentage + '%';
+            percentageDisplay.textContent = percentage + '%';
+            
+            const stepElement = document.createElement('div');
+            stepElement.className = 'flex items-center text-sm text-gray-400';
+            stepElement.innerHTML = `
+                <div class="w-2 h-2 bg-[var(--pastel-blue)] rounded-full mr-3 flex-shrink-0"></div>
+                <span>${message}</span>
+            `;
+            stepsContainer.appendChild(stepElement);
+            
+            while (stepsContainer.children.length > 3) {
+                stepsContainer.removeChild(stepsContainer.firstChild);
+            }
+        }
+
+        function showNotification(message, type = 'info') {
+            const notification = document.createElement('div');
+            const bgColor = type === 'error' ? 'bg-red-500' : type === 'success' ? 'bg-green-500' : 'bg-blue-500';
+            
+            notification.className = `fixed top-4 right-4 ${bgColor} text-white px-6 py-3 rounded-lg shadow-lg z-50 transform translate-x-full transition-transform duration-300`;
+            notification.textContent = message;
+            
+            document.body.appendChild(notification);
+            
+            setTimeout(() => {
+                notification.classList.remove('translate-x-full');
+            }, 100);
+            
+            setTimeout(() => {
+                notification.classList.add('translate-x-full');
+                setTimeout(() => {
+                    if (notification.parentNode) {
+                        notification.parentNode.removeChild(notification);
+                    }
+                }, 300);
+            }, 4000);
+        }
+    </script>
+</body>
+</html>
+    """
+
+@app.post("/upload")
+async def upload_document(file: UploadFile = File(...)):
+    """Upload and process a document with improved error handling and logging"""
+    try:
+        print(f"[INFO] Received file: {file.filename}")
+        upload_dir = "uploaded_docs"
+        try:
+            os.makedirs(upload_dir, exist_ok=True)
+        except Exception as e:
+            print(f"[ERROR] Failed to create upload directory: {e}")
+            return JSONResponse(status_code=500, content={"error": f"Failed to create upload directory: {str(e)}"})
+
+        file_location = os.path.join(upload_dir, file.filename)
+        try:
+            with open(file_location, "wb") as f:
+                f.write(await file.read())
+            print(f"[INFO] File saved to: {file_location}")
+        except Exception as e:
+            print(f"[ERROR] Failed to save file: {e}")
+            return JSONResponse(status_code=500, content={"error": f"Failed to save file: {str(e)}"})
+
+        try:
+            loader = DocumentLoader(file_location)
+            documents = loader.load()
+            print(f"[INFO] Loaded {len(documents)} document(s) from file.")
+            # Get real page/slide count
+            page_count = loader.get_page_count() or 1
+        except Exception as e:
+            print(f"[ERROR] Document loading failed: {e}")
+            return JSONResponse(status_code=400, content={"error": f"Document loading failed: {str(e)}"})
+
+        try:
+            text_content = " ".join([doc.page_content for doc in documents])
+            print(f"[INFO] Extracted text content, length: {len(text_content)} characters.")
+        except Exception as e:
+            print(f"[ERROR] Failed to extract text: {e}")
+            return JSONResponse(status_code=500, content={"error": f"Failed to extract text: {str(e)}"})
+
+        try:
+            summarizer = DocumentSummarizer()
+            summary_result = await summarizer.summarize_document(text_content)
+            print(f"[INFO] Document summarized. Classification: {summary_result.get('classification')}")
+        except Exception as e:
+            print(f"[ERROR] Summarization failed: {e}")
+            return JSONResponse(status_code=500, content={"error": f"Summarization failed: {str(e)}"})
+
+        try:
+            chunks = chunk_text(text_content)
+            print(f"[INFO] Created {len(chunks)} chunk(s) for vector store.")
+        except Exception as e:
+            print(f"[ERROR] Chunking failed: {e}")
+            return JSONResponse(status_code=500, content={"error": f"Chunking failed: {str(e)}"})
+
+        try:
+            add_to_vector_store(chunks)
+            print(f"[INFO] Chunks added to vector store.")
+        except Exception as e:
+            print(f"[ERROR] Vector store addition failed: {e}")
+            return JSONResponse(status_code=500, content={"error": f"Vector store addition failed: {str(e)}"})
+
+        # Store chunks for small document queries (in-memory, keyed by filename)
+        if not hasattr(app.state, 'doc_chunks'):
+            app.state.doc_chunks = {}
+        app.state.doc_chunks[file.filename] = chunks
+
+        return {
+            "filename": file.filename,
+            "summary": summary_result["summary"],
+            "classification": summary_result["classification"],
+            "chunk_count": summary_result["chunk_count"],
+            "processing_method": summary_result["processing_method"],
+            "page_estimate": page_count
+        }
+
+    except Exception as e:
+        print(f"[ERROR] Unexpected error: {e}")
+        return JSONResponse(
+            status_code=500,
+            content={"error": f"Unexpected error processing document: {str(e)}"}
+        )
+
+@app.post("/summarize")
+async def summarize_document(filename: str = Form(...)):
+    """Generate summary for a specific document"""
+    try:
+        file_location = f"uploaded_docs/{filename}"
+        if not os.path.exists(file_location):
+            return JSONResponse(
+                status_code=404,
+                content={"error": "Document not found"}
+            )
+        
+        # Load and process document
+        loader = DocumentLoader(file_location)
+        documents = loader.load()
+        text_content = " ".join([doc.page_content for doc in documents])
+        
+        # Generate summary
+        summarizer = DocumentSummarizer()
+        summary_result = await summarizer.summarize_document(text_content)
+        
+        return {
+            "filename": filename,
+            "summary": summary_result["summary"],
+            "classification": summary_result["classification"],
+            "chunk_count": summary_result["chunk_count"],
+            "processing_method": summary_result["processing_method"]
+        }
+        
+    except Exception as e:
+        return JSONResponse(
+            status_code=500,
+            content={"error": f"Error summarizing document: {str(e)}"}
+        )
+
+@app.post("/query")
+async def query_document(filename: str = Form(...), query: str = Form(...)):
+    """Query a document using RAG pipeline"""
+    try:
+        # Try to get all chunks for small documents
+        chunks = None
+        if hasattr(app.state, 'doc_chunks') and filename in app.state.doc_chunks:
+            chunks = app.state.doc_chunks[filename]
+
+        # If we have all chunks, check if the document is small
+        is_small_doc = False
+        if chunks is not None:
+            # Heuristic: if number of chunks < 20, treat as small document
+            is_small_doc = len(chunks) < 20
+
+        if is_small_doc:
+            # Use all chunks as context
+            context_chunks = chunks
+        else:
+            # Use similarity search for large documents or if chunks not available
+            search_results = similarity_search(query, top_k=5)
+            context_chunks = search_results.get("documents", [[]])[0]
+
+        context = " ".join(context_chunks)
+
+        # Generate a more intelligent response based on the actual context
+        if not context_chunks:
+            answer = f"I couldn't find specific information in the document that directly answers your question: '{query}'. The document may not contain relevant content for this query."
+        else:
+            # Create a more contextual response based on the found chunks
+            answer = generate_contextual_response(query, context_chunks)
+
+        return {
+            "filename": filename,
+            "query": query,
+            "answer": answer,
+            "context_chunks": len(context_chunks)
+        }
+        
+    except Exception as e:
+        return JSONResponse(
+            status_code=500,
+            content={"error": f"Error processing query: {str(e)}"}
+        )
+
+def generate_contextual_response(query: str, context_chunks: List[str]) -> str:
+    full_context = " ".join(context_chunks)
+    if len(full_context) > 8000:
+        sentences = full_context.split('. ')
+        if len(sentences) > 20:
+            relevant_sentences = sentences[:5] + sentences[-5:]
+            full_context = '. '.join(relevant_sentences)
+    # Use Mistral API for contextual response
+    from app.summarizer import DocumentSummarizer
+    summarizer = DocumentSummarizer()
+    prompt = f"You are a helpful assistant that answers questions based on document content. Provide comprehensive, accurate answers using the given context. Use plain text format without markdown. Provide detailed responses that fully address the user's question.\n\nQuestion: {query}\n\nContext: {full_context}\n\nAnswer (comprehensive, plain text):"
+    return summarizer.call_mistral_api(prompt)
+
+def generate_simulated_response(query: str, full_context: str) -> str:
+    """Generate a simulated response when Qwen2-0.5B is not available"""
+    
+    # Analyze the query type and generate appropriate response
+    query_lower = query.lower()
+    
+    if any(word in query_lower for word in ["key", "main", "important", "points", "summary"]):
+        # Extract key points from the context
+        sentences = full_context.split('. ')
+        key_points = []
+        for sentence in sentences[:min(5, len(sentences))]:  # Allow up to 5 key points
+            if len(sentence.strip()) > 10:  # Include more meaningful sentences
+                key_points.append(sentence.strip())
+        
+        if key_points:
+            answer = f"Based on the document content, here are the key points:\n\n"
+            for i, point in enumerate(key_points, 1):
+                answer += f"{i}. {point}\n"
+        else:
+            answer = f"The document contains information about your query, but I couldn't extract specific key points from the available content."
+    
+    elif any(word in query_lower for word in ["explain", "what is", "how", "why"]):
+        # Provide explanatory response with more content
+        if len(full_context) > 300:
+            # Take more content for explanations
+            relevant_part = full_context[:1000] + "..." if len(full_context) > 1000 else full_context
+            answer = f"Based on the document, here's what I found regarding your question '{query}':\n\n{relevant_part}"
+        else:
+            answer = f"The document provides the following information about your query: {full_context}"
+    
+    elif any(word in query_lower for word in ["conclusion", "result", "find", "found"]):
+        # Look for conclusions or results
+        sentences = full_context.split('. ')
+        conclusion_sentences = []
+        for sentence in sentences:
+            if any(word in sentence.lower() for word in ["conclude", "result", "therefore", "thus", "finally", "overall"]):
+                conclusion_sentences.append(sentence)
+        
+        if conclusion_sentences:
+            answer = f"Based on the document analysis, here are the conclusions related to your query:\n\n"
+            for sentence in conclusion_sentences[:3]:  # Allow up to 3 conclusions
+                answer += f"• {sentence}\n"
+        else:
+            answer = f"The document contains relevant information about your query, but I couldn't identify specific conclusions from the available content."
+    
+    else:
+        # General response with more content
+        if len(full_context) > 300:
+            # Take more sentences for general responses
+            sentences = full_context.split('. ')
+            summary_sentences = sentences[:min(8, len(sentences))]  # Increased from 4 to 8 sentences
+            summary = '. '.join(summary_sentences)
+            answer = f"Regarding your question '{query}', the document contains the following relevant information:\n\n{summary}"
+        else:
+            answer = f"The document provides this information related to your query: {full_context}"
+    
+    # Clean markdown formatting from the answer
+    answer = clean_markdown_formatting(answer)
+    return answer 

app/summarizer.py

@@ -0,0 +1,403 @@
+from typing import List, Dict, Any
+import asyncio
+import re
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.schema import Document
+import requests
+import os
+
+# Remove top-level import of transformers and torch
+# from transformers import AutoTokenizer, AutoModelForCausalLM
+# import torch
+
+def clean_markdown_formatting(text: str) -> str:
+    """
+    Clean markdown formatting from text and convert to plain text
+    
+    Args:
+        text: Text that may contain markdown formatting
+        
+    Returns:
+        Cleaned plain text without markdown
+    """
+    if not text:
+        return text
+    
+    # Remove markdown headers (# ## ### etc.)
+    text = re.sub(r'^#{1,6}\s+', '', text, flags=re.MULTILINE)
+    
+    # Remove bold formatting (**text** or __text__)
+    text = re.sub(r'\*\*(.*?)\*\*', r'\1', text)
+    text = re.sub(r'__(.*?)__', r'\1', text)
+    
+    # Remove italic formatting (*text* or _text_)
+    text = re.sub(r'\*(.*?)\*', r'\1', text)
+    text = re.sub(r'_(.*?)_', r'\1', text)
+    
+    # Remove code formatting (`text`)
+    text = re.sub(r'`(.*?)`', r'\1', text)
+    
+    # Remove links [text](url) -> text
+    text = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', text)
+    
+    # Remove inline links [text] -> text
+    text = re.sub(r'\[([^\]]+)\]', r'\1', text)
+    
+    # Remove strikethrough ~~text~~
+    text = re.sub(r'~~(.*?)~~', r'\1', text)
+    
+    # Remove blockquotes (> text)
+    text = re.sub(r'^>\s+', '', text, flags=re.MULTILINE)
+    
+    # Remove horizontal rules (---, ***, ___)
+    text = re.sub(r'^[-*_]{3,}$', '', text, flags=re.MULTILINE)
+    
+    # Clean up extra whitespace
+    text = re.sub(r'\n\s*\n\s*\n', '\n\n', text)  # Remove excessive line breaks
+    text = re.sub(r' +', ' ', text)  # Remove multiple spaces
+    text = re.sub(r'\n +', '\n', text)  # Remove leading spaces after line breaks
+    
+    # Clean up the text
+    text = text.strip()
+    
+    return text
+
+MISTRAL_API_KEY = os.getenv("MISTRAL_API_KEY", "")
+if not MISTRAL_API_KEY:
+    print("[WARNING] MISTRAL_API_KEY environment variable is not set. API calls will fail.")
+MISTRAL_API_URL = "https://api.mistral.ai/v1/chat/completions"
+
+class DocumentSummarizer:
+    def __init__(self, chunk_size=1200, chunk_overlap=200):
+        """
+        Initialize the document summarizer (CPU-optimized version)
+        
+        Args:
+            llm_model: Qwen2-0.5B model instance (CPU-friendly)
+            chunk_size: Size of text chunks for processing (optimized for CPU)
+            chunk_overlap: Overlap between chunks (reduced for memory efficiency)
+        """
+        self.chunk_size = chunk_size
+        self.chunk_overlap = chunk_overlap
+        self.text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=chunk_size,
+            chunk_overlap=chunk_overlap,
+            length_function=len,
+            separators=["\n\n", "\n", ". ", "! ", "? ", " ", ""]
+        )
+
+    def classify_document_size(self, text: str) -> Dict[str, Any]:
+        """
+        Classify document as small or large based on content length
+        
+        Args:
+            text: Document text content
+            
+        Returns:
+            Dict with classification info
+        """
+        words = len(text.split())
+        pages_estimate = words // 500  # Rough estimate: 500 words per page
+        is_large = pages_estimate > 15
+        
+        return {
+            "is_large": is_large,
+            "word_count": words,
+            "page_estimate": pages_estimate,
+            "classification": "Large Document" if is_large else "Small Document"
+        }
+    
+    def create_chunks(self, text: str) -> List[Document]:
+        """
+        Create text chunks using RecursiveCharacterTextSplitter
+        
+        Args:
+            text: Document text content
+            
+        Returns:
+            List of Document chunks
+        """
+        chunks = self.text_splitter.split_text(text)
+        return [Document(page_content=chunk, metadata={"chunk_id": i}) 
+                for i, chunk in enumerate(chunks)]
+    
+    def _truncate_text_for_model(self, text: str, max_tokens: int = 4000) -> str:
+        """
+        Truncate text to fit within model context limits (increased limits for better summaries)
+        
+        Args:
+            text: Text to truncate
+            max_tokens: Maximum tokens allowed (increased from 2000)
+            
+        Returns:
+            Truncated text
+        """
+        return text[:max_tokens * 4]
+
+    def call_mistral_api(self, prompt: str) -> str:
+        headers = {
+            "Authorization": f"Bearer {MISTRAL_API_KEY}",
+            "Content-Type": "application/json"
+        }
+        data = {
+            "model": "mistral-medium",
+            "messages": [
+                {"role": "user", "content": prompt}
+            ],
+            "max_tokens": 500,
+            "temperature": 0.3,
+            "top_p": 0.8
+        }
+        try:
+            response = requests.post(MISTRAL_API_URL, headers=headers, json=data, timeout=60)
+            response.raise_for_status()
+            result = response.json()
+            return result["choices"][0]["message"]["content"].strip()
+        except Exception as e:
+            print(f"[WARNING] Error calling Mistral API: {e}")
+            return "[Error: Unable to generate summary with Mistral AI API.]"
+
+    async def generate_chunk_summary(self, chunk: Document) -> str:
+        """
+        Generate summary for a single chunk using Qwen2-0.5B (CPU-optimized)
+        
+        Args:
+            chunk: Document chunk to summarize
+            
+        Returns:
+            Summary text for the chunk
+        """
+        truncated_content = self._truncate_text_for_model(chunk.page_content, max_tokens=3000)
+        prompt = f"""You are an expert document summarizer. Create comprehensive summaries that capture key information from text chunks. Provide summaries in plain text format without markdown formatting.\n\nText to summarize:\n{truncated_content}\n\nSummary:"""
+        response = self.call_mistral_api(prompt)
+        return clean_markdown_formatting(response)
+    
+    def _simulate_chunk_summary(self, text: str) -> str:
+        """
+        Simulate chunk summary generation (fallback when LLM not available)
+        
+        Args:
+            text: Text to summarize
+            
+        Returns:
+            Simulated summary
+        """
+        # Create a balanced summary simulation
+        words = text.split()
+        if len(words) < 30:
+            return text
+        
+        # Split into sentences and take key information
+        sentences = text.split('. ')
+        if len(sentences) <= 2:
+            return text
+        
+        # For longer text, create a meaningful summary
+        if len(sentences) > 4:
+            # Take first sentence, middle sentence, and last sentence for context
+            summary_sentences = [sentences[0]]  # Introduction
+            middle_idx = len(sentences) // 2
+            summary_sentences.append(sentences[middle_idx])  # Key point
+            summary_sentences.append(sentences[-1])  # Conclusion
+        else:
+            # For shorter text, take first 2 sentences
+            summary_sentences = sentences[:2]
+        
+        summary = '. '.join(summary_sentences)
+        return summary + ('.' if not summary.endswith('.') else '')
+    
+    async def summarize_small_document(self, chunks: List[Document]) -> str:
+        """
+        Summarize small documents (≤15 pages) by summarizing all chunks and combining
+        
+        Args:
+            chunks: List of document chunks
+            
+        Returns:
+            Combined document summary
+        """
+        print(f"Processing small document with {len(chunks)} chunks...")
+        
+        # Generate summaries for all chunks
+        chunk_summaries = []
+        for i, chunk in enumerate(chunks):
+            print(f"Summarizing chunk {i+1}/{len(chunks)}...")
+            summary = await self.generate_chunk_summary(chunk)
+            chunk_summaries.append(summary)
+        
+        # Combine all chunk summaries
+        combined_summary = " ".join(chunk_summaries)
+        
+        # Generate final summary from combined summaries
+        final_summary = await self.generate_final_summary(combined_summary, "small")
+        
+        return final_summary
+    
+    async def summarize_large_document(self, chunks: List[Document]) -> str:
+        """
+        Summarize large documents (>15 pages) using hierarchical summarization
+        
+        Args:
+            chunks: List of document chunks
+            
+        Returns:
+            Hierarchical document summary
+        """
+        print(f"Processing large document with {len(chunks)} chunks using hierarchical summarization...")
+        
+        # Step 1: Generate chunk-level summaries
+        chunk_summaries = []
+        for i, chunk in enumerate(chunks):
+            print(f"Generating chunk summary {i+1}/{len(chunks)}...")
+            summary = await self.generate_chunk_summary(chunk)
+            chunk_summaries.append(summary)
+        
+        # Step 2: Group summaries into sections (for very large documents)
+        if len(chunk_summaries) > 50:
+            section_summaries = await self._create_section_summaries(chunk_summaries)
+        else:
+            section_summaries = chunk_summaries
+        
+        # Step 3: Generate section-level summaries
+        section_level_summaries = []
+        for i, section in enumerate(section_summaries):
+            print(f"Generating section summary {i+1}/{len(section_summaries)}...")
+            if isinstance(section, list):
+                combined_section = " ".join(section)
+            else:
+                combined_section = section
+            section_summary = await self.generate_chunk_summary(
+                Document(page_content=combined_section, metadata={"section_id": i})
+            )
+            section_level_summaries.append(section_summary)
+        
+        # Step 4: Generate final hierarchical summary
+        final_combined = " ".join(section_level_summaries)
+        final_summary = await self.generate_final_summary(final_combined, "large")
+        
+        return final_summary
+    
+    async def _create_section_summaries(self, chunk_summaries: List[str]) -> List[List[str]]:
+        """
+        Group chunk summaries into sections for very large documents
+        
+        Args:
+            chunk_summaries: List of chunk summaries
+            
+        Returns:
+            List of section summaries (each section is a list of chunk summaries)
+        """
+        section_size = max(10, len(chunk_summaries) // 10)  # Create ~10 sections
+        sections = []
+        
+        for i in range(0, len(chunk_summaries), section_size):
+            section = chunk_summaries[i:i + section_size]
+            sections.append(section)
+        
+        return sections
+    
+    async def generate_final_summary(self, combined_text: str, doc_type: str) -> str:
+        """
+        Generate final summary from combined text using Qwen2-0.5B (CPU-optimized)
+        
+        Args:
+            combined_text: Combined text to summarize
+            doc_type: Type of document (small/large)
+            
+        Returns:
+            Final document summary
+        """
+        prompt = f"""You are an expert document summarizer. Create a final summary for the following combined text. Provide a comprehensive, plain text summary.\n\nText:\n{combined_text}\n\nFinal Summary:"""
+        response = self.call_mistral_api(prompt)
+        return clean_markdown_formatting(response)
+    
+    def _simulate_final_summary(self, combined_text: str, doc_type: str) -> str:
+        """
+        Simulate final summary generation (fallback when LLM not available)
+        
+        Args:
+            combined_text: Combined text to summarize
+            doc_type: Type of document (small/large)
+            
+        Returns:
+            Simulated final summary
+        """
+        # Create a balanced final summary
+        sentences = combined_text.split('. ')
+        
+        if len(sentences) <= 3:
+            return combined_text
+        
+        # For small documents, take key sentences for better context
+        if doc_type == "small":
+            if len(sentences) <= 5:
+                summary_sentences = sentences
+            else:
+                # Take introduction, key point, and conclusion for small docs
+                summary_sentences = [sentences[0]]  # Introduction
+                middle_idx = len(sentences) // 2
+                summary_sentences.append(sentences[middle_idx])  # Key point
+                summary_sentences.append(sentences[-1])  # Conclusion
+        else:
+            # For large documents, create a comprehensive summary
+            if len(sentences) <= 6:
+                summary_sentences = sentences
+            else:
+                # Take introduction, 2 key points, and conclusion
+                summary_sentences = [sentences[0]]  # Introduction
+                # Take 2 key points from different parts
+                quarter_idx = len(sentences) // 4
+                three_quarter_idx = (3 * len(sentences)) // 4
+                summary_sentences.append(sentences[quarter_idx])  # First key point
+                summary_sentences.append(sentences[three_quarter_idx])  # Second key point
+                summary_sentences.append(sentences[-1])  # Conclusion
+        
+        summary = '. '.join(summary_sentences)
+        return summary + ('.' if not summary.endswith('.') else '')
+    
+    async def summarize_document(self, text: str) -> Dict[str, Any]:
+        """
+        Main method to summarize a document
+        
+        Args:
+            text: Document text content
+            
+        Returns:
+            Dict with summary results
+        """
+        # Classify document size
+        classification = self.classify_document_size(text)
+        
+        # Create chunks
+        chunks = self.create_chunks(text)
+        
+        # Generate summary based on document size
+        if classification["is_large"]:
+            summary = await self.summarize_large_document(chunks)
+            processing_method = "Hierarchical Summarization"
+        else:
+            summary = await self.summarize_small_document(chunks)
+            processing_method = "Chunk-wise Summarization"
+        
+        return {
+            "summary": summary,
+            "classification": classification["classification"],
+            "word_count": classification["word_count"],
+            "page_estimate": classification["page_estimate"],
+            "chunk_count": len(chunks),
+            "processing_method": processing_method
+        }
+
+async def summarize_text(text: str, llm_model=None) -> Dict[str, Any]:
+    """
+    Convenience function to summarize text
+    
+    Args:
+        text: Text to summarize
+        llm_model: Optional LLM model instance
+        
+    Returns:
+        Dict with summary results
+    """
+    summarizer = DocumentSummarizer(llm_model=llm_model)
+    return await summarizer.summarize_document(text) 

app/vector_store.py

@@ -0,0 +1,55 @@
+import chromadb
+
+chroma_client = chromadb.Client()
+model = None
+
+def get_model():
+    global model
+    if model is None:
+        try:
+            from sentence_transformers import SentenceTransformer
+            model = SentenceTransformer('all-MiniLM-L6-v2')
+        except Exception as e:
+            print(f"[ERROR] Could not load SentenceTransformer: {e}")
+            model = None
+    return model
+
+COLLECTION_NAME = "documents"
+
+# Ensure collection exists
+if not chroma_client.list_collections() or COLLECTION_NAME not in [c.name for c in chroma_client.list_collections()]:
+    chroma_client.create_collection(COLLECTION_NAME)
+collection = chroma_client.get_collection(COLLECTION_NAME)
+
+def add_to_vector_store(chunks, metadatas=None):
+    try:
+        if not chunks:
+            print("[WARNING] No chunks provided to vector store")
+            return
+        model_instance = get_model()
+        if model_instance is None:
+            print("[ERROR] Embedding model not available.")
+            return
+        embeddings = model_instance.encode(chunks).tolist()
+        ids = [f"chunk_{i}" for i in range(len(chunks))]
+        collection.add(documents=chunks, embeddings=embeddings, ids=ids, metadatas=metadatas)
+        print(f"[INFO] Added {len(chunks)} chunks to vector store")
+    except Exception as e:
+        print(f"[ERROR] Failed to add chunks to vector store: {e}")
+        # Don't raise the exception to prevent the entire upload from failing
+
+def similarity_search(query, top_k=5):
+    try:
+        if not query or not query.strip():
+            return {"documents": [[]], "metadatas": [[]], "distances": [[]]}
+        model_instance = get_model()
+        if model_instance is None:
+            print("[ERROR] Embedding model not available.")
+            return {"documents": [[]], "metadatas": [[]], "distances": [[]]}
+        embedding = model_instance.encode([query]).tolist()[0]
+        results = collection.query(query_embeddings=[embedding], n_results=top_k)
+        return results
+    except Exception as e:
+        print(f"[ERROR] Similarity search failed: {e}")
+        # Return empty results instead of failing
+        return {"documents": [[]], "metadatas": [[]], "distances": [[]]} 

requirements.txt

@@ -0,0 +1,22 @@
+fastapi
+uvicorn
+langchain
+chromadb
+pypdf2
+pdfplumber
+unstructured
+pymupdf
+python-pptx
+python-docx
+sentence-transformers
+pydantic
+httpx
+python-multipart
+langchain-community
+requests
+pytesseract
+opencv-python
+pillow
+numpy
+pdf2image
+# torch, transformers, onnxruntime removed for CPU-only, API-based summarization