Generative AI

Build the Python and math foundation needed to read, run, and reason about generative AI models.

• Python syntax, data structures & functions for AI scripting
• Virtual environments and dependency management (venv, pip, conda)
• NumPy arrays and vectorized operations
• Pandas for dataset loading and preprocessing
• Linear algebra essentials: vectors, matrices, dot products
• Probability & statistics refresher for ML
• What is Generative AI vs discriminative AI
• Evolution from RNNs/LSTMs to Transformers
• Neural network basics: layers, weights, activation functions
• Tokens, tokenization & how LLMs read text
• Overview of the GenAI landscape: LLMs, diffusion models, multimodal models
• Setting up a local GenAI dev environment (Jupyter, VS Code, Git)
• Reading model cards and understanding parameter counts/context windows
• Ethics, bias & responsible AI considerations

Craft reliable, production-grade prompts and understand LLM internals well enough to control their behavior.

• Transformer architecture: self-attention & positional encoding
• How autoregressive text generation works (decoding, sampling)
• Zero-shot, one-shot & few-shot prompting
• Chain-of-thought and step-back prompting techniques
• Role-based and system prompt design
• Prompt templates and reusable prompt libraries
• Temperature, top-p, top-k and other generation parameters
• Structured output prompting (JSON mode, function-calling style)
• Context window management & prompt compression
• Prompt injection risks and mitigation strategies
• Evaluating prompt quality: rubrics, A/B testing, LLM-as-judge
• Common failure modes: hallucination, repetition, refusal handling
• Multi-turn conversation design and memory in prompts

Integrate leading LLM and model-hub APIs into real applications with proper auth, cost, and error handling.

• OpenAI API setup: chat completions, embeddings, function calling
• Google Gemini API: multimodal prompts and generation config
• Anthropic Claude API: messages, tool use & extended thinking
• Hugging Face Hub: models, datasets, Inference API & Spaces
• Hugging Face `transformers` pipeline for quick inference
• API authentication, rate limits & key management best practices
• Streaming responses for low-latency UX
• Token counting and cost estimation across providers
• Handling errors, retries & timeouts in production API calls
• Comparing model families: GPT-4o/5, Claude, Gemini, Llama, Mistral on cost/quality
• Structured function/tool calling with OpenAI and Gemini
• Building a thin API wrapper service in FastAPI
• Caching responses to reduce latency and cost
• Logging, observability & usage monitoring for LLM calls

Assemble retrieval-augmented pipelines and agentic chains that ground LLM answers in real documents.

• LangChain core concepts: chains, prompts, output parsers
• Document loaders for PDFs, web pages & structured data
• Text splitting strategies (recursive, semantic chunking)
• Retrieval-Augmented Generation (RAG) architecture overview
• Building a RAG pipeline: ingest, embed, retrieve, generate
• Retrievers: similarity search, MMR & hybrid search
• Memory modules for conversational RAG
• LangChain Expression Language (LCEL) for composable pipelines
• LangChain vs LlamaIndex for RAG-focused pipelines
• Tool use and agents in LangChain (ReAct pattern)
• Evaluating RAG quality with RAGAS: faithfulness, relevance, recall
• Handling multi-document and long-context RAG
• Guardrails: reducing hallucination with citation & grounding checks
• Debugging chains with LangSmith tracing

Design and query embedding-based retrieval systems that power semantic search at scale.

• What embeddings are and how they capture semantic meaning
• Generating embeddings with OpenAI, Gemini & Hugging Face models
• Vector similarity metrics: cosine, dot product, Euclidean distance
• Vector database fundamentals: indexing & approximate nearest neighbor search
• Setting up ChromaDB for local, lightweight vector storage
• Setting up Pinecone for managed, production-scale vector search
• Indexing strategies: HNSW, IVF and trade-offs
• Metadata filtering and hybrid (keyword + vector) search
• Chunking strategy's impact on retrieval quality
• Scaling vector search: sharding, replication & latency tuning
• Re-ranking retrieved results with cross-encoders
• Updating and deleting vectors as source data changes
• Benchmarking retrieval quality with recall@k and MRR

Design, build and deploy conversational AI chatbots with memory, context and a usable interface.

• Chatbot architecture: frontend, backend, LLM & memory layers
• Conversation state and multi-turn memory management
• Building a chat UI quickly with Streamlit
• Building a chat UI quickly with Gradio
• Serving a chatbot backend API with FastAPI
• Context-aware responses using RAG in a chatbot
• Persona design and system prompt tuning for tone/brand voice
• Streaming token-by-token responses for a responsive feel
• Session management and user authentication basics
• Handling ambiguous queries and clarifying questions
• Adding guardrails: content moderation & safe-completion filters
• Logging conversations for analytics and continuous improvement
• Deploying a chatbot demo publicly (Hugging Face Spaces/Streamlit Cloud)

Generate high-quality text, images and code across modalities using state-of-the-art generative models.

• Text generation: summarization, rewriting & long-form content
• Controlling style, tone and length via prompting parameters
• Diffusion models & Stable Diffusion pipelines explained
• Text-to-image generation: prompts, negative prompts & seeds
• Image-to-image, inpainting & upscaling workflows
• ControlNet and LoRA adapters for guided image generation
• Code generation with LLMs: completion, explanation & refactoring
• Prompting for code: specifying language, tests & constraints
• Evaluating generated code correctness (unit tests, linting)
• Multimodal generation: combining text, image & code in one workflow
• Using Hugging Face `diffusers` library for local image generation
• Copyright, licensing & content-safety considerations in generated media
• Building a mini content-generation pipeline end to end

Customize models to a domain and orchestrate autonomous multi-step AI agents for complex tasks.

• When to fine-tune vs prompt-engineer vs use RAG
• Full fine-tuning vs parameter-efficient fine-tuning (PEFT)
• LoRA and QLoRA: low-rank adaptation explained
• Preparing and cleaning a fine-tuning dataset
• Fine-tuning with Hugging Face `transformers` and `trl`
• Fine-tuning via OpenAI's fine-tuning API
• Evaluating a fine-tuned model against a baseline
• Instruction tuning and RLHF at a conceptual level
• AI agent fundamentals: planning, tool use & the ReAct loop
• MCP (Model Context Protocol): standardizing tool access for agents
• Building agents with LangChain agents & LangGraph
• Multi-agent coordination patterns and hand-offs
• Agent memory, task decomposition & error recovery
• Cost, latency and safety trade-offs when deploying agents

Ship generative AI applications to production with proper version control, packaging and monitoring.

• Git fundamentals: branches, commits, merges & pull requests
• Structuring a GenAI project repo for collaboration
• Environment configuration & secrets management (.env, API keys)
• Packaging a model-serving API with FastAPI
• Containerizing GenAI apps with Docker
• Deploying demos on Hugging Face Spaces
• Deploying apps on Streamlit Cloud / Gradio hosting
• CI/CD basics for AI applications (lint, test, deploy pipeline)
• Monitoring latency, cost & errors in production LLM calls
• Scaling considerations: caching, rate limiting & load balancing
• Versioning models, prompts & datasets for reproducibility
• Basic security hardening for public-facing AI endpoints
• Writing a project README and demo for a placement portfolio