assignment checkpoint

.env.example

@@ -0,0 +1,2 @@
+# OpenAI API key - required for embedding and generation
+OPENAI_API_KEY=your_openai_api_key_here 

Dockerfile

@@ -1,31 +1,73 @@
+FROM ghcr.io/astral-sh/uv:python3.10-bookworm-slim as builder
 
-# Get a distribution that has uv already installed
-FROM ghcr.io/astral-sh/uv:python3.13-bookworm-slim
+WORKDIR /app
+
+# Copy project files for dependency installation
+COPY pyproject.toml /app/
+COPY README.md /app/
+
+# Show pyproject.toml content
+RUN cat pyproject.toml
+
+# Create a virtual environment and install dependencies using uv sync
+RUN uv venv /app/.venv && \
+    . /app/.venv/bin/activate && \
+    uv sync
+
+# Verify installations with the virtual environment
+RUN . /app/.venv/bin/activate && \
+    python -c "import numpy; print(f'NumPy version: {numpy.__version__}')" && \
+    python -c "import pandas; print(f'Pandas version: {pandas.__version__}')" && \
+    python -c "import uvicorn; print(f'Uvicorn version: {uvicorn.__version__}')"
+
+# Second stage for the final image
+FROM ghcr.io/astral-sh/uv:python3.10-bookworm-slim
 
 # Add user - this is the user that will run the app
-# If you do not set user, the app will run as root (undesirable)
 RUN useradd -m -u 1000 user
-USER user
 
-# Set the home directory and path
-ENV HOME=/home/user \
-    PATH=/home/user/.local/bin:$PATH        
+# Copy the virtual environment from the builder stage
+COPY --from=builder /app/.venv /home/user/app/.venv
+
+# Install Node.js for building the frontend
+RUN apt-get update && apt-get install -y \
+    curl \
+    gnupg \
+    && curl -sL https://deb.nodesource.com/setup_18.x | bash - \
+    && apt-get install -y nodejs \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
 
+# Set up user environment
+ENV HOME=/home/user \
+    PATH=/home/user/app/.venv/bin:$PATH
+    
 ENV UVICORN_WS_PROTOCOL=websockets
 
 
-# Set the working directory
-WORKDIR $HOME/app
+# Verify dependencies are available in the final image
+RUN python -c "import numpy; print(f'NumPy version: {numpy.__version__}')" && \
+    python -c "import pandas; print(f'Pandas version: {pandas.__version__}')" && \
+    python -c "import uvicorn; print(f'Uvicorn version: {uvicorn.__version__}')"
+
+# Copy frontend code and build it
+COPY --chown=user frontend /home/user/app/frontend
+USER user
+WORKDIR /home/user/app/frontend
+RUN npm install && npm run build
+
+# Copy backend code
+WORKDIR /home/user/app
+COPY --chown=user backend /home/user/app/backend
 
-# Copy the app to the container
-COPY --chown=user . $HOME/app
+# Copy aimakerspace module
+COPY --chown=user aimakerspace /home/user/app/aimakerspace
 
-# Install the dependencies
-# RUN uv sync --frozen
-RUN uv sync
+# Set the working directory to the backend folder
+WORKDIR /home/user/app/backend
 
-# Expose the port
+# Expose port for FastAPI on Hugging Face
 EXPOSE 7860
 
-# Run the app
-CMD ["uv", "run", "chainlit", "run", "app.py", "--host", "0.0.0.0", "--port", "7860"]
+# Start the FastAPI server
+CMD ["python", "-m", "uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -168,6 +168,10 @@ Simply put, this downloads the file as a temp file, we load it in with `TextFile
 
 Why do we want to support streaming? What about streaming is important, or useful?
 
+```
+    Improved User experience helping reduce percieved response time. Also making application interactive.
+```
+
 ### On Chat Start:
 
 The next scope is where "the magic happens". On Chat Start is when a user begins a chat session. This will happen whenever a user opens a new chat window, or refreshes an existing chat window.
@@ -210,6 +214,20 @@ Now, we'll save that into our user session!
 
 Why are we using User Session here? What about Python makes us need to use this? Why not just store everything in a global variable?
 
+```
+User Session - > The user session is designed to persist data in memory through the life cycle of a chat session. Each user session is unique to a user and a given chat session.
+Enables users to: 
+ - Their own chat history
+ - Their own state (e.g., selected options, intermediate results, etc.)
+ - Their own context
+
+What about Python makes us need to use this? Why not just store everything in a global variable?
+Python Global Variables
+ - Shared across all users: A global variable in Python is shared across all threads/processes unless isolated manually.
+ - Not thread-safe: In multi-threaded setups, concurrent access to globals can lead to race conditions.
+ - Stateless in serverless setups: If you're running Chainlit on something like a cloud function or serverless platform, globals may reset between requests.
+```
+
 ### On Message
 
 First, we load our chain from the user session:
@@ -334,11 +352,147 @@ Upload a PDF file of the recent DeepSeek-R1 paper and ask the following question
 3. What is this paper about?
 
 Does this application pass your vibe check? Are there any immediate pitfalls you're noticing?
+```
+The application fails vibe check as when we ask What is this paper about it responds -> I dont know the answer
+If we looked at retrieved context by logging it we will see it retrieves mostly the author name and hence doesn't give LLM good context. 
+Fixing retrieval should be the key to answer these questions.
+
 
+```
+---
+```
+    here is example retrieval 
+    2025-04-14 12:48:19 - HTTP Request: POST https://api.openai.com/v1/embeddings "HTTP/1.1 200 OK"
+Context: flect deeply on the boundaries of the unknown, 2024a. URL https://qwenlm
+.github.io/blog/qwq-32b-preview/ .
+Qwen. Qwen2.5: A party of foundation models, 2024b. URL https://qwenlm.github.io/b
+log/qwen2.5 .
+D. Rein, B. L. Hou, A. C. Stickland, J. Petty, R. Y. Pang, J. Dirani, J. Michael, and S. R. Bowman.
+GPQA: A graduate-level google-proof q&a benchmark. arXiv preprint arXiv:2311.12022 , 2023.
+Z. Shao, P . Wang, Q. Zhu, R. Xu, J. Song, M. Zhang, Y. Li, Y. Wu, and D. Guo. Deepseekmath:
+Pushing the limits of mathematical reasoning in open language models. arXiv preprint
+arXiv:2402.03300, 2024.
+D. Silver, T. Hubert, J. Schrittwieser, I. Antonoglou, M. Lai, A. Guez, M. Lanctot, L. Sifre,
+D. Kumaran, T. Graepel, T. P . Lillicrap, K. Simonyan, and D. Hassabis. Mastering chess and
+shogi by self-play with a general reinforcement learning algorithm. CoRR , abs/1712.01815,
+2017a. URL http://arxiv.org/abs/1712.01815 .
+18
+D. Silver, J. Schrittwieser, K. Simonyan, I. Antonoglou, A. Huang, A. Guez, T
+3-06747-5.
+J. Uesato, N. Kushman, R. Kumar, F. Song, N. Siegel, L. Wang, A. Creswell, G. Irving, and
+I. Higgins. Solving math word problems with process-and outcome-based feedback. arXiv
+preprint arXiv:2211.14275, 2022.
+P . Wang, L. Li, Z. Shao, R. Xu, D. Dai, Y. Li, D. Chen, Y. Wu, and Z. Sui. Math-shepherd: A label-
+free step-by-step verifier for llms in mathematical reasoning. arXiv preprint arXiv:2312.08935 ,
+2023.
+X. Wang, J. Wei, D. Schuurmans, Q. Le, E. Chi, S. Narang, A. Chowdhery, and D. Zhou.
+Self-consistency improves chain of thought reasoning in language models. arXiv preprint
+arXiv:2203.11171, 2022.
+Y. Wang, X. Ma, G. Zhang, Y. Ni, A. Chandra, S. Guo, W. Ren, A. Arulraj, X. He, Z. Jiang, T. Li,
+M. Ku, K. Wang, A. Zhuang, R. Fan, X. Yue, and W. Chen. Mmlu-pro: A more robust and
+challenging multi-task language understanding benchmark. CoRR , abs/2406.01574, 2024.
+URL https://doi.org/10.48550/arXiv.2406.01574 .
+C. S. Xia, Y. Deng, S. Dunn, and L. Zhang. Agentless: Demystifyin
+
+challenging multi-task language understanding benchmark. CoRR , abs/2406.01574, 2024.
+URL https://doi.org/10.48550/arXiv.2406.01574 .
+C. S. Xia, Y. Deng, S. Dunn, and L. Zhang. Agentless: Demystifying llm-based software
+engineering agents. arXiv preprint, 2024.
+H. Xin, Z. Z. Ren, J. Song, Z. Shao, W. Zhao, H. Wang, B. Liu, L. Zhang, X. Lu, Q. Du, W. Gao,
+Q. Zhu, D. Yang, Z. Gou, Z. F. Wu, F. Luo, and C. Ruan. Deepseek-prover-v1.5: Harnessing
+proof assistant feedback for reinforcement learning and monte-carlo tree search, 2024. URL
+https://arxiv.org/abs/2408.08152 .
+J. Zhou, T. Lu, S. Mishra, S. Brahma, S. Basu, Y. Luan, D. Zhou, and L. Hou. Instruction-following
+evaluation for large language models. arXiv preprint arXiv:2311.07911, 2023.
+19
+Appendix
+A. Contributions and Acknowledgments
+Core Contributors
+Daya Guo
+Dejian Yang
+Haowei Zhang
+Junxiao Song
+Ruoyu Zhang
+Runxin Xu
+Qihao Zhu
+Shirong Ma
+Peiyi Wang
+Xiao Bi
+Xiaokang Zhang
+Xingkai Yu
+Yu Wu
+Z.F. Wu
+Zhibin Gou
+Zhihong Shao
+Zhuoshu Li
+
+md .
+Anthropic. Claude 3.5 sonnet, 2024. URL https://www.anthropic.com/news/claude-3
+-5-sonnet .
+M. Chen, J. Tworek, H. Jun, Q. Yuan, H. P . de Oliveira Pinto, J. Kaplan, H. Edwards, Y. Burda,
+N. Joseph, G. Brockman, A. Ray, R. Puri, G. Krueger, M. Petrov, H. Khlaaf, G. Sastry, P . Mishkin,
+B. Chan, S. Gray, N. Ryder, M. Pavlov, A. Power, L. Kaiser, M. Bavarian, C. Winter, P . Tillet,
+F. P . Such, D. Cummings, M. Plappert, F. Chantzis, E. Barnes, A. Herbert-Voss, W. H. Guss,
+A. Nichol, A. Paino, N. Tezak, J. Tang, I. Babuschkin, S. Balaji, S. Jain, W. Saunders, C. Hesse,
+A. N. Carr, J. Leike, J. Achiam, V . Misra, E. Morikawa, A. Radford, M. Knight, M. Brundage,
+M. Murati, K. Mayer, P . Welinder, B. McGrew, D. Amodei, S. McCandlish, I. Sutskever, and
+W. Zaremba. Evaluating large language models trained on code. CoRR , abs/2107.03374, 2021.
+URL https://arxiv.org/abs/2107.03374 .
+A. Dubey, A. Jauhri, A. Pandey, A. Kadian, A. Al-Dahle, A. Letman, A. Mathur, A. Schelten,
+A. Yang, A. Fan, e
+```
 ## 🚧 CHALLENGE MODE 🚧
 
 For the challenge mode, please instead create a simple FastAPI backend with a simple React (or any other JS framework) frontend.
 
 You can use the same prompt templates and RAG pipeline as we did here - but you'll need to modify the code to work with FastAPI and React.
 
-Deploy this application to Hugging Face Spaces!
+Deploy this application to Hugging Face Spaces!
+
+# FastAPI & React RAG Chat Application
+
+A document question-answering application built with FastAPI, React, and a Pythonic RAG (Retrieval Augmented Generation) implementation.
+
+## Features
+
+- Upload PDF and text files
+- Chat with your documents
+- Modern React UI with Chakra UI components
+- Pythonic RAG implementation with OpenAI models
+- Dockerized for easy deployment
+- Uses UV for Python package management
+
+
+## Environment Variables
+
+Create a `.env` file with the following variables:
+
+```
+OPENAI_API_KEY=your_openai_api_key_here
+```
+
+## Credits
+
+Based on the Pythonic RAG implementation from the AI Makerspace course.
+
+## Docker Deployment
+
+### Building the Docker Image
+
+Build the Docker image with:
+
+```bash
+docker build -t rag-app .
+```
+
+### Running the Container
+
+Run the container:
+
+```bash
+docker run -p 7860:7860 --env OPENAI_API_KEY=your_key_here rag-app
+```
+
+Replace `your_key_here` with your actual OpenAI API key.
+
+Access the application at http://localhost:7860

aimakerspace/openai_utils/__init__.py

@@ -0,0 +1 @@
+# OpenAI utilities module

aimakerspace/utils/__init__.py

@@ -0,0 +1 @@
+# Utils module for AI Makerspace 

aimakerspace/utils/session_manager.py

@@ -0,0 +1,70 @@
+import uuid
+import logging
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+class SessionManager:
+    """
+    Manages user sessions for processing and query operations
+    """
+    def __init__(self):
+        """Initialize the session manager with an empty sessions dictionary"""
+        self.sessions = {}
+        logger.info("SessionManager initialized")
+    
+    def create_session(self, initial_value="processing"):
+        """Create a new session with a UUID and return the session ID"""
+        session_id = str(uuid.uuid4())
+        self.sessions[session_id] = initial_value
+        logger.info(f"Created session: {session_id} with initial value: {initial_value}")
+        return session_id
+    
+    def update_session(self, session_id, value):
+        """Update the session with the given ID to the provided value"""
+        self.sessions[session_id] = value
+        logger.info(f"Updated session: {session_id}")
+    
+    def session_exists(self, session_id):
+        """Check if a session with the given ID exists"""
+        return session_id in self.sessions
+    
+    def get_session(self, session_id):
+        """Get the session data for the given ID"""
+        return self.sessions.get(session_id)
+    
+    def get_sessions_summary(self):
+        """Get a summary of all sessions"""
+        session_info = {}
+        
+        for session_id, session_data in self.sessions.items():
+            if session_data == "processing":
+                status = "processing"
+            elif session_data == "failed":
+                status = "failed"
+            else:
+                # It's a RAG pipeline object
+                status = "ready"
+                # Count documents in vector DB
+                doc_count = 0
+                
+                if hasattr(session_data, 'vector_db_retriever'):
+                    if hasattr(session_data.vector_db_retriever, 'documents'):
+                        doc_count = len(session_data.vector_db_retriever.documents)
+                    elif hasattr(session_data.vector_db_retriever, 'vectors'):
+                        doc_count = len(session_data.vector_db_retriever.vectors)
+            
+            session_info[session_id] = {
+                "status": status
+            }
+            
+            if status == "ready":
+                session_info[session_id]["document_count"] = doc_count
+        
+        return {
+            "session_count": len(self.sessions),
+            "sessions": session_info,
+            "memory_usage": {
+                "session_count": len(self.sessions)
+            }
+        } 

app.py

@@ -36,7 +36,7 @@ class RetrievalAugmentedQAPipeline:
         context_prompt = ""
         for context in context_list:
             context_prompt += context[0] + "\n"
-
+        print(f"Context: {context_prompt}")
         formatted_system_prompt = system_role_prompt.create_message()
 
         formatted_user_prompt = user_role_prompt.create_message(question=user_query, context=context_prompt)

backend/main.py

@@ -0,0 +1,305 @@
+from fastapi import FastAPI, File, UploadFile, HTTPException, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+import uvicorn
+import os
+import tempfile
+import shutil
+from typing import List, Optional, Dict, Any
+import pathlib
+import asyncio
+import logging
+import time
+import traceback
+import uuid
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, 
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Import our RAG components
+from rag import RetrievalAugmentedQAPipeline, process_file, setup_vector_db
+
+# Add local aimakerspace module to the path
+import sys
+sys.path.append(os.path.join(os.path.dirname(os.path.dirname(__file__)), ""))
+
+# Import from local aimakerspace module
+from aimakerspace.utils.session_manager import SessionManager
+
+# Load environment variables
+from dotenv import load_dotenv
+load_dotenv()
+
+app = FastAPI()
+
+# Configure CORS - allow all origins explicitly for development
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # This will allow all origins
+    allow_credentials=True,
+    allow_methods=["*"],  # Allow all methods
+    allow_headers=["*"],  # Allow all headers
+    expose_headers=["*"]
+)
+
+# Initialize session manager
+session_manager = SessionManager()
+
+class QueryRequest(BaseModel):
+    session_id: str
+    query: str
+
+class QueryResponse(BaseModel):
+    response: str
+    session_id: str
+
+# Set file size limit to 10MB - adjust as needed
+FILE_SIZE_LIMIT = 10 * 1024 * 1024  # 10MB
+
+async def process_file_background(temp_path: str, filename: str, session_id: str):
+    """Process file in background and set up the RAG pipeline"""
+    try:
+        start_time = time.time()
+        logger.info(f"Background processing started for file: {filename} (session: {session_id})")
+        
+        # Set max processing time (5 minutes)
+        max_processing_time = 300  # seconds
+        
+        # Process the file
+        logger.info(f"Starting text extraction for file: {filename}")
+        try:
+            texts = process_file(temp_path, filename)
+            logger.info(f"Processed file into {len(texts)} text chunks (took {time.time() - start_time:.2f}s)")
+            
+            # Check if processing is taking too long already
+            if time.time() - start_time > max_processing_time / 2:
+                logger.warning(f"Text extraction took more than half the allowed time. Limiting chunks...")
+                # Limit to a smaller number if extraction took a long time
+                max_chunks = 50
+                if len(texts) > max_chunks:
+                    logger.warning(f"Limiting text chunks from {len(texts)} to {max_chunks}")
+                    texts = texts[:max_chunks]
+        except Exception as e:
+            logger.error(f"Error during text extraction: {str(e)}")
+            logger.error(traceback.format_exc())
+            session_manager.update_session(session_id, "failed")
+            os.unlink(temp_path)
+            return
+        
+        # Setup vector database - This is the part that might be hanging
+        logger.info(f"Starting vector DB creation for {len(texts)} chunks")
+        embedding_start = time.time()
+        
+        # Create a task with overall timeout
+        try:
+            async def setup_with_timeout():
+                return await setup_vector_db(texts)
+                
+            # Wait for vector DB setup with timeout
+            vector_db = await asyncio.wait_for(
+                setup_with_timeout(), 
+                timeout=max_processing_time - (time.time() - start_time)
+            )
+            
+            # Get document count - check if documents property is available
+            if hasattr(vector_db, 'documents'):
+                doc_count = len(vector_db.documents)
+            else:
+                # If using the original VectorDatabase implementation that uses vectors dict
+                doc_count = len(vector_db.vectors) if hasattr(vector_db, 'vectors') else 0
+                
+            logger.info(f"Created vector database with {doc_count} documents (took {time.time() - embedding_start:.2f}s)")
+            
+            # Create RAG pipeline
+            logger.info(f"Creating RAG pipeline for session {session_id}")
+            rag_pipeline = RetrievalAugmentedQAPipeline(vector_db_retriever=vector_db)
+            
+            # Store pipeline in session manager
+            session_manager.update_session(session_id, rag_pipeline)
+            logger.info(f"Updated session {session_id} with processed pipeline (total time: {time.time() - start_time:.2f}s)")
+            
+        except asyncio.TimeoutError:
+            logger.error(f"Vector database creation timed out after {time.time() - embedding_start:.2f}s")
+            session_manager.update_session(session_id, "failed")
+        except Exception as e:
+            logger.error(f"Error in vector database creation: {str(e)}")
+            logger.error(traceback.format_exc())
+            session_manager.update_session(session_id, "failed")
+        
+        # Clean up temp file
+        os.unlink(temp_path)
+        logger.info(f"Removed temporary file: {temp_path}")
+        
+    except Exception as e:
+        logger.error(f"Error in background processing for session {session_id}: {str(e)}")
+        logger.error(traceback.format_exc())  # Log the full error traceback
+        # Mark the session as failed rather than removing it
+        session_manager.update_session(session_id, "failed")
+        # Try to clean up temp file if it exists
+        try:
+            if os.path.exists(temp_path):
+                os.unlink(temp_path)
+                logger.info(f"Cleaned up temporary file after error: {temp_path}")
+        except Exception as cleanup_error:
+            logger.error(f"Error cleaning up temp file: {str(cleanup_error)}")
+
+@app.post("/upload/")
+async def upload_file(background_tasks: BackgroundTasks, file: UploadFile = File(...)):
+    try:
+        logger.info(f"Received upload request for file: {file.filename}")
+        
+        # Check file size first
+        file_size = 0
+        chunk_size = 1024 * 1024  # 1MB chunks for reading
+        contents = bytearray()
+        
+        # Read file in chunks to avoid memory issues
+        while True:
+            chunk = await file.read(chunk_size)
+            if not chunk:
+                break
+            file_size += len(chunk)
+            contents.extend(chunk)
+            
+            # Check size limit
+            if file_size > FILE_SIZE_LIMIT:
+                logger.warning(f"File too large: {file_size/1024/1024:.2f}MB exceeds limit of {FILE_SIZE_LIMIT/1024/1024}MB")
+                return HTTPException(
+                    status_code=413, 
+                    detail=f"File too large. Maximum size is {FILE_SIZE_LIMIT/1024/1024}MB"
+                )
+        
+        logger.info(f"File size: {file_size/1024/1024:.2f}MB")
+        
+        # Reset file stream for processing
+        file_content = bytes(contents)
+        
+        # Create a temporary file
+        suffix = f".{file.filename.split('.')[-1]}"
+        with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as temp_file:
+            # Write file content to temp file
+            temp_file.write(file_content)
+            temp_path = temp_file.name
+            logger.info(f"Created temporary file at: {temp_path}")
+        
+        # Generate session ID and create session
+        session_id = session_manager.create_session("processing")
+        logger.info(f"Created session ID: {session_id}")
+        
+        # Process file in background
+        background_tasks.add_task(
+            process_file_background, 
+            temp_path, 
+            file.filename, 
+            session_id
+        )
+        
+        return {"session_id": session_id, "message": "File uploaded and processing started"}
+    
+    except Exception as e:
+        logger.error(f"Error processing upload: {str(e)}")
+        logger.error(traceback.format_exc())  # Log the full error traceback
+        raise HTTPException(status_code=500, detail=f"Error processing file: {str(e)}")
+
+@app.post("/query/", response_model=QueryResponse)
+async def process_query(request: QueryRequest):
+    logger.info(f"Received query request for session: {request.session_id}")
+    
+    # Check if session exists
+    if not session_manager.session_exists(request.session_id):
+        logger.warning(f"Session not found: {request.session_id}")
+        raise HTTPException(status_code=404, detail="Session not found. Please upload a document first.")
+    
+    # Get session data
+    session_data = session_manager.get_session(request.session_id)
+    
+    # Check if processing is still ongoing
+    if session_data == "processing":
+        logger.info(f"Document still processing for session: {request.session_id}")
+        raise HTTPException(status_code=409, detail="Document is still being processed. Please try again in a moment.")
+    
+    # Check if processing failed
+    if session_data == "failed":
+        logger.error(f"Processing failed for session: {request.session_id}")
+        raise HTTPException(status_code=500, detail="Document processing failed. Please try uploading again.")
+    
+    try:
+        logger.info(f"Processing query: '{request.query}' for session: {request.session_id}")
+        
+        # Get response from RAG pipeline
+        start_time = time.time()
+        result = await session_data.arun_pipeline(request.query)
+        
+        # In a streaming setup, we'd handle this differently
+        # For simplicity, we're collecting the entire response
+        response_text = ""
+        async for chunk in result["response"]:
+            response_text += chunk
+        
+        logger.info(f"Generated response of length: {len(response_text)} (took {time.time() - start_time:.2f}s)")
+        
+        return {
+            "response": response_text,
+            "session_id": request.session_id
+        }
+    
+    except Exception as e:
+        logger.error(f"Error processing query for session {request.session_id}: {str(e)}")
+        logger.error(traceback.format_exc())  # Log the full error traceback
+        raise HTTPException(status_code=500, detail=f"Error processing query: {str(e)}")
+
+@app.get("/health")
+def health_check():
+    return {"status": "healthy"}
+
+@app.get("/test")
+def test_endpoint():
+    return {"message": "Backend is accessible"}
+
+@app.get("/session/{session_id}/status")
+async def session_status(session_id: str):
+    """Check if a session exists and its processing status"""
+    logger.info(f"Checking status for session: {session_id}")
+    
+    if not session_manager.session_exists(session_id):
+        logger.warning(f"Session not found: {session_id}")
+        return {"exists": False, "status": "not_found"}
+    
+    session_data = session_manager.get_session(session_id)
+    
+    if session_data == "processing":
+        logger.info(f"Session {session_id} is still processing")
+        return {"exists": True, "status": "processing"}
+    
+    if session_data == "failed":
+        logger.error(f"Session {session_id} processing failed")
+        return {"exists": True, "status": "failed"}
+    
+    logger.info(f"Session {session_id} is ready")
+    return {"exists": True, "status": "ready"}
+
+@app.get("/debug/sessions")
+async def debug_sessions():
+    """Return debug information about all sessions - for diagnostic use only"""
+    logger.info("Accessed debug sessions endpoint")
+    
+    # Get summary of all sessions
+    sessions_summary = session_manager.get_sessions_summary()
+    
+    return sessions_summary
+
+# For Hugging Face Spaces deployment, serve the static files from the React build
+frontend_path = pathlib.Path(__file__).parent.parent / "frontend" / "build"
+if frontend_path.exists():
+    app.mount("/", StaticFiles(directory=str(frontend_path), html=True), name="frontend")
+
+    @app.get("/", include_in_schema=False)
+    async def serve_frontend():
+        return FileResponse(str(frontend_path / "index.html"))
+
+if __name__ == "__main__":
+    uvicorn.run("main:app", host="0.0.0.0", port=8000) 

backend/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "rag-backend"
+version = "0.1.0"
+description = "FastAPI backend for RAG chat application"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+dependencies = [
+    "fastapi==0.104.1",
+    "uvicorn==0.23.2",
+    "python-multipart==0.0.6",
+    "pydantic==2.4.2",
+    "openai>=1.0.0",
+    "python-dotenv==1.0.0",
+    "numpy>=1.20.0",
+    "pandas>=1.3.0",
+    "scikit-learn>=1.0.0",
+    "tiktoken>=0.5.0",
+    "PyPDF2>=3.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "black",
+]
+
+[tool.pytest]
+testpaths = ["tests"]
+
+[tool.black]
+line-length = 88
+target-version = ["py39"] 

backend/rag.py

@@ -0,0 +1,154 @@
+import os
+from typing import List, Dict, Any
+import tempfile
+import shutil
+import logging
+import time
+import traceback
+import asyncio
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, 
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Make sure aimakerspace is in the path
+import sys
+sys.path.append(os.path.join(os.path.dirname(os.path.dirname(__file__)), ""))
+
+# Import from local aimakerspace module
+from aimakerspace.text_utils import CharacterTextSplitter, TextFileLoader, PDFLoader
+from aimakerspace.vectordatabase import VectorDatabase
+from aimakerspace.openai_utils.embedding import EmbeddingModel
+from openai import OpenAI
+
+# Initialize OpenAI client
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+logger.info(f"Initialized OpenAI client with API key: {'valid key' if os.getenv('OPENAI_API_KEY') else 'API KEY MISSING!'}")
+
+class RetrievalAugmentedQAPipeline:
+    def __init__(self, vector_db_retriever: VectorDatabase) -> None:
+        self.vector_db_retriever = vector_db_retriever
+    
+    async def arun_pipeline(self, user_query: str):
+        """
+        Run the RAG pipeline with the given user query.
+        Returns a stream of response chunks.
+        """
+        try:
+            # 1. Retrieve relevant documents
+            logger.info(f"RAG Pipeline: Retrieving documents for query: '{user_query}'")
+            relevant_docs = self.vector_db_retriever.search_by_text(user_query, k=4)
+            
+            if not relevant_docs:
+                logger.warning("No relevant documents found in vector database")
+                documents_context = "No relevant information found in the document."
+            else:
+                logger.info(f"Found {len(relevant_docs)} relevant document chunks")
+                # Format documents
+                documents_context = "\n\n".join([doc[0] for doc in relevant_docs])
+            
+            # Debug similarity scores
+            doc_scores = [f"{i+1}. Score: {doc[1]:.4f}" for i, doc in enumerate(relevant_docs)]
+            logger.info(f"Document similarity scores: {', '.join(doc_scores) if doc_scores else 'No documents'}")
+            
+            # 2. Create messaging payload
+            messages = [
+                {"role": "system", "content": f"""You are a helpful AI assistant that answers questions based on the provided document context.
+                If the answer is not in the context, say that you don't know based on the available information. 
+                Use the following document extracts to answer the user's question:
+                
+                {documents_context}"""},
+                {"role": "user", "content": user_query}
+            ]
+            
+            # 3. Call LLM and stream the output
+            async def generate_response():
+                try:
+                    logger.info("Initiating streaming completion from OpenAI")
+                    stream = client.chat.completions.create(
+                        model="gpt-3.5-turbo",
+                        messages=messages,
+                        temperature=0.2,
+                        stream=True
+                    )
+                    
+                    for chunk in stream:
+                        if chunk.choices[0].delta.content:
+                            yield chunk.choices[0].delta.content
+                except Exception as e:
+                    logger.error(f"Error generating stream: {str(e)}")
+                    yield f"\n\nI apologize, but I encountered an error while generating a response: {str(e)}"
+            
+            return {
+                "response": generate_response()
+            }
+        
+        except Exception as e:
+            logger.error(f"Error in RAG pipeline: {str(e)}")
+            logger.error(traceback.format_exc())
+            return {
+                "response": (chunk for chunk in [f"I apologize, but an error occurred: {str(e)}"])
+            }
+
+def process_file(file_path: str, file_name: str) -> List[str]:
+    """Process an uploaded file and convert it to text chunks"""
+    logger.info(f"Processing file: {file_name} at path: {file_path}")
+    
+    try:
+        # Determine loader based on file extension
+        if file_name.lower().endswith('.txt'):
+            logger.info(f"Using TextFileLoader for {file_name}")
+            loader = TextFileLoader(file_path)
+            loader.load()
+        elif file_name.lower().endswith('.pdf'):
+            logger.info(f"Using PDFLoader for {file_name}")
+            loader = PDFLoader(file_path)
+            loader.load()
+        else:
+            logger.warning(f"Unsupported file type: {file_name}")
+            return ["Unsupported file format. Please upload a .txt or .pdf file."]
+        
+        # Get documents from loader
+        documents = loader.documents
+        if documents and len(documents) > 0:
+            logger.info(f"Loaded document with {len(documents[0])} characters")
+        else:
+            logger.warning("No document content loaded")
+            return ["No content found in the document"]
+        
+        # Split text into chunks
+        text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
+        text_chunks = text_splitter.split_texts(documents)
+        
+        logger.info(f"Split document into {len(text_chunks)} chunks")
+        return text_chunks
+        
+    except Exception as e:
+        logger.error(f"Error processing file: {str(e)}")
+        logger.error(traceback.format_exc())
+        return [f"Error processing file: {str(e)}"]
+
+async def setup_vector_db(texts: List[str]) -> VectorDatabase:
+    """Create vector database from text chunks"""
+    logger.info(f"Setting up vector database with {len(texts)} text chunks")
+    
+    embedding_model = EmbeddingModel()
+    vector_db = VectorDatabase(embedding_model=embedding_model)
+    
+    try:
+        await vector_db.abuild_from_list(texts)
+        
+        vector_db.documents = texts
+        
+        logger.info(f"Vector database built with {len(texts)} documents")
+        return vector_db
+    except Exception as e:
+        logger.error(f"Error setting up vector database: {str(e)}")
+        logger.error(traceback.format_exc())
+        
+        fallback_db = VectorDatabase(embedding_model=embedding_model)
+        error_text = "I'm sorry, but there was an error processing the document."
+        fallback_db.insert(error_text, [0.0] * 1536)
+        fallback_db.documents = [error_text]
+        return fallback_db 

frontend/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "rag-chat-frontend",
+  "version": "0.1.0",
+  "private": true,
+  "dependencies": {
+    "@chakra-ui/react": "^2.8.0",
+    "@emotion/react": "^11.11.1",
+    "@emotion/styled": "^11.11.0",
+    "axios": "^1.5.0",
+    "framer-motion": "^10.16.4",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-dropzone": "^14.2.3",
+    "react-icons": "^4.11.0",
+    "react-markdown": "^8.0.7",
+    "react-scripts": "5.0.1"
+  },
+  "scripts": {
+    "start": "react-scripts start",
+    "build": "react-scripts build",
+    "test": "react-scripts test",
+    "eject": "react-scripts eject"
+  },
+  "eslintConfig": {
+    "extends": [
+      "react-app",
+      "react-app/jest"
+    ]
+  },
+  "browserslist": {
+    "production": [
+      ">0.2%",
+      "not dead",
+      "not op_mini all"
+    ],
+    "development": [
+      "last 1 chrome version",
+      "last 1 firefox version",
+      "last 1 safari version"
+    ]
+  }
+} 

frontend/public/index.html

@@ -0,0 +1,43 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <link rel="icon" href="%PUBLIC_URL%/favicon.ico" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="theme-color" content="#000000" />
+    <meta
+      name="description"
+      content="Chat with your documents using RAG technology"
+    />
+    <link rel="apple-touch-icon" href="%PUBLIC_URL%/logo192.png" />
+    <!--
+      manifest.json provides metadata used when your web app is installed on a
+      user's mobile device or desktop. See https://developers.google.com/web/fundamentals/web-app-manifest/
+    -->
+    <link rel="manifest" href="%PUBLIC_URL%/manifest.json" />
+    <!--
+      Notice the use of %PUBLIC_URL% in the tags above.
+      It will be replaced with the URL of the `public` folder during the build.
+      Only files inside the `public` folder can be referenced from the HTML.
+
+      Unlike "/favicon.ico" or "favicon.ico", "%PUBLIC_URL%/favicon.ico" will
+      work correctly both with client-side routing and a non-root public URL.
+      Learn how to configure a non-root public URL by running `npm run build`.
+    -->
+    <title>Document Chat</title>
+  </head>
+  <body>
+    <noscript>You need to enable JavaScript to run this app.</noscript>
+    <div id="root"></div>
+    <!--
+      This HTML file is a template.
+      If you open it directly in the browser, you will see an empty page.
+
+      You can add webfonts, meta tags, or analytics to this file.
+      The build step will place the bundled scripts into the <body> tag.
+
+      To begin the development, run `npm start` or `yarn start`.
+      To create a production bundle, use `npm run build` or `yarn build`.
+    -->
+  </body>
+</html> 

frontend/public/manifest.json

@@ -0,0 +1,15 @@
+{
+  "short_name": "Document Chat",
+  "name": "Chat with Your Documents",
+  "icons": [
+    {
+      "src": "favicon.ico",
+      "sizes": "64x64 32x32 24x24 16x16",
+      "type": "image/x-icon"
+    }
+  ],
+  "start_url": ".",
+  "display": "standalone",
+  "theme_color": "#000000",
+  "background_color": "#ffffff"
+} 

frontend/public/robots.txt

@@ -0,0 +1,3 @@
+# https://www.robotstxt.org/robotstxt.html
+User-agent: *
+Disallow: 

frontend/src/App.js

@@ -0,0 +1,582 @@
+import React, { useState, useRef } from 'react';
+import { 
+  ChakraProvider, 
+  Box, 
+  VStack, 
+  HStack, 
+  Text, 
+  Input, 
+  Button, 
+  Flex, 
+  Heading, 
+  Container,
+  useToast,
+  Divider,
+  Progress,
+  extendTheme,
+  Image
+} from '@chakra-ui/react';
+import axios from 'axios';
+import { useDropzone } from 'react-dropzone';
+import { FiSend, FiUpload } from 'react-icons/fi';
+import ReactMarkdown from 'react-markdown';
+
+// Star Wars theme
+const starWarsTheme = extendTheme({
+  colors: {
+    brand: {
+      100: '#ffe81f', // Star Wars yellow
+      200: '#ffe81f',
+      300: '#ffe81f',
+      400: '#ffe81f',
+      500: '#ffe81f',
+      600: '#d6c119',
+      700: '#a99a14',
+      800: '#7c710f',
+      900: '#4f480a',
+    },
+    imperial: {
+      500: '#ff0000', // Empire red
+    },
+    rebel: {
+      500: '#4bd5ee', // Rebel blue
+    },
+    dark: {
+      500: '#000000', // Dark side
+    },
+    light: {
+      500: '#ffffff', // Light side
+    },
+    space: {
+      100: '#05050f',
+      500: '#0a0a1f',
+      900: '#000005',
+    }
+  },
+  fonts: {
+    heading: "'Star Jedi', 'Roboto', sans-serif",
+    body: "'Roboto', sans-serif",
+  },
+  styles: {
+    global: {
+      body: {
+        bg: 'space.500',
+        color: 'light.500',
+      },
+    },
+  },
+});
+
+// API URL - Using the browser's current hostname for backend access
+const getAPIURL = () => {
+  // If we're in development mode (running with npm start)
+  if (process.env.NODE_ENV === 'development') {
+    return 'http://localhost:8000';
+  }
+  
+  // When running in production, use the same host with the backend port
+  // This works because we're exposing the backend port in docker-compose
+  // If port is 7860, use the same port (Hugging Face scenario)
+  const currentPort = window.location.port;
+  if (currentPort === '7860') {
+    return `http://${window.location.hostname}:${currentPort}`;
+  } else {
+    return `http://${window.location.hostname}:8000`;
+  }
+};
+
+const API_URL = process.env.REACT_APP_API_URL || getAPIURL();
+
+// Debug log
+console.log('Using API URL:', API_URL);
+console.log('Environment:', process.env.NODE_ENV);
+console.log('Window location:', window.location.hostname);
+
+// Add axios default timeout and error handling
+axios.defaults.timeout = 120000; // 120 seconds
+axios.interceptors.response.use(
+  response => response,
+  error => {
+    console.error('Axios error:', error);
+    // Log the specific details
+    if (error.response) {
+      // The request was made and the server responded with a status code
+      // that falls out of the range of 2xx
+      console.error('Error response data:', error.response.data);
+      console.error('Error response status:', error.response.status);
+      console.error('Error response headers:', error.response.headers);
+    } else if (error.request) {
+      // The request was made but no response was received
+      console.error('Error request:', error.request);
+      if (error.code === 'ECONNABORTED') {
+        console.error('Request timed out after', axios.defaults.timeout, 'ms');
+      }
+    } else {
+      // Something happened in setting up the request that triggered an Error
+      console.error('Error message:', error.message);
+    }
+    return Promise.reject(error);
+  }
+);
+
+function ChatMessage({ message, isUser }) {
+  return (
+    <Box 
+      bg={isUser ? 'rebel.500' : 'imperial.500'} 
+      p={3} 
+      borderRadius="md" 
+      borderWidth="1px"
+      borderColor={isUser ? 'brand.500' : 'dark.500'}
+      alignSelf={isUser ? 'flex-end' : 'flex-start'}
+      maxW="80%"
+      boxShadow="0 0 5px"
+      color={isUser ? 'dark.500' : 'light.500'}
+    >
+      <Text fontWeight="bold" fontSize="sm" mb={1}>
+        {isUser ? 'Rebel Commander' : 'Jedi Archives'}
+      </Text>
+      <ReactMarkdown>{message}</ReactMarkdown>
+    </Box>
+  );
+}
+
+function FileUploader({ onFileUpload }) {
+  const toast = useToast();
+  const [isUploading, setIsUploading] = useState(false);
+  const [uploadProgress, setUploadProgress] = useState(0);
+  const [processingStatus, setProcessingStatus] = useState(null);
+  
+  const { getRootProps, getInputProps } = useDropzone({
+    maxFiles: 1,
+    maxSize: 5 * 1024 * 1024, // 5MB max size
+    accept: {
+      'text/plain': ['.txt'],
+      'application/pdf': ['.pdf']
+    },
+    onDropRejected: (rejectedFiles) => {
+      toast({
+        title: 'Transmission rejected',
+        description: rejectedFiles[0]?.errors[0]?.message || 'File rejected by the Empire',
+        status: 'error',
+        duration: 5000,
+        isClosable: true,
+      });
+    },
+    onDrop: async (acceptedFiles) => {
+      if (acceptedFiles.length === 0) return;
+      
+      setIsUploading(true);
+      setUploadProgress(0);
+      const file = acceptedFiles[0];
+      
+      // Check file size
+      if (file.size > 5 * 1024 * 1024) {
+        toast({
+          title: 'File too large for hyperdrive',
+          description: 'Maximum file size is 5MB - even the Death Star plans were smaller',
+          status: 'error',
+          duration: 5000,
+          isClosable: true,
+        });
+        setIsUploading(false);
+        return;
+      }
+      
+      const formData = new FormData();
+      formData.append('file', file);
+      
+      try {
+        // Either use the API_URL or direct backend based on environment
+        const uploadUrl = `${API_URL}/upload/`;
+        console.log('Uploading file to:', uploadUrl);
+        
+        const response = await axios.post(uploadUrl, formData, {
+          headers: {
+            'Content-Type': 'multipart/form-data',
+          },
+          onUploadProgress: (progressEvent) => {
+            const percentCompleted = Math.round((progressEvent.loaded * 100) / progressEvent.total);
+            setUploadProgress(percentCompleted);
+          }
+        });
+        
+        console.log('Upload response:', response.data);
+        setProcessingStatus('starting');
+        
+        // Start polling for document processing status
+        const sessionId = response.data.session_id;
+        const pollStatus = async () => {
+          try {
+            const statusUrl = `${API_URL}/session/${sessionId}/status`;
+            console.log('Checking status at:', statusUrl);
+            
+            const statusResponse = await axios.get(statusUrl);
+            console.log('Status response:', statusResponse.data);
+            
+            if (statusResponse.data.status === 'ready') {
+              setProcessingStatus('complete');
+              onFileUpload(sessionId, file.name);
+              return;
+            } else if (statusResponse.data.status === 'failed') {
+              setProcessingStatus('failed');
+              toast({
+                title: 'Processing failed',
+                description: 'There was a disturbance in the Force. Please try again with a different file.',
+                status: 'error',
+                duration: 7000,
+                isClosable: true,
+              });
+              setIsUploading(false);
+              return;
+            }
+            
+            // Still processing, continue polling
+            setProcessingStatus('processing');
+            setTimeout(pollStatus, 3000);
+          } catch (error) {
+            console.error('Error checking status:', error);
+            
+            // Continue polling if there are non-critical errors
+            if (error.code === 'ECONNABORTED') {
+              // Request timed out
+              toast({
+                title: 'Status check timed out',
+                description: 'Your document is being processed by the Jedi Council. Please be patient, this may take time.',
+                status: 'warning',
+                duration: 7000,
+                isClosable: true,
+              });
+              setProcessingStatus('timeout');
+              // Keep polling, but with a longer delay
+              setTimeout(pollStatus, 10000);
+            } else {
+              // Other errors, but still try to continue polling
+              setTimeout(pollStatus, 5000);
+            }
+          }
+        };
+        
+        // Start polling
+        setTimeout(pollStatus, 1000);
+        
+      } catch (error) {
+        console.error('Error uploading file:', error);
+        setProcessingStatus(null);
+        
+        let errorMessage = 'Network error - the Death Star has jammed our comms';
+        
+        if (error.response) {
+          errorMessage = error.response.data?.detail || `Imperial error (${error.response.status})`;
+        } else if (error.code === 'ECONNABORTED') {
+          errorMessage = 'Request timed out. Even the Millennium Falcon would struggle with this file.';
+        }
+        
+        toast({
+          title: 'Upload failed',
+          description: errorMessage,
+          status: 'error',
+          duration: 5000,
+          isClosable: true,
+        });
+        
+        setIsUploading(false);
+      }
+    }
+  });
+  
+  // Status message based on current processing state
+  const getStatusMessage = () => {
+    switch(processingStatus) {
+      case 'starting':
+        return 'Initiating hyperspace jump...';
+      case 'processing':
+        return 'The Force is analyzing your document... This may take several minutes.';
+      case 'timeout':
+        return 'Document processing is taking longer than expected. Patience, young Padawan...';
+      case 'failed':
+        return 'Document processing failed. The dark side clouded this document.';
+      case 'complete':
+        return 'Your document has joined the Jedi Archives!';
+      default:
+        return '';
+    }
+  };
+  
+  return (
+    <Box 
+      {...getRootProps()} 
+      border="2px dashed" 
+      borderColor="brand.500" 
+      borderRadius="md" 
+      p={10} 
+      textAlign="center"
+      cursor="pointer"
+      bg="space.100"
+      _hover={{ bg: 'space.900', borderColor: 'rebel.500' }}
+    >
+      <input {...getInputProps()} />
+      <VStack spacing={2}>
+        <FiUpload size={30} color="#ffe81f" />
+        <Text>Drop a holocron (PDF or text file) here, or click to select</Text>
+        <Text fontSize="sm" color="brand.500">
+          Max file size: 5MB - suitable for Death Star plans
+        </Text>
+        {isUploading && (
+          <>
+            <Text color="brand.500">Uploading to the Jedi Archives...</Text>
+            <Progress 
+              value={uploadProgress} 
+              size="sm" 
+              colorScheme="yellow" 
+              width="100%" 
+              borderRadius="md"
+            />
+            {processingStatus && (
+              <Text 
+                color={processingStatus === 'failed' ? 'imperial.500' : 'brand.500'}
+                fontSize="sm"
+                mt={2}
+              >
+                {getStatusMessage()}
+              </Text>
+            )}
+          </>
+        )}
+      </VStack>
+    </Box>
+  );
+}
+
+function App() {
+  const [sessionId, setSessionId] = useState(null);
+  const [fileName, setFileName] = useState(null);
+  const [messages, setMessages] = useState([]);
+  const [inputText, setInputText] = useState('');
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [isDocProcessing, setIsDocProcessing] = useState(false);
+  const messagesEndRef = useRef(null);
+  const toast = useToast();
+  
+  const handleFileUpload = (newSessionId, name) => {
+    setSessionId(newSessionId);
+    setFileName(name);
+    setIsDocProcessing(true);
+    setMessages([
+      { text: `Processing ${name}. May the Force be with you...`, isUser: false }
+    ]);
+    
+    // Poll for document processing status
+    const checkStatus = async () => {
+      try {
+        const response = await axios.get(`${API_URL}/session/${newSessionId}/status`);
+        console.log('Status response:', response.data);
+        
+        if (response.data.status === 'ready') {
+          setIsDocProcessing(false);
+          setMessages([
+            { text: `"${name}" has been added to the Jedi Archives. What knowledge do you seek?`, isUser: false }
+          ]);
+          return;
+        }
+        
+        // Continue polling if still processing
+        if (response.data.status === 'processing') {
+          setTimeout(checkStatus, 2000);
+        }
+      } catch (error) {
+        console.error('Error checking status:', error);
+        // Continue polling even if there's an error
+        setTimeout(checkStatus, 3000);
+      }
+    };
+    
+    checkStatus();
+  };
+  
+  const handleSendMessage = async () => {
+    if (!inputText.trim() || !sessionId || isDocProcessing) return;
+    
+    const userMessage = inputText;
+    setInputText('');
+    setMessages(prev => [...prev, { text: userMessage, isUser: true }]);
+    setIsProcessing(true);
+    
+    try {
+      // Either use the API_URL or direct backend based on environment
+      const queryUrl = `${API_URL}/query/`;
+      console.log('Sending query to:', queryUrl);
+      
+      const response = await axios.post(queryUrl, {
+        session_id: sessionId,
+        query: userMessage
+      });
+      
+      console.log('Query response:', response.data);
+      setMessages(prev => [...prev, { text: response.data.response, isUser: false }]);
+    } catch (error) {
+      console.error('Error sending message:', error);
+      
+      // Handle specific errors
+      if (error.response?.status === 409) {
+        // Document still processing
+        toast({
+          title: 'Document still processing',
+          description: 'The Jedi Council is still analyzing this document. Please wait a moment and try again.',
+          status: 'warning',
+          duration: 5000,
+          isClosable: true,
+        });
+        
+        setMessages(prev => [...prev, { 
+          text: "The Jedi Council is still analyzing this document. Patience, young Padawan.", 
+          isUser: false 
+        }]);
+      } else {
+        // General error
+        toast({
+          title: 'Error',
+          description: error.response?.data?.detail || 'A disturbance in the Force - make sure the backend is operational',
+          status: 'error',
+          duration: 5000,
+          isClosable: true,
+        });
+        
+        setMessages(prev => [...prev, { 
+          text: "I find your lack of network connectivity disturbing. Please try again.", 
+          isUser: false 
+        }]);
+      }
+    } finally {
+      setIsProcessing(false);
+    }
+  };
+  
+  // Scroll to the bottom of messages
+  React.useEffect(() => {
+    messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' });
+  }, [messages]);
+  
+  // Handle Enter key press
+  const handleKeyPress = (e) => {
+    if (e.key === 'Enter' && !e.shiftKey) {
+      e.preventDefault();
+      handleSendMessage();
+    }
+  };
+  
+  return (
+    <ChakraProvider theme={starWarsTheme}>
+      <Box bg="space.500" minH="100vh" py={8}>
+        <Container maxW="container.lg">
+          <VStack spacing={6} align="stretch" h="100vh">
+            <Box textAlign="center" mb={4}>
+              <Heading 
+                as="h1" 
+                size="xl" 
+                color="brand.500"
+                textShadow="0 0 10px #ffe81f"
+                letterSpacing="2px"
+              >
+                Jedi Archives Chat
+              </Heading>
+              <Text color="light.500" mt={2}>The galaxy's knowledge at your fingertips</Text>
+            </Box>
+            
+            {!sessionId ? (
+              <FileUploader onFileUpload={handleFileUpload} />
+            ) : (
+              <>
+                <Flex justify="space-between" align="center">
+                  <Text fontWeight="bold" color="brand.500">
+                    Current holocron: {fileName} {isDocProcessing && "(Jedi Council analyzing...)"}
+                  </Text>
+                  <Button 
+                    size="sm" 
+                    colorScheme="yellow"
+                    variant="outline"
+                    onClick={() => {
+                      setSessionId(null);
+                      setFileName(null);
+                      setMessages([]);
+                      setIsDocProcessing(false);
+                    }}
+                  >
+                    Access different holocron
+                  </Button>
+                </Flex>
+                
+                <Divider borderColor="brand.500" />
+                
+                <Box 
+                  flex="1" 
+                  overflowY="auto" 
+                  p={4} 
+                  bg="space.100" 
+                  borderRadius="md"
+                  borderWidth="1px"
+                  borderColor="brand.500"
+                  boxShadow="0 0 15px #ffe81f22"
+                  minH="300px"
+                >
+                  <VStack spacing={4} align="stretch">
+                    {messages.map((msg, idx) => (
+                      <ChatMessage 
+                        key={idx} 
+                        message={msg.text} 
+                        isUser={msg.isUser}
+                      />
+                    ))}
+                    {isDocProcessing && (
+                      <Box textAlign="center" p={4}>
+                        <Progress 
+                          size="xs" 
+                          isIndeterminate 
+                          colorScheme="yellow"
+                          width="80%"
+                          mx="auto"
+                        />
+                        <Text mt={2} color="brand.500">
+                          The Force is strong with this document... Processing in progress
+                        </Text>
+                      </Box>
+                    )}
+                    <div ref={messagesEndRef} />
+                  </VStack>
+                </Box>
+                
+                <HStack>
+                  <Input
+                    placeholder={isDocProcessing 
+                      ? "Waiting for the Jedi Council to complete analysis..." 
+                      : "What knowledge do you seek from the holocron?"}
+                    value={inputText}
+                    onChange={(e) => setInputText(e.target.value)}
+                    onKeyPress={handleKeyPress}
+                    disabled={isProcessing || isDocProcessing}
+                    bg="space.100"
+                    color="light.500"
+                    borderColor="brand.500"
+                    _hover={{ borderColor: "rebel.500" }}
+                    _focus={{ borderColor: "rebel.500", boxShadow: "0 0 0 1px #4bd5ee" }}
+                  />
+                  <Button
+                    colorScheme="yellow"
+                    isLoading={isProcessing}
+                    onClick={handleSendMessage}
+                    disabled={!inputText.trim() || isProcessing || isDocProcessing}
+                    leftIcon={<FiSend />}
+                    _hover={{ bg: "rebel.500", color: "dark.500" }}
+                  >
+                    Send
+                  </Button>
+                </HStack>
+              </>
+            )}
+          </VStack>
+        </Container>
+      </Box>
+    </ChakraProvider>
+  );
+}
+
+export default App; 

frontend/src/index.js

@@ -0,0 +1,10 @@
+import React from 'react';
+import ReactDOM from 'react-dom/client';
+import App from './App';
+
+const root = ReactDOM.createRoot(document.getElementById('root'));
+root.render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>
+); 

pyproject.toml

@@ -1,14 +1,34 @@
 [project]
-name = "aie5-deploypythonicrag"
+name = "rag-application"
 version = "0.1.0"
-description = "Simple Pythonic RAG App"
+description = "Retrieval Augmented Generation App with FastAPI backend and React frontend"
 readme = "README.md"
-requires-python = ">=3.13"
+requires-python = ">=3.10"
 dependencies = [
-    "chainlit==2.0.4",
-    "numpy==2.2.2",
-    "openai==1.59.9",
-    "pydantic==2.10.1",
-    "pypdf2==3.0.1",
-    "websockets==14.2",
+    "fastapi>=0.115.3",
+    "uvicorn>=0.25.0",
+    "python-multipart>=0.0.6",
+    "pydantic>=2.4.2",
+    "openai>=1.0.0",
+    "python-dotenv>=1.0.0",
+    "numpy>=1.20.0",
+    "pandas>=1.3.0",
+    "scikit-learn>=1.0.0",
+    "tiktoken>=0.5.0",
+    "PyPDF2>=3.0.0",
+    "chainlit==2.5.5",
+    "websockets>=11.0.0",
 ]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "black",
+]
+
+[tool.pytest]
+testpaths = ["tests"]
+
+[tool.black]
+line-length = 88
+target-version = ["py310"]