Clean repository setup with PDF downloading

.gitignore

@@ -0,0 +1,5 @@
+data/*
+__pycache__/
+*.pyc
+.env
+data/preprocessed_data.pkl

Dockerfile

@@ -0,0 +1,47 @@
+# Get a distribution that has uv already installed
+FROM ghcr.io/astral-sh/uv:python3.13-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        
+
+ENV UVICORN_WS_PROTOCOL=websockets
+
+
+# Set the working directory
+WORKDIR $HOME/app
+
+# Copy the app to the container
+COPY --chown=user . $HOME/app
+
+# Install the dependencies
+# RUN uv sync --frozen
+RUN uv sync
+
+# Create data directory if it doesn't exist
+RUN mkdir -p $HOME/app/data
+
+# Install additional dependencies for downloading PDFs
+RUN uv pip install huggingface_hub datasets
+
+# Download PDFs from Hugging Face dataset
+# This requires HF_TOKEN to be set as a build secret in Hugging Face Spaces
+ARG HF_TOKEN
+RUN HF_TOKEN=${HF_TOKEN} huggingface-cli login --token ${HF_TOKEN}
+RUN python download_pdfs.py
+
+# Run preprocessing to generate the embeddings
+# Note: This requires the OPENAI_API_KEY environment variable to be set during build
+# For Hugging Face, you'll need to use their build secrets feature
+RUN OPENAI_API_KEY=${OPENAI_API_KEY} uv run python preprocess.py
+
+# Expose the port
+EXPOSE 7860
+
+# Run the app
+CMD ["uv", "run", "chainlit", "run", "app.py", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,142 @@
+import os
+import pickle
+import time
+from typing import List, Dict, Any
+from chainlit.types import AskFileResponse
+from aimakerspace.text_utils import CharacterTextSplitter, TextFileLoader, PDFLoader
+from aimakerspace.openai_utils.prompts import (
+    UserRolePrompt,
+    SystemRolePrompt,
+    AssistantRolePrompt,
+)
+from aimakerspace.openai_utils.embedding import EmbeddingModel
+from aimakerspace.vectordatabase import VectorDatabase
+from aimakerspace.openai_utils.chatmodel import ChatOpenAI
+import chainlit as cl
+
+system_template = """\
+Use the following context to answer a users question. If you cannot find the answer in the context, say you don't know the answer."""
+system_role_prompt = SystemRolePrompt(system_template)
+
+user_prompt_template = """\
+Context:
+{context}
+
+Question:
+{question}
+"""
+user_role_prompt = UserRolePrompt(user_prompt_template)
+
+class RetrievalAugmentedQAPipeline:
+    def __init__(self, llm: ChatOpenAI(), vector_db_retriever: VectorDatabase, metadata: List[Dict[str, Any]] = None) -> None:
+        self.llm = llm
+        self.vector_db_retriever = vector_db_retriever
+        self.metadata = metadata or []
+        self.text_to_metadata = {}
+        
+        # Create lookup for text to metadata
+        if metadata:
+            texts = [key for key in self.vector_db_retriever.vectors.keys()]
+            for i, text in enumerate(texts):
+                if i < len(metadata):
+                    self.text_to_metadata[text] = metadata[i]
+
+    async def arun_pipeline(self, user_query: str):
+        context_list = self.vector_db_retriever.search_by_text(user_query, k=4)
+
+        context_prompt = ""
+        sources = []
+        
+        for context in context_list:
+            text = context[0]
+            context_prompt += text + "\n"
+            
+            # Get metadata for this text if available
+            if text in self.text_to_metadata:
+                sources.append(self.text_to_metadata[text])
+            else:
+                sources.append({"filename": "unknown", "page": "unknown"})
+
+        formatted_system_prompt = system_role_prompt.create_message()
+
+        formatted_user_prompt = user_role_prompt.create_message(question=user_query, context=context_prompt)
+
+        async def generate_response():
+            async for chunk in self.llm.astream([formatted_system_prompt, formatted_user_prompt]):
+                yield chunk
+
+        return {"response": generate_response(), "sources": sources}
+
+text_splitter = CharacterTextSplitter()
+
+def load_preprocessed_data():
+    # Check if preprocessed data exists
+    if not os.path.exists('data/preprocessed_data.pkl'):
+        raise FileNotFoundError("Preprocessed data not found. Please run the preprocess.py script first.")
+    
+    # Load the pre-processed data
+    with open('data/preprocessed_data.pkl', 'rb') as f:
+        data = pickle.load(f)
+    
+    # Create a new vector database
+    vector_db = VectorDatabase()
+    
+    # Directly populate the vectors dictionary
+    for key, vector in data['vectors'].items():
+        vector_db.insert(key, vector)
+    
+    # Get metadata if available
+    metadata = data.get('metadata', [])
+    
+    return vector_db, metadata
+
+@cl.on_chat_start
+async def on_chat_start():
+    # Send welcome message
+    msg = cl.Message(content="Loading knowledge base from pre-processed PDF documents...")
+    await msg.send()
+    
+    try:
+        # Load pre-processed data
+        start_time = time.time()
+        vector_db, metadata = load_preprocessed_data()
+        load_time = time.time() - start_time
+        print(f"Loaded vector database in {load_time:.2f} seconds")
+        
+        chat_openai = ChatOpenAI()
+        
+        # Create chain
+        retrieval_augmented_qa_pipeline = RetrievalAugmentedQAPipeline(
+            vector_db_retriever=vector_db,
+            llm=chat_openai,
+            metadata=metadata
+        )
+        
+        # Let the user know that the system is ready
+        msg.content = "Knowledge base loaded! You can now ask questions about AB Testing. We'll use material written by Ronny Kohavi to answer your questions!"
+        await msg.update()
+        
+        cl.user_session.set("chain", retrieval_augmented_qa_pipeline)
+        
+    except Exception as e:
+        msg.content = f"Error loading knowledge base: {str(e)}"
+        await msg.update()
+        raise e
+
+@cl.on_message
+async def main(message):
+    chain = cl.user_session.get("chain")
+
+    msg = cl.Message(content="")
+    result = await chain.arun_pipeline(message.content)
+
+    async for stream_resp in result["response"]:
+        await msg.stream_token(stream_resp)
+    
+    # Add source information after the response
+    sources_text = "\n\n**Sources:**"
+    for i, source in enumerate(result["sources"]):
+        sources_text += f"\n- {source['filename']} (Page {source['page']})"
+    
+    await msg.stream_token(sources_text)
+    await msg.send()

chainlit.md

@@ -0,0 +1,3 @@
+# Welcome to Chat with Your Text/PDF File
+
+With this application, you can chat with an uploaded text/PDFfile that is smaller than 2MB!

download_pdfs.py

@@ -0,0 +1,134 @@
+from datasets import load_dataset
+import os
+from huggingface_hub import hf_hub_download
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def download_pdfs():
+    """
+    Download PDF files from the Hugging Face dataset.
+    """
+    logger.info("Creating data directory if it doesn't exist")
+    os.makedirs("data", exist_ok=True)
+    
+    try:
+        logger.info("Loading the dataset from kamkol/ab_testing_pdfs")
+        # Try to load the dataset first
+        dataset = load_dataset("kamkol/ab_testing_pdfs", use_auth_token=True)
+        
+        # Check if we have files in the dataset
+        if 'train' in dataset and len(dataset['train']) > 0:
+            logger.info(f"Found {len(dataset['train'])} files in dataset")
+            
+            # Handle dataset format that uses binary field
+            if 'binary' in dataset['train'].features:
+                for i, item in enumerate(dataset['train']):
+                    filename = item["filename"] if "filename" in item else f"document_{i}.pdf"
+                    with open(f"data/{filename}", "wb") as f:
+                        f.write(item["binary"])
+                    logger.info(f"Downloaded: {filename}")
+            
+            # Alternative approach for direct file access
+            else:
+                # List all PDF files in the repository
+                logger.info("Dataset doesn't have binary field, trying direct file download")
+                for i, item in enumerate(dataset['train']):
+                    # Get filename from the dataset if available
+                    if 'filename' in item:
+                        filename = item['filename']
+                    else:
+                        logger.warning(f"No filename found for item {i}, using default")
+                        filename = f"document_{i}.pdf"
+                    
+                    # Download the file
+                    try:
+                        file_path = hf_hub_download(
+                            repo_id="kamkol/ab_testing_pdfs",
+                            filename=filename,
+                            repo_type="dataset",
+                            use_auth_token=True
+                        )
+                        # Copy to data directory
+                        with open(file_path, 'rb') as src, open(f"data/{filename}", 'wb') as dst:
+                            dst.write(src.read())
+                        logger.info(f"Downloaded: {filename}")
+                    except Exception as e:
+                        logger.error(f"Error downloading {filename}: {str(e)}")
+                        
+        else:
+            # Fall back to direct file download from the repository
+            logger.info("No files found in dataset train split, trying direct repository access")
+            
+            # List of PDF files to download
+            pdf_files = [
+                "trustworthy-online-controlled-experiments.pdf",
+                "2012-controllable-experimentation-paper.pdf",
+                "2011-Bing-Flight-KDD-final.pdf",
+                "best-practices-long.pdf",
+                "kohavi-dmkd-published-version.pdf",
+                "online-experimentation-at-microsoft.pdf",
+                "p609-kohavi.pdf",
+                "TechReport-2009-4.pdf",
+                "Seven-Pitfalls-to-Avoid.pdf",
+                "KDD-2009-ExP-Design-Pitfalls.pdf",
+                "wsdm-4page-paper.pdf",
+                "expAIsterdam-PValue.pdf",
+                "Interleaving-www11.pdf"
+            ]
+            
+            for filename in pdf_files:
+                try:
+                    file_path = hf_hub_download(
+                        repo_id="kamkol/ab_testing_pdfs",
+                        filename=filename,
+                        repo_type="dataset",
+                        use_auth_token=True
+                    )
+                    # Copy to data directory
+                    with open(file_path, 'rb') as src, open(f"data/{filename}", 'wb') as dst:
+                        dst.write(src.read())
+                    logger.info(f"Downloaded: {filename}")
+                except Exception as e:
+                    logger.error(f"Error downloading {filename}: {str(e)}")
+    
+    except Exception as e:
+        logger.error(f"Error loading dataset: {str(e)}")
+        logger.info("Falling back to direct file download")
+        
+        # List of PDF files to download directly from the hub
+        pdf_files = [
+            "trustworthy-online-controlled-experiments.pdf",
+            "2012-controllable-experimentation-paper.pdf",
+            "2011-Bing-Flight-KDD-final.pdf",
+            "best-practices-long.pdf",
+            "kohavi-dmkd-published-version.pdf",
+            "online-experimentation-at-microsoft.pdf",
+            "p609-kohavi.pdf",
+            "TechReport-2009-4.pdf",
+            "Seven-Pitfalls-to-Avoid.pdf",
+            "KDD-2009-ExP-Design-Pitfalls.pdf",
+            "wsdm-4page-paper.pdf",
+            "expAIsterdam-PValue.pdf",
+            "Interleaving-www11.pdf"
+        ]
+        
+        for filename in pdf_files:
+            try:
+                file_path = hf_hub_download(
+                    repo_id="kamkol/ab_testing_pdfs",
+                    filename=filename,
+                    repo_type="dataset",
+                    use_auth_token=True
+                )
+                # Copy to data directory
+                with open(file_path, 'rb') as src, open(f"data/{filename}", 'wb') as dst:
+                    dst.write(src.read())
+                logger.info(f"Downloaded: {filename}")
+            except Exception as e:
+                logger.error(f"Error downloading {filename}: {str(e)}")
+
+if __name__ == "__main__":
+    download_pdfs() 

preprocess.py

@@ -0,0 +1,65 @@
+import os
+import pickle
+import numpy as np
+from aimakerspace.text_utils import CharacterTextSplitter, PDFLoader
+from aimakerspace.openai_utils.embedding import EmbeddingModel
+from aimakerspace.vectordatabase import VectorDatabase
+import asyncio
+
+async def preprocess_files():
+    # Get all PDF files from the data directory
+    data_dir = "data"
+    pdf_files = [os.path.join(data_dir, f) for f in os.listdir(data_dir) 
+                 if f.lower().endswith('.pdf')]
+    
+    if not pdf_files:
+        print("No PDF files found in the data directory!")
+        return
+    
+    print(f"Found {len(pdf_files)} PDF files to process")
+    
+    text_splitter = CharacterTextSplitter()
+    all_texts = []
+    all_metadata = []
+    
+    # Load and process all PDF documents
+    for file_path in pdf_files:
+        print(f"Processing {file_path}")
+        loader = PDFLoader(file_path)
+        documents = loader.load_documents()
+        
+        # Get pages from each document and extract text chunks
+        for doc_idx, doc in enumerate(documents):
+            # Extract page number if available
+            try:
+                page_num = doc_idx + 1  # Use document index as page number
+                texts = text_splitter.split_texts([doc])
+                
+                for text in texts:
+                    all_texts.append(text)
+                    # Store metadata with each chunk
+                    all_metadata.append({
+                        "filename": os.path.basename(file_path),
+                        "page": page_num
+                    })
+            except Exception as e:
+                print(f"Error processing document: {e}")
+    
+    print(f"Extracted {len(all_texts)} text chunks from all PDFs")
+    
+    # Create vector database with embeddings
+    vector_db = VectorDatabase()
+    vector_db = await vector_db.abuild_from_list(all_texts)
+    
+    # Save the processed data with metadata
+    with open('data/preprocessed_data.pkl', 'wb') as f:
+        pickle.dump({
+            'texts': all_texts,
+            'vectors': dict(vector_db.vectors),
+            'metadata': all_metadata
+        }, f)
+    
+    print("Preprocessing complete. Data saved to data/preprocessed_data.pkl")
+
+if __name__ == "__main__":
+    asyncio.run(preprocess_files()) 

pyproject.toml

@@ -0,0 +1,14 @@
+[project]
+name = "aie5-deploypythonicrag"
+version = "0.1.0"
+description = "Simple Pythonic RAG App"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "chainlit==2.0.4",
+    "numpy==2.2.2",
+    "openai==1.59.9",
+    "pydantic==2.10.1",
+    "pypdf2==3.0.1",
+    "websockets==14.2",
+]