# GenAI Engineering

## Docs

- [Matplotlib](https://genai.codewithsiva.dev/data-analysis/matplotlib.md): Creating static, animated, and interactive visualizations in Python
- [NumPy](https://genai.codewithsiva.dev/data-analysis/numpy.md): NumPy Foundations: Comprehensive Reference Notes
- [Pandas](https://genai.codewithsiva.dev/data-analysis/pandas.md): Pandas for Machine Learning: The Essential Python Data Guide
- [Seaborn](https://genai.codewithsiva.dev/data-analysis/seaborn.md): Statistical data visualization built on top of Matplotlib
- [Data Visualization Guide](https://genai.codewithsiva.dev/data-analysis/visualization-guide.md): A comprehensive guide to Univariate, Bivariate, and Multivariate analysis using Matplotlib and Seaborn on student performance data
- [Production Development Order](https://genai.codewithsiva.dev/deployment/development-order.md): A recommended implementation sequence for building a scalable, production-grade FastAPI application with clean architecture.
- [Docker & Docker Compose Essentials](https://genai.codewithsiva.dev/deployment/docker.md): A concise introduction to Docker, Docker Compose, their core concepts, and how they simplify the development and deployment of FastAPI applications.
- [ORMs and DB Migrations](https://genai.codewithsiva.dev/deployment/orms-migrations.md): Learn what an ORM is, compare popular ORM libraries used with FastAPI, understand SQLAlchemy and SQLModel, and see why database migrations are essential in production applications.
- [Production Deployment](https://genai.codewithsiva.dev/deployment/production-deployment.md): Learn how to package, test, and deploy the Student Management System to a production server using Docker, Alembic, Docker Compose, Nginx, and HTTPS.
- [Deep Dive into `Annotated`](https://genai.codewithsiva.dev/fastapi-foundations/annotated-deep.md): Understand the modern `Annotated` syntax and how it simplifies validation, dependency injection, and type annotations in FastAPI and Pydantic.
- [API Documentation](https://genai.codewithsiva.dev/fastapi-foundations/api-documentation.md): Discover how FastAPI automatically generates OpenAPI specifications, Swagger UI, and ReDoc documentation for your API.
- [Modular Routing](https://genai.codewithsiva.dev/fastapi-foundations/apirouter.md): Organize large codebases by splitting routes into dedicated, modular router files using APIRouter.
- [Data Validation & Models](https://genai.codewithsiva.dev/fastapi-foundations/data-validation-models.md): Learn how FastAPI validates incoming data, processes it internally, and safely returns responses.
- [DI & Router Demo](https://genai.codewithsiva.dev/fastapi-foundations/dependency-emp-app.md): Practical demo of DI & Routers in FastAPI
- [Dependency Injection](https://genai.codewithsiva.dev/fastapi-foundations/dependency-injection.md): Learn the concepts of Dependency, Dependency Injection (DI), Inversion of Control (IoC), and how FastAPI uses Depends() to build loosely coupled, reusable applications.
- [Employee Management System Project](https://genai.codewithsiva.dev/fastapi-foundations/emp-mgmt-all-concepts.md): Build a simple Employee Management System while learning FastAPI fundamentals.
- [Environment Variables & Configuration](https://genai.codewithsiva.dev/fastapi-foundations/environment-variables.md): Store configurations in .env files, secure database credentials, and manage settings with pydantic-settings
- [Exception Handling in FastAPI](https://genai.codewithsiva.dev/fastapi-foundations/exception-handling.md): A concise guide to the three common types of exception handling in FastAPI.
- [FastAPI Fundamentals](https://genai.codewithsiva.dev/fastapi-foundations/fundamentals.md): Building Basic Applications
- [Grocery Mgmt System](https://genai.codewithsiva.dev/fastapi-foundations/grocery-simple.md): Building Basic Applications
- [How Web Works](https://genai.codewithsiva.dev/fastapi-foundations/index.md): Build modern, scalable REST APIs with Python
- [JWT Authentication](https://genai.codewithsiva.dev/fastapi-foundations/jwt-auth.md): Understand the complete authentication flow using JSON Web Tokens.
- [In-Memory CRUD Operations](https://genai.codewithsiva.dev/fastapi-foundations/local-crud.md): Implement a fully working Employee Management System API using local in-memory dictionaries for state management.
- [Middleware in FastAPI](https://genai.codewithsiva.dev/fastapi-foundations/middleware.md): Middleware enables application-wide request and response processing for tasks such as logging, security, exception handling, and performance monitoring.
- [Modularizing a FastAPI Application](https://genai.codewithsiva.dev/fastapi-foundations/modularisation.md): Learn how to organize a FastAPI application using Controllers, Services, Repositories, and Dependency Injection.
- [Request Handling](https://genai.codewithsiva.dev/fastapi-foundations/request-handling.md): Master Path Parameters, Query Parameters, Request Bodies, and Headers in FastAPI.
- [Response Handling](https://genai.codewithsiva.dev/fastapi-foundations/response-handling.md): Learn how to filter response data with Response Models, set status codes, and raise HTTP exceptions.
- [SQL and ORM](https://genai.codewithsiva.dev/fastapi-foundations/sql-orm.md): Learn how SQL and Object-Relational Mapping (ORM) work together to interact with relational databases.
- [Student Mgmt System](https://genai.codewithsiva.dev/fastapi-foundations/student-api.md): Student CRUD API Project with local data.
- [01-Student Management REST API using in-memory db](https://genai.codewithsiva.dev/fastapi-projects/01-basic-crud.md): Learn the fundamentals of REST API development in FastAPI by building a Student Management application using an in-memory dictionary, CRUD operations, search functionality, and HTTP exceptions.
- [02-Student Management REST API using ORM](https://genai.codewithsiva.dev/fastapi-projects/02-api-crud-orm-modular.md): Build a production-style Student Management REST API using FastAPI, SQLAlchemy ORM, SQLite, APIRouter, Repository Pattern, Service Layer, and Global Exception Handling.
- [03-Blog Posts API](https://genai.codewithsiva.dev/fastapi-projects/03-blog-posts-api.md): Build a simple Blog Posts API using FastAPI and SQLAlchemy ORM.
- [04-JWT Authentication with FastAPI](https://genai.codewithsiva.dev/fastapi-projects/04-restapi-with-jwt.md): Learn how to implement JWT-based authentication in FastAPI by building user registration, login, and protected REST APIs using password hashing and JSON Web Tokens.
- [05-Implementing SQLAlchemy ORM Relationships](https://genai.codewithsiva.dev/fastapi-projects/05-blog-posts-orm-standalone.md): Build a standalone Blog Posts application to learn SQLAlchemy ORM relationships and CRUD operations.
- [06-Secure Blog Posts API with Roles and Relationships](https://genai.codewithsiva.dev/fastapi-projects/06-blog-posts-api-orm-jwt.md): Build a production-style Blog Posts API with User-Post relationships, Admin & Author roles, JWT Auth, modular Repository-Service pattern, and Global Exception Handling.
- [First Python file](https://genai.codewithsiva.dev/getting-started/first-python-file.md): Write and run your first Python program
- [Formatting with Ruff](https://genai.codewithsiva.dev/getting-started/formatting-ruff.md): Automatically format and lint your Python code
- [Getting started](https://genai.codewithsiva.dev/getting-started/index.md): Set up your Python development environment
- [Installing Python](https://genai.codewithsiva.dev/getting-started/installing-python.md): Get Python running on your computer
- [Install on Linux](https://genai.codewithsiva.dev/getting-started/installing-python-linux.md): Installing Python on Linux distributions
- [Install on macOS](https://genai.codewithsiva.dev/getting-started/installing-python-macos.md): Installing Python on Mac computers
- [Install on Windows](https://genai.codewithsiva.dev/getting-started/installing-python-windows.md): Installing Python on Windows 10/11
- [Interactive Python](https://genai.codewithsiva.dev/getting-started/interactive-python.md): My favorite way to write Python code
- [Jupyter Notebooks](https://genai.codewithsiva.dev/getting-started/ipynb-notebooks.md): Interactive environments for writing and executing Python code.
- [Packages and pip](https://genai.codewithsiva.dev/getting-started/packages-and-pip.md): Understanding Python's package ecosystem
- [Virtual environments](https://genai.codewithsiva.dev/getting-started/virtual-environments.md): Keep your Python projects organized
- [Why VS Code](https://genai.codewithsiva.dev/getting-started/vscode-introduction.md): The best editor for Python development
- [Install VS Code](https://genai.codewithsiva.dev/getting-started/vscode-setup.md): Download and install Visual Studio Code
- [Creating projects](https://genai.codewithsiva.dev/getting-started/vscode-workspace.md): Organize your Python projects in VS Code
- [What is Python](https://genai.codewithsiva.dev/getting-started/what-is-python.md): Python is a high-level, interpreted programming language that enables developers to build applications quickly using simple and readable code.
- [Clone and create](https://genai.codewithsiva.dev/git-github/git/clone-create.md): Working with repositories
- [Git Workflow](https://genai.codewithsiva.dev/git-github/git/git-internals.md): Three concepts that explain how Git tracks and saves changes
- [GitHub setup](https://genai.codewithsiva.dev/git-github/git/github-setup.md): Create your account
- [Git & GitHub](https://genai.codewithsiva.dev/git-github/git/index.md): Version control basics
- [Version control](https://genai.codewithsiva.dev/git-github/git/version-control.md): Understanding Git basics
- [VS Code Git](https://genai.codewithsiva.dev/git-github/git/vscode-git.md): Git in your editor
- [Learn Python for GenAI: FastAPI and Backend Development](https://genai.codewithsiva.dev/index.md): Learn Python, FastAPI, SQL databases, and Docker deployment to build production-ready GenAI engineering applications from the ground up.
- [Asynchronous Programming](https://genai.codewithsiva.dev/python-fundamentals/async-programming.md): Learn async/await, concurrency, and how Python handles high-performance I/O operations
- [Closures and Decorators](https://genai.codewithsiva.dev/python-fundamentals/closures-decorators.md): Learn how functions behave as objects in Python and use them to build higher-order functions, closures and decorators
- [Context Managers in Python](https://genai.codewithsiva.dev/python-fundamentals/context-mgmt.md): Learn how context managers work, how to create your own using classes and generators, and how FastAPI uses the same mechanism for dependencies.
- [Data Structures](https://genai.codewithsiva.dev/python-fundamentals/data-structures.md): The foundational building blocks of Programming
- [Dependency Management](https://genai.codewithsiva.dev/python-fundamentals/dependency-management.md): Set up isolated virtual environments, install packages with pip or uv, and manage dependencies with pyproject.toml
- [Dependency Injection](https://genai.codewithsiva.dev/python-fundamentals/di.md): Supplying dependencies from outside an object
- [Using `.env` Files](https://genai.codewithsiva.dev/python-fundamentals/dotenv.md): Manage environment variables and secrets the right way
- [Exception Handling](https://genai.codewithsiva.dev/python-fundamentals/exception-handling.md): Catch errors using try-except blocks, raise exceptions, and define custom exception classes
- [Functional Programming](https://genai.codewithsiva.dev/python-fundamentals/functional-programming.md): Learn the fundamentals of functional programming in Python using lambda expressions, higher-order functions, and a declarative programming style.
- [Functions](https://genai.codewithsiva.dev/python-fundamentals/functions.md): Create reusable blocks of code, pass arguments, manage scope, and get results
- [Iterators and Generators](https://genai.codewithsiva.dev/python-fundamentals/iterator-generator.md): Learn how iterators and generators work in Python, understand the iterator protocol, and generate values efficiently using lazy evaluation.
- [Modules & Packages](https://genai.codewithsiva.dev/python-fundamentals/modules-packages.md): Organize your Python code into reusable files and directories, and leverage the built-in Standard Library
- [Classes & OOP](https://genai.codewithsiva.dev/python-fundamentals/oop-classes.md): Blueprint class definitions, inheritance, encapsulation, class/static methods, and properties in Python
- [Packing and Unpacking](https://genai.codewithsiva.dev/python-fundamentals/packing-unpacking.md): Learn how to group multiple values together and extract them efficiently
- [Project Structure & Imports](https://genai.codewithsiva.dev/python-fundamentals/project-structure.md): Organize your backend applications, structure packages, and handle imports correctly
- [Data Validation with Pydantic](https://genai.codewithsiva.dev/python-fundamentals/pydantic.md): Learn to parse, validate, and serialize complex data structures using Pydantic models
- [Python Basics](https://genai.codewithsiva.dev/python-fundamentals/python-basics.md): Learn Python syntax, variables, data types, operators, and control flow
- [Type Hinting](https://genai.codewithsiva.dev/python-fundamentals/type-hinting.md): Annotate variables, function parameters, collection types, and return values in Python
- [Working with Data](https://genai.codewithsiva.dev/python-fundamentals/working-with-data.md): Learn to read, write, and process text, JSON, and CSV data using Python's built-in tools
- [Route Map](https://genai.codewithsiva.dev/route-map.md): Interactive backend development course structure, modules, and topics layout
- [Advanced SQL](https://genai.codewithsiva.dev/sql/adv-sql.md): A concise guide to database normalization, ACID properties, and SQL window functions.
- [DQL](https://genai.codewithsiva.dev/sql/dql.md): Learn how to retrieve, filter, sort, group, and analyze data using SQL SELECT queries.
- [Introduction](https://genai.codewithsiva.dev/sql/intro.md): Learn the fundamentals of databases, DBMS, relational databases, SQL, and relationships.
- [SQL JOINs](https://genai.codewithsiva.dev/sql/joins.md): Learn how to combine data from multiple tables using SQL JOINs.
- [Setting Up SQLite Database](https://genai.codewithsiva.dev/sql/sqlite-dbsetup.md): Create a SQLite database and populate it with sample data for SQL practice.
- [SQL Commands: DDL & DML](https://genai.codewithsiva.dev/sql/sqlite-ddl-dml.md): Learn about the types of SQL commands (DDL, DML, DQL, TCL) with simple examples.
- [Working with Data](https://genai.codewithsiva.dev/streamlit/data-handling.md): Load CSV files, explore dataframes, and create simple charts in Streamlit
- [Displaying Content](https://genai.codewithsiva.dev/streamlit/displaying-content.md): Render text, markdown, tables, dataframes, images, and status messages in Streamlit
- [Introduction](https://genai.codewithsiva.dev/streamlit/intro.md): Learn what Streamlit is, how it works, and how to build your first app
- [Streamlit APP-1](https://genai.codewithsiva.dev/streamlit/streamlit-app.md): Student Performance Analytics Dashboard
- [User Input Widgets](https://genai.codewithsiva.dev/streamlit/widgets.md): Capture clicks, selections, text, files, and slider values in Streamlit
- [Complete workflow](https://genai.codewithsiva.dev/uv/complete-setup.md): Start to finish setup
- [Modern Python](https://genai.codewithsiva.dev/uv/index.md): Next-level development with uv
- [Why uv?](https://genai.codewithsiva.dev/uv/uv-intro.md): The future of Python packaging
- [Using uv](https://genai.codewithsiva.dev/uv/virtual-env.md): Create projects the modern way
- [00-Introduction & Getting Started](https://genai.codewithsiva.dev/workshop/00-introduction.md): Welcome to the Advanced Python & FastAPI Workshop. Set up your development environment with Python 3.12+, VS Code and uv.
- [01-Advanced Fundamentals](https://genai.codewithsiva.dev/workshop/01-advanced-fundamentals.md): Learn advanced Python features that help you write cleaner, more expressive, and Pythonic code.
- [02-Data Structures & Comprehensions](https://genai.codewithsiva.dev/workshop/02-ds-comprehensions.md): Master lists, tuples, dictionaries, sets, queues with deque, and learn Pythonic comprehensions.
- [03-Python Functions](https://genai.codewithsiva.dev/workshop/03-python-functions.md): Understand function arguments, print parameters, packing/unpacking, mutable defaults, and variable scope LEGB resolution.
- [04-Advanced Python Concepts](https://genai.codewithsiva.dev/workshop/04-advanced-concepts.md): Learn advanced Python concepts including functions as objects, higher-order functions, closures, decorators, iterators, generators, and context managers.
- [05-Functional Programming](https://genai.codewithsiva.dev/workshop/05-functional-programming.md): Learn how Python treats functions as first-class objects and explore functional programming techniques for writing clean, reusable, and expressive code.
- [05b-Python Modules & Packages](https://genai.codewithsiva.dev/workshop/05b-modules-packages.md): Learn how to structure code with modules and packages, and work with prominent standard libraries (math, random, os, pathlib, python-dotenv).
- [06-Advanced Oops](https://genai.codewithsiva.dev/workshop/06-advanced-oop.md): Learn advanced object-oriented programming concepts in Python, including class members, magic methods, abstract base classes, and multiple inheritance.
- [06b-Exceptions & Data Handling](https://genai.codewithsiva.dev/workshop/06b-exceptions-data-handling.md): Learn exception handling (try-except-else-finally), custom exceptions, and reading/writing text, CSV, and JSON files.
- [07-Data Modeling with Pydantic](https://genai.codewithsiva.dev/workshop/07-data-validation.md): Learn how to build robust, type-safe data models using Pydantic for validation, serialization, and modern Python applications.
- [08-Python Project Essentials](https://genai.codewithsiva.dev/workshop/08-project-essentials.md): Learn the essential tools and practices for building modern Python projects, including dependency management, configuration, JSON handling, REST APIs, and dependency injection.
- [09-FastAPI Foundations](https://genai.codewithsiva.dev/workshop/09-fastapi-essentials.md): Learn the fundamentals of building modern REST APIs using FastAPI.
- [10-Introduction to SQLAlchemy](https://genai.codewithsiva.dev/workshop/10-sql-orm.md): Understand why ORMs exist, how SQLAlchemy works, and the overall workflow before building your first ORM application.
- [11-Authentication & Authorization with JWT](https://genai.codewithsiva.dev/workshop/11-auth-jwt.md): Learn the fundamentals of securing REST APIs by understanding authentication, authorization, different authentication mechanisms, and implementing JWT-based authentication and role-based authorization in FastAPI.
- [12-Production Deployment](https://genai.codewithsiva.dev/workshop/12-deployment.md): Learn how to package, test, and deploy the Student Management System to a production server using Docker, Alembic, Docker Compose, Nginx, and HTTPS.
- [13-Streamlit Frontend Integration](https://genai.codewithsiva.dev/workshop/13-frontend-streamlit.md): Learn how to build a clean web frontend using Streamlit to interact with a FastAPI CRUD backend running at api.domain.com.