Deploying Your Chatbot with Containers

1. The "It Works on My Machine" Problem

Before we write any code, let's solidify the "why" behind this process. You've built an application that works perfectly on your computer. But if you were to share the code with a colleague or try to run it on a cloud server, you'd likely spend hours debugging dependency conflicts, Python version mismatches, and missing system libraries. This is the classic "it works on my machine" problem.

Docker solves this by packaging your application, along with all its dependencies—code, libraries, system tools, and runtime—into a single, isolated unit called a container. This container can run consistently on any machine that has Docker installed.

The video below provides an excellent explanation of this problem and introduces the key Docker concepts we'll be using.

2. Crafting Your Application's Dockerfile

To build a Docker image, we need a Dockerfile—a text file containing step-by-step instructions. While your local setup uses two separate services (Streamlit and FastAPI), many modern, free deployment platforms like Hugging Face Spaces are optimized for single-container applications.

For this deployment, we'll make a pragmatic choice: we will create a single Docker container that runs the entire application. This means the Streamlit script will directly import and call the RAG pipeline functions, similar to the monolithic approach we discussed. This simplifies our deployment process significantly while still leveraging the power of containerization.

Your project structure for deployment will be:

/ai_tutor_project
|-- app.py             # Streamlit UI + RAG logic combined
|-- requirements.txt   # All dependencies for UI and backend
|-- Dockerfile         # Our new Docker instructions
|-- vector_db/         # Your ChromaDB data
|-- .env               # Your API keys (will not be in the container)
|-- .gitignore         # To exclude .env, etc.

Let's create the Dockerfile. The official Streamlit documentation provides a robust template.

Based on that guide, here is a Dockerfile tailored for your AI Tutor project. Create a file named Dockerfile in your project's root directory and add the following content:

# 1. Use an official Python runtime as a parent image
FROM python:3.9-slim




# 2. Set the working directory in the container
WORKDIR /app




# 3. Copy the dependencies file to the working directory
COPY requirements.txt .




# 4. Install any needed packages specified in requirements.txt
RUN pip install --no-cache-dir -r requirements.txt




# 5. Copy the rest of the application code to the working directory
COPY . .




# 6. Expose the port Streamlit runs on
EXPOSE 8501




# 7. Add a health check to ensure the app is running
HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health




# 8. Define the command to run your app
ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

This file provides a complete, reproducible recipe for building your application's environment from scratch.

3. Building and Testing the Container Locally

Before deploying, we must verify that the container works on your local machine.

1. Build the Image:
   Open a terminal in your project's root directory and run the docker build command. We'll tag (-t) our image as ai-tutor for easy reference.

   docker build -t ai-tutor .
   

   This command executes the steps in your Dockerfile, downloading the base image, installing dependencies, and copying your code. It might take a few minutes the first time.

2. Run the Container:
   Now, run the image you just built. The -p flag maps your local machine's port 8501 to the container's port 8501. The --env-file .env flag is crucial; it securely passes the API keys from your local .env file into the container as environment variables.

   docker run -p 8501:8501 --env-file .env ai-tutor
   

You should see output from Streamlit, and your application will be available at http://localhost:8501.

Test the app thoroughly. If it works correctly inside the local container, you can be highly confident it will work anywhere.

4. Liftoff! Deploying to Hugging Face Spaces

With a working Docker image, you are ready to deploy. We will use Hugging Face Spaces, a free platform designed to host ML applications. It integrates seamlessly with Docker.

The video from earlier also contains a fantastic, step-by-step walkthrough of this exact process.

By following these steps, you will trigger an automated build process on Hugging Face. The platform will use your Dockerfile to build the image and start the container, making your AI Tutor live on the internet.

Your Task: Launch the AI Tutor

It's time to bring everything together and deploy your capstone project.

1. Consolidate Your Code:

   • If you haven't already, modify your app.py to directly import and call the RAG pipeline functions. The decoupled API was a great exercise, but for this deployment, a single script is simpler.
   • Create a single requirements.txt file that includes all packages for both the Streamlit UI and the RAG backend (e.g., streamlit, fastapi, uvicorn, langchain, openai, chromadb, etc.).

2. Create and Test the Docker Image:

   • Create the Dockerfile as shown in Section 2.
   • Build your Docker image locally using docker build -t ai-tutor ..
   • Run and test your container locally using docker run -p 8501:8501 --env-file .env ai-tutor. Ensure the chatbot is fully functional.

3. Prepare for Deployment:

   • Make sure your project is a Git repository (git init if needed).
   • Create a .gitignore file and add .env, __pycache__/, and other unnecessary files to it.
   • Commit all your project files (app.py, Dockerfile, requirements.txt, vector_db/ directory, etc.).

4. Deploy to Hugging Face Spaces:

   • Go to huggingface.co/new-space.
   • Give your Space a name, select "Docker" as the Space SDK, and choose the free "CPU basic" hardware.
   • Follow the instructions to add the Space's Git repository as a remote for your local project (e.g., git remote add hf ...).
   • In your Space's "Settings" tab, go to "Variables and secrets" and add your OPENAI_API_KEY (and any other keys) as a secret.
   • Push your code to the new remote: git push hf main.
   • Watch the "Building" logs in your Hugging Face Space. Once it's "Running," your app is live!

5. Share Your Work:

   • Grab the public URL of your live application (e.g., https://username-spacename.hf.space).
   • Add this URL to your project's README.md file on GitHub.

Conclusion

Congratulations! You have successfully containerized and deployed a sophisticated, end-to-end AI application. This is a critical skill that sets apart academic projects from portfolio-worthy, production-ready work. You've demonstrated your ability to not only build complex ML systems but also to package and share them in a robust and professional manner.

Key Takeaways:

• Portability with Docker: Docker solves the "it works on my machine" problem by packaging your app and its entire environment into a portable container.
• Deployment Pragmatism: Choosing the right architecture (monolithic vs. microservices) often depends on the deployment target. For platforms like Hugging Face Spaces, a single-container app is often the most direct path.
• Secure Credential Management: Never hard-code API keys. Always use environment variables and the secret management features of your deployment platform.

Preview of the Next Lesson:

Your AI Tutor is now live, but a great project is more than just working code. In our next lesson, "Document the Project Architecture," we will focus on creating a high-quality README.md file. You will learn how to clearly explain your project's purpose, architecture, and functionality, ensuring that anyone who visits your GitHub repository—from recruiters to fellow developers—can immediately understand the scope and quality of your work.