embedding and model

.history/Dockerfile_20240310014704

@@ -0,0 +1,37 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9
+
+# Create app directory
+WORKDIR /app
+
+# Copy the Python requirements file and system packages list
+COPY ./requirements.txt /app/requirements.txt
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies
+RUN pip install --upgrade pip setuptools wheel && \
+    pip install --no-cache-dir -r /app/requirements.txt
+
+# Create a non-root user
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME /home/user
+ENV PATH $HOME/.local/bin:$PATH
+
+# Copy the application to the user's home directory
+WORKDIR $HOME
+COPY --chown=user:user . $HOME/app
+
+# Set the working directory to the app directory
+WORKDIR $HOME/app
+
+# Expose the Streamlit port
+EXPOSE 8501
+
+# Run the Streamlit application with additional configurations for cloud deployment
+CMD ["streamlit", "run", "app.py", "--server.address=0.0.0.0", "--server.headless=true", "--server.enableCORS=false", "--server.enableXsrfProtection=false", "--server.fileWatcherType=none"]

.history/Dockerfile_20240310014908

@@ -0,0 +1,44 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9
+
+# Set a working directory for the application
+WORKDIR /app
+
+# Copy the Python and system requirements files to the container
+COPY ./requirements.txt /app/requirements.txt
+# If you have system dependencies listed in a packages.txt file, uncomment the next line
+# COPY ./packages.txt /app/packages.txt
+
+# Install system dependencies
+# If you're using packages.txt, uncomment the following RUN command and remove the subsequent one
+# RUN apt-get update && xargs -r -a /app/packages.txt apt-get install -y && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Upgrade pip, setuptools, and wheel, then install Python dependencies
+RUN pip install --upgrade pip setuptools wheel && pip install --no-cache-dir -r /app/requirements.txt
+
+# Create a non-root user and switch to it
+RUN useradd -m user
+USER user
+ENV HOME /home/user
+ENV PATH $HOME/.local/bin:$PATH
+
+# Copy the application source code to the container (as the non-root user)
+COPY --chown=user:user . $HOME/app
+
+# Set the working directory to the app directory
+WORKDIR $HOME/app
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run app.py \
+    --server.headless true \
+    --server.address 0.0.0.0 \
+    --server.enableCORS false \
+    --server.enableXsrfProtection false \
+    --server.fileWatcherType none

.history/Dockerfile_20240310014955

@@ -0,0 +1,48 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9
+
+# Set a working directory for the application
+WORKDIR /app
+
+# Copy the Python and system requirements files to the container
+COPY ./requirements.txt /app/requirements.txt
+COPY ./app.py /app/app.py
+COPY ./src /app/src
+
+
+# If you have system dependencies listed in a packages.txt file, uncomment the next line
+# COPY ./packages.txt /app/packages.txt
+
+# Install system dependencies
+# If you're using packages.txt, uncomment the following RUN command and remove the subsequent one
+# RUN apt-get update && xargs -r -a /app/packages.txt apt-get install -y && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Upgrade pip, setuptools, and wheel, then install Python dependencies
+RUN pip install --upgrade pip setuptools wheel && pip install --no-cache-dir -r /app/requirements.txt
+
+# Create a non-root user and switch to it
+RUN useradd -m user
+USER user
+ENV HOME /home/user
+ENV PATH $HOME/.local/bin:$PATH
+
+# Copy the application source code to the container (as the non-root user)
+COPY --chown=user:user . $HOME/app
+
+# Set the working directory to the app directory
+WORKDIR $HOME/app
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run app.py \
+    --server.headless true \
+    --server.address 0.0.0.0 \
+    --server.enableCORS false \
+    --server.enableXsrfProtection false \
+    --server.fileWatcherType none

.history/Dockerfile_20240310015011

@@ -0,0 +1,42 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9
+
+# Set a working directory for the application
+WORKDIR /app
+
+# Copy the Python and system requirements files to the container
+COPY ./requirements.txt /app/requirements.txt
+COPY ./app.py /app/app.py
+COPY ./src /app/src
+
+# RUN apt-get update && xargs -r -a /app/packages.txt apt-get install -y && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Upgrade pip, setuptools, and wheel, then install Python dependencies
+RUN pip install --upgrade pip setuptools wheel && pip install --no-cache-dir -r /app/requirements.txt
+
+# Create a non-root user and switch to it
+RUN useradd -m user
+USER user
+ENV HOME /home/user
+ENV PATH $HOME/.local/bin:$PATH
+
+# Copy the application source code to the container (as the non-root user)
+COPY --chown=user:user . $HOME/app
+
+# Set the working directory to the app directory
+WORKDIR $HOME/app
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run app.py \
+    --server.headless true \
+    --server.address 0.0.0.0 \
+    --server.enableCORS false \
+    --server.enableXsrfProtection false \
+    --server.fileWatcherType none

.history/Dockerfile_20240310015012

@@ -0,0 +1,42 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9
+
+# Set a working directory for the application
+WORKDIR /app
+
+# Copy the Python and system requirements files to the container
+COPY ./requirements.txt /app/requirements.txt
+COPY ./app.py /app/app.py
+COPY ./src /app/src
+
+# RUN apt-get update && xargs -r -a /app/packages.txt apt-get install -y && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Upgrade pip, setuptools, and wheel, then install Python dependencies
+RUN pip install --upgrade pip setuptools wheel && pip install --no-cache-dir -r /app/requirements.txt
+
+# Create a non-root user and switch to it
+RUN useradd -m user
+USER user
+ENV HOME /home/user
+ENV PATH $HOME/.local/bin:$PATH
+
+# Copy the application source code to the container (as the non-root user)
+COPY --chown=user:user . $HOME/app
+
+# Set the working directory to the app directory
+WORKDIR $HOME/app
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run app.py \
+    --server.headless true \
+    --server.address 0.0.0.0 \
+    --server.enableCORS false \
+    --server.enableXsrfProtection false \
+    --server.fileWatcherType none

.history/Dockerfile_20240310015021

@@ -0,0 +1,42 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9
+
+# Set a working directory for the application
+WORKDIR /app
+
+# Copy the Python and system requirements files to the container
+COPY ./requirements.txt /app/requirements.txt
+COPY ./app.py /app/app.py
+COPY ./src /app/src
+
+# RUN apt-get update && xargs -r -a /app/packages.txt apt-get install -y && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Upgrade pip, setuptools, and wheel, then install Python dependencies
+RUN pip install --upgrade pip setuptools wheel && pip install --no-cache-dir -r /app/requirements.txt
+
+# Create a non-root user and switch to it
+RUN useradd -m user
+USER user
+ENV HOME /home/user
+ENV PATH $HOME/.local/bin:$PATH
+
+# Copy the application source code to the container (as the non-root user)
+COPY --chown=user:user . $HOME/app
+
+# Set the working directory to the app directory
+WORKDIR $HOME/app
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run app.py \
+    --server.headless true \
+    --server.address 0.0.0.0 \
+    --server.enableCORS false \
+    --server.enableXsrfProtection false \
+    --server.fileWatcherType none

.history/Dockerfile_20240310121246

@@ -0,0 +1,19 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set a working directory for the application
+WORKDIR /app
+
+# Copy the Python and system requirements files to the container
+COPY ./requirements.txt /app/requirements.txt
+COPY ./app.py /app/app.py
+COPY ./src /app/src
+
+# Upgrade pip, setuptools, and wheel, then install Python dependencies
+RUN pip install --upgrade pip setuptools wheel && pip install --no-cache-dir -r /app/requirements.txt
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run app.py

.history/Dockerfile_20240310121443

@@ -0,0 +1,25 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set a working directory for the application
+WORKDIR /app
+
+# Copy the Python and system requirements files to the container
+COPY ./requirements.txt /app/requirements.txt
+COPY ./app.py /app/app.py
+COPY ./src /app/src
+
+# RUN apt-get update && xargs -r -a /app/packages.txt apt-get install -y && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Upgrade pip, setuptools, and wheel, then install Python dependencies
+RUN pip install --upgrade pip setuptools wheel && pip install --no-cache-dir -r /app/requirements.txt
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run app.py

.history/Dockerfile_20240310121634

@@ -0,0 +1,25 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set a working directory for the application
+WORKDIR /app
+
+# Copy the Python and system requirements files to the container
+COPY ./requirements.txt /app/requirements.txt
+COPY ./app.py /app/app.py
+COPY ./src /app/src
+
+# RUN apt-get update && xargs -r -a /app/packages.txt apt-get install -y && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Upgrade pip, setuptools, and wheel, then install Python dependencies
+RUN pip install --upgrade pip setuptools wheel && pip install --no-cache-dir -r /app/requirements.txt
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run /app/app.py

.history/Dockerfile_20240310121931

@@ -0,0 +1,25 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set a working directory for the application
+WORKDIR /app
+
+# Copy the Python and system requirements files to the container
+COPY ./requirements.txt /app/requirements.txt
+COPY ./app.py /app/app.py
+COPY ./src/ /app/src/
+
+# RUN apt-get update && xargs -r -a /app/packages.txt apt-get install -y && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Upgrade pip, setuptools, and wheel, then install Python dependencies
+RUN pip install --upgrade pip setuptools wheel && pip install --no-cache-dir -r /app/requirements.txt
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run /app/app.py --server.address 0.0.0.0

.history/Dockerfile_20240310121948

@@ -0,0 +1,25 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set a working directory for the application
+WORKDIR /app
+
+# Copy the Python and system requirements files to the container
+COPY ./requirements.txt /app/requirements.txt
+COPY ./app.py /app/app.py
+COPY ./src/ /app/src/
+
+# RUN apt-get update && xargs -r -a /app/packages.txt apt-get install -y && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Upgrade pip, setuptools, and wheel, then install Python dependencies
+RUN pip install --upgrade pip setuptools wheel && pip install --no-cache-dir -r /app/requirements.txt
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run /app/app.py --server.address 0.0.0.0

.history/Dockerfile_20240310122013

@@ -0,0 +1,25 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set a working directory for the application
+WORKDIR /
+
+# Copy the Python and system requirements files to the container
+COPY ./requirements.txt /requirements.txt
+COPY ./app.py /app.py
+COPY ./src/ /src/
+
+# RUN apt-get update && xargs -r -a /app/packages.txt apt-get install -y && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Upgrade pip, setuptools, and wheel, then install Python dependencies
+RUN pip install --upgrade pip setuptools wheel && pip install --no-cache-dir -r /app/requirements.txt
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run /app/app.py --server.address 0.0.0.0

.history/Dockerfile_20240310122017

@@ -0,0 +1,25 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set a working directory for the application
+WORKDIR /
+
+# Copy the Python and system requirements files to the container
+COPY ./requirements.txt /requirements.txt
+COPY ./app.py /app.py
+COPY ./src/ /src/
+
+# RUN apt-get update && xargs -r -a /app/packages.txt apt-get install -y && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Upgrade pip, setuptools, and wheel, then install Python dependencies
+RUN pip install --upgrade pip setuptools wheel && pip install --no-cache-dir -r /app/requirements.txt
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run /app.py --server.address 0.0.0.0

.history/Dockerfile_20240310122018

@@ -0,0 +1,25 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set a working directory for the application
+WORKDIR /
+
+# Copy the Python and system requirements files to the container
+COPY ./requirements.txt /requirements.txt
+COPY ./app.py /app.py
+COPY ./src/ /src/
+
+# RUN apt-get update && xargs -r -a /app/packages.txt apt-get install -y && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Upgrade pip, setuptools, and wheel, then install Python dependencies
+RUN pip install --upgrade pip setuptools wheel && pip install --no-cache-dir -r /app/requirements.txt
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run /app.py --server.address 0.0.0.0

.history/Dockerfile_20240310122020

@@ -0,0 +1,25 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set a working directory for the application
+WORKDIR /
+
+# Copy the Python and system requirements files to the container
+COPY ./requirements.txt /requirements.txt
+COPY ./app.py /app.py
+COPY ./src/ /src/
+
+# RUN apt-get update && xargs -r -a /app/packages.txt apt-get install -y && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Upgrade pip, setuptools, and wheel, then install Python dependencies
+RUN pip install --upgrade pip setuptools wheel && pip install --no-cache-dir -r /app/requirements.txt
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run app.py --server.address 0.0.0.0

.history/Dockerfile_20240310122058

@@ -0,0 +1,25 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set a working directory for the application
+WORKDIR /
+
+# Copy the Python and system requirements files to the container
+COPY ./requirements.txt /requirements.txt
+COPY ./app.py /app.py
+COPY ./src/ /src/
+
+# RUN apt-get update && xargs -r -a /app/packages.txt apt-get install -y && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Upgrade pip, setuptools, and wheel, then install Python dependencies
+RUN pip install --upgrade pip setuptools wheel && pip install --no-cache-dir -r requirements.txt
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run app.py --server.address 0.0.0.0

.history/Dockerfile_20240310122106

@@ -0,0 +1,25 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set a working directory for the application
+WORKDIR /
+
+# Copy the Python and system requirements files to the container
+COPY ./requirements.txt /requirements.txt
+COPY ./app.py /app.py
+COPY ./src/ /src/
+
+# RUN apt-get update && xargs -r -a /app/packages.txt apt-get install -y && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Upgrade pip, setuptools, and wheel, then install Python dependencies
+RUN pip install --upgrade pip setuptools wheel && pip install --no-cache-dir -r requirements.txt
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run app.py --server.address 0.0.0.0

.history/Dockerfile_20240310122300

@@ -0,0 +1,25 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set a working directory for the application
+WORKDIR /
+
+# Copy the Python and system requirements files to the container
+COPY ./requirements.txt /app/requirements.txt
+COPY ./app.py /app/app.py
+COPY ./src/ /app/src/
+
+# RUN apt-get update && xargs -r -a /app/packages.txt apt-get install -y && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Upgrade pip, setuptools, and wheel, then install Python dependencies
+RUN pip install --upgrade pip setuptools wheel && pip install --no-cache-dir -r /app/requirements.txt
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run app.py --server.address 0.0.0.0

.history/Dockerfile_20240310122456

@@ -0,0 +1,25 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set a working directory for the application
+WORKDIR /
+
+# Copy the Python and system requirements files to the container
+COPY ./requirements.txt /app/requirements.txt
+COPY ./app.py /app/app.py
+COPY ./src/ /app/src/
+
+# RUN apt-get update && xargs -r -a /app/packages.txt apt-get install -y && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Upgrade pip, setuptools, and wheel, then install Python dependencies
+RUN pip install --upgrade pip setuptools wheel && pip install --no-cache-dir -r /app/requirements.txt
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run /app/app.py --server.address 0.0.0.0

.history/Dockerfile_20240310122851

@@ -0,0 +1,47 @@
+# Use an official Python runtime as a parent image
+FROM python:3.11-slim
+
+# Set a working directory for copying requirements initially
+WORKDIR /app
+
+# Copy only the requirements file, to cache the pip install step
+COPY ./requirements.txt /app/requirements.txt
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r /app/requirements.txt
+
+# Copy specific application files to the container
+COPY ./app.py /app/app.py
+COPY ./src /app/src
+
+# Create a non-root user 'appuser' with home directory /home/appuser
+# No need to specify USER ID unless it's required for your use case
+RUN useradd -m appuser
+
+# Switch to the non-root user
+USER appuser
+
+# Set environment variables for the non-root user
+ENV HOME /home/appuser
+ENV PATH $HOME/.local/bin:$PATH
+
+# Set the working directory to the non-root user's home directory
+WORKDIR $HOME
+
+# Create an 'app' directory under the non-root user's home directory and change workdir to it
+RUN mkdir app
+WORKDIR $HOME/app
+
+# Copy the application files from host to container, ensuring correct ownership
+COPY --chown=appuser:appuser . $HOME/app
+
+# Since we've already copied app.py and src/ before changing the user,
+# ensure they are copied into the correct final directory and with correct ownership
+COPY --chown=appuser:appuser /app/app.py $HOME/app/
+COPY --chown=appuser:appuser /app/src/ $HOME/app/src/
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD ["streamlit", "run", "app.py", "--server.address=0.0.0.0"]

.history/Dockerfile_20240310123010

@@ -0,0 +1,36 @@
+# Use an official Python runtime as a parent image
+FROM python:3.11-slim
+
+# Create a non-root user 'appuser' with home directory /home/appuser
+RUN useradd -m appuser
+
+# Set a working directory for copying requirements initially as root
+WORKDIR /app
+
+# Copy only the requirements file, to cache the pip install step
+COPY ./requirements.txt /app/requirements.txt
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r /app/requirements.txt
+
+# Switch to the non-root user
+USER appuser
+
+# Set environment variables for the non-root user
+ENV HOME /home/appuser
+
+# Set the working directory to the non-root user's home directory
+WORKDIR $HOME
+
+# Create an 'app' directory under the non-root user's home directory and change workdir to it
+RUN mkdir app
+WORKDIR $HOME/app
+
+# Copy the application files from host to container, ensuring correct ownership
+COPY --chown=appuser:appuser ./ $HOME/app/
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD ["streamlit", "run", "app.py", "--server.address=0.0.0.0"]

.history/Dockerfile_20240310123131

@@ -0,0 +1,36 @@
+# Use an official Python runtime as a parent image
+FROM python:3.11-slim
+
+# Create a non-root user 'appuser' with home directory /home/appuser
+RUN useradd -m appuser
+
+# Set a working directory for copying requirements initially as root
+WORKDIR /app
+
+# Copy only the requirements file, to cache the pip install step
+COPY ./ /app/
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r /app/requirements.txt
+
+# Switch to the non-root user
+USER appuser
+
+# Set environment variables for the non-root user
+ENV HOME /home/appuser
+
+# Set the working directory to the non-root user's home directory
+WORKDIR $HOME
+
+# Create an 'app' directory under the non-root user's home directory and change workdir to it
+RUN mkdir app
+WORKDIR $HOME/app
+
+# Copy the application files from host to container, ensuring correct ownership
+COPY --chown=appuser:appuser ./ $HOME/app/
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD ["streamlit", "run", "app.py", "--server.address=0.0.0.0"]

.history/Dockerfile_20240310123224

@@ -0,0 +1,36 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Create a non-root user 'appuser' with home directory /home/appuser
+RUN useradd -m appuser
+
+# Set a working directory for copying requirements initially as root
+WORKDIR /app
+
+# Copy only the requirements file, to cache the pip install step
+COPY ./ /app/
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r /app/requirements.txt
+
+# Switch to the non-root user
+USER appuser
+
+# Set environment variables for the non-root user
+ENV HOME /home/appuser
+
+# Set the working directory to the non-root user's home directory
+WORKDIR $HOME
+
+# Create an 'app' directory under the non-root user's home directory and change workdir to it
+RUN mkdir app
+WORKDIR $HOME/app
+
+# Copy the application files from host to container, ensuring correct ownership
+COPY --chown=appuser:appuser ./ $HOME/app/
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD ["streamlit", "run", "app.py", "--server.address=0.0.0.0"]

.history/Dockerfile_20240310123319

@@ -0,0 +1,36 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9
+
+# Create a non-root user 'appuser' with home directory /home/appuser
+RUN useradd -m appuser
+
+# Set a working directory for copying requirements initially as root
+WORKDIR /app
+
+# Copy only the requirements file, to cache the pip install step
+COPY ./ /app/
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r /app/requirements.txt
+
+# Switch to the non-root user
+USER appuser
+
+# Set environment variables for the non-root user
+ENV HOME /home/appuser
+
+# Set the working directory to the non-root user's home directory
+WORKDIR $HOME
+
+# Create an 'app' directory under the non-root user's home directory and change workdir to it
+RUN mkdir app
+WORKDIR $HOME/app
+
+# Copy the application files from host to container, ensuring correct ownership
+COPY --chown=appuser:appuser ./ $HOME/app/
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD ["streamlit", "run", "app.py", "--server.address=0.0.0.0"]

.history/Dockerfile_20240310123825

@@ -0,0 +1,36 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9
+
+# Create a non-root user 'appuser' with home directory /home/appuser
+RUN useradd -m appuser
+
+# Set a working directory for copying requirements initially as root
+WORKDIR /app
+
+# Copy only the requirements file, to cache the pip install step
+COPY ./ /app/
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r /app/requirements.txt
+
+# # Switch to the non-root user
+# USER appuser
+
+# # Set environment variables for the non-root user
+# ENV HOME /home/appuser
+
+# # Set the working directory to the non-root user's home directory
+# WORKDIR $HOME
+
+# # Create an 'app' directory under the non-root user's home directory and change workdir to it
+# RUN mkdir app
+# WORKDIR $HOME/app
+
+# # Copy the application files from host to container, ensuring correct ownership
+# COPY --chown=appuser:appuser ./ $HOME/app/
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD ["streamlit", "run", "app.py", "--server.address=0.0.0.0"]

.history/Dockerfile_20240310123836

@@ -0,0 +1,36 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9
+
+# Create a non-root user 'appuser' with home directory /home/appuser
+RUN useradd -m appuser
+
+# Set a working directory for copying requirements initially as root
+WORKDIR /app
+
+# Copy only the requirements file, to cache the pip install step
+COPY ./ /app/
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r /app/requirements.txt
+
+# # Switch to the non-root user
+# USER appuser
+
+# # Set environment variables for the non-root user
+# ENV HOME /home/appuser
+
+# # Set the working directory to the non-root user's home directory
+# WORKDIR $HOME
+
+# # Create an 'app' directory under the non-root user's home directory and change workdir to it
+# RUN mkdir app
+# WORKDIR $HOME/app
+
+# # Copy the application files from host to container, ensuring correct ownership
+# COPY --chown=appuser:appuser ./ $HOME/app/
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD ["streamlit", "run", "app.py"]

.history/Dockerfile_20240310124558

@@ -0,0 +1,36 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9
+
+# Create a non-root user 'appuser' with home directory /home/appuser
+RUN useradd -m appuser
+
+# Set a working directory for copying requirements initially as root
+WORKDIR /app
+
+# Copy only the requirements file, to cache the pip install step
+COPY ./ /app/
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r /app/requirements.txt
+
+# # Switch to the non-root user
+# USER appuser
+
+# # Set environment variables for the non-root user
+# ENV HOME /home/appuser
+
+# # Set the working directory to the non-root user's home directory
+# WORKDIR $HOME
+
+# # Create an 'app' directory under the non-root user's home directory and change workdir to it
+# RUN mkdir app
+# WORKDIR $HOME/app
+
+# # Copy the application files from host to container, ensuring correct ownership
+# COPY --chown=appuser:appuser ./ $HOME/app/
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD ["streamlit", "run", "app.py", "--server.address=0.0.0.0", "--server.port=8501"]

.history/Dockerfile_20240310124839

@@ -0,0 +1,20 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9
+
+# Create a non-root user 'appuser' with home directory /home/appuser
+RUN useradd -m appuser
+
+# Set a working directory for copying requirements initially as root
+WORKDIR /app
+
+# Copy only the requirements file, to cache the pip install step
+COPY ./ /app
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r /app/requirements.txt
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD ["streamlit", "run", "app.py", "--server.address=0.0.0.0", "--server.port=8501"]

.history/Dockerfile_20240310125002

@@ -0,0 +1,20 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9
+
+# Create a non-root user 'appuser' with home directory /home/appuser
+RUN useradd -m appuser
+
+# Set a working directory for copying requirements initially as root
+WORKDIR /app
+
+# Copy only the requirements file, to cache the pip install step
+COPY ./ /app
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r /app/requirements.txt
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run app.py

.history/Dockerfile_20240310125005

@@ -0,0 +1,20 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9
+
+# Create a non-root user 'appuser' with home directory /home/appuser
+RUN useradd -m appuser
+
+# Set a working directory for copying requirements initially as root
+WORKDIR /app
+
+# Copy only the requirements file, to cache the pip install step
+COPY ./ /app
+
+# Install Python dependencies
+RUN pip3 install --no-cache-dir -r /app/requirements.txt
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run app.py

.history/Dockerfile_20240310125425

@@ -0,0 +1,20 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9
+
+# Create a non-root user 'appuser' with home directory /home/appuser
+RUN useradd -m appuser
+
+# Set a working directory for copying requirements initially as root
+WORKDIR /app
+
+# Copy only the requirements file, to cache the pip install step
+COPY ./ /app
+
+# Install Python dependencies
+RUN pip3 install --no-cache-dir -r /app/requirements.txt
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD python streamlit run app.py --server.address=0.0.0.0

.history/Dockerfile_20240310125557

@@ -0,0 +1,20 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9
+
+# Create a non-root user 'appuser' with home directory /home/appuser
+RUN useradd -m appuser
+
+# Set a working directory for copying requirements initially as root
+WORKDIR /app
+
+# Copy only the requirements file, to cache the pip install step
+COPY ./ /app
+
+# Install Python dependencies
+RUN pip3 install --no-cache-dir -r /app/requirements.txt
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run app.py --server.address=0.0.0.0

.history/Dockerfile_20240310125612

@@ -0,0 +1,20 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9
+
+# Create a non-root user 'appuser' with home directory /home/appuser
+RUN useradd -m appuser
+
+# Set a working directory for copying requirements initially as root
+WORKDIR /app
+
+# Copy only the requirements file, to cache the pip install step
+COPY ./ /app
+
+# Install Python dependencies
+RUN pip3 install --no-cache-dir -r /app/requirements.txt
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run app.py --server.address=0.0.0.0

.history/Dockerfile_20240310130057

@@ -0,0 +1,23 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9
+
+# Create a non-root user 'appuser' with home directory /home/appuser
+RUN useradd -m appuser
+
+# Set a working directory for copying requirements initially as root
+WORKDIR /app
+
+# Copy only the requirements file, to cache the pip install step
+COPY ./ /app
+
+# Install Python dependencies
+RUN pip3 install --no-cache-dir -r /app/requirements.txt
+RUN pip install "langchain[docarray]"
+RUN pip3 install "langchain[docarray]"
+
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run app.py --server.address=0.0.0.0

.history/Dockerfile_20240310130108

@@ -0,0 +1,23 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9
+
+# Create a non-root user 'appuser' with home directory /home/appuser
+RUN useradd -m appuser
+
+# Set a working directory for copying requirements initially as root
+WORKDIR /app
+
+# Copy only the requirements file, to cache the pip install step
+COPY ./ /app
+
+# Install Python dependencies
+RUN pip3 install --no-cache-dir -r /app/requirements.txt
+RUN pip install "langchain[docarray]"
+RUN pip3 install "langchain[docarray]"
+
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run app.py --server.address=0.0.0.0:8501

.history/Dockerfile_20240310130420

@@ -0,0 +1,23 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9
+
+# Create a non-root user 'appuser' with home directory /home/appuser
+RUN useradd -m appuser
+
+# Set a working directory for copying requirements initially as root
+WORKDIR /app
+
+# Copy only the requirements file, to cache the pip install step
+COPY ./ /app
+
+# Install Python dependencies
+RUN pip3 install --no-cache-dir -r /app/requirements.txt
+RUN pip install "langchain[docarray]"
+RUN pip3 install "langchain[docarray]"
+
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run app.py --server.address=0.0.0.0

.history/Dockerfile_20240310130429

@@ -0,0 +1,22 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9
+
+# Create a non-root user 'appuser' with home directory /home/appuser
+RUN useradd -m appuser
+
+# Set a working directory for copying requirements initially as root
+WORKDIR /app
+
+# Copy only the requirements file, to cache the pip install step
+COPY ./ /app
+
+# Install Python dependencies
+RUN pip3 install --no-cache-dir -r /app/requirements.txt
+RUN pip install "langchain[docarray]"
+RUN pip3 install "langchain[docarray]"
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run app.py --server.address=0.0.0.0

.history/Dockerfile_20240310203811

@@ -0,0 +1,22 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9
+
+# Create a non-root user 'appuser' with home directory /home/appuser
+RUN useradd -m appuser
+
+# Set a working directory for copying requirements initially as root
+WORKDIR /app
+
+# Copy only the requirements file, to cache the pip install step
+COPY ./ /app
+
+# Install Python dependencies
+RUN pip3 install --no-cache-dir -r /app/requirements.txt
+RUN pip install "langchain[docarray]"
+RUN pip3 install "langchain[docarray]"
+
+# Expose the port the app runs on
+EXPOSE 8501
+
+# Define the command to run the app
+CMD streamlit run app.py --server.address=0.0.0.0

.history/Dockerfile_20240310204031

@@ -0,0 +1,44 @@
+# # Use an official Python runtime as a parent image
+# FROM python:3.9
+
+# # Create a non-root user 'appuser' with home directory /home/appuser
+# RUN useradd -m appuser
+
+# # Set a working directory for copying requirements initially as root
+# WORKDIR /app
+
+# # Copy only the requirements file, to cache the pip install step
+# COPY ./ /app
+
+# # Install Python dependencies
+# RUN pip3 install --no-cache-dir -r /app/requirements.txt
+# RUN pip install "langchain[docarray]"
+# RUN pip3 install "langchain[docarray]"
+
+# # Expose the port the app runs on
+# EXPOSE 8501
+
+# # Define the command to run the app
+# CMD streamlit run app.py --server.address=0.0.0.0
+
+
+FROM python:3.9-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY ./ /app
+
+RUN pip3 install -r requirements.txt
+
+EXPOSE 8501
+
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+
+ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

.history/Dockerfile_20240310204542

@@ -0,0 +1,45 @@
+# # Use an official Python runtime as a parent image
+# FROM python:3.9
+
+# # Create a non-root user 'appuser' with home directory /home/appuser
+# RUN useradd -m appuser
+
+# # Set a working directory for copying requirements initially as root
+# WORKDIR /app
+
+# # Copy only the requirements file, to cache the pip install step
+# COPY ./ /app
+
+# # Install Python dependencies
+# RUN pip3 install --no-cache-dir -r /app/requirements.txt
+# RUN pip install "langchain[docarray]"
+# RUN pip3 install "langchain[docarray]"
+
+# # Expose the port the app runs on
+# EXPOSE 8501
+
+# # Define the command to run the app
+# CMD streamlit run app.py --server.address=0.0.0.0
+
+
+FROM python:3.9-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY ./ /app
+
+RUN pip3 install -r requirements.txt
+RUN pip3 install 'langchain[docarray]'
+
+EXPOSE 8501
+
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+
+ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

.history/requirements_20240310012013.txt

@@ -0,0 +1,5 @@
+streamlit
+langchain==0.0.305
+langchain[docarray]
+tiktoken
+openai

.history/requirements_20240310124533.txt

@@ -0,0 +1,5 @@
+streamlit
+langchain==0.0.305
+"langchain[docarray]"
+tiktoken
+openai

.history/requirements_20240310124625.txt

@@ -0,0 +1,5 @@
+streamlit
+langchain==0.0.305
+'langchain[docarray]'
+tiktoken
+openai

.history/requirements_20240310124727.txt

@@ -0,0 +1,5 @@
+openai
+streamlit
+langchain==0.0.305
+langchain[docarray]
+tiktoken

.history/src/main_20240310011128.py

@@ -0,0 +1,143 @@
+import os
+import openai
+import sys
+sys.path.append('../..')
+from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.text_splitter import CharacterTextSplitter, RecursiveCharacterTextSplitter
+from langchain.vectorstores import DocArrayInMemorySearch
+from langchain.document_loaders import TextLoader
+from langchain.chains import RetrievalQA,  ConversationalRetrievalChain
+from langchain.memory import ConversationBufferMemory
+from langchain.chat_models import ChatOpenAI
+from langchain.document_loaders import TextLoader
+from langchain.document_loaders import GitLoader
+from langchain.llms import OpenAI
+from langchain.memory import ConversationBufferMemory, ConversationBufferWindowMemory
+from langchain.vectorstores import Chroma
+from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.prompts import PromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate, AIMessagePromptTemplate, ChatPromptTemplate
+import datetime
+import shutil
+
+
+# Function to load the data from github using langchain with string type url, string type branch, string type file_filter
+def loader(url: str, branch: str, file_filter: str):
+    repo_path = "./github_repo"
+    if os.path.exists(repo_path):
+        shutil.rmtree(repo_path)
+
+    loader = GitLoader(
+    clone_url= url,
+    repo_path="./github_repo/",
+    branch=branch,
+    file_filter=lambda file_path: file_path.endswith(tuple(file_filter.split(','))) # Filter out files in Data but whole repo is cloned
+    )
+
+    data = loader.load()
+    return data
+    
+
+#Function to split the data into chunks using recursive character text splitter
+def split_data(data):
+    splitter = RecursiveCharacterTextSplitter(
+            chunk_size=1000,
+            chunk_overlap=150,
+            length_function=len,  # Function to measure the length of chunks while splitting
+            add_start_index=True  # Include the starting position of each chunk in metadata
+    )
+    chunks = splitter.split_documents(data)
+    return chunks
+
+#Function to ingest the chunks into a vectorstore of doc
+def ingest_chunks(chunks):
+    embedding = OpenAIEmbeddings(
+    # deployment="your-embeddings-deployment-name",
+    model="codellama",
+    openai_api_base="https://thewise-ollama-server.hf.space",
+    # openai_api_type="azure",
+    openai_api_key='nothing'
+)
+    vector_store = DocArrayInMemorySearch.from_documents(chunks, embedding)
+
+    repo_path = "./github_repo"
+    if os.path.exists(repo_path):
+        shutil.rmtree(repo_path)
+
+    return vector_store
+
+#Retreival function to get the data from the database and reply to the user
+def retreival(vector_store, k):
+    #Creating LLM
+    llm = ChatOpenAI(model='codellama', temperature=0, openai_api_base='https://thewise-ollama-server.hf.space', openai_api_key='nothing')
+
+    # Define the system message template
+    #Adding CHAT HISTORY to the System template explicitly because mainly Chat history goes to Condense the Human Question with Backround (Not template), but System template goes straight the LLM Chain
+    #Explicitly adding chat history to access previous chats and answer "what is my previous question?"
+    #Great thing this also sends the chat history to the LLM Model along with the context and question
+    system_template = """You're a code summarisation assistant. Given the following extracted parts of a long document as "CONTEXT" create a final answer.
+    If you don't know the answer, just say that you don't know. Don't try to make up an answer.
+    Only If asked to create a "DIAGRAM" for code use "MERMAID SYNTAX LANGUAGE" in your answer from "CONTEXT" and "CHAT HISTORY" with a short explanation of diagram.
+    CONTEXT: {context}
+    =======
+    CHAT HISTORY: {chat_history}
+    =======
+    FINAL ANSWER:"""
+
+    human_template = """{question}"""
+
+    # ai_template = """
+    # FINAL ANSWER:"""
+
+    # Create the chat prompt templates
+    messages = [
+    SystemMessagePromptTemplate.from_template(system_template),
+    HumanMessagePromptTemplate.from_template(human_template)
+    # AIMessagePromptTemplate.from_template(ai_template)
+    ]
+
+    PROMPT = ChatPromptTemplate.from_messages(messages)
+
+    #Creating memory
+    # memory = ConversationBufferMemory(
+    #         memory_key="chat_history",
+    #         input_key="question",
+    #         output_key="answer",
+    #         return_messages=True)
+
+    memory = ConversationBufferWindowMemory(
+            memory_key="chat_history",
+            input_key="question",
+            output_key="answer",
+            return_messages=True,
+            k=5)
+
+    #Creating the retriever, this can also be a contextual compressed retriever
+    retriever = vector_store.as_retriever(search_type="similarity", search_kwargs={"k": k}) #search_type can be "similarity" or "mmr"
+
+    chain = ConversationalRetrievalChain.from_llm(
+        llm=llm, 
+        chain_type="stuff", #chain type can be refine, stuff, map_reduce
+        retriever=retriever, 
+        memory=memory,
+        return_source_documents=True, #When used these 2 properties, the output gets 3 properties: answer, source_document, source_document_score and then have to speocify input and output key in memory for it to work
+        combine_docs_chain_kwargs=dict({"prompt": PROMPT})
+        )
+
+    return chain
+
+#Class using all above components to create QA system
+class ConversationalResponse:
+    def __init__(self, url, branch, file_filter):
+        self.url = url
+        self.branch = branch
+        self.file_filter = file_filter
+        self.data = loader(self.url, self.branch, self.file_filter)
+        self.chunks = split_data(self.data)
+        self.vector_store = ingest_chunks(self.chunks)
+        self.chain_type = "stuff"
+        self.k = 10
+        self.chain = retreival(self.vector_store, self.k)
+
+    def __call__(self, question):
+        agent = self.chain(question)
+        return agent['answer']

.history/src/main_20240310203826.py

@@ -0,0 +1,143 @@
+import os
+import openai
+import sys
+sys.path.append('../..')
+from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.text_splitter import CharacterTextSplitter, RecursiveCharacterTextSplitter
+from langchain.vectorstores import DocArrayInMemorySearch
+from langchain.document_loaders import TextLoader
+from langchain.chains import RetrievalQA,  ConversationalRetrievalChain
+from langchain.memory import ConversationBufferMemory
+from langchain.chat_models import ChatOpenAI
+from langchain.document_loaders import TextLoader
+from langchain.document_loaders import GitLoader
+from langchain.llms import OpenAI
+from langchain.memory import ConversationBufferMemory, ConversationBufferWindowMemory
+from langchain.vectorstores import Chroma
+from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.prompts import PromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate, AIMessagePromptTemplate, ChatPromptTemplate
+import datetime
+import shutil
+
+
+# Function to load the data from github using langchain with string type url, string type branch, string type file_filter
+def loader(url: str, branch: str, file_filter: str):
+    repo_path = "./github_repo"
+    if os.path.exists(repo_path):
+        shutil.rmtree(repo_path)
+
+    loader = GitLoader(
+    clone_url= url,
+    repo_path="./github_repo/",
+    branch=branch,
+    file_filter=lambda file_path: file_path.endswith(tuple(file_filter.split(','))) # Filter out files in Data but whole repo is cloned
+    )
+
+    data = loader.load()
+    return data
+    
+
+#Function to split the data into chunks using recursive character text splitter
+def split_data(data):
+    splitter = RecursiveCharacterTextSplitter(
+            chunk_size=1000,
+            chunk_overlap=150,
+            length_function=len,  # Function to measure the length of chunks while splitting
+            add_start_index=True  # Include the starting position of each chunk in metadata
+    )
+    chunks = splitter.split_documents(data)
+    return chunks
+
+#Function to ingest the chunks into a vectorstore of doc
+def ingest_chunks(chunks):
+    embedding = OpenAIEmbeddings(
+    # deployment="your-embeddings-deployment-name",
+    model="nomic-embed-text",
+    openai_api_base="https://thewise-ollama-server.hf.space",
+    # openai_api_type="azure",
+    openai_api_key='nothing'
+)
+    vector_store = DocArrayInMemorySearch.from_documents(chunks, embedding)
+
+    repo_path = "./github_repo"
+    if os.path.exists(repo_path):
+        shutil.rmtree(repo_path)
+
+    return vector_store
+
+#Retreival function to get the data from the database and reply to the user
+def retreival(vector_store, k):
+    #Creating LLM
+    llm = ChatOpenAI(model='codellama', temperature=0, openai_api_base='https://thewise-ollama-server.hf.space', openai_api_key='nothing')
+
+    # Define the system message template
+    #Adding CHAT HISTORY to the System template explicitly because mainly Chat history goes to Condense the Human Question with Backround (Not template), but System template goes straight the LLM Chain
+    #Explicitly adding chat history to access previous chats and answer "what is my previous question?"
+    #Great thing this also sends the chat history to the LLM Model along with the context and question
+    system_template = """You're a code summarisation assistant. Given the following extracted parts of a long document as "CONTEXT" create a final answer.
+    If you don't know the answer, just say that you don't know. Don't try to make up an answer.
+    Only If asked to create a "DIAGRAM" for code use "MERMAID SYNTAX LANGUAGE" in your answer from "CONTEXT" and "CHAT HISTORY" with a short explanation of diagram.
+    CONTEXT: {context}
+    =======
+    CHAT HISTORY: {chat_history}
+    =======
+    FINAL ANSWER:"""
+
+    human_template = """{question}"""
+
+    # ai_template = """
+    # FINAL ANSWER:"""
+
+    # Create the chat prompt templates
+    messages = [
+    SystemMessagePromptTemplate.from_template(system_template),
+    HumanMessagePromptTemplate.from_template(human_template)
+    # AIMessagePromptTemplate.from_template(ai_template)
+    ]
+
+    PROMPT = ChatPromptTemplate.from_messages(messages)
+
+    #Creating memory
+    # memory = ConversationBufferMemory(
+    #         memory_key="chat_history",
+    #         input_key="question",
+    #         output_key="answer",
+    #         return_messages=True)
+
+    memory = ConversationBufferWindowMemory(
+            memory_key="chat_history",
+            input_key="question",
+            output_key="answer",
+            return_messages=True,
+            k=5)
+
+    #Creating the retriever, this can also be a contextual compressed retriever
+    retriever = vector_store.as_retriever(search_type="similarity", search_kwargs={"k": k}) #search_type can be "similarity" or "mmr"
+
+    chain = ConversationalRetrievalChain.from_llm(
+        llm=llm, 
+        chain_type="stuff", #chain type can be refine, stuff, map_reduce
+        retriever=retriever, 
+        memory=memory,
+        return_source_documents=True, #When used these 2 properties, the output gets 3 properties: answer, source_document, source_document_score and then have to speocify input and output key in memory for it to work
+        combine_docs_chain_kwargs=dict({"prompt": PROMPT})
+        )
+
+    return chain
+
+#Class using all above components to create QA system
+class ConversationalResponse:
+    def __init__(self, url, branch, file_filter):
+        self.url = url
+        self.branch = branch
+        self.file_filter = file_filter
+        self.data = loader(self.url, self.branch, self.file_filter)
+        self.chunks = split_data(self.data)
+        self.vector_store = ingest_chunks(self.chunks)
+        self.chain_type = "stuff"
+        self.k = 10
+        self.chain = retreival(self.vector_store, self.k)
+
+    def __call__(self, question):
+        agent = self.chain(question)
+        return agent['answer']

Dockerfile

@@ -1,19 +1,45 @@
-# Use an official Python runtime as a parent image
-FROM python:3.9
+# # Use an official Python runtime as a parent image
+# FROM python:3.9
 
-# Set the working directory in the container
-WORKDIR /usr/src/app
+# # Create a non-root user 'appuser' with home directory /home/appuser
+# RUN useradd -m appuser
 
-# Copy the current directory contents into the container at /usr/src/app
-COPY requirements.txt ./
-COPY app.py ./
-COPY src ./src
+# # Set a working directory for copying requirements initially as root
+# WORKDIR /app
 
-# Install any needed packages specified in requirements.txt
-RUN pip install --no-cache-dir -r requirements.txt
+# # Copy only the requirements file, to cache the pip install step
+# COPY ./ /app
+
+# # Install Python dependencies
+# RUN pip3 install --no-cache-dir -r /app/requirements.txt
+# RUN pip install "langchain[docarray]"
+# RUN pip3 install "langchain[docarray]"
+
+# # Expose the port the app runs on
+# EXPOSE 8501
+
+# # Define the command to run the app
+# CMD streamlit run app.py --server.address=0.0.0.0
+
+
+FROM python:3.9-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY ./ /app
+
+RUN pip3 install -r requirements.txt
+RUN pip3 install 'langchain[docarray]'
 
-# Make port 8501 available to the world outside this container
 EXPOSE 8501
 
-# Run app.py when the container launches
-CMD ["streamlit", "run", "app.py"]
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+
+ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

requirements.txt

@@ -1,5 +1,5 @@
+openai
 streamlit
 langchain==0.0.305
 langchain[docarray]
-tiktoken
-openai
+tiktoken

src/main.py

@@ -52,7 +52,7 @@ def split_data(data):
 def ingest_chunks(chunks):
     embedding = OpenAIEmbeddings(
     # deployment="your-embeddings-deployment-name",
-    model="codellama",
+    model="nomic-embed-text",
     openai_api_base="https://thewise-ollama-server.hf.space",
     # openai_api_type="azure",
     openai_api_key='nothing'