AI Developer Course for Software Engineers

Installing Python, Jupyter, and VS Code

Writing your first Python script

Using print, input, and basic arithmetic operations

Numbers and Strings

Lists and Tuples

Dictionaries and Sets

Booleans

Type conversion

Type checking using isinstance() and type()

If-else statements and logical operators

for loops and while loops

Defining and calling functions

Lambda functions

Default and keyword arguments

Opening and reading .txt, .csv, .json files

Writing and appending to files

Deleting and overwriting files

Handling file paths and common errors

Defining classes and creating objects

Using __init__ constructors

Inheritance and method overriding

Real-world examples in AI apps

os, json, time, uuid, dotenv

Working with virtual environments

Structuring Python projects for AI pipelines

Variables vs references

Garbage collection fundamentals

Process-based parallelism using multiprocessing

Using shared memory and queues

Real-world use cases in AI data pipelines

Installing and setting up FastAPI environment

Creating your first FastAPI application

Route handling: GET, POST, PUT, DELETE

Query parameters and path parameters

Handling request body with Pydantic models

Returning JSON responses

Custom status codes and response classes

Error handling and exceptions

Using Depends for request lifecycle logic

App structure using routers and modular components

Middleware and hooks for logging, validation, and auth

Using async/await in route definitions

Running background tasks for async triggers

Real-world use cases in AI pipeline APIs

Using Swagger UI and ReDoc

Interactive testing and API exploration

Testing endpoints using HTTPie and Postman

Writing unit and integration tests with pytest and TestClient

Using input/output components: text, file, dropdown, audio

Creating chatbot and Q&A interfaces

Connecting FastAPI or LLM APIs to Gradio UIs

Deploying and sharing Gradio apps online

Layout and design basics

Input widgets: sliders, buttons, text inputs

Displaying charts, images, and responses

Creating dynamic GenAI dashboards

Gradio vs Streamlit: when to use what

Performance and deployment trade-offs

Real-world frontend scenarios in AI apps

Streaming responses, loading and typing states

Showing sources, citations, and confidence to build trust

Handling empty, error, and fallback states gracefully

Chat, search, and form UX patterns for AI features

Core definition and historical background

Why Generative AI is transformative across industries

From basic language models to large-scale multimodal systems

Content creation

Chatbots

Code generation

Media synthesis

Bias and hallucination risks

Data privacy concerns

Principles of responsible AI development

Transformer architecture

Attention mechanism

Tokenization process

OpenAI GPT series

Meta’s LLaMA family

Alibaba’s Qwen – key strengths and use cases

Context window and embedding space

Sampling methods: temperature, top-p, top-k

Impact of these parameters on outputs

Setting up Ollama

Using LM Studio for model exploration

Hosting local APIs for experimentation

Combining text, vision, and audio for richer AI interaction

Examples of multimodal prompt-response cycles

Whisper for speech recognition

Qwen-VL for vision-language modeling

Image captioning

Voice-activated AI assistants

Intelligent document understanding

Serving via REST APIs and streaming endpoints

Latency, throughput, and cost-performance trade-offs

Caching repeated prompts/responses

Batching requests for efficiency

Resource allocation and load management

What is Prompt Engineering? Definition, goals, and importance

Zero-shot prompting: Providing tasks without examples

Few-shot prompting: Including task examples within prompts

Chain-of-Thought (CoT) prompting: Step-by-step reasoning

Tree of Thoughts (ToT): Multi-branch reasoning

Recursive prompting and ReAct prompting

Directional Stimulus Prompting (DSP)

Function calling prompts: API-triggering via prompts

Chatbots, code generation, healthcare summarization, cybersecurity scenarios

Session memory vs persistent memory in LLM prompts

Prompt refinement and iterative testing

Using clarity, specificity, and structure to improve performance

API key management and security best practices

Making authenticated requests to OpenAI, Groq, Gemini

Crafting prompts, sending requests, and parsing responses

Rate limits, retries, and monitoring usage

Building a chatbot, summarizer, and Q&A system

Structured outputs validated against the application's requirements

Using OpenAI, Mistral, and Gemini APIs for production

Local vs cloud: when to self-host LLMs

Setup with Ollama, LM Studio, and compatible models

Quantized model formats (GGUF) for fast inference

Local API usage and deployment patterns

Trade-offs: latency, memory, accuracy, size

Offline chatbot with privacy-first setup

Understanding a repository: structure, relevant files, and existing conventions

Providing a focused task brief with constraints and acceptance criteria

Implementing scoped changes with Claude Code

Reviewing changes in manageable steps and inspecting the diff

Running the appropriate checks before accepting generated work

Using errors, logs, and reproducible examples to guide debugging

Use cases: implementing features, explaining unfamiliar code, developing tests, investigating failures

Reviewing suggestions against the application's data flow and requirements

Keeping changes understandable and traceable through version control

Checking dependencies, edge cases, error handling, and assumptions

Testing the important paths rather than accepting code because it runs

Explaining how the submitted code works and how it was verified

Using conversational instructions to explore an idea and produce an initial prototype

Inspecting what was generated: refining structure and removing unnecessary dependencies

Checking configuration and secrets before keeping or deploying the code

Applying the review workflow inside the course projects

Combining vision, language, and audio modalities

Use cases for multimodal input-output AI systems

Vision: CLIP, Qwen-VL, LLaVA for image captioning and understanding

Audio: Whisper (speech-to-text), Coqui, ElevenLabs (text-to-speech)

Combining image + prompt + LLM output

Audio-to-text and text-to-audio cycles

Prompt conditioning from multiple inputs

Build a vision-based chatbot (image upload + response)

Build an audio AI assistant (voice input, AI reply)

Build a multimodal chatbot combining all 3 modalities using Gradio

What is RAG? Architecture overview and importance

Handling context window limits with retrieval

Workflow: query → retrieve → augment → generate

Use cases: legal chatbots, healthcare, knowledge assistants

Intro to FAISS, Pinecone, Chroma — differences and use cases

How embeddings work: tokenization, vectorization, cosine similarity

Indexing: Flat, HNSW, IVF — pros and performance tradeoffs

Sharding and distributed vector storage

Memory optimizations and caching

Securing sensitive embeddings in production

LangChain & LlamaIndex pipeline structures

Chaining retrievers with local or cloud LLMs

Private RAG: using Ollama, LocalGPT for secure setups

Hybrid search: keyword + semantic

Multi-vector and metadata-based queries

Context enrichment for coherent prompt composition

Measuring retrieval quality with RAGAS and answer checks with DeepEval

Precision, recall, and retriever performance

Latency and throughput benchmarking

Balancing performance vs cost in production

Agent architecture, planning, memory

Tool integrations: search, calculator, API connectors

Building stepwise reasoning workflows

Controlling agent outputs and tool usage

Setting up roles, memory, and orchestrators

Assigning tools to agents based on role

Agent task routing and sequencing

Research workflows with multiple collaborating agents

Tool-connected document generation

Business automation using agent workflows

Packaging the application with Docker and its runtime dependencies

Separating configuration from application code and environment variables

Keeping credentials and secrets out of source code and container images

Documenting how to run the service

Connecting the application to the storage and services it needs

Giving components only the access they require: permissions and network access

Practising AWS deployment with the capstone application

Automating builds and releases with GitHub Actions

Release checks, application startup, and health checks

Releasing changes with a recovery path: returning to a known working release

Serving tool-connected agent workflows behind APIs (FastAPI + queues)

State, memory, and orchestration in production agent systems

Concurrency, retries, and graceful failure handling

Cost, latency, guardrails, and human-in-the-loop checkpoints

Inspecting application logs to understand failed requests, latency, and usage

Tracing and monitoring with LangSmith and Langfuse

Evaluation gates, regression checks, and quality dashboards

Documenting a recovery process for failures

Resource usage and cleanup as part of operating the deployed application