Refactor code structure for improved readability and maintainability

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+.chainlit/
+.venv/ 
+.env
+.chainlit/
+.files/

Dockerfile

@@ -0,0 +1,31 @@
+
+# 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
+
+# Expose the port
+EXPOSE 7860
+
+# Run the app
+CMD ["uv", "run", "chainlit", "run", "app.py", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,83 @@
+---
+title: Research Agent
+emoji: 📉
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+license: apache-2.0
+---
+
+# Research Agent
+
+A document-based Q&A application built with LangChain and Chainlit that allows users to upload documents and ask questions about their content.
+
+## Features
+
+- Upload PDF or text documents
+- Ask questions about the uploaded documents
+- Get AI-generated answers based on the document content
+- Streaming responses for better user experience
+
+## Technology Stack
+
+- **LangChain**: Framework for developing applications powered by language models
+- **Chainlit**: Frontend for creating chat-based applications
+- **Qdrant**: Vector database for storing and retrieving document embeddings
+- **OpenAI**: Provides the language model and embeddings
+
+## How It Works
+
+1. User uploads a PDF or text document
+2. The application processes the document:
+   - Splits it into manageable chunks
+   - Creates embeddings using OpenAI
+   - Stores these embeddings in Qdrant vector database
+3. User asks questions about the document
+4. The application:
+   - Retrieves relevant chunks using semantic search
+   - Uses a Retrieval-Augmented Generation (RAG) pipeline to generate answers
+   - Returns streaming responses to the user
+
+## Getting Started
+
+### Prerequisites
+
+- Python 3.8+
+- OpenAI API key
+
+### Installation
+
+```bash
+# Clone the repository
+git clone <repository-url>
+cd AIE6-ResearchAgent
+
+# Install dependencies
+pip install -r requirements.txt
+# Or using uv
+uv add langchain langchain-openai langchain-community langchain-core langchain-text-splitters langchain-qdrant qdrant-client chainlit
+```
+
+### Running the Application
+
+```bash
+# Set your OpenAI API key
+export OPENAI_API_KEY=your-api-key
+
+# Start the application
+chainlit run app.py
+```
+
+## Docker Deployment
+
+The application can also be deployed using Docker:
+
+```bash
+docker build -t research-agent .
+docker run -p 7860:7860 -e OPENAI_API_KEY=your-api-key research-agent
+```
+
+## License
+
+This project is licensed under the Apache License 2.0 - see the LICENSE file for details.

app.py

@@ -0,0 +1,15 @@
+"""
+Main entry point for the Research Agent application.
+
+This file imports the necessary components from other modules and
+serves as the entry point for the Chainlit application.
+"""
+
+# Import the handlers to register Chainlit event handlers
+from handlers.chainlit_handlers import on_chat_start, main
+
+# The Chainlit application will automatically
+# discover and use the imported event handlers
+
+if __name__ == "__main__":
+    print("Research Agent started. Access the web interface to interact.")

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!

config.py

@@ -0,0 +1,18 @@
+"""
+Configuration settings for the Research Agent application.
+"""
+
+# System template for RAG
+SYSTEM_TEMPLATE = """Use the following context to answer a user's question. 
+If you cannot find the answer in the context, say you don't know the answer."""
+
+# Text splitter configurations
+CHUNK_SIZE = 1000
+CHUNK_OVERLAP = 200
+SEPARATORS = ["\n\n", "\n", " ", ""]
+
+# Retrieval configurations
+NUM_RETRIEVAL_RESULTS = 4
+
+# Vector database configurations
+VECTOR_DIMENSION = 1536  # For OpenAI embeddings

handlers/chainlit_handlers.py

@@ -0,0 +1,98 @@
+"""
+Chainlit event handlers for the Research Agent.
+"""
+import os
+import chainlit as cl
+from langchain_openai import ChatOpenAI, OpenAIEmbeddings
+from langchain_qdrant import QdrantVectorStore
+from qdrant_client import QdrantClient
+from qdrant_client.models import Distance, VectorParams
+
+from utils.file_processor import process_file
+from models.rag import LangChainRAG
+import config
+
+@cl.on_chat_start
+async def on_chat_start():
+    """
+    Handler for chat start event. Prompts user to upload a file
+    and initializes the RAG system.
+    """
+    files = None
+
+    # Wait for the user to upload a file
+    while files == None:
+        files = await cl.AskFileMessage(
+            content="Please upload a Text or PDF file to begin!",
+            accept=["text/plain", "application/pdf"],
+            max_size_mb=2,
+            timeout=180,
+        ).send()
+
+    file = files[0]
+
+    msg = cl.Message(content=f"Processing `{file.name}`...")
+    await msg.send()
+
+    # Load and process the file
+    texts = process_file(file)
+    print(f"Processing {len(texts)} text chunks")
+
+    # Initialize embeddings
+    embeddings = OpenAIEmbeddings()
+    
+    # Create a unique collection name based on the file name
+    collection_name = f"collection_{file.name.replace('.', '_')}_{os.urandom(4).hex()}"
+    
+    # Initialize Qdrant client (using in-memory storage)
+    client = QdrantClient(":memory:")
+    
+    # Create collection with proper vector dimensions for OpenAI embeddings
+    client.create_collection(
+        collection_name=collection_name,
+        vectors_config=VectorParams(size=config.VECTOR_DIMENSION, distance=Distance.COSINE)
+    )
+    
+    # Create vector store with QdrantVectorStore
+    vector_store = QdrantVectorStore(
+        client=client, 
+        collection_name=collection_name,
+        embedding=embeddings
+    )
+    
+    # Add documents to the vector store
+    vector_store.add_documents(texts)
+    
+    # Create a retriever
+    retriever = vector_store.as_retriever(search_kwargs={"k": config.NUM_RETRIEVAL_RESULTS})
+    
+    # Initialize language model
+    llm = ChatOpenAI(streaming=True)
+
+    # Create RAG chain
+    rag_chain = LangChainRAG(retriever=retriever, llm=llm)
+    
+    # Let the user know that the system is ready
+    msg.content = f"Processing `{file.name}` done. You can now ask questions!"
+    await msg.update()
+
+    cl.user_session.set("chain", rag_chain)
+
+@cl.on_message
+async def main(message):
+    """
+    Handler for user messages. Processes the query through the RAG chain
+    and streams the response back to the user.
+    
+    Args:
+        message: The user's 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)
+
+    await msg.send()

models/rag.py

@@ -0,0 +1,69 @@
+"""
+RAG (Retrieval Augmented Generation) model implementation.
+"""
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.runnables import RunnablePassthrough
+
+import config
+
+# Create prompt template
+prompt = ChatPromptTemplate.from_messages([
+    ("system", config.SYSTEM_TEMPLATE),
+    MessagesPlaceholder(variable_name="chat_history"),
+    ("human", "{question}"),
+    ("human", "Context: {context}")
+])
+
+class LangChainRAG:
+    """
+    RAG implementation using LangChain components.
+    """
+    def __init__(self, retriever, llm):
+        """
+        Initialize the RAG model.
+        
+        Args:
+            retriever: Document retriever component
+            llm: Language model for generation
+        """
+        self.retriever = retriever
+        self.llm = llm
+        self.chain = self._create_chain()
+        
+    def _create_chain(self):
+        """
+        Create the RAG chain.
+        
+        Returns:
+            A runnable chain that processes user queries
+        """
+        # Define the RAG chain
+        rag_chain = (
+            {"context": self.retriever, "question": RunnablePassthrough(), "chat_history": lambda _: []}
+            | prompt
+            | self.llm
+            | StrOutputParser()
+        )
+        return rag_chain
+    
+    async def arun_pipeline(self, user_query: str):
+        """
+        Run the RAG pipeline with the user query.
+        
+        Args:
+            user_query: User's question
+            
+        Returns:
+            Dict containing the response generator and context
+        """
+        # Get relevant documents for context
+        docs = self.retriever.invoke(user_query)
+        context_list = [(doc.page_content, doc.metadata) for doc in docs]
+        
+        # Create async generator for streaming
+        async def generate_response():
+            async for chunk in self.chain.astream(user_query):
+                yield chunk
+        
+        return {"response": generate_response(), "context": context_list}

pyproject.toml

@@ -0,0 +1,22 @@
+[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",
+    "langchain>=0.3.23",
+    "langchain-community>=0.3.21",
+    "langchain-core>=0.3.54",
+    "langchain-openai>=0.3.8",
+    "langchain-qdrant>=0.2.0",
+    "langchain-text-splitters>=0.3.8",
+    "numpy==2.2.2",
+    "openai==1.59.9",
+    "pydantic==2.10.1",
+    "pypdf>=5.4.0",
+    "pypdf2==3.0.1",
+    "qdrant-client>=1.13.3",
+    "websockets==14.2",
+]

utils/file_processor.py

@@ -0,0 +1,59 @@
+"""
+Utilities for processing uploaded files.
+"""
+import os
+import tempfile
+import shutil
+from typing import List
+
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_community.document_loaders import PyPDFLoader, TextLoader
+from chainlit.types import AskFileResponse
+
+import config
+
+# Initialize text splitter
+text_splitter = RecursiveCharacterTextSplitter(
+    chunk_size=config.CHUNK_SIZE,
+    chunk_overlap=config.CHUNK_OVERLAP,
+    length_function=len,
+    is_separator_regex=False,
+    separators=config.SEPARATORS
+)
+
+def process_file(file: AskFileResponse):
+    """
+    Process an uploaded file and split it into text chunks.
+    
+    Args:
+        file: The uploaded file response from Chainlit
+        
+    Returns:
+        List of document chunks
+    """
+    print(f"Processing file: {file.name}")
+    
+    # Create a temporary file with the correct extension
+    suffix = f".{file.name.split('.')[-1]}"
+    with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as temp_file:
+        # Copy the uploaded file content to the temporary file
+        shutil.copyfile(file.path, temp_file.name)
+        print(f"Created temporary file at: {temp_file.name}")
+        
+        try:
+            # Create appropriate loader
+            if file.name.lower().endswith('.pdf'):
+                loader = PyPDFLoader(temp_file.name)
+            else:
+                loader = TextLoader(temp_file.name)
+                
+            # Load and process the documents
+            documents = loader.load()
+            texts = text_splitter.split_documents(documents)
+            return texts
+        finally:
+            # Clean up the temporary file
+            try:
+                os.unlink(temp_file.name)
+            except Exception as e:
+                print(f"Error cleaning up temporary file: {e}")