more changes

.history/Dockerfile_20240310210059

@@ -0,0 +1,91 @@
+# # 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.8.9
+
+# 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"]
+
+
+# Use Python 3.8.9 as the base image
+FROM python:3.8.9
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy the requirements and packages files into the container
+COPY ./requirements.txt ./packages.txt /app/
+
+# Install Python dependencies
+RUN pip3 install --no-cache-dir -r requirements.txt
+RUN pip3 install 'langchain[docarray]'
+
+# Create a non-root user to run the application
+RUN useradd -m -u 1000 user
+USER user
+
+# Set environment variables for the non-root user
+ENV HOME /home/user
+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 and set it as the working directory
+RUN mkdir app
+WORKDIR $HOME/app
+
+# Copy the rest of the application's code with appropriate ownership
+COPY --chown=user:user . $HOME/app
+
+# Expose the port Streamlit runs on
+EXPOSE 8501
+
+# Set the entry point and default command to run the Streamlit application
+ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

.history/Dockerfile_20240310210143

@@ -0,0 +1,91 @@
+# # 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.8.9
+
+# 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"]
+
+
+# Use Python 3.8.9 as the base image
+FROM python:3.8.9
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy the requirements and packages files into the container
+COPY ./requirements.txt /app/
+
+# Install Python dependencies
+RUN pip3 install --no-cache-dir -r requirements.txt
+RUN pip3 install 'langchain[docarray]'
+
+# Create a non-root user to run the application
+RUN useradd -m -u 1000 user
+USER user
+
+# Set environment variables for the non-root user
+ENV HOME /home/user
+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 and set it as the working directory
+RUN mkdir app
+WORKDIR $HOME/app
+
+# Copy the rest of the application's code with appropriate ownership
+COPY --chown=user:user . $HOME/app
+
+# Expose the port Streamlit runs on
+EXPOSE 8501
+
+# Set the entry point and default command to run the Streamlit application
+ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

.history/Dockerfile_20240310210457

@@ -0,0 +1,92 @@
+# # 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.8.9
+
+# 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"]
+
+
+# Use Python 3.8.9 as the base image
+FROM python:3.8.9
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy the requirements and packages files into the container
+COPY ./requirements.txt /app/
+
+# Install Python dependencies
+RUN pip3 install --no-cache-dir -r requirements.txt
+RUN pip3 install 'langchain[docarray]'
+
+# Create a non-root user to run the application
+RUN useradd -m -u 1000 user
+USER user
+
+# Set environment variables for the non-root user
+ENV HOME /home/user
+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 and set it as the working directory
+RUN mkdir app
+WORKDIR $HOME/app
+
+# Copy the rest of the application's code with appropriate ownership
+COPY --chown=user:user . $HOME/app
+
+# Expose the port Streamlit runs on
+EXPOSE 8501
+ENV PORT=8501
+
+# Set the entry point and default command to run the Streamlit application
+ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=$PORT", "--server.address=0.0.0.0"]

.history/Dockerfile_20240310210618

@@ -0,0 +1,93 @@
+# # 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.8.9
+
+# 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"]
+
+
+# Use Python 3.8.9 as the base image
+FROM python:3.8.9
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy the requirements and packages files into the container
+COPY ./requirements.txt /app/
+
+# Install Python dependencies
+RUN pip3 install --no-cache-dir -r requirements.txt
+RUN pip3 install 'langchain[docarray]'
+
+# Create a non-root user to run the application
+RUN useradd -m -u 1000 user
+USER user
+
+# Set environment variables for the non-root user
+ENV HOME /home/user
+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 and set it as the working directory
+RUN mkdir app
+WORKDIR $HOME/app
+
+# Copy the rest of the application's code with appropriate ownership
+COPY --chown=user:user . $HOME/app
+
+# Expose the port Streamlit runs on
+EXPOSE 8501
+ENV PORT=8501
+
+# Set the entry point and default command to run the Streamlit application
+# ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=$PORT", "--server.address=0.0.0.0"]
+CMD streamlit run app.py --server.port=$PORT --server.address=0.0.0.0

.history/Dockerfile_20240310211133

@@ -0,0 +1,114 @@
+# # # 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.8.9
+
+# # 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"]
+
+
+# # Use Python 3.8.9 as the base image
+# FROM python:3.8.9
+
+# # Set the working directory in the container
+# WORKDIR /app
+
+# # Install system dependencies
+# RUN apt-get update && apt-get install -y \
+#     build-essential \
+#     curl \
+#     software-properties-common \
+#     git \
+#     && rm -rf /var/lib/apt/lists/*
+
+# # Copy the requirements and packages files into the container
+# COPY ./requirements.txt /app/
+
+# # Install Python dependencies
+# RUN pip3 install --no-cache-dir -r requirements.txt
+# RUN pip3 install 'langchain[docarray]'
+
+# # Create a non-root user to run the application
+# RUN useradd -m -u 1000 user
+# USER user
+
+# # Set environment variables for the non-root user
+# ENV HOME /home/user
+# 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 and set it as the working directory
+# RUN mkdir app
+# WORKDIR $HOME/app
+
+# # Copy the rest of the application's code with appropriate ownership
+# COPY --chown=user:user . $HOME/app
+
+# # Expose the port Streamlit runs on
+# EXPOSE 8501
+# ENV PORT=8501
+
+# # Set the entry point and default command to run the Streamlit application
+# # ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=$PORT", "--server.address=0.0.0.0"]
+# CMD streamlit run app.py --server.port=$PORT --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/*
+
+RUN git clone https://github.com/streamlit/streamlit-example.git .
+
+RUN pip3 install -r requirements.txt
+
+EXPOSE 8501
+
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+
+ENTRYPOINT ["streamlit", "run", "streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]

.history/Dockerfile_20240310211707

@@ -0,0 +1,123 @@
+# # # 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.8.9
+
+# # 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"]
+
+
+# # Use Python 3.8.9 as the base image
+# FROM python:3.8.9
+
+# # Set the working directory in the container
+# WORKDIR /app
+
+# # Install system dependencies
+# RUN apt-get update && apt-get install -y \
+#     build-essential \
+#     curl \
+#     software-properties-common \
+#     git \
+#     && rm -rf /var/lib/apt/lists/*
+
+# # Copy the requirements and packages files into the container
+# COPY ./requirements.txt /app/
+
+# # Install Python dependencies
+# RUN pip3 install --no-cache-dir -r requirements.txt
+# RUN pip3 install 'langchain[docarray]'
+
+# # Create a non-root user to run the application
+# RUN useradd -m -u 1000 user
+# USER user
+
+# # Set environment variables for the non-root user
+# ENV HOME /home/user
+# 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 and set it as the working directory
+# RUN mkdir app
+# WORKDIR $HOME/app
+
+# # Copy the rest of the application's code with appropriate ownership
+# COPY --chown=user:user . $HOME/app
+
+# # Expose the port Streamlit runs on
+# EXPOSE 8501
+# ENV PORT=8501
+
+# # Set the entry point and default command to run the Streamlit application
+# # ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=$PORT", "--server.address=0.0.0.0"]
+# CMD streamlit run app.py --server.port=$PORT --server.address=0.0.0.0
+
+# This sets up the container with Python 3.10 installed.
+FROM python:3.10-slim
+
+# This copies everything in your current directory to the /app directory in the container.
+COPY . /app
+
+# This sets the /app directory as the working directory for any RUN, CMD, ENTRYPOINT, or COPY instructions that follow.
+WORKDIR /app
+
+# This runs pip install for all the packages listed in your requirements.txt file.
+RUN pip install -r requirements.txt
+
+# This tells Docker to listen on port 80 at runtime. Port 80 is the standard port for HTTP.
+EXPOSE 80
+
+# This command creates a .streamlit directory in the home directory of the container.
+RUN mkdir ~/.streamlit
+
+# This copies your Streamlit configuration file into the .streamlit directory you just created.
+COPY config.toml ~/.streamlit/config.toml
+
+# Similar to the previous step, this copies your Streamlit credentials file into the .streamlit directory.
+# COPY credentials.toml ~/.streamlit/credentials.toml
+
+# This sets the default command for the container to run the app with Streamlit.
+ENTRYPOINT ["streamlit", "run"]
+
+# This command tells Streamlit to run your app.py script when the container starts.
+CMD ["app.py"]

.history/Dockerfile_20240310211951

@@ -0,0 +1,132 @@
+# # # 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.8.9
+
+# # 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"]
+
+
+# # Use Python 3.8.9 as the base image
+# FROM python:3.8.9
+
+# # Set the working directory in the container
+# WORKDIR /app
+
+# # Install system dependencies
+# RUN apt-get update && apt-get install -y \
+#     build-essential \
+#     curl \
+#     software-properties-common \
+#     git \
+#     && rm -rf /var/lib/apt/lists/*
+
+# # Copy the requirements and packages files into the container
+# COPY ./requirements.txt /app/
+
+# # Install Python dependencies
+# RUN pip3 install --no-cache-dir -r requirements.txt
+# RUN pip3 install 'langchain[docarray]'
+
+# # Create a non-root user to run the application
+# RUN useradd -m -u 1000 user
+# USER user
+
+# # Set environment variables for the non-root user
+# ENV HOME /home/user
+# 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 and set it as the working directory
+# RUN mkdir app
+# WORKDIR $HOME/app
+
+# # Copy the rest of the application's code with appropriate ownership
+# COPY --chown=user:user . $HOME/app
+
+# # Expose the port Streamlit runs on
+# EXPOSE 8501
+# ENV PORT=8501
+
+# # Set the entry point and default command to run the Streamlit application
+# # ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=$PORT", "--server.address=0.0.0.0"]
+# CMD streamlit run app.py --server.port=$PORT --server.address=0.0.0.0
+
+# This sets up the container with Python 3.10 installed.
+FROM python:3.10-slim
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libstdc++-9-dev \
+    gcc \
+    g++ \
+    && rm -rf /var/lib/apt/lists/*
+
+# This copies everything in your current directory to the /app directory in the container.
+COPY . /app
+
+# This sets the /app directory as the working directory for any RUN, CMD, ENTRYPOINT, or COPY instructions that follow.
+WORKDIR /app
+
+# This runs pip install for all the packages listed in your requirements.txt file.
+RUN pip install -r requirements.txt
+RUN pip install 'langchain[docarray]'
+
+
+# This tells Docker to listen on port 80 at runtime. Port 80 is the standard port for HTTP.
+EXPOSE 80
+
+# This command creates a .streamlit directory in the home directory of the container.
+RUN mkdir ~/.streamlit
+
+# This copies your Streamlit configuration file into the .streamlit directory you just created.
+COPY config.toml ~/.streamlit/config.toml
+
+# Similar to the previous step, this copies your Streamlit credentials file into the .streamlit directory.
+# COPY credentials.toml ~/.streamlit/credentials.toml
+
+# This sets the default command for the container to run the app with Streamlit.
+ENTRYPOINT ["streamlit", "run"]
+
+# This command tells Streamlit to run your app.py script when the container starts.
+CMD ["app.py"]

.history/Dockerfile_20240310212052

@@ -0,0 +1,132 @@
+# # # 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.8.9
+
+# # 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"]
+
+
+# # Use Python 3.8.9 as the base image
+# FROM python:3.8.9
+
+# # Set the working directory in the container
+# WORKDIR /app
+
+# # Install system dependencies
+# RUN apt-get update && apt-get install -y \
+#     build-essential \
+#     curl \
+#     software-properties-common \
+#     git \
+#     && rm -rf /var/lib/apt/lists/*
+
+# # Copy the requirements and packages files into the container
+# COPY ./requirements.txt /app/
+
+# # Install Python dependencies
+# RUN pip3 install --no-cache-dir -r requirements.txt
+# RUN pip3 install 'langchain[docarray]'
+
+# # Create a non-root user to run the application
+# RUN useradd -m -u 1000 user
+# USER user
+
+# # Set environment variables for the non-root user
+# ENV HOME /home/user
+# 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 and set it as the working directory
+# RUN mkdir app
+# WORKDIR $HOME/app
+
+# # Copy the rest of the application's code with appropriate ownership
+# COPY --chown=user:user . $HOME/app
+
+# # Expose the port Streamlit runs on
+# EXPOSE 8501
+# ENV PORT=8501
+
+# # Set the entry point and default command to run the Streamlit application
+# # ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=$PORT", "--server.address=0.0.0.0"]
+# CMD streamlit run app.py --server.port=$PORT --server.address=0.0.0.0
+
+# This sets up the container with Python 3.10 installed.
+FROM python:3.10-slim
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libstdc++-dev \
+    gcc \
+    g++ \
+    && rm -rf /var/lib/apt/lists/*
+
+# This copies everything in your current directory to the /app directory in the container.
+COPY . /app
+
+# This sets the /app directory as the working directory for any RUN, CMD, ENTRYPOINT, or COPY instructions that follow.
+WORKDIR /app
+
+# This runs pip install for all the packages listed in your requirements.txt file.
+RUN pip install -r requirements.txt
+RUN pip install 'langchain[docarray]'
+
+
+# This tells Docker to listen on port 80 at runtime. Port 80 is the standard port for HTTP.
+EXPOSE 80
+
+# This command creates a .streamlit directory in the home directory of the container.
+RUN mkdir ~/.streamlit
+
+# This copies your Streamlit configuration file into the .streamlit directory you just created.
+COPY config.toml ~/.streamlit/config.toml
+
+# Similar to the previous step, this copies your Streamlit credentials file into the .streamlit directory.
+# COPY credentials.toml ~/.streamlit/credentials.toml
+
+# This sets the default command for the container to run the app with Streamlit.
+ENTRYPOINT ["streamlit", "run"]
+
+# This command tells Streamlit to run your app.py script when the container starts.
+CMD ["app.py"]

.history/Dockerfile_20240310212121

@@ -0,0 +1,132 @@
+# # # 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.8.9
+
+# # 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"]
+
+
+# # Use Python 3.8.9 as the base image
+# FROM python:3.8.9
+
+# # Set the working directory in the container
+# WORKDIR /app
+
+# # Install system dependencies
+# RUN apt-get update && apt-get install -y \
+#     build-essential \
+#     curl \
+#     software-properties-common \
+#     git \
+#     && rm -rf /var/lib/apt/lists/*
+
+# # Copy the requirements and packages files into the container
+# COPY ./requirements.txt /app/
+
+# # Install Python dependencies
+# RUN pip3 install --no-cache-dir -r requirements.txt
+# RUN pip3 install 'langchain[docarray]'
+
+# # Create a non-root user to run the application
+# RUN useradd -m -u 1000 user
+# USER user
+
+# # Set environment variables for the non-root user
+# ENV HOME /home/user
+# 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 and set it as the working directory
+# RUN mkdir app
+# WORKDIR $HOME/app
+
+# # Copy the rest of the application's code with appropriate ownership
+# COPY --chown=user:user . $HOME/app
+
+# # Expose the port Streamlit runs on
+# EXPOSE 8501
+# ENV PORT=8501
+
+# # Set the entry point and default command to run the Streamlit application
+# # ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=$PORT", "--server.address=0.0.0.0"]
+# CMD streamlit run app.py --server.port=$PORT --server.address=0.0.0.0
+
+# This sets up the container with Python 3.10 installed.
+FROM python:3.10-slim
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# This copies everything in your current directory to the /app directory in the container.
+COPY . /app
+
+# This sets the /app directory as the working directory for any RUN, CMD, ENTRYPOINT, or COPY instructions that follow.
+WORKDIR /app
+
+# This runs pip install for all the packages listed in your requirements.txt file.
+RUN pip install -r requirements.txt
+RUN pip install 'langchain[docarray]'
+
+
+# This tells Docker to listen on port 80 at runtime. Port 80 is the standard port for HTTP.
+EXPOSE 80
+
+# This command creates a .streamlit directory in the home directory of the container.
+RUN mkdir ~/.streamlit
+
+# This copies your Streamlit configuration file into the .streamlit directory you just created.
+COPY config.toml ~/.streamlit/config.toml
+
+# Similar to the previous step, this copies your Streamlit credentials file into the .streamlit directory.
+# COPY credentials.toml ~/.streamlit/credentials.toml
+
+# This sets the default command for the container to run the app with Streamlit.
+ENTRYPOINT ["streamlit", "run"]
+
+# This command tells Streamlit to run your app.py script when the container starts.
+CMD ["app.py"]

.history/Dockerfile_20240310212350

@@ -0,0 +1,132 @@
+# # # 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.8.9
+
+# # 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"]
+
+
+# # Use Python 3.8.9 as the base image
+# FROM python:3.8.9
+
+# # Set the working directory in the container
+# WORKDIR /app
+
+# # Install system dependencies
+# RUN apt-get update && apt-get install -y \
+#     build-essential \
+#     curl \
+#     software-properties-common \
+#     git \
+#     && rm -rf /var/lib/apt/lists/*
+
+# # Copy the requirements and packages files into the container
+# COPY ./requirements.txt /app/
+
+# # Install Python dependencies
+# RUN pip3 install --no-cache-dir -r requirements.txt
+# RUN pip3 install 'langchain[docarray]'
+
+# # Create a non-root user to run the application
+# RUN useradd -m -u 1000 user
+# USER user
+
+# # Set environment variables for the non-root user
+# ENV HOME /home/user
+# 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 and set it as the working directory
+# RUN mkdir app
+# WORKDIR $HOME/app
+
+# # Copy the rest of the application's code with appropriate ownership
+# COPY --chown=user:user . $HOME/app
+
+# # Expose the port Streamlit runs on
+# EXPOSE 8501
+# ENV PORT=8501
+
+# # Set the entry point and default command to run the Streamlit application
+# # ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=$PORT", "--server.address=0.0.0.0"]
+# CMD streamlit run app.py --server.port=$PORT --server.address=0.0.0.0
+
+# This sets up the container with Python 3.10 installed.
+FROM python:3.10-slim
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# This copies everything in your current directory to the /app directory in the container.
+COPY . /app
+
+# This sets the /app directory as the working directory for any RUN, CMD, ENTRYPOINT, or COPY instructions that follow.
+WORKDIR /app
+
+# This runs pip install for all the packages listed in your requirements.txt file.
+RUN pip install -r requirements.txt
+RUN pip install 'langchain[docarray]'
+
+
+# This tells Docker to listen on port 80 at runtime. Port 80 is the standard port for HTTP.
+EXPOSE 80
+
+# This command creates a .streamlit directory in the home directory of the container.
+RUN mkdir ~/.streamlit
+
+# This copies your Streamlit configuration file into the .streamlit directory you just created.
+COPY config.toml ~/.streamlit/config.toml
+
+# Similar to the previous step, this copies your Streamlit credentials file into the .streamlit directory.
+# COPY credentials.toml ~/.streamlit/credentials.toml
+
+# This sets the default command for the container to run the app with Streamlit.
+ENTRYPOINT ["streamlit", "run", "app.py"]
+
+# # This command tells Streamlit to run your app.py script when the container starts.
+# CMD ["app.py"]

.history/Dockerfile_20240310212737

@@ -0,0 +1,132 @@
+# # # 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.8.9
+
+# # 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"]
+
+
+# # Use Python 3.8.9 as the base image
+# FROM python:3.8.9
+
+# # Set the working directory in the container
+# WORKDIR /app
+
+# # Install system dependencies
+# RUN apt-get update && apt-get install -y \
+#     build-essential \
+#     curl \
+#     software-properties-common \
+#     git \
+#     && rm -rf /var/lib/apt/lists/*
+
+# # Copy the requirements and packages files into the container
+# COPY ./requirements.txt /app/
+
+# # Install Python dependencies
+# RUN pip3 install --no-cache-dir -r requirements.txt
+# RUN pip3 install 'langchain[docarray]'
+
+# # Create a non-root user to run the application
+# RUN useradd -m -u 1000 user
+# USER user
+
+# # Set environment variables for the non-root user
+# ENV HOME /home/user
+# 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 and set it as the working directory
+# RUN mkdir app
+# WORKDIR $HOME/app
+
+# # Copy the rest of the application's code with appropriate ownership
+# COPY --chown=user:user . $HOME/app
+
+# # Expose the port Streamlit runs on
+# EXPOSE 8501
+# ENV PORT=8501
+
+# # Set the entry point and default command to run the Streamlit application
+# # ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=$PORT", "--server.address=0.0.0.0"]
+# CMD streamlit run app.py --server.port=$PORT --server.address=0.0.0.0
+
+# This sets up the container with Python 3.10 installed.
+FROM python:3.10-slim
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# This copies everything in your current directory to the /app directory in the container.
+COPY . /app
+
+# This sets the /app directory as the working directory for any RUN, CMD, ENTRYPOINT, or COPY instructions that follow.
+WORKDIR /app
+
+# This runs pip install for all the packages listed in your requirements.txt file.
+RUN pip install -r requirements.txt
+RUN pip install 'langchain[docarray]'
+
+
+# This tells Docker to listen on port 80 at runtime. Port 80 is the standard port for HTTP.
+EXPOSE 80
+
+# This command creates a .streamlit directory in the home directory of the container.
+RUN mkdir ~/.streamlit
+
+# This copies your Streamlit configuration file into the .streamlit directory you just created.
+COPY config.toml ~/.streamlit/config.toml
+
+# Similar to the previous step, this copies your Streamlit credentials file into the .streamlit directory.
+# COPY credentials.toml ~/.streamlit/credentials.toml
+
+# This sets the default command for the container to run the app with Streamlit.
+ENTRYPOINT ["streamlit", "run", "app/app.py"]
+
+# # This command tells Streamlit to run your app.py script when the container starts.
+# CMD ["app.py"]

.history/Dockerfile_20240310212858

@@ -0,0 +1,132 @@
+# # # 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.8.9
+
+# # 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"]
+
+
+# # Use Python 3.8.9 as the base image
+# FROM python:3.8.9
+
+# # Set the working directory in the container
+# WORKDIR /app
+
+# # Install system dependencies
+# RUN apt-get update && apt-get install -y \
+#     build-essential \
+#     curl \
+#     software-properties-common \
+#     git \
+#     && rm -rf /var/lib/apt/lists/*
+
+# # Copy the requirements and packages files into the container
+# COPY ./requirements.txt /app/
+
+# # Install Python dependencies
+# RUN pip3 install --no-cache-dir -r requirements.txt
+# RUN pip3 install 'langchain[docarray]'
+
+# # Create a non-root user to run the application
+# RUN useradd -m -u 1000 user
+# USER user
+
+# # Set environment variables for the non-root user
+# ENV HOME /home/user
+# 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 and set it as the working directory
+# RUN mkdir app
+# WORKDIR $HOME/app
+
+# # Copy the rest of the application's code with appropriate ownership
+# COPY --chown=user:user . $HOME/app
+
+# # Expose the port Streamlit runs on
+# EXPOSE 8501
+# ENV PORT=8501
+
+# # Set the entry point and default command to run the Streamlit application
+# # ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=$PORT", "--server.address=0.0.0.0"]
+# CMD streamlit run app.py --server.port=$PORT --server.address=0.0.0.0
+
+# This sets up the container with Python 3.10 installed.
+FROM python:3.10-slim
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# This copies everything in your current directory to the /app directory in the container.
+COPY . /app
+
+# This sets the /app directory as the working directory for any RUN, CMD, ENTRYPOINT, or COPY instructions that follow.
+WORKDIR /app
+
+# This runs pip install for all the packages listed in your requirements.txt file.
+RUN pip install -r requirements.txt
+RUN pip install 'langchain[docarray]'
+
+
+# This tells Docker to listen on port 80 at runtime. Port 80 is the standard port for HTTP.
+EXPOSE 80
+
+# This command creates a .streamlit directory in the home directory of the container.
+RUN mkdir ~/.streamlit
+
+# This copies your Streamlit configuration file into the .streamlit directory you just created.
+COPY config.toml ~/.streamlit/config.toml
+
+# Similar to the previous step, this copies your Streamlit credentials file into the .streamlit directory.
+# COPY credentials.toml ~/.streamlit/credentials.toml
+
+# This sets the default command for the container to run the app with Streamlit.
+ENTRYPOINT ["streamlit", "run", "app.py"]
+
+# # This command tells Streamlit to run your app.py script when the container starts.
+# CMD ["app.py"]

.history/Dockerfile_20240310213336

@@ -0,0 +1,136 @@
+# # # 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.8.9
+
+# # 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"]
+
+
+# # Use Python 3.8.9 as the base image
+# FROM python:3.8.9
+
+# # Set the working directory in the container
+# WORKDIR /app
+
+# # Install system dependencies
+# RUN apt-get update && apt-get install -y \
+#     build-essential \
+#     curl \
+#     software-properties-common \
+#     git \
+#     && rm -rf /var/lib/apt/lists/*
+
+# # Copy the requirements and packages files into the container
+# COPY ./requirements.txt /app/
+
+# # Install Python dependencies
+# RUN pip3 install --no-cache-dir -r requirements.txt
+# RUN pip3 install 'langchain[docarray]'
+
+# # Create a non-root user to run the application
+# RUN useradd -m -u 1000 user
+# USER user
+
+# # Set environment variables for the non-root user
+# ENV HOME /home/user
+# 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 and set it as the working directory
+# RUN mkdir app
+# WORKDIR $HOME/app
+
+# # Copy the rest of the application's code with appropriate ownership
+# COPY --chown=user:user . $HOME/app
+
+# # Expose the port Streamlit runs on
+# EXPOSE 8501
+# ENV PORT=8501
+
+# # Set the entry point and default command to run the Streamlit application
+# # ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=$PORT", "--server.address=0.0.0.0"]
+# CMD streamlit run app.py --server.port=$PORT --server.address=0.0.0.0
+
+# This sets up the container with Python 3.10 installed.
+FROM python:3.10-slim
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# This copies everything in your current directory to the /app directory in the container.
+COPY . /app
+
+# This sets the /app directory as the working directory for any RUN, CMD, ENTRYPOINT, or COPY instructions that follow.
+WORKDIR /app
+
+# This runs pip install for all the packages listed in your requirements.txt file.
+RUN pip install -r requirements.txt
+RUN pip install 'langchain[docarray]'
+
+
+# This tells Docker to listen on port 80 at runtime. Port 80 is the standard port for HTTP.
+# EXPOSE 80
+
+# This command creates a .streamlit directory in the home directory of the container.
+RUN mkdir ~/.streamlit
+
+# This copies your Streamlit configuration file into the .streamlit directory you just created.
+COPY config.toml ~/.streamlit/config.toml
+
+# Similar to the previous step, this copies your Streamlit credentials file into the .streamlit directory.
+# COPY credentials.toml ~/.streamlit/credentials.toml
+
+# # This sets the default command for the container to run the app with Streamlit.
+# ENTRYPOINT ["streamlit", "run", "app.py"]
+
+# # # This command tells Streamlit to run your app.py script when the container starts.
+# # CMD ["app.py"]
+
+EXPOSE 8501
+ENV PORT=8501
+CMD streamlit run app.py --server.port $PORT

.history/Dockerfile_20240310213859

@@ -0,0 +1,137 @@
+# # # 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.8.9
+
+# # 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"]
+
+
+# # Use Python 3.8.9 as the base image
+# FROM python:3.8.9
+
+# # Set the working directory in the container
+# WORKDIR /app
+
+# # Install system dependencies
+# RUN apt-get update && apt-get install -y \
+#     build-essential \
+#     curl \
+#     software-properties-common \
+#     git \
+#     && rm -rf /var/lib/apt/lists/*
+
+# # Copy the requirements and packages files into the container
+# COPY ./requirements.txt /app/
+
+# # Install Python dependencies
+# RUN pip3 install --no-cache-dir -r requirements.txt
+# RUN pip3 install 'langchain[docarray]'
+
+# # Create a non-root user to run the application
+# RUN useradd -m -u 1000 user
+# USER user
+
+# # Set environment variables for the non-root user
+# ENV HOME /home/user
+# 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 and set it as the working directory
+# RUN mkdir app
+# WORKDIR $HOME/app
+
+# # Copy the rest of the application's code with appropriate ownership
+# COPY --chown=user:user . $HOME/app
+
+# # Expose the port Streamlit runs on
+# EXPOSE 8501
+# ENV PORT=8501
+
+# # Set the entry point and default command to run the Streamlit application
+# # ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=$PORT", "--server.address=0.0.0.0"]
+# CMD streamlit run app.py --server.port=$PORT --server.address=0.0.0.0
+
+# This sets up the container with Python 3.10 installed.
+FROM python:3.10-slim
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# This copies everything in your current directory to the /app directory in the container.
+COPY . /app
+
+# This sets the /app directory as the working directory for any RUN, CMD, ENTRYPOINT, or COPY instructions that follow.
+WORKDIR /app
+
+# This runs pip install for all the packages listed in your requirements.txt file.
+RUN pip install -r requirements.txt
+RUN pip install 'langchain[docarray]'
+
+
+# This tells Docker to listen on port 80 at runtime. Port 80 is the standard port for HTTP.
+# EXPOSE 80
+
+# This command creates a .streamlit directory in the home directory of the container.
+RUN mkdir ~/.streamlit
+
+# This copies your Streamlit configuration file into the .streamlit directory you just created.
+COPY config.toml ~/.streamlit/config.toml
+
+# Similar to the previous step, this copies your Streamlit credentials file into the .streamlit directory.
+# COPY credentials.toml ~/.streamlit/credentials.toml
+
+# # This sets the default command for the container to run the app with Streamlit.
+# ENTRYPOINT ["streamlit", "run", "app.py"]
+
+# # # This command tells Streamlit to run your app.py script when the container starts.
+# # CMD ["app.py"]
+
+EXPOSE 8501
+ENV PORT=8501
+CMD streamlit run app.py --server.port $PORT
+ENTRYPOINT [“streamlit”, “run”, “app.py”, “–server.port=8501”, “–server.address=0.0.0.0”]

.history/Dockerfile_20240310213910

@@ -0,0 +1,137 @@
+# # # 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.8.9
+
+# # 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"]
+
+
+# # Use Python 3.8.9 as the base image
+# FROM python:3.8.9
+
+# # Set the working directory in the container
+# WORKDIR /app
+
+# # Install system dependencies
+# RUN apt-get update && apt-get install -y \
+#     build-essential \
+#     curl \
+#     software-properties-common \
+#     git \
+#     && rm -rf /var/lib/apt/lists/*
+
+# # Copy the requirements and packages files into the container
+# COPY ./requirements.txt /app/
+
+# # Install Python dependencies
+# RUN pip3 install --no-cache-dir -r requirements.txt
+# RUN pip3 install 'langchain[docarray]'
+
+# # Create a non-root user to run the application
+# RUN useradd -m -u 1000 user
+# USER user
+
+# # Set environment variables for the non-root user
+# ENV HOME /home/user
+# 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 and set it as the working directory
+# RUN mkdir app
+# WORKDIR $HOME/app
+
+# # Copy the rest of the application's code with appropriate ownership
+# COPY --chown=user:user . $HOME/app
+
+# # Expose the port Streamlit runs on
+# EXPOSE 8501
+# ENV PORT=8501
+
+# # Set the entry point and default command to run the Streamlit application
+# # ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=$PORT", "--server.address=0.0.0.0"]
+# CMD streamlit run app.py --server.port=$PORT --server.address=0.0.0.0
+
+# This sets up the container with Python 3.10 installed.
+FROM python:3.10-slim
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# This copies everything in your current directory to the /app directory in the container.
+COPY . /app
+
+# This sets the /app directory as the working directory for any RUN, CMD, ENTRYPOINT, or COPY instructions that follow.
+WORKDIR /app
+
+# This runs pip install for all the packages listed in your requirements.txt file.
+RUN pip install -r requirements.txt
+RUN pip install 'langchain[docarray]'
+
+
+# This tells Docker to listen on port 80 at runtime. Port 80 is the standard port for HTTP.
+# EXPOSE 80
+
+# This command creates a .streamlit directory in the home directory of the container.
+RUN mkdir ~/.streamlit
+
+# This copies your Streamlit configuration file into the .streamlit directory you just created.
+COPY config.toml ~/.streamlit/config.toml
+
+# Similar to the previous step, this copies your Streamlit credentials file into the .streamlit directory.
+# COPY credentials.toml ~/.streamlit/credentials.toml
+
+# # This sets the default command for the container to run the app with Streamlit.
+# ENTRYPOINT ["streamlit", "run", "app.py"]
+
+# # # This command tells Streamlit to run your app.py script when the container starts.
+# # CMD ["app.py"]
+
+EXPOSE 8501
+# ENV PORT=8501
+# CMD streamlit run app.py --server.port $PORT
+ENTRYPOINT [“streamlit”, “run”, “app.py”, “–server.port=8501”, “–server.address=0.0.0.0”]

.history/Dockerfile_20240310214129

@@ -0,0 +1,135 @@
+# # # 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.8.9
+
+# # 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"]
+
+
+# # Use Python 3.8.9 as the base image
+# FROM python:3.8.9
+
+# # Set the working directory in the container
+# WORKDIR /app
+
+# # Install system dependencies
+# RUN apt-get update && apt-get install -y \
+#     build-essential \
+#     curl \
+#     software-properties-common \
+#     git \
+#     && rm -rf /var/lib/apt/lists/*
+
+# # Copy the requirements and packages files into the container
+# COPY ./requirements.txt /app/
+
+# # Install Python dependencies
+# RUN pip3 install --no-cache-dir -r requirements.txt
+# RUN pip3 install 'langchain[docarray]'
+
+# # Create a non-root user to run the application
+# RUN useradd -m -u 1000 user
+# USER user
+
+# # Set environment variables for the non-root user
+# ENV HOME /home/user
+# 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 and set it as the working directory
+# RUN mkdir app
+# WORKDIR $HOME/app
+
+# # Copy the rest of the application's code with appropriate ownership
+# COPY --chown=user:user . $HOME/app
+
+# # Expose the port Streamlit runs on
+# EXPOSE 8501
+# ENV PORT=8501
+
+# # Set the entry point and default command to run the Streamlit application
+# # ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=$PORT", "--server.address=0.0.0.0"]
+# CMD streamlit run app.py --server.port=$PORT --server.address=0.0.0.0
+
+# This sets up the container with Python 3.10 installed.
+FROM python:3.10-slim
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# This copies everything in your current directory to the /app directory in the container.
+COPY . /app
+
+# This sets the /app directory as the working directory for any RUN, CMD, ENTRYPOINT, or COPY instructions that follow.
+WORKDIR /app
+
+# This runs pip install for all the packages listed in your requirements.txt file.
+RUN pip install -r requirements.txt
+RUN pip install 'langchain[docarray]'
+
+
+# This tells Docker to listen on port 80 at runtime. Port 80 is the standard port for HTTP.
+# EXPOSE 80
+
+# This command creates a .streamlit directory in the home directory of the container.
+RUN mkdir ~/.streamlit
+
+# This copies your Streamlit configuration file into the .streamlit directory you just created.
+COPY config.toml ~/.streamlit/config.toml
+
+# Similar to the previous step, this copies your Streamlit credentials file into the .streamlit directory.
+# COPY credentials.toml ~/.streamlit/credentials.toml
+
+# # This sets the default command for the container to run the app with Streamlit.
+# ENTRYPOINT ["streamlit", "run", "app.py"]
+
+# # # This command tells Streamlit to run your app.py script when the container starts.
+# # CMD ["app.py"]
+
+EXPOSE 8501
+ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

.history/Dockerfile_20240310215224

@@ -0,0 +1,135 @@
+# # # 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.8.9
+
+# # 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"]
+
+
+# # Use Python 3.8.9 as the base image
+# FROM python:3.8.9
+
+# # Set the working directory in the container
+# WORKDIR /app
+
+# # Install system dependencies
+# RUN apt-get update && apt-get install -y \
+#     build-essential \
+#     curl \
+#     software-properties-common \
+#     git \
+#     && rm -rf /var/lib/apt/lists/*
+
+# # Copy the requirements and packages files into the container
+# COPY ./requirements.txt /app/
+
+# # Install Python dependencies
+# RUN pip3 install --no-cache-dir -r requirements.txt
+# RUN pip3 install 'langchain[docarray]'
+
+# # Create a non-root user to run the application
+# RUN useradd -m -u 1000 user
+# USER user
+
+# # Set environment variables for the non-root user
+# ENV HOME /home/user
+# 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 and set it as the working directory
+# RUN mkdir app
+# WORKDIR $HOME/app
+
+# # Copy the rest of the application's code with appropriate ownership
+# COPY --chown=user:user . $HOME/app
+
+# # Expose the port Streamlit runs on
+# EXPOSE 8501
+# ENV PORT=8501
+
+# # Set the entry point and default command to run the Streamlit application
+# # ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=$PORT", "--server.address=0.0.0.0"]
+# CMD streamlit run app.py --server.port=$PORT --server.address=0.0.0.0
+
+# This sets up the container with Python 3.10 installed.
+FROM python:3.10-slim
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# This copies everything in your current directory to the /app directory in the container.
+COPY . /app
+
+# This sets the /app directory as the working directory for any RUN, CMD, ENTRYPOINT, or COPY instructions that follow.
+WORKDIR /app
+
+# This runs pip install for all the packages listed in your requirements.txt file.
+RUN pip install -r requirements.txt
+RUN pip install "langchain[docarray]"
+
+
+# This tells Docker to listen on port 80 at runtime. Port 80 is the standard port for HTTP.
+# EXPOSE 80
+
+# This command creates a .streamlit directory in the home directory of the container.
+RUN mkdir ~/.streamlit
+
+# This copies your Streamlit configuration file into the .streamlit directory you just created.
+COPY config.toml ~/.streamlit/config.toml
+
+# Similar to the previous step, this copies your Streamlit credentials file into the .streamlit directory.
+# COPY credentials.toml ~/.streamlit/credentials.toml
+
+# # This sets the default command for the container to run the app with Streamlit.
+# ENTRYPOINT ["streamlit", "run", "app.py"]
+
+# # # This command tells Streamlit to run your app.py script when the container starts.
+# # CMD ["app.py"]
+
+EXPOSE 8501
+ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

.history/Dockerfile_20240310221328

@@ -0,0 +1,135 @@
+# # # 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.8.9
+
+# # 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"]
+
+
+# # Use Python 3.8.9 as the base image
+# FROM python:3.8.9
+
+# # Set the working directory in the container
+# WORKDIR /app
+
+# # Install system dependencies
+# RUN apt-get update && apt-get install -y \
+#     build-essential \
+#     curl \
+#     software-properties-common \
+#     git \
+#     && rm -rf /var/lib/apt/lists/*
+
+# # Copy the requirements and packages files into the container
+# COPY ./requirements.txt /app/
+
+# # Install Python dependencies
+# RUN pip3 install --no-cache-dir -r requirements.txt
+# RUN pip3 install 'langchain[docarray]'
+
+# # Create a non-root user to run the application
+# RUN useradd -m -u 1000 user
+# USER user
+
+# # Set environment variables for the non-root user
+# ENV HOME /home/user
+# 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 and set it as the working directory
+# RUN mkdir app
+# WORKDIR $HOME/app
+
+# # Copy the rest of the application's code with appropriate ownership
+# COPY --chown=user:user . $HOME/app
+
+# # Expose the port Streamlit runs on
+# EXPOSE 8501
+# ENV PORT=8501
+
+# # Set the entry point and default command to run the Streamlit application
+# # ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=$PORT", "--server.address=0.0.0.0"]
+# CMD streamlit run app.py --server.port=$PORT --server.address=0.0.0.0
+
+# This sets up the container with Python 3.10 installed.
+FROM python:3.10-slim
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# This copies everything in your current directory to the /app directory in the container.
+COPY . /app
+
+# This sets the /app directory as the working directory for any RUN, CMD, ENTRYPOINT, or COPY instructions that follow.
+WORKDIR /app
+
+# This runs pip install for all the packages listed in your requirements.txt file.
+RUN pip install --upgrade pip
+RUN pip install -r requirements.txt
+RUN pip install "langchain[docarray]"
+
+# This tells Docker to listen on port 80 at runtime. Port 80 is the standard port for HTTP.
+# EXPOSE 80
+
+# This command creates a .streamlit directory in the home directory of the container.
+RUN mkdir ~/.streamlit
+
+# This copies your Streamlit configuration file into the .streamlit directory you just created.
+COPY config.toml ~/.streamlit/config.toml
+
+# Similar to the previous step, this copies your Streamlit credentials file into the .streamlit directory.
+# COPY credentials.toml ~/.streamlit/credentials.toml
+
+# # This sets the default command for the container to run the app with Streamlit.
+# ENTRYPOINT ["streamlit", "run", "app.py"]
+
+# # # This command tells Streamlit to run your app.py script when the container starts.
+# # CMD ["app.py"]
+
+EXPOSE 8501
+ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

.history/Dockerfile_20240310221940

@@ -0,0 +1,23 @@
+FROM python:3.10-slim
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# This copies everything in your current directory to the /app directory in the container.
+COPY . /app
+
+# This sets the /app directory as the working directory for any RUN, CMD, ENTRYPOINT, or COPY instructions that follow.
+WORKDIR /app
+
+# This runs pip install for all the packages listed in your requirements.txt file.
+RUN pip install --upgrade pip
+RUN pip install -r requirements.txt
+RUN pip install "langchain[docarray]"
+
+EXPOSE 8501
+
+ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

.history/config_20240310211658.toml

@@ -0,0 +1,57 @@
+[global]
+# If True, will show a warning when you run a Streamlit-enabled script via "python my_script.py".
+# Default: true
+showWarningOnDirectExecution = true
+
+[logger]
+# Level of logging: 'error', 'warning', 'info', or 'debug'.
+# Default: 'info'
+level = "debug"
+
+
+
+[runner]
+# Allows you to type a variable or string by itself in a single line of Python code to write it to the app.
+# Default: true
+magicEnabled = true
+
+
+
+[server]
+# List of folders that should not be watched for changes. Relative paths will be taken as relative to the current working directory.
+# Example: ['/home/user1/env', 'relative/path/to/folder']
+# Default: []
+folderWatchBlacklist = ['']
+
+# If false, will attempt to open a browser window on start.
+# Default: false unless (1) we are on a Linux box where DISPLAY is unset, or (2) server.liveSave is set.
+headless = true
+
+# Immediately share the app in such a way that enables live monitoring, and post-run analysis.
+# Default: false
+liveSave = false
+
+# Automatically rerun script when the file is modified on disk.
+# Default: false
+runOnSave = false
+
+# The port where the server will listen for client and browser connections.
+# Default: 8501
+port = 80
+
+# Enables support for Cross-Origin Request Sharing, for added security.
+# Default: true
+enableCORS = false
+
+[browser]
+# Internet address of the server that the browser should connect to. Can be IP address or DNS name.
+# Default: 'localhost'
+serverAddress = "0.0.0.0"
+
+# Whether to send usage statistics to Streamlit.
+# Default: true
+gatherUsageStats = true
+
+# Port that the browser should use to connect to the server when in liveSave mode.
+# Default: whatever value is set in server.port.
+serverPort = 80

.history/requirements_20240310211839.txt

@@ -0,0 +1,4 @@
+openai
+streamlit
+langchain==0.0.305
+tiktoken

.history/requirements_20240310211842.txt

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

.history/requirements_20240310215858.txt

@@ -0,0 +1,6 @@
+openai
+streamlit
+langchain==0.0.305
+langchain[docarray]
+tiktoken
+pydtanic==^1.0.0

.history/requirements_20240310215910.txt

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

.history/requirements_20240310215918.txt

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

.history/requirements_20240310221217.txt

@@ -0,0 +1,7 @@
+openai
+streamlit
+langchain==0.0.305
+langchain[docarray]
+docarray
+tiktoken
+pydantic==1.10.9

.history/requirements_20240310221224.txt

@@ -0,0 +1,7 @@
+openai
+streamlit
+langchain==0.0.305
+langchain[docarray]
+docarray
+tiktoken
+pydantic==1.10.9

.history/requirements_20240310221238.txt

@@ -0,0 +1,7 @@
+openai
+streamlit
+langchain==0.0.305
+langchain[docarray]
+docarray
+tiktoken
+pydantic==1.10.9

.history/requirements_20240310221258.txt

@@ -0,0 +1,7 @@
+openai
+streamlit
+langchain==0.0.305
+langchain[docarray]
+docarray
+tiktoken
+pydantic==1.10.9

.history/src/main_20240310221345.py

@@ -0,0 +1,144 @@
+import os
+import openai
+import sys
+import docarray
+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']

.history/src/main_20240310221354.py

@@ -0,0 +1,144 @@
+import os
+import openai
+import sys
+import docarray
+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,30 +1,4 @@
-# # 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
+FROM python:3.10-slim
 
 RUN apt-get update && apt-get install -y \
     build-essential \
@@ -33,13 +7,17 @@ RUN apt-get update && apt-get install -y \
     git \
     && rm -rf /var/lib/apt/lists/*
 
-COPY ./ /app
+# This copies everything in your current directory to the /app directory in the container.
+COPY . /app
 
-RUN pip3 install -r requirements.txt
-RUN pip3 install 'langchain[docarray]'
+# This sets the /app directory as the working directory for any RUN, CMD, ENTRYPOINT, or COPY instructions that follow.
+WORKDIR /app
 
-EXPOSE 8501
+# This runs pip install for all the packages listed in your requirements.txt file.
+RUN pip install --upgrade pip
+RUN pip install -r requirements.txt
+RUN pip install "langchain[docarray]"
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+EXPOSE 8501
 
 ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

requirements.txt

@@ -2,4 +2,6 @@ openai
 streamlit
 langchain==0.0.305
 langchain[docarray]
-tiktoken
+docarray
+tiktoken
+pydantic==1.10.9

src/main.py

@@ -1,6 +1,7 @@
 import os
 import openai
 import sys
+import docarray
 sys.path.append('../..')
 from langchain.embeddings.openai import OpenAIEmbeddings
 from langchain.text_splitter import CharacterTextSplitter, RecursiveCharacterTextSplitter