DEV Community: Thu Kha Kyawe

Day 12: Configure a DVC Remote Storage

Thu Kha Kyawe — Tue, 16 Jun 2026 12:02:21 +0000

Lab Information

The xFusionCorp Industries ML team uses SeaweedFS as the shared S3-compatible object store for DVC-tracked data. A .dvc/config already declares a remote called s3 for the fraud-detection project, but dvc push currently fails. Correct the configuration and push the tracked data into the SeaweedFS bucket.

A project exists at /root/code/fraud-detection/ with DVC initialised and data/raw/transactions.csv already tracked.

SeaweedFS is already running on the controlplane:
    S3 endpoint: http://localhost:8333
    Filer UI: open the SeaweedFS Filer button at the top of the lab (forwarded port 8888) – buckets are visible under /buckets/.
    Credentials: weedadmin / weedadmin123 (already set in .dvc/config)
    Bucket name: dvc-storage (already created and visible in the Filer UI under /buckets/dvc-storage)

Review the existing .dvc/config and correct everything that prevents dvc push from succeeding. The remote called s3 must:
    point at the dvc-storage bucket using s3://;
    use the correct SeaweedFS S3 endpoint URL;
    be marked as the default remote.

Push the tracked data. After the push, the dvc-storage bucket in the SeaweedFS Filer UI must contain at least one object under the files/md5/... prefix.

Lab Solutions

✅ Part 1: Lab Step-by-Step Guidelines

Step 1: Move into the repository

cd /root/code/fraud-detection

Step 2: Inspect the current DVC configuration

View the config:

cat .dvc/config

Or:

dvc remote list

You will likely find one or more configuration mistakes.

Step 3: Verify the remote configuration

The lab requires:

Setting Required Value
Remote name s3
Bucket s3://dvc-storage
Endpoint URL http://localhost:8333
Default remote s3

A correct configuration looks similar to:

['remote "s3"']
    url = s3://dvc-storage
    endpointurl = http://localhost:8333
    access_key_id = weedadmin
    secret_access_key = weedadmin123

[core]
    remote = s3

Step 4: Fix the configuration
Set the remote URL

dvc remote modify s3 url s3://dvc-storage

Set the SeaweedFS endpoint

dvc remote modify s3 endpointurl http://localhost:8333

Set the remote as default

dvc remote default s3

Step 5: Verify the final configuration

cat .dvc/config

Confirm:

[core]
    remote = s3
['remote "s3"']
    url = s3://dvc-storage
    endpointurl = http://localhost:8333
    access_key_id = weedadmin
    secret_access_key = weedadmin123

Step 6: Check DVC status

dvc status

Expected:

Data and pipelines are up to date.

Step 7: Push the data

Run:

dvc push

Expected output:

root@controlplane fraud-detection on  main [!] ➜  dvc push
Collecting                                           |1.00 [00:00,  658entry/s]
Pushing
1 file pushed

Step 8: Verify remote storage

You can verify from DVC:

dvc status -c

Expected:

root@controlplane fraud-detection on  main [!] ➜  dvc status -c
Cache and remote 's3' are in sync.

Step 9: Verify in SeaweedFS

Open the SeaweedFS Filer UI:

SeaweedFS Filer
→ /buckets/
→ dvc-storage/

You should see a path similar to:

files/
└── md5/
└── xx/
└── xxxxxxxxxxxxxxxxxxxx

The exact hash will vary.

This confirms the dataset was uploaded successfully.

🧠 Part 2: Simple Step-by-Step Explanation (Beginner Friendly)

What is happening in this lab?

Previously, DVC was tracking the dataset locally.

Right now:

transactions.csv
↓
transactions.csv.dvc

But the actual file content is only stored on your machine.

The team wants all datasets backed up to a shared storage system.

What is SeaweedFS?

SeaweedFS is acting like a private Amazon S3 service.

Think of it as:

Local Machine
↓
DVC
↓
SeaweedFS Bucket

Instead of storing datasets in Git, DVC stores them in the bucket.

Why does dvc push fail?

Usually because one of these is wrong:

Wrong bucket name
Wrong endpoint URL
Remote not set as default

The lab specifically tells us the correct values:

Bucket: dvc-storage
Endpoint: http://localhost:8333
Remote: s3

What does dvc remote default s3 do?

It tells DVC:

Whenever I push or pull,
use the remote named "s3".

Without this setting, DVC may not know which remote to use.

What does dvc push do?

When you run:

dvc push

DVC uploads the tracked dataset into SeaweedFS.

Conceptually:

transactions.csv
↓
DVC Cache
↓
SeaweedFS Bucket

Resources & Next Steps

📦 Full Code Repository: KodeKloud Learning Labs

💬 Join Discussion: DEV Community - Share your thoughts and questions

💼 Let's Connect: LinkedIn - I'd love to connect with you

Credits

• All labs are from: KodeKloud

• I sincerely appreciate your provision of these valuable resources.

Day 11: Track a Dataset with DVC

Thu Kha Kyawe — Tue, 16 Jun 2026 12:00:38 +0000

Lab Information

A teammate has added the transactions dataset to the xFusionCorp Industries fraud-detection repository, but it was committed directly to Git instead of being tracked with DVC. Bring the repository in line with the team standard—every dataset under data/ must be tracked by DVC, not by Git.

A project exists at /root/code/fraud-detection/ with DVC already initialised. The dataset data/raw/transactions.csv is currently tracked by Git, and the team standard requires DVC to own it instead.

Stop Git from tracking the dataset without deleting it from disk.

Track the same dataset with DVC so a .dvc pointer file is produced and data/raw/.gitignore excludes the dataset itself.

Stage the new .dvc pointer and the new .gitignore, then record a Git commit with the message Track transactions dataset with DVC.

Once tracking is moved to DVC, the DVC TRACKED section in the EXPLORER panel will list the dataset, confirming the extension recognises it as a DVC-managed file.

Lab Solutions

✅ Part 1: Lab Step-by-Step Guidelines

Step 1: Move into the repository

cd /root/code/fraud-detection

Verify the dataset is currently tracked by Git:

git ls-files | grep transactions.csv

Expected:

root@controlplane fraud-detection on  main ➜  git ls-files | grep transactions.csv
data/raw/transactions.csv

Step 2: Stop Git from tracking the dataset (keep the file)

The lab specifically says:

Stop Git from tracking the dataset without deleting it from disk.

Use:

git rm --cached data/raw/transactions.csv

Important: Use --cached.

Removes the file from Git tracking
Keeps the actual file on disk

Verify:

ls -l data/raw/transactions.csv

The file should still exist.

Step 3: Track the dataset with DVC

Run:

dvc add data/raw/transactions.csv

DVC will create:

data/raw/transactions.csv.dvc

and update:

data/raw/.gitignore

Expected output:

root@controlplane fraud-detection on  main [✘?] ➜  dvc add data/raw/transactions.csv
100% Adding...|███████████████████████████████████████|1/1 [00:00, 60.46file/s]

To track the changes with git, run:

        git add data/raw/.gitignore data/raw/transactions.csv.dvc

To enable auto staging, run:

        dvc config core.autostage true

Step 4: Verify DVC artifacts

Check:

ls -la data/raw

Expected:

root@controlplane fraud-detection on  main [✘?] ➜  ls -la data/raw
total 20
drwxr-xr-x 2 root root 4096 Jun 14 11:59 .
drwxr-xr-x 3 root root 4096 Jun 14 11:56 ..
-rw-r--r-- 1 root root   18 Jun 14 11:59 .gitignore
-rw-r--r-- 1 root root  379 Jun 14 11:59 transactions.csv
-rw-r--r-- 1 root root   95 Jun 14 11:59 transactions.csv.dvc

Inspect the new files:

cat data/raw/.gitignore
cat data/raw/transactions.csv.dvc

Step 5: Check Git status

git status

You should see something similar to:

root@controlplane fraud-detection on  main [✘?] ➜  git status
On branch main
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        deleted:    data/raw/transactions.csv

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        data/

Step 6: Stage the required files

Stage everything needed for the migration:

git add data/raw/transactions.csv.dvc
git add data/raw/.gitignore
git add -u

The git add -u stages the removal of transactions.csv from Git tracking.

Verify:

git status

Everything should be staged.

Step 7: Commit the changes

Use the exact commit message required by the lab:

git commit -m "Track transactions dataset with DVC"

Step 8: Verify the commit

git log --oneline -n 1

Expected:

root@controlplane fraud-detection on  main ➜  git log --oneline -n 1
1b8a2c7 (HEAD -> main) Track transactions dataset with DVC

Step 9: Final verification

Confirm Git no longer tracks the dataset:

git ls-files | grep transactions.csv

Expected:

data/raw/transactions.csv.dvc

Confirm DVC tracks it:

dvc status

Expected:

Data and pipelines are up to date.

🧠 Part 2: Simple Step-by-Step Explanation (Beginner Friendly)

What is the problem?

Right now:

Git
└── data/raw/transactions.csv

Git is tracking a dataset file.

The team standard says:

Git → track code and metadata
DVC → track datasets and models

So we need to move ownership of the dataset from Git to DVC.

Why use git rm --cached?

If you run:

git rm data/raw/transactions.csv

Git removes the file completely.

We don't want that.

Instead:

git rm --cached data/raw/transactions.csv

removes it only from Git tracking.

The file remains on disk:

data/raw/transactions.csv

What does dvc add do?

When you run:

dvc add data/raw/transactions.csv

DVC creates a pointer file:

data/raw/transactions.csv.dvc

Think of it as:

transactions.csv.dvc
↓
points to
↓
transactions.csv

Git stores the small .dvc file instead of the large dataset.

Why is .gitignore created?

DVC automatically adds:

data/raw/.gitignore

so Git ignores:

transactions.csv

This prevents someone from accidentally committing the dataset again.

What gets committed to Git?

After migration, Git stores:

data/raw/transactions.csv.dvc
data/raw/.gitignore

Git no longer stores:

data/raw/transactions.csv

Resources & Next Steps

📦 Full Code Repository: KodeKloud Learning Labs

💬 Join Discussion: DEV Community - Share your thoughts and questions

💼 Let's Connect: LinkedIn - I'd love to connect with you

Credits

• All labs are from: KodeKloud

• I sincerely appreciate your provision of these valuable resources.

Day 10: Install and Initialize DVC in an ML Project

Thu Kha Kyawe — Tue, 16 Jun 2026 11:58:12 +0000

Lab Information

The xFusionCorp Industries ML team is adopting DVC so that datasets and model files are versioned separately from code. Initialise DVC inside the existing Git repository at /root/code/fraud-detection/ and record the initialisation in Git.

A Git repository already exists at /root/code/fraud-detection/ with an initial commit.

Initialise DVC inside that repository so that the standard .dvc/ control directory and .dvcignore file are created alongside the existing Git working tree.

Stage every file that DVC produces during initialisation, and record them in a new Git commit with the message Initialize DVC.

Once initialisation is complete, the DVC extension will detect the new .dvc/ directory and surface the DVC TRACKED section in the EXPLORER panel together with a DVC indicator in the bottom status bar.

Lab Solutions

✅ Part 1: Lab Step-by-Step Guidelines

Step 1: Move into the existing Git repository

cd /root/code/fraud-detection

Verify it's a Git repository:

git status

You should see something like:

On branch main
nothing to commit, working tree clean

Step 2: Verify DVC is installed

dvc version

Expected output:

root@controlplane fraud-detection on  master ➜  dvc version
DVC version: 3.67.1 (pip)
-------------------------
Platform: Python 3.12.3 on Linux-6.8.0-94-generic-x86_64-with-glibc2.39
Subprojects:
        dvc_data = 3.18.3
        dvc_objects = 5.2.0
        dvc_render = 1.0.2
        dvc_task = 0.40.2
        scmrepo = 3.6.2
Supports:
        http (aiohttp = 3.13.5, aiohttp-retry = 2.9.1),
        https (aiohttp = 3.13.5, aiohttp-retry = 2.9.1),
        s3 (s3fs = 2026.4.0)
Config:
        Global: /root/.config/dvc
        System: /etc/xdg/dvc

Step 3: Initialize DVC

Run:

dvc init

This creates:

.dvc/
.dvcignore

Typical output:

root@controlplane fraud-detection on  master ➜  dvc init
Initialized DVC repository.

You can now commit the changes to git.

+---------------------------------------------------------------------+
|                                                                     |
|        DVC has enabled anonymous aggregate usage analytics.         |
|     Read the analytics documentation (and how to opt-out) here:     |
|             <https://dvc.org/doc/user-guide/analytics>              |
|                                                                     |
+---------------------------------------------------------------------+

What's next?
------------
- Check out the documentation: <https://dvc.org/doc>
- Get help and share ideas: <https://dvc.org/chat>
- Star us on GitHub: <https://github.com/treeverse/dvc>

Step 4: Verify the new files

ls -la

You should now see:

.dvc/
.dvcignore

You can also inspect:

find .dvc

Step 5: Check Git status

git status

Expected output will show new DVC files:

root@controlplane fraud-detection on  master [+] ➜  git status
On branch master
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        new file:   .dvc/.gitignore
        new file:   .dvc/config
        new file:   .dvcignore

Step 6: Stage all DVC-generated files

git add .dvc .dvcignore

Verify:

git status

Everything should be staged.

Step 7: Commit the DVC initialization

Use the exact commit message required by the lab:

git commit -m "Initialize DVC"

Expected output:

root@controlplane fraud-detection on  master [+] ➜  git commit -m "Initialize DVC"
[master e1de19a] Initialize DVC
 3 files changed, 6 insertions(+)
 create mode 100644 .dvc/.gitignore
 create mode 100644 .dvc/config
 create mode 100644 .dvcignore

Step 8: Verify the commit

git log --oneline -n 2

Expected:

root@controlplane fraud-detection on  master ➜  git log --oneline -n 2
e1de19a (HEAD -> master) Initialize DVC
446962d Initial commit

🧠 Part 2: Simple Step-by-Step Explanation (Beginner Friendly)

What is DVC?

DVC (Data Version Control) is a tool used in Machine Learning projects to track:

Datasets
Models
Large files

without storing them directly in Git.

Think of it like:

Git -> tracks code
DVC -> tracks data and models

Why are we running dvc init?

The repository already exists as a Git project.

When we run:

dvc init

DVC adds its own management files:

.dvc/
.dvcignore

These files tell DVC how to manage datasets and model artifacts.

What does .dvc/ contain?

Example:

.dvc/
├── config
├── .gitignore
└── tmp/

These files store DVC configuration information.

Why do we commit the DVC files?

The lab specifically says:

Record the initialization in Git.

This means the new DVC files must be saved in Git history.

So we:

git add .dvc .dvcignore
git commit -m "Initialize DVC"

This creates a permanent record that DVC was enabled in the project.

Resources & Next Steps

📦 Full Code Repository: KodeKloud Learning Labs

💬 Join Discussion: DEV Community - Share your thoughts and questions

💼 Let's Connect: LinkedIn - I'd love to connect with you

Credits

• All labs are from: KodeKloud

• I sincerely appreciate your provision of these valuable resources.

5.Generate Tags and Keywords with AI

Thu Kha Kyawe — Sun, 14 Jun 2026 11:30:00 +0000

Lab Information

The datacenter AI Commerce team is developing tools to automatically enhance product visibility and branding through intelligent marketing assistance. You are tasked to build a Python-based Product Tag and Keyword Generator that creates creative titles and SEO-optimized keyword sets for product listings, helping businesses reach the right audience effectively.

Your task is to create a function that generates a marketing title and a fixed number of SEO keywords based on a product description and a target tone. The file tag_generator.py is ready for your code.

Initialize the OpenAIclient using api_key and base_url provided under /root/.bash_profile

Define a function named generate_seo(description: str, tone: str) -> str.

Construct a parameterized prompt asking the AI to:
    Generate a short, attention-grabbing product title (4-8 words) in the specified tone.
    Generate exactly ten low-competition keywords, separated by commas, for SEO tagging.

Send this prompt to the API, ensuring the output is strictly two lines:
    Line 1: The generated title.
    Line 2: The ten comma-separated keywords.

Use the following parameters:
    model: openai/gpt-4.1-mini
    messages: {"role": "user", "content": constructed prompt}
    max_tokens: 60
    temperature: 0.7 (for creative tone)

In the main execution, call the function with:
    Description: 'A waterproof, lightweight backpack designed for multi-day hikes in difficult terrain.'
    Tone: 'Rugged and Adventurous'

Print only the raw two-line output to the console.

Notes:

Ensure you are working in the /root/openaiproject directory.

Your API credentials will be provided under /root/.bash_profile.

The entire output must consist of exactly two lines separated by a newline (\n), with no extra text.

The keywords line must contain exactly 10 comma-separated values (no spaces around commas).

Use hardcoded values for api_key and base_url when initializing the OpenAI client or read them from environment variables via os.environ.get('OPENAI_API_KEY') and os.environ.get('OPENAI_BASE_URL').

Before running tag_generator.py, create and activate a virtual environment, then install OpenAI using:

python3 -m venv venv && source venv/bin/activate && pip install openai

The output should be a single, case-sensitive word extracted from the AI's response.

You are allowed a maximum of 10 requests. After this, you may encounter a rate limiter error. Therefore, use your requests judiciously.

Lab Solutions

Part 1: Lab Step-by-Step Guidelines

Step 1 — Navigate to the Project Directory

cd /root/openaiproject

Step 2 — Create and Activate Virtual Environment

python3 -m venv venv
source venv/bin/activate

Step 3 — Install OpenAI SDK

pip install openai

Step 4 — Verify OpenAI Variables

Since your previous labs showed:

printenv | grep OPENAI

Output similar to:

OPENAI_API_KEY=...
OPENAI_API_BASE=https://kodekey.ai.kodekloud.com/v1

Use:

os.environ.get("OPENAI_API_KEY")
os.environ.get("OPENAI_API_BASE")

when creating the client.

Step 5 — Edit tag_generator.py

vi /root/openaiproject/tag_generator.py

Replace the contents with:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("OPENAI_API_KEY"),
    base_url=os.environ.get("OPENAI_API_BASE")
)


def generate_seo(description: "str, tone: str) -> str:"
    prompt = f"""
Product Description:
{description}

Tone:
{tone}

Generate:
1. A short attention-grabbing product title (4-8 words).
2. Exactly 10 low-competition SEO keywords.

Output Rules:
- Output exactly two lines.
- Line 1: title only.
- Line 2: exactly 10 keywords.
- Keywords must be comma-separated.
- No spaces around commas.
- No numbering.
- No labels.
- No extra text.
"""

    response = client.chat.completions.create(
        model="openai/gpt-4.1-mini",
        messages=[
            {
                "role": "user",
                "content": prompt
            }
        ],
        max_tokens=60,
        temperature=0.7
    )

    return response.choices[0].message.content.strip()


if __name__ == "__main__":
    result = generate_seo(
        "A waterproof, lightweight backpack designed for multi-day hikes in difficult terrain.",
        "Rugged and Adventurous"
    )

    print(result)

Save and exit:

Step 6 — Run the Script

python tag_generator.py

Step 7 — Verify Output Format

Example:

~/openaiproject ➜  python tag_generator.py
Trailblazer Waterproof Hiking Backpack  
waterproof backpack,hiking gear,multi-day backpack,lightweight hiking bag,rugged backpack,adventure gear,off-road backpack,durable hiking pack,outdoor backpack,trekking backpack

Part 2: Simple Beginner-Friendly Explanation

What This Lab Does

In this lab, you are building an AI-powered SEO content generator.

The AI receives:

A product description
A desired tone

It then generates:

A marketing title
Ten SEO keywords

This helps products become easier to find online.

Why We Use a Prompt prompt = f""" ... """

The prompt tells the AI exactly what to create.

It includes:

Product details
Desired writing style
Output format requirements

A clear prompt helps the AI produce consistent results.

Why We Include the Tone Tone: Rugged and Adventurous

The tone influences how the title sounds.

For example:

Professional Tone

Lightweight Waterproof Hiking Backpack

Rugged and Adventurous Tone

Trailblazer Pack for Wild Terrain

The same product can be presented differently depending on the target audience.

Why We Generate Keywords

Keywords help search engines understand a product.

Example keywords:

waterproofhikingpack
multidaybackpack
adventurebackpack

These keywords improve discoverability in online searches.

Why Temperature is 0.7 temperature=0.7

A higher temperature increases creativity.

Benefits:

More engaging titles
More varied wording
Better marketing-style content

This is useful for branding and product promotion.

How the Program Works
The product description is provided.
The desired tone is provided.
Both are inserted into the prompt.
The prompt is sent to the AI model.
The model creates:
One title
Ten keywords
The result is returned and printed.
Example Input
Description:
A waterproof, lightweight backpack designed for multi-day hikes in difficult terrain.

Tone:
Rugged and Adventurous

Example Output Trailblazer Pack for Wild Terrain waterproofhikingpack,multidaybackpack,ruggedtrailgear,lightweighthikingbag,adventurebackpack,trekkingequipment,outdoorhikingpack,mountaintrailpack,durablehikegear,backpackingessentials

The first line is the marketing title.

The second line contains exactly ten SEO keywords separated by commas with no spaces, matching the lab requirements.

Resources & Next Steps

📦 Full Code Repository: KodeKloud Learning Labs

💬 Join Discussion: DEV Community - Share your thoughts and questions

💼 Let's Connect: LinkedIn - I'd love to connect with you

Credits

• All labs are from: KodeKloud

• I sincerely appreciate your provision of these valuable resources.

4.Create a Structured Quiz with AI

Thu Kha Kyawe — Sun, 14 Jun 2026 08:30:00 +0000

Lab Information

The nautilus AI Learning team is developing intelligent training tools that automatically generate learning content for developers and students. You are tasked to build a Python-based Structured Quiz Generator that creates a single, well-formatted multiple-choice question (MCQ) in JSON format to support automated learning modules.

Build a function that generates a quiz on a given topic, ensuring the output is a strict JSON array containing a single question object. The file quiz_generator.py has been created.

Initialize the OpenAI clientusing api_key andbase_urlunder /root/.bash_profile

Define a function generate_quiz(topic: str) -> str.

Implement the API call using a detailed prompt and system message to instruct the AI to generate exactly one multiple-choice question (MCQ) on the topic: 'Basic Linux Commands'.

The final output must be a JSON array containing a single object with the keys: question, options (an array of 4 strings), and answer (the correct option text).

Use the following parameters, and print the raw JSON output to the console:

model: openai/gpt-4.1-mini
max_tokens: 150
temperature: 0.3

You must output your response ONLY as a JSON array that strictly follows this schema:

[
{"question": "The question text.", "options": ["Option A", "Option B", "Option C", "Option D"], "answer": "The correct answer text."}
]

Notes:

Ensure you are working in the /root/openaiproject folder.

Use the system message to strictly enforce the JSON format and the constraint of one question.

Use hardcoded values for api_key and base_url when initializing the OpenAI client or read them from environment variables via os.environ.get('OPENAI_API_KEY') and os.environ.get('OPENAI_BASE_URL').

Before running quiz_generator.py, create and activate a virtual environment, then install OpenAI using:

python3 -m venv venv && source venv/bin/activate && pip install openai

Question should be related to topic Linux operating system.

You are allowed a maximum of 10 requests. After this, you may encounter a rate limiter error. Therefore, use your requests judiciously.

Lab Solutions

Part 1: Lab Step-by-Step Guidelines

Step 1 — Navigate to the Project Directory

cd /root/openaiproject

Step 2 — Create and Activate a Virtual Environment

python3 -m venv venv
source venv/bin/activate

Step 3 — Install OpenAI SDK

pip install openai

Step 4 — Verify OpenAI Environment Variables

Check which variables are available:

printenv | grep OPENAI

From your previous labs, you likely have:

OPENAI_API_KEY=...
OPENAI_API_BASE=...

Use the actual variable names that exist in your environment.

Step 5 — Edit quiz_generator.py

vi /root/openaiproject/quiz_generator.py

Replace the contents with:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("OPENAI_API_KEY"),
    base_url=os.environ.get("OPENAI_API_BASE")
)


def generate_quiz(topic: str) -> str:
    system_message = """
You are a quiz generator.

Generate EXACTLY one multiple-choice question.

Return ONLY a valid JSON array containing a single object.

Required schema:
[
  {
    "question": "Question text",
    "options": ["Option A", "Option B", "Option C", "Option D"],
    "answer": "Correct option text"
  }
]

Rules:
- Generate exactly one question.
- Include exactly 4 options.
- The answer must match one option exactly.
- Do not include markdown.
- Do not include explanations.
- Output JSON only.
"""

    user_message = (
        f"Generate one MCQ about the topic: {topic}. "
        f"The question should relate to Linux operating systems."
    )

    response = client.chat.completions.create(
        model="openai/gpt-4.1-mini",
        messages=[
            {"role": "system", "content": system_message},
            {"role": "user", "content": user_message}
        ],
        max_tokens=150,
        temperature=0.3
    )

    return response.choices[0].message.content.strip()


if __name__ == "__main__":
    result = generate_quiz("Basic Linux Commands")
    print(result)

Save and exit:

Step 6 — Run the Script

python quiz_generator.py

Step 7 — Verify Output

Expected format:

~/openaiproject ➜  python quiz_generator.py
[
  {
    "question": "Which command is used to list the files and directories in the current directory in Linux?",
    "options": ["ls", "cd", "mkdir", "rm"],
    "answer": "ls"
  }
]

Part 2: Simple Beginner-Friendly Explanation

What This Lab Does

In this lab, you are building an AI-powered quiz generator.

The AI will:

Receive a topic.
Create one multiple-choice question.
Generate four answer choices.
Identify the correct answer.
Return everything in JSON format.

This can be used in learning platforms, training systems, or educational applications.

Why We Use JSON

JSON (JavaScript Object Notation) is a common format for storing and exchanging structured data.

Example:

[
{
"question": "Which command lists files in Linux?",
"options": ["ls", "pwd", "cd", "mkdir"],
"answer": "ls"
}
]

JSON is easy for both humans and programs to read.

Why We Use a System Message system_message = """ You are a quiz generator... """

The system message provides strict instructions to the AI.

It tells the model:

Generate only one question.
Use the required JSON format.
Include four options.
Provide the correct answer.
Return JSON only.

Think of the system message as the rules the AI must follow.

Why We Use a User Message user_message = ( f"Generate one MCQ about the topic: {topic}" )

The user message contains the actual task.

In this lab, the topic is:

Basic Linux Commands

Think of it this way:

System message = instructions
User message = specific request

Why Temperature is 0.3 temperature=0.3

Temperature controls creativity.

A value of 0.3:

Allows some variation in questions.
Keeps answers reliable.
Produces consistent quiz content.

This is useful when generating educational questions.

Resources & Next Steps

📦 Full Code Repository: KodeKloud Learning Labs

💬 Join Discussion: DEV Community - Share your thoughts and questions

💼 Let's Connect: LinkedIn - I'd love to connect with you

Credits

• All labs are from: KodeKloud

• I sincerely appreciate your provision of these valuable resources.

3.Analyze Sentiment with AI

Thu Kha Kyawe — Sun, 14 Jun 2026 05:30:00 +0000

Lab Information

The datacenter AI Engineering team is developing tools to interpret the tone of developer communications. You are tasked to build a Python-based AI Sentiment Analyzer that identifies whether a given message or feedback is Positive, Negative, or Neutral, helping teams gauge emotional context quickly.

Create a Python program named under /root/openaiproject/sentiment_analyzer.py that analyzes the sentiment (Positive, Negative, or Neutral) of a given text using the OpenAI API.

Initialize the OpenAI client with the provided api_key and base_url.

Define a function named analyze_sentiment(text: str) -> str that:
    Constructs a parameterized prompt asking the AI to analyze the sentiment of the given text and respond with Sentiment and Reason.
    Sends this prompt to the API using the following parameters:
    model: openai/gpt-4.1-mini
    messages:{"role": "user", "content": constructed prompt}
    max_tokens: 60
    temperature: 0.0
    Extracts and returns both the Sentiment label (Positive, Negative, or Neutral) and a short Reason explaining the classification.

In the main execution block, analyze the following text:
I am really happy with the new update!

Print the output strictly in the following format:
Sentiment:<Positive/Negative/Neutral>
Reason:<short explanation>

Notes:

Ensure you are working in the /root/openaiproject directory.

Your API credentials will be provided under /root/.bash_profile.

Use hardcoded values for api_key and base_url when initializing the OpenAI client or read them from environment variables via os.environ.get('OPENAI_API_KEY') and os.environ.get('OPENAI_BASE_URL').

Before running sentiment_analyzer.py, create and activate a virtual environment, then install OpenAI using:

python3 -m venv venv && source venv/bin/activate && pip install openai

The output should be a single, case-sensitive word & short reason extracted from the AI's response.

You are allowed a maximum of 10 requests. After this, you may encounter a rate limiter error. Therefore, use your requests judiciously.

Lab Solutions

Part 1: Lab Step-by-Step Guidelines

Step 1 — Navigate to the Project Directory

cd /root/openaiproject

Step 2 — Create and Activate a Virtual Environment

python3 -m venv venv
source venv/bin/activate

Step 3 — Verify Environment Variables

Based on your previous labs, check which OpenAI variables are available:

printenv | grep OPENAI

You will likely see:

OPENAI_API_KEY=...
OPENAI_API_BASE=...

Use the actual variable names that exist in your environment.

Step 4 — Edit sentiment_analyzer.py

vi /root/openaiproject/sentiment_analyzer.py

Replace the contents with:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("OPENAI_API_KEY"),
    base_url=os.environ.get("OPENAI_API_BASE")
)


def analyze_sentiment(text: str) -> str:
    prompt = f"""
Analyze the sentiment of the following text.

Classify it as exactly one of:
- Positive
- Negative
- Neutral

Respond in exactly this format:

Sentiment:<Positive/Negative/Neutral>
Reason:<short explanation>

Text:
{text}
"""

    response = client.chat.completions.create(
        model="openai/gpt-4.1-mini",
        messages=[
            {
                "role": "user",
                "content": prompt
            }
        ],
        max_tokens=60,
        temperature=0.0
    )

    return response.choices[0].message.content.strip()


if __name__ == "__main__":
    text = "I am really happy with the new update!"

    result = analyze_sentiment(text)

    print(result)

Save and exit:

Step 5 — Run the Script

python sentiment_analyzer.py

Step 6 — Verify Output

Expected format:

~/openaiproject ➜  python sentiment_analyzer.py
Sentiment:Positive  
Reason: The text expresses happiness and satisfaction with the new update.

Part 2: Simple Beginner-Friendly Explanation

What This Lab Does

In this lab, you are building a simple AI-powered sentiment analyzer.

The AI reads a piece of text and determines whether the sentiment is:

Positive
Negative
Neutral

It also explains why it made that decision.

This helps teams quickly understand the emotional tone of messages, comments, or feedback.

Why We Create a Prompt

prompt = f"""
Analyze the sentiment of the following text...
"""

A prompt is the instruction we send to the AI.

It tells the model:

What task to perform
Which sentiment labels are allowed
What format the response should follow

Good prompts help produce consistent results.

Why We Use a User Message

messages=[
{
"role": "user",
"content": prompt
}
]

The user message contains:

The instructions
The text being analyzed

Think of it as:

Prompt = task description + data
User message = what is sent to the model

Why Temperature is Zero

temperature=0.0

Temperature controls randomness.

A value of 0.0 means:

Very consistent results
Minimal creativity
More predictable classifications

This is useful for sentiment analysis because we want reliable answers.

How the Analysis Works
The script receives some text.
The text is inserted into the prompt.
The prompt is sent to the AI model.
The model determines the sentiment.
The model provides a short reason.
The result is printed to the terminal.

Example Input
I am really happy with the new update!

The phrase:

really happy

shows satisfaction and enthusiasm.

Example Output
Sentiment:Positive
Reason:Expresses happiness and satisfaction with the update.

Only the sentiment and reason are printed, making the output easy to read and process.

Resources & Next Steps

📦 Full Code Repository: KodeKloud Learning Labs

💬 Join Discussion: DEV Community - Share your thoughts and questions

💼 Let's Connect: LinkedIn - I'd love to connect with you

Credits

• All labs are from: KodeKloud

• I sincerely appreciate your provision of these valuable resources.

2.Analyse Logs with AI

Thu Kha Kyawe — Sun, 14 Jun 2026 02:30:00 +0000

Lab Information

The datacenter AI Reliability team is designing intelligent tools to monitor application health and proactively detect production issues. You are tasked to build a Python-based Log Anomaly Detector and Summarizer that reads a log file, identifies the most critical failure, and generates a concise, human-readable summary — helping engineers quickly understand the nature and impact of system errors.

Your task is to build a Python script to detect and summarize critical errors from a log file. The file log_analyzer.py has been created under /root/openaiproject.

Initialize the OpenAI client using the api_key and base_url provided in your environment.

Define a function named analyze_log_anomaly(log_file_path: str) -> str.

Inside the function:
    Read the entire content of the provided log file (app.log under/root/openaiproject).
    Construct the API call using both a system message and a user message.
    The system instruction is critical: You must instruct the AI to act as an auditor, focus ONLY on the [CRITICAL] line, and provide a two-part summary: 1) The error type, 2) Immediate Impact.

Send this prompt (including the log content in the user message) to the API using the following parameters:
    model: openai/gpt-4.1-mini
    messages: [{"role": "user", "content": prompt}]
    max_tokens: 80
    temperature: 0.1 (for factual summarization)

In the main execution, call the function with the path '/root/openaiproject/app.log' and print only the raw summary to the console.

Notes:

Ensure you are working in the /root/openaiproject folder.

You will be provided with an OpenAI api_key & base_urlfor this session under /root/.bash_profile

The prompt must include the log file content.

The final output printed should be only the concise summary text.

Use hardcoded values for api_key and base_url when initializing the OpenAI client or read them from environment variables via os.environ.get('OPENAI_API_KEY') and os.environ.get('OPENAI_BASE_URL').

Before running log_analyzer.py, create and activate a virtual environment, then install OpenAI using:

python3 -m venv venv && source venv/bin/activate && pip install openai

You are allowed a maximum of 10 requests. After this, you may encounter a rate limiter error. Therefore, use your requests judiciously.

Lab Solutions

Part 1: Lab Step-by-Step Guidelines

Step 1 — Navigate to the Project Directory

cd /root/openaiproject

Step 2 — Create and Activate Virtual Environment

python3 -m venv venv
source venv/bin/activate

Step 3 — Install OpenAI SDK

pip install openai

Step 4 — Check Environment Variables

Based on your previous lab, verify the actual variable names:

printenv | grep OPENAI

You will likely see:

OPENAI_API_KEY=...
OPENAI_API_BASE=...

If so, use OPENAI_API_BASE in your code.

Step 5 — Edit log_analyzer.py

vi /root/openaiproject/log_analyzer.py

Replace the file contents with:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("OPENAI_API_KEY"),
    base_url=os.environ.get("OPENAI_API_BASE")
)


def analyze_log_anomaly(log_file_path: str) -> str:
    with open(log_file_path, "r") as file:
        log_content = file.read()

    system_message = (
        "You are an auditor. Focus ONLY on the [CRITICAL] log entry. "
        "Provide a concise two-part summary:\n"
        "1. Error Type\n"
        "2. Immediate Impact\n"
        "Ignore all non-critical log entries."
    )

    user_message = f"""
Analyze the following log file.

Log Content:
{log_content}
"""

    response = client.chat.completions.create(
        model="openai/gpt-4.1-mini",
        messages=[
            {"role": "system", "content": system_message},
            {"role": "user", "content": user_message}
        ],
        max_tokens=80,
        temperature=0.1
    )

    return response.choices[0].message.content.strip()


if __name__ == "__main__":
    result = analyze_log_anomaly(
        "/root/openaiproject/app.log"
    )

    print(result)

Save:

Step 6 — Run the Script

python log_analyzer.py

Example Output:

~/openaiproject ✖ python log_analyzer.py
1. Error Type: OutOfMemoryError in main thread due to JVM heap exhaustion.  
2. Immediate Impact: Service is shutting down immediately, causing potential downtime and service unavailability.

Part 2: Simple Beginner-Friendly Explanation

What This Lab Does

In this lab, you are building a simple AI-powered log analyzer.

Instead of manually reading hundreds or thousands of log entries, the AI:

Reads the log file.
Examines the log entries.
Focuses on the most important [CRITICAL] event.
Generates a short, human-readable summary.
Explains the immediate impact of the problem.

This helps engineers quickly understand serious production issues.

Why We Read the Log File
with open(log_file_path, "r") as file:
log_content = file.read()

This code opens the log file and reads all its contents into a variable called log_content.

Example log:

[INFO] Service started
[WARNING] Memory usage high
[CRITICAL] Database connection failed

The AI can only analyze information that is sent to it. Therefore, the log file contents must be included in the API request.

Why We Use a System Message
system_message = (
"You are an auditor..."
)

The system message provides instructions that guide the AI's behavior.

In this lab, it tells the AI to:

Act as an auditor.
Focus on the [CRITICAL] log entry.
Identify the error type.
Describe the immediate impact.
Avoid summarizing the entire log file.

Think of the system message as the rules the AI must follow.

Why We Use a User Message
user_message = f"""
Analyze the following log file.

Log Content:
{log_content}
"""

The user message contains the actual data that the AI will analyze.

It includes the full contents of the log file.

Think of it this way:

System message = instructions
User message = data

The AI follows the instructions from the system message while analyzing the data in the user message.

Why We Use a Low Temperature
temperature=0.1

Temperature controls how creative the AI is.

A low temperature:

Produces more consistent responses.
Reduces randomness.
Focuses on factual information.
Helps generate reliable summaries.

This is ideal for log analysis because accuracy is more important than creativity.

How the API Processes the Logs
The script reads the log file.
The log contents are added to the user message.
The system message tells the AI what to look for.
The request is sent to the AI model.
The AI finds the critical issue and summarizes it.
The summary is returned and printed to the terminal.
Example Output

If the critical log entry is:

[CRITICAL] Database connection failed

The AI might return:

Error Type: Database Connection Failure
Immediate Impact: Application cannot access backend data and user requests may fail.

Only the summary is printed to the console, making it easy for engineers to quickly understand the problem.

Resources & Next Steps

📦 Full Code Repository: KodeKloud Learning Labs

💬 Join Discussion: DEV Community - Share your thoughts and questions

💼 Let's Connect: LinkedIn - I'd love to connect with you

Credits

• All labs are from: KodeKloud

• I sincerely appreciate your provision of these valuable resources.

1.Generate Commit Messages with AI

Thu Kha Kyawe — Sat, 13 Jun 2026 23:30:00 +0000

Lab Information

The xfusion AI Development Team is building intelligent developer-assistance tools that enhance productivity and communication across engineering workflows. Continuing this mission, you are tasked to develop a Python-based AI Commit Generator that analyzes code change descriptions and produces clean, Conventional Commit–style messages — ensuring consistency and clarity in version control histories.

Your task is to build a function that takes a summary of code changes and generates a formal Git commit message adhering to the Conventional Commit standard (: ). The file /root/openaiproject/commit_generator.py is ready.

Initialize the OpenAI client using api_key & base_url credentials provided under root/.bash_profile.

Define a function named generate_commit(changes: str) -> str.

Construct a detailed prompt asking the AI to:
    Analyze the input changes.
    Choose the appropriate commit type from: feat, fix, or docs.
    Generate a concise subject (under 50 characters).
    The output must be only the commit message in the exact format: <type>: <subject>.

Send this prompt to the API using the following parameters:
    model: openai/gpt-4.1-mini
    messages: [{\"role\": \"user\", \"content\": prompt}]
    max_tokens: 30
    temperature: 0.0 (for strict formatting)

In the main execution, call the function with the changes summary:
    Summary: 'Added a new user registration endpoint and fixed a typo in the README file.'

Print only the generated commit message to the console.

Notes:

The final output must be a single line of text.

The output must contain a colon (:) exactly once, separating the type and subject.

Ensure the commit type correctly matches the primary nature of the change (e.g., feat for new functionality, fix for a bug correction, docs for documentation updates).

Use hardcoded values for api_key and base_url when initializing the OpenAI client or read them from environment variables via os.environ.get('OPENAI_API_KEY') and os.environ.get('OPENAI_BASE_URL').

Before running commit_generator.py, create and activate a virtual environment, then install OpenAI using:

python3 -m venv venv && source venv/bin/activate && pip install openai

The script should strictly output only the formatted commit message, with no additional commentary or lines.

You are allowed a maximum of 10 requests. After this, you may encounter a rate limiter error. Therefore, use your requests judiciously.

Lab Solutions

Part 1: Lab Step-by-Step Guidelines

Step 1 — Navigate to the Project Directory

cd /root/openaiproject

Step 2 — Create and Activate a Virtual Environment

Run:

python3 -m venv venv
source venv/bin/activate

Step 3 — Install OpenAI SDK

pip install openai

Step 4 — Open the Python File

Edit the file:

vi commit_generator.py

Replace everything with:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("OPENAI_API_KEY"),
    base_url=os.environ.get("OPENAI_API_BASE")
)


def generate_commit(changes: str) -> str:
    prompt = f"""
Analyze the following code changes and generate a Conventional Commit message.

Rules:
- Choose only one commit type from: feat, fix, docs
- Format must be exactly: <type>: <subject>
- Subject must be concise and under 50 characters
- Output only the commit message
- Do not include quotes or extra text

Changes:
{changes}
"""

    response = client.chat.completions.create(
        model="openai/gpt-4.1-mini",
        messages=[
            {
                "role": "user",
                "content": prompt
            }
        ],
        max_tokens=30,
        temperature=0.0
    )

    return response.choices[0].message.content.strip()


if __name__ == "__main__":
    changes = (
        "Added a new user registration endpoint and "
        "fixed a typo in the README file."
    )

    commit_message = generate_commit(changes)

    print(commit_message)

Save and exit:

Step 5 — Load Environment Variables

Run:

source /root/.bash_profile

Step 6 — Execute the Script

python commit_generator.py

Step 7 — Verify Output

Expected format example:

feat: add user registration endpoint

Requirements:

Single line only
Exactly one colon
Conventional Commit format

Part 2: Simple Beginner-Friendly Explanation

What This Lab Does

You are building a small AI-powered Git commit message generator.

Instead of manually writing commit messages, the AI:

Reads a summary of code changes
Understands the main purpose
Generates a clean Conventional Commit message

Why Conventional Commits Matter
Conventional Commits keep Git history organized.

Examples:

feat: add login API
fix: resolve crash on startup
docs: update installation guide

This helps teams:
Read project history easily
Automate changelogs
Understand changes quickly

What the Code Is Doing

Importing Libraries
from openai import OpenAI
This imports the OpenAI SDK so Python can talk to the AI model.
Creating the Client
client = OpenAI(
api_key=os.environ.get("OPENAI_API_KEY"),
base_url=os.environ.get("OPENAI_BASE_URL")
)

This connects your script to the AI API using credentials stored in .bash_profile.

Defining the Function def generate_commit(changes: str) -> str:

This function:
Accepts a change summary
Sends it to the AI
Returns a commit message

Building the Prompt prompt = f""" ... """

The prompt tells the AI:
Use only feat, fix, or docs
Follow exact formatting
Keep subject short
Output only the commit message
Good prompts produce reliable outputs.

Sending the API Request response = client.chat.completions.create(

This sends your prompt to the AI model.
Important settings:
temperature=0.0
→ Makes output predictable and strict
max_tokens=30
→ Prevents long responses

Extracting the Response
return response.choices[0].message.content.strip()
This gets only the generated commit message text.
Running the Script
print(commit_message)
This prints the final commit message to the terminal.

Example:
feat: add user registration endpoint

Resources & Next Steps

📦 Full Code Repository: KodeKloud Learning Labs

💬 Join Discussion: DEV Community - Share your thoughts and questions

💼 Let's Connect: LinkedIn - I'd love to connect with you

Credits

• All labs are from: KodeKloud

• I sincerely appreciate your provision of these valuable resources.

Day 9: Create a Custom ML Project Template with Cookiecutter

Thu Kha Kyawe — Sat, 13 Jun 2026 13:56:31 +0000

Lab Information

The xFusionCorp Industries ML platform team maintains a Cookiecutter template that new ML projects are generated from. A draft template exists at /root/code/mlops-template/, but it does not render. Correct the template and use it to generate a project.

A Cookiecutter template exists at /root/code/mlops-template/. cookiecutter is installed system-wide.

The corrected template must satisfy every one of the following:
    The cookiecutter.json declares four variables:
        project_name (default my-ml-project)
        author (default xFusionCorp)
        python_version (default 3.11)
        ml_framework with the choices sklearn, pytorch, and tensorflow
    The generated requirements.txt logic:
        Contains scikit-learn when ml_framework is sklearn
        Contains torch when ml_framework is pytorch
        Contains tensorflow when ml_framework is tensorflow
    The generated README.md content:
        Must reference both the project_name and the author from cookiecutter variables.
    The template directory structure {{cookiecutter.project_name}}/ must contain:
        Files: README.md and requirements.txt
        Directories: data/, models/, src/, and tests/

Review the existing template in the VS Code explorer and correct everything that prevents it from rendering.

Once the template renders, generate a project at /root/code/churn-model/:

cookiecutter /root/code/mlops-template/ -o /root/code/ --no-input project_name=churn-model ml_framework=sklearn

The generated project must contain a requirements.txt listing scikit-learn and a README.md that mentions xFusionCorp.

Lab Solutions

✅ Part 1: Lab Step-by-Step Guidelines

This is a Cookiecutter template repair and generation task.

Inspect the existing template

cd /root/code/mlops-template
find . -type f

Check:

cat cookiecutter.json
find . -type d

Correct cookiecutter.json

It must contain exactly these variables and defaults:

{
    "project_name": "my-ml-project",
    "author": "xFusionCorp",
    "python_version": "3.11",
    "ml_framework": [
        "sklearn",
        "pytorch",
        "tensorflow"
    ]
}

Ensure template directory name is correct

Cookiecutter project template directory must be:

{{cookiecutter.project_name}}/

Inside it create:

{{cookiecutter.project_name}}/
├── README.md
├── requirements.txt
├── data/
├── models/
├── src/
└── tests/

Fix README.md

README must reference both variables:

# {{ cookiecutter.project_name }}

Created by {{ cookiecutter.author }}.

Fix requirements.txt conditional logic

Use Jinja conditionals:

{% if cookiecutter.ml_framework == 'sklearn' %}
scikit-learn
{% elif cookiecutter.ml_framework == 'pytorch' %}
torch
{% elif cookiecutter.ml_framework == 'tensorflow' %}
tensorflow
{% endif %}

Generate the project

Run exactly:

cookiecutter /root/code/mlops-template/ \
-o /root/code/ \
--no-input \
project_name=churn-model \
ml_framework=sklearn

Verify output

apt update
apt install -y tree
tree /root/code/churn-model

Check README:

cat /root/code/churn-model/README.md

Expected Output:

root@controlplane ~/code/mlops-template ➜  cat /root/code/churn-model/README.md
# churn-model

Check requirements:

cat /root/code/churn-model/requirements.txt

Expected Output:

root@controlplane ~/code/mlops-template ➜  cat /root/code/churn-model/requirements.txt
scikit-learn

🧠 Part 2: Simple Step-by-Step Explanation (Beginner Friendly)

What is broken? A Cookiecutter template is a project blueprint. Cookiecutter reads:

cookiecutter.json
template folders
template files

and generates a new project.

If any variable names, folder names, or Jinja syntax are wrong, rendering fails.

Why do we need cookiecutter.json? This file tells Cookiecutter which values users can provide.

Required values:

Variable Default
project_name my-ml-project
author xFusionCorp
python_version 3.11
ml_framework sklearn / pytorch / tensorflow

Why use {{cookiecutter.project_name}}? Cookiecutter replaces:

with:

churn-model

when generating the project.

So the generated folder becomes:

/root/code/churn-model

Why use Jinja conditions in requirements.txt?

The lab wants different packages depending on the framework.

If:

ml_framework=sklearn

then output:

scikit-learn

If:

ml_framework=pytorch

then output:

torch

If:

ml_framework=tensorflow

then output:

tensorflow

Jinja if/elif statements make this happen automatically.

Resources & Next Steps

📦 Full Code Repository: KodeKloud Learning Labs

💬 Join Discussion: DEV Community - Share your thoughts and questions

💼 Let's Connect: LinkedIn - I'd love to connect with you

Credits

• All labs are from: KodeKloud

• I sincerely appreciate your provision of these valuable resources.

🚀 Exciting opportunity for anyone looking to build a strong foundation in AI and Cloud!

Thu Kha Kyawe — Fri, 12 Jun 2026 11:09:56 +0000

AWS and Pearson VUE have launched a special offer that makes it easier than ever to start your certification journey:

✅ Get 50% off the AWS Certified AI Practitioner (AIF-C01) exam using the promo code AIF2CLOUD

✅ Pass the AI Practitioner exam and receive a FREE voucher for the AWS Certified Cloud Practitioner exam

This initiative is designed for both technical and non-technical professionals who want to understand AI, Generative AI, machine learning concepts, and cloud fundamentals without requiring prior coding or engineering experience.

As AI continues to transform every industry, combining AI literacy with cloud knowledge is becoming an increasingly valuable skill set. This is a great opportunity to validate your knowledge while accelerating your learning path in the AWS ecosystem.

Here is official link: https://www.pearsonvue.com/us/en/aws/aif2cloud.html

Day 8: Configure Pre-Commit Hooks for ML Repository

Thu Kha Kyawe — Thu, 11 Jun 2026 11:12:47 +0000

Lab Information

The xFusionCorp Industries ML team enforces code quality on every commit via pre-commit. A draft .pre-commit-config.yaml exists in the git repository at /root/code/fraud-detection/, but it does not match the team's standard and pre-commit run --all-files fails against it. Correct the configuration.

A git repository already exists at /root/code/fraud-detection/ with .pre-commit-config.yaml and process.py already tracked. pre-commit is installed system-wide.

The corrected configuration must declare the following five hooks so that pre-commit run --all-files executes every one of them:
    trailing-whitespace, end-of-file-fixer, and check-yaml – All three sourced from the pre-commit/pre-commit-hooks repository, pinned to a current release;
    ruff – Sourced from the astral-sh/ruff-pre-commit repository, pinned to a current release;
    black – Sourced from the psf/black-pre-commit-mirror repository, pinned to a current release.

Every repository entry in the configuration must include a rev: field.

Review the existing .pre-commit-config.yaml and correct everything that prevents the hooks above from running.

Once the configuration is correct, register the hooks with git and run them against the tracked files:

pre-commit install
pre-commit run --all-files

Tip: pre-commit autoupdate queries each referenced repository and rewrites the rev: pins to the latest released tag. This is the standard way to discover current versions without looking them up by hand.

Lab Solutions

🧭 Part 1: Lab Step-by-Step Guidelines

Step 1 — Move into the Repository

cd /root/code/fraud-detection

Step 2 — Inspect the Current Configuration

cat .pre-commit-config.yaml

Look for:

missing hooks
missing rev: fields
incorrect repository URLs
outdated configuration structure
Step 3 — Create a Valid Configuration

Edit the file:

vi .pre-commit-config.yaml

Use a configuration like this:

repos:
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v0.0.0
    hooks:
      - id: trailing-whitespace
      - id: end-of-file-fixer
      - id: check-yaml

  - repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.0.0
    hooks:
      - id: ruff

  - repo: https://github.com/psf/black-pre-commit-mirror
    rev: v0.0.0
    hooks:
      - id: black

Step 4 — Update to Current Releases

Run:

pre-commit autoupdate

Example Output:

root@controlplane fraud-detection on  main via 🐍 v3.12.3 ➜  pre-commit autoupdate
[https://github.com/pre-commit/pre-commit-hooks] updating v0.0.0 -> v6.0.0
[https://github.com/astral-sh/ruff-pre-commit] updating v0.0.0 -> v0.15.16
[https://github.com/psf/black-pre-commit-mirror] updating v0.0.0 -> 26.5.1

This automatically:

discovers current released tags
updates all rev: values
satisfies the lab requirement that repositories are pinned to current releases

Verify:

cat .pre-commit-config.yaml

You should now see real version tags instead of placeholders.

root@controlplane fraud-detection on  main [!] via 🐍 v3.12.3 ➜  cat .pre-commit-config.yaml
repos:
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v6.0.0
    hooks:
      - id: trailing-whitespace
      - id: end-of-file-fixer
      - id: check-yaml

  - repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.15.16
    hooks:
      - id: ruff

  - repo: https://github.com/psf/black-pre-commit-mirror
    rev: 26.5.1
    hooks:
      - id: black

Step 5 — Install the Hooks

pre-commit install

Expected output:

pre-commit installed at .git/hooks/pre-commit

Step 6 — Run All Hooks

pre-commit run --all-files

Expected output:

root@controlplane fraud-detection on  main [!] via 🐍 v3.12.3 ➜  pre-commit run --all-files
[INFO] Initializing environment for https://github.com/pre-commit/pre-commit-hooks.
[INFO] Initializing environment for https://github.com/astral-sh/ruff-pre-commit.
[INFO] Initializing environment for https://github.com/psf/black-pre-commit-mirror.
[INFO] Installing environment for https://github.com/pre-commit/pre-commit-hooks.
[INFO] Once installed this environment will be reused.
[INFO] This may take a few minutes...
[INFO] Installing environment for https://github.com/astral-sh/ruff-pre-commit.
[INFO] Once installed this environment will be reused.
[INFO] This may take a few minutes...
[INFO] Installing environment for https://github.com/psf/black-pre-commit-mirror.
[INFO] Once installed this environment will be reused.
[INFO] This may take a few minutes...
trim trailing whitespace.................................................Failed
- hook id: trailing-whitespace
- exit code: 1
- files were modified by this hook

Fixing process.py

fix end of files.........................................................Failed
- hook id: end-of-file-fixer
- exit code: 1
- files were modified by this hook

Fixing .pre-commit-config.yaml

check yaml...............................................................Passed
ruff (legacy alias)......................................................Passed
black....................................................................Passed

🧠 Part 2: Simple Beginner-Friendly Explanation

What is Pre-Commit?
Pre-commit is a tool that automatically checks code before it is committed to Git.

It helps catch:
formatting problems
linting issues
whitespace errors
configuration mistakes

before code reaches the repository.

What is .pre-commit-config.yaml?
This file tells pre-commit:

which checks to run
where the hooks come from
which versions to use

Each hook is downloaded from a Git repository.

Why rev: Is Required
Example:

repo: https://github.com/pre-commit/pre-commit-hooks rev: v6.0.0

The rev: field pins the hook to a specific release.

Benefits:
reproducible behavior
same version for every developer
prevents unexpected changes

The lab requires every repository entry to have a rev: field.

Understanding the Required Hooks
trailing-whitespace
Removes spaces at the ends of lines.
Bad:
hello···

Good:
hello

end-of-file-fixer
Ensures files end with a single newline.
Many tools expect this format.

check-yaml
Validates YAML syntax.
Useful for files such as:
.pre-commit-config.yaml
docker-compose.yml

ruff
Runs Ruff linting checks on Python code.
Detects:
unused imports
syntax issues
import ordering problems

black
Formats Python code automatically.
Ensures all developers use the same code style.

What pre-commit autoupdate Does
Command:
pre-commit autoupdate
automatically updates:
rev:
to the latest released versions.
This is the recommended way to obtain current release tags.

Why You May Need to Run Hooks Twice
Some hooks automatically fix files.
Example:
Black reformats Python code
trailing-whitespace removes extra spaces

The first run modifies files.
The second run verifies everything is clean.

Resources & Next Steps

📦 Full Code Repository: KodeKloud Learning Labs

💬 Join Discussion: DEV Community - Share your thoughts and questions

💼 Let's Connect: LinkedIn - I'd love to connect with you

Credits

• All labs are from: KodeKloud

• I sincerely appreciate your provision of these valuable resources.

Day 7: Package an ML Project as Installable Python Package

Thu Kha Kyawe — Wed, 10 Jun 2026 14:55:56 +0000

Lab Information

The xFusionCorp Industries deployment team needs the fraud-detection model code packaged as an installable Python distribution. A draft pyproject.toml exists at /root/code/fraud-detection/, but it does not build a wheel that meets the team's standard. Correct the file and produce a compliant package.

The project at /root/code/fraud-detection/ already contains the source code under src/fraud_detection/. The Python files are complete—you do not need to modify any of them.

The corrected pyproject.toml must satisfy every one of the following:
    it declares a [build-system] section with requires = ["setuptools>=61.0", "wheel"] and build-backend = "setuptools.build_meta";
    name is fraud_detection (the distribution name must match the module path under src/);
    version is 0.1.0;
    requires-python is >=3.10;
    dependencies is ["scikit-learn", "pandas", "numpy"].

Review the existing pyproject.toml and correct everything that does not match the requirements above.

Build the package from the project directory:

cd /root/code/fraud-detection
python3 -m build

The build must produce a wheel named fraud_detection-0.1.0-*.whl under dist/.

The build package is already installed. Use python3 rather than python.

Lab Solutions

🧭 Part 1: Lab Step-by-Step Guidelines

Step 1 — Move into the project directory

cd /root/code/fraud-detection

Step 2 — Inspect the existing pyproject.toml

cat pyproject.toml

Look for:

missing [build-system]
incorrect package name
wrong version
missing dependencies
incorrect Python version requirement

Step 3 — Fix pyproject.toml

Open the file:

vi pyproject.toml

Replace the contents with:

[build-system]
requires = ["setuptools>=61.0", "wheel"]
build-backend = "setuptools.build_meta"

[project]
name = "fraud_detection"
version = "0.1.0"
requires-python = ">=3.10"
dependencies = [
    "scikit-learn",
    "pandas",
    "numpy"
]

[tool.setuptools.packages.find]
where = ["src"]

Step 4 — Build the Package

Run exactly:

python3 -m build

Expected output:

root@controlplane ~/code/fraud-detection via 🐍 v3.12.3 ✖ python3 -m build
* Creating isolated environment: venv+pip...
* Installing packages in isolated environment:
  - setuptools>=61.0
  - wheel
* Getting build dependencies for sdist...
running egg_info
creating src/fraud_detection.egg-info
writing src/fraud_detection.egg-info/PKG-INFO
writing dependency_links to src/fraud_detection.egg-info/dependency_links.txt
writing requirements to src/fraud_detection.egg-info/requires.txt
writing top-level names to src/fraud_detection.egg-info/top_level.txt
writing manifest file 'src/fraud_detection.egg-info/SOURCES.txt'
reading manifest file 'src/fraud_detection.egg-info/SOURCES.txt'
writing manifest file 'src/fraud_detection.egg-info/SOURCES.txt'
* Building sdist...
running sdist
running egg_info
writing src/fraud_detection.egg-info/PKG-INFO
writing dependency_links to src/fraud_detection.egg-info/dependency_links.txt
writing requirements to src/fraud_detection.egg-info/requires.txt
writing top-level names to src/fraud_detection.egg-info/top_level.txt
reading manifest file 'src/fraud_detection.egg-info/SOURCES.txt'
writing manifest file 'src/fraud_detection.egg-info/SOURCES.txt'
warning: sdist: standard file not found: should have one of README, README.rst, README.txt, README.md

running check
creating fraud_detection-0.1.0
creating fraud_detection-0.1.0/src/fraud_detection
creating fraud_detection-0.1.0/src/fraud_detection.egg-info
copying files to fraud_detection-0.1.0...
copying pyproject.toml -> fraud_detection-0.1.0
copying src/fraud_detection/__init__.py -> fraud_detection-0.1.0/src/fraud_detection
copying src/fraud_detection/predict.py -> fraud_detection-0.1.0/src/fraud_detection
copying src/fraud_detection.egg-info/PKG-INFO -> fraud_detection-0.1.0/src/fraud_detection.egg-info
copying src/fraud_detection.egg-info/SOURCES.txt -> fraud_detection-0.1.0/src/fraud_detection.egg-info
copying src/fraud_detection.egg-info/dependency_links.txt -> fraud_detection-0.1.0/src/fraud_detection.egg-info
copying src/fraud_detection.egg-info/requires.txt -> fraud_detection-0.1.0/src/fraud_detection.egg-info
copying src/fraud_detection.egg-info/top_level.txt -> fraud_detection-0.1.0/src/fraud_detection.egg-info
copying src/fraud_detection.egg-info/SOURCES.txt -> fraud_detection-0.1.0/src/fraud_detection.egg-info
Writing fraud_detection-0.1.0/setup.cfg
Creating tar archive
removing 'fraud_detection-0.1.0' (and everything under it)
* Building wheel from sdist
* Creating isolated environment: venv+pip...
* Installing packages in isolated environment:
  - setuptools>=61.0
  - wheel
* Getting build dependencies for wheel...
running egg_info
writing src/fraud_detection.egg-info/PKG-INFO
writing dependency_links to src/fraud_detection.egg-info/dependency_links.txt
writing requirements to src/fraud_detection.egg-info/requires.txt
writing top-level names to src/fraud_detection.egg-info/top_level.txt
reading manifest file 'src/fraud_detection.egg-info/SOURCES.txt'
writing manifest file 'src/fraud_detection.egg-info/SOURCES.txt'
* Building wheel...
running bdist_wheel
running build
running build_py
creating build/lib/fraud_detection
copying src/fraud_detection/predict.py -> build/lib/fraud_detection
copying src/fraud_detection/__init__.py -> build/lib/fraud_detection
running egg_info
writing src/fraud_detection.egg-info/PKG-INFO
writing dependency_links to src/fraud_detection.egg-info/dependency_links.txt
writing requirements to src/fraud_detection.egg-info/requires.txt
writing top-level names to src/fraud_detection.egg-info/top_level.txt
reading manifest file 'src/fraud_detection.egg-info/SOURCES.txt'
writing manifest file 'src/fraud_detection.egg-info/SOURCES.txt'
installing to build/bdist.linux-x86_64/wheel
running install
running install_lib
creating build/bdist.linux-x86_64/wheel
creating build/bdist.linux-x86_64/wheel/fraud_detection
copying build/lib/fraud_detection/predict.py -> build/bdist.linux-x86_64/wheel/./fraud_detection
copying build/lib/fraud_detection/__init__.py -> build/bdist.linux-x86_64/wheel/./fraud_detection
running install_egg_info
Copying src/fraud_detection.egg-info to build/bdist.linux-x86_64/wheel/./fraud_detection-0.1.0-py3.12.egg-info
running install_scripts
creating build/bdist.linux-x86_64/wheel/fraud_detection-0.1.0.dist-info/WHEEL
creating '/root/code/fraud-detection/dist/.tmp-k44hfcde/fraud_detection-0.1.0-py3-none-any.whl' and adding 'build/bdist.linux-x86_64/wheel' to it
adding 'fraud_detection/__init__.py'
adding 'fraud_detection/predict.py'
adding 'fraud_detection-0.1.0.dist-info/METADATA'
adding 'fraud_detection-0.1.0.dist-info/WHEEL'
adding 'fraud_detection-0.1.0.dist-info/top_level.txt'
adding 'fraud_detection-0.1.0.dist-info/RECORD'
removing build/bdist.linux-x86_64/wheel
Successfully built fraud_detection-0.1.0.tar.gz and fraud_detection-0.1.0-py3-none-any.whl

Step 5 — Verify the Wheel File

Check the dist/ directory:

ls dist/

Expected wheel name pattern:

Example:

fraud_detection-0.1.0-py3-none-any.whl fraud_detection-0.1.0.tar.gz

🧠 Part 2: Simple Beginner-Friendly Explanation

What is this lab about?

This lab focuses on packaging a Python project into an installable distribution.

The goal is to:

configure the project correctly
build a Python wheel package
make the ML code installable on other systems

What is pyproject.toml?
pyproject.toml is the modern Python project configuration file.

It defines:
project metadata
dependencies
build system configuration
packaging settings

It replaces older files like:
setup.py
setup.cfg

in many modern Python projects.
Understanding the [build-system] Section

The lab requires:

[build-system]
requires = ["setuptools>=61.0", "wheel"]
build-backend = "setuptools.build_meta"

This tells Python:
which tools are needed to build the package
which backend performs the build

Why setuptools and wheel Are Required
Package Purpose
setuptools Builds Python packages
wheel Creates .whl files

Without these:
package building may fail

Why the Package Name Matters
The lab requires:
name = "fraud_detection"
This must match the module directory:
src/fraud_detection/
Using a different name can break:

imports
packaging
installation

What requires-python Means
Required setting:
requires-python = ">=3.10"
This means:
the package only supports Python 3.10 or newer.

Why Dependencies Are Declared
Required dependencies:

dependencies = [
"scikit-learn",
"pandas",
"numpy"
]

When someone installs the package:
these libraries install automatically

What python3 -m build Does

Command:
python3 -m build
performs the packaging process.

It creates:

source distribution (.tar.gz)
wheel distribution (.whl)

inside:

dist/

What Is a Wheel File?
A wheel (.whl) is a standard Python package format.

Example:
fraud_detection-0.1.0-py3-none-any.whl

It allows fast installation using:
pip install package.whl

Why python3 Must Be Used
The lab explicitly requires:

python3 -m build

instead of:

python -m build

This guarantees the correct Python interpreter is used.