digest.txt

Directory structure:
└── pdf_reader_project/
    ├── README.md
    ├── Project Documentation.docx
    ├── Backend/
    │   ├── gunicorn.conf.py
    │   ├── pyproject.toml
    │   ├── render.yaml
    │   ├── requirements.txt
    │   ├── runtime.txt
    │   ├── app/
    │   │   ├── __init__.py
    │   │   ├── auth.py
    │   │   ├── auth_config.py
    │   │   ├── auth_models.py
    │   │   ├── chat_manager.py
    │   │   ├── file_processor.py
    │   │   ├── ingest.py
    │   │   ├── main.py
    │   │   ├── models.py
    │   │   ├── mongo_db.py
    │   │   ├── query.py
    │   │   ├── test_imports.py
    │   │   └── vector_search.py
    │   └── db/
    │       ├── index.faiss
    │       └── index.pkl
    └── Frontend/
        ├── README.md
        ├── eslint.config.js
        ├── index.html
        ├── package.json
        ├── postcss.config.mjs
        ├── vite.config.js
        └── src/
            ├── App.css
            ├── App.jsx
            ├── index.css
            ├── main.jsx
            ├── api/
            │   ├── api.js
            │   ├── ask.js
            │   ├── chat.js
            │   └── upload.js
            ├── components/
            │   ├── Navbar.jsx
            │   └── ProtectedRoute.jsx
            ├── context/
            │   └── AuthContext.jsx
            └── pages/
                ├── Login.jsx
                └── Signup.jsx

================================================
FILE: README.md
================================================
AI Document Chat

A RAG based application where users upload documents and ask questions.

Tech Stack:
Python
LangChain
FAISS
OpenAI
React
Node.js

Features:
• Document upload
• Semantic search
• AI answer generation
• Chat history


================================================
FILE: Project Documentation.docx
================================================
[Binary file]


================================================
FILE: Backend/gunicorn.conf.py
================================================

workers = 4
worker_class = "uvicorn.workers.UvicornWorker"
bind = "0.0.0.0:8000"
timeout = 120


================================================
FILE: Backend/pyproject.toml
================================================
# pyproject.toml
[build-system]
requires = ["setuptools", "wheel", "cython"]
build-backend = "setuptools.build_meta"


================================================
FILE: Backend/render.yaml
================================================
services:
  - type: web
    name: pdf-ai-assistant-backend
    runtime: python3
    rootDir: Backend
    buildCommand: pip install -r requirements.txt
    startCommand: uvicorn app.main:app --host 0.0.0.0 --port $PORT
    envVars:
      - key: MONGO_URI
        sync: false
      - key: GOOGLE_API_KEY
        sync: false
      - key: SECRET_KEY
        generateValue: true
      - key: ALGORITHM
        value: HS256
      - key: ACCESS_TOKEN_EXPIRE_MINUTES
        value: 30


================================================
FILE: Backend/requirements.txt
================================================
fastapi
uvicorn
gunicorn
python-multipart

langchain
langchain-community
langchain-google-genai
langchain-huggingface

google-generativeai
tiktoken

sentence-transformers
faiss-cpu

pypdf
pandas

python-dotenv

passlib[argon2]
email-validator
python-jose[cryptography]
argon2-cffi

pymongo

python-docx
openpyxl
python-pptx
pillow
pytesseract

torch --index-url https://download.pytorch.org/whl/cpu


================================================
FILE: Backend/runtime.txt
================================================
python-3.10.16


================================================
FILE: Backend/app/__init__.py
================================================
[Empty file]


================================================
FILE: Backend/app/auth.py
================================================
from fastapi import APIRouter, HTTPException, Depends, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
from app.auth_models import UserCreate, UserLogin, TokenResponse, UserResponse
from app.auth_config import verify_password, get_password_hash, create_access_token, verify_token
from app.mongo_db import db
from datetime import datetime, timedelta
from bson import ObjectId
import logging

logger = logging.getLogger(__name__)

router = APIRouter(prefix="/auth", tags=["authentication"])

# OAuth2 scheme for token authentication
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/auth/login")

# Users collection
users_collection = db["users"]

@router.post("/signup", response_model=TokenResponse)
async def signup(user_data: UserCreate):
    """Register a new user"""
    
    # Check if user already exists
    existing_user = users_collection.find_one({"email": user_data.email})
    if existing_user:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="Email already registered"
        )
    
    # Hash password and create user
    hashed_password = get_password_hash(user_data.password)
    
    user = {
        "email": user_data.email,
        "password": hashed_password,
        "created_at": datetime.utcnow()
    }
    
    result = users_collection.insert_one(user)
    user_id = str(result.inserted_id)
    
    # Create access token
    access_token = create_access_token(
        data={"sub": user_data.email, "user_id": user_id}
    )
    
    return TokenResponse(
        access_token=access_token,
        token_type="bearer",
        user=UserResponse(id=user_id, email=user_data.email)
    )

@router.post("/login", response_model=TokenResponse)
async def login(form_data: OAuth2PasswordRequestForm = Depends()):
    """Login with email and password (OAuth2 compatible)"""
    
    # Find user
    user = users_collection.find_one({"email": form_data.username})
    if not user:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Incorrect email or password",
            headers={"WWW-Authenticate": "Bearer"},
        )
    
    # Verify password
    if not verify_password(form_data.password, user["password"]):
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Incorrect email or password",
            headers={"WWW-Authenticate": "Bearer"},
        )
    
    # Create access token
    access_token = create_access_token(
        data={"sub": user["email"], "user_id": str(user["_id"])}
    )
    
    return TokenResponse(
        access_token=access_token,
        token_type="bearer",
        user=UserResponse(id=str(user["_id"]), email=user["email"])
    )

@router.post("/login/json")
async def login_json(user_data: UserLogin):
    """Login with JSON body (alternative to form)"""
    
    # Find user
    user = users_collection.find_one({"email": user_data.email})
    if not user:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Incorrect email or password"
        )
    
    # Verify password
    if not verify_password(user_data.password, user["password"]):
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Incorrect email or password"
        )
    
    # Create access token
    access_token = create_access_token(
        data={"sub": user["email"], "user_id": str(user["_id"])}
    )
    
    return {
        "access_token": access_token,
        "token_type": "bearer",
        "user": {
            "id": str(user["_id"]),
            "email": user["email"]
        }
    }

@router.get("/me", response_model=UserResponse)
async def get_current_user(token: str = Depends(oauth2_scheme)):
    """Get current user info"""
    
    payload = verify_token(token)
    if not payload:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Invalid authentication credentials",
            headers={"WWW-Authenticate": "Bearer"},
        )
    
    email = payload.get("sub")
    user_id = payload.get("user_id")
    
    if not email or not user_id:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Invalid token payload"
        )
    
    user = users_collection.find_one({"_id": ObjectId(user_id), "email": email})
    if not user:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="User not found"
        )
    
    return UserResponse(id=str(user["_id"]), email=user["email"])

# Dependency to get current user for protected routes
async def get_current_user_id(token: str = Depends(oauth2_scheme)) -> str:
    """Get current user ID from token"""
    
    payload = verify_token(token)
    if not payload:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Invalid authentication credentials",
            headers={"WWW-Authenticate": "Bearer"},
        )
    
    user_id = payload.get("user_id")
    if not user_id:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Invalid token"
        )
    
    return user_id


================================================
FILE: Backend/app/auth_config.py
================================================
from passlib.context import CryptContext
from datetime import datetime, timedelta
from jose import JWTError, jwt
import os
from dotenv import load_dotenv

load_dotenv()

# JWT Configuration
SECRET_KEY = os.getenv("SECRET_KEY", "your-secret-key-change-in-production")
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30

# Password hashing - using argon2 which doesn't have the 72-byte limit
pwd_context = CryptContext(
    schemes=["argon2"],
    deprecated="auto",
    argon2__memory_cost=65536,  # 64MB
    argon2__time_cost=3,
    argon2__parallelism=4
)

def verify_password(plain_password, hashed_password):
    """Verify a plain password against a hashed password"""
    try:
        return pwd_context.verify(plain_password, hashed_password)
    except Exception as e:
        print(f"Password verification error: {e}")
        return False

def get_password_hash(password):
    """Hash a password"""
    try:
        return pwd_context.hash(password)
    except Exception as e:
        print(f"Password hashing error: {e}")
        raise

def create_access_token(data: dict, expires_delta: timedelta = None):
    """Create a JWT access token"""
    to_encode = data.copy()
    if expires_delta:
        expire = datetime.utcnow() + expires_delta
    else:
        expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
    to_encode.update({"exp": expire})
    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
    return encoded_jwt

def verify_token(token: str):
    """Verify a JWT token and return the payload"""
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        return payload
    except JWTError:
        return None


================================================
FILE: Backend/app/auth_models.py
================================================
from pydantic import BaseModel, EmailStr, Field
from typing import Optional

class UserCreate(BaseModel):
    """User registration model"""
    email: EmailStr
    password: str = Field(..., min_length=6)

class UserLogin(BaseModel):
    """User login model"""
    email: EmailStr
    password: str

class UserResponse(BaseModel):
    """User response model"""
    id: str
    email: str

class TokenResponse(BaseModel):
    """Token response model"""
    access_token: str
    token_type: str
    user: UserResponse

class TokenData(BaseModel):
    """Token data model"""
    email: Optional[str] = None
    user_id: Optional[str] = None


================================================
FILE: Backend/app/chat_manager.py
================================================
from app.mongo_db import db
from app.models import ChatSession, Message, MessageRole, ChatSessionResponse
from datetime import datetime
from typing import List, Optional, Dict, Any
import uuid
import logging
from bson import ObjectId

logger = logging.getLogger(__name__)

sessions_collection = db["chat_sessions"]
messages_collection = db["messages"]

class ChatSessionManager:
    
    @staticmethod
    async def create_session(user_id: str, title: str = None) -> Dict[str, Any]:
        """Create a new chat session"""
        if not title:
            title = f"Chat Session {datetime.utcnow().strftime('%Y-%m-%d %H:%M')}"
        
        session_id = str(uuid.uuid4())
        
        session = {
            "session_id": session_id,
            "user_id": user_id,
            "title": title,
            "created_at": datetime.utcnow(),
            "updated_at": datetime.utcnow(),
            "files": [],
            "message_count": 0
        }
        
        sessions_collection.insert_one(session)
        
        return {
            "session_id": session_id,
            "title": title,
            "created_at": session["created_at"],
            "updated_at": session["updated_at"],
            "message_count": 0,
            "file_count": 0
        }
    
    @staticmethod
    async def get_user_sessions(user_id: str) -> List[Dict[str, Any]]:
        """Get all sessions for a user"""
        cursor = sessions_collection.find(
            {"user_id": user_id}
        ).sort("updated_at", -1)
        
        sessions = []
        for doc in cursor:
            sessions.append({
                "session_id": doc["session_id"],
                "title": doc["title"],
                "created_at": doc["created_at"],
                "updated_at": doc["updated_at"],
                "message_count": doc.get("message_count", 0),
                "file_count": len(doc.get("files", []))
            })
        
        return sessions
    
    @staticmethod
    async def get_session(session_id: str, user_id: str) -> Optional[Dict[str, Any]]:
        """Get a specific session"""
        session = sessions_collection.find_one({
            "session_id": session_id,
            "user_id": user_id
        })
        
        if not session:
            return None
        
        # Get messages for this session
        messages = list(messages_collection.find(
            {"session_id": session_id}
        ).sort("timestamp", 1))
        
        return {
            "session_id": session["session_id"],
            "title": session["title"],
            "created_at": session["created_at"],
            "updated_at": session["updated_at"],
            "files": session.get("files", []),
            "messages": [
                {
                    "role": msg["role"],
                    "content": msg["content"],
                    "timestamp": msg["timestamp"],
                    "sources": msg.get("sources", [])
                }
                for msg in messages
            ]
        }
    
    @staticmethod
    async def add_message(
        session_id: str,
        user_id: str,
        role: MessageRole,
        content: str,
        sources: List[Dict[str, Any]] = None
    ) -> None:
        """Add a message to a session"""
        # Verify session belongs to user
        session = sessions_collection.find_one({
            "session_id": session_id,
            "user_id": user_id
        })
        
        if not session:
            raise ValueError("Session not found")
        
        # Add message
        message = {
            "session_id": session_id,
            "role": role.value if isinstance(role, MessageRole) else role,
            "content": content,
            "timestamp": datetime.utcnow(),
            "sources": sources or []
        }
        
        messages_collection.insert_one(message)
        
        # Update session
        sessions_collection.update_one(
            {"session_id": session_id},
            {
                "$set": {"updated_at": datetime.utcnow()},
                "$inc": {"message_count": 1}
            }
        )
    
    @staticmethod
    async def add_file_to_session(session_id: str, user_id: str, filename: str) -> None:
        """Add a file reference to a session"""
        sessions_collection.update_one(
            {
                "session_id": session_id,
                "user_id": user_id
            },
            {
                "$addToSet": {"files": filename},
                "$set": {"updated_at": datetime.utcnow()}
            }
        )
    
    @staticmethod
    async def delete_session(session_id: str, user_id: str) -> bool:
        """Delete a session and its messages"""
        result = sessions_collection.delete_one({
            "session_id": session_id,
            "user_id": user_id
        })
        
        if result.deleted_count > 0:
            # Delete messages
            messages_collection.delete_many({"session_id": session_id})
            
            # Note: Files are not deleted, just disassociated
            return True
        
        return False
    
    @staticmethod
    async def get_session_files(session_id: str, user_id: str) -> List[str]:
        """Get all files associated with a session"""
        session = sessions_collection.find_one({
            "session_id": session_id,
            "user_id": user_id
        })
        
        return session.get("files", []) if session else []


================================================
FILE: Backend/app/file_processor.py
================================================
import os
import logging
import tempfile
import uuid
from typing import List, Dict, Any, Optional
from datetime import datetime
from langchain_community.document_loaders import (
    PyPDFLoader,
    TextLoader,
    Docx2txtLoader,
    UnstructuredExcelLoader,
    UnstructuredPowerPointLoader,
)
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_core.documents import Document  # Updated import
from app.mongo_db import collection, fs, files_collection
import pandas as pd
import pytesseract
from PIL import Image
import io

logger = logging.getLogger(__name__)

# Initialize embeddings
embeddings = HuggingFaceEmbeddings(
    model_name="sentence-transformers/all-MiniLM-L6-v2"
)

class FileProcessor:
    SUPPORTED_EXTENSIONS = {
        '.pdf': 'pdf',
        '.docx': 'docx',
        '.doc': 'docx',
        '.txt': 'txt',
        '.csv': 'xlsx',
        '.xlsx': 'xlsx',
        '.xls': 'xlsx',
        '.pptx': 'pptx',
        '.ppt': 'pptx',
        '.jpg': 'image',
        '.jpeg': 'image',
        '.png': 'image',
        '.gif': 'image'
    }
    
    @classmethod
    def get_file_type(cls, filename: str) -> str:
        ext = os.path.splitext(filename)[1].lower()
        return cls.SUPPORTED_EXTENSIONS.get(ext, 'txt')
    
    @classmethod
    async def process_file(cls, file_bytes: bytes, filename: str, user_id: str, session_id: Optional[str] = None) -> Dict[str, Any]:
        """Process any supported file type and store in MongoDB"""
        
        temp_file_path = None
        file_type = cls.get_file_type(filename)
        
        try:
            # Create temp file
            unique_filename = f"{uuid.uuid4()}_{filename}"
            temp_dir = os.path.join(tempfile.gettempdir(), "file_processor")
            os.makedirs(temp_dir, exist_ok=True)
            temp_file_path = os.path.join(temp_dir, unique_filename)
            
            with open(temp_file_path, 'wb') as f:
                f.write(file_bytes)
            
            # Load documents based on file type
            documents = await cls._load_documents(temp_file_path, filename, file_type)
            
            if not documents:
                raise ValueError(f"No content extracted from {filename}")
            
            # Split documents into chunks
            splitter = RecursiveCharacterTextSplitter(
                chunk_size=1000,
                chunk_overlap=200
            )
            splits = splitter.split_documents(documents)
            
            # Store in MongoDB with embeddings
            success_count = 0
            for i, doc in enumerate(splits):
                try:
                    embedding = embeddings.embed_query(doc.page_content)
                    
                    collection.insert_one({
                        "text": doc.page_content,
                        "embedding": embedding,
                        "metadata": doc.metadata,
                        "file": filename,
                        "file_type": file_type,
                        "user_id": user_id,
                        "session_id": session_id,
                        "chunk_id": i,
                        "timestamp": datetime.utcnow()
                    })
                    success_count += 1
                except Exception as e:
                    logger.error(f"Failed to store chunk {i}: {e}")
                    continue
            
            # Store file in GridFS
            file_id = fs.put(
                file_bytes,
                filename=filename,
                uploadDate=datetime.utcnow(),
                contentType=cls._get_mime_type(file_type),
                metadata={
                    "user_id": user_id,
                    "file_type": file_type,
                    "session_id": session_id
                }
            )
            
            # Store file metadata
            files_collection.insert_one({
                "file_id": file_id,
                "filename": filename,
                "file_type": file_type,
                "user_id": user_id,
                "session_id": session_id,
                "upload_date": datetime.utcnow(),
                "size": len(file_bytes),
                "chunks": success_count
            })
            
            return {
                "success": True,
                "filename": filename,
                "file_type": file_type,
                "chunks_stored": success_count,
                "file_id": str(file_id)
            }
            
        except Exception as e:
            logger.error(f"File processing failed: {e}")
            raise
        finally:
            if temp_file_path and os.path.exists(temp_file_path):
                try:
                    os.remove(temp_file_path)
                except:
                    pass
    
    @classmethod
    async def _load_documents(cls, file_path: str, filename: str, file_type: str) -> List[Document]:
        """Load documents based on file type"""
        
        try:
            if file_type == 'pdf':
                loader = PyPDFLoader(file_path)
                return loader.load()
                
            elif file_type == 'docx':
                loader = Docx2txtLoader(file_path)
                return loader.load()
                
            elif file_type == 'txt':
                loader = TextLoader(file_path, encoding='utf-8')
                return loader.load()
                
            elif file_type == 'xlsx':
                # Handle Excel files
                try:
                    df_dict = pd.read_excel(file_path, sheet_name=None)
                    documents = []
                    for sheet_name, df in df_dict.items():
                        content = f"Sheet: {sheet_name}\n"
                        content += df.to_string()
                        doc = Document(
                            page_content=content,
                            metadata={"source": filename, "sheet": sheet_name, "page": 0}
                        )
                        documents.append(doc)
                    return documents
                except Exception as e:
                    logger.error(f"Excel processing error: {e}")
                    loader = UnstructuredExcelLoader(file_path)
                    return loader.load()
                    
            elif file_type == 'pptx':
                loader = UnstructuredPowerPointLoader(file_path)
                return loader.load()
                
            elif file_type == 'image':
                # Handle images with OCR
                try:
                    image = Image.open(file_path)
                    text = pytesseract.image_to_string(image)
                    doc = Document(
                        page_content=text,
                        metadata={"source": filename, "page": 0}
                    )
                    return [doc]
                except Exception as e:
                    logger.error(f"OCR failed: {e}")
                    return []
                    
            else:
                # Default to text loader
                loader = TextLoader(file_path, encoding='utf-8')
                return loader.load()
        except Exception as e:
            logger.error(f"Error loading documents: {e}")
            return []
    
    @staticmethod
    def _get_mime_type(file_type: str) -> str:
        mime_types = {
            'pdf': 'application/pdf',
            'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
            'txt': 'text/plain',
            'xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
            'pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
            'image': 'image/jpeg'
        }
        return mime_types.get(file_type, 'application/octet-stream')


================================================
FILE: Backend/app/ingest.py
================================================
from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_huggingface import HuggingFaceEmbeddings
from pymongo import MongoClient
import os
import logging
from dotenv import load_dotenv
import io
from datetime import datetime
import tempfile
import uuid

load_dotenv()

# Setup logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# MongoDB connection
try:
    client = MongoClient(os.getenv("MONGO_URI"))
    db = client["pdf_ai"]
    collection = db["documents"]
    logger.info("Connected to MongoDB")
except Exception as e:
    logger.error(f"MongoDB connection failed: {e}")
    raise

# Initialize embeddings
try:
    embeddings = HuggingFaceEmbeddings(
        model_name="sentence-transformers/all-MiniLM-L6-v2"
    )
    logger.info("Embeddings model loaded successfully")
except Exception as e:
    logger.error(f"Failed to load embeddings model: {e}")
    raise

def ingest_pdf_from_bytes(pdf_bytes, filename, user_id):
    """Process PDF from bytes and store in MongoDB with vector embeddings"""
    
    temp_file_path = None
    
    try:
        # Create a unique filename to avoid conflicts
        unique_filename = f"{uuid.uuid4()}_{filename}"
        
        # Create temp directory if it doesn't exist
        temp_dir = os.path.join(tempfile.gettempdir(), "pdf_processor")
        os.makedirs(temp_dir, exist_ok=True)
        
        # Create temp file path
        temp_file_path = os.path.join(temp_dir, unique_filename)
        
        # Write bytes to temp file with proper permissions
        logger.info(f"Creating temp file: {temp_file_path}")
        with open(temp_file_path, 'wb') as f:
            f.write(pdf_bytes)
        
        # Verify file was written
        if not os.path.exists(temp_file_path):
            raise Exception("Failed to create temp file")
        
        logger.info(f"Temp file created successfully, size: {os.path.getsize(temp_file_path)} bytes")
        
        # Load PDF using the temp file
        loader = PyPDFLoader(temp_file_path)
        documents = loader.load()
        
        if not documents:
            raise ValueError("No content extracted from PDF")
        
        logger.info(f"Loaded {len(documents)} pages from PDF")

        # Split documents into chunks
        splitter = RecursiveCharacterTextSplitter(
            chunk_size=1000,
            chunk_overlap=200
        )
        splits = splitter.split_documents(documents)
        logger.info(f"Created {len(splits)} text chunks")

        # Store in MongoDB with embeddings and user_id
        success_count = 0
        for i, doc in enumerate(splits):
            try:
                # Generate embedding
                embedding = embeddings.embed_query(doc.page_content)
                
                # Store in MongoDB with user_id
                collection.insert_one({
                    "text": doc.page_content,
                    "embedding": embedding,
                    "page": doc.metadata.get("page", 0),
                    "file": filename,
                    "user_id": user_id,
                    "chunk_id": i,
                    "timestamp": datetime.utcnow()
                })
                success_count += 1
                
            except Exception as e:
                logger.error(f"Failed to store chunk {i}: {e}")
                continue

        logger.info(f"Successfully stored {success_count}/{len(splits)} chunks in MongoDB")
        return {"success": True, "chunks_stored": success_count}
        
    except Exception as e:
        logger.error(f"PDF ingestion failed: {e}")
        raise
        
    finally:
        # Clean up temp file
        if temp_file_path and os.path.exists(temp_file_path):
            try:
                # Make sure file is not locked before deleting
                import time
                time.sleep(0.1)  # Small delay to ensure file is released
                os.remove(temp_file_path)
                logger.info(f"Temp file deleted: {temp_file_path}")
            except Exception as e:
                logger.warning(f"Could not delete temp file {temp_file_path}: {e}")


================================================
FILE: Backend/app/main.py
================================================
Error reading file with 'cp1252': 'charmap' codec can't decode byte 0x9d in position 1398: character maps to <undefined>


================================================
FILE: Backend/app/models.py
================================================
from pydantic import BaseModel, Field
from typing import Optional, List, Dict, Any
from datetime import datetime
from enum import Enum

class FileType(str, Enum):
    PDF = "pdf"
    DOCX = "docx"
    TXT = "txt"
    XLSX = "xlsx"
    PPTX = "pptx"
    IMAGE = "image"

class MessageRole(str, Enum):
    USER = "user"
    ASSISTANT = "assistant"
    SYSTEM = "system"

class Message(BaseModel):
    role: MessageRole
    content: str
    timestamp: datetime = Field(default_factory=datetime.utcnow)
    sources: Optional[List[Dict[str, Any]]] = None

class ChatSession(BaseModel):
    session_id: str
    user_id: str
    title: str
    created_at: datetime = Field(default_factory=datetime.utcnow)
    updated_at: datetime = Field(default_factory=datetime.utcnow)
    messages: List[Message] = []
    files: List[str] = []  # List of filenames used in this session

class ChatSessionCreate(BaseModel):
    title: Optional[str] = None

class ChatSessionResponse(BaseModel):
    session_id: str
    title: str
    created_at: datetime
    updated_at: datetime
    message_count: int
    file_count: int

class ChatRequest(BaseModel):
    session_id: Optional[str] = None
    message: str
    files: Optional[List[str]] = None  # Optional: specify which files to use

class ChatResponse(BaseModel):
    session_id: str
    message: str
    sources: List[Dict[str, Any]]
    timestamp: datetime

class FileUploadResponse(BaseModel):
    filename: str
    file_type: FileType
    size: int
    chunks_processed: int
    session_id: Optional[str] = None


================================================
FILE: Backend/app/mongo_db.py
================================================
from pymongo import MongoClient, ASCENDING, TEXT
import gridfs
import os
from dotenv import load_dotenv
import logging

load_dotenv()

MONGO_URI = os.getenv("MONGO_URI")
if not MONGO_URI:
    raise ValueError("MONGO_URI not found in environment variables")

try:
    client = MongoClient(MONGO_URI)
    # Test connection
    client.admin.command('ping')
    logging.info("Connected to MongoDB successfully")
except Exception as e:
    logging.error(f"Failed to connect to MongoDB: {e}")
    raise

db = client["pdf_ai"]

# Collections
collection = db["documents"]
users_collection = db["users"]
files_collection = db["files"]
sessions_collection = db["chat_sessions"]
messages_collection = db["messages"]

# Create indexes
users_collection.create_index([("email", ASCENDING)], unique=True)

# File indexes
files_collection.create_index([
    ("user_id", ASCENDING),
    ("filename", ASCENDING)
])
files_collection.create_index([("session_id", ASCENDING)])
files_collection.create_index([("upload_date", ASCENDING)])

# Document chunks indexes
collection.create_index([
    ("user_id", ASCENDING),
    ("file", ASCENDING)
])
collection.create_index([("session_id", ASCENDING)])
collection.create_index([("timestamp", ASCENDING)])
collection.create_index([("file_type", ASCENDING)])

# Text search index for fallback
collection.create_index([
    ("text", TEXT)
])

# Chat sessions indexes
sessions_collection.create_index([
    ("user_id", ASCENDING),
    ("updated_at", -1)
])
sessions_collection.create_index([("session_id", ASCENDING)], unique=True)

# Messages indexes
messages_collection.create_index([
    ("session_id", ASCENDING),
    ("timestamp", ASCENDING)
])

# Add GridFS for file storage
fs = gridfs.GridFS(db)


================================================
FILE: Backend/app/query.py
================================================
from app.vector_search import search_documents
from app.chat_manager import ChatSessionManager
from app.models import MessageRole
from langchain_google_genai import ChatGoogleGenerativeAI
import os
from dotenv import load_dotenv
import logging
from typing import Optional, List

# Setup logging
load_dotenv()
logger = logging.getLogger(__name__)

# Initialize Gemini model
try:
    model = ChatGoogleGenerativeAI(
        model="gemini-2.5-flash",
        google_api_key=os.getenv("GOOGLE_API_KEY"),
        temperature=0.3,
        max_tokens=1000
    )
    logger.info("Gemini model initialized successfully")
except Exception as e:
    logger.error(f"Failed to initialize Gemini model: {e}")
    model = None

async def ask_question(
    question: str,
    user_id: str,
    session_id: Optional[str] = None,
    files: Optional[List[str]] = None
):
    """Answer question using RAG pipeline with session support"""
    
    if not model:
        logger.error("AI model not available")
        return {
            "answer": "AI model not available. Please check your Google API key.",
            "sources": []
        }
    
    try:
        logger.info(f"Processing question for user {user_id}: {question[:100]}...")
        
        # Get conversation history if session exists
        conversation_history = ""
        if session_id:
            logger.info(f"Getting session history for session {session_id}")
            session = await ChatSessionManager.get_session(session_id, user_id)
            if session and session.get("messages"):
                # Get last 5 messages for context
                recent_messages = session["messages"][-5:]
                for msg in recent_messages:
                    role = "User" if msg["role"] == "user" else "Assistant"
                    conversation_history += f"{role}: {msg['content']}\n"
                logger.info(f"Found {len(recent_messages)} recent messages")
        
        # Search for relevant documents
        logger.info(f"Searching documents for query")
        docs = search_documents(
            query=question,
            user_id=user_id,
            session_id=session_id,
            files=files
        )
        if not session_id:
         return {
           "answer": "Session ID missing. Please start a chat session.",
          "sources": []
        }
        
        if not docs:
            logger.warning("No relevant documents found")
            return {
                "answer": "No relevant documents found. Please upload files first.",
                "sources": []
            }
        
        logger.info(f"Found {len(docs)} relevant documents")
        
        # Prepare context
        context = ""
        sources = []
        
        for doc in docs:
            context += f"\nFrom {doc['file']} (Type: {doc.get('file_type', 'unknown')}):\n{doc['text']}\n"
            sources.append({
                "file": doc["file"],
                "file_type": doc.get("file_type", "unknown"),
                "score": doc.get("score"),
                "text_snippet": doc["text"][:200] + "..." if len(doc["text"]) > 200 else doc["text"]
            })
        
        # Create prompt with conversation history
        prompt = f"""You are a helpful assistant that answers questions based on the provided context.

Conversation History:
{conversation_history if conversation_history else "No previous conversation."}

Current Context from uploaded files:
{context}

Current Question: {question}

Instructions:
1. Answer based only on the provided context and conversation history
2. If the answer isn't in the context, say "I cannot find this information in the uploaded files"
3. Be concise and accurate
4. Reference which file you're getting information from when possible

Answer:"""

        # Get response from Gemini
        logger.info("Sending prompt to Gemini")
        response = model.invoke(prompt)
        logger.info("Received response from Gemini")
        
        return {
            "answer": response.content,
            "sources": sources
        }
        
    except Exception as e:
        logger.error(f"Question answering failed: {str(e)}")
        return {
            "answer": f"Error processing question: {str(e)}",
            "sources": []
        }


================================================
FILE: Backend/app/test_imports.py
================================================
# test_imports.py
print("Testing imports...")
try:
    from app.main import app
    print("✅ main.py imported")
except Exception as e:
    print(f"❌ main.py import failed: {e}")

try:
    from app.file_processor import FileProcessor
    print("✅ file_processor.py imported")
except Exception as e:
    print(f"❌ file_processor.py import failed: {e}")

try:
    from app.query import ask_question
    print("✅ query.py imported")
except Exception as e:
    print(f"❌ query.py import failed: {e}")

try:
    from app.mongo_db import client
    print("✅ mongo_db.py imported")
except Exception as e:
    print(f"❌ mongo_db.py import failed: {e}")


================================================
FILE: Backend/app/vector_search.py
================================================
from app.mongo_db import collection
from langchain_community.embeddings import HuggingFaceEmbeddings
import logging
from typing import List, Dict, Any, Optional

# Setup logger
logger = logging.getLogger(__name__)

try:
    embeddings = HuggingFaceEmbeddings(
        model_name="sentence-transformers/all-MiniLM-L6-v2"
    )
    logger.info("Embeddings model loaded successfully")
except Exception as e:
    logger.error(f"Failed to load embeddings: {e}")
    raise

def search_documents(
    query: str,
    user_id: str,
    session_id: Optional[str] = None,
    files: Optional[List[str]] = None,
    limit: int = 5
) -> List[Dict[str, Any]]:
    """Search for relevant documents using vector similarity"""
    
    if not query or not query.strip():
        raise ValueError("Query cannot be empty")
    
    try:
        # Generate query embedding
        query_vector = embeddings.embed_query(query)
        
        # MongoDB vector search pipeline WITHOUT filter first (using post-filtering)
        pipeline = [
        {
        "$vectorSearch": {
            "index": "vector_index",
            "path": "embedding",
            "queryVector": query_vector,
            "numCandidates": 100,
            "limit": 5,
            "filter": {
               "user_id": user_id,  
               "session_id":session_id                  
            }
         }
        },
        {
        "$project": {
              "text": 1,
             "file": 1,
             "file_type": 1,
             "metadata": 1,
             "score": {"$meta": "vectorSearchScore"}
            }
         }
        ]
        
        # Execute search
        results = collection.aggregate(pipeline)
        
        # Process results
        docs = []
        for r in results:
            docs.append({
                "text": r.get("text", ""),
                "metadata": r.get("metadata", {}),
                "file": r.get("file", "unknown"),
                "file_type": r.get("file_type", "unknown"),
                "score": r.get("score", 0)
            })
        
        logger.info(f"Found {len(docs)} relevant documents for user {user_id}")
        
        # If no results found with vector search, try fallback
        if not docs:
            logger.info("No vector search results, trying fallback text search")
            return fallback_text_search(query, user_id, session_id, files, limit)
            
        return docs
        
    except Exception as e:
        logger.error(f"Vector search failed: {str(e)}")
        # Fallback to text search
        return fallback_text_search(query, user_id, session_id, files, limit)

def fallback_text_search(
    query: str,
    user_id: str,
    session_id: Optional[str] = None,
    files: Optional[List[str]] = None,
    limit: int = 3
) -> List[Dict[str, Any]]:
    """Fallback text search if vector search fails"""
    try:
        logger.info(f"Performing fallback text search for query: {query[:50]}...")
        
        # Build filter
        filter_conditions = {
            "text": {"$regex": query, "$options": "i"},
            "user_id": user_id
        }
        
        if session_id:
            filter_conditions["session_id"] = session_id
        
        if files:
            filter_conditions["file"] = {"$in": files}
        
        results = collection.find(filter_conditions).limit(limit)
        
        docs = []
        for r in results:
            docs.append({
                "text": r.get("text", ""),
                "metadata": r.get("metadata", {}),
                "file": r.get("file", "unknown"),
                "file_type": r.get("file_type", "unknown")
            })
        
        logger.info(f"Fallback search found {len(docs)} documents")
        return docs
        
    except Exception as e:
        logger.error(f"Fallback search failed: {str(e)}")
        return []


================================================
FILE: Backend/db/index.faiss
================================================
[Binary file]


================================================
FILE: Backend/db/index.pkl
================================================
[Binary file]


================================================
FILE: Frontend/README.md
================================================
# React + Vite

This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.

Currently, two official plugins are available:

- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Babel](https://babeljs.io/) (or [oxc](https://oxc.rs) when used in [rolldown-vite](https://vite.dev/guide/rolldown)) for Fast Refresh
- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh

## React Compiler

The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation).

## Expanding the ESLint configuration

If you are developing a production application, we recommend using TypeScript with type-aware lint rules enabled. Check out the [TS template](https://github.com/vitejs/vite/tree/main/packages/create-vite/template-react-ts) for information on how to integrate TypeScript and [`typescript-eslint`](https://typescript-eslint.io) in your project.



================================================
FILE: Frontend/eslint.config.js
================================================
import js from '@eslint/js'
import globals from 'globals'
import reactHooks from 'eslint-plugin-react-hooks'
import reactRefresh from 'eslint-plugin-react-refresh'
import { defineConfig, globalIgnores } from 'eslint/config'

export default defineConfig([
  globalIgnores(['dist']),
  {
    files: ['**/*.{js,jsx}'],
    extends: [
      js.configs.recommended,
      reactHooks.configs.flat.recommended,
      reactRefresh.configs.vite,
    ],
    languageOptions: {
      ecmaVersion: 2020,
      globals: globals.browser,
      parserOptions: {
        ecmaVersion: 'latest',
        ecmaFeatures: { jsx: true },
        sourceType: 'module',
      },
    },
    rules: {
      'no-unused-vars': ['error', { varsIgnorePattern: '^[A-Z_]' }],
    },
  },
])



================================================
FILE: Frontend/index.html
================================================
<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>frontend</title>
  </head>
  <body>
    <div id="root"></div>
    <script type="module" src="/src/main.jsx"></script>
  </body>
</html>



================================================
FILE: Frontend/package.json
================================================
{
  "name": "frontend",
  "private": true,
  "version": "0.0.0",
  "type": "module",
  "scripts": {
    "dev": "vite",
    "build": "vite build",
    "lint": "eslint .",
    "preview": "vite preview"
  },
  "dependencies": {
    "@tailwindcss/postcss": "^4.2.1",
    "axios": "^1.13.6",
    "lucide-react": "^0.577.0",
    "postcss": "^8.5.8",
    "react": "^19.2.0",
    "react-dom": "^19.2.0",
    "react-dropzone": "^15.0.0",
    "react-markdown": "^10.1.0",
    "react-router-dom": "^7.13.1",
    "tailwindcss": "^4.2.1"
  },
  "devDependencies": {
    "@eslint/js": "^9.39.1",
    "@types/react": "^19.2.7",
    "@types/react-dom": "^19.2.3",
    "@vitejs/plugin-react": "^5.1.1",
    "eslint": "^9.39.1",
    "eslint-plugin-react-hooks": "^7.0.1",
    "eslint-plugin-react-refresh": "^0.4.24",
    "globals": "^16.5.0",
    "vite": "^7.3.1"
  }
}



================================================
FILE: Frontend/postcss.config.mjs
================================================
export default {
  plugins: {
    "@tailwindcss/postcss": {},
  }
}


================================================
FILE: Frontend/vite.config.js
================================================
import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'

// https://vite.dev/config/
export default defineConfig({
  plugins: [react()],
})



================================================
FILE: Frontend/src/App.css
================================================
[Empty file]


================================================
FILE: Frontend/src/App.jsx
================================================
Error reading file with 'cp1252': 'charmap' codec can't decode byte 0x9d in position 7894: character maps to <undefined>


================================================
FILE: Frontend/src/index.css
================================================
@import "tailwindcss";

@layer base {
  body {
    @apply antialiased;
    overflow: hidden;
  }

  /* Dark mode styles */
  .dark {
    color-scheme: dark;
  }

  /* Custom scrollbar */
  ::-webkit-scrollbar {
    width: 8px;
    height: 8px;
  }

  ::-webkit-scrollbar-track {
    @apply bg-gray-100 dark:bg-gray-800;
  }

  ::-webkit-scrollbar-thumb {
    @apply bg-gray-300 dark:bg-gray-600 rounded-full;
  }

  ::-webkit-scrollbar-thumb:hover {
    @apply bg-gray-400 dark:bg-gray-500;
  }
}

@layer components {
  /* Message animations */
  .message-enter {
    animation: slideIn 0.3s ease-out;
  }

  @keyframes slideIn {
    from {
      opacity: 0;
      transform: translateY(20px);
    }
    to {
      opacity: 1;
      transform: translateY(0);
    }
  }

  /* Typing indicator animation */
  .animate-bounce {
    animation: bounce 1s infinite;
  }

  @keyframes bounce {
    0%, 60%, 100% {
      transform: translateY(0);
    }
    30% {
      transform: translateY(-10px);
    }
  }

  /* Pulse animation for recording */
  .animate-pulse {
    animation: pulse 2s infinite;
  }

  @keyframes pulse {
    0%, 100% {
      opacity: 1;
    }
    50% {
      opacity: 0.5;
    }
  }

  /* Markdown styles */
  .prose {
    @apply text-gray-800 dark:text-gray-200;
  }

  .prose h1 {
    @apply text-2xl font-bold mb-4;
  }

  .prose h2 {
    @apply text-xl font-bold mb-3;
  }

  .prose h3 {
    @apply text-lg font-bold mb-2;
  }

  .prose p {
    @apply mb-2;
  }

  .prose ul {
    @apply list-disc list-inside mb-2;
  }

  .prose ol {
    @apply list-decimal list-inside mb-2;
  }

  .prose code {
    @apply bg-gray-100 dark:bg-gray-700 px-1 py-0.5 rounded text-sm;
  }

  .prose pre {
    @apply bg-gray-100 dark:bg-gray-700 p-3 rounded-lg overflow-x-auto mb-2;
  }

  .prose blockquote {
    @apply border-l-4 border-gray-300 dark:border-gray-600 pl-4 italic;
  }

  .prose a {
    @apply text-blue-600 dark:text-blue-400 hover:underline;
  }

  /* File upload preview */
  .file-preview {
    @apply bg-gray-50 dark:bg-gray-800 rounded-lg p-2;
  }

  /* Loading spinner */
  .loading-spinner {
    @apply animate-spin rounded-full border-2 border-gray-300 dark:border-gray-600 border-t-blue-600 dark:border-t-blue-400;
  }

  /* Tooltip */
  .tooltip {
    @apply absolute -top-8 left-1/2 transform -translate-x-1/2 bg-gray-800 text-white text-xs py-1 px-2 rounded opacity-0 group-hover:opacity-100 transition-opacity whitespace-nowrap pointer-events-none;
  }

  /* Gradient text */
  .gradient-text {
    @apply bg-gradient-to-r from-blue-600 to-purple-600 bg-clip-text text-transparent;
  }

  /* Glass effect */
  .glass {
    @apply bg-white/80 dark:bg-gray-900/80 backdrop-blur-lg;
  }
}


================================================
FILE: Frontend/src/main.jsx
================================================
import { StrictMode } from 'react'
import { createRoot } from 'react-dom/client'
import { BrowserRouter, Routes, Route } from 'react-router-dom'
import './index.css'
import App from './App.jsx'
import Login from './pages/Login.jsx'
import Signup from './pages/Signup.jsx'
import { AuthProvider } from './context/AuthContext'
import ProtectedRoute from './components/ProtectedRoute'
import Navbar from './components/Navbar'

createRoot(document.getElementById('root')).render(
  <StrictMode>
    <BrowserRouter>
      <AuthProvider>
        <Navbar />
        <Routes>
          <Route path="/login" element={<Login />} />
          <Route path="/signup" element={<Signup />} />
          <Route path="/" element={
            <ProtectedRoute>
              <App />
            </ProtectedRoute>
          } />
        </Routes>
      </AuthProvider>
    </BrowserRouter>
  </StrictMode>,
)


================================================
FILE: Frontend/src/api/api.js
================================================
import axios from 'axios';

const API = axios.create({
    baseURL: 'http://127.0.0.1:8000',
})

API.interceptors.response.use(
    response => response,
    error => {
        if (error.code === 'ECONNABORTED') {
            console.error('Request timeout');
            return Promise.reject(new Error('Request timed out. Please try again.'));
        }
        if (!error.response) {
            console.error('Network error - backend not reachable');
            return Promise.reject(new Error('Cannot connect to server. Make sure backend is running.'));
        }
        // Handle 401 Unauthorized - token expired or invalid
        if (error.response?.status === 401) {
            // Clear token and redirect to login
            localStorage.removeItem('token');
            delete API.defaults.headers.common['Authorization'];
            window.location.href = '/login';
        }
        return Promise.reject(error);
    }
);

export default API;


================================================
FILE: Frontend/src/api/ask.js
================================================
import API from "./api";

export const askQuestion = async (question , sessionId) => {
    try {
        const res = await API.post('/ask', {
            question: question,
            session_id: sessionId
        });
        
        // Validate response structure
        if (!res.data) {
            throw new Error('Empty response from server');
        }
        
        return {
            answer: res.data.answer || 'No answer received',
            sources: res.data.sources || [],
            question: res.data.question || question
        };
    } catch (error) {
        // Enhanced error handling
        if (error.response) {
            // Server responded with error
            throw new Error(error.response.data?.detail || `Error ${error.response.status}: Failed to get answer`);
        } else if (error.request) {
            // No response received
            throw new Error('Cannot reach server. Make sure backend is running.');
        } else {
            // Other errors
            throw new Error(error.message || 'Failed to ask question');
        }
    }
};


================================================
FILE: Frontend/src/api/chat.js
================================================
import API from "./api";

export const getSessions = async () => {
    try {
        const response = await API.get('/sessions');
        return response.data;
    } catch (error) {
        console.error('Failed to fetch sessions:', error);
        throw error;
    }
};

export const getSession = async (sessionId) => {
    try {
        const response = await API.get(`/sessions/${sessionId}`);
        return response.data;
    } catch (error) {
        console.error('Failed to fetch session:', error);
        throw error;
    }
};

export const createSession = async (title = null) => {
    try {
        const response = await API.post('/sessions', null, {
            params: { title }
        });
        return response.data;
    } catch (error) {
        console.error('Failed to create session:', error);
        throw error;
    }
};

export const updateSession = async (sessionId, title) => {
    try {
        const response = await API.put(`/sessions/${sessionId}`, { title });
        return response.data;
    } catch (error) {
        console.error('Failed to update session:', error);
        throw error;
    }
};

export const deleteSession = async (sessionId) => {
    try {
        const response = await API.delete(`/sessions/${sessionId}`);
        return response.data;
    } catch (error) {
        console.error('Failed to delete session:', error);
        throw error;
    }
};

export const sendMessage = async (sessionId, message, files = []) => {
    try {
        const response = await API.post('/chat', {
            session_id: sessionId,
            message: message,
            files: files
        });
        return response.data;
    } catch (error) {
        console.error('Failed to send message:', error);
        throw error;
    }
};

export const getMessages = async (sessionId) => {
    try {
        const response = await API.get(`/sessions/${sessionId}/messages`);
        return response.data;
    } catch (error) {
        console.error('Failed to get messages:', error);
        throw error;
    }
};

export const deleteMessage = async (sessionId, messageId) => {
    try {
        const response = await API.delete(`/sessions/${sessionId}/messages/${messageId}`);
        return response.data;
    } catch (error) {
        console.error('Failed to delete message:', error);
        throw error;
    }
};

export const editMessage = async (sessionId, messageId, content) => {
    try {
        const response = await API.put(`/sessions/${sessionId}/messages/${messageId}`, {
            content
        });
        return response.data;
    } catch (error) {
        console.error('Failed to edit message:', error);
        throw error;
    }
};

export const bookmarkMessage = async (sessionId, messageId) => {
    try {
        const response = await API.post(`/sessions/${sessionId}/messages/${messageId}/bookmark`);
        return response.data;
    } catch (error) {
        console.error('Failed to bookmark message:', error);
        throw error;
    }
};

export const getBookmarkedMessages = async () => {
    try {
        const response = await API.get('/bookmarks');
        return response.data;
    } catch (error) {
        console.error('Failed to get bookmarks:', error);
        throw error;
    }
};


================================================
FILE: Frontend/src/api/upload.js
================================================
import API from "./api";

export const uploadFile = async (file, sessionId = null) => {
    try {
        const formData = new FormData();
        formData.append('file', file);
        
        if (sessionId) {
            formData.append('session_id', sessionId);
        }

        const response = await API.post('/upload', formData, {
            headers: {
                "Content-Type": "multipart/form-data"
            },
            onUploadProgress: (progressEvent) => {
                const percentCompleted = Math.round((progressEvent.loaded * 100) / progressEvent.total);
                // You can handle progress here if needed
            }
        });
        
        return response.data;
    } catch (error) {
        console.error('Upload failed:', error);
        throw error;
    }
};

export const getUserFiles = async (sessionId = null) => {
    try {
        const response = await API.get('/files', {
            params: { session_id: sessionId }
        });
        return response.data;
    } catch (error) {
        console.error('Failed to fetch files:', error);
        throw error;
    }
};

export const deleteFile = async (filename) => {
    try {
        const response = await API.delete(`/files/${filename}`);
        return response.data;
    } catch (error) {
        console.error('Failed to delete file:', error);
        throw error;
    }
};


================================================
FILE: Frontend/src/components/Navbar.jsx
================================================
import { useAuth } from '../context/AuthContext';
import { Link, useNavigate } from 'react-router-dom';
import { Sparkles, LogOut, User } from 'lucide-react';

export default function Navbar() {
    const { user, logout, isAuthenticated } = useAuth();
    const navigate = useNavigate();

    const handleLogout = () => {
        logout();
        navigate('/login');
    };

    if (!isAuthenticated) return null;

    return (
        <nav className="bg-white shadow-sm border-b">
            <div className="max-w-6xl mx-auto px-4 py-3">
                <div className="flex items-center justify-between">
                    <Link to="/" className="flex items-center gap-2">
                        <div className="bg-blue-600 p-2 rounded-lg">
                            <Sparkles className="h-5 w-5 text-white" />
                        </div>
                        <span className="font-semibold text-gray-900">PDF AI Assistant</span>
                    </Link>

                    <div className="flex items-center gap-4">
                        <div className="flex items-center gap-2 text-sm text-gray-600">
                            <User className="h-4 w-4" />
                            <span>{user?.email}</span>
                        </div>
                        <button
                            onClick={handleLogout}
                            className="flex items-center gap-2 px-3 py-2 text-sm text-gray-600 hover:text-gray-900 hover:bg-gray-100 rounded-lg transition-colors"
                        >
                            <LogOut className="h-4 w-4" />
                            Logout
                        </button>
                    </div>
                </div>
            </div>
        </nav>
    );
}


================================================
FILE: Frontend/src/components/ProtectedRoute.jsx
================================================
import { Navigate } from 'react-router-dom';
import { useAuth } from '../context/AuthContext';

export default function ProtectedRoute({ children }) {
    const { isAuthenticated, loading } = useAuth();

    if (loading) {
        return (
            <div className="min-h-screen flex items-center justify-center">
                <div className="text-center">
                    <div className="animate-spin rounded-full h-12 w-12 border-b-2 border-blue-600 mx-auto mb-4"></div>
                    <p className="text-gray-600">Loading...</p>
                </div>
            </div>
        );
    }

    if (!isAuthenticated) {
        return <Navigate to="/login" replace />;
    }

    return children;
}


================================================
FILE: Frontend/src/context/AuthContext.jsx
================================================
import { createContext, useState, useContext, useEffect } from 'react';
import API from '../api/api';

const AuthContext = createContext(null);

export const useAuth = () => {
    const context = useContext(AuthContext);
    if (!context) {
        throw new Error('useAuth must be used within an AuthProvider');
    }
    return context;
};

export const AuthProvider = ({ children }) => {
    const [user, setUser] = useState(null);
    const [loading, setLoading] = useState(true);
    const [token, setToken] = useState(localStorage.getItem('token'));

    useEffect(() => {
        if (token) {
            // Set default authorization header
            API.defaults.headers.common['Authorization'] = `Bearer ${token}`;
            fetchUser();
        } else {
            setLoading(false);
        }
    }, [token]);

    const fetchUser = async () => {
        try {
            const response = await API.get('/auth/me');
            setUser(response.data);
        } catch (error) {
            console.error('Failed to fetch user:', error);
            logout();
        } finally {
            setLoading(false);
        }
    };

    const login = async (email, password) => {
        try {
            // Using form data for OAuth2 compatible endpoint
            const formData = new FormData();
            formData.append('username', email);
            formData.append('password', password);

            const response = await API.post('/auth/login', formData, {
                headers: {
                    'Content-Type': 'application/x-www-form-urlencoded'
                }
            });

            const { access_token, user } = response.data;
            
            localStorage.setItem('token', access_token);
            API.defaults.headers.common['Authorization'] = `Bearer ${access_token}`;
            setToken(access_token);
            setUser(user);
            
            return { success: true };
        } catch (error) {
            return {
                success: false,
                error: error.response?.data?.detail || 'Login failed'
            };
        }
    };

    const signup = async (email, password) => {
        try {
            const response = await API.post('/auth/signup', {
                email,
                password
            });

            const { access_token, user } = response.data;
            
            localStorage.setItem('token', access_token);
            API.defaults.headers.common['Authorization'] = `Bearer ${access_token}`;
            setToken(access_token);
            setUser(user);
            
            return { success: true };
        } catch (error) {
            return {
                success: false,
                error: error.response?.data?.detail || 'Signup failed'
            };
        }
    };

    const logout = () => {
        localStorage.removeItem('token');
        delete API.defaults.headers.common['Authorization'];
        setToken(null);
        setUser(null);
    };

    const value = {
        user,
        loading,
        login,
        signup,
        logout,
        isAuthenticated: !!user
    };

    return (
        <AuthContext.Provider value={value}>
            {children}
        </AuthContext.Provider>
    );
};


================================================
FILE: Frontend/src/pages/Login.jsx
================================================
import { useState } from 'react';
import { useAuth } from '../context/AuthContext';
import { Link, useNavigate } from 'react-router-dom';
import { Mail, Lock, LogIn, AlertCircle, Sparkles } from 'lucide-react';

export default function Login() {
    const [email, setEmail] = useState('');
    const [password, setPassword] = useState('');
    const [error, setError] = useState('');
    const [loading, setLoading] = useState(false);
    
    const { login } = useAuth();
    const navigate = useNavigate();

    const handleSubmit = async (e) => {
        e.preventDefault();
        setError('');
        setLoading(true);

        const result = await login(email, password);
        
        if (result.success) {
            navigate('/');
        } else {
            setError(result.error);
        }
        
        setLoading(false);
    };

    return (
        <div className="min-h-screen bg-gradient-to-br from-blue-50 to-indigo-100 flex items-center justify-center p-4">
            <div className="bg-white rounded-2xl shadow-xl max-w-md w-full p-8">
                {/* Header */}
                <div className="text-center mb-8">
                    <div className="bg-blue-600 p-3 rounded-xl inline-block mb-4">
                        <Sparkles className="h-8 w-8 text-white" />
                    </div>
                    <h1 className="text-3xl font-bold text-gray-900">Welcome Back</h1>
                    <p className="text-gray-600 mt-2">Sign in to your account</p>
                </div>

                {/* Error Message */}
                {error && (
                    <div className="mb-6 p-4 bg-red-50 rounded-lg flex items-start gap-3">
                        <AlertCircle className="h-5 w-5 text-red-600 mt-0.5 flex-shrink-0" />
                        <p className="text-sm text-red-600">{error}</p>
                    </div>
                )}

                {/* Login Form */}
                <form onSubmit={handleSubmit} className="space-y-6">
                    <div>
                        <label className="block text-sm font-medium text-gray-700 mb-2">
                            Email Address
                        </label>
                        <div className="relative">
                            <Mail className="absolute left-3 top-1/2 transform -translate-y-1/2 h-5 w-5 text-gray-400" />
                            <input
                                type="email"
                                value={email}
                                onChange={(e) => setEmail(e.target.value)}
                                className="w-full pl-10 pr-4 py-3 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500 focus:border-transparent"
                                placeholder="you@example.com"
                                required
                                disabled={loading}
                            />
                        </div>
                    </div>

                    <div>
                        <label className="block text-sm font-medium text-gray-700 mb-2">
                            Password
                        </label>
                        <div className="relative">
                            <Lock className="absolute left-3 top-1/2 transform -translate-y-1/2 h-5 w-5 text-gray-400" />
                            <input
                                type="password"
                                value={password}
                                onChange={(e) => setPassword(e.target.value)}
                                className="w-full pl-10 pr-4 py-3 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500 focus:border-transparent"
                                placeholder="••••••••"
                                required
                                disabled={loading}
                                minLength={6}
                            />
                        </div>
                    </div>

                    <button
                        type="submit"
                        disabled={loading}
                        className={`w-full py-3 px-4 rounded-lg font-medium flex items-center justify-center gap-2 transition-all ${
                            loading
                                ? 'bg-gray-300 text-gray-500 cursor-not-allowed'
                                : 'bg-blue-600 text-white hover:bg-blue-700 hover:shadow-lg'
                        }`}
                    >
                        {loading ? (
                            <>
                                <div className="animate-spin rounded-full h-5 w-5 border-b-2 border-white"></div>
                                Signing in...
                            </>
                        ) : (
                            <>
                                <LogIn size={18} />
                                Sign In
                            </>
                        )}
                    </button>
                </form>

                {/* Signup Link */}
                <p className="mt-6 text-center text-gray-600">
                    Don't have an account?{' '}
                    <Link to="/signup" className="text-blue-600 hover:text-blue-700 font-medium">
                        Sign up
                    </Link>
                </p>
            </div>
        </div>
    );
}


================================================
FILE: Frontend/src/pages/Signup.jsx
================================================
import { useState } from 'react';
import { useAuth } from '../context/AuthContext';
import { Link, useNavigate } from 'react-router-dom';
import { Mail, Lock, UserPlus, AlertCircle, Sparkles, CheckCircle } from 'lucide-react';

export default function Signup() {
    const [email, setEmail] = useState('');
    const [password, setPassword] = useState('');
    const [confirmPassword, setConfirmPassword] = useState('');
    const [error, setError] = useState('');
    const [loading, setLoading] = useState(false);
    
    const { signup } = useAuth();
    const navigate = useNavigate();

    const validatePassword = () => {
        if (password.length < 6) {
            return 'Password must be at least 6 characters';
        }
        if (password !== confirmPassword) {
            return 'Passwords do not match';
        }
        return null;
    };

    const handleSubmit = async (e) => {
        e.preventDefault();
        
        const passwordError = validatePassword();
        if (passwordError) {
            setError(passwordError);
            return;
        }

        setError('');
        setLoading(true);

        const result = await signup(email, password);
        
        if (result.success) {
            navigate('/');
        } else {
            setError(result.error);
        }
        
        setLoading(false);
    };

    const getPasswordStrength = () => {
        if (!password) return null;
        
        const hasLower = /[a-z]/.test(password);
        const hasUpper = /[A-Z]/.test(password);
        const hasNumber = /[0-9]/.test(password);
        const hasSpecial = /[^A-Za-z0-9]/.test(password);
        
        const strength = [hasLower, hasUpper, hasNumber, hasSpecial].filter(Boolean).length;
        
        if (strength < 2) return 'weak';
        if (strength < 4) return 'medium';
        return 'strong';
    };

    const passwordStrength = getPasswordStrength();

    return (
        <div className="min-h-screen bg-gradient-to-br from-blue-50 to-indigo-100 flex items-center justify-center p-4">
            <div className="bg-white rounded-2xl shadow-xl max-w-md w-full p-8">
                {/* Header */}
                <div className="text-center mb-8">
                    <div className="bg-blue-600 p-3 rounded-xl inline-block mb-4">
                        <Sparkles className="h-8 w-8 text-white" />
                    </div>
                    <h1 className="text-3xl font-bold text-gray-900">Create Account</h1>
                    <p className="text-gray-600 mt-2">Sign up to get started</p>
                </div>

                {/* Error Message */}
                {error && (
                    <div className="mb-6 p-4 bg-red-50 rounded-lg flex items-start gap-3">
                        <AlertCircle className="h-5 w-5 text-red-600 mt-0.5 flex-shrink-0" />
                        <p className="text-sm text-red-600">{error}</p>
                    </div>
                )}

                {/* Signup Form */}
                <form onSubmit={handleSubmit} className="space-y-6">
                    <div>
                        <label className="block text-sm font-medium text-gray-700 mb-2">
                            Email Address
                        </label>
                        <div className="relative">
                            <Mail className="absolute left-3 top-1/2 transform -translate-y-1/2 h-5 w-5 text-gray-400" />
                            <input
                                type="email"
                                value={email}
                                onChange={(e) => setEmail(e.target.value)}
                                className="w-full pl-10 pr-4 py-3 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500 focus:border-transparent"
                                placeholder="you@example.com"
                                required
                                disabled={loading}
                            />
                        </div>
                    </div>

                    <div>
                        <label className="block text-sm font-medium text-gray-700 mb-2">
                            Password
                        </label>
                        <div className="relative">
                            <Lock className="absolute left-3 top-1/2 transform -translate-y-1/2 h-5 w-5 text-gray-400" />
                            <input
                                type="password"
                                value={password}
                                onChange={(e) => setPassword(e.target.value)}
                                className="w-full pl-10 pr-4 py-3 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500 focus:border-transparent"
                                placeholder="••••••••"
                                required
                                disabled={loading}
                                minLength={6}
                            />
                        </div>
                        
                        {/* Password strength indicator */}
                        {password && (
                            <div className="mt-2">
                                <div className="flex gap-1 mb-1">
                                    <div className={`h-1 flex-1 rounded ${
                                        passwordStrength === 'weak' ? 'bg-red-500' :
                                        passwordStrength === 'medium' ? 'bg-yellow-500' :
                                        passwordStrength === 'strong' ? 'bg-green-500' : 'bg-gray-200'
                                    }`} />
                                    <div className={`h-1 flex-1 rounded ${
                                        passwordStrength === 'medium' ? 'bg-yellow-500' :
                                        passwordStrength === 'strong' ? 'bg-green-500' : 'bg-gray-200'
                                    }`} />
                                    <div className={`h-1 flex-1 rounded ${
                                        passwordStrength === 'strong' ? 'bg-green-500' : 'bg-gray-200'
                                    }`} />
                                </div>
                                <p className="text-xs text-gray-500">
                                    {passwordStrength === 'weak' && 'Weak password'}
                                    {passwordStrength === 'medium' && 'Medium password'}
                                    {passwordStrength === 'strong' && 'Strong password'}
                                </p>
                            </div>
                        )}
                    </div>

                    <div>
                        <label className="block text-sm font-medium text-gray-700 mb-2">
                            Confirm Password
                        </label>
                        <div className="relative">
                            <Lock className="absolute left-3 top-1/2 transform -translate-y-1/2 h-5 w-5 text-gray-400" />
                            <input
                                type="password"
                                value={confirmPassword}
                                onChange={(e) => setConfirmPassword(e.target.value)}
                                className={`w-full pl-10 pr-4 py-3 border rounded-lg focus:ring-2 focus:ring-blue-500 focus:border-transparent ${
                                    confirmPassword && password !== confirmPassword
                                        ? 'border-red-300 bg-red-50'
                                        : 'border-gray-300'
                                }`}
                                placeholder="••••••••"
                                required
                                disabled={loading}
                                minLength={6}
                            />
                        </div>
                        {confirmPassword && password === confirmPassword && (
                            <p className="mt-1 text-xs text-green-600 flex items-center gap-1">
                                <CheckCircle className="h-3 w-3" />
                                Passwords match
                            </p>
                        )}
                    </div>

                    <button
                        type="submit"
                        disabled={loading}
                        className={`w-full py-3 px-4 rounded-lg font-medium flex items-center justify-center gap-2 transition-all ${
                            loading
                                ? 'bg-gray-300 text-gray-500 cursor-not-allowed'
                                : 'bg-blue-600 text-white hover:bg-blue-700 hover:shadow-lg'
                        }`}
                    >
                        {loading ? (
                            <>
                                <div className="animate-spin rounded-full h-5 w-5 border-b-2 border-white"></div>
                                Creating account...
                            </>
                        ) : (
                            <>
                                <UserPlus size={18} />
                                Sign Up
                            </>
                        )}
                    </button>
                </form>

                {/* Login Link */}
                <p className="mt-6 text-center text-gray-600">
                    Already have an account?{' '}
                    <Link to="/login" className="text-blue-600 hover:text-blue-700 font-medium">
                        Sign in
                    </Link>
                </p>
            </div>
        </div>
    );
}