Iniital commit

.gitignore

@@ -0,0 +1,42 @@
+# --- Python Backend ---
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+venv/
+ENV/
+.env
+.venv/
+*.db
+*.sqlite3
+chroma_db/
+uploads/
+.vscode/
+.DS_Store
+Thumbs.db
+*.log
+*.ipynb
+.pytest_cache/
+dist/
+build/
+*.egg-info/
+htmlcov/
+.coverage
+coverage.xml
+
+# --- Frontend (Next.js/React) ---
+node_modules/
+.next/
+out/
+.env
+.env.*
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+dist/
+coverage/
+
+# --- General ---
+# Ignore Docker build cache
+# Ignore coverage reports
+# Ignore node_modules if any 

LICENSE

@@ -0,0 +1,11 @@
+UNLICENSED – VIEW ONLY
+
+Copyright (c) 2025 Al Amin
+
+Permission is NOT granted to any person obtaining a copy of this software and associated documentation files (the "Software") to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software.
+
+The Software is provided strictly for viewing and educational reference purposes only.
+
+The above copyright notice must be retained, and this notice must appear in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE VIEWING OF THE SOFTWARE.

README.md

@@ -0,0 +1,279 @@
+# PDF-Based Q&A Chatbot System
+
+A comprehensive end-to-end PDF-based Q&A chatbot system that processes uploaded PDF documents and enables users to retrieve accurate, context-aware answers via natural language queries.
+
+## Features
+
+- **PDF Processing**: Extract text and metadata from uploaded PDF documents
+- **Vector Storage**: Store document embeddings in ChromaDB for efficient retrieval
+- **AI-Powered Q&A**: Use OpenAI/Claude for intelligent question answering
+- **Modern UI**: Clean, responsive interface built with Next.js and Tailwind CSS
+- **Real-time Chat**: Interactive chat interface with conversation history
+- **File Management**: Upload, view, and manage multiple PDF documents
+- **Context Awareness**: Maintain conversation context and document references
+
+## Tech Stack
+
+### Backend
+- **FastAPI**: High-performance web framework
+- **PyPDF2**: PDF text extraction
+- **ChromaDB**: Vector database for embeddings
+- **OpenAI/Claude**: AI language models for Q&A
+- **SQLAlchemy**: Database ORM
+- **Pydantic**: Data validation
+
+### Frontend
+- **Next.js 14**: React framework with App Router
+- **TypeScript**: Type-safe development
+- **Tailwind CSS**: Utility-first styling
+- **Shadcn/ui**: Modern UI components
+- **React Hook Form**: Form handling
+- **Zustand**: State management
+
+## Project Structure
+
+```
+ChatbotCursor/
+├── backend/
+│   ├── app/
+│   │   ├── api/
+│   │   ├── core/
+│   │   ├── models/
+│   │   ├── services/
+│   │   └── utils/
+│   ├── requirements.txt
+│   └── main.py
+├── frontend/
+│   ├── app/
+│   ├── components/
+│   ├── lib/
+│   └── package.json
+├── docker-compose.yml
+└── README.md
+```
+
+## Quick Start
+
+### Option 1: Automated Setup (Recommended)
+
+**For Linux/macOS:**
+```bash
+chmod +x setup.sh
+./setup.sh
+```
+
+**For Windows:**
+```powershell
+.\setup.ps1
+```
+
+### Option 2: Manual Setup
+
+1. **Clone and Setup**
+   ```bash
+   cd ChatbotCursor
+   ```
+
+2. **Backend Setup**
+   ```bash
+   cd backend
+   python -m venv venv
+   source venv/bin/activate  # On Windows: venv\Scripts\activate
+   pip install -r requirements.txt
+   cp .env.example .env
+   # Edit .env and add your API keys
+   ```
+
+3. **Frontend Setup**
+   ```bash
+   cd frontend
+   npm install
+   cp .env.example .env
+   ```
+
+4. **Environment Variables**
+   - Edit `backend/.env` and add your API keys:
+     - `OPENAI_API_KEY` or `ANTHROPIC_API_KEY`
+   - The frontend `.env` should work with defaults
+
+5. **Run the Application**
+   ```bash
+   # Backend (Terminal 1)
+   cd backend
+   source venv/bin/activate  # On Windows: venv\Scripts\activate
+   uvicorn main:app --reload
+   
+   # Frontend (Terminal 2)
+   cd frontend
+   npm run dev
+   ```
+
+### Option 3: Docker Setup
+
+```bash
+# Build and run with Docker Compose
+docker-compose up --build
+
+# Or run services individually
+docker-compose up backend
+docker-compose up frontend
+```
+
+6. **Access the Application**
+   - Frontend: http://localhost:3000
+   - Backend API: http://localhost:8000
+   - API Documentation: http://localhost:8000/docs
+
+## Usage
+
+### Getting Started
+
+1. **Upload Documents**
+   - Navigate to the "Documents" tab
+   - Drag and drop PDF files or click to select
+   - Wait for processing (text extraction and vector embedding)
+   - View upload status and document statistics
+
+2. **Start Chatting**
+   - Switch to the "Chat" tab
+   - Ask questions about your uploaded documents
+   - Get AI-powered answers with source references
+   - View conversation history
+
+3. **Document Management**
+   - View all uploaded documents with metadata
+   - Delete documents when no longer needed
+   - Monitor processing status and file sizes
+
+### Features
+
+- **Smart Document Processing**: Automatic text extraction and chunking
+- **Vector Search**: Semantic similarity search for relevant content
+- **AI-Powered Q&A**: Context-aware answers using OpenAI or Claude
+- **Source Citations**: See which documents and sections were referenced
+- **Conversation History**: Persistent chat sessions
+- **File Management**: Upload, view, and delete documents
+- **Real-time Processing**: Live status updates during uploads
+
+### Supported File Types
+
+- **PDF Documents**: All standard PDF files
+- **Maximum Size**: 10MB per file
+- **Processing**: Automatic text extraction and metadata parsing
+
+## API Endpoints
+
+### Document Management
+- `POST /api/v1/documents/upload`: Upload PDF documents
+- `GET /api/v1/documents/`: List all documents
+- `GET /api/v1/documents/{id}`: Get specific document
+- `DELETE /api/v1/documents/{id}`: Delete a document
+- `GET /api/v1/documents/stats/summary`: Get document statistics
+
+### Chat & Q&A
+- `POST /api/v1/chat/`: Send questions and get answers
+- `GET /api/v1/chat/history/{session_id}`: Get chat history
+- `POST /api/v1/chat/session/new`: Create new chat session
+- `GET /api/v1/chat/sessions`: List all sessions
+- `DELETE /api/v1/chat/session/{session_id}`: Delete session
+- `GET /api/v1/chat/models/available`: Get available AI models
+
+### System
+- `GET /health`: Health check
+- `GET /docs`: Interactive API documentation (Swagger UI)
+- `GET /redoc`: Alternative API documentation
+
+## Configuration
+
+### Environment Variables
+
+**Backend (.env):**
+```env
+# Required: Set at least one AI provider
+OPENAI_API_KEY=your-openai-api-key
+ANTHROPIC_API_KEY=your-anthropic-api-key
+
+# Optional: Customize settings
+DATABASE_URL=sqlite:///./pdf_chatbot.db
+CHROMA_PERSIST_DIRECTORY=./chroma_db
+UPLOAD_DIR=./uploads
+MAX_FILE_SIZE=10485760
+```
+
+**Frontend (.env):**
+```env
+NEXT_PUBLIC_API_URL=http://localhost:8000
+```
+
+### AI Provider Setup
+
+1. **OpenAI**: Get API key from [OpenAI Platform](https://platform.openai.com/)
+2. **Anthropic**: Get API key from [Anthropic Console](https://console.anthropic.com/)
+
+## Development
+
+### Backend Development
+```bash
+cd backend
+source venv/bin/activate
+uvicorn main:app --reload --port 8000
+```
+
+### Frontend Development
+```bash
+cd frontend
+npm run dev
+```
+
+### Testing
+```bash
+# Backend tests
+cd backend
+pytest
+
+# Frontend tests
+cd frontend
+npm test
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **API Key Not Configured**
+   - Ensure you've added your API key to `backend/.env`
+   - Restart the backend server after changing environment variables
+
+2. **Upload Fails**
+   - Check file size (max 10MB)
+   - Ensure file is a valid PDF
+   - Check backend logs for detailed error messages
+
+3. **Chat Not Working**
+   - Verify AI service is configured and working
+   - Check if documents are properly processed
+   - Review browser console for frontend errors
+
+4. **Docker Issues**
+   - Ensure Docker and Docker Compose are installed
+   - Check if ports 3000 and 8000 are available
+   - Use `docker-compose logs` to view service logs
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
+
+This project is unlicensed - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+- Built with [FastAPI](https://fastapi.tiangolo.com/) and [Next.js](https://nextjs.org/)
+- Vector storage powered by [ChromaDB](https://www.trychroma.com/)
+- AI capabilities provided by [OpenAI](https://openai.com/) and [Anthropic](https://www.anthropic.com/)
+- UI components from [Tailwind CSS](https://tailwindcss.com/) and [Lucide React](https://lucide.dev/)

backend/Dockerfile

@@ -0,0 +1,30 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create necessary directories
+RUN mkdir -p uploads chroma_db
+
+# Expose port
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Run the application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"] 

backend/app/__init__.py

@@ -0,0 +1 @@
+# App package 

backend/app/api/__init__.py

@@ -0,0 +1 @@
+# API package 

backend/app/api/endpoints/__init__.py

@@ -0,0 +1 @@
+# Endpoints package 

backend/app/api/endpoints/chat.py

@@ -0,0 +1,204 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from typing import List
+import json
+import uuid
+from datetime import datetime
+
+from app.core.database import get_db
+from app.models.document import ChatMessage
+from app.schemas.chat import ChatRequest, ChatResponse, ChatHistoryResponse, ChatMessageCreate, ChatMessageResponse
+from app.services.vector_store import VectorStore
+from app.services.ai_service import AIService
+
+router = APIRouter()
+vector_store = VectorStore()
+ai_service = AIService()
+
+
+@router.post("/", response_model=ChatResponse)
+def chat_with_documents(
+    request: ChatRequest,
+    db: Session = Depends(get_db)
+):
+    """Send a question and get an answer based on uploaded documents"""
+    try:
+        # Check if AI service is configured
+        if not ai_service.is_configured():
+            raise HTTPException(
+                status_code=503,
+                detail="AI service not configured. Please set up OpenAI or Anthropic API keys."
+            )
+        
+        # Search for relevant documents
+        print(f"Searching for documents with query: {request.question}")
+        context_documents = vector_store.search_similar(request.question, n_results=5, document_id=str(request.document_id) if request.document_id is not None else None)
+        print(f"Found {len(context_documents)} relevant documents")
+        if context_documents:
+            print(f"Document IDs found: {[doc.get('metadata', {}).get('document_id') for doc in context_documents]}")
+        else:
+            print("No documents found in vector store")
+            # Check vector store stats
+            stats = vector_store.get_collection_stats()
+            print(f"Vector store stats: {stats}")
+        
+        if not context_documents:
+            # No relevant documents found
+            answer = "I don't have enough information in the uploaded documents to answer your question. Please upload relevant PDF documents first."
+            
+            # Save user message
+            user_message = ChatMessage(
+                session_id=request.session_id,
+                message_type="user",
+                content=request.question
+            )
+            db.add(user_message)
+            db.commit()
+            
+            # Save assistant message
+            assistant_message = ChatMessage(
+                session_id=request.session_id,
+                message_type="assistant",
+                content=answer
+            )
+            db.add(assistant_message)
+            db.commit()
+            
+            return ChatResponse(
+                success=True,
+                answer=answer,
+                session_id=request.session_id,
+                message_id=assistant_message.id
+            )
+        
+        # Generate answer using AI
+        ai_response = ai_service.generate_answer(
+            request.question,
+            context_documents,
+            model=request.model
+        )
+        
+        # Save user message
+        user_message = ChatMessage(
+            session_id=request.session_id,
+            message_type="user",
+            content=request.question
+        )
+        db.add(user_message)
+        db.commit()
+        
+        # Save assistant message with document references
+        document_refs = json.dumps([doc.get('metadata', {}).get('document_id') for doc in context_documents])
+        assistant_message = ChatMessage(
+            session_id=request.session_id,
+            message_type="assistant",
+            content=ai_response["answer"],
+            document_references=document_refs
+        )
+        db.add(assistant_message)
+        db.commit()
+        
+        return ChatResponse(
+            success=ai_response["success"],
+            answer=ai_response["answer"],
+            model=ai_response.get("model"),
+            sources=ai_response.get("sources", []),
+            session_id=request.session_id,
+            message_id=assistant_message.id
+        )
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error processing chat request: {str(e)}")
+
+
+@router.get("/history/{session_id}", response_model=ChatHistoryResponse)
+def get_chat_history(
+    session_id: str,
+    skip: int = 0,
+    limit: int = 50,
+    db: Session = Depends(get_db)
+):
+    """Get chat history for a specific session"""
+    try:
+        messages = db.query(ChatMessage).filter(
+            ChatMessage.session_id == session_id
+        ).order_by(ChatMessage.created_at.asc()).offset(skip).limit(limit).all()
+        
+        total = db.query(ChatMessage).filter(
+            ChatMessage.session_id == session_id
+        ).count()
+        
+        return ChatHistoryResponse(
+            messages=[ChatMessageResponse.from_orm(msg) for msg in messages],
+            total=total
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error retrieving chat history: {str(e)}")
+
+
+@router.post("/session/new")
+def create_new_session():
+    """Create a new chat session"""
+    try:
+        session_id = str(uuid.uuid4())
+        return {"session_id": session_id}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error creating session: {str(e)}")
+
+
+@router.get("/sessions")
+def list_sessions(db: Session = Depends(get_db)):
+    """List all chat sessions"""
+    try:
+        # Get unique session IDs with message counts
+        sessions = db.query(
+            ChatMessage.session_id,
+            db.func.count(ChatMessage.id).label('message_count'),
+            db.func.max(ChatMessage.created_at).label('last_message_at')
+        ).group_by(ChatMessage.session_id).order_by(
+            db.func.max(ChatMessage.created_at).desc()
+        ).all()
+        
+        return [
+            {
+                "session_id": session.session_id,
+                "message_count": session.message_count,
+                "last_message_at": session.last_message_at
+            }
+            for session in sessions
+        ]
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error retrieving sessions: {str(e)}")
+
+
+@router.delete("/session/{session_id}")
+def delete_session(session_id: str, db: Session = Depends(get_db)):
+    """Delete a chat session and all its messages"""
+    try:
+        messages = db.query(ChatMessage).filter(
+            ChatMessage.session_id == session_id
+        ).all()
+        
+        for message in messages:
+            db.delete(message)
+        
+        db.commit()
+        
+        return {"success": True, "message": f"Session {session_id} deleted successfully"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error deleting session: {str(e)}")
+
+
+@router.get("/models/available")
+def get_available_models():
+    """Get list of available AI models"""
+    try:
+        models = ai_service.get_available_models()
+        return {
+            "available_models": models,
+            "is_configured": ai_service.is_configured()
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error retrieving models: {str(e)}") 

backend/app/api/endpoints/documents.py

@@ -0,0 +1,216 @@
+from fastapi import APIRouter, Depends, HTTPException, UploadFile, File
+from sqlalchemy.orm import Session
+from typing import List
+import os
+import uuid
+import aiofiles
+from datetime import datetime
+
+from app.core.database import get_db
+from app.core.config import settings
+from app.models.document import Document
+from app.schemas.document import DocumentResponse, DocumentListResponse, DocumentDeleteResponse, UploadResponse
+from app.services.pdf_processor import PDFProcessor
+from app.services.vector_store import VectorStore
+from app.models.document import ChatMessage
+import shutil
+
+router = APIRouter()
+pdf_processor = PDFProcessor()
+vector_store = VectorStore()
+
+
+@router.post("/upload", response_model=UploadResponse)
+async def upload_document(
+    file: UploadFile = File(...),
+    db: Session = Depends(get_db)
+):
+    """Upload and process a PDF document"""
+    try:
+        # Restrict to 3 documents max
+        doc_count = db.query(Document).count()
+        if doc_count >= 3:
+            raise HTTPException(status_code=400, detail="You can only upload up to 3 documents.")
+        # Validate file type
+        if not file.filename.lower().endswith('.pdf'):
+            raise HTTPException(status_code=400, detail="Only PDF files are allowed")
+        
+        # Generate unique filename
+        file_extension = os.path.splitext(file.filename)[1]
+        unique_filename = f"{uuid.uuid4()}{file_extension}"
+        file_path = os.path.join(settings.UPLOAD_DIR, unique_filename)
+        
+        # Save file
+        async with aiofiles.open(file_path, 'wb') as f:
+            content = await file.read()
+            await f.write(content)
+        
+        # Process PDF
+        success, text_content, metadata = pdf_processor.process_pdf(file_path)
+        
+        if not success:
+            # Clean up file if processing failed
+            if os.path.exists(file_path):
+                os.remove(file_path)
+            raise HTTPException(status_code=400, detail=text_content)
+        
+        # Create document record
+        db_document = Document(
+            filename=unique_filename,
+            original_filename=file.filename,
+            file_path=file_path,
+            file_size=len(content),
+            content=text_content,
+            processed=True
+        )
+        
+        db.add(db_document)
+        db.commit()
+        db.refresh(db_document)
+        
+        # Add to vector store
+        print(f"Adding document {db_document.id} to vector store...")
+        vector_success = vector_store.add_document(
+            str(db_document.id),
+            text_content,
+            metadata={
+                "filename": file.filename,
+                "file_size": len(content),
+                "num_pages": metadata.get('num_pages', 0)
+            }
+        )
+        
+        if not vector_success:
+            # Log warning but don't fail the upload
+            print(f"Warning: Failed to add document {db_document.id} to vector store")
+        else:
+            print(f"Successfully added document {db_document.id} to vector store")
+            # Check collection stats
+            stats = vector_store.get_collection_stats()
+            print(f"Vector store stats: {stats}")
+        
+        return UploadResponse(
+            success=True,
+            document=DocumentResponse.from_orm(db_document),
+            message="Document uploaded and processed successfully"
+        )
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        # Clean up file if something went wrong
+        if 'file_path' in locals() and os.path.exists(file_path):
+            os.remove(file_path)
+        raise HTTPException(status_code=500, detail=f"Error uploading document: {str(e)}")
+
+
+@router.get("/", response_model=DocumentListResponse)
+def list_documents(
+    skip: int = 0,
+    limit: int = 100,
+    db: Session = Depends(get_db)
+):
+    """List all uploaded documents"""
+    try:
+        documents = db.query(Document).offset(skip).limit(limit).all()
+        total = db.query(Document).count()
+        
+        return DocumentListResponse(
+            documents=[DocumentResponse.from_orm(doc) for doc in documents],
+            total=total
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error retrieving documents: {str(e)}")
+
+
+@router.get("/{document_id}", response_model=DocumentResponse)
+def get_document(document_id: int, db: Session = Depends(get_db)):
+    """Get a specific document by ID"""
+    try:
+        document = db.query(Document).filter(Document.id == document_id).first()
+        if not document:
+            raise HTTPException(status_code=404, detail="Document not found")
+        
+        return DocumentResponse.from_orm(document)
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error retrieving document: {str(e)}")
+
+
+@router.delete("/{document_id}", response_model=DocumentDeleteResponse)
+def delete_document(document_id: int, db: Session = Depends(get_db)):
+    """Delete a document and its vector embeddings"""
+    try:
+        document = db.query(Document).filter(Document.id == document_id).first()
+        if not document:
+            raise HTTPException(status_code=404, detail="Document not found")
+        
+        # Delete from vector store
+        vector_store.delete_document(str(document_id))
+        
+        # Delete file from filesystem
+        if os.path.exists(document.file_path):
+            os.remove(document.file_path)
+        
+        # Delete from database
+        db.delete(document)
+        db.commit()
+        
+        return DocumentDeleteResponse(
+            success=True,
+            message=f"Document {document.original_filename} deleted successfully"
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error deleting document: {str(e)}")
+
+
+@router.post("/clear_all")
+def clear_all_data(db: Session = Depends(get_db)):
+    """Admin endpoint to clear all documents, chat messages, uploaded files, and vector store."""
+    try:
+        # Delete all documents and chat messages from DB
+        db.query(Document).delete()
+        db.query(ChatMessage).delete()
+        db.commit()
+        # Delete all files in uploads directory
+        upload_dir = settings.UPLOAD_DIR
+        for filename in os.listdir(upload_dir):
+            file_path = os.path.join(upload_dir, filename)
+            try:
+                if os.path.isfile(file_path) or os.path.islink(file_path):
+                    os.unlink(file_path)
+                elif os.path.isdir(file_path):
+                    shutil.rmtree(file_path)
+            except Exception as e:
+                print(f"Failed to delete {file_path}: {e}")
+        # Clear ChromaDB vector store using the singleton
+        vector_store.clear_all()
+        return {"success": True, "message": "All documents, chat messages, uploads, and vectors cleared."}
+    except Exception as e:
+        return {"success": False, "message": f"Error clearing data: {str(e)}"}
+
+
+@router.get("/stats/summary")
+def get_document_stats(db: Session = Depends(get_db)):
+    """Get document statistics"""
+    try:
+        total_documents = db.query(Document).count()
+        processed_documents = db.query(Document).filter(Document.processed == True).count()
+        total_size = db.query(Document).with_entities(
+            db.func.sum(Document.file_size)
+        ).scalar() or 0
+        
+        vector_stats = vector_store.get_collection_stats()
+        
+        return {
+            "total_documents": total_documents,
+            "processed_documents": processed_documents,
+            "total_size_bytes": total_size,
+            "total_size_mb": round(total_size / (1024 * 1024), 2),
+            "vector_store_chunks": vector_stats.get("total_documents", 0)
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error retrieving stats: {str(e)}") 

backend/app/core/__init__.py

@@ -0,0 +1 @@
+# Core package 

backend/app/core/config.py

@@ -0,0 +1,47 @@
+from pydantic_settings import BaseSettings
+from typing import Optional
+import os
+
+
+class Settings(BaseSettings):
+    # API Configuration
+    API_V1_STR: str = "/api/v1"
+    PROJECT_NAME: str = "PDF Q&A Chatbot"
+    
+    # Security
+    SECRET_KEY: str = "your-secret-key-here"
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 60 * 24 * 8  # 8 days
+    
+    # Database
+    DATABASE_URL: str = "sqlite:///./pdf_chatbot.db"
+    
+    # Vector Database
+    CHROMA_PERSIST_DIRECTORY: str = "./chroma_db"
+    
+    # AI Providers
+    OPENROUTER_API_KEY: Optional[str] = None
+    ANTHROPIC_API_KEY: Optional[str] = None
+    
+    # File Storage
+    UPLOAD_DIR: str = "./uploads"
+    MAX_FILE_SIZE: int = 10 * 1024 * 1024  # 10MB
+    ALLOWED_EXTENSIONS: list = [".pdf"]
+    
+    # CORS
+    BACKEND_CORS_ORIGINS: list = [
+        "http://localhost:3000",
+        "http://localhost:3001",
+        "http://127.0.0.1:3000",
+        "http://127.0.0.1:3001",
+    ]
+    
+    class Config:
+        env_file = ".env"
+        case_sensitive = True
+
+
+settings = Settings()
+
+# Ensure upload directory exists
+os.makedirs(settings.UPLOAD_DIR, exist_ok=True)
+os.makedirs(settings.CHROMA_PERSIST_DIRECTORY, exist_ok=True) 

backend/app/core/database.py

@@ -0,0 +1,29 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, Session
+from sqlalchemy.ext.declarative import declarative_base
+from app.core.config import settings
+
+engine = create_engine(
+    settings.DATABASE_URL,
+    connect_args={"check_same_thread": False} if "sqlite" in settings.DATABASE_URL else {}
+)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+# Import models to ensure they are registered
+from app.models.document import Document, ChatMessage
+
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+def create_tables():
+    """Create all tables in the database"""
+    Base.metadata.create_all(bind=engine) 

backend/app/models/__init__.py

@@ -0,0 +1 @@
+# Models package 

backend/app/models/document.py

@@ -0,0 +1,35 @@
+from sqlalchemy import Column, Integer, String, DateTime, Text, Boolean
+from sqlalchemy.sql import func
+from datetime import datetime
+from app.core.database import Base
+
+
+class Document(Base):
+    __tablename__ = "documents"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    filename = Column(String(255), nullable=False)
+    original_filename = Column(String(255), nullable=False)
+    file_path = Column(String(500), nullable=False)
+    file_size = Column(Integer, nullable=False)
+    content = Column(Text, nullable=True)
+    processed = Column(Boolean, default=False)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
+    
+    def __repr__(self):
+        return f"<Document(id={self.id}, filename='{self.filename}')>"
+
+
+class ChatMessage(Base):
+    __tablename__ = "chat_messages"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    session_id = Column(String(255), nullable=False, index=True)
+    message_type = Column(String(20), nullable=False)  # 'user' or 'assistant'
+    content = Column(Text, nullable=False)
+    document_references = Column(Text, nullable=True)  # JSON string of referenced documents
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    
+    def __repr__(self):
+        return f"<ChatMessage(id={self.id}, session_id='{self.session_id}', type='{self.message_type}')>" 

backend/app/schemas/__init__.py

@@ -0,0 +1 @@
+# Schemas package 

backend/app/schemas/chat.py

@@ -0,0 +1,50 @@
+from pydantic import BaseModel
+from typing import Optional, List, Dict
+from datetime import datetime
+
+
+class ChatMessageBase(BaseModel):
+    content: str
+    message_type: str  # 'user' or 'assistant'
+
+
+class ChatMessageCreate(ChatMessageBase):
+    session_id: str
+    document_references: Optional[str] = None
+
+
+class ChatMessageResponse(ChatMessageBase):
+    id: int
+    session_id: str
+    document_references: Optional[str] = None
+    created_at: datetime
+    
+    class Config:
+        from_attributes = True
+
+
+class ChatRequest(BaseModel):
+    question: str
+    session_id: str
+    model: Optional[str] = "auto"
+    document_id: Optional[int] = None
+
+
+class ChatResponse(BaseModel):
+    success: bool
+    answer: str
+    model: Optional[str] = None
+    sources: List[str] = []
+    session_id: str
+    message_id: Optional[int] = None
+
+
+class ChatHistoryResponse(BaseModel):
+    messages: List[ChatMessageResponse]
+    total: int
+
+
+class ChatSessionResponse(BaseModel):
+    session_id: str
+    message_count: int
+    last_message_at: Optional[datetime] = None 

backend/app/schemas/document.py

@@ -0,0 +1,40 @@
+from pydantic import BaseModel
+from typing import Optional, List
+from datetime import datetime
+
+
+class DocumentBase(BaseModel):
+    filename: str
+    original_filename: str
+    file_size: int
+
+
+class DocumentCreate(DocumentBase):
+    file_path: str
+
+
+class DocumentResponse(DocumentBase):
+    id: int
+    content: Optional[str] = None
+    processed: bool
+    created_at: datetime
+    updated_at: Optional[datetime] = None
+    
+    class Config:
+        from_attributes = True
+
+
+class DocumentListResponse(BaseModel):
+    documents: List[DocumentResponse]
+    total: int
+
+
+class DocumentDeleteResponse(BaseModel):
+    success: bool
+    message: str
+
+
+class UploadResponse(BaseModel):
+    success: bool
+    document: Optional[DocumentResponse] = None
+    message: str 

backend/app/services/__init__.py

@@ -0,0 +1 @@
+# Services package 

backend/app/services/ai_service.py

@@ -0,0 +1,267 @@
+import openai
+import anthropic
+from typing import List, Dict, Optional, Union
+import logging
+from app.core.config import settings
+import os
+import httpx
+
+logger = logging.getLogger(__name__)
+
+
+class AIService:
+    def __init__(self):
+        self.openrouter_api_key = settings.OPENROUTER_API_KEY
+        self.anthropic_client = None
+        
+        # Initialize OpenRouter (OpenAI-compatible) client
+        if self.openrouter_api_key:
+            # Validate API key format
+            if not self.openrouter_api_key.startswith('sk-or-'):
+                logger.warning("OpenRouter API key doesn't start with 'sk-or-'. This might cause issues.")
+            
+            openai.api_key = self.openrouter_api_key
+            openai.base_url = "https://openrouter.ai/api/v1"
+            os.environ["OPENAI_API_KEY"] = self.openrouter_api_key
+            os.environ["OPENAI_BASE_URL"] = "https://openrouter.ai/api/v1"
+            logger.info("OpenRouter API key configured")
+        else:
+            logger.warning("No OpenRouter API key found")
+        
+        # Initialize Anthropic client
+        if settings.ANTHROPIC_API_KEY:
+            self.anthropic_client = anthropic.Anthropic(api_key=settings.ANTHROPIC_API_KEY)
+            logger.info("Anthropic API key configured")
+        else:
+            logger.warning("No Anthropic API key found")
+    
+    def generate_answer(self, question: str, context_documents: List[Dict], model: str = "auto") -> Dict:
+        """Generate answer based on question and context documents"""
+        try:
+            # Prepare context from documents
+            context = self._prepare_context(context_documents)
+            # Collect unique document IDs from context_documents
+            used_doc_ids = list({str(doc.get('metadata', {}).get('document_id')) for doc in context_documents if doc.get('metadata', {}).get('document_id') is not None})
+            # Choose model based on availability
+            if model == "auto":
+                if self.openrouter_api_key:
+                    model = "openrouter"
+                elif self.anthropic_client:
+                    model = "anthropic"
+                else:
+                    return {
+                        "success": False,
+                        "answer": "No AI service configured. Please set up OpenRouter or Anthropic API keys.",
+                        "sources": []
+                    }
+            if model == "openrouter" and self.openrouter_api_key:
+                ai_result = self._generate_openrouter_answer(question, context)
+            elif model == "anthropic" and self.anthropic_client:
+                ai_result = self._generate_anthropic_answer(question, context)
+            else:
+                return {
+                    "success": False,
+                    "answer": f"Model {model} not available or not configured.",
+                    "sources": []
+                }
+            # Always use the actual doc IDs from context_documents for sources
+            ai_result["sources"] = used_doc_ids
+            return ai_result
+        except Exception as e:
+            logger.error(f"Error generating answer: {e}")
+            return {
+                "success": False,
+                "answer": f"Error generating answer: {str(e)}",
+                "sources": []
+            }
+    
+    def _prepare_context(self, context_documents: List[Dict]) -> str:
+        """Prepare context string from document chunks"""
+        if not context_documents:
+            return ""
+        context_parts = []
+        for doc in context_documents:
+            content = doc.get('content', '')
+            metadata = doc.get('metadata', {})
+            similarity = doc.get('similarity_score', 0)
+            doc_id = metadata.get('document_id', 'unknown')
+            chunk_index = metadata.get('chunk_index')
+            # Use real document ID as the main label
+            doc_info = f"Document {doc_id} (Relevance: {similarity:.2f})"
+            if chunk_index is not None:
+                doc_info += f" - Chunk: {chunk_index}"
+            context_parts.append(f"{doc_info}:\n{content}\n")
+        return "\n".join(context_parts)
+    
+    def _generate_openrouter_answer(self, question: str, context: str) -> Dict:
+        """Generate answer using OpenRouter API via HTTPX"""
+        try:
+            system_prompt = """You are a helpful AI assistant that answers questions based on provided document context. 
+            Follow these guidelines:
+            1. Only answer based on the information provided in the context
+            2. If the context doesn't contain enough information to answer the question, say so
+            3. Be concise but comprehensive
+            4. Cite specific parts of the documents when possible
+            5. If you're unsure about something, acknowledge the uncertainty
+            6. Format your response clearly and professionally using proper markdown formatting:\n   - Use **bold** for important points and headings\n   - Use bullet points (•) for lists\n   - Use numbered lists for step-by-step instructions\n   - Use proper paragraph breaks for readability\n   - Structure your response with clear sections when appropriate\n   - Use blockquotes for important quotes or key information\n7. You must answer the user's question as directly as possible, using only the information in the context. Do not simply summarize the context. If the context does not contain an answer, say so."""
+            
+            user_prompt = f"""Context from documents:\n{context}\n\nQuestion: {question}\n\nPlease provide a comprehensive answer based on the context above."""
+
+            headers = {
+                "Authorization": f"Bearer {self.openrouter_api_key}",
+                "HTTP-Referer": "http://localhost:3000",
+                "X-Title": "PDF Q&A Chatbot",
+                "Content-Type": "application/json"
+            }
+            payload = {
+                "model": "meta-llama/llama-3-70b-instruct",
+                "messages": [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                "max_tokens": 1000,
+                "temperature": 0.3
+            }
+            url = "https://openrouter.ai/api/v1/chat/completions"
+            
+            logger.info(f"Making OpenRouter API request to: {url}")
+            logger.info(f"Request payload: {payload}")
+            
+            with httpx.Client(timeout=60) as client:
+                resp = client.post(url, headers=headers, json=payload)
+                
+                logger.info(f"OpenRouter API response status: {resp.status_code}")
+                logger.info(f"OpenRouter API response headers: {dict(resp.headers)}")
+                
+                # Log the raw response for debugging
+                response_text = resp.text
+                logger.info(f"OpenRouter API raw response: {response_text[:500]}...")
+                
+                if not response_text.strip():
+                    logger.error("OpenRouter API returned empty response")
+                    return {
+                        "success": False,
+                        "answer": "OpenRouter API returned empty response. Please check your API key and try again.",
+                        "sources": []
+                    }
+                
+                resp.raise_for_status()
+                
+                try:
+                    data = resp.json()
+                    logger.info(f"OpenRouter API parsed response: {data}")
+                except Exception as e:
+                    logger.error(f"OpenRouter API non-JSON response: {response_text}")
+                    logger.error(f"JSON parsing error: {e}")
+                    return {
+                        "success": False,
+                        "answer": f"OpenRouter API returned invalid JSON response: {str(e)}",
+                        "sources": []
+                    }
+                
+                if "choices" not in data or not data["choices"]:
+                    logger.error(f"OpenRouter API response missing choices: {data}")
+                    return {
+                        "success": False,
+                        "answer": "OpenRouter API response missing choices field",
+                        "sources": []
+                    }
+                
+                answer = data["choices"][0]["message"]["content"].strip()
+
+            return {
+                "success": True,
+                "answer": answer,
+                "model": "openrouter/meta-llama/llama-3-70b-instruct",
+                "sources": []  # Always set to empty, will be overwritten by generate_answer
+            }
+        except httpx.HTTPStatusError as e:
+            logger.error(f"OpenRouter API HTTP error: {e.response.status_code} - {e.response.text}")
+            return {
+                "success": False,
+                "answer": f"OpenRouter API HTTP error: {e.response.status_code} - {e.response.text}",
+                "sources": []
+            }
+        except Exception as e:
+            logger.error(f"OpenRouter API error: {e}")
+            return {
+                "success": False,
+                "answer": f"Error calling OpenRouter API: {str(e)}",
+                "sources": []
+            }
+    
+    def _generate_anthropic_answer(self, question: str, context: str) -> Dict:
+        """Generate answer using Anthropic Claude API"""
+        try:
+            if not self.anthropic_client:
+                return {
+                    "success": False,
+                    "answer": "Anthropic client not configured",
+                    "sources": []
+                }
+            
+            system_prompt = """You are a helpful AI assistant that answers questions based on provided document context. 
+            Follow these guidelines:
+            1. Only answer based on the information provided in the context
+            2. If the context doesn't contain enough information to answer the question, say so
+            3. Be concise but comprehensive
+            4. Cite specific parts of the documents when possible
+            5. If you're unsure about something, acknowledge the uncertainty
+            6. Format your response clearly and professionally using proper markdown formatting:\n   - Use **bold** for important points and headings\n   - Use bullet points (•) for lists\n   - Use numbered lists for step-by-step instructions\n   - Use proper paragraph breaks for readability\n   - Structure your response with clear sections when appropriate\n   - Use blockquotes for important quotes or key information\n7. You must answer the user's question as directly as possible, using only the information in the context. Do not simply summarize the context. If the context does not contain an answer, say so."""
+
+            user_prompt = f"""Context from documents:\n{context}\n\nQuestion: {question}\n\nPlease provide a comprehensive answer based on the context above."""
+
+            response = self.anthropic_client.messages.create(
+                model="claude-3-sonnet-20240229",
+                max_tokens=1000,
+                temperature=0.3,
+                system=system_prompt,
+                messages=[
+                    {"role": "user", "content": user_prompt}
+                ]
+            )
+            
+            answer = response.content[0].text.strip()
+            
+            return {
+                "success": True,
+                "answer": answer,
+                "model": "claude-3-sonnet-20240229",
+                "sources": []  # Always set to empty, will be overwritten by generate_answer
+            }
+        
+        except Exception as e:
+            logger.error(f"Anthropic API error: {e}")
+            return {
+                "success": False,
+                "answer": f"Error calling Anthropic API: {str(e)}",
+                "sources": []
+            }
+    
+    def _extract_sources_from_context(self, context: str) -> List[str]:
+        """Extract source information from context"""
+        sources = set()  # Use set to avoid duplicates
+        lines = context.split('\n')
+        
+        for line in lines:
+            if line.startswith('Document') and 'ID:' in line:
+                # Extract document ID
+                parts = line.split('ID:')
+                if len(parts) > 1:
+                    doc_id = parts[1].strip().split()[0]
+                    sources.add(f"Document ID: {doc_id}")
+        
+        return list(sources)  # Convert back to list
+    
+    def get_available_models(self) -> List[str]:
+        """Get list of available AI models"""
+        models = []
+        if self.openrouter_api_key:
+            models.append("openrouter")
+        if self.anthropic_client:
+            models.append("anthropic")
+        return models
+    
+    def is_configured(self) -> bool:
+        """Check if any AI service is configured"""
+        return bool(self.openrouter_api_key or self.anthropic_client) 

backend/app/services/pdf_processor.py

@@ -0,0 +1,105 @@
+import PyPDF2
+import os
+from typing import Optional, Tuple
+from app.core.config import settings
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class PDFProcessor:
+    def __init__(self):
+        self.allowed_extensions = settings.ALLOWED_EXTENSIONS
+        self.max_file_size = settings.MAX_FILE_SIZE
+    
+    def validate_file(self, file_path: str) -> Tuple[bool, str]:
+        """Validate uploaded file"""
+        if not os.path.exists(file_path):
+            return False, "File does not exist"
+        
+        # Check file size
+        file_size = os.path.getsize(file_path)
+        if file_size > self.max_file_size:
+            return False, f"File size exceeds maximum allowed size of {self.max_file_size} bytes"
+        
+        # Check file extension
+        file_ext = os.path.splitext(file_path)[1].lower()
+        if file_ext not in self.allowed_extensions:
+            return False, f"File type not allowed. Allowed types: {', '.join(self.allowed_extensions)}"
+        
+        return True, "File is valid"
+    
+    def extract_text(self, file_path: str) -> Optional[str]:
+        """Extract text content from PDF file"""
+        try:
+            with open(file_path, 'rb') as file:
+                pdf_reader = PyPDF2.PdfReader(file)
+                text_content = []
+                
+                for page_num in range(len(pdf_reader.pages)):
+                    try:
+                        page = pdf_reader.pages[page_num]
+                        text = page.extract_text()
+                        if text.strip():
+                            text_content.append(f"Page {page_num + 1}:\n{text.strip()}")
+                    except Exception as e:
+                        logger.warning(f"Error extracting text from page {page_num + 1}: {e}")
+                        continue
+                
+                return "\n\n".join(text_content)
+        
+        except Exception as e:
+            logger.error(f"Error processing PDF file {file_path}: {e}")
+            return None
+    
+    def get_metadata(self, file_path: str) -> dict:
+        """Extract metadata from PDF file"""
+        try:
+            with open(file_path, 'rb') as file:
+                pdf_reader = PyPDF2.PdfReader(file)
+                metadata = {
+                    'num_pages': len(pdf_reader.pages),
+                    'file_size': os.path.getsize(file_path),
+                    'title': None,
+                    'author': None,
+                    'subject': None,
+                    'creator': None
+                }
+                
+                if pdf_reader.metadata:
+                    metadata.update({
+                        'title': pdf_reader.metadata.get('/Title'),
+                        'author': pdf_reader.metadata.get('/Author'),
+                        'subject': pdf_reader.metadata.get('/Subject'),
+                        'creator': pdf_reader.metadata.get('/Creator')
+                    })
+                
+                return metadata
+        
+        except Exception as e:
+            logger.error(f"Error extracting metadata from PDF file {file_path}: {e}")
+            return {
+                'num_pages': 0,
+                'file_size': os.path.getsize(file_path) if os.path.exists(file_path) else 0,
+                'title': None,
+                'author': None,
+                'subject': None,
+                'creator': None
+            }
+    
+    def process_pdf(self, file_path: str) -> Tuple[bool, str, dict]:
+        """Process PDF file and return text content and metadata"""
+        # Validate file
+        is_valid, error_message = self.validate_file(file_path)
+        if not is_valid:
+            return False, error_message, {}
+        
+        # Extract text
+        text_content = self.extract_text(file_path)
+        if text_content is None:
+            return False, "Failed to extract text from PDF", {}
+        
+        # Get metadata
+        metadata = self.get_metadata(file_path)
+        
+        return True, text_content, metadata 

backend/app/services/vector_store.py

@@ -0,0 +1,194 @@
+import chromadb
+from chromadb.config import Settings as ChromaSettings
+from typing import List, Dict, Optional, Tuple
+import json
+import logging
+from app.core.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class VectorStore:
+    _instance = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(VectorStore, cls).__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+    
+    def __init__(self):
+        if not self._initialized:
+            self.client = chromadb.PersistentClient(
+                path=settings.CHROMA_PERSIST_DIRECTORY,
+                settings=ChromaSettings(
+                    anonymized_telemetry=False
+                )
+            )
+            self.collection_name = "pdf_documents"
+            self.collection = self._get_or_create_collection()
+            self._initialized = True
+    
+    def _get_or_create_collection(self):
+        """Get existing collection or create new one"""
+        try:
+            collection = self.client.get_collection(name=self.collection_name)
+            logger.info(f"Using existing collection: {self.collection_name}")
+        except Exception:
+            collection = self.client.create_collection(
+                name=self.collection_name,
+                metadata={"description": "PDF document embeddings for Q&A chatbot"}
+            )
+            logger.info(f"Created new collection: {self.collection_name}")
+        
+        return collection
+    
+    def add_document(self, document_id: str, content: str, metadata: Dict = None) -> bool:
+        """Add document content to vector store"""
+        try:
+            logger.info(f"Starting to add document {document_id} to vector store")
+            logger.info(f"Content length: {len(content)} characters")
+            
+            # Split content into chunks for better retrieval
+            chunks = self._split_text(content, chunk_size=1000, overlap=200)
+            logger.info(f"Split content into {len(chunks)} chunks")
+            
+            # Prepare data for ChromaDB
+            ids = [f"{document_id}_chunk_{i}" for i in range(len(chunks))]
+            documents = chunks
+            metadatas = [{
+                "document_id": document_id,
+                "chunk_index": i,
+                **(metadata or {})
+            } for i in range(len(chunks))]
+            
+            logger.info(f"Prepared {len(ids)} chunks with IDs: {ids[:3]}...")  # Log first 3 IDs
+            
+            # Add to collection
+            logger.info(f"Adding chunks to ChromaDB collection: {self.collection_name}")
+            self.collection.add(
+                ids=ids,
+                documents=documents,
+                metadatas=metadatas
+            )
+            
+            logger.info(f"Successfully added document {document_id} with {len(chunks)} chunks to vector store")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error adding document {document_id} to vector store: {e}")
+            logger.error(f"Exception type: {type(e).__name__}")
+            import traceback
+            logger.error(f"Full traceback: {traceback.format_exc()}")
+            return False
+    
+    def search_similar(self, query: str, n_results: int = 5, document_id: str = None) -> List[Dict]:
+        """Search for similar documents based on query, optionally filtering by document_id"""
+        try:
+            results = self.collection.query(
+                query_texts=[query],
+                n_results=n_results,
+                include=["documents", "metadatas", "distances"]
+            )
+            
+            # Format results
+            formatted_results = []
+            if results['documents'] and results['documents'][0]:
+                for i, (doc, metadata, distance) in enumerate(zip(
+                    results['documents'][0],
+                    results['metadatas'][0],
+                    results['distances'][0]
+                )):
+                    if document_id is not None and str(metadata.get('document_id')) != str(document_id):
+                        continue
+                    formatted_results.append({
+                        'content': doc,
+                        'metadata': metadata,
+                        'similarity_score': 1 - distance,  # Convert distance to similarity
+                        'rank': i + 1
+                    })
+            return formatted_results
+        except Exception as e:
+            logger.error(f"Error searching vector store: {e}")
+            return []
+    
+    def delete_document(self, document_id: str) -> bool:
+        """Delete all chunks for a specific document"""
+        try:
+            # Get all chunks for this document
+            results = self.collection.get(
+                where={"document_id": document_id}
+            )
+            
+            if results['ids']:
+                self.collection.delete(ids=results['ids'])
+                logger.info(f"Deleted {len(results['ids'])} chunks for document {document_id}")
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error deleting document {document_id} from vector store: {e}")
+            return False
+    
+    def get_collection_stats(self) -> Dict:
+        """Get statistics about the vector store collection"""
+        try:
+            logger.info(f"Getting stats for collection: {self.collection_name}")
+            count = self.collection.count()
+            logger.info(f"Collection count: {count}")
+            return {
+                "total_documents": count,
+                "collection_name": self.collection_name
+            }
+        except Exception as e:
+            logger.error(f"Error getting collection stats: {e}")
+            logger.error(f"Exception type: {type(e).__name__}")
+            import traceback
+            logger.error(f"Full traceback: {traceback.format_exc()}")
+            return {"total_documents": 0, "collection_name": self.collection_name}
+    
+    def _split_text(self, text: str, chunk_size: int = 1000, overlap: int = 200) -> List[str]:
+        """Split text into overlapping chunks"""
+        if len(text) <= chunk_size:
+            return [text]
+        
+        chunks = []
+        start = 0
+        
+        while start < len(text):
+            end = start + chunk_size
+            
+            # If this isn't the last chunk, try to break at a sentence boundary
+            if end < len(text):
+                # Look for sentence endings
+                for i in range(end, max(start + chunk_size - 100, start), -1):
+                    if text[i] in '.!?':
+                        end = i + 1
+                        break
+            
+            chunk = text[start:end].strip()
+            if chunk:
+                chunks.append(chunk)
+            
+            # Move start position with overlap
+            start = end - overlap
+            if start >= len(text):
+                break
+        
+        return chunks
+    
+    def clear_all(self) -> bool:
+        """Clear all documents from the vector store"""
+        try:
+            self.client.delete_collection(name=self.collection_name)
+            self.collection = self._get_or_create_collection()
+            logger.info("Cleared all documents from vector store")
+            return True
+        except Exception as e:
+            logger.error(f"Error clearing vector store: {e}")
+            return False
+    
+    @classmethod
+    def reset_instance(cls):
+        """Reset the singleton instance - useful after clearing collections"""
+        cls._instance = None 

backend/main.py

@@ -0,0 +1,125 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+import logging
+import os
+
+from app.core.config import settings
+from app.core.database import create_tables, SessionLocal
+from app.models.document import Document, ChatMessage
+import shutil
+from app.api.endpoints import documents, chat
+from app.services.vector_store import VectorStore
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+
+# Create FastAPI app
+app = FastAPI(
+    title=settings.PROJECT_NAME,
+    description="A comprehensive PDF-based Q&A chatbot system",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.BACKEND_CORS_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include API routes
+app.include_router(
+    documents.router,
+    prefix=f"{settings.API_V1_STR}/documents",
+    tags=["documents"]
+)
+
+app.include_router(
+    chat.router,
+    prefix=f"{settings.API_V1_STR}/chat",
+    tags=["chat"]
+)
+
+# Health check endpoint
+@app.get("/health")
+def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "service": settings.PROJECT_NAME,
+        "version": "1.0.0"
+    }
+
+# Root endpoint
+@app.get("/")
+def root():
+    """Root endpoint with API information"""
+    return {
+        "message": "PDF Q&A Chatbot API",
+        "version": "1.0.0",
+        "docs": "/docs",
+        "health": "/health"
+    }
+
+# Startup event
+@app.on_event("startup")
+async def startup_event():
+    """Initialize application on startup"""
+    # Create database tables
+    create_tables()
+    
+    # Ensure directories exist
+    os.makedirs(settings.UPLOAD_DIR, exist_ok=True)
+    os.makedirs(settings.CHROMA_PERSIST_DIRECTORY, exist_ok=True)
+
+    # --- ERASE ALL DOCUMENTS, CHAT MESSAGES, AND VECTORS ON STARTUP ---
+    # 1. Delete all rows from documents and chat_messages tables
+    db = SessionLocal()
+    try:
+        db.query(Document).delete()
+        db.query(ChatMessage).delete()
+        db.commit()
+    finally:
+        db.close()
+    # 2. Remove all files in chroma_db directory (but keep the directory)
+    chroma_dir = settings.CHROMA_PERSIST_DIRECTORY
+    for filename in os.listdir(chroma_dir):
+        file_path = os.path.join(chroma_dir, filename)
+        try:
+            if os.path.isfile(file_path) or os.path.islink(file_path):
+                os.unlink(file_path)
+            elif os.path.isdir(file_path):
+                shutil.rmtree(file_path)
+        except Exception as e:
+            logging.warning(f"Failed to delete {file_path}: {e}")
+    # 3. Explicitly clear ChromaDB vector store
+    vector_store = VectorStore()
+    vector_store.clear_all()
+    logging.info("All documents, chat messages, and vector store erased on startup.")
+    # --- END ERASE ---
+
+    logging.info("Application started successfully")
+
+# Shutdown event
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Cleanup on application shutdown"""
+    logging.info("Application shutting down")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(
+        "main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=True,
+        log_level="info"
+    ) 

backend/requirements.txt

@@ -0,0 +1,19 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+python-multipart==0.0.6
+pydantic==2.5.0
+pydantic-settings==2.1.0
+sqlalchemy==2.0.23
+alembic==1.13.0
+chromadb==0.4.18
+openai==1.3.7
+anthropic==0.7.8
+pypdf2==3.0.1
+python-dotenv==1.0.0
+aiofiles==23.2.1
+python-jose[cryptography]==3.3.0
+passlib[bcrypt]==1.7.4
+python-multipart==0.0.6
+httpx==0.25.2
+pytest==7.4.3
+pytest-asyncio==0.21.1 

backend/test_openrouter.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""
+Test script to verify OpenRouter API connectivity
+"""
+
+import os
+import httpx
+import json
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+def test_openrouter_api():
+    """Test OpenRouter API connection"""
+    api_key = os.getenv("OPENROUTER_API_KEY")
+    
+    if not api_key:
+        print("❌ No OpenRouter API key found in environment variables")
+        return False
+    
+    print(f"🔑 API Key found: {api_key[:10]}...{api_key[-4:]}")
+    
+    # Test API endpoint
+    url = "https://openrouter.ai/api/v1/chat/completions"
+    
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "HTTP-Referer": "http://localhost:3000",
+        "X-Title": "PDF Q&A Chatbot Test",
+        "Content-Type": "application/json"
+    }
+    
+    payload = {
+        "model": "meta-llama/llama-3-70b-instruct",
+        "messages": [
+            {"role": "user", "content": "Hello! Please respond with 'API test successful' if you can see this message."}
+        ],
+        "max_tokens": 50,
+        "temperature": 0.1
+    }
+    
+    print(f"🌐 Making request to: {url}")
+    print(f"📤 Request payload: {json.dumps(payload, indent=2)}")
+    
+    try:
+        with httpx.Client(timeout=30) as client:
+            response = client.post(url, headers=headers, json=payload)
+            
+            print(f"📥 Response status: {response.status_code}")
+            print(f"📥 Response headers: {dict(response.headers)}")
+            
+            # Log raw response
+            response_text = response.text
+            print(f"📥 Raw response: {response_text}")
+            
+            if not response_text.strip():
+                print("❌ Empty response received")
+                return False
+            
+            if response.status_code != 200:
+                print(f"❌ HTTP error: {response.status_code}")
+                return False
+            
+            # Try to parse JSON
+            try:
+                data = response.json()
+                print(f"✅ JSON parsed successfully: {json.dumps(data, indent=2)}")
+                
+                if "choices" in data and data["choices"]:
+                    answer = data["choices"][0]["message"]["content"]
+                    print(f"🤖 AI Response: {answer}")
+                    return True
+                else:
+                    print("❌ No choices in response")
+                    return False
+                    
+            except json.JSONDecodeError as e:
+                print(f"❌ JSON parsing failed: {e}")
+                return False
+                
+    except Exception as e:
+        print(f"❌ Request failed: {e}")
+        return False
+
+if __name__ == "__main__":
+    print("🧪 Testing OpenRouter API connectivity...")
+    success = test_openrouter_api()
+    
+    if success:
+        print("✅ OpenRouter API test successful!")
+    else:
+        print("❌ OpenRouter API test failed!") 

docker-compose.yml

@@ -0,0 +1,42 @@
+version: '3.8'
+
+services:
+  backend:
+    build:
+      context: ./backend
+      dockerfile: Dockerfile
+    ports:
+      - "8000:8000"
+    environment:
+      - DATABASE_URL=sqlite:///./pdf_chatbot.db
+      - CHROMA_PERSIST_DIRECTORY=./chroma_db
+      - UPLOAD_DIR=./uploads
+      - MAX_FILE_SIZE=10485760
+      - ALLOWED_EXTENSIONS=[".pdf"]
+      - BACKEND_CORS_ORIGINS=["http://localhost:3000","http://localhost:3001","http://127.0.0.1:3000","http://127.0.0.1:3001"]
+    env_file:
+      - ./backend/.env
+    volumes:
+      - ./backend/uploads:/app/uploads
+      - ./backend/chroma_db:/app/chroma_db
+      - ./backend/pdf_chatbot.db:/app/pdf_chatbot.db
+    restart: unless-stopped
+
+  frontend:
+    build:
+      context: ./frontend
+      dockerfile: Dockerfile
+    ports:
+      - "3000:3000"
+    environment:
+      - NEXT_PUBLIC_API_URL=http://localhost:8000
+    env_file:
+      - ./frontend/.env
+    depends_on:
+      - backend
+    restart: unless-stopped
+
+volumes:
+  uploads:
+  chroma_db:
+  database: 

frontend/Dockerfile

@@ -0,0 +1,25 @@
+FROM node:18-alpine
+
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+
+# Install dependencies
+RUN npm ci --only=production
+
+# Copy application code
+COPY . .
+
+# Build the application
+RUN npm run build
+
+# Expose port
+EXPOSE 3000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:3000 || exit 1
+
+# Run the application
+CMD ["npm", "start"] 

frontend/app/globals.css

@@ -0,0 +1,107 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+@layer base {
+  :root {
+    --background: 0 0% 100%;
+    --foreground: 222.2 84% 4.9%;
+    --card: 0 0% 100%;
+    --card-foreground: 222.2 84% 4.9%;
+    --popover: 0 0% 100%;
+    --popover-foreground: 222.2 84% 4.9%;
+    --primary: 221.2 83.2% 53.3%;
+    --primary-foreground: 210 40% 98%;
+    --secondary: 210 40% 96%;
+    --secondary-foreground: 222.2 84% 4.9%;
+    --muted: 210 40% 96%;
+    --muted-foreground: 215.4 16.3% 46.9%;
+    --accent: 210 40% 96%;
+    --accent-foreground: 222.2 84% 4.9%;
+    --destructive: 0 84.2% 60.2%;
+    --destructive-foreground: 210 40% 98%;
+    --border: 214.3 31.8% 91.4%;
+    --input: 214.3 31.8% 91.4%;
+    --ring: 221.2 83.2% 53.3%;
+    --radius: 0.5rem;
+  }
+
+  .dark {
+    --background: 222.2 84% 4.9%;
+    --foreground: 210 40% 98%;
+    --card: 222.2 84% 4.9%;
+    --card-foreground: 210 40% 98%;
+    --popover: 222.2 84% 4.9%;
+    --popover-foreground: 210 40% 98%;
+    --primary: 217.2 91.2% 59.8%;
+    --primary-foreground: 222.2 84% 4.9%;
+    --secondary: 217.2 32.6% 17.5%;
+    --secondary-foreground: 210 40% 98%;
+    --muted: 217.2 32.6% 17.5%;
+    --muted-foreground: 215 20.2% 65.1%;
+    --accent: 217.2 32.6% 17.5%;
+    --accent-foreground: 210 40% 98%;
+    --destructive: 0 62.8% 30.6%;
+    --destructive-foreground: 210 40% 98%;
+    --border: 217.2 32.6% 17.5%;
+    --input: 217.2 32.6% 17.5%;
+    --ring: 224.3 76.3% 94.1%;
+  }
+}
+
+@layer base {
+  * {
+    @apply border-border;
+  }
+  body {
+    @apply bg-background text-foreground;
+  }
+}
+
+/* Custom scrollbar */
+::-webkit-scrollbar {
+  width: 6px;
+}
+
+::-webkit-scrollbar-track {
+  background: hsl(var(--muted));
+}
+
+::-webkit-scrollbar-thumb {
+  background: hsl(var(--muted-foreground));
+  border-radius: 3px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+  background: hsl(var(--foreground));
+}
+
+/* Chat message animations */
+@keyframes slideIn {
+  from {
+    opacity: 0;
+    transform: translateY(10px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+.chat-message {
+  animation: slideIn 0.3s ease-out;
+}
+
+/* Loading animation */
+@keyframes pulse {
+  0%, 100% {
+    opacity: 1;
+  }
+  50% {
+    opacity: 0.5;
+  }
+}
+
+.animate-pulse {
+  animation: pulse 2s cubic-bezier(0.4, 0, 0.6, 1) infinite;
+} 

frontend/app/layout.tsx

@@ -0,0 +1,26 @@
+import type { Metadata } from 'next'
+import { Inter } from 'next/font/google'
+import './globals.css'
+
+const inter = Inter({ subsets: ['latin'] })
+
+export const metadata: Metadata = {
+  title: 'PDF Q&A Chatbot',
+  description: 'A comprehensive PDF-based Q&A chatbot system',
+}
+
+export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode
+}) {
+  return (
+    <html lang="en">
+      <body className={inter.className}>
+        <div className="min-h-screen bg-background">
+          {children}
+        </div>
+      </body>
+    </html>
+  )
+} 

frontend/app/page.tsx

@@ -0,0 +1,128 @@
+'use client'
+
+import { useState, useEffect, useCallback } from 'react'
+import { Upload, MessageCircle, FileText, Settings, Send, Trash2 } from 'lucide-react'
+import ChatInterface from '@/components/ChatInterface'
+import DocumentUpload from '@/components/DocumentUpload'
+import DocumentList from '@/components/DocumentList'
+import { useChatStore } from '@/lib/store'
+import { apiService } from '@/lib/api'
+
+export default function Home() {
+  const [activeTab, setActiveTab] = useState<'chat' | 'documents'>('documents')
+  const { sessionId, createNewSession } = useChatStore()
+  const [documentCount, setDocumentCount] = useState(0)
+
+  const fetchDocumentCount = useCallback(async () => {
+    try {
+      const response = await apiService.getDocuments()
+      setDocumentCount(response.documents.length)
+    } catch (e) {
+      setDocumentCount(0)
+    }
+  }, [])
+
+  useEffect(() => {
+    if (!sessionId) {
+      createNewSession()
+    }
+  }, [sessionId, createNewSession])
+
+  useEffect(() => {
+    fetchDocumentCount()
+  }, [activeTab, fetchDocumentCount])
+
+  useEffect(() => {
+    // Clear all data on every page load
+    fetch('/api/v1/documents/clear_all', { method: 'POST' })
+      .then(() => fetchDocumentCount())
+      .catch(() => fetchDocumentCount())
+  }, [])
+
+  return (
+    <div className="flex h-screen bg-gray-50">
+      {/* Sidebar */}
+      <div className="w-64 bg-white border-r border-gray-200 flex flex-col">
+        <div className="p-6 border-b border-gray-200">
+          <h1 className="text-xl font-bold text-gray-900">PDF Q&A Chatbot</h1>
+          <p className="text-sm text-gray-600 mt-1">Upload and chat with your documents</p>
+        </div>
+        
+        <nav className="flex-1 p-4">
+          <div className="space-y-2">
+            <button
+              onClick={() => setActiveTab('documents')}
+              className={`w-full flex items-center px-3 py-2 text-sm font-medium rounded-md transition-colors ${
+                activeTab === 'documents'
+                  ? 'bg-blue-100 text-blue-700'
+                  : 'text-gray-600 hover:bg-gray-100'
+              }`}
+            >
+              <FileText className="w-4 h-4 mr-3" />
+              Documents
+            </button>
+            <button
+              onClick={() => setActiveTab('chat')}
+              className={`w-full flex items-center px-3 py-2 text-sm font-medium rounded-md transition-colors ${
+                activeTab === 'chat'
+                  ? 'bg-blue-100 text-blue-700'
+                  : 'text-gray-600 hover:bg-gray-100'
+              }`}
+            >
+              <MessageCircle className="w-4 h-4 mr-3" />
+              Chat
+            </button>
+          </div>
+        </nav>
+        {/* Removed Upload PDF button from sidebar */}
+      </div>
+
+      {/* Main Content */}
+      <div className="flex-1 flex flex-col">
+        {activeTab === 'chat' && (
+          <div className="flex-1 flex flex-col">
+            <div className="p-6 border-b border-gray-200">
+              <h2 className="text-lg font-semibold text-gray-900">Chat with Documents</h2>
+              <p className="text-sm text-gray-600 mt-1">
+                Ask questions about your uploaded PDF documents
+              </p>
+            </div>
+            <div className="flex-1 overflow-hidden">
+              <ChatInterface />
+            </div>
+          </div>
+        )}
+
+        {activeTab === 'documents' && (
+          <div className="flex-1 flex flex-col">
+            <div className="p-6 border-b border-gray-200">
+              <h2 className="text-lg font-semibold text-gray-900">Document Management</h2>
+              <p className="text-sm text-gray-600 mt-1">
+                Upload, view, and manage your PDF documents
+              </p>
+            </div>
+            <div className="flex-1 overflow-auto">
+              <div className="p-6">
+                <DocumentUpload disabled={documentCount >= 3} onDocumentChange={fetchDocumentCount} />
+                <div className="mt-8">
+                  <DocumentList onDocumentChange={fetchDocumentCount} />
+                </div>
+              </div>
+            </div>
+          </div>
+        )}
+        {/* Add fixed Upload PDF button at bottom left */}
+        <div className="fixed bottom-6 left-6 z-50">
+          <button
+            onClick={() => setActiveTab('documents')}
+            className={`w-48 flex items-center justify-center px-3 py-2 text-sm font-medium text-white bg-blue-600 rounded-md transition-colors shadow-lg ${documentCount >= 3 ? 'opacity-60 cursor-not-allowed' : ''}`}
+            disabled={documentCount >= 3}
+          >
+            <Upload className="w-4 h-4 mr-2" />
+            Upload PDF
+          </button>
+        </div>
+      </div>
+    </div>
+  )
+} 

frontend/components/ChatInterface.tsx

@@ -0,0 +1,240 @@
+'use client'
+
+import { useState, useRef, useEffect } from 'react'
+import { Send, Bot, User, Loader2 } from 'lucide-react'
+import { useChatStore, ChatMessage } from '@/lib/store'
+import { apiService } from '@/lib/api'
+import ReactMarkdown from 'react-markdown'
+import remarkGfm from 'remark-gfm'
+
+export default function ChatInterface() {
+  const [input, setInput] = useState('')
+  const [isLoading, setIsLoading] = useState(false)
+  const messagesEndRef = useRef<HTMLDivElement>(null)
+  const { sessionId, messages, addMessage, setLoading } = useChatStore()
+
+  const scrollToBottom = () => {
+    messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' })
+  }
+
+  useEffect(() => {
+    scrollToBottom()
+  }, [messages])
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault()
+    if (!input.trim() || !sessionId || isLoading) return
+
+    const userMessage = input.trim()
+    setInput('')
+    setIsLoading(true)
+    setLoading(true)
+
+    // Add user message
+    addMessage({
+      content: userMessage,
+      type: 'user',
+    })
+
+    try {
+      const response = await apiService.sendMessage({
+        question: userMessage,
+        session_id: sessionId,
+      })
+
+      // Add assistant message
+      addMessage({
+        content: response.answer,
+        type: 'assistant',
+        sources: response.sources,
+      })
+    } catch (error) {
+      console.error('Error sending message:', error)
+      addMessage({
+        content: 'Sorry, I encountered an error while processing your request. Please try again.',
+        type: 'assistant',
+      })
+    } finally {
+      setIsLoading(false)
+      setLoading(false)
+    }
+  }
+
+  const formatTimestamp = (timestamp: Date) => {
+    return timestamp.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })
+  }
+
+  return (
+    <div className="flex flex-col h-full">
+      {/* Messages */}
+      <div className="flex-1 overflow-y-auto p-4 space-y-4">
+        {messages.length === 0 ? (
+          <div className="flex items-center justify-center h-full text-gray-500">
+            <div className="text-center">
+              <Bot className="w-12 h-12 mx-auto mb-4 text-gray-300" />
+              <p className="text-lg font-medium">Start a conversation</p>
+              <p className="text-sm">Ask questions about your uploaded documents</p>
+            </div>
+          </div>
+        ) : (
+          messages.map((message) => (
+            <div
+              key={message.id}
+              className={`flex ${message.type === 'user' ? 'justify-end' : 'justify-start'}`}
+            >
+              <div
+                className={`max-w-[75%] rounded-xl px-4 py-3 shadow-sm ${
+                  message.type === 'user'
+                    ? 'bg-blue-600 text-white'
+                    : 'bg-white text-gray-900 border border-gray-200'
+                }`}
+              >
+                <div className="flex items-start space-x-2">
+                  {message.type === 'assistant' && (
+                    <Bot className="w-4 h-4 mt-1 flex-shrink-0" />
+                  )}
+                  <div className="flex-1">
+                    <ReactMarkdown
+                      remarkPlugins={[remarkGfm]}
+                      className="prose prose-sm max-w-none leading-relaxed"
+                      components={{
+                        // Enhanced paragraph styling
+                        p: ({ children }) => (
+                          <p className="mb-3 text-gray-800 leading-6">{children}</p>
+                        ),
+                        // Enhanced heading styling
+                        h1: ({ children }) => (
+                          <h1 className="text-xl font-bold text-gray-900 mb-3 mt-4 border-b border-gray-200 pb-2">{children}</h1>
+                        ),
+                        h2: ({ children }) => (
+                          <h2 className="text-lg font-semibold text-gray-900 mb-2 mt-4">{children}</h2>
+                        ),
+                        h3: ({ children }) => (
+                          <h3 className="text-base font-medium text-gray-900 mb-2 mt-3">{children}</h3>
+                        ),
+                        // Enhanced list styling
+                        ul: ({ children }) => (
+                          <ul className="mb-3 ml-4 space-y-1">{children}</ul>
+                        ),
+                        ol: ({ children }) => (
+                          <ol className="mb-3 ml-4 space-y-1 list-decimal">{children}</ol>
+                        ),
+                        li: ({ children }) => (
+                          <li className="text-gray-800 leading-6">{children}</li>
+                        ),
+                        // Enhanced code styling
+                        code: ({ node, inline, className, children, ...props }) => {
+                          return (
+                            <code
+                              className={`${className} ${
+                                inline
+                                  ? 'bg-gray-200 px-1.5 py-0.5 rounded text-sm font-mono text-gray-800'
+                                  : 'block bg-gray-100 p-3 rounded-md text-sm font-mono text-gray-800 border border-gray-200'
+                              }`}
+                              {...props}
+                            >
+                              {children}
+                            </code>
+                          )
+                        },
+                        // Enhanced blockquote styling
+                        blockquote: ({ children }) => (
+                          <blockquote className="border-l-4 border-blue-500 pl-4 py-2 my-3 bg-blue-50 rounded-r-md">
+                            <div className="text-gray-700 italic">{children}</div>
+                          </blockquote>
+                        ),
+                        // Enhanced table styling
+                        table: ({ children }) => (
+                          <div className="overflow-x-auto my-4">
+                            <table className="min-w-full border border-gray-300 rounded-lg">
+                              {children}
+                            </table>
+                          </div>
+                        ),
+                        th: ({ children }) => (
+                          <th className="border border-gray-300 px-3 py-2 bg-gray-100 font-semibold text-gray-900 text-left">
+                            {children}
+                          </th>
+                        ),
+                        td: ({ children }) => (
+                          <td className="border border-gray-300 px-3 py-2 text-gray-800">
+                            {children}
+                          </td>
+                        ),
+                        // Enhanced strong/bold styling
+                        strong: ({ children }) => (
+                          <strong className="font-semibold text-gray-900">{children}</strong>
+                        ),
+                        // Enhanced emphasis styling
+                        em: ({ children }) => (
+                          <em className="italic text-gray-700">{children}</em>
+                        ),
+                      }}
+                    >
+                      {message.content}
+                    </ReactMarkdown>
+                    {message.sources && message.sources.length > 0 && (
+                      <div className="mt-3 pt-3 border-t border-gray-200">
+                        <p className="text-xs font-medium text-gray-600 mb-2 flex items-center">
+                          <span className="w-2 h-2 bg-blue-500 rounded-full mr-2"></span>
+                          Sources:
+                        </p>
+                        <div className="space-y-1">
+                          {message.sources.map((source, index) => (
+                            <p key={index} className="text-xs text-gray-600 bg-gray-50 px-2 py-1 rounded">
+                              {source}
+                            </p>
+                          ))}
+                        </div>
+                      </div>
+                    )}
+                  </div>
+                  {message.type === 'user' && (
+                    <User className="w-4 h-4 mt-1 flex-shrink-0" />
+                  )}
+                </div>
+                <div className="text-xs opacity-70 mt-1">
+                  {formatTimestamp(message.timestamp)}
+                </div>
+              </div>
+            </div>
+          ))
+        )}
+        
+        {isLoading && (
+          <div className="flex justify-start">
+            <div className="bg-gray-100 rounded-lg px-4 py-2">
+              <div className="flex items-center space-x-2">
+                <Loader2 className="w-4 h-4 animate-spin" />
+                <span className="text-sm text-gray-600">Thinking...</span>
+              </div>
+            </div>
+          </div>
+        )}
+        
+        <div ref={messagesEndRef} />
+      </div>
+
+      {/* Input */}
+      <div className="border-t border-gray-200 p-4">
+        <form onSubmit={handleSubmit} className="flex space-x-2">
+          <input
+            type="text"
+            value={input}
+            onChange={(e) => setInput(e.target.value)}
+            placeholder="Ask a question about your documents..."
+            className="flex-1 px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+            disabled={isLoading}
+          />
+          <button
+            type="submit"
+            disabled={!input.trim() || isLoading}
+            className="px-4 py-2 bg-blue-600 text-white rounded-md hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-2 disabled:opacity-50 disabled:cursor-not-allowed"
+          >
+            <Send className="w-4 h-4" />
+          </button>
+        </form>
+      </div>
+    </div>
+  )
+} 

frontend/components/DocumentList.tsx

@@ -0,0 +1,223 @@
+'use client'
+
+import { useState, useEffect } from 'react'
+import { FileText, Trash2, Calendar, HardDrive, Eye } from 'lucide-react'
+import { apiService, Document } from '@/lib/api'
+
+export default function DocumentList({ onDocumentChange }: { onDocumentChange?: () => void }) {
+  const [documents, setDocuments] = useState<Document[]>([])
+  const [loading, setLoading] = useState(true)
+  const [stats, setStats] = useState<any>(null)
+
+  useEffect(() => {
+    loadDocuments()
+    loadStats()
+  }, [])
+
+  const loadDocuments = async () => {
+    try {
+      setLoading(true)
+      const response = await apiService.getDocuments()
+      setDocuments(response.documents)
+    } catch (error) {
+      console.error('Error loading documents:', error)
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  const loadStats = async () => {
+    try {
+      const response = await apiService.getDocumentStats()
+      setStats(response)
+    } catch (error) {
+      console.error('Error loading stats:', error)
+    }
+  }
+
+  const handleDelete = async (id: number) => {
+    try {
+      await apiService.deleteDocument(id)
+      setDocuments(prev => prev.filter(doc => doc.id !== id))
+      loadStats() // Refresh stats
+      loadDocuments() // Refresh document list after delete
+      if (onDocumentChange) onDocumentChange();
+    } catch (error) {
+      console.error('Error deleting document:', error)
+      alert('Failed to delete document')
+    }
+  }
+
+  const formatFileSize = (bytes: number) => {
+    if (bytes === 0) return '0 Bytes'
+    const k = 1024
+    const sizes = ['Bytes', 'KB', 'MB', 'GB']
+    const i = Math.floor(Math.log(bytes) / Math.log(k))
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
+  }
+
+  const formatDate = (dateString: string) => {
+    return new Date(dateString).toLocaleDateString('en-US', {
+      year: 'numeric',
+      month: 'short',
+      day: 'numeric',
+      hour: '2-digit',
+      minute: '2-digit',
+    })
+  }
+
+  if (loading) {
+    return (
+      <div className="flex items-center justify-center py-8">
+        <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-blue-600"></div>
+      </div>
+    )
+  }
+
+  return (
+    <div className="space-y-6">
+      {/* Stats */}
+      {stats && (
+        <div className="grid grid-cols-1 md:grid-cols-4 gap-4">
+          <div className="bg-white p-4 rounded-lg border border-gray-200">
+            <div className="flex items-center">
+              <FileText className="w-8 h-8 text-blue-600" />
+              <div className="ml-3">
+                <p className="text-sm font-medium text-gray-600">Total Documents</p>
+                <p className="text-2xl font-bold text-gray-900">{stats.total_documents}</p>
+              </div>
+            </div>
+          </div>
+          
+          <div className="bg-white p-4 rounded-lg border border-gray-200">
+            <div className="flex items-center">
+              <CheckCircle className="w-8 h-8 text-green-600" />
+              <div className="ml-3">
+                <p className="text-sm font-medium text-gray-600">Processed</p>
+                <p className="text-2xl font-bold text-gray-900">{stats.processed_documents}</p>
+              </div>
+            </div>
+          </div>
+          
+          <div className="bg-white p-4 rounded-lg border border-gray-200">
+            <div className="flex items-center">
+              <HardDrive className="w-8 h-8 text-purple-600" />
+              <div className="ml-3">
+                <p className="text-sm font-medium text-gray-600">Total Size</p>
+                <p className="text-2xl font-bold text-gray-900">{stats.total_size_mb} MB</p>
+              </div>
+            </div>
+          </div>
+          
+          <div className="bg-white p-4 rounded-lg border border-gray-200">
+            <div className="flex items-center">
+              <Database className="w-8 h-8 text-orange-600" />
+              <div className="ml-3">
+                <p className="text-sm font-medium text-gray-600">Vector Chunks</p>
+                <p className="text-2xl font-bold text-gray-900">{stats.vector_store_chunks}</p>
+              </div>
+            </div>
+          </div>
+        </div>
+      )}
+
+      {/* Documents List */}
+      <div>
+        <h3 className="text-lg font-medium text-gray-900 mb-4">Uploaded Documents</h3>
+        
+        {documents.length === 0 ? (
+          <div className="text-center py-8">
+            <FileText className="w-12 h-12 mx-auto text-gray-400 mb-4" />
+            <p className="text-gray-500">No documents uploaded yet</p>
+            <p className="text-sm text-gray-400">Upload your first PDF document to get started</p>
+          </div>
+        ) : (
+          <div className="bg-white border border-gray-200 rounded-lg overflow-hidden">
+            <div className="overflow-x-auto">
+              <table className="min-w-full divide-y divide-gray-200">
+                <thead className="bg-gray-50">
+                  <tr>
+                    <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
+                      Document
+                    </th>
+                    <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
+                      Size
+                    </th>
+                    <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
+                      Status
+                    </th>
+                    <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
+                      Uploaded
+                    </th>
+                    <th className="px-6 py-3 text-right text-xs font-medium text-gray-500 uppercase tracking-wider">
+                      Actions
+                    </th>
+                  </tr>
+                </thead>
+                <tbody className="bg-white divide-y divide-gray-200">
+                  {documents.map((document) => (
+                    <tr key={document.id} className="hover:bg-gray-50">
+                      <td className="px-6 py-4 whitespace-nowrap">
+                        <div className="flex items-center">
+                          <FileText className="w-5 h-5 text-gray-400 mr-3" />
+                          <div>
+                            <div className="text-sm font-medium text-gray-900">
+                              {document.original_filename}
+                            </div>
+                            <div className="text-sm text-gray-500">
+                              ID: {document.id}
+                            </div>
+                          </div>
+                        </div>
+                      </td>
+                      <td className="px-6 py-4 whitespace-nowrap text-sm text-gray-900">
+                        {formatFileSize(document.file_size)}
+                      </td>
+                      <td className="px-6 py-4 whitespace-nowrap">
+                        <span className={`inline-flex px-2 py-1 text-xs font-semibold rounded-full ${
+                          document.processed
+                            ? 'bg-green-100 text-green-800'
+                            : 'bg-yellow-100 text-yellow-800'
+                        }`}>
+                          {document.processed ? 'Processed' : 'Processing'}
+                        </span>
+                      </td>
+                      <td className="px-6 py-4 whitespace-nowrap text-sm text-gray-500">
+                        <div className="flex items-center">
+                          <Calendar className="w-4 h-4 mr-1" />
+                          {formatDate(document.created_at)}
+                        </div>
+                      </td>
+                      <td className="px-6 py-4 whitespace-nowrap text-right text-sm font-medium">
+                        <button
+                          onClick={() => handleDelete(document.id)}
+                          className="text-red-600 hover:text-red-900 p-1"
+                          title="Delete document"
+                        >
+                          <Trash2 className="w-4 h-4" />
+                        </button>
+                      </td>
+                    </tr>
+                  ))}
+                </tbody>
+              </table>
+            </div>
+          </div>
+        )}
+      </div>
+    </div>
+  )
+}
+
+// Placeholder components for missing icons
+const CheckCircle = ({ className }: { className?: string }) => (
+  <svg className={className} fill="none" stroke="currentColor" viewBox="0 0 24 24">
+    <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z" />
+  </svg>
+)
+
+const Database = ({ className }: { className?: string }) => (
+  <svg className={className} fill="none" stroke="currentColor" viewBox="0 0 24 24">
+    <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M4 7v10c0 2.21 3.582 4 8 4s8-1.79 8-4V7M4 7c0 2.21 3.582 4 8 4s8-1.79 8-4M4 7c0-2.21 3.582-4 8-4s8 1.79 8 4" />
+  </svg>
+) 

frontend/components/DocumentUpload.tsx

@@ -0,0 +1,199 @@
+'use client'
+
+import { useState, useCallback } from 'react'
+import { useDropzone } from 'react-dropzone'
+import { Upload, FileText, X, CheckCircle, AlertCircle } from 'lucide-react'
+import { apiService } from '@/lib/api'
+
+interface UploadStatus {
+  file: File
+  status: 'uploading' | 'success' | 'error'
+  message?: string
+}
+
+interface DocumentUploadProps {
+  disabled?: boolean
+  onDocumentChange?: () => void
+}
+
+export default function DocumentUpload({ disabled, onDocumentChange }: DocumentUploadProps) {
+  const [uploadStatuses, setUploadStatuses] = useState<UploadStatus[]>([])
+  const [infoMessage, setInfoMessage] = useState<string | null>(null)
+
+  const onDrop = useCallback(async (acceptedFiles: File[]) => {
+    if (disabled) return;
+    // Fetch current document count
+    let currentCount = 0;
+    try {
+      const response = await apiService.getDocuments();
+      currentCount = response.documents.length;
+    } catch (e) {
+      currentCount = 0;
+    }
+    // Only allow up to 3 documents total
+    const allowed = Math.max(0, 3 - currentCount);
+    const filesToUpload = acceptedFiles.slice(0, allowed);
+    const ignoredCount = acceptedFiles.length - filesToUpload.length;
+    if (ignoredCount > 0) {
+      setInfoMessage(`Only the first ${allowed} file(s) were uploaded. The rest were ignored to keep the maximum of 3 documents.`);
+      setTimeout(() => setInfoMessage(null), 4000);
+    }
+    if (filesToUpload.length === 0) return;
+    const newUploads = filesToUpload.map(file => ({
+      file,
+      status: 'uploading' as const,
+    }))
+    setUploadStatuses(prev => [...prev, ...newUploads])
+    for (const file of filesToUpload) {
+      try {
+        const response = await apiService.uploadDocument(file)
+        setUploadStatuses(prev => 
+          prev.map(upload => 
+            upload.file === file 
+              ? { ...upload, status: 'success', message: response.message }
+              : upload
+          )
+        )
+        if (onDocumentChange) onDocumentChange();
+      } catch (error: any) {
+        setUploadStatuses(prev => 
+          prev.map(upload => 
+            upload.file === file 
+              ? { ...upload, status: 'error', message: error.response?.data?.detail || 'Upload failed' }
+              : upload
+          )
+        )
+      }
+    }
+  }, [disabled, onDocumentChange])
+
+  const { getRootProps, getInputProps, isDragActive } = useDropzone({
+    onDrop,
+    accept: {
+      'application/pdf': ['.pdf']
+    },
+    multiple: true,
+    maxSize: 10 * 1024 * 1024, // 10MB
+    disabled,
+  })
+
+  const removeUpload = async (file: File) => {
+    // If the upload was successful, delete the document from the backend as well
+    const upload = uploadStatuses.find(u => u.file === file)
+    if (upload && upload.status === 'success') {
+      try {
+        // Fetch all documents and find the one with matching original_filename
+        const response = await apiService.getDocuments()
+        const doc = response.documents.find((d: any) => d.original_filename === file.name)
+        if (doc) {
+          await apiService.deleteDocument(doc.id)
+        }
+      } catch (e) {
+        // Optionally show error, but always remove from UI
+      }
+    }
+    setUploadStatuses(prev => prev.filter(upload => upload.file !== file))
+    if (onDocumentChange) onDocumentChange();
+  }
+
+  const formatFileSize = (bytes: number) => {
+    if (bytes === 0) return '0 Bytes'
+    const k = 1024
+    const sizes = ['Bytes', 'KB', 'MB', 'GB']
+    const i = Math.floor(Math.log(bytes) / Math.log(k))
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
+  }
+
+  return (
+    <div className="space-y-4">
+      <div
+        {...getRootProps()}
+        className={`border-2 border-dashed rounded-lg p-8 text-center transition-colors ${
+          disabled
+            ? 'border-gray-200 bg-gray-100 cursor-not-allowed opacity-60'
+            : isDragActive
+              ? 'border-blue-500 bg-blue-50 cursor-pointer'
+              : 'border-gray-300 hover:border-gray-400 cursor-pointer'
+        }`}
+      >
+        <input {...getInputProps()} disabled={disabled} />
+        <Upload className="w-12 h-12 mx-auto mb-4 text-gray-400" />
+        {infoMessage && (
+          <p className="text-sm text-yellow-600 mb-2">{infoMessage}</p>
+        )}
+        {disabled ? (
+          <p className="text-lg font-medium text-gray-400">Maximum 3 documents uploaded</p>
+        ) : isDragActive ? (
+          <p className="text-lg font-medium text-blue-600">Drop the PDF files here...</p>
+        ) : (
+          <div>
+            <p className="text-lg font-medium text-gray-900 mb-2">
+              Upload PDF Documents
+            </p>
+            <p className="text-sm text-gray-600 mb-4">
+              Drag and drop PDF files here, or click to select files
+            </p>
+            <p className="text-xs text-gray-500">
+              Maximum file size: 10MB • Supported format: PDF
+            </p>
+          </div>
+        )}
+      </div>
+
+      {/* Upload Status */}
+      {uploadStatuses.length > 0 && (
+        <div className="space-y-2">
+          <h3 className="text-sm font-medium text-gray-900">Upload Status</h3>
+          {uploadStatuses.map((upload, index) => (
+            <div
+              key={index}
+              className="flex items-center justify-between p-3 bg-gray-50 rounded-lg"
+            >
+              <div className="flex items-center space-x-3">
+                <FileText className="w-5 h-5 text-gray-400" />
+                <div>
+                  <p className="text-sm font-medium text-gray-900">
+                    {upload.file.name}
+                  </p>
+                  <p className="text-xs text-gray-500">
+                    {formatFileSize(upload.file.size)}
+                  </p>
+                </div>
+              </div>
+              
+              <div className="flex items-center space-x-2">
+                {upload.status === 'uploading' && (
+                  <div className="flex items-center space-x-2">
+                    <div className="w-4 h-4 border-2 border-blue-500 border-t-transparent rounded-full animate-spin" />
+                    <span className="text-sm text-blue-600">Uploading...</span>
+                  </div>
+                )}
+                
+                {upload.status === 'success' && (
+                  <div className="flex items-center space-x-2">
+                    <CheckCircle className="w-4 h-4 text-green-500" />
+                    <span className="text-sm text-green-600">Success</span>
+                  </div>
+                )}
+                
+                {upload.status === 'error' && (
+                  <div className="flex items-center space-x-2">
+                    <AlertCircle className="w-4 h-4 text-red-500" />
+                    <span className="text-sm text-red-600">Error</span>
+                  </div>
+                )}
+                
+                <button
+                  onClick={() => removeUpload(upload.file)}
+                  className="p-1 hover:bg-gray-200 rounded"
+                >
+                  <X className="w-4 h-4 text-gray-400" />
+                </button>
+              </div>
+            </div>
+          ))}
+        </div>
+      )}
+    </div>
+  )
+} 

frontend/lib/api.ts

@@ -0,0 +1,109 @@
+import axios from 'axios'
+
+const API_BASE_URL = process.env.NEXT_PUBLIC_API_URL || 'http://localhost:8000'
+
+const api = axios.create({
+  baseURL: API_BASE_URL,
+  headers: {
+    'Content-Type': 'application/json',
+  },
+})
+
+export interface Document {
+  id: number
+  filename: string
+  original_filename: string
+  file_size: number
+  content?: string
+  processed: boolean
+  created_at: string
+  updated_at?: string
+}
+
+export interface ChatRequest {
+  question: string
+  session_id: string
+  model?: string
+}
+
+export interface ChatResponse {
+  success: boolean
+  answer: string
+  model?: string
+  sources: string[]
+  session_id: string
+  message_id?: number
+}
+
+export interface UploadResponse {
+  success: boolean
+  document?: Document
+  message: string
+}
+
+export const apiService = {
+  // Document endpoints
+  uploadDocument: async (file: File): Promise<UploadResponse> => {
+    const formData = new FormData()
+    formData.append('file', file)
+    
+    const response = await api.post('/api/v1/documents/upload', formData, {
+      headers: {
+        'Content-Type': 'multipart/form-data',
+      },
+    })
+    return response.data
+  },
+
+  getDocuments: async (): Promise<{ documents: Document[]; total: number }> => {
+    const response = await api.get('/api/v1/documents/')
+    return response.data
+  },
+
+  deleteDocument: async (id: number): Promise<{ success: boolean; message: string }> => {
+    const response = await api.delete(`/api/v1/documents/${id}`)
+    return response.data
+  },
+
+  getDocumentStats: async (): Promise<any> => {
+    const response = await api.get('/api/v1/documents/stats/summary')
+    return response.data
+  },
+
+  // Chat endpoints
+  sendMessage: async (request: ChatRequest): Promise<ChatResponse> => {
+    const response = await api.post('/api/v1/chat/', request)
+    return response.data
+  },
+
+  getChatHistory: async (sessionId: string): Promise<any> => {
+    const response = await api.get(`/api/v1/chat/history/${sessionId}`)
+    return response.data
+  },
+
+  createSession: async (): Promise<{ session_id: string }> => {
+    const response = await api.post('/api/v1/chat/session/new')
+    return response.data
+  },
+
+  getSessions: async (): Promise<any[]> => {
+    const response = await api.get('/api/v1/chat/sessions')
+    return response.data
+  },
+
+  deleteSession: async (sessionId: string): Promise<{ success: boolean; message: string }> => {
+    const response = await api.delete(`/api/v1/chat/session/${sessionId}`)
+    return response.data
+  },
+
+  getAvailableModels: async (): Promise<{ available_models: string[]; is_configured: boolean }> => {
+    const response = await api.get('/api/v1/chat/models/available')
+    return response.data
+  },
+
+  // Health check
+  healthCheck: async (): Promise<any> => {
+    const response = await api.get('/health')
+    return response.data
+  },
+} 

frontend/lib/store.ts

@@ -0,0 +1,50 @@
+import { create } from 'zustand'
+import { v4 as uuidv4 } from 'uuid'
+
+export interface ChatMessage {
+  id: string
+  content: string
+  type: 'user' | 'assistant'
+  timestamp: Date
+  sources?: string[]
+}
+
+interface ChatStore {
+  sessionId: string | null
+  messages: ChatMessage[]
+  isLoading: boolean
+  createNewSession: () => void
+  addMessage: (message: Omit<ChatMessage, 'id' | 'timestamp'>) => void
+  setLoading: (loading: boolean) => void
+  clearMessages: () => void
+}
+
+export const useChatStore = create<ChatStore>((set, get) => ({
+  sessionId: null,
+  messages: [],
+  isLoading: false,
+  
+  createNewSession: () => {
+    const sessionId = uuidv4()
+    set({ sessionId, messages: [] })
+  },
+  
+  addMessage: (message) => {
+    const newMessage: ChatMessage = {
+      ...message,
+      id: uuidv4(),
+      timestamp: new Date(),
+    }
+    set((state) => ({
+      messages: [...state.messages, newMessage]
+    }))
+  },
+  
+  setLoading: (loading) => {
+    set({ isLoading: loading })
+  },
+  
+  clearMessages: () => {
+    set({ messages: [] })
+  },
+})) 

frontend/next-env.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/basic-features/typescript for more information.

frontend/next.config.js

@@ -0,0 +1,19 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  experimental: {
+    appDir: true,
+  },
+  images: {
+    domains: ['localhost'],
+  },
+  async rewrites() {
+    return [
+      {
+        source: '/api/:path*',
+        destination: 'http://localhost:8000/api/:path*',
+      },
+    ];
+  },
+};
+
+module.exports = nextConfig; 

frontend/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "pdf-chatbot-frontend",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "next lint"
+  },
+  "dependencies": {
+    "next": "14.0.4",
+    "react": "^18",
+    "react-dom": "^18",
+    "@types/node": "^20",
+    "@types/react": "^18",
+    "@types/react-dom": "^18",
+    "typescript": "^5",
+    "tailwindcss": "^3.3.0",
+    "autoprefixer": "^10.0.1",
+    "postcss": "^8",
+    "lucide-react": "^0.294.0",
+    "class-variance-authority": "^0.7.0",
+    "clsx": "^2.0.0",
+    "tailwind-merge": "^2.0.0",
+    "zustand": "^4.4.7",
+    "react-hook-form": "^7.48.2",
+    "@hookform/resolvers": "^3.3.2",
+    "zod": "^3.22.4",
+    "axios": "^1.6.2",
+    "react-dropzone": "^14.2.3",
+    "react-markdown": "^9.0.1",
+    "remark-gfm": "^4.0.0",
+    "react-syntax-highlighter": "^15.5.0",
+    "@types/react-syntax-highlighter": "^15.5.11",
+    "uuid": "^9.0.1",
+    "@types/uuid": "^9.0.7",
+    "tailwindcss-animate": "^1.0.7"
+  },
+  "devDependencies": {
+    "eslint": "^8",
+    "eslint-config-next": "14.0.4"
+  }
+} 

frontend/postcss.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+} 

frontend/tailwind.config.js

@@ -0,0 +1,76 @@
+/** @type {import('tailwindcss').Config} */
+module.exports = {
+  darkMode: ["class"],
+  content: [
+    './pages/**/*.{ts,tsx}',
+    './components/**/*.{ts,tsx}',
+    './app/**/*.{ts,tsx}',
+    './src/**/*.{ts,tsx}',
+  ],
+  theme: {
+    container: {
+      center: true,
+      padding: "2rem",
+      screens: {
+        "2xl": "1400px",
+      },
+    },
+    extend: {
+      colors: {
+        border: "hsl(var(--border))",
+        input: "hsl(var(--input))",
+        ring: "hsl(var(--ring))",
+        background: "hsl(var(--background))",
+        foreground: "hsl(var(--foreground))",
+        primary: {
+          DEFAULT: "hsl(var(--primary))",
+          foreground: "hsl(var(--primary-foreground))",
+        },
+        secondary: {
+          DEFAULT: "hsl(var(--secondary))",
+          foreground: "hsl(var(--secondary-foreground))",
+        },
+        destructive: {
+          DEFAULT: "hsl(var(--destructive))",
+          foreground: "hsl(var(--destructive-foreground))",
+        },
+        muted: {
+          DEFAULT: "hsl(var(--muted))",
+          foreground: "hsl(var(--muted-foreground))",
+        },
+        accent: {
+          DEFAULT: "hsl(var(--accent))",
+          foreground: "hsl(var(--accent-foreground))",
+        },
+        popover: {
+          DEFAULT: "hsl(var(--popover))",
+          foreground: "hsl(var(--popover-foreground))",
+        },
+        card: {
+          DEFAULT: "hsl(var(--card))",
+          foreground: "hsl(var(--card-foreground))",
+        },
+      },
+      borderRadius: {
+        lg: "var(--radius)",
+        md: "calc(var(--radius) - 2px)",
+        sm: "calc(var(--radius) - 4px)",
+      },
+      keyframes: {
+        "accordion-down": {
+          from: { height: 0 },
+          to: { height: "var(--radix-accordion-content-height)" },
+        },
+        "accordion-up": {
+          from: { height: "var(--radix-accordion-content-height)" },
+          to: { height: 0 },
+        },
+      },
+      animation: {
+        "accordion-down": "accordion-down 0.2s ease-out",
+        "accordion-up": "accordion-up 0.2s ease-out",
+      },
+    },
+  },
+  plugins: [require("tailwindcss-animate")],
+} 

frontend/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "lib": ["dom", "dom.iterable", "es6"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./*"]
+    }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+} 

setup.ps1

@@ -0,0 +1,96 @@
+# PowerShell setup script for PDF Q&A Chatbot System
+
+Write-Host "🚀 Setting up PDF Q&A Chatbot System..." -ForegroundColor Green
+
+# Check if Python is installed
+try {
+    $pythonVersion = python --version 2>&1
+    Write-Host "✅ Python found: $pythonVersion" -ForegroundColor Green
+} catch {
+    Write-Host "❌ Python is required but not installed. Please install Python 3.8+ and try again." -ForegroundColor Red
+    exit 1
+}
+
+# Check if Node.js is installed
+try {
+    $nodeVersion = node --version 2>&1
+    Write-Host "✅ Node.js found: $nodeVersion" -ForegroundColor Green
+} catch {
+    Write-Host "❌ Node.js is required but not installed. Please install Node.js 18+ and try again." -ForegroundColor Red
+    exit 1
+}
+
+# Check if npm is installed
+try {
+    $npmVersion = npm --version 2>&1
+    Write-Host "✅ npm found: $npmVersion" -ForegroundColor Green
+} catch {
+    Write-Host "❌ npm is required but not installed. Please install npm and try again." -ForegroundColor Red
+    exit 1
+}
+
+Write-Host "✅ Prerequisites check passed" -ForegroundColor Green
+
+# Backend setup
+Write-Host "📦 Setting up backend..." -ForegroundColor Yellow
+Set-Location backend
+
+# Create virtual environment
+Write-Host "Creating Python virtual environment..." -ForegroundColor Yellow
+python -m venv venv
+
+# Activate virtual environment
+Write-Host "Activating virtual environment..." -ForegroundColor Yellow
+.\venv\Scripts\Activate.ps1
+
+# Install dependencies
+Write-Host "Installing Python dependencies..." -ForegroundColor Yellow
+pip install -r requirements.txt
+
+# Create .env file if it doesn't exist
+if (-not (Test-Path .env)) {
+    Write-Host "Creating .env file..." -ForegroundColor Yellow
+    Copy-Item .env.example .env
+    Write-Host "⚠️  Please edit backend/.env and add your API keys (OpenAI or Anthropic)" -ForegroundColor Yellow
+}
+
+Set-Location ..
+
+# Frontend setup
+Write-Host "📦 Setting up frontend..." -ForegroundColor Yellow
+Set-Location frontend
+
+# Install dependencies
+Write-Host "Installing Node.js dependencies..." -ForegroundColor Yellow
+npm install
+
+# Create .env file if it doesn't exist
+if (-not (Test-Path .env)) {
+    Write-Host "Creating .env file..." -ForegroundColor Yellow
+    Copy-Item .env.example .env
+}
+
+Set-Location ..
+
+Write-Host ""
+Write-Host "🎉 Setup completed successfully!" -ForegroundColor Green
+Write-Host ""
+Write-Host "📋 Next steps:" -ForegroundColor Cyan
+Write-Host "1. Edit backend/.env and add your API keys:" -ForegroundColor White
+Write-Host "   - OPENAI_API_KEY or ANTHROPIC_API_KEY" -ForegroundColor White
+Write-Host ""
+Write-Host "2. Start the backend server:" -ForegroundColor White
+Write-Host "   cd backend" -ForegroundColor White
+Write-Host "   .\venv\Scripts\Activate.ps1" -ForegroundColor White
+Write-Host "   uvicorn main:app --reload" -ForegroundColor White
+Write-Host ""
+Write-Host "3. Start the frontend server (in a new terminal):" -ForegroundColor White
+Write-Host "   cd frontend" -ForegroundColor White
+Write-Host "   npm run dev" -ForegroundColor White
+Write-Host ""
+Write-Host "4. Open your browser and go to: http://localhost:3000" -ForegroundColor White
+Write-Host ""
+Write-Host "🐳 Alternatively, you can use Docker:" -ForegroundColor White
+Write-Host "   docker-compose up --build" -ForegroundColor White
+Write-Host ""
+Write-Host "📚 For more information, see the README.md file" -ForegroundColor White 

setup.sh

@@ -0,0 +1,90 @@
+#!/bin/bash
+
+echo "🚀 Setting up PDF Q&A Chatbot System..."
+
+# Check if Python is installed
+if ! command -v python3 &> /dev/null; then
+    echo "❌ Python 3 is required but not installed. Please install Python 3.8+ and try again."
+    exit 1
+fi
+
+# Check if Node.js is installed
+if ! command -v node &> /dev/null; then
+    echo "❌ Node.js is required but not installed. Please install Node.js 18+ and try again."
+    exit 1
+fi
+
+# Check if npm is installed
+if ! command -v npm &> /dev/null; then
+    echo "❌ npm is required but not installed. Please install npm and try again."
+    exit 1
+fi
+
+echo "✅ Prerequisites check passed"
+
+# Backend setup
+echo "📦 Setting up backend..."
+cd backend
+
+# Create virtual environment
+echo "Creating Python virtual environment..."
+python3 -m venv venv
+
+# Activate virtual environment
+if [[ "$OSTYPE" == "msys" || "$OSTYPE" == "win32" ]]; then
+    source venv/Scripts/activate
+else
+    source venv/bin/activate
+fi
+
+# Install dependencies
+echo "Installing Python dependencies..."
+pip install -r requirements.txt
+
+# Create .env file if it doesn't exist
+if [ ! -f .env ]; then
+    echo "Creating .env file..."
+    cp .env.example .env
+    echo "⚠️  Please edit backend/.env and add your API keys (OpenAI or Anthropic)"
+fi
+
+cd ..
+
+# Frontend setup
+echo "📦 Setting up frontend..."
+cd frontend
+
+# Install dependencies
+echo "Installing Node.js dependencies..."
+npm install
+
+# Create .env file if it doesn't exist
+if [ ! -f .env ]; then
+    echo "Creating .env file..."
+    cp .env.example .env
+fi
+
+cd ..
+
+echo ""
+echo "🎉 Setup completed successfully!"
+echo ""
+echo "📋 Next steps:"
+echo "1. Edit backend/.env and add your API keys:"
+echo "   - OPENAI_API_KEY or ANTHROPIC_API_KEY"
+echo ""
+echo "2. Start the backend server:"
+echo "   cd backend"
+echo "   source venv/bin/activate  # On Windows: venv\\Scripts\\activate"
+echo "   uvicorn main:app --reload"
+echo ""
+echo "3. Start the frontend server (in a new terminal):"
+echo "   cd frontend"
+echo "   npm run dev"
+echo ""
+echo "4. Open your browser and go to: http://localhost:3000"
+echo ""
+echo "🐳 Alternatively, you can use Docker:"
+echo "   docker-compose up --build"
+echo ""
+echo "📚 For more information, see the README.md file"