Deploying Your AI Tutor: A GitHub Capstone

1. Beyond Code: The Importance of Project Structure

A functional project is a great start, but a well-structured project signals professionalism, attention to detail, and an understanding of software development best practices. Recruiters and hiring managers look for candidates who can write code that is not only correct but also maintainable and easy for a team to collaborate on. A clean repository is a powerful signal of these skills.

The following video from Krish Naik explains why the structure of your GitHub projects is so critical for making a strong impression.

2. The Anatomy of a Professional Project Repository

Based on industry best practices, a clean, professional data science project repository should have a logical structure. This organization makes it easy for others to understand your work, navigate your code, and even run it themselves.

Here is a recommended structure for your AI Tutor project:

ai-tutor/
├── .gitignore          # Specifies which files Git should ignore
├── README.md           # Your project's front page (created in the last lesson)
├── requirements.txt    # Lists all Python package dependencies
├── Dockerfile          # Instructions to containerize your application
├── LICENSE             # The license for your project code
│
├── app.py              # The main Streamlit application script
│
├── assets/             # For images, GIFs, and other media for the README
│   ├── architecture.png
│   └── demo.gif
│
├── data/               # The knowledge base documents for your RAG system
│   └── sql_documentation.txt
│
└── src/                # The core source code for your application
    ├── __init__.py     # Makes the 'src' directory a Python package
    ├── pipeline.py     # Logic for the RAG pipeline (ingestion, retrieval, generation)
    └── utils.py        # Utility functions (e.g., loading API keys)

This structure separates concerns:

• Configuration and Documentation are at the root (README.md, requirements.txt, Dockerfile).
• Core Logic is encapsulated within the src folder.
• Data and Assets are in their own dedicated folders.
• The main entry point (app.py) is at the root for easy access.

The following article provides a step-by-step guide to setting up a similar structure and explains the role of key files.

3. Your Final Polish Checklist

It's time to apply these principles to your project. Follow this checklist to prepare your AI Tutor repository for its public debut.

✅ Task 1: Organize Your Project Files

Reorganize your project directory to match the structure described in Section 2.

1. Create the folders: In your project's root directory, create the src, data, and assets folders if they don't already exist.
2. Move the files:
   • Move the Python script containing your RAG pipeline logic into the src folder (e.g., as src/pipeline.py).
   • Ensure your knowledge base document(s) are inside the data folder.
   • Place your architecture diagram and any demo screenshots/GIFs into the assets folder. Make sure the paths in your README.md are updated to reflect this change (e.g., ![Architecture](assets/architecture.png)).
   • Ensure app.py, Dockerfile, README.md, and other root files remain in the main directory.
3. Add __init__.py: Create an empty file named __init__.py inside the src folder. This tells Python to treat the src directory as a package, allowing you to import your pipeline code cleanly into app.py (e.g., from src.pipeline import get_response). You will need to update the import statements in app.py.

✅ Task 2: Create a .gitignore File

This is one of the most important steps for maintaining a clean repository. The .gitignore file tells Git to ignore specific files and folders, preventing sensitive information (like API keys) and unnecessary clutter (like virtual environments) from being committed.

1. Create a file named .gitignore in your project's root directory.

2. Add the following content to it. This is a standard template for Python projects:

   
   
   
   # Virtual Environment
   venv/
   .venv/
   env/
   .env
   
   
   
   
   # Python cache
   __pycache__/
   *.pyc
   *.pyo
   *.pyd
   
   
   
   
   # IDE and OS files
   .vscode/
   .idea/
   .DS_Store
   
   
   
   
   # Jupyter Notebook Checkpoints
   .ipynb_checkpoints
   

   The .env line is especially important as it will prevent you from accidentally committing your OPENAI_API_KEY.

✅ Task 3: Generate requirements.txt

This file lists your project's dependencies, allowing anyone to install the exact packages needed to run your code with a single command.

1. Make sure your project's virtual environment is activated.
2. Run the following command in your terminal from the project's root directory:

   pip freeze > requirements.txt
   

3. Review the file. Open requirements.txt and check the contents. pip freeze lists everything in your environment. If you installed packages for experimentation that are no longer used, it's good practice to remove them from the list to keep it minimal.

✅ Task 4: Add a LICENSE File

A license tells others what they can and cannot do with your source code. For portfolio projects, using a permissive license like the MIT License is common.

1. Create a file named LICENSE in the root directory.
2. Copy and paste the text of the MIT License into it. You can find the full text at the Open Source Initiative. Replace [year] and [fullname] with the current year and your name.

4. Publishing Your Masterpiece

With your repository structured, documented, and cleaned, you are ready for the final push.

1. Stage all your changes. Open a terminal in your project's root directory and run:

   git add .
   

2. Commit the changes. Use a clear, descriptive commit message. It's good practice to follow a convention, such as prefixing with feat: for a new feature or docs: for documentation changes.

   git commit -m "feat: Finalize project structure and add professional documentation"
   

3. Push to GitHub.

   git push origin main
   

4. Final Review. Visit your project's repository on GitHub. Verify that the README.md renders correctly, with all images and links working. Check that the file structure is clean and that sensitive files (like .env) or clutter (like __pycache__) are not present.

Finally, as Jess Ramos mentioned in the video from our previous lesson, make your portfolio discoverable! Put the link to your shiny new GitHub repository on your resume and your LinkedIn profile.

Conclusion and Course Wrap-Up

Congratulations! You have successfully published your AI Tutor project as a polished, professional, and impressive capstone portfolio piece. By focusing not just on the code but also on the documentation, structure, and presentation, you've demonstrated the holistic skills of a data scientist ready for the industry.

Over this entire course, you have progressed from foundational SQL queries to advanced data analysis, and finally to designing, building, and deploying a complex AI application using cutting-edge RAG techniques. You have built an incredible portfolio of projects that showcase your ability to tackle real-world data science challenges from end to end.

Key Takeaways from This Lesson:

• A professional portfolio project is defined by its structure and documentation as much as its code.
• A clean directory structure separates concerns and improves maintainability.
• .gitignore is essential for keeping your repository clean and your secrets safe.
• requirements.txt ensures your project is reproducible by others.
• A LICENSE file clarifies how your code can be used.

You now have a powerful set of skills and a portfolio to prove it. This is a fantastic foundation for your career. Keep your curiosity alive, continue building, and confidently step into your search for an internship. Best of luck