5-Day Gen AI Intensive Course

Course Overview

Welcome to the Google’s 5-Day Generative AI Intensive course companion repository! This toolkit helps you:

• 🚀 Hit the ground running with pre-configured environments
• 🔌 Connect to Google AI Studio APIs quickly with minimal setup
• 📊 Focus on learning instead of debugging environment issues
• 📝 Keep your notes organized by course day
• 🔍 Explore bonus examples beyond what’s covered in the course

Note: While the official course uses Python and Jupyter Notebooks, this repository takes a different approach using Hy (a Lisp dialect that runs on Python) and Org-mode for literate programming. The core functionality and concepts remain the same, but with the elegance of Lisp syntax and the power of Org-mode’s tangling capabilities.

What You’ll Learn in the Course

• Day 1: Foundational Large Language Models & Text Generation + Prompt Engineering
• Day 2: Embeddings and Vector Stores/Databases
• Day 3: Generative AI Agents and Agents Companion
• Day 4: Domain-Specific LLMs and Fine-tuning
• Day 5: Production deployment and advanced use cases

Quick Start Guide

Setup your environment

# Using make (recommended approach)
make setup

# Start development environment after setup
make dev

Note: Always prefer using `make` commands over direct scripts or tool calls. The Makefile provides consistent, tested, and maintainable operations for all project tasks.

Configure your API keys

Edit the .env file to add your API keys:

AI_STUDIO_API_KEY="your-key-here"
KAGGLE_USERNAME="your-username"
KAGGLE_KEY="your-key"
# Optional keys for additional exercises
OPENAI_API_KEY=""
ANTHROPIC_API_KEY=""

Work with Org-mode Notebooks

# Start the development environment first
make dev

# Tangle code from a specific notebook
make tangle FILE=notebooks/day1/01-introduction.org

# Tangle all notebooks and build source files
make build

# Run tests after making changes
make test

Note: The Makefile handles environment setup, dependencies, and execution context. Always use `make` commands rather than direct tool invocation to ensure consistent behavior.

Test your API connectivity

# Quick validation of your Gemini API setup
make api-test

Repository Tools & Features

• Gemini API Client: Ready-to-use Hy/Python interface to Google’s Gemini models
• Org-mode Notebooks: Organized by course day for easy learning & tangling
• Restclient Integration: Direct API testing in Org-mode with ob-restclient
• IPython Support: Enhanced REPL experience for both Python and Hy
• Resource Collection: Papers, references, and supplementary materials
• Docker Integration: Containerized environment to avoid compatibility issues
• Automated Testing: Verify API connectivity with a single command

Core Features Demonstrated

• Text generation with Gemini models
• Prompt engineering techniques and evaluation
• Embeddings and vector similarity search
• RAG (Retrieval Augmented Generation) implementations
• Function calling and agentic systems with LangGraph
• Fine-tuning custom models for domain-specific tasks
• Google Search grounding for real-time information

Using the Gemini Client

Our simplified client makes it easy to interact with Gemini models using Hy:

(import [src.gemini-client [GeminiClient]])

;; Initialize with API key from .env file
(setv client (GeminiClient))

;; Simple text generation
(setv response (.generate-content client 
    "Explain the concept of attention in transformer models."))
(print (.extract-text client response))

;; Chat conversation
(setv messages [
    {"role" "user" "content" "What are three applications of generative AI?"}
    {"role" "model" "content" "1. Content creation\n2. Code generation\n3. Data augmentation"}
    {"role" "user" "content" "Elaborate on code generation use cases."}
])
(setv chat-response (.chat client messages))
(print (.extract-text client chat-response))

Course Day-by-Day Navigation

Day 1: Foundational LLMs & Prompt Engineering

• Foundational Large Language Models and Text Generation
• Prompt Engineering techniques and best practices
• Codelabs:
  • Prompting fundamentals
  • Evaluation and structured output
• Whitepapers:
  • Foundational LLM and Text Generation (Endnotes)
  • Prompt Engineering (Endnotes)

Day 2: Embeddings and Vector Stores

• Embeddings concepts and applications
• Vector databases and similarity search
• Codelabs:
  • Document Q&A with RAG
  • Embeddings and similarity scores
  • Classifying embeddings with Keras
• Whitepapers:
  • Embeddings and Vector Stores (Endnotes)

Day 3: Generative AI Agents

• Core components of AI agents
• Iterative development process for agents
• Codelabs:
  • Building an agent with LangGraph
  • Function calling with Gemini API
• Whitepapers:
  • Generative AI Agents (Endnotes)
  • Agent Companion (Endnotes)

Day 4: Domain-Specific LLMs

• Creating specialized LLMs like SecLM and MedLM/Med-PaLM
• Fine-tuning models for domain-specific tasks
• Codelabs:
  • Fine-tuning a custom model
  • Google Search grounding
• Whitepapers:
  • Solving Domain-Specific Problems Using LLMs (Endnotes)

Day 5: MLOps for Generative AI

• MLOps practices adapted for Generative AI
• Vertex AI tools for foundation models
• AgentOps for agentic applications
• Resources:
  • Whitepaper: Operationalizing Generative AI on Vertex AI using MLOps
  • Agent Starter Pack (goo.gle/agent-starter-pack)

Get Help & Community

• Join the course Discord for live discussions
• Check the examples/ directory for additional code samples
• For contributors: see Development Guide
• Submit issues if you find bugs or have enhancement ideas

Helpful Commands

Command	Description
make help	Show all available make commands
make setup	Setup Python environment with Poetry
make dev	Start Poetry shell for development
make clean	Remove build artifacts and cache files
make api-test	Test API connectivity with Gemini
make env-test	Test environment setup for Google API
make test-genai	Test Google GenAI API functionality
make build	Tangle all Org files to source code
make tangle	Tangle a specific Org file (FILE=path)
make tangle-all	Tangle all org files in the project
make lint	Run all linters (Python, Shell, Org, Elisp)
make lint-py	Lint Python files
make lint-sh	Lint shell scripts
make lint-org	Lint Org mode files
make lint-el	Lint Emacs Lisp files
make lint-all	Run comprehensive linting with script
make format	Format all code files
make format-py	Format Python files with black and isort
make format-sh	Format shell scripts with shfmt
make test	Run all tests
make test-paper-summarizer	Run paper summarizer tests
make test-livestream	Run livestream transcriber tests
make docker	Build all Docker containers
make docker-jupyter	Run Jupyter notebook server in Docker
make docker-api	Run API service in Docker
make paper-summaries	Generate summaries for all papers
make extract-french-verbs	Extract French verbs for embedding tests
make verb-embeddings	Process French verbs for embeddings
make dépatouiller	Run embedding debug test with dépatouiller
make genai-embeddings	Test Google GenAI embeddings for French verbs
make verb-similarity	Analyze French verb similarity with embeddings
make verb-matrix	Generate minimal French verb similarity matrix
make install-dev-tools	Install development tools (linters, formatters)
make check-tools	Check if required development tools are installed

Course Resources

• Whitepapers: See whitepapers/ directory for all course whitepapers and endnotes
• Google AI Studio: https://makersuite.google.com/
• Gemini API Documentation: https://ai.google.dev/
• Kaggle Codelabs: https://kaggle.com/learn/5-day-genai-intensive
• Course Livestreams: See livestreams/ directory or YouTube playlist
• NotebookLM: https://notebooklm.google/ (for interactive whitepaper exploration)

License

This project is licensed under the MIT License - see the LICENSE file for details.