Upload 31 files

.gitignore

@@ -0,0 +1,7 @@
+.env
+link.txt
+data
+temp_uploads
+data
+logs
+__pycache__

Build_journey.md

@@ -0,0 +1,75 @@
+The Build Journey: Engineering a Full-Stack RAG Pipeline
+
+This document serves as an exact record of the development process, architectural decisions, and the intense debugging journey I went through to build this dynamic Retrieval-Augmented Generation (RAG) application from scratch.
+
+Phase 1: Architectural Design & Modularization
+
+Instead of writing a monolithic script, I deliberately separated the backend logic into a clean, enterprise-grade src/ directory.
+
+loader.py & splitter.py: Configured to ingest PDFs and cleanly chop them into 1000-character chunks with 200-character overlaps.
+
+embeddings.py: Swapped legacy tools for the modern langchain-huggingface package, utilizing the lightweight all-MiniLM-L6-v2 model.
+
+vectorstore.py: Set up ChromaDB to run ephemerally (in-memory). This was a crucial architectural decision to ensure the app remains stateless between sessions and doesn't eat up disk space on cloud deployments.
+
+rag_chain.py: Wired the vector database up to Google's Gemini 1.5 Flash using LangChain Expression Language (LCEL).
+
+Phase 2: The Dependency Wars
+
+Once the modules were wired into FastAPI (app.py), the environment debugging began.
+
+Conflict 1: The Protobuf Clash: Installing the LangChain Google integration brought in protobuf 6.33.2, which triggered errors against an existing local tensorflow environment (which demanded protobuf<6.0.0). I safely ignored this for the RAG app, noting that a downgrade to 5.x would patch it globally if needed.
+
+Conflict 2: The Missing Neural Network (NameError 'nn' is not defined): The Hugging Face transformers library crashed upon startup. I diagnosed this as an out-of-sync local PyTorch installation and executed a forced upgrade: pip install torch accelerate transformers --upgrade.
+
+Conflict 3: Breaking Computer Vision: Upgrading PyTorch to 2.12.0 triggered dependency warnings for existing facenet-pytorch and torchvision libraries. I made the engineering decision to ignore these warnings, correctly identifying that my text-based RAG pipeline did not rely on those vision libraries.
+
+Phase 3: The Windows "Boss Fights"
+
+Running a complex AI application on local Windows environments introduced a series of highly specific OS-level bugs that required immediate patching.
+
+Boss 1: The Emoji Crash (UnicodeEncodeError)
+
+The Bug: The server crashed immediately during the startup event with UnicodeEncodeError: 'charmap' codec can't encode character '\U0001f680'.
+
+The Diagnosis: The Windows terminal (cp1252 encoding) panicked when my Python logger tried to print a rocket emoji (🚀).
+
+The Fix: Removed the emoji from the console print statement and updated the logger.py RotatingFileHandler to explicitly use encoding="utf-8" to prevent future crashes when reading complex PDF text.
+
+Boss 2: The Hot-Reload Crash (forrtl: error (200))
+
+The Bug: The server booted, but crashed with a severe libifcoremd.dll error whenever an endpoint was hit.
+
+The Diagnosis: I identified a known architectural bug where the C++ backends of PyTorch and NumPy clash with Uvicorn's --reload (WatchFiles) threading on Windows, causing a false Control-C abort sequence.
+
+The Fix: Disabled hot-reloading (uvicorn app:app), which completely stabilized the server memory.
+
+Boss 3: The File System Collision (WinError 183)
+
+The Bug: Uploading a PDF triggered FileExistsError: [WinError 183] Cannot create a file when that file already exists: 'data'.
+
+The Diagnosis: I had written os.makedirs("data", exist_ok=True). However, a local file named data (no extension) already existed in the directory. Windows threw a fatal error because it couldn't create a folder with the same name as a file.
+
+The Fix: Refactored the temp-file routing to use a highly specific temp_uploads/ directory, permanently bypassing the collision.
+
+Phase 4: The Phantom Cache
+
+The Bug: The pipeline failed midway through processing with ImportError: Could not import sentence_transformers. However, running pip install returned "Requirement already satisfied".
+
+The Diagnosis: A network timeout earlier in the build process had created the sentence-transformers folder in the pip cache, but failed to download the actual code. Pip was being tricked by an empty folder.
+
+The Fix: Used the "sledgehammer" command: pip install --force-reinstall --no-cache-dir sentence-transformers to bypass the corrupted local cache and force a fresh binary download. This successfully unblocked the embedding pipeline.
+
+Phase 5: The "No-React" Full-Stack Pivot
+
+With the backend fully operational, I needed a frontend. Instead of context-switching to a completely different language and framework (React) and managing two separate servers, I engineered an all-in-one solution.
+
+I wrote a beautiful, single-page Vanilla HTML/JS frontend styled with Tailwind CSS.
+
+I embedded it directly into the FastAPI application using HTMLResponse.
+
+This allowed me to serve a complete, professional web application from a single Python server, drastically simplifying the deployment process.
+
+Conclusion
+
+This build journey evolved from writing simple Python scripts to engineering a robust, modular microservice architecture. By systematically hunting down and resolving complex OS-level threading issues, file system quirks, and corrupted dependency caches, I successfully delivered a production-ready AI application.

Dockerfile

@@ -0,0 +1,21 @@
+# Use a lightweight Python image
+FROM python:3.10-slim
+
+# Set the working directory
+WORKDIR /app
+
+# Copy the requirements file
+COPY requirements.txt .
+
+# Install dependencies (We force CPU-only PyTorch to save massive amounts of space!)
+RUN pip install --no-cache-dir -r requirements.txt
+RUN pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
+
+# Copy all your code into the container
+COPY . .
+
+# Hugging Face requires apps to run on port 7860
+ENV PORT=7860
+
+# Command to run your FastAPI app
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

ProjectStructure.txt

@@ -0,0 +1,23 @@
+rag-app/
+│
+├── app.py                    # FastAPI application
+├── requirements.txt          # Python dependencies
+├── render.yaml               # Optional Render configuration
+├── .gitignore
+├── .env                      # Local development only
+│
+├── data/
+│   ├── document1.pdf
+│   ├── document2.pdf
+│   └── ...
+│
+├── chroma_db/                # Generated vector database
+│
+├── src/
+│   ├── loader.py             # Load PDFs/documents
+│   ├── splitter.py           # Text chunking
+│   ├── embeddings.py         # Embedding model
+│   ├── vectorstore.py        # ChromaDB setup
+│   └── rag_chain.py          # LangChain retrieval chain
+│   |-- logger.py 
+└── README.md

Readme.md

@@ -0,0 +1,72 @@
+Dynamic RAG Engine 🚀
+
+A full-stack, ephemeral Retrieval-Augmented Generation (RAG) API built with FastAPI, LangChain, and Google's Gemini 1.5 Flash.
+
+This application allows users to upload PDF documents dynamically, vectorizes the text in real-time using local Hugging Face embeddings, and serves a chat interface to query the document using an LLM.
+
+🏗️ Architecture
+
+Backend Framework: FastAPI (Asynchronous, High-Performance)
+
+Orchestration: LangChain
+
+Embedding Model: all-MiniLM-L6-v2 (via Hugging Face)
+
+Vector Database: ChromaDB (Ephemeral / In-Memory for session security)
+
+LLM: Google Gemini 1.5 Flash
+
+Frontend: Vanilla HTML/JS with Tailwind CSS (Served via FastAPI)
+
+✨ Features
+
+Zero-Footprint DB: Uses an in-memory ChromaDB instance that wipes clean after the session, ensuring data privacy and saving server storage.
+
+Modular Pipeline: Document loading, text splitting, embedding, and chain building are separated into clean, maintainable micro-modules (src/).
+
+Custom Logging: Built-in rotating file loggers and middleware for precise API request tracing.
+
+Integrated UI: A modern, single-page application built directly into the root API endpoint.
+
+🚀 Quick Start (Local Deployment)
+
+1. Clone the repository
+
+git clone [https://github.com/yourusername/dynamic-rag-fastapi.git](https://github.com/yourusername/dynamic-rag-fastapi.git)
+cd dynamic-rag-fastapi
+
+
+2. Install dependencies
+
+It is recommended to use a virtual environment.
+
+pip install -r requirements.txt
+
+
+3. Set your Environment Variables
+
+Create a .env file in the root directory or export the variable in your terminal:
+
+export GOOGLE_API_KEY="your_gemini_api_key_here"
+
+
+4. Run the Server
+
+Note for Windows users: Avoid using --reload to prevent Uvicorn threading clashes with local PyTorch installations.
+
+uvicorn app:app
+
+
+5. Access the App
+
+Web UI: http://127.0.0.1:8000/
+
+Interactive API Docs (Swagger): http://127.0.0.1:8000/docs
+
+📡 API Endpoints
+
+GET /: Serves the frontend web interface.
+
+POST /upload: Accepts a multipart/form-data PDF, chunks the text, creates embeddings, and initializes the RAG chain.
+
+POST /chat: Accepts a JSON payload {"message": "string"} and returns the LLM's context-aware response.

app.py

@@ -0,0 +1,118 @@
+from fastapi import FastAPI, UploadFile, File, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import os
+import shutil
+import time
+
+# 1. Import our custom modules from the src/ folder
+from src.logger import logger
+from src.loader import load_pdf
+from src.splitter import split_text
+from src.embeddings import get_embeddings
+from src.vectorstore import create_vectorstore
+from src.rag_chain import build_chain
+from fastapi.responses import HTMLResponse
+# 2. Initialize FastAPI
+app = FastAPI(title="Dynamic PDF RAG API")
+
+# Allow frontend applications (like React) to communicate with this API
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ==========================================
+# AUTO-LOGGING MIDDLEWARE
+# ==========================================
+@app.middleware("http")
+async def log_requests(request: Request, call_next):
+    start_time = time.time()
+    logger.info(f"Incoming request: {request.method} {request.url.path}")
+    response = await call_next(request)
+    process_time = (time.time() - start_time) * 1000
+    logger.info(f"Completed {request.method} {request.url.path} - Status: {response.status_code} - Time: {process_time:.2f}ms")
+    return response
+
+# ==========================================
+# GLOBAL STATE & MODELS
+# ==========================================
+class ChatRequest(BaseModel):
+    message: str
+
+# This holds our LangChain pipeline in memory for the active session
+current_chain = None
+
+@app.on_event("startup")
+async def startup_event():
+    logger.info("Starting up Dynamic RAG API Server...")
+
+# ==========================================
+# API ENDPOINTS
+# ==========================================
+@app.post("/upload")
+async def upload_pdf(file: UploadFile = File(...)):
+    """Accepts a PDF, processes it through the RAG pipeline, and readies the chat."""
+    global current_chain
+    logger.info(f"Received file upload: {file.filename}")
+    
+    # 1. Save the file temporarily in a specific uploads folder
+    upload_dir = "temp_uploads"
+    temp_file_path = f"{upload_dir}/{file.filename}"
+    
+    # Create the directory safely
+    os.makedirs(upload_dir, exist_ok=True)
+    
+    try:
+        with open(temp_file_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+            
+        logger.info("Starting document processing pipeline...")
+        
+        # 2. THE PIPELINE EXECUTES HERE
+        docs = load_pdf(temp_file_path)
+        chunks = split_text(docs)
+        embeddings = get_embeddings()
+        vectorstore = create_vectorstore(chunks, embeddings)
+        current_chain = build_chain(vectorstore)
+        
+        logger.info(f"Successfully processed {file.filename} and activated RAG chain.")
+        return {"status": "success", "message": f"{file.filename} processed! You can now chat."}
+    
+    except Exception as e:
+        logger.error(f"Failed to process PDF: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Failed to process PDF: {str(e)}")
+    
+    finally:
+        # 3. Clean up the temporary PDF file to save server space
+        if os.path.exists(temp_file_path):
+            os.remove(temp_file_path)
+            logger.debug(f"Cleaned up temporary file: {temp_file_path}")
+
+@app.post("/chat")
+async def chat_endpoint(request: ChatRequest):
+    """Answers questions based on the currently uploaded PDF."""
+    global current_chain
+    
+    if current_chain is None:
+        logger.warning("User attempted to chat without uploading a PDF first.")
+        raise HTTPException(status_code=400, detail="No PDF uploaded yet. Please upload a document first.")
+    
+    try:
+        logger.info(f"User asked: '{request.message}'")
+        answer = current_chain.invoke(request.message)
+        logger.debug("Successfully generated LLM response.")
+        return {"reply": answer}
+    except Exception as e:
+        logger.error(f"Error during chat generation: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/")
+async def serve_frontend():
+    """Serves the frontend HTML UI."""
+    with open("index.html", "r", encoding="utf-8") as f:
+        html_content = f.read()
+    return HTMLResponse(content=html_content)

index.html

@@ -0,0 +1,205 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Robotics AI Assistant</title>
+    <!-- Use Tailwind CSS for instant, beautiful styling without needing a CSS file -->
+    <script src="https://cdn.tailwindcss.com"></script>
+    <style>
+        /* A small animation for the loading dots */
+        .dot-flashing {
+            animation: dotFlashing 1s infinite linear alternate;
+        }
+        .dot-flashing:nth-child(2) { animation-delay: 0.2s; }
+        .dot-flashing:nth-child(3) { animation-delay: 0.4s; }
+        @keyframes dotFlashing {
+            0% { opacity: 0.2; transform: scale(0.8); }
+            100% { opacity: 1; transform: scale(1.2); }
+        }
+    </style>
+</head>
+<body class="bg-slate-50 h-screen flex flex-col items-center justify-center p-4 font-sans">
+
+    <div class="w-full max-w-3xl bg-white rounded-2xl shadow-xl overflow-hidden flex flex-col h-[90vh]">
+        
+        <!-- Header -->
+        <div class="bg-slate-900 text-white p-5 flex items-center justify-between">
+            <div>
+                <h1 class="font-bold text-xl flex items-center gap-2">
+                    🤖 Robotics AI Assistant
+                </h1>
+                <p class="text-sm text-slate-400 mt-1">FastAPI + LangChain + Gemini</p>
+            </div>
+            
+            <!-- Upload Section -->
+            <div class="flex items-center gap-2 bg-slate-800 p-2 rounded-lg">
+                <input type="file" id="pdf-upload" accept="application/pdf" class="text-sm text-slate-300 file:mr-4 file:py-2 file:px-4 file:rounded-full file:border-0 file:text-sm file:font-semibold file:bg-blue-600 file:text-white hover:file:bg-blue-700 cursor-pointer">
+                <button onclick="uploadPDF()" id="upload-btn" class="bg-blue-600 hover:bg-blue-700 text-white px-4 py-2 rounded-full text-sm font-semibold transition-colors">
+                    Upload
+                </button>
+            </div>
+        </div>
+
+        <!-- System Message Bar -->
+        <div id="status-bar" class="bg-blue-50 text-blue-800 text-sm p-3 text-center border-b border-blue-100 hidden font-medium">
+            System status goes here...
+        </div>
+
+        <!-- Chat Area -->
+        <div id="chat-box" class="flex-1 overflow-y-auto p-6 space-y-4 bg-slate-50">
+            <!-- Initial Bot Message -->
+            <div class="flex gap-4">
+                <div class="w-8 h-8 rounded-full bg-blue-600 flex items-center justify-center shrink-0 text-white text-sm">AI</div>
+                <div class="bg-white p-4 rounded-2xl rounded-tl-none shadow-sm border border-slate-100 text-slate-700 max-w-[80%]">
+                    Hello! Please upload your PDF document using the button in the top right, and then ask me anything about it.
+                </div>
+            </div>
+        </div>
+
+        <!-- Input Area -->
+        <div class="p-4 bg-white border-t border-slate-200">
+            <form onsubmit="sendMessage(event)" class="flex gap-3">
+                <input type="text" id="user-input" placeholder="Ask a question about the PDF..." disabled
+                    class="flex-1 px-4 py-3 bg-slate-50 border border-slate-300 rounded-xl focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-transparent transition-all disabled:opacity-50 disabled:cursor-not-allowed">
+                <button type="submit" id="send-btn" disabled
+                    class="px-6 py-3 bg-slate-900 text-white rounded-xl hover:bg-slate-800 transition-colors disabled:opacity-50 disabled:cursor-not-allowed font-semibold shadow-sm">
+                    Send
+                </button>
+            </form>
+        </div>
+    </div>
+
+    <script>
+        // --- Logic to handle File Upload ---
+        async function uploadPDF() {
+            const fileInput = document.getElementById('pdf-upload');
+            const file = fileInput.files[0];
+            const uploadBtn = document.getElementById('upload-btn');
+            const statusBar = document.getElementById('status-bar');
+            
+            if (!file) {
+                alert("Please select a PDF file first.");
+                return;
+            }
+
+            // Update UI to show loading
+            uploadBtn.innerText = "Processing...";
+            uploadBtn.disabled = true;
+            statusBar.innerText = `Processing ${file.name}... This may take a moment.`;
+            statusBar.classList.remove('hidden', 'bg-red-50', 'text-red-800');
+            statusBar.classList.add('bg-blue-50', 'text-blue-800');
+
+            const formData = new FormData();
+            formData.append("file", file);
+
+            try {
+                // Send the file to our FastAPI /upload endpoint
+                const response = await fetch('/upload', {
+                    method: 'POST',
+                    body: formData
+                });
+
+                const data = await response.json();
+
+                if (response.ok) {
+                    statusBar.innerText = "✅ PDF processed successfully! You can now chat.";
+                    statusBar.classList.add('bg-green-50', 'text-green-800');
+                    document.getElementById('user-input').disabled = false;
+                    document.getElementById('send-btn').disabled = false;
+                    uploadBtn.innerText = "Uploaded";
+                } else {
+                    throw new Error(data.detail || "Failed to upload");
+                }
+            } catch (error) {
+                statusBar.innerText = `❌ Error: ${error.message}`;
+                statusBar.classList.add('bg-red-50', 'text-red-800');
+                uploadBtn.innerText = "Upload";
+                uploadBtn.disabled = false;
+            }
+        }
+
+        // --- Logic to handle Chat Messages ---
+        async function sendMessage(event) {
+            event.preventDefault(); // Prevent page reload
+            
+            const inputField = document.getElementById('user-input');
+            const message = inputField.value.trim();
+            const chatBox = document.getElementById('chat-box');
+            const sendBtn = document.getElementById('send-btn');
+            
+            if (!message) return;
+
+            // 1. Add User message to UI
+            inputField.value = '';
+            inputField.disabled = true;
+            sendBtn.disabled = true;
+            
+            chatBox.innerHTML += `
+                <div class="flex gap-4 flex-row-reverse">
+                    <div class="w-8 h-8 rounded-full bg-slate-800 flex items-center justify-center shrink-0 text-white text-sm">U</div>
+                    <div class="bg-blue-600 text-white p-4 rounded-2xl rounded-tr-none shadow-sm max-w-[80%]">
+                        ${message}
+                    </div>
+                </div>
+            `;
+            chatBox.scrollTop = chatBox.scrollHeight;
+
+            // 2. Add Loading Indicator
+            const loadingId = "loading-" + Date.now();
+            chatBox.innerHTML += `
+                <div id="${loadingId}" class="flex gap-4">
+                    <div class="w-8 h-8 rounded-full bg-blue-600 flex items-center justify-center shrink-0 text-white text-sm">AI</div>
+                    <div class="bg-white p-4 rounded-2xl rounded-tl-none shadow-sm border border-slate-100 text-slate-700 flex gap-1 items-center h-12">
+                        <div class="w-2 h-2 bg-slate-400 rounded-full dot-flashing"></div>
+                        <div class="w-2 h-2 bg-slate-400 rounded-full dot-flashing"></div>
+                        <div class="w-2 h-2 bg-slate-400 rounded-full dot-flashing"></div>
+                    </div>
+                </div>
+            `;
+            chatBox.scrollTop = chatBox.scrollHeight;
+
+            try {
+                // 3. Send message to our FastAPI /chat endpoint
+                const response = await fetch('/chat', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ message: message })
+                });
+
+                const data = await response.json();
+                
+                // Remove loading indicator
+                document.getElementById(loadingId).remove();
+
+                if (response.ok) {
+                    // Add Bot response to UI
+                    chatBox.innerHTML += `
+                        <div class="flex gap-4">
+                            <div class="w-8 h-8 rounded-full bg-blue-600 flex items-center justify-center shrink-0 text-white text-sm">AI</div>
+                            <div class="bg-white p-4 rounded-2xl rounded-tl-none shadow-sm border border-slate-100 text-slate-700 max-w-[80%] whitespace-pre-wrap leading-relaxed">${data.reply}</div>
+                        </div>
+                    `;
+                } else {
+                    throw new Error(data.detail || "Failed to get response");
+                }
+            } catch (error) {
+                document.getElementById(loadingId).remove();
+                chatBox.innerHTML += `
+                    <div class="flex gap-4">
+                        <div class="w-8 h-8 rounded-full bg-red-500 flex items-center justify-center shrink-0 text-white text-sm">!</div>
+                        <div class="bg-red-50 text-red-800 p-4 rounded-2xl rounded-tl-none shadow-sm border border-red-100 max-w-[80%]">
+                            Error communicating with server: ${error.message}
+                        </div>
+                    </div>
+                `;
+            }
+
+            inputField.disabled = false;
+            sendBtn.disabled = false;
+            inputField.focus();
+            chatBox.scrollTop = chatBox.scrollHeight;
+        }
+    </script>
+</body>
+</html>

pyproject.toml

@@ -0,0 +1,11 @@
+[project]
+name = "src"
+version = "0.0.1"
+description = "A dynamic RAG backend API using FastAPI, LangChain, and ChromaDB"
+authors = [{name = "Abdul Rauf", email = "raufyawar@gmail.com"}]
+
+[tool.setuptools]
+packages = {find = {}}
+
+[tool.setuptools.dynamic]
+dependencies = {file = "requirements.txt"}

requirements.txt

@@ -0,0 +1,13 @@
+langchain-community
+pypdf
+langchain-text-splitters
+langchain-huggingface
+langchain-chroma
+langchain-core
+langchain-google-genai
+fastapi
+sentence-transformers
+python-multipart
+pysqlite3-binary
+uvicorn
+-e .

setup.py

@@ -0,0 +1,9 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="src",
+    version="0.0.1",
+    author="Abdul Rauf",
+    author_email="raufyawar@gmail.com",
+    packages=find_packages()
+)

src/embeddings.py

@@ -0,0 +1,22 @@
+from langchain_huggingface import HuggingFaceEmbeddings
+from src.logger import logger
+
+def get_embeddings(model_name: str = "all-MiniLM-L6-v2"):
+    """
+    Initializes and returns the HuggingFace embedding model.
+    This model translates text chunks into mathematical vectors.
+    """
+    logger.info(f"Initializing embedding model: {model_name}")
+    
+    try:
+        # Initialize the HuggingFace embeddings model
+        embeddings = HuggingFaceEmbeddings(model_name=model_name)
+        
+        logger.info("Successfully loaded embedding model.")
+        
+        # Return the embedding object so ChromaDB can use it
+        return embeddings
+        
+    except Exception as e:
+        logger.error(f"Failed to initialize embeddings: {str(e)}", exc_info=True)
+        raise e

src/loader.py

@@ -0,0 +1,23 @@
+from langchain_community.document_loaders import PyPDFLoader
+from src.logger import logger
+
+def load_pdf(file_path: str):
+    """
+    Loads a PDF file from the given path and returns a list of LangChain Document objects.
+    """
+    logger.info(f"Attempting to load PDF from: {file_path}")
+    try:
+        # Initialize the loader
+        loader = PyPDFLoader(file_path)
+        
+        # Load the document
+        docs = loader.load()
+        
+        logger.info(f"Successfully loaded {len(docs)} pages from the PDF.")
+        
+        # Return the docs so the splitter can use them
+        return docs
+        
+    except Exception as e:
+        logger.error(f"PDF Loader failed to read {file_path}: {str(e)}", exc_info=True)
+        raise e

src/logger.py

@@ -0,0 +1,44 @@
+import logging
+import sys
+from logging.handlers import RotatingFileHandler
+import os
+
+# Create a logs directory if it doesn't exist
+os.makedirs("logs", exist_ok=True)
+
+def setup_logger():
+    # 1. Create a custom logger
+    logger = logging.getLogger("rag_app")
+    logger.setLevel(logging.DEBUG) # Capture everything from DEBUG and above
+
+    # Avoid duplicate logs if this function is called multiple times
+    if logger.handlers:
+        return logger
+
+    # 2. Create formatting (How the log looks)
+    # Example: 2026-06-17 10:45:01,123 - INFO - rag_app - Something happened
+    formatter = logging.Formatter(
+        "%(asctime)s - %(levelname)s - %(name)s - %(message)s"
+    )
+
+    # 3. Console Handler (Prints to your terminal)
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(logging.INFO) # Keep console clean (INFO, WARNING, ERROR)
+    console_handler.setFormatter(formatter)
+
+    # 4. File Handler (Saves to logs/app.log)
+    # Auto-rotates when the file hits 5MB, keeps 3 backups max
+    file_handler = RotatingFileHandler(
+        "logs/app.log", maxBytes=5*1024*1024, backupCount=3, encoding="utf-8"
+    )
+    file_handler.setLevel(logging.DEBUG) # Save EVERYTHING to the file
+    file_handler.setFormatter(formatter)
+
+    # 5. Add handlers to our logger
+    logger.addHandler(console_handler)
+    logger.addHandler(file_handler)
+
+    return logger
+
+# Create a globally accessible logger object
+logger = setup_logger()

src/rag_chain.py

@@ -0,0 +1,62 @@
+import os
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_core.prompts import PromptTemplate
+from langchain_core.runnables import RunnablePassthrough
+from langchain_core.output_parsers import StrOutputParser
+from src.logger import logger
+
+def build_chain(vectorstore):
+    """
+    Takes the populated ChromaDB vector store and builds the LangChain 
+    retrieval-augmented generation (RAG) pipeline using Gemini 1.5 Flash.
+    """
+    logger.info("Building RAG chain...")
+    
+    try:
+        # 1. Verify API Key
+        api_key = os.environ.get("GOOGLE_API_KEY")
+        if not api_key:
+            logger.error("GOOGLE_API_KEY environment variable is missing!")
+            raise ValueError("GOOGLE_API_KEY is not set. Please set it before running the app.")
+
+        # 2. Initialize the LLM
+        logger.debug("Initializing Gemini 1.5 Flash model...")
+        llm = ChatGoogleGenerativeAI(model="gemini-2.5-flash-lite", google_api_key=api_key)
+
+        # 3. Setup the Retriever
+        # k=4 ensures it pulls the top 4 most relevant chunks from ChromaDB
+        retriever = vectorstore.as_retriever(search_kwargs={"k": 4})
+
+        # 4. Define the Prompt Template (Guardrails against hallucinations)
+        template = PromptTemplate.from_template("""
+        You are a helpful AI assistant. Answer the user's question using ONLY the provided context from the uploaded document.
+        If you cannot find the answer in the text, politely say "I cannot find the answer to that in the provided document."
+
+        <context>
+        {context}
+        </context>
+
+        Question: {query}
+        Answer:
+        """)
+
+        # 5. Helper function to combine document chunks into a single string
+        def format_docs(docs):
+            return "\n\n".join(doc.page_content for doc in docs)
+
+        # 6. Build the LangChain Expression Language (LCEL) Pipeline
+        chain = (
+            {"context": retriever | format_docs, "query": RunnablePassthrough()}
+            | template
+            | llm
+            | StrOutputParser()
+        )
+        
+        logger.info("Successfully built RAG chain.")
+        
+        # Return the fully compiled chain back to app.py
+        return chain
+
+    except Exception as e:
+        logger.error(f"Failed to build RAG chain: {str(e)}", exc_info=True)
+        raise e

src/splitter.py

@@ -0,0 +1,29 @@
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from src.logger import logger
+
+def split_text(docs, chunk_size=1000, chunk_overlap=200):
+    """
+    Takes a list of LangChain Document objects and splits them into smaller, 
+    manageable chunks for the vector database.
+    """
+    logger.info(f"Starting text splitting: chunk_size={chunk_size}, overlap={chunk_overlap}")
+    
+    try:
+        # Initialize the LangChain text splitter
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=chunk_size,
+            chunk_overlap=chunk_overlap,
+            separators=["\n\n", "\n", " ", ""] # Splits by paragraph, then line, then word
+        )
+        
+        # Split the documents
+        chunks = text_splitter.split_documents(docs)
+        
+        logger.info(f"Successfully split the document into {len(chunks)} individual chunks.")
+        
+        # Return the chunks so the embedding model can vectorize them
+        return chunks
+        
+    except Exception as e:
+        logger.error(f"Text splitting failed: {str(e)}", exc_info=True)
+        raise e

src/vectorstore.py

@@ -0,0 +1,27 @@
+from langchain_chroma import Chroma
+from src.logger import logger
+
+def create_vectorstore(chunks, embeddings):
+    """
+    Takes the split text chunks and the embedding model,
+    and builds an ephemeral (in-memory) ChromaDB vector store.
+    """
+    logger.info(f"Creating vector store for {len(chunks)} chunks...")
+    
+    try:
+        # Initialize the Chroma vector store from the document chunks.
+        # By omitting 'persist_directory', the database is built in-memory,
+        # which is much faster and perfect for temporary session-based files.
+        vectorstore = Chroma.from_documents(
+            documents=chunks,
+            embedding=embeddings
+        )
+        
+        logger.info("Successfully built Chroma vector store.")
+        
+        # Return the vectorstore so the RAG chain can use it as a retriever
+        return vectorstore
+        
+    except Exception as e:
+        logger.error(f"Failed to create vector store: {str(e)}", exc_info=True)
+        raise e