LLMOps And AIOps Bootcamp With 8 End To End Projects

Create a common Python logging and custom exception system. Build a package with logger and custom exception modules, configure log folders, and capture file name and line number.

Learn how to configure setup.py to package a python app, parse requirements.txt, locate packages with find_packages, and install dependencies.

Explore building an ai anime recommender using a csv data store, Hugging Face embeddings, and a Chroma vector store, orchestrated with Docker, Kubernetes, and a Streamlit UI.

Set up the anime recommender project by creating the structure, configuring a virtual environment, and integrating grok and hugging face keys; build the data pipeline with chroma db and LangChain.

Explains configuring the project: install dependencies, set up package structure, create config.config.py, load environment variables with dotenv, and pick a production model from graph cloud models.

Instantiate anime data loader, read original csv with pandas, keep name, genre, synopsis, merge into a single info column, and save as processed csv in UTF eight.

Build and load a vector store with chroma, using CSV loader and character text splitter, then convert text into embeddings via hugging face embeddings and env vars.

Build a project template in src by using a prompt template from GitHub to configure the LM as an expert anime recommender with context-driven, 2–3 sentence plots and matching explanations.

Create an anime recommender class in Python, wiring LangChain retrieval QA with an LLM via Chad Brock, configuring the API key, model, and temperature, and exposing the get recommendation method.

Learn to build and load a training and recommendation pipeline by integrating a data loader, vector store builder, retriever, and anime recommender, with logging and error handling.

Build and deploy an anime recommendation app with streamlit, a vector store retriever, and a pipeline; configure env variables and dockerize the project for easy deployment.

Create a docker file for a Python streamlit app, deploy with a Kubernetes deployment and service, and version code with GitHub for end-to-end LLMOps projects.

Set up a Google Cloud VM instance with Ubuntu 24.04 LTS, 16 GB memory, and four CPUs; install Docker Engine, Minikube, and kubectl to form a Kubernetes cluster.

Clone the GitHub repo to the VM and connect local, VM, and GitHub to sync changes using git add, commit, push, and pull, while managing docker and kubernetes configurations.

Learn how to create a GCP firewall rule with ingress direction, allow action, targets all instances, set source IPv4 ranges, and allow all ports.

Build a Docker image inside Minikube, deploy the app on a Kubernetes cluster, secure API keys with secrets, and expose the Streamlit app via a port-forwarded service using Minikube tunnel.

Create a monitoring namespace, install helm, and deploy Grafana Cloud to monitor Kubernetes. Configure the cluster (minikube) and values.yaml, then view namespaces, pods, and workloads in Grafana.

Delete your VM instance to clean up, which disables the Kubernetes Grafana cloud and its monitoring. It covers Grafana cloud usage, a 14-day free trial, and creating alerts and dashboards.

Build a Flipkart-style product recommender using embedding models with grok and hugging face, stored in Astra DB, deployed on minikube with kubectl; monitor with Prometheus and Grafana on Google Cloud.

Set up a python virtual environment, create the data and utils packages for the flipkart project, install dependencies, and configure Astra DB, Hugging Face, and Grok API keys.

Create a config.py in the Flipkart project and load environment variables with dotenv. Define a Config class with variables for the db endpoint, api key, embedding model, and rag model.

Create a Python data converter that reads a csv file with product title and review, converts rows to LangChain documents, with review as page content and title as metadata.

Develop data ingestion code that converts a csv file into documents, creates embeddings with Hugging Face, and stores them in an Astra DB vector store.

Build a memory-enabled rag pipeline with a history-aware retriever using LangChain, a vector store, context and question prompts, and a stuff document chain for contextual answers.

Build a Flask-based main application with an HTML/CSS front end, wire up a vector store and rack chain, and expose Prometheus metrics via a /metrics endpoint.

Create a dockerfile using python 3.1 slim, set app as workdir, install dependencies with pip, expose port 5000, and run python app.py; then configure a flask deployment and service yaml.

Write Prometheus deployment and config map yaml files in a dedicated monitoring namespace. Mount the config map, run Prometheus pod, and expose it on port 1990 with a custom config.

Create a Grafana deployment file in the grafana folder by copying code from GitHub, run a single Grafana pod in the monitoring namespace, using Docker Hub image and port 3000.

Learn code versioning with GitHub by installing git, creating a public repository, configuring .gitignore for env and virtual environments, then initialize, commit, and push to main.

set up a Google Cloud VM with Docker Engine, Minikube, and kubectl on Ubuntu 24.04 LTS, configuring 16 GB memory, 150 GB disk, and enabling Kubernetes workflow.

Connect your local repository, GitHub, and VM by cloning the repo to the VM, then push, pull, and sync changes with git while using Docker, minikube, and kubectl.

Configure a GCP firewall rule to allow traffic to all instances in the default network. Set ingress, source IPv4 ranges to 0.0.0.0/0, and enable all ports.

Build and deploy a docker-based app on minikube kubernetes, configuring secrets and environment variables, then expose the service via port forwarding and firewall rules to access from outside.

Set up Prometheus and Grafana in a Kubernetes cluster, create a monitoring namespace, deploy configs, and configure dashboards to visualize internal and flask metrics.

Discover the ai travel planner project’s tech stack, including grok llm, llama 3.3, Streamlit UI, Docker, Kubernetes and Minikube, plus ELK stack for logs with Filebeat, Logstash, Elasticsearch, Kibana.

Set up the ai travel agent project in VS Code, create and activate a python venv, scaffold a src package with utils, core modules, a setup.py, and a requirements.txt.

Learn to load environment variables with dotenv in a Python config module and convert them into usable API key variables for your project setup.

Build and run an itinerary chain by loading a language model, crafting a structured prompt, and generating a city itinerary from user interests via a generate itinerary function.

Create the core planner by building a TravelPlanner class that tracks city and interests, records chat history with human and AI messages, and generates itineraries via the itinerary chain.

Create the main Streamlit app by integrating a travel planner class, configuring the page, loading environment variables, and prompting for city and interests to generate and display an itinerary.

Create a Dockerfile and a Kubernetes deployment file, then version your code on GitHub to deploy a Streamlit app using Python 3.1, with proper ports and environment configuration.

Deploy filebeat on every node with a daemonset, configure inputs and outputs, enrich logs with metadata, and implement rbac permissions in the LLMOps and AIOps bootcamp.

Configure a logstash deployment with a custom config map in a logging namespace, routing filebeat logs from port 5044 to Elasticsearch 9200 via a single deployment, service, and volume.

Deploy Elasticsearch in Kubernetes using a persistent volume claim to store indexes. Configure single-node mode, memory settings, and expose port 9200 via a service.

Deploy Kibana in the elk stack on Kubernetes, using a single Kibana deployment and nodeport service, connected to Elasticsearch at port 9200 and exposing 5601.

Set up a Google Cloud vm with Ubuntu 24.04 LTS, 150 GB storage, and minikube using Docker; install kubectl and enable Docker to start on boot.

Clone your GitHub repository to the VM and link your local and VM. Run git add, commit, and push with a personal access token to sync changes and pull updates.

Create a GCP firewall rule to allow ingress traffic for all instances in the default network, using IPv4 ranges and all ports.

Build a docker image for a streamlit app, deploy it on a minikube kubernetes cluster, create secrets, apply deployment, expose the service, and access the app via port forwarding.

Set up the ELK stack with Filebeat to collect Kubernetes logs, process them through Logstash, index in Elasticsearch, and visualize via the Kibana dashboard, using a dedicated logging namespace.

Build a study buddy ai that generates fill ups and multiple-choice questions with adjustable difficulty. Utilize a GitOps-driven lmlops stack with minikube, Jenkins, Argo CD, grok lm, LangChain, and Streamlit.

Set up a grok API based LLM project by creating a venv, installing dependencies via setup.py and requirements.txt, and organizing a src package (common, config, lm, generator, models, prompts, utils).

Build a configuration package with settings.py that loads environment variables, captures the grok api key, selects a graph model, sets temperature and max retries, and instantiates the settings.

Design mcq and fill-in-the-blank question schemas as pydantic models in a models package, with a validator to normalize dictionary inputs and ensure structured question data.

Create a prompts package with templates.py to generate MCQ and fill-in-the-blank questions, returning only a JSON object guided by difficulty and topic inputs.

Set up the Grok graph client by creating a drop client.py, importing Chad Grok, and wiring API key, model name, and temperature from settings for reuse with get grok.

build a question generator for the llm ops and aiops bootcamp, wiring init and generator modules, installing dependencies, and parsing lm outputs into mcq and fill-in-the-blank templates.

Create a helper module with a quiz manager that generates mcq or fill in the blank questions, collects answers, evaluates results, and saves a csv report in a results directory.

Create the main application code for a Streamlit quiz app, loading environment variables, initializing session states, and wiring a sidebar to generate and evaluate questions with a quiz manager.

Learn how to set up code versioning with git and GitHub, create a gitignore, push to a new repo, and build a dockerfile for a Streamlit deployment.

Create Kubernetes manifest files (deployment.yaml and service.yaml) to deploy a docker image with replicas on port 8501, expose the app via a service, and inject API keys as environment variables.

set up a gcp vm with ubuntu 24.04, install docker, minikube, and kubectl, then clone the github repo and prepare a ci/cd kubernetes environment.

Set up Jenkins for CI on the same network as minikube using the LTS image and expose 8080, then install Docker, Docker pipeline, and Kubernetes plugins.

Learn to integrate Jenkins with GitHub by creating a GitHub access token and configuring Jenkins credentials. Build a pipeline that checks out code from the GitHub repo using a Jenkinsfile.

Build a Docker image, push to Docker Hub, configure Jenkins with Docker and credentials, update deployment.yaml, and push changes via Git to trigger a pipeline.

Create an Argo CD namespace, install Argo CD, verify pods run, switch the Argo CD server to a node port, sign in with the admin password to finish part 1.

Learn to set up Argo CD for deployment on a Kubernetes cluster by configuring the Kubernetes config file with certificate data and encoding kubeconfig for Jenkins integration.

Install kubectl and Argo CD CLI in the Jenkins container, connect Argo CD to GitHub, sync an app with manifests, and port-forward to access the deployed app in Minikube.

Set up GitHub webhooks to trigger a Jenkins pipeline on push events, and manage dynamic image tags and deployment.yaml updates for CI/CD with Argo CD.

Build an ai celebrity detector and question-answer system using grok lm and lama vision transformers, with opencv image processing, deployed on google cloud with kubernetes and circle ci.

Create a celebrity detector and question answer system project folder, set up and activate a virtual environment, and prepare dependencies with a requirements.txt and setup.py for a Flask backend.

Develop an image handler in Python using OpenCV that converts in-memory uploads, detects the largest face with Haar cascades, draws a bounding box, and returns jpeg bytes and coordinates.

Build a celebrity detector by encoding the image in base64, sending a chat completion request to a Llama for Maverick model via an API key, and extracting the name.

Build a question answer engine that uses a configured model, headers, and payload to answer celebrity questions via an api, using environment variables for the api key.

Flask backend development comes alive as this lecture builds a routes.py blueprint that wires image handling, a celebrity detector, and a question‑answer engine for interactive queries.

This lecture guides building a full Flask web app from blueprint setup and environment loading to front-end templates, including index.html, style.css, and forms for image upload and questions.

Create a Dockerfile and Kubernetes deployment file, enable code versioning with GitHub, and deploy a Flask app on port 5000 with OpenCV dependencies.

Learn google cloud setup for llm ops and ai ops bootcamp: enable kubernetes and artifact registry, launch a GKE cluster, and configure a service account with a json key.

Create a CircleCI pipeline in config.yml using a Docker executor with Google Cloud SDK, push to Google Artifact Registry, and deploy to GKE via CircleCI environment variables.

Demonstrates setting up circleci, encoding gcp keys, and deploying a full ci/cd pipeline to google kubernetes engine, injecting secrets for a celebrity detector app.

Design a multi ai agent platform with financial, medical, or study agents using grok, tivoli, and landgraf. Build end-to-end with fast api, streamlit, docker, jenkins ci/cd, sonar, and aws fargate.

Set up a multi ai agent project by building the folder and api structure, creating a venv, installing dependencies with setup.py, and configuring env keys for grok and telecom APIs.

Create a config package with init.py and settings.py, load dot env, and expose api keys and allowed models such as llama 370 billion parameters and versatile version.

Initialize the core package and install dependencies. Implement get_response_from_ai_agents using Chad Brock, Tivoli search, and LangGraph to return the latest AI reply.

Demonstrates building a FastAPI backend: define request model, implement /chat endpoint, validate model names against allowed models, log activity, and handle errors with HTTP exceptions and a custom exception.

Build a Streamlit frontend for a multi-agent AI app, creating the UI, system prompts, and model selection, then send a JSON payload via http post to a backend at 127.0.0.1:9999.

Connect backend and frontend to run a full stack app by wiring a FastAPI API with uvicorn and a Streamlit frontend, loading environment variables and logging.

Learn to version code with git and GitHub by creating a .gitignore to exclude venv, dot env file, and logs, then run git init, commit, and push to a repository.

create a dockerfile in project root using a python 3.1 slim image to dockerize app, set work directory, install dependencies, expose ports 8501 and 9999, and run python app/main.py.

Set up Jenkins for CI/CD deployment by building a Docker image from a custom Jenkins folder and Dockerfile, running containers, and installing Python and plugins inside the container.

Learn to integrate GitHub with Jenkins by creating a personal access token, configuring Jenkins credentials, and linking a repository via pipeline script from SCM to automate builds.

Learn to integrate SonarQube with Jenkins by running SonarQube in Docker, configuring Jenkins plugins and credentials, and connecting both on a shared network to enforce a quality gate in CI.

Build and push your Docker image to AWS ECR by configuring Jenkins with AWS credentials, installing the AWS CLI, creating an ECR repository, and pushing the latest image.

Deploy a CI/CD workflow to AWS Fargate by deploying an ECR image. Configure a multi AI agent cluster, a task definition, environment variables, and port mappings 8501 and 9999.

Delete your cluster to avoid charges, remove ECR repo and IAM user, prune docker images, volumes, and builds with docker system prune -a -f to reclaim space and enable ci/cd.

Build an end-to-end medical chat board using Hugging Face LLMs and embeddings, a FAISS vector store, PDF data source, Flask frontend, and a dockerized CI/CD pipeline on AWS.

Set up a medical chatbot project by creating a virtual environment, structuring an app package, and using setup.py to install lang chain, hugging face, and flask.

Configure the project by updating dot env for hugging face hub token and implementing config.py to fetch the token and set data path, vector store, repo id, and chunk size.

Create a pdf loader that loads pdfs from a data directory via directory and py pdf loaders, splits text into chunks with a recursive splitter, and logs with custom exception.

Build embeddings in python by creating embeddings.py, loading a hugging face embedding model with LangChain, and logging with a custom exception for robust error handling.

Learn to build and load vector stores with Faiss from text chunks, using embedding models, logging, and error handling for end-to-end LangChain integration.

Create a data loader to build a vector store by loading pdf files, converting them to text chunks, and saving the vector store using embeddings.

Load lm from hugging face hub using repo ID and API token for mistral i 0.3. Set temperature, max length, and return_full_text; initialize a logger and custom exception.

Build a retrieval question answering chain using LangChain by creating a retrieval module, loading a vector store and language model, and configuring a custom prompt for context-aware answers.

Build a Flask web app with a chat interface using a QA chain, manage session messages, render HTML via templates, and load environment variables for tokens.

Learn code versioning with git and GitHub, including initializing a repository, configuring env and gitignore, pushing to main, and creating a Dockerfile for a Python Flask app.

Set up jenkins for ci-cd deployment using docker in docker. Build a custom jenkins image from a dockerfile, run the container, unlock it, and install plugins.

Connect GitHub with Jenkins by generating a GitHub access token, configuring credentials in Jenkins, and creating a pipeline that checks out the GitHub repo using a Jenkinsfile.

Learn to build a docker image, scan it for vulnerabilities with Trivy, and push it to AWS ECR using Jenkins, AWS CLI, and IAM credentials.

Learn how to deploy a containerized app from ECR to AWS App Runner using a CI/CD pipeline, including IAM permissions, environment setup, and automated deployments via Jenkins and lm ops.

Learn to perform a thorough cleanup by deleting resources in App Runner, emptying and deleting an ECR repo, removing Docker images, containers, volumes, builds, and deactivating access keys.