This post provides a step-by-step process for installing and setting up the BMAD Method for Roo Code, which integrates AI with Agile methodologies to enhance software development. It covers prerequisites, installation steps, and customisation options that streamlines workflows and automates tasks, improving the SDLC (Software Development Life-Cycle) for many software solutions.

Attributions:

• The BMAD GitHub Repo ↗, and

• The BMAD Website ↗.

An Introduction.

This guide walks through the installation and setup of BMAD for Roo Code, a framework for integrating AI with Agile methodologies which improves my software development efficiency.

The purpose of this post is to show how to setup the BMAD Method so that it works with Roo Code.

The Big Picture.

BMAD for Roo Code is essential for my understanding of how to effectively integrate AI with Agile methodologies. This guide walks through the installation and setup process, providing insights into how the BMAD Method enhances my software development by enhancing many, tedious tasks. By following the steps outlined in this post, the result is a streamlined workflow for leveraging innovations that boosts my effectiveness when creating my projects.

NOTE: The following process results in a single installation that is used across multiple projects.

Prerequisites.

• A Debian-based Linux distro (I use Ubuntu),

• The Roo Code Extension,

• VS Code, and

• Node v20+.

Updating my Base System.

• From the (base) terminal, I update my (base) system:

sudo apt clean && \
sudo apt update && \
sudo apt dist-upgrade -y && \
sudo apt --fix-broken install && \
sudo apt autoclean && \
sudo apt autoremove -y

NOTE: The Ollama LLM manager is already installed on my (base) system.

What is the BMAD Method?

BMAD is a framework that integrates AI with Agile methodologies that streamlines software development. It utilises specialised AI agents to manage tasks and automate repetitive processes, which improves the SDLC (Software Development Life-Cycle) for many software projects.

Installing the BMAD Method.

From the terminal, I install the BMAD Method:

npx bmad-method install

• On the next screen, I provide the full path to my installation directory and tap the ENTER key:

NOTE: As I am already in the installation directory, I type a period (.) to install BMAD into the current location.

• On the next screen, I use the up/down arrow keys to move the selector, use the SPACEBAR to select/deselect multiple options, and hit the ENTER key:

• On the next two screens, I type ‘y’ for both of the document sharding options, and hit the ENTER key:

NOTE: Sharding is used to intelligently break large documents into a collection of smaller documents. The purpose of sharding is to provide LLMs with prompts that do not overwhelm the context window.

• On the next screen, I use the up/down arrow keys to move the selector and the SPACEBAR to make my selections, and then I tap the ENTER key:

• On the final screen, I type ‘n’ to bypass the installation of pre-built web bundles, and hit the ENTER key:

• Here is the screen after a successful installation:

• And here is the installation directory:

Editing the .roomodes & .kilocodemodes Files.

The trick to using a single instance or BMAD across multiple projects is to:

• Open the files in a text editor,

• Changing every instance of a relative to an absolute path and saving the results, and

• Adding copies of these files into the root directories of every project.

In this post, for example, the installation directory is /home/brian/.roo/commands, so in the .roocodes and .kilocodemodes files I would change a relative path, like .bmad-core/agents/ux-expert.md, so that it becomes an absolute path, like /home/brian/.roo/commands/.bmad-core/agents/ux-expert.md.

BMAD v6.

I also install BMAD v6 into the same location. Here is the installation command for BMAD v6 (currently in Public Alpha):

npx bmad-method@alpha install

The Results.

The installation and setup of the BMAD Method for Roo Code provides a robust framework for integrating AI with Agile methodologies, enhancing the software development process. By following the detailed steps outlined, I can effectively implement the BMAD Method, customise Roo Code with new modes, and create reusable slash commands to streamline my workflow. This approach not only automates repetitive tasks but also fosters improved collaboration and efficiency throughout the software development life cycle. As I continue to explore and utilise these tools, I must remember to adapt and customise these utilities to best fit the unique needs of each project.

In Conclusion.

I learned how to seamlessly integrate AI with Agile methodologies using the BMAD Method for Roo Code. This comprehensive guide covered the installation, setup, and customisations that enhances my software development processes and automates many of the tasks I perform. The BMAD method is perfect for developers looking to streamline their workflow with innovative tools.

Until next time: Be safe, be kind, be awesome.

Hash Tags.

#BMADMethod #RooCode #AIMethodologies #AgileDevelopment #SoftwareDevelopment #WorkflowAutomation #VSCode #NodeJS #TechGuide #SoftwareEfficiency

This post is a comprehensive walk-through on how I install PVE (Proxmox Virtual Environment) on a spare PC. I cover the step-by-step installation process, and tips for optimizing the virtual environment. This article is ideal for tech enthusiasts who want to maximize the capabilities of their Homelab by setting up a robust virtualization platform that supports both containers and virtual machines.

Attributions:

A post from Proxmox ↗ on setting up a Proxmox VE virtual machine ↗, and

A video from Tailscale ↗ about installing Proxmox VE on a PC ↗.

An Introduction.

Containers and virtual machines are technologies that allow operating systems and applications to be isolated within a runtime environment. Depending on the hardware specifications, PVE allows multiple containers and virtual machines to run on a single PC:

The purpose of this post is to demonstrate how I install PVE and create a container.

The Big Picture.

Learn how I efficiently install PVE on a spare PC with this comprehensive guide. Discover the prerequisites, step-by-step installation process, and tips that I use to optimize my virtual environment setup. PVE is perfect for tech enthusiasts looking to maximize their Homelab PCs.

Prerequisites.

• A Debian-based Linux distro (I use Ubuntu),

• A USB Thumb Drive.

Updating my Base System.

• From the (base) terminal, I update my (base) system:

sudo apt clean && \
sudo apt update && \
sudo apt dist-upgrade -y && \
sudo apt --fix-broken install && \
sudo apt autoclean && \
sudo apt autoremove -y

NOTE: The Ollama LLM manager is already installed on my (base) system.

What are the Specs for my Spare PC?

An Intel NUC (Next Unit of Computing) is a small-form-factor computer designed by Intel, which offers a compact and powerful computing solution. This PC typically comes without RAM, storage, or an operating system, allowing me to customize the hardware according to my needs.

NUC Specifications.

Hardware Specifications.

What is PVE?

PVE (Proxmox Virtual Environment) is an open-source virtualization platform designed for setting up hyper-converged infrastructure and, under the GNU AGPLv3 license, can be used for commercial purposes. It lets me deploy and manage containers and virtual machines. PVE is built on a modified Debian LTS (Long Term Service) kernel, and supports two types of virtualization: containers with LXC (Linux Containers) and virtual machines with KVM (Kernel-level Virtual Machines). PVE features a web-based management interface, and there is also a mobile app available for managing PVEs.

Creating a PVE Installation Thumb Drive.

• I download the PVE ISO file from https://proxmox.com/en/downloads/proxmox-virtual-environment/iso.

• I grab a 32GB thumb drive and label it.

• I plug the thumb drive into my PC.

• I start the balenaEtcher-1.14.3-x64.AppImage imaging utility that runs on Ubuntu.

NOTE: There are versions of Balena Etcher for Windows, macOS, and (x64 & x86) Linux.

• I select the 1.57GB ISO file as the source, the 32GB thumb drive as the target, and then I click the blue Flash button.

• After the ISO has been successfully flashed onto the thumb drive, I eject the thumb drive and remove it from my PC.

Installing PVE.

NOTE: PVE requires at least 3 drives that are directly connected to the NUC. I have an internal 256GB M.2 drive that uses the NVMe interface labelled prox-int-nvme, an internal 256GB SSD that uses the SATA interface which has been split into 2 × 128GB partitions labelled prox-int-sata1 & prox-int-sata2, and an external 2TB HDD that uses the USB 3.0 interface labelled prox-ext-usb3. These configurations will be altered during the PVE setup process.

• I plug the PVE installation thumb drive into the NUC.

• I power up the NUC.

• I follow the installation instructions.

• I use the following network settings that work on my LAN:

NOTE: During the Management Network Configuration setup, I can use IPv4 or IPv6 but I CANNOT mix the 2 protocols. The Management Interface is the name of the NIC (Network Interface Card) that is installed in the NUC which, in my case, is eno1. The Hostname (FQDN) only matters if I intend to open, and host, PVE over the Internet. The IP Address (CIDR) is 192.168.0.60/24. The PVE tells the router that this is the IP address it wants. The Gateway is the IP address of my router, which is 192.168.0.1, and is needed to connect PVE to the LAN. The DHCP server is found at 192.168.0.1 because my router includes the server that is responsible for assigning IP addresses.

• After installation, the spare PC will reboot.

• At this time, I remove the USB installation thumb drive.

• At the login screen, I make a note of the PVE IP address and :port number that is displayed.

• On a PC that is connected to the same network as PVE, I open a browser, visit the IP address and :port, and bookmark that address.

• At the browser login screen, my user name is ‘root’ and my ‘password’ is the same one I gave during the installation.

• From the terminal, I SSH into PVE with root@ip_address and password.

A Note about Routers and DHCP Servers.

My router has 2 jobs:

• Connect to an ISP (Internet Service Provider) that, in turn, provides access to the Internet, and

• Route that connection to all the wired, and wireless, devices that share the LAN (Local Area Network).

As the name suggests, Internet connectivity is routed to all of the linked devices in the LAN. There are many devices, like smart phones, tablets, PCs, notebooks, and others, that use an Internet connection to improve their functionality. Many devices, like smart TVs, require that connectivity.

The problem is that all the devices that connect to the LAN require unique identifiers. These identifiers are called IP addresses. But where does a device get an IP address? To solve the IP address problem, my router has a built-in DHCP server where DHCP stands for Dynamic Host Configuration Protocol. Almost all routers have a DHCP server and the purpose of this server is to assign a dynamic IP address to every wired, and wireless, device in the LAN.

In most cases, each device in the LAN is dynamically, i.e. automatically, assigned an IP address from a pool of available, unassigned addresses. Most often, devices will use the same dynamic IP addresses when they connect to the LAN, but sometimes the DHCP server will issue a new IP address. This is a fine solution and is NOT a problem. In most cases.

Servers, however, are special use cases. PVE, as well as the containers and virtual machines it manages, require static IP addresses. My NUC 10 will need static IP addresses if it, and the containers, want to be accessible in my local LAN. The reason I need IP addresses that DO NOT CHANGE is because I will setup a Kubernetes cluster and each node needs to know how to find each other. (Setting up a cluster is beyond the scope of this post.)

Replacing dynamic IP addresses with static IP addresses requires:

• Accessing my router and making changes to the DHCP settings for each container and virtual machine (which is also beyond the scope of this post), and

• Reflecting those changes to each container and virtual machine running on PVE.

The PVE Server.

PVE (Proxmox Virtual Environment) is the server that hosts the containers and virtual machines I deploy.

Accessing PVE.

• I use a browser to login to PVE:

• On the left of the screen, I go to Datacenter > nuclab60.

• In the 2nd pane, I click ‘Shell‘.

The Helper Script.

• In a new browser tab, I visit http://helper-scripts.com/.

• I search for ‘pve post install‘.

• I copy the script command.

Running the Helper Script.

• Back in the Shell for nuclab60, I run the helper script command from the terminal:

NOTE: I answer ‘yes’ to MOST of the questions when asked but there are 3 exceptions, as listed below.

• I answer ‘no’ to ‘Disable high availability?’:

NOTE: High availability will be used when other nodes are created.

• I answer ‘no’ to ‘Update Proxmox VE now?‘:

NOTE: I will update PVE manually later in this post.

• I answer ‘no’ to ‘Reboot Proxmox VE now?‘:

NOTE: I will reboot once I finish updating the remote system and upgrading PVE.

• Once the script has finished, I update the system:

NOTE: The ‘sudo’ command is not required as the root account has full privileges.

• Once the updates have been downloaded, I run the ‘pveupgrade‘ command to update the system and the PVE installation:

• Due to the installation of a kernel update, I need to reboot PVE:

Preparing PVE.

Before I can create any containers or virtual machines, I need to prepare PVE and the assets it will use.

Downloading an OS to PVE.

• I use a browser to login to PVE.

• On the left of the screen, under Server View, I go to Datacenter > nuclab60 > local (nuclab60).

• In the 2nd pane, I click ISO Images.

• In the 3rd pane, I click the grey Download from URL button:

• In the pop-up modal, I add https://releases.ubuntu.com/24.04.3/ubuntu-24.04.3-live-server-amd64.iso to the URL: field so that PVE can download the ISO for Ubuntu Server 24.04.2 LTS.

• I click the blue Query URL button to check the link:

• I click the blue Download button to start the download:

• I close the modal once I receive the ‘TASK OK’ message:

Preparing the Disks.

NOTE: The following is adapted from the instructions provided by the PVE team.

• I use a browser to login to PVE.

• On the left of the screen, under Server View, I go to Datacenter > pve.

• In the 2nd pane, I click Disks.

• In the 3rd pane, I select the dev/sda drive (that currently has 2 partitions).

• I click the grey Wipe Disk button.

• In the Confirm modal, I click the blue Yes button.

• I repeat the process for the /dev/sdb disk.

• Back in the 2nd pane, I click Disks > ZFS.

• In the 3rd pane, I click the grey Create: ZFS button:

• In the Create: ZFS modal, I add the following details and then click the blue ‘Create‘ button:

NOTE: The /dev/sdb disk is an external SDD that uses the USB 3.0 interface.

Installing a Container Template.

• I use a browser to login to PVE.

• On the left of the screen, under Server View, I go to Datacenter > pve > local (pve).

• In the 2nd pane, I click CT Templates.

• In the 3rd pane, I click the grey Templates button.

• In the Templates modal, I select the ubuntu-24.04-standard template and click the blue Download button:

Now that all of the requirements are in place, I can take the next step by clicking the blue Create CT button (top-right of the screen), following the resulting prompts, and creating a container.

Creating a New Container

This container is built to be cloned. As such, there is a lot of effort that goes into building it.

“Create CT.”

• I use a browser to login to PVE.

• At the top-right of the screen, I click the blue ‘Create CT‘ button:

• I add details to the ‘General’ tab, then I click the blue ‘Next’ button:

• I select the ‘Template:’, then I click the blue ‘Next’ button:

• I select the ‘Storage:‘ (zfs-disk), set the size (56GB), then I click the blue ‘Next’ button:

• I leave the ‘Cores:‘ set to 1, then I click the blue ‘Next‘ button:

• I set the ‘Memory (MiB):’ (12288), the ‘Swap (MiB):’ (4096), then I click the blue ‘Next‘ button:

• I set the ‘IPv4/CIDR:’, ‘Gateway (IPv4):’, then I click the blue ‘Next’ button:

• I leave the DNS settings blank, then I click the blue ‘Next’ button:

• I check my settings, then I click the blue ‘Finish’ button:

“Start at boot.”

• I use a browser to login to PVE.

• On the left of the screen, under Server View, I go to Datacenter > nuclab60 > 101 (nuclab61).

• In the 2nd pane, I click Options.

• In the 3rd pane, I select “Start at boot“ from the list and click the gray Edit button.

• In the “Edit: Start at boot“ modal, I tick the “Start at boot” option followed by the blue OK button:

Creating a User Account for the Container.

• I use a browser to login to PVE.

• On the left of the screen, under Server View, I go to Datacenter > nuclab60 > 101 (nuclab61):

• I start the container.

• In the 2nd pane, I click Console.

• In the 3rd pane, I login to the container using root as the nuclab61 login: and the password I created while building the container.

• Once logged in, I create a new user account:

adduser brian

• I add the new user to the 'sudo' group:

usermod -aG sudo brian

• I log out of the root account for the container:

logout

• Towards the top-right of the console window, I open the drop down menu of the Shutdown option, by clicking the down arrow (⌄), and selecting Reboot:

Once the reboot is complete, I switch to a terminal on my local PC.

Creating an RSA Key Pair on the Local PC.

• From a terminal (CTRL + ALT + T) on my local PC, I start the ssh-agent:

eval "$(ssh-agent -s)"

• I generate a pair of RSA keys called "/home/brian/.ssh/key-name" (where I replace "key-name" with the name of the remote server):

ssh-keygen -b 4096

NOTE: It is my convention to name RSA keys after the remote server on which they will be used.

• I add the SSH key to my workstation account (where I replace "key-name" with the actual name of the ssh key):

ssh-add /home/brian/.ssh/nuclab61

Uploading the Public Key to the Remote Container.

• From the workstation terminal (CTRL + ALT + T), I use "ssh-copy-id" to upload the locally-generated public key to the remote container (where I replace "container-name" with the actual name of the container):

ssh-copy-id -i /home/brian/.ssh/nuclab61.pub brian@192.168.0.61

SSH Folder and File Permissions.

• Change the permission for the .ssh folder:

chmod 0700 /home/brian/.ssh

• Change the permission for the private key:

chmod 0600 /home/brian/.ssh/nuclab61

• Change the permission for the public key:

chmod 0644 /home/brian/.ssh/nuclab61.pub

SPECIAL NOTES

The "Permission denied (publickey)" error indicates that your SSH connection was rejected because the server could not authenticate your public key. To resolve this, ensure your public key is correctly added to your account on the server and that your private key has the correct file permissions.

Understanding the "Permission Denied (publickey)" Error

The "Permission denied (publickey)" error occurs when your SSH client cannot authenticate with the server using the provided public key. This can happen for several reasons.

Common Causes and Solutions

1. Incorrect SSH Key Configuration

• Public Key Not Added: Ensure your public key is added to the server's ~/.ssh/authorized_keys file.

• Key Format: Verify that the key is in the correct format and not corrupted.

2. SSH Key Permissions

• File Permissions: The permissions for your SSH keys must be set correctly:

  • Private key: chmod 600 ~/.ssh/id_rsa

  • Public key: chmod 644 ~/.ssh/id_rsa.pub

  • .ssh directory: chmod 700 ~/.ssh

3. SSH Agent Issues

• SSH Agent Not Running: Start the SSH agent with eval "$(ssh-agent -s)".

• Key Not Loaded: Add your private key to the agent using ssh-add ~/.ssh/id_rsa.

4. Connection User

• Correct User: Always connect using the "git" user for GitHub or the appropriate user for your server. For example, use ssh -T git@github.com.

Additional Troubleshooting Steps

• Verbose Mode: Use ssh -v user@host to get detailed output about the connection process. This can help identify where the failure occurs.

• Firewall or Network Issues: Ensure that your network allows SSH connections and that the server's firewall is not blocking your access.

By following these steps, you should be able to resolve the "Permission denied (publickey)" error and successfully connect to your server.

Logging In to the Remote Container.

• From the terminal (CTRL + ALT + T), I login to the account of the remote server:

ssh -i /home/brian/.ssh/nuclab61 'brian@192.168.0.61'

• For ‘Too many authentication failures‘, use the following:

ssh -o IdentitiesOnly=yes brian@192.168.0.61

Preparing the Container.

The next step is to prepare the container for cloning.

Updating the Container.

• I update Ubuntu:

sudo apt clean && \
sudo apt update && \
sudo apt dist-upgrade -y && \
sudo apt --fix-broken install && \
sudo apt autoclean && \
sudo apt autoremove -y

Installing the Unattended Upgrades Utility.

• I install the unattended-upgrades package:

sudo apt install unattended-upgrades

• I manually trigger an Unattended Upgrade:

sudo unattended-upgrade

NOTE: -d is the switch for running this command in debug mode.

• I check the Unattended Updates log to ensure everything is worked as expected:

sudo cat /var/log/unattended-upgrades/unattended-upgrades.log

Hardening the Container.

• I open the "sshd_config" file:

sudo nano /etc/ssh/sshd_config

• I add (CTRL + V) the following to the bottom of the "sshd_config" page, save (CTRL + S) the changes, and exit (CTRL + X) the Nano text editor:

PasswordAuthentication no
PermitRootLogin no
Protocol 2

• I restart the "ssh" service:

sudo systemctl restart ssh.service

Enabling, and Setting Up, UFW on the Container.

• I check the UFW status:

sudo ufw status

• I enable the UFW:

sudo ufw enable

• I install a UFW rule:

sudo ufw allow from 192.168.0.2

NOTE: I specify the IP address of the PC from which I will connect using SSH***.***

• I check the status of the UFW and list the rules by number:

sudo ufw status numbered

NOTE 1: UFW will, by default, block all incoming traffic, including SSH and HTTP.

NOTE 2: I will update the UFW rules as I deploy other services to the remote server.

• I can delete a UFW rule by number if needed:

sudo ufw delete 1

• I can also disable UFW if needed:

sudo ufw disable

Installing, and Setting Up, Fail2Ban on the Container.

• I install Fail2Ban:

sudo apt install -y fail2ban

• I copy the jail.conf file as jail.local:

sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local

• I open the jail.local file in Nano:

sudo nano /etc/fail2ban/jail.local

• I make the following changes to a few (SSH-centric) settings in the jail.local file, then I save (CTRL + S) those changes, and exit (CTRL + X) the Nano text editor:

[DEFAULT]
⋮
bantime = 30m
ignoreip = 127.0.0.1/8 your_ip_address
⋮
[sshd]
enabled = true
port = ssh,22

• I restart Fail2Ban:

sudo systemctl restart fail2ban

• I check the Fail2ban whitelist:

sudo fail2ban-client status

• I check the status of Fail2Ban:

sudo systemctl status fail2ban

• I enable Fail2Ban to auto-start on boot:

sudo systemctl enable fail2ban

• I reboot the container:

sudo reboot

“Clone.”

A clone is a direct, functional copy of a container that includes all of the settings from the original. After making the clones, I will adjust the settings of each so they will function correctly.

Cloning the Container.

• I use a browser to login to PVE.

• On the left of the screen, under Server View, I go to Datacenter > nuclab60.

• In the second pane, I select “Search”.

• In the third pane, I right-click the ‘101 (nuclab61)’ container and, in the pop-up menu, I click the ‘Shutdown’ option if the container is running.

• In the third pane, I right-click the ‘101 (nuclab61)’ container and, in the pop-up menu, I click the ‘Clone’ option:

• In the ‘Clone CT 101 (nuclab61)’ modal, I enter the following details, then I click the blue ‘Clone’ button:

• After a moment, a clone of the original container appears under Datacenter > nuclab60:

• I repeat this process two more times to meet my requirements.

Network Settings for Each Clone.

• I use a browser to login to PVE.

• On the left of the screen, under Server View, I go to Datacenter > nuclab60 > 101 (nuclab61).

• In the 2nd pane, I click Network.

• In the 3rd pane, I select the Network Device and click the gray, Edit button:

• In the ‘Edit: Network Device’ modal, I change:

  • the ‘Name:’,

  • Ensure the ‘IPv4:’ radio button is set to ‘Static’,

  • Ensure the ‘IPv4/CIDR:’ setting is correct, and

  • Ensure the ‘Gateway (IPv4):’ setting is correct:

• Once I confirm these settings, I click the blue OK button and repeat the process for the three remaining containers.

Setting Up the Local Terminal.

The following describes:

• How to locally generate an RSA Key Pair for an SSH connection,

• Pushing the public key to the container,

• Logging in to the remote container,

• Updating the OS that is running on the container,

• Hardening the container by changing a few settings, and

• Installing and enabling security utilities like UFW and Fail2Ban.

NOTE: These operations need to be performed for (and on) each container.

The Results.

Installing PVE (Proxmox Virtual Environment) onto a spare PC results in a compact and efficient solution for creating, and managing, containers and virtual environments. The process involves preparing the installation hardware, creating a USB drive that is used as the installation media, and configuring the system to suit my network and storage needs. By following the steps above, I can set up a robust virtualization platform that supports both containers and virtual machines. This setup not only maximizes the capabilities of the spare PC but also offers flexibility and scalability for various computing tasks.

In Conclusion.

In this guide, I created a USB installation thumb drive for PVE, installed PVE onto a spare PC, learned how to download an OS to PVE, installed CT templates, created a container, created a new account for that container, and cloned that container multiple times. By following these steps, I maximized the capabilities of the spare PC and now enjoy a robust virtualization platform that supports both containers and virtual machines. This setup offers flexibility and scalability for various computing tasks, making it perfect for tech enthusiasts and professionals alike.

Have you tried setting up PVE on a spare PC? What challenges did you face? How did you overcome those challenges? Let's discuss in the comments below!

Until next time: Be safe, be kind, be awesome.

Hash Tags.

#ProxmoxVE #pve #IntelNUC #Virtualization #Homelab #Containers #VirtualMachines #Networking #ServerSetup #ServerCluster #Linux #Debian #Ubuntu #TechGuide

This post provides a step-by-step guide on installing the WinBoat AppImage on a Debian-based Linux system, such as Ubuntu. It covers prerequisites, system updates, and the installation steps, enabling me to run Windows applications seamlessly on Linux for enhanced productivity and software access.

Attributions:

WinBoat.app ↗.

An Introduction.

This post is a comprehensive walk-through for installing WinBoat AppImage on Ubuntu 24.04 LTS, enabling Windows applications to run in a Linux environment:

The purpose of this post is to allow access to Win11 programs within Ubuntu.

The Big Picture.

WinBoat on Ubuntu bridges the gap between Linux and Windows environments, allowing me to leverage the strengths of both operating systems for enhanced productivity and software versatility.

Prerequisites.

• A Debian-based Linux distro (I use Ubuntu).

Updating my Base System.

• From the (base) terminal, I update my (base) system:

sudo apt clean && \
sudo apt update && \
sudo apt dist-upgrade -y && \
sudo apt --fix-broken install && \
sudo apt autoclean && \
sudo apt autoremove -y

NOTE: The Ollama LLM manager is already installed on my (base) system.

What is WinBoat?

WinBoat is an application that allows users to run Windows applications on Linux with seamless integration, making them feel like native apps. It uses a containerized approach to run Windows in a virtual machine, enabling access to a wide range of Windows software within a Linux environment.

Installing WinBoat.

• From the terminal, I install the libfuse2 library:

sudo apt install libfuse2

NOTE: AppImages rely on FUSE (Filesystem in Userspace) to function properly.

• From a browser, I download the AppImage file from the WinBoat.app website.

• From the file manager, I move the WinBoat app to it’s own directory.

• I copy the WinBoat logo to the WinBoat directory:

NOTE: I downloaded the WinBoat PNG logo from the Internet.

• From the terminal, I make the AppImage an executable:

chmod +x /media/brian/Downloads/Ubuntu/WinBoat/winboat-0.8.5-x86_64.AppImage

• I use the Nano text editor to create a desktop entry:

nano ~/.local/share/applications/winboat.desktop

• I paste (CTRL + SHIFT + V) the following into the desktop entry, save (CTRL + S) the changes, and exit (CTRL + X) the Nano text editor:

[Desktop Entry]
Name=WinBoat
Exec=/media/brian/Downloads/Ubuntu/WinBoat/winboat-0.8.5-x86_64.AppImage --no-sandbox
Icon=/media/brian/Downloads/Ubuntu/WinBoat/winboat-logo.png
Type=Application
Categories=OS;Distro

• From the apps menu, I pin the WinBoat app to the Dash.

The Results.

Installing the WinBoat AppImage on a Debian-based Linux system, such as Ubuntu, allows me to seamlessly run Windows applications as if they were native to Linux. By following the outlined steps, including updating the system, installing necessary libraries, and setting up the AppImage, I can enjoy the benefits of both operating systems. This integration not only enhances productivity but also expands the range of available software, making it a valuable tool for both Linux and Windows applications.

In Conclusion.

I learned how to seamlessly install the WinBoat AppImage on a Debian-based Linux system like Ubuntu. This post covered prerequisites, system updates, and step-by-step installation, enabling me to run Windows applications natively on Linux for enhanced productivity and software access.

Until next time: Be safe, be kind, be awesome.

Hash Tags.

#WinBoat #Linux #Ubuntu #AppImage #WindowsOnLinux #SeamlessIntegration #TechTutorial #Productivity #SoftwareAccess #LinuxApps

Using system images allows for efficient computer management by separating system files from personal data, ensuring easy recovery and enhancing productivity. Regularly updating and creating production images facilitates quick restoration and experimentation with new technologies, saving time and providing peace of mind.

Attributions:

None ↗.

An Introduction.

Using system images allows for efficient computer management by separating system files from personal data:

The purpose of this post is to justify the creation, and use, of operating system images.

The Big Picture.

Creating, and using, operating system images offers a range of features and benefits that enhance computer management and productivity:

1. Efficient System Management: System images allows me to capture the entire state of an operating system, including installed applications, system settings, and configurations. This makes it easy to manage and maintain systems, especially in environments with multiple computers.

2. Quick Recovery and Restoration: In the event of system failure, corruption, or malware attack, a system image can be used to quickly restore my system to a previous, stable state. This minimises downtime and ensures business continuity.

3. Separation of System and Data: By keeping system files separate from personal data, I can ensure that my important information is safe and easily recoverable. This separation also simplifies the process of updating or upgrading the operating system without affecting my personal files.

4. Experimentation and Testing: System images provide a safe environment for testing new software, updates, or configurations. I can experiment with new technologies without the risk of permanently altering my primary system setup.

5. Time-Saving: Regularly updating and creating system images reduces the time required for system setup and configuration. When a system needs to be reinstalled, the image can be deployed quickly, saving time compared to manual installation and configuration.

6. Consistency Across Systems: In organisational settings, system images ensure consistency across multiple computers. This is particularly useful for IT departments that need to deploy standardised environments across a network of machines.

7. Peace of Mind: Knowing that a reliable backup of the system exists provides peace of mind. I can be confident that I can recover my system to a working state with minimal effort.

8. Cost-Effective: By reducing the need for technical support and minimising downtime, system images can lead to cost savings for both individuals and organisations.

Overall, the use of operating system images is a practical approach to managing my computer systems, enhancing my productivity, and ensuring my data is security separated from my operating system.

Prerequisites.

• A Debian-based Linux distro (I use Ubuntu).

Updating my Base System.

• From the (base) terminal, I update my (base) system:

sudo apt clean && \
sudo apt update && \
sudo apt dist-upgrade -y && \
sudo apt --fix-broken install && \
sudo apt autoclean && \
sudo apt autoremove -y

NOTE: The Ollama LLM manager is already installed on my (base) system.

What is CloneZilla Live?

Clonezilla Live is a small, bootable GNU/Linux distribution that can be used to image, or “clone”, individual computers using an (obsolete) CD/DVD or USB flash drive.

Why I Can Re-Image My System.

I have always separated my system from my data. Over the years, I have saved my data to:

• 5¼” floppy diskettes,

• 3½” floppy diskettes,

• External serial Zip Drives,

• External USB SATA HDDs,

• External USB Enclosures with SATA SSDs, and

• External USB Enclosures with M.2 NVMe Drives.

NOTE: I was very happy to get my purplish-blue 750MB Zip drive from Iomega. And then I found out they also had the 1TB Jaz drive. Oh, well. I used the Zip drive for years, even when I started using external USB drives. It finally died in the early 2010s.

At the moment, I use a 4-bay NAS with RAID-5 redundancy that has an external 5TB USB HDD that is used for backups.

Saving my data to the NAS means I can restore a previously saved system image to my PC. For decades, I have very rarely worried about loosing anything important.

Last year, I had an HDD fail on me (and I still have a sour taste about the incident). I checked the drive and, luckily for me, the data could be retrieved. So I set that drive aside (fully intending to recover the data), used another HDD, and started saving up for a 4-bay NAS and 4 × 6TB HDDs. Now that I have a NAS, I’m starting to think about getting another one for replication. It couldn’t hurt.

Also, I never recovered the data from the failed HDD. I keep prioritising work over recovery. The busted drive has been sitting on my PC for over a year, quietly gathering dust, and now I can barely remember what it contained.

NOTE: I have now added the failed drive to a pile of other HDDs that are scheduled for physical destruction… some day.

Updating My Fresh System Image.

Every few months, I will:

• Install my fresh system image,

• Apply all of the updates, and

• Replace the old system image.

This update simply reduces the system update time whenever I use the system image.

Fresh Image vs. Production Image.

Often, I will load my fresh system image, add a few apps or utilities, and save it as a production image.

The purpose of production images is to have specific apps and utilities ready to use as soon as I restore a production image. I will even create a production image that contains everything.

Sometimes, I will create an image of my current setup, switch to a different image, do what I needed to achieve, and then restore my current setup.

The reason for having multiple images is education. Technology moves fast, especially AI technology, so using an image where I can run experiments allows me to explore how new tech can be integrated into my existing workflow.

Replacing My PC.

My PC died in 2019. I had to save up for a replacement and I got a new PC with an AMD Ryzen 5 2600 CPU. It has 6 cores and supports 12 threads. Over the years, I have:

• Upgraded the RAM to its maximum of 64GB,

• Installed a 1TB M.2 NVMe drive for Ubuntu,

• Installed a 512GB SATA SSD for Windows,

• Installed a 256GB SATA SSD for storage, and

• Installed a 12GB VRAM Nvidia RTX-3060 graphics card.

Switching to a different PC made no difference to my data. Everything important was saved to an external HDD (until it died 5-years later).

Even with my old - and long expired - PC, I was using system images. I even used a similar product to CloneZilla Live when I was still using Windows as my daily driver and primary system (before switching to Linux distros in 2015). Creating, and using, system images just feels like the right process for me.

The Results.

Using system images is a practical and efficient way to manage and maintain my computer systems. By separating system files from personal data, I can ensure that my important information is always safe and easily recoverable. Regularly creating production images allows for quick restoration and experimentation with new technologies. This approach not only saves time but also provides peace of mind, knowing that my system can be restored to a working state with minimal effort. Embracing system images as part of my workflow significantly enhances my productivity and adaptability in the ever-evolving tech landscape.

In Conclusion.

Discover the benefits of using system images for efficient computer management. Learn how separating system files from personal data ensures easy recovery and enhances productivity. Explore practical tips for creating and updating system images to stay adaptable in the fast-paced tech world.

Until next time: Be safe, be kind, be awesome.

Hash Tags.

#SystemImages #ComputerManagement #DataRecovery #Productivity #TechTips #CloneZilla #DataBackup #TechAdaptability #SystemBackup #EfficientComputing

This post provides an overview of how the BMAD Method works, identifies key markdown files and their purpose, explains how these files can be changed to meet my requirements, details the impact of making specific changes to these files, and walks through installing, and systematically applying, the BMAD Method to produce a comprehensive suite of documents (from high-level requirements to executable code and user-facing guides, all driven by intelligent AI agents).

Attributions:

The BMAD GitHub Repository ↗.

An Introduction.

Using AI for software development is a constantly evolving process. The BMAD method is yet another approach to keeping AI models focused on their programming tasks:

The purpose of this post is to introduce the BMAD Method for AI-based software development.

The Big Picture.

The Breakthrough Method of Agile AI-Driven Development (BMAD Method) is a powerful natural language framework designed to enhance software development and other domains through specialized AI agents. This guide provides an overview of how the BMAD Method works, its key components, and how I can customize it to meet my specific requirements.

Prerequisites.

• A Debian-based Linux distro (I use Ubuntu).

Updating my Base System.

• From the (base) terminal, I update my (base) system:

sudo apt clean && \
sudo apt update && \
sudo apt dist-upgrade -y && \
sudo apt --fix-broken install && \
sudo apt autoclean && \
sudo apt autoremove -y

NOTE: The Ollama LLM manager is already installed on my (base) system.

What is the BMAD Method?

The BMAD Method, or Breakthrough Method for Agile AI-Driven Development, is a framework that integrates AI with agile methodologies to streamline software development. It utilizes specialized AI agents to manage various roles in the development process, enhancing efficiency and organization.

1. Overview of the BMAD Method.

The BMAD Method addresses common challenges in AI-assisted development, such as planning inconsistency and context loss, through two core innovations:

1.1. Agentic Planning.

In this initial phase, dedicated AI agents like the Analyst, Product Manager (PM), and Architect collaborate to create highly detailed and consistent Product Requirement Documents (PRDs) and Architecture documents. This planning can optionally be performed using web-based agents for cost efficiency, leveraging powerful models and human-in-the-loop refinement to produce comprehensive specifications.

1.2. Context-Engineered Development.

Following the planning phase, a Scrum Master (SM) agent takes the detailed plans and transforms them into hyper-detailed development stories. These story files are crucial as they embed the full context, implementation details, and architectural guidance directly within them. The Development (Dev) agent then uses these self-contained story files to implement the actual code, ensuring complete understanding of what, how, and why to build.

This two-phase approach ensures that development proceeds with a clear, consistent vision, minimizing misinterpretations and maximizing efficiency.

2. The BMAD Workflow.

The BMAD Method follows a structured workflow, typically starting with planning and moving into a continuous development cycle.

2.1. The Planning Workflow (Web UI or Powerful IDE Agents).

The planning phase focuses on defining the project scope, requirements, and technical architecture.

1. Project Idea & Research: Starts with a project idea, optionally involving an Analyst for brainstorming, market research, and competitor analysis to create a Project Brief.

2. PRD Creation: A PM agent creates the PRD (Product Requirement Document) from the Project Brief, detailing Functional Requirements (FRs), Non-Functional Requirements (NFRs), Epics, and Stories.

3. UX Specification (Optional): If User Experience (UX) is required, a UX Expert agent creates a Front End Specification and can generate UI prompts.

4. Architecture Design: An Architect agent designs the system architecture based on the PRD and optional UX specifications.

5. Document Alignment: A Product Owner (PO) agent runs a Master Checklist to ensure all documents (PRD, Architecture, UX Spec) are aligned. If not, the PO updates Epics and Stories, and the PRD/Architecture are revised.

6. Transition to IDE: Once planning is complete and documents are aligned, the process transitions from web UI (if used) to the IDE. The PO shards the PRD and Architecture documents, preparing them for the development cycle.

2.2. The Core Development Cycle (IDE).

This phase focuses on implementing the planned features and ensuring quality.

1. Story Drafting: The SM agent reviews previous development/QA notes and drafts the next story from the sharded Epic and Architecture documents.

2. Story Review (Optional): A QA agent can optionally review the story draft against existing artifacts.

3. User Approval: The user approves the story. If changes are needed, the SM revises the story.

4. Development & Testing: The Dev agent executes tasks sequentially, implements code and tests, and runs all validations.

5. Ready for Review: The Dev agent marks the story as "Ready for Review" and adds notes.

6. User Verification & QA Review: The user verifies the work. They can approve without QA (with a critical reminder to verify all regression tests and linting) or request a QA review.

7. QA Review & Refactoring: If requested, the QA agent performs a senior developer review, refactors code, adds tests, and documents notes.

8. QA Decision: QA decides if more Dev work is needed or if the story is approved.

9. Commit Changes: Crucially, all changes are committed before proceeding.

10. Story Completion: The story is marked as "Done," and the cycle repeats for the next story.

3. Key Components and Their Customization.

The BMAD Method's flexibility comes from its natural language-based components, primarily Markdown and YAML files, which define agent behaviors, workflows, and content.

3.1. Agent Definition Files (bmad-core/agents/*.md).

• Purpose: Each Markdown file in bmad-core/agents/ defines a specific AI agent's persona, role, style, identity, focus, and core principles. They also list the commands the agent can execute and its dependencies (tasks, templates, checklists, data). The customization field allows for specific overrides that take precedence over other instructions.

• How to Change:

  • Refine Persona: Modify the persona sections (role, style, identity, focus) to fine-tune how an agent "thinks" and communicates. For example, making a "Dev" agent's style "extremely concise" will result in shorter, more direct responses.

  • Adjust Core Principles: Add, remove, or modify bullet points under core_principles to instill specific guidelines or values. For instance, adding "Prioritize secure coding practices" to a dev.md agent's principles would make it focus more on security during implementation.

  • Update Commands & Dependencies: Add new commands or modify existing ones, ensuring they map to relevant tasks or templates. Update the dependencies section to include or exclude files the agent needs to access.

  • Apply Customization Overrides: Use the agent.customization field for powerful, explicit overrides that ensure specific behaviors or rules are always followed, even if they conflict with other instructions.

• Impact of Changes: Directly alters the agent's behavior, capabilities, and output. A modified agent will approach tasks differently, potentially leading to changes in the generated code, documentation, or planning artifacts.

3.2. Checklists (bmad-core/checklists/*.md).

• Purpose: These Markdown files provide structured lists of criteria or step-by-step procedures that agents (or users) must follow to ensure quality, completeness, or adherence to standards. They often include [[LLM: INSTRUCTIONS]] for the agent on how to process the checklist.

• How to Change:

  • Add/Remove/Modify Items: Directly edit the markdown list items to add new checks, remove irrelevant ones, or refine existing criteria.

  • Update LLM Instructions: Modify the [[LLM: ...]] blocks to guide the agent on how to interpret and apply the checklist items, or what kind of output to generate (e.g., "Be specific - list each requirement and whether it's complete").

• Impact of Changes: Directly impacts the quality and completeness of deliverables. A more rigorous story-dod-checklist.md will lead to higher quality story implementations. It also influences how agents report on their progress and adherence to standards.

3.3. Technical Preferences (bmad-core/data/technical-preferences.md).

• Purpose: This Markdown file allows users to inject their preferred technologies, design patterns, or other technical biases into the planning agents (e.g., PM, Architect).

• How to Change: Add markdown content describing my preferences. For example, I can specify preferred frontend frameworks, backend languages, database types, or architectural styles.

• Impact of Changes: Planning agents will consider these preferences when generating PRDs, architecture documents, and making technology recommendations, leading to plans more aligned with my specific technical stack and philosophy.

3.4. Core Configuration (bmad-core/core-config.yaml).

• Purpose: This YAML file contains critical configurations for the BMAD Method, such as the devLoadAlwaysFiles list.

• How to Change: Modify the devLoadAlwaysFiles list to specify which documents (e.g., coding standards, tech stack, project structure) the Dev agent should always load into its context.

• Impact of Changes: Crucial for managing the Dev agent's context. By including lean, focused documents here, I ensure the Dev agent has essential guidelines without unnecessary context bloat, leading to more efficient and compliant code generation.

3.5. Tasks (bmad-core/tasks/*.md).

• Purpose: These Markdown files define step-by-step procedures that an agent follows to complete a specific piece of work. They are the "how-to" guides for agents.

• How to Change: Modify the instructions within a task file to alter the steps an agent takes to perform a function. For example, changing create-doc.md would change how documents are generally created by agents.

• Impact of Changes: Directly affects the execution flow and output of specific agent commands.

3.6. Templates (bmad-core/templates/*.yaml).

• Purpose: These YAML files define the structured output format for documents generated by agents (e.g., PRD, Architecture, Story). They include metadata, workflow configuration, and sections with instructions for content generation.

• How to Change: Modify the YAML structure to define new sections, change existing section titles, or update the instruction fields that guide the LLM on what content to generate for each section.

• Impact of Changes: Determines the structure and content of the documents produced by agents, ensuring consistency and adherence to desired formats.

4. Best Practices for Using and Customizing the BMAD Method.

• Keep Dev Agents Lean: Adhere to the principle of minimal context for development agents. Only load essential files (devLoadAlwaysFiles) to maximize coding efficiency.

• Leverage Natural Language: Since everything is Markdown and natural language, focus on clear, concise, and unambiguous instructions in agent definitions, tasks, and templates.

• Use Expansion Packs for Specialization: For domain-specific needs (e.g., game development, DevOps) or non-technical applications, create or use expansion packs to avoid bloating the core agents.

• Iterative Refinement: Continuously refine agent definitions, checklists, and preferences based on the quality of the AI-generated output and my evolving project needs.

• Commit Regularly: Especially during the development cycle, commit my changes frequently to maintain version control and track progress.

• Understand the Workflows: Familiarize myself with both the Planning and Development workflows to effectively guide the agents and intervene when necessary.

By understanding these core components and their interplay, I can effectively leverage and customize the BMAD Method to streamline my AI-assisted development processes and achieve higher quality outcomes.

5. Practically Applying the BMAD Method.

To effectively utilize the BMAD Method, I'll need to set up my local environment and understand the practical steps for generating documents. This section guides me through the installation, configuration, and a step-by-step process for creating a complete set of project documents.

5.1. Installation and Configuration.

The BMAD Method is primarily built around Python scripts and Markdown/YAML files, leveraging AI models for content generation.

5.1.1. Prerequisites.

Before I begin, ensure I have the following installed on my local machine:

• Python 3.9+: The core of the BMAD Method relies on Python.

• pip: Python's package installer, usually included with Python.

• Git: For cloning the BMAD Method repository.

• An IDE (e.g., VS Code): Recommended for editing Markdown and YAML files, and running scripts.

• Access to an LLM API: The BMAD Method requires access to a Large Language Model (LLM) API (e.g., OpenAI, Anthropic, Google Gemini). I will need an API key for my chosen LLM provider.

5.1.2. Setup Steps.

1. Clone the Repository: Start by cloning the BMAD Method repository to my local machine:

    git clone https://github.com/bmadcode/BMAD-METHOD.git
    cd BMAD-METHOD
   

2. Create a Virtual Environment (Recommended): It's good practice to create a virtual environment to manage dependencies:

    python -m venv venv
    source venv/bin/activate  # On Windows, use `venv\Scripts\activate`
   

3. Install Dependencies: Install the necessary Python packages. A requirements.txt file is typically provided in the repository.

    pip install -r requirements.txt
   

   (If requirements.txt is not present, I would typically install langchain, openai (or equivalent for my LLM), pyyaml, etc., manually.)

4. Configure LLM API Key: The BMAD Method will need my LLM API key to interact with the AI models. This is usually done by setting an environment variable. For example, for OpenAI:

    export OPENAI_API_KEY="my_openai_api_key_here"
   

   Replace "my_openai_api_key_here" with my actual API key. For other LLMs, consult their documentation for the appropriate environment variable name.

5. Review bmad-core/core-config.yaml: Familiarize myself with the bmad-core/core-config.yaml file. This file contains crucial configurations, such as devLoadAlwaysFiles, which dictates what documents the Development agent always loads. Adjust this as needed for my projects’ specific standards.

5.2. Step-by-Step Document Generation.

The BMAD Method facilitates the creation of a comprehensive set of documents through a guided, agent-driven process. This section outlines a typical flow, starting with high-level planning documents and progressing to detailed development artifacts.

5.2.1. Phase 1: Planning Documents (PRD and Architecture).

This phase leverages the planning agents to define the project's scope and technical foundation.

1. Initiate Project Idea & Research (Analyst Agent):

   • Start with a clear project idea.

   • Optionally, use the Analyst agent to conduct initial brainstorming, market research, and competitor analysis. This helps in creating a foundational "Project Brief" document.

   • Command Example (conceptual): python bmad.py analyst --task "research_project_idea" --output "ProjectBrief.md"

2. Generate Product Requirement Document (PRD) (Product Manager Agent):

   • The Product Manager (PM) agent takes the Project Brief (or my initial idea) and generates a detailed PRD. This document will outline Functional Requirements (FRs), Non-Functional Requirements (NFRs), Epics, and high-level Stories.

   • Command Example (conceptual): python bmad.py pm --task "create_prd" --input "ProjectBrief.md" --output "PRD.md"

3. Design Architecture Document (Architect Agent):

   • Based on the generated PRD, the Architect agent designs the system architecture. This document will detail the technical stack, system components, data flow, and overall structural design.

   • Command Example (conceptual): python bmad.py architect --task "design_architecture" --input "PRD.md" --output "Architecture.md"

4. Document Alignment (Product Owner Agent - Optional but Recommended):

   • The Product Owner (PO) agent can run a Master Checklist to ensure consistency and alignment between the PRD and Architecture documents. If discrepancies are found, the PO can guide revisions.

   • Command Example (conceptual): python bmad.py po --task "align_documents" --input "PRD.md,Architecture.md"

5.2.2. Phase 2: Detailed Development Documents (Stories and Beyond).

Once the core planning documents are stable, the focus shifts to creating detailed development artifacts that can directly drive AI-assisted coding.

1. Shard Planning Documents (Product Owner Agent):

   • The PO agent "shards" the comprehensive PRD and Architecture documents into smaller, manageable pieces. This prepares them for the Scrum Master to draft individual stories.

   • Command Example (conceptual): python bmad.py po --task "shard_documents" --input "PRD.md,Architecture.md" --output-dir "sharded_docs/"

2. Draft Development Stories (Scrum Master Agent):

   • The Scrum Master (SM) agent reviews the sharded documents and drafts individual development stories. Each story is a self-contained unit of work, embedding context, implementation details, and architectural guidance.

   • Command Example (conceptual): python bmad.py sm --task "draft_story" --input "sharded_docs/epic_1_part_1.md" --output "Story_FeatureX_01.md"

   • Repeat this step for each story I need to generate.

3. Generate Code and Tests (Development Agent):

   • The Development (Dev) agent takes a drafted story file and generates the actual code and associated tests. The story file provides all the necessary context, minimizing the need for external lookups.

   • Command Example (conceptual): python bmad.py dev --task "implement_story" --input "Story_FeatureX_01.md" --output-dir "src/feature_x/"

4. Quality Assurance and Refactoring (QA Agent - Optional):

   • A QA agent can review the generated code and tests against defined quality standards, refactor code, add more tests, and document any findings.

   • Command Example (conceptual): python bmad.py qa --task "review_code" --input "src/feature_x/" --story "Story_FeatureX_01.md"

5. Generate User Guides, API Documentation, etc.:

   • Once the core application is developed, I can use specialized agents (or adapt existing ones) to generate further documentation:

     • User Guides: An agent could take the PRD and implemented features to create user-facing documentation.

     • API Documentation: An agent could analyze the generated code to produce API specifications (e.g., OpenAPI/Swagger).

     • Installation Guides: An agent could synthesize information from the architecture and development process to create detailed installation instructions.

   • These would typically involve custom tasks and templates tailored for each document type.

By following these steps, I can systematically apply the BMAD Method to produce a comprehensive suite of documents, from high-level requirements to executable code and user-facing guides, all driven by intelligent AI agents.

6. Agent Names.

The BMAD Method utilizes a set of specialized AI agents, each with a distinct role and purpose within the development workflow. Understanding these agents is key to effectively leveraging the method.

• Analyst Agent:

  • Purpose: Involved in the initial project idea and research phase. Responsible for brainstorming, market research, and competitor analysis to help create a foundational Project Brief.

• Product Manager (PM) Agent:

  • Purpose: Creates the Product Requirement Document (PRD) from the Project Brief. This document details Functional Requirements (FRs), Non-Functional Requirements (NFRs), Epics, and Stories.

• Architect Agent:

  • Purpose: Designs the system architecture based on the PRD and optional UX specifications. This includes defining the technical stack, system components, data flow, and overall structural design.

• UX Expert Agent (Optional):

  • Purpose: If User Experience (UX) is required, this agent creates a Front End Specification and can generate UI prompts.

• Product Owner (PO) Agent:

  • Purpose: Ensures all planning documents (PRD, Architecture, UX Spec) are aligned by running a Master Checklist. If not aligned, the PO updates Epics and Stories and guides revisions. Also responsible for sharding the PRD and Architecture documents for the development cycle.

• Scrum Master (SM) Agent:

  • Purpose: Reviews previous development/QA notes and drafts the next development story from the sharded Epic and Architecture documents. Ensures stories are self-contained units of work.

• Development (Dev) Agent:

  • Purpose: Executes tasks sequentially, implements code and tests based on the detailed story files, and runs all validations. Marks stories as "Ready for Review" upon completion.

• QA Agent:

  • Purpose: Optionally reviews story drafts against existing artefacts. In the core development cycle, performs a senior developer review, refactors code, adds tests, and documents notes. Decides if more Dev work is needed or if the story is approved.

The Results.

I have explored the BMAD Method, a revolutionary framework integrating AI with Agile methodologies to enhance software development. I learned about its key components, customization options, and best practices to streamline my AI-assisted development processes for higher quality outcomes.

In Conclusion.

The BMAD Method offers a transformative approach to software development by integrating AI with Agile methodologies. By understanding and customizing its key components, such as agent definitions, checklists, and templates, I can streamline my processes and achieve higher quality outcomes. The method's flexibility and emphasis on natural language make it accessible and adaptable to various project needs, ensuring that AI-assisted development is both efficient and effective. As I continue to explore and implement the BMAD Method, I must remember to iterate and refine my approach to maximize its benefits.

Until next time: Be safe, be kind, be awesome.

Hash Tags.

#BMADMethod #AIDrivenDevelopment #AgileDevelopment #SoftwareDevelopment

#AIIntegration #TechInnovation #DevelopmentWorkflow #AIFramework

#CustomizableAI #SoftwareEngineering #AgileMethodologies #AIInSoftware

#TechBestPractices #AIandAgile #DevelopmentEfficiency

TL;DR.

This post is a guide to upgrading Pi5 SBCs (Raspberry Pi 5 Single Board Computers) from using microSD cards to employing M.2 NVMe drives.

Attributions:

None ↗.

An Introduction.

Upgrading from using a microSD card on a Pi5 SBC to using an M.2 NVMe drive on the same device can really open up the storage capability of the Raspberry Pi platform:

The purpose of this post is to demonstrate how to install an OS onto an M.2 NVMe drive for a Pi5 SBC.

The Big Picture.

There is a redundancy requirement when assembling an HA (High Availability) cluster. Many different flavours of Kubernetes (K8s, K3s, MicroK8s, K0s, and even Minikube) support HA clustering and I will use my Homelab hardware, such as it is, to practice the skills of deploying HA solutions. Using Pi5 SBCs as HA Master Nodes (sometimes called Control Planes) is fine due to the low resource requirements. Worker Nodes (sometimes called Data Planes), on the other hand, consumes many resources (CPU cycles, RAM, bandwidth, etc.) due to processing resource requests. Not only do Worker Nodes need to send a LOT of data, but they must also spin up more nodes when the demand increases. More nodes means more resources consumed.

For M.2 NVMe drives, there is a speed difference between the (older) SATA interface and the (newer) NVMe interface. The drives I use in this post are NVMe PCIe Gen3 x4 ↗. The M.2 NVMe enclosures I use also support NVMe Drives. Also, the hats that are installed in the Pi5 SBCs are also NVMe compatible.

For now, my focus is on installing a Linux distro on M.2 NVMe drives that will be used by Pi5 SBCs.

Prerequisites.

• A Debian-based Linux distro (I use Ubuntu),

• 3 x Pi5 single board computers,

• 3 x Pi5 active coolers,

• 3 x M.2 NVMe drives,

• 3 x Pi5 NVMe hats,

• An M.2 NVMe enclosure,

• 3 x CAT-5 Ethernet cables, and

• Access to an Internet router, or a LAN switch, that is connected to the Internet router.

Updating my Base System.

• From the (base) terminal, I update my (base) system:

sudo apt clean && \
sudo apt update && \
sudo apt dist-upgrade -y && \
sudo apt --fix-broken install && \
sudo apt autoclean && \
sudo apt autoremove -y

NOTE: The Ollama LLM manager is already installed on my (base) system.

What is the Raspberry Pi Imager?

Raspberry Pi Imager is a user-friendly application that allows me to easily install Raspberry Pi OS, or any other compatible operating system, onto a microSD card for use with Raspberry Pi devices. It simplifies the process of selecting the OS and writing it to the card, ensuring that the installation is done correctly.

In my case, I will be installing Ubuntu Server LTS 24.04 onto an M.2 NVMe drive using an M.2 NVMe enclosure.

Installing Pi Imager.

• From the terminal, I install the Raspberry Imager:

sudo apt install -y rpi-imager

Creating an Ubuntu Server M.2 NVMe Drive.

NOTE: For this process, I use the Raspberry Imager software, 3 x M.2 NVMe drives, an M.2 NVMe enclosure, 3 x M.2 NVMe hats for Pi5 SBCs, and 3 x Pi5 SBCs.

• I purchase three (3) M.2 NVMe drives, 1 for each Pi5, from my local computer store:

• I install an M.2 NVMe drive into an M.2 NVMe enclosure:

• I connect the M.2 NVMe enclosure to my PC:

• I start the Raspberry Pi Imager:

• I select Raspberry Pi 5 as my Raspberry Pi Device:

• I select Ubuntu Server 24.04.2 LTS (64-bit) as the Operating System:

• I select the M.2 NVMe enclosure (Realtek TS512GMTE440S) as the Storage:

NOTE: TS512GMTE440S is the product ID for the M.2 NVMe drive.

• I click the NEXT button:

• From the Use OS customisation? dialog, I click the EDIT SETTINGS button to open the OS Customisation dialog:

• In the GENERAL tab, I use the following settings:

• In the SERVICES tab, I use the following settings:

NOTE: Setting the public key encryption for SSH will be described in a later post.

• In the OPTIONS tab, I use the following settings:

• I click the SAVE button to return to the previous dialog.

• Back in the Use OS customisation? dialog, I click the YES button.

• I read the Warning dialog, then click the YES button:

• The Raspberry Pi Imager installs Ubuntu Server 24.4.2 LTS (64-bit) onto the M.2 NVMe drive.

• After the image is written to the M.2 NVMe drive, the M.2 NVMe enclosure is automatically ejected from my PC:

NOTE: The M.2 NVMe enclosure is automatically ejected from my PC due to this setting that was enabled earlier:

• I unplug the M.2 NVMe enclosure from my PC.

• I remove the M.2 NVMe drive from the M.2 NVMe enclosure.

• I install the M.2 NVMe drive into the M.2 NVMe hat that I previously added to my Pi5 SBC.

• I repeat this process 2 more times (along with making appropriate changes to the settings):

NOTE: Now that the M.2 NVMe drives have been imaged and installed, I now need to provide the Pi5 SBCs with a new boot order.

Creating a MicroSD Card Bootloader.

NOTE: For this process, I use the Raspberry Imager software, a microSD card and a USB card reader.

• I insert a microSD card into the USB card reader.

• I insert the USB card reader into my PC.

• I start the Raspberry Pi Imager:

• I set the Raspberry Pi Device to Raspberry Pi 5:

• I set the Operating System to Misc utility images > Bootloader (Pi 5 family) > SD Card Boot:

• I set the Storage to the SD Card Reader - 31.3 GB:

NOTE: 31.3 GB is the usable capacity of the microSD card inserted in the SD Card Reader.

• I click the NEXT button:

• I read the Warning dialog and then click the YES button:

• It takes less than 20-seconds for the Raspberry Pi Imager to finish:

• I remove the USB reader from my PC.

• I remove the microSD card from the USB card reader.

Changing the Pi5 Boot Order.

• I insert the microSD card into the Pi5 microSD card slot.

• I power on the Pi5.

• I wait for the microSD card to rewrite the bootloader in the EEPROM of the Pi5.

NOTE: Rewriting the settings for the bootloader only takes a few seconds.

• A successful rewrite is shown by a blinking, green LED and a green screen displayed on the monitor. (A failed process is denoted by a blinking, red LED and a red screen displayed on the monitor.)

• I repeat this process for the remaining Pi5 SBCs.

NOTE: If there is no bootable microSD card in the Pi5, then it will try to boot from an M.2 NVMe drive. If there is no bootable M.2 NVMe drive, the it will try to boot from a USB drive.

What is a Raspberry Pi?

A Raspberry Pi is a single-board computer, or SBC, that is a little larger than a credit card, specifically 85mm x 56mm in size. It looks like a miniature motherboard but all the components, like the CPU, memory, wireless module, USB ports, and the network port are already (and permanently) installed. Hardware upgrades are enabled through the use of ‘hats’. A hat is a circuit board that is installed on top of, or below, the Raspberry Pi. Hats have pins that electrically connect to the header of the Pi, and may also include a ribbon cable that also provides a connection to the SBC.

Assembling a Pi5 that Supports an M.2 NVMe Drive.

• If installed, I remove the passive heat sink from the Pi5 CPU.

• I install the active cooler and attach the fan cable to the fan header of the Pi5.

• I remove a specific screw from the active cooler fan.

• I connect the NVMe hat to the Pi5 header and use the included long screw to attach it to the active cooler fan.

• I use the NVMe ribbon cable to connect the NVMe hat to the Pi5.

• I install the M.2 NVMe drive, the drive with Ubuntu Server 24.4 LTS installed, into the NVMe hat and use the included short screw to secure the drive.

• On the case, I pop out the case fan because it will get in the way of the NVMe hat.

• I install the assembled Pi5 into the Pi case.

• I repeat this process 2 more times:

Setting Up the Local Terminal.

The following describes setting up the remote PiLab servers, two of which will become the control plane nodes of the MicroK8s cluster. These settings must also be applied to the eight NucLab containers that will become the worker nodes of the MicroK8s cluster.

Creating an RSA Key Pair on the Local PC.

• From my local, PC terminal (CTRL + ALT + T), I start the ssh-agent:

eval "$(ssh-agent -s)"

• I generate a pair of RSA keys called "/home/brian/.ssh/key-name" (where I replace "key-name" with the name of the remote server):

ssh-keygen -b 4096

NOTE: It is my convention to name RSA keys after the remote server on which they will be used.

• I add the SSH key to my workstation account (where I replace "key-name" with the actual name of the ssh key):

ssh-add /home/brian/.ssh/key-name

Uploading the Public Key to the Remote Server.

• From the workstation terminal (CTRL + ALT + T), I use "ssh-copy-id" to upload the locally-generated public key to the remote container (where I replace "container-name" with the actual name of the container):

ssh-copy-id -i /home/brian/.ssh/container-name.pub yt@192.168.?.?

NOTE: I replace the "?" with the actual IP address for the remote server.

Logging In to the Remote Server.

• From the terminal (CTRL + ALT + T), I login to the account of the remote server:

ssh 'yt@192.168.?.?'

NOTE: I replace the "?" with the actual IP address for the remote server.

Updating the Remote Server.

• From the terminal, I update the remote server:

sudo apt clean && \
sudo apt update && \
sudo apt dist-upgrade -y && \
sudo apt --fix-broken install && \
sudo apt autoclean && \
sudo apt autoremove -y

Hardening the Remote Server.

• From the terminal (CTRL + ALT + T) that is connected to the remote server, I open the "sshd_config" file:

sudo nano /etc/ssh/sshd_config

• I add (CTRL + V) the following to the bottom of the "sshd_config" page, save (CTRL + S) the changes, and exit (CTRL + X) the Nano text editor:

PasswordAuthentication no
PermitRootLogin no
Protocol 2

• I restart the "ssh" service:

sudo systemctl restart ssh.service

Enabling, and Setting Up, UFW on the Remote Server.

• From the PC terminal (CTRL + ALT + T) that is connected to the remote server, I check the UFW status:

sudo ufw status

• I enable the UFW:

sudo ufw enable

• I install a UFW rule:

sudo ufw allow from 192.168.?.?

NOTE: I can use ip a or ip addr in my local PC terminal to find my IP address. I replace the IP address above with the actual address for the workstation, e.g. 192.168.188.41.

• I check the status of the UFW and list the rules by number:

sudo ufw status numbered

NOTE 1: UFW will, by default, block all incoming traffic, including SSH and HTTP.

NOTE 2: I will update the UFW rules as I deploy other services to the remote server.

• I can delete a UFW rule by number if needed:

sudo ufw delete 1

• I can also disable UFW if needed:

sudo ufw disable

Installing, and Setting Up, Fail2Ban on the Remote Server.

• From the terminal (CTRL + ALT + T) that is connected to the remote server, I install Fail2Ban:

sudo apt install -y fail2ban

• I copy the jail.conf file as jail.local:

sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local

• I open the jail.local file in Nano:

sudo nano /etc/fail2ban/jail.local

• I make the following changes to a few (SSH-centric) settings in the jail.local file, then I save (CTRL + S) those changes, and exit (CTRL + X) the Nano text editor:

[DEFAULT]
⋮
bantime = 1d
maxretry = 3
⋮
[sshd]
enabled = true
port = ssh,22

• I restart Fail2Ban:

sudo systemctl restart fail2ban

• I check the status of Fail2Ban:

sudo systemctl status fail2ban

• I enable Fail2Ban to auto-start on boot:

sudo systemctl enable fail2ban

• I reboot the remote server:

sudo reboot

My Use Case.

My plan is to use PiLab51 as the primary control plane, PiLab52 as the secondary control plane, and PiLab53 as a general server for hosting GitLab CE, PiHole, and other services. The NucLab systems will host ProxMox VE which, themselves, will host four containers each. These eight containers (total) will act as the worker nodes which, themselves, will host the pods. Although a pod is the smallest deployable unit that can contain one or more containers, the three PiLab SBCs, along with the eight ProxMox containers, collectively make up my local cluster.

The Results.

Transitioning from microSD cards to M.2 NVMe drives for my Pi5 SBCs significantly enhanced the storage capabilities and performance of my Raspberry Pi setup. By following the steps outlined in this post, I successfully installed Ubuntu Server 24.04 LTS on multiple M.2 NVMe drives, paving the way for more robust and efficient use of the Pi5 platform in various applications, including HA (high availability) clustering. This upgrade not only improved data handling and processing speed but also provided a more reliable and scalable solution for my projects. As I continue to explore and implement these technologies, I will adapt and customize my setup to meet my specific needs and objectives.

In Conclusion.

I learned how to enhance the storage capabilities my Raspberry Pi 5 SBCs by replacing microSD cards with M.2 NVMe drives. This post covered my prerequisites, the installation steps, and suggested a practical application where Pi5 SBCs can be used in an HA cluster. The Pi5 platform is a potentially strong and flexible, though expensive, resource for Homelab enthusiasts.

Until next time: Be safe, be kind, be awesome.

Hash Tags.

#RaspberryPi #Pi5 #SingleBoardComputer #M2Drive #UbuntuServer #ServerInstallation

#Kubernetes #HighAvailability #Homelab #StorageSolutions #OpenSource #DIYTech

#TechTutorial #TechUpgrade #TechEnthusiast

The post provides a step-by-step guide on deploying and utilising CrewAI agents by following a part of Tyler Reed's YouTube tutorial. This article emphasises learning by doing, documenting the process, and sharing my insights. I highlight the importance of experimenting and creating posts that enhance my understanding of CrewAI's functionalities.

Attributions:

https://www.youtube.com/watch?v=ONKOXwucLvE from Tyler AI ↗.

An Introduction.

Although I will be deploying CrewAI agents, my main objective is to show the results of converting hands-on processes into documentation:

The purpose of this post is to show how practical experiences are captured as documented events.

The Big Picture.

This is the first project (in a series of projects) where I cover part of a YouTube video from Tyler Reed.

Tyler AI

If you are new to CrewAI (like me), then I STRONGLY suggest you do EXACTLY what I did: Follow Tyler’s instructions, make detailed notes about his process, turn your notes into a blog post, and publish your results. You will learn by doing and you will end up with a post that you can reference. Copying and pasting my post is not a learning process. You will ultimately cheat yourself, and fail to understand how CrewAI works.

Here is a link to Tyler’s video:

https://www.youtube.com/watch?v=ONKOXwucLvE&t=0 ↗.

Prerequisites.

• A Debian-based Linux distro (I use Ubuntu),

• CrewAI.

Updating my Base System.

• From the (base) terminal, I update my (base) system:

sudo apt clean && \
sudo apt update && \
sudo apt dist-upgrade -y && \
sudo apt --fix-broken install && \
sudo apt autoclean && \
sudo apt autoremove -y

NOTE: The Ollama LLM manager is already installed on my (base) system.

What is the Report Project?

The Report Project shows how to deploy existing tools for CrewAI agents to use. A list of existing tools can be found within the CrewAI documentation ↗.

Creating the Report Project.

• From the terminal, I navigate to my projects directory:

cd ~/AI

• I start a new project:

crewai create crew report

• From the first list of options, I choose the ollama option.

• From the next list of options, I choose the ollama/llama3.1 option.

Opening the Report Project in VS Code.

• I open the Report Project in VS Code:

code ./report

Editing the .env File.

• I open the .env file and replace the contents with the following:

OPENAI_API_BASE=https://openrouter.ai/api/v1 # openrouter url here
OPENAI_MODEL_NAME=openrouter/google/gemini-2.0-flash-001 # openrouter/path/model_name here
OPENROUTER_API_KEY=your_api_key # API key here

NOTE: By default, these settings provide this project with access to the OpenRouter.ai API.

Editing the main.py File.

• Under the src/report directory, I open the main.py file.

• I replace the contents of the main.py file with the following:

#!/usr/bin/env python
import sys
import warnings

from datetime import datetime

from crew import Report

warnings.filterwarnings("ignore", category=SyntaxWarning, module="pysbd")

# This main file is intended to be a way for you to run your
# crew locally, so refrain from adding unnecessary logic into this file.
# Replace with inputs you want to test with, it will automatically
# interpolate any tasks and agents information

def run():
    """
    Run the crew.
    """
    inputs = {
        'topic': 'AI LLMs',
        'current_year': str(datetime.now().year)
    }

    try:
        Report().crew().kickoff(inputs=inputs)
    except Exception as e:
        raise Exception(f"An error occurred while running the crew: {e}")

run()

What changed:

• Near the top, I changed from report.crew import Report to from crew import Report,

• I deleted the train(), replay(), and test() functions, and

• At the bottom of the file, I added the run() function.

Editing the crew.py File.

• Under the src/report directory, I open the crew.py file.

• I replace the contents of the crew.py file with the following:

from crewai import Agent, Crew, Process, Task, LLM
from crewai.project import CrewBase, agent, crew, task
from dotenv import load_dotenv

load_dotenv()

# If you want to run a snippet of code before or after the crew starts,
# you can use the @before_kickoff and @after_kickoff decorators
# https://docs.crewai.com/concepts/crews#example-crew-class-with-decorators

@CrewBase
class Report():
    """Report crew"""

    # Learn more about YAML configuration files here:
    # Agents: https://docs.crewai.com/concepts/agents#yaml-configuration-recommended
    # Tasks: https://docs.crewai.com/concepts/tasks#yaml-configuration-recommended
    agents_config = 'config/agents.yaml'
    tasks_config = 'config/tasks.yaml'

    ollama_llm = LLM(
        model = 'ollama/deepseek-r1:14b',
        base_url = 'http://localhost:11434'
    )

    # If you would like to add tools to your agents, you can learn more about it here:
    # https://docs.crewai.com/concepts/agents#agent-tools
    @agent
    def researcher(self) -> Agent:
        return Agent(
            config=self.agents_config['researcher'],
            verbose=True,
            llm = self.ollama_llm
        )

    @agent
    def reporting_analyst(self) -> Agent:
        return Agent(
            config=self.agents_config['reporting_analyst'],
            verbose=True,
            llm = self.ollama_llm
        )

    # To learn more about structured task outputs,
    # task dependencies, and task callbacks, check out the documentation:
    # https://docs.crewai.com/concepts/tasks#overview-of-a-task
    @task
    def research_task(self) -> Task:
        return Task(
            config=self.tasks_config['research_task'],
        )

    @task
    def reporting_task(self) -> Task:
        return Task(
            config=self.tasks_config['reporting_task'],
            output_file='report.md'
        )

    @crew
    def crew(self) -> Crew:
        """Creates the Report crew"""
        # To learn how to add knowledge sources to your crew, check out the documentation:
        # https://docs.crewai.com/concepts/knowledge#what-is-knowledge

        return Crew(
            agents=self.agents, # Automatically created by the @agent decorator
            tasks=self.tasks, # Automatically created by the @task decorator
            process=Process.sequential,
            verbose=True,
            # process=Process.hierarchical, # In case you wanna use that instead https://docs.crewai.com/how-to/Hierarchical/
        )

What changed:

• At the top of the page and the end of the line from crewai import Agent, Crew, Process, Task I added LLM,

• Near the top, I added from dotenv import load_dotenv and load_dotenv(), and

• Within the Report() class, after tasks_config = 'config/tasks.yaml' I added the following:

    ollama_llm = LLM(
            model = 'ollama/deepseek-r1:14b',
            base_url = 'http://localhost:11434'
        )
  

• Within the researcher() and reporting_analyst() agents, I added llm = self.ollama_llm to override the OpenRouter.ai settings in the .env file.

Editing the agents.yaml File.

• Under the src/report/config directory, I open the agents.yaml file.

• I replace the contents of the agents.yaml file with the following:

researcher:
  role: >
    {topic} Senior Data Researcher
  goal: >
    Uncover cutting-edge developments in {topic}
  backstory: >
    You are a seasoned researcher with a knack for uncovering the latest
    developments in {topic}. Known for your ability to find the most relevant
    information and present it in a clear and concise manner.

reporting_analyst:
  role: >
    {topic} Reporting Analyst
  goal: >
    Create detailed reports based on {topic} data analysis and research findings
  backstory: >
    You are a meticulous analyst with a keen eye for detail. You are known for
    your ability to turn complex data into clear and concise reports, making
    it easy for others to understand and act on the information you provide.

What changed:

• No changes made.

Editing the tasks.yaml File.

• Under the src/report/config directory, I open the tasks.py file.

• I replace the contents of the tasks.py file with the following:

research_task:
  description: >
    Conduct a thorough research about {topic}
    Make sure you find any interesting and relevant information given
    the current year is {current_year}.
  expected_output: >
    A list with 10 bullet points of the most relevant information about {topic}
  agent: researcher

reporting_task:
  description: >
    Review the context you got and expand each topic into a full section for a report.
    Make sure the report is detailed and contains any and all relevant information.
  expected_output: >
    A fully fledged report with the main topics, each with a full section of information.
    Formatted as markdown without '```'
  agent: reporting_analyst

What changed:

• No changes made.

The Results.

This CrewAI project provides a comprehensive guide to deploying and utilising CrewAI agents effectively. By watching Tyler Reed's video, following his instructions, and documenting the process, I gained a deeper understanding of CrewAI's functionalities. This hands-on approach not only enhanced my learning but also resulted in a valuable reference post. As I embark on this journey, I must experiment, document my findings, and share my insights with the community.

In Conclusion.

I discovered how to deploy, and utilise, CrewAI agents. I followed along with (some of) Tyler Reed's video tutorial, learned by doing, and enhanced my understanding of CrewAI's functionalities. This process is perfect for me as I look to document my journey while sharing my insights.

Until next time: Be safe, be kind, be awesome.

Hash Tags.

#CrewAI #AI #AI-Projects #AI-Tools #AI-Research #AI-Community

#AI-Integration #Tech-Tutorial #Tech-Blog #Open-Source

#VS-Code #Ubuntu #Learning-By-Doing #Practical-AI

TL;DR.

This post is a guide to setting up a local AI toolkit on a Debian-based Linux distribution, specifically Ubuntu. It covers the installation and management of various AI tools and frameworks, including:

• Ollama,

• CrewAI,

• Crawl4AI,

• LLM Axe,

• AI Extensions for VS Code,

• OpenRouter.ai,

• Cursor,

• Windsurf,

• LM Studio,

• Open WebUI,

• Pinokio, and

• Ngrok.

This guide includes step-by-step instructions for installing, updating, and uninstalling these tools, as well as promoting virtual environments (specifically Conda) for best practices. Also, this post occasionally offers insights into these tools and how they are utilised during AI development.

Although this post contains many AI tools, the only ones I actually use are Ollama, CrewAI, Crawl4AI, the LLM Axe toolkit, the AI extensions for VS Code, and the OpenRouter.ai website.

Attributions:

various ↗.

An Introduction.

This post highlights the tools I find useful as an AI enthusiast. I want to share my insights into these tools and explain why they are beneficial to AI developers:

The purpose of this post is to describe the tools that I, as an AI enthusiast, find useful.

The Big Picture.

November 30th 2022 saw the launch of AI’s first killer app: ChatGPT (Generative Pre-trained Transformer). Three months later, in February 2023, someone “leaked“ the first, open LLM (Large Language Model) which was built by Meta, the corporation that owns Facebook. Since then, many open models have dropped and Hugging Face has become the de facto centre for these AI machines.

NOTE: From here on, I will refer to LLMs as models.

It is now early 2025 and, over the last two and-a-bit years, there has been an explosion of tools and workflows hitting the Internet. The continued growth of commercial, frontier models (e.g. OpenAI models such as GPT-4o, GPT-4o mini, and the GPT-4.1 series) has easily matched, and usually surpassed, the power of my favourite open models (DeepSeek-R1, Phi4, Qwen3, etc.) However, thanks to the rise of MoE (Mixture of Experts) models, reasoning models, agents, agentic tasks and tools, RAG (Retrieval-Augmented Generation) processes, and AI-specific scraping tools, AI enthusiasts can easily develop vibe coding skills on local PCs using open models, frontier models, or a combination of both types of systems.

Prerequisites.

• A Debian-based Linux distribution (I use Ubuntu),

• Python 3.11+.

Updating my Base System.

• From the (base) terminal, I update my (base) system:

sudo apt clean && \
sudo apt update && \
sudo apt dist-upgrade -y && \
sudo apt --fix-broken install && \
sudo apt autoclean && \
sudo apt autoremove -y

What is Ollama?

Ollama is a local, large language model manager that facilitates the installation, management, and operation of AI models on personal computers.

Installing Ollama.

• From the terminal, I install Ollama:

curl https://ollama.com/install.sh | sh

• I run Ollama as a background service:

ollama serve &

NOTE: An error typically displays (see below) because Ollama, by default, already runs as a background service. Also, by default, Ollama runs on port 11434.

Updating Ollama.

• I update Ollama:

curl https://ollama.com/install.sh | sh

NOTE: The update command is the same as the install command.

Pulling Models from Ollama.

• I pull the following models from Ollama (it will take time for these downloads to complete):

ollama pull nomic-embed-text:v1.5 &&
ollama pull falcon3:10b &&
ollama pull cogito:14b &&
ollama pull tulu3:8b &&
ollama pull olmo2:13b &&
ollama pull marco-o1:7b &&
ollama pull smallthinker:3b &&
ollama pull openthinker:7b &&
ollama pull dolphin3:8b &&
ollama pull exaone3.5:7.8b &&
ollama pull exaone-deep:7.8b &&
ollama pull granite3.2-vision:2b &&
ollama pull granite3.3:8b &&
ollama pull gemma3:12b &&

ollama pull llama3.1:8b &&
ollama pull llama3.2:3b &&
ollama pull llama3.2-vision:11b &&
ollama pull phi4-mini-reasoning:3.8b &&
ollama pull phi4-reasoning:14b &&
ollama pull phi4-mini:3.8b &&
ollama pull phi4:14b &&
ollama pull qwen3:14b &&
ollama pull qwen2.5vl:7b &&
ollama pull opencoder:8b &&
ollama pull deepcoder:14b &&
ollama pull codellama:13b &&
ollama pull qwen2.5-coder:14b &&
ollama pull deepseek-coder-v2:16b &&
ollama pull deepseek-r1:14b &&
ollama pull gpt-oss:20b

NOTE: Theses models are perfect for running on my GTX3060 GPU with 12GB VRAM. Also, this list is continually updated. If a newer version of a model is released, I remove the old listing above, replace it with the new listing, run the pull commands, list the installed models (ollama ls), and remove (ollama rm <model-name>) the older model.

Listing the AI Models.

• I list the models downloaded by Ollama:

ollama ls

Running an AI Model.

• I run one of the listed AI models:

ollama run deepseek-r1:14b

Stopping an AI Model.

• I stop running the AI model by typing the following prompt:

/bye

Uninstalling Ollama.

• I stop the Ollama service:

sudo systemctl stop ollama

• I disable the Ollama service:

sudo systemctl disable ollama

• I remove the Ollama service:

sudo rm /etc/systemd/system/ollama.service

• I remove the Ollama binary from my bin directory:

sudo rm $(which ollama)

• I remove the models downloaded by Ollama:

sudo rm -r /usr/share/ollama

• I delete the Ollama service user:

sudo userdel ollama

• I delete the Ollama service group:

sudo groupdel ollama

What is CrewAI?

CrewAI is a framework that is used to build AI crews, agents, tasks, and tools.

Installing CrewAI.

NOTE: Best practice involves installing this app in a virtual environment, using either venv or Conda.

• From the terminal, I use the pip command to install CrewAI and its’ tools:

pip install crewai 'crewai[tools]'

What is Crawl4AI?

Crawl4AI is a web-scraping tool that can conform website data into a format that can be understood by AI models, or the data can be prepared for uploading to a vector database (pending).

Installing Crawl4AI.

NOTE: Best practice involves installing this app in a virtual environment, using either venv or Conda.

• I use the pip command to install the updated version of Crawl4AI:

pip install -U crawl4ai

• I setup Crawl4AI:

crawl4ai-setup

• I verify the Crawl4AI installation:

crawl4ai-doctor

What is LLM Axe?

LLM Axe is a toolkit that provides simple abstractions for commonly used LLM functions.

Installing LLM Axe.

• I use pip to install LLM Axe:

pip install llm-axe

What are AI Extensions for VS Code?

VS Code is a FREE, open-source IDE (integrated development environment) from Microsoft. Extensions are add-ons that are installed within VS Code. These extensions provide extra functionality without having to make changes to the VS Code source code. AI extensions for VS Code are tools and integrations that connect to local, and remote, AI models.

Some Popular AI Extensions for VS Code.

Some of my favourite AI Extensions for VS Code include:

• Twinny,

• Roo Code,

• Cline, and

• Continue.

Other Extensions I find useful include:

• AsciiDoc from AsciiDoctor,

• AsciiDoctor PDF from AsciiDoctor,

• vscode-pdf from tomoki1207, and

• Code Spell Checker from Street Side Software.

NOTE: I have a post that covers the installation of VS Code and some of its’ Extensions.

What is OpenRouter.ai?

OpenRouter ↗ provides a single API for accessing numerous models from multiple providers.

Open Models vs. OpenRouter.

I prefer downloading open models to my local system, and then using these models on my personal computer. Using local models ensures my data does not leak, and my constructs are not used to train other models. Sometimes, however, I need to run complex inference. In those cases, I will use better models that run on powerful hardware. This is why I sometimes switch to using OpenRouter.

Choosing to use OpenRouter over open models depends on my requirements at each stage of a project.

What is Cursor?

Cursor is a VS Code fork that provides an improved AI development experience.

NOTE: The following process can be used to install any AppImage app.

Installing Cursor.

ATTRIBUTION: https://forum.cursor.com/t/tutorial-install-cursor-permanently-when-appimage-install-didnt-work-on-linux/7712

• From a browser, I download the AppImage file from the cursor.com website.

• From the file manager, I move the Cursor app to the NAS (network attached storage) server.

• From the terminal, I create the Apps/Cursor directory:

mkdir ~/Apps/Cursor

• I copy the Cursor download to the the Apps/Cursor directory:

cp ~/Downloads/Ubuntu/Cursor/Cursor*.AppImage ~/Apps/Cursor/Cursor.AppImage

NOTE: This copy command changes the download name to Cursor.AppImage.

• OPTIONAL:

• OPTIONAL: I copy the 128px by 128px logo to the ~/Apps/Cursor directory:

cp /media/brian/Drawings/logos/cursor/Images/Cursor-icon.png ~/Apps/Cursor/Cursor-icon.png

NOTE: I downloaded this image from the Internet.

• I make the AppImage executable:

chmod +x ~/Apps/Cursor/Cursor.AppImage

• I use the Nano text editor to create a desktop entry:

nano ~/.local/share/applications/cursor.desktop

• I paste (CTRL + SHIFT + V) the following into the desktop entry:

[Desktop Entry]
Name=Cursor
Exec=~/Apps/Cursor/Cursor.AppImage
Icon=~/Apps/Cursor/Cursor-icon.png
Type=Application
Categories=Utility;Development;

• I save (CTRL + S) the changes, and exit (CTRL + X) the Nano text editor.

• I create a symlink to start Cursor from the terminal:

sudo ln -s ~/Apps/Cursor/Cursor.AppImage /usr/local/bin/cursor

• I restart my system.

• From the terminal, I run the Cursor IDE:

cursor

What is Windsurf?

Windsurf is an AI-powered code editor designed to enhance the coding experience with features like automatic context analysis, AI-driven autocompletion, and an intuitive user interface.

Installing Windsurf.

• I add the Windsurf repo to my local system:

curl -fsSL "https://windsurf-stable.codeiumdata.com/wVxQEIWkwPUEAGf3/windsurf.gpg" | sudo gpg --dearmor -o /usr/share/keyrings/windsurf-stable-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/windsurf-stable-archive-keyring.gpg arch=amd64] https://windsurf-stable.codeiumdata.com/wVxQEIWkwPUEAGf3/apt stable main" | sudo tee /etc/apt/sources.list.d/windsurf.list > /dev/null

• I update my system:

sudo apt update

• I upgrade Windsurf:

sudo apt upgrade windsurf

What is LM Studio?

LM Studio is an AI application for running local AI models.

NOTE: The following process can be used to install any AppImage app.

Installing LM Studio.

• I use a browser to download the AppImage file from the https://lmstudio.ai/download website.

• From the file manager, I move the LMStudio app to the NAS (network attached storage) server.

• From the terminal, I create the Apps/LMStudio directory:

mkdir ~/Apps/LMStudio

• I copy the LMStudio download to the the Apps/LMStudio directory:

cp /media/brian/Downloads/Ubuntu/'LM Studio'/LM*.AppImage ~/Apps/LMStudio/LMStudio.AppImage

NOTE: This copy command changes the download name to LMStudio.AppImage.

• I copy the 128px by 128px logo from the NAS to the ~/Apps/LMStudio directory:

cp /media/brian/Drawings/logos/lmstudio/Images/LMStudio-icon.png ~/Apps/LMStudio/LMStudio-icon.png

NOTE: I downloaded this image from the Internet.

• I make the AppImage executable:

chmod +x ~/Apps/LMStudio/LMStudio.AppImage

• I use the Nano text editor to create a desktop entry:

nano ~/.local/share/applications/lmstudio.desktop

• I paste (CTRL + SHIFT + V) the following into the desktop entry:

[Desktop Entry]
Name=Cursor
Exec=~/Apps/LMStudio/LMStudio.AppImage
Icon=~/Apps/LMStudio/LMStudio-icon.png
Type=Application
Categories=Utility;Development;

• I save (CTRL + S) the changes, and exit (CTRL + X) the Nano text editor.

• I create a symbolic link (-s) to start Cursor from the terminal:

sudo ln -s ~/Apps/LMStudio/LMStudio.AppImage /usr/local/bin/lmstudio

• I run LMStudio:

lmstudio

What is Open WebUI?

Open WebUI is a browser-based interface for using AI models.

Installing Open WebUI.

• From the terminal, I use Docker to pull Open WebUI:

sudo docker pull ghcr.io/open-webui/open-webui:main

• Now I can run Open WebUI on port 3000 from within the Docker container:

docker run -d -p 3000:8080 -v open-webui:/app/backend/data --name open-webui ghcr.io/open-webui/open-webui:main

• Alternatively, I can start Open WebUI from Docker Desktop.

What is Pinokio?

Pinokio is a browser that runs applications.

Installing Pinokio.

• I use a browser to visit the download page for Pinokio:

https://github.com/pinokiocomputer/pinokio/releases

• I download the latest version of Pinokio that runs on Debian (.deb) distributions for AMD64 processors.

• From the terminal, I install Pinokio:

sudo apt install -y ~/Downloads/Pinokio*

• I run Pinokio from the Apps Drawer.

What is Ngrok?

Ngrok creates secure tunnels to localhost, allowing developers to expose local servers to the Internet.

Installing Ngrok.

• In a browser, I visit the https://ngrok.com/ website and create an account.

• I copy the authentication token.

• From a new terminal tab, I install Ngrok:

sudo snap install ngrok

• I add the authentication token:

ngrok config add-authtoken <auth_token>

• I point Ngrok to any local port number that is running a server:

ngrok http <local_port_number>

The Results.

Setting up a local AI toolkit significantly improves my chances of improving my AI development skills. By following this guide, I efficiently installed, can manage, and will utilise various AI tools and frameworks. Combining Ollama, CrewAI, Pinokio, Open WebUI, LM Studio, Ngrok, and Cursor provides a robust environment for developing and experimenting with open AI models. This well-equipped, local toolkit will help me develop my vibe coding skills.

In Conclusion.

In this post, I described how to set up a powerful local AI toolkit on Ubuntu with step-by-step instructions. I learned how to install and manage AI tools like Ollama, CrewAI, and more, enhancing my AI development capabilities. This article is perfect for AI enthusiasts and developers looking to harness both open and commercial AI technologies.

Until next time: Be safe, be kind, be awesome.

Hash Tags.

#AI #Artificial-Intelligence #AI-Development #AI-Models #AI-Community #Machine-Learning #Deep-Learning #Linux #Ubuntu #Open-Source #Coding #Tech-Guide #Tech-Tools #Future-Tech #Innovation

TL;DR.

This post provides a guide to setting up a personalised Ubuntu 24.04 LTS system with essential applications and utilities. It covers software installation for productivity, development, and media tasks, including package managers, partition tools, and specialised applications like VS Code and DaVinci Resolve Studio. This guide emphasises the importance of keeping my system updated while exploring new tools that optimise workflows, supports daily tasks, and helps to achieve long-term goals.

Attributions:

Various ↗.

An Introduction.

Setting up a practical Ubuntu system requires a collection of apps and utilities that meet my needs. The applications and services I list below are used to adapt the Ubuntu 24.04 LTS distribution to my requirements.

The purpose of this post is to identify some apps and utilities that I find useful.

The Big Picture.

Software that is installed on my PC defines what I want to achieve with my computer. I run a dual-boot PC that allows me to boot into Ubuntu or Windows.

Ubuntu is my daily driver where I spend my time writing these blog posts, and practising my SysOps skills. It is also where I will develop my skills as a software developer and AI generalist.

I also run Windows-only programs like the Reason DAW (digital audio workstation) and the Anadigm Designer 2 computer-aided design tool.

A PC is a generic tool where the installed software defines what the user is capable of achieving.

Prerequisites.

• A Debian-based Linux distro (I use Ubuntu).

Updating the System.

APT (Advanced Package Tool) handles the installation and removal of software on Debian and Debian-based Linux distributions. The following commands are used to keep my Ubuntu system (a Debian-based Linux distro) up-to-date.

• From the terminal, I update my system:

sudo apt clean && \
sudo apt update && \
sudo apt dist-upgrade -y && \
sudo apt --fix-broken install && \
sudo apt autoclean && \
sudo apt autoremove -y

• I go to Settings > System > Software Updates to update my system.

Activating Ubuntu Pro.

Ubuntu Pro is a subscription service that extends the Long Term Support (LTS) versions of Ubuntu from 5 years to 10 years (and soon to be 12 years).

• In the Apps Drawer, I click on the blue, Additional Drivers icon to start the utility.

• In the Additional Drivers window, I click on the Ubuntu Pro tab.

• I click on the Enable Ubuntu Pro button.

• I can create an account, or login to an existing Ubuntu One account.

• The Enable Ubuntu Pro window generates a token.

• I take the token to https://ubuntu.com/pro/attach.

• It takes a moment to successfully apply the subscription.

NOTE: Canonical provides up to five (5) FREE tokens for personal PCs.

My Terminal Settings.

A terminal is a text window where system commands are issued.

• I go to Preferences > Unnamed > Text tab,

• I set the Initial terminal size to 80 columns and 24 rows,

• I set the Custom font to Monospace at 20pt,

• I set the Allow blinking text to Never, and

• I set the Cursor blinking to Disabled.

NOTE: These settings make it easier to see the commands I use.

Connecting My System to My NAS.

NOTE: Safely ignore this section if a NAS explainer is unnecessary.

Changing the Owner of My System Images.

NOTE: An image is a snapshot of my system. Due to my app development process, I sometimes end up with a flaky system. Using an image to restore my system to a previous state sidesteps the need to reinstall my OS and all of the apps. Creating images is an easy process when using CloneZilla Live from a USB thumb drive. After creating the USB drive, I can boot into CloneZilla Live and start “cloning“ my system as an image. An external HDD is handy because the resulting image can not be saved to a system drive that is being cloned. I use a simple naming convention, e.g. ‘datetime-img-clean-win10-ubu24’ where: ‘datetime-img-‘ is automatically prepended to the name, ‘clean‘ refers to a fresh installation, ‘win10‘ identifies Windows 10, and ‘ubu24‘ is a reference to Ubuntu Desktop 24.04.x LTS.

• I power up my PC.

• In the file manager, I navigate to the external drive that holds my system images.

• I access the root directory of the drive because that is where I save my images when they are made.

• I right-click the file manager and select Open in Terminal from the pop-up menu.

• From the terminal, I change the owner of an image:

sudo chown -R $USER:$USER datetime-img-simplified-name-of-contents

Installing Network Utilities.

NOTE: CIFS is a network file-sharing protocol that allows Linux systems to access Windows shares. Smbclient is a command-line tool that allows users to access and interact with SMB/CIFS file shares, commonly used in Windows environments, and Samba servers.

• I install the CIFS utilities:

sudo apt install -y cifs-utils smbclient

NOTE: CIFS is a dialect of SMB.

Removing the System Directories.

• I remove these directories:

sudo rm -r ~/Desktop ~/Documents ~/Downloads ~/Music ~/Pictures ~/Public ~/Templates ~/Videos

NOTE: It is now VITAL to continue this section until the very end. These deleted directories are important to the UI and UX of the desktop file manager.

Creating a Credentials File.

• I make a hidden file called .cred_smb in my home directory:

sudo touch /home/yt/.cred_smb

• I open the .cred_smb file using the Nano text editor:

sudo nano /home/yt/.cred_smb

• I copy the following, add it (CTRL + SHIFT + V) to the .cred_smb file, save (CTRL + S) the changes, and exit (CTRL + X) Nano:

username=yt
password=super-secret-password
domain=WORKGROUP

• I change the access permissions for the .cred_smb file:

sudo chmod 600 ~/.cred_smb

Altering the fstab File.

• I use a QNAP utility called Qfinder Pro that helps identify the IP address of my NAS.

• I make a copy the fstab file as fstab.bak:

sudo cp /etc/fstab /etc/fstab.bak

• I use the Nano text editor to open the fstab file:

sudo nano /etc/fstab

• I copy the following, add it (CTRL + SHIFT + V) to the bottom of the fstab file, save (CTRL + S) the changes, and exit (CTRL + X) Nano:

//192.168.0.2/ai             /media/yt/AI cifs vers=3.0,uid=1000,gid=1000,credentials=/home/yt/.cred_smb
//192.168.0.2/desktop        /media/yt/Desktop cifs vers=3.0,uid=1000,gid=1000,credentials=/home/yt/.cred_smb
//192.168.0.2/mydocs         /media/yt/Documents cifs vers=3.0,uid=1000,gid=1000,credentials=/home/yt/.cred_smb
//192.168.0.2/downloads      /media/yt/Downloads cifs vers=3.0,uid=1000,gid=1000,credentials=/home/yt/.cred_smb
//192.168.0.2/drawings       /media/yt/Drawings cifs vers=3.0,uid=1000,gid=1000,credentials=/home/yt/.cred_smb
//192.168.0.2/images         /media/yt/Images cifs vers=3.0,uid=1000,gid=1000,credentials=/home/yt/.cred_smb
//192.168.0.2/multimedia     /media/yt/Media cifs vers=3.0,uid=1000,gid=1000,credentials=/home/yt/.cred_smb
//192.168.0.2/music          /media/yt/Music cifs vers=3.0,uid=1000,gid=1000,credentials=/home/yt/.cred_smb
//192.168.0.2/mydocs         /media/yt/MyDocs cifs vers=3.0,uid=1000,gid=1000,credentials=/home/yt/.cred_smb
//192.168.0.2/mydrive        /media/yt/MyDrive cifs vers=3.0,uid=1000,gid=1000,credentials=/home/yt/.cred_smb
//192.168.0.2/photos         /media/yt/Pictures cifs vers=3.0,uid=1000,gid=1000,credentials=/home/yt/.cred_smb
//192.168.0.2/public         /media/yt/Public cifs vers=3.0,uid=1000,gid=1000,credentials=/home/yt/.cred_smb
//192.168.0.2/screencasts    /media/yt/Screencasts cifs vers=3.0,uid=1000,gid=1000,credentials=/home/yt/.cred_smb
//192.168.0.2/screenshots    /media/yt/Screenshots cifs vers=3.0,uid=1000,gid=1000,credentials=/home/yt/.cred_smb
//192.168.0.2/templates      /media/yt/Templates cifs vers=3.0,uid=1000,gid=1000,credentials=/home/yt/.cred_smb
//192.168.0.2/videos         /media/yt/Videos cifs vers=3.0,uid=1000,gid=1000,credentials=/home/yt/.cred_smb

Making Remote Share Directories.

• I create these directories where the remote shares will mount:

sudo mkdir /media/yt/AI && \
sudo mkdir /media/yt/Desktop && \
sudo mkdir /media/yt/Documents && \
sudo mkdir /media/yt/Downloads && \
sudo mkdir /media/yt/Drawings && \
sudo mkdir /media/yt/Images && \
sudo mkdir /media/yt/Media && \
sudo mkdir /media/yt/Music && \
sudo mkdir /media/yt/MyDocs && \
sudo mkdir /media/yt/MyDrive && \
sudo mkdir /media/yt/Pictures && \
sudo mkdir /media/yt/Public && \
sudo mkdir /media/yt/Screencasts && \
sudo mkdir /media/yt/Screenshots && \
sudo mkdir /media/yt/Templates && \
sudo mkdir /media/yt/Videos

Creating Symbolic Links.

• I create these symlinks (symbolic links) where the remote shares will display:

ln -s "/media/yt/AI" "/home/yt/AI"  && \
ln -s "/media/yt/Desktop" "/home/yt/Desktop" && \
ln -s "/media/yt/MyDocs" "/home/yt/Documents" && \
ln -s "/media/yt/Downloads" "/home/yt/Downloads" && \
ln -s "/media/yt/Drawings" "/home/yt/Drawings" && \
ln -s "/media/yt/Images" "/home/yt/Images" && \
ln -s "/media/yt/Media" "/home/yt/Media" && \
ln -s "/media/yt/Music" "/home/yt/Music" && \
ln -s "/media/yt/MyDocs" "/home/yt/MyDocs" && \
ln -s "/media/yt/MyDrive" "/home/yt/MyDrive" && \
ln -s "/media/yt/Pictures" "/home/yt/Pictures" && \
ln -s "/media/yt/Public" "/home/yt/Public" && \
ln -s "/media/yt/Screencasts" "/home/yt/Screencasts" && \
ln -s "/media/yt/Screenshots" "/home/yt/Screenshots" && \
ln -s "/media/yt/Templates" "/home/yt/Templates" && \
ln -s "/media/yt/Videos" "/home/yt/Videos"

• I update my system:

sudo apt clean && \
sudo apt update && \
sudo apt dist-upgrade -y && \
sudo apt --fix-broken install && \
sudo apt autoclean && \
sudo apt autoremove -y

• I reboot my system.

• I check the symlinks to my NAS.

Restoring the System Directories.

• Once I have access to my NAS, I can edit the following file so the default system directories point to the equivalent share directories which, in turn, point to the NAS:

sudo nano $HOME/.config/user-dirs.dirs

NOTE: For example: XDG_DOWNLOAD_DIR="/media/yt/Downloads" points the system Downloads directory to the remote share directory I created earlier.

Installing GNOME Tweaks.

GNOME Tweaks is a system utility for the GNOME desktop environment GUI.

• From the terminal, I install GNOME Tweaks:

sudo apt install -y gnome-tweaks

• I run GNOME Tweaks:

gnome-tweaks

• I right-click the icon in the Dock and select “Pin to Dash” from the pop-up menu.

Installing the Package Managers.

Package managers are used to distribute apps and utilities.

NOTE: A developer might also package their app as an AppImage.

Installing the Snap Package Manager.

• From the terminal, I use APT to install the Snap daemon:

sudo apt install -y snapd

• I use Snap to install the Snap package manager core:

sudo snap install core

Installing the Flatpak Package Manager.

• From the terminal, I refresh the terminal:

. ~/.bashrc

• I use the APT to install the Flatpak package manager:

sudo apt install -y flatpak

Installing the Partition Managers.

Partition managers are system utilities for HDDs and SSDs.

Installing GNOME Disks.

GNOME Disks is the default, graphical, partition management tool on all the GNOME-based desktop environments. The following describes how to install the GNOME Disks utility, if required.

• From the terminal, I install GNOME Disks utility (if required):

sudo apt -y install gnome-disk-utility

Installing GParted.

GParted, or GNOME Partition Editor, is an alternative to GNOME Disks. It is a free, graphical, partition management tool. The following describes how to install the GParted utility.

• From the terminal, I install the GParted utility:

sudo apt -y install gparted

GParted can also be installed onto a USB thumb drive↗.

Installing exfatprogs.

exfatprogs allows partition management tools, like GNOME Disks and GParted, to use the exFAT file system when formatting partitions.

NOTE: exFAT is a proprietary file system from Microsoft, was released in 2006, and is the successor to FAT32.

• From the terminal, I install the exfatprogs library:

sudo apt -y install exfatprogs

Installing UNZIP.

UNZIP is a utility that is used to unpack compressed packages.

• From the terminal, I install UNZIP:

sudo apt install unzip

Installing Curl.

curl is a command-line utility for transferring data to, or from, a remote server.

• From the terminal, I install Curl:

sudo apt install -y apt-transport-https curl

Installing Wget.

Wget is a command-line utility for retrieving files using the HTTP or FTP protocols.

• From the terminal, I install Wget:

sudo apt install wget

Installing uv.

• I run the following command to install the Python package and project manager called uv:

curl -LsSf https://astral.sh/uv/install.sh | sh

Installing Miniconda.

• Check out this post to see how to install Miniconda.

Installing LXD and Using LXCs.

• Check out these posts to see how to install LXD and create an LXC.

Installing NodeJS.

NodeJS is a server-side runtime that uses the V8 JavaScript engine.

• I download and install nvm:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash

• I restart the shell:

\. "$HOME/.nvm/nvm.sh"

• I download and install Node.js:

nvm install 22

• I verify the Node.js version:

node -v

• I verify npm version:

npm -v

Installing the NodeJS Package Managers.

Package managers are used to bundle code for distribution.

Installing NPM.

• I install NPM:

sudo apt install -y npm

• I verify the NPM installation:

npm -v

Installing NVM.

• I download, and run, the NVM installation script:

wget -q -O- https://raw.githubusercontent.com/nvm-sh/nvm/master/install.sh | bash

• I refresh my terminal:

. ~/.bashrc

• I verify the NVM installation:

nvm -v

Installing PNPM.

• I install PNPM:

sudo npm install -g pnpm

• I verify the PNPM installation:

pnpm -v

Installing NPX.

NOTE: NPX is now part of the NPM CLI.

Installing Git.

Git is a version control utility.

• From the terminal, I install Git:

sudo apt install -y git-all

• I verify the installation:

git -v

• I add my name:

git config --global user.name "Brian King"

• I add my email address:

git config --global user.email "brian@digitalcore.co.nz"

• I list the configuration settings:

git config --list

Installing the GitHub Utility.

GitHub CLI is a tool that extends the capabilities of Git. Developers can interact with GitHub repositories, pull requests, issues, and workflows directly from their terminal.

Installing GitHub CLI.

• From the terminal, I install GitHub CLI:

(type -p wget >/dev/null || (sudo apt update && sudo apt-get install wget -y)) \
    && sudo mkdir -p -m 755 /etc/apt/keyrings \
    && out=$(mktemp) && wget -nv -O$out https://cli.github.com/packages/githubcli-archive-keyring.gpg \
    && cat $out | sudo tee /etc/apt/keyrings/githubcli-archive-keyring.gpg > /dev/null \
    && sudo chmod go+r /etc/apt/keyrings/githubcli-archive-keyring.gpg \
    && echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null \
    && sudo apt update \
    && sudo apt install gh -y

Upgrading GitHub CLI.

• I upgrade GitHub CLI:

sudo apt update && sudo apt install gh

Authorising GitHub CLI.

• I authorise GitLab CLI:

gh auth login

Installing Docker CE.

Docker CE (Community Edition) is a container manager for app development and distribution.

Attribution:

https://linuxiac.com/how-to-install-docker-on-ubuntu-24-04-lts/ ↗.

• From the terminal, I add HTTPS and the Curl utility:

sudo apt install -y apt-transport-https curl

• I import the Docker GPG repository key:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

• I add the official Docker repository to my system:

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

• I refresh my local repo list:

sudo apt update && sudo apt upgrade

• I install Docker:

sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

• I check to see if Docker is active:

sudo systemctl is-active docker

• I create the Docker group:

sudo groupadd docker

• I add my account to the group:

sudo usermod -aG docker $USER

• I test the installation:

sudo docker run hello-world

Uninstalling Docker CE.

Attributions:

https://learnubuntu.com/uninstall-docker/ ↗.

• From the terminal, I stop the running Docker containers:

docker stop $(docker ps -a -q)

• I remove the Docker containers:

docker rm $(docker ps -a -q)

• I remove the Docker images:

docker rmi $(docker images -a -q)

• I prune the custom Docker networks:

docker network prune

• I prune the Docker containers, networks, images, cache and volumes:

docker system prune -a

• I purge every Docker package:

sudo apt purge docker-* containerd.io --auto-remove

• I remove the Docker files:

sudo rm -rf /var/lib/docker

• I remove the Docker group:

sudo groupdel docker

• I remove the Docker socket:

sudo rm -rf /var/run/docker.sock

• I remove Docker Compose:

sudo rm -rf /usr/local/bin/docker-compose && sudo rm -rf /etc/docker && sudo rm -rf ~/.docker

Installing Docker Desktop.

Docker Desktop is a GUI for Docker.

Attributions:

https://docs.docker.com/desktop/setup/install/linux/ubuntu/ ↗,

https://dev.to/chandrashekhar/docker-desktop-is-not-working-on-ubuntu-2404-lts--2kpa ↗.

• I download the latest version of Docker Desktop:

https://docs.docker.com/desktop/release-notes/

• From the terminal, I change to the Downloads directory:

cd ~/Downloads

• I install the DEB package:

sudo apt install -y ./docker-desktop*.deb

NOTE: Ignore the error message after installation.

• I fix the permissions issue:

echo 'kernel.apparmor_restrict_unprivileged_userns = 0' | sudo tee /etc/sysctl.d/20-apparmor-donotrestrict.conf

• I reboot my system:

reboot

• After the reboot, I return to a terminal and launch Docker Desktop:

systemctl --user start docker-desktop

• From the Apps Drawer, I pin the Docker Desktop icon to the Dock.

Uninstall Docker Desktop.

• From the terminal, I remove Docker Desktop from my system:

sudo apt remove docker-desktop

• I remove the configuration and data files:

sudo apt remove docker-desktop && sudo rm /usr/local/bin/com.docker.cli && sudo apt purge docker-desktop

Updating Blender.

Blender is a 3D modelling, rendering, animation, and simulation app.

• From the terminal, I update Blender:

sudo apt purge -y --auto-remove blender && sudo snap install blender --classic

Removing Blender.

• I use the following command to remove Blender:

sudo snap remove blender

Installing VS Code.

VS Code (Visual Studio Code) is a free, versatile code editor.

• From the terminal, I install VS Code:

sudo snap install code --classic

Updating the Snap-Installed VS Code Editor.

I use the following command to update the Snap-Installed VS Code editor:

sudo snap refresh code --classic

Removing VS Code.

• I use the following command to remove VS Code:

sudo snap remove code

• This command removes the configurations for VS Code:

sudo rm -R ~/.config/Code

• This command removes the installation directory:

sudo rm -R ~/.vscode

Printing an AsciiDoc File as a PDF.

• I install the AsciiDoc extension from Asciidoctor for VS Code.

• From the terminal, I install Ruby:

sudo apt install -y ruby-full

• I install the AsciiDoctor PDF Gem:

sudo gem install asciidoctor-pdf

• From the terminal, I look for the path to the AsciiDoctor PDF Gem:

which asciidoctor-pdf

• Within VS Code, I open the Settings tab and search for asciidoc-pdf.

• I set the Asciidoc > Pdf: Asciidoctor Pdf Command Path:

/usr/local/bin/asciidoctor-pdf

NOTE: The path might also be /usr/bin/asciidoctor-pdf.

• I set the Asciidoc > Pdf: Engine to asciidoctor-pdf.

• I create an example AsciiDoc file called example.ad:

# Test File

This is a test file.

• I open the Command Palette (CTRL + SHIFT + P) and search for AsciiDoc: Export Document as PDF.

• I use this feature to generate a PDF file based on my my example.ad file.

Removing Ruby.

• I use the following command to remove Ruby:

sudo apt remove ruby -y

Useful VS Code Extensions when using AsciiDoc.

Here is a list of other VS Code extensions I find useful when creating an example.ad file or generating a PDF file from the example.ad file:

• Code Spell Checker from Street Side Software let’s me check for spelling mistakes in my example.ad file, and

• vscode-pdf from tomoki1207 let’s me view PDF files within VS Code. This is useful when I use AsciiDoc to generate PDF files because the view automatically updates on when I export an update to the example.ad content.

Installing Spotify.

Spotify is an app and streaming service.

• From the terminal, I install Spotify:

sudo snap install spotify

Removing Spotify.

• I use the following command to remove Spotify:

sudo snap remove spotify

Installing Screenkey.

Screenkey displays keystrokes on a monitor.

• From the terminal, I install Screenkey:

sudo apt install -y screenkey

Installing Inkscape.

Inkscape is a vector-based image editor.

• From the terminal, I add the repo:

sudo add-apt-repository ppa:inkscape.dev/stable

• I update and upgrade my system:

sudo apt update && sudo apt -y dist-upgrade

• I install Inkscape:

sudo apt install -y inkscape

Installing Krita.

Krita is a pixel-based image editor.

• From the terminal, I install Krita:

sudo snap install krita

Installing Krita Manually.

• From the terminal, I install the libfuse2 library:

sudo apt install libfuse2

NOTE: AppImages rely on FUSE (Filesystem in Userspace) to function properly.

• From a browser, I download the AppImage file from the Krita.org website.

• From the file manager, I move the Krita app to it’s own directory.

• I copy the Krita logo to the Krita directory:

NOTE: I downloaded the Krita PNG logo from the Internet.

• From the Krita directory, I make the AppImage executable, for example:

chmod +x krita-5.2.13-x86_64.AppImage

• I use the Nano text editor to create a desktop entry:

nano ~/.local/share/applications/krita.desktop

• I paste (CTRL + SHIFT + V) the following into the desktop entry, e.g.:

[Desktop Entry]
Name=Krita
Exec=/media/brian/Downloads/Ubuntu/Krita/krita-5.2.13-x86_64.AppImage
Icon=/media/brian/Downloads/Ubuntu/Krita/krita-logo.png
Type=Application
Categories=Graphics;Images

• I save (CTRL + S) the changes, and exit (CTRL + X) the Nano text editor.

• I create a symlink to start Krita from the terminal:

sudo ln -s /media/brian/Downloads/Ubuntu/Krita/krita-5.2.13-x86_64.AppImage /usr/local/bin/krita

• I open a new terminal.

• From the new terminal, I run the Krita image editor:

krita

• From the apps menu, I pin the Krita app to the Dash.

Updating the Firefox Browser.

NOTE: I can determine the type of Firefox installation (APT or Snap) by reading the Help > About Firefox banner.

• I use the following command to update the Snap-installed Firefox browser:

sudo snap refresh firefox

• I use the following command to update the APT-installed Firefox browser:

sudo apt update && sudo apt upgrade firefox

Installing the Brave Browser.

Brave is a Chromium-based web browser.

• From the terminal, I install the Brave browser:

sudo curl -fsSLo /usr/share/keyrings/brave-browser-archive-keyring.gpg https://brave-browser-apt-release.s3.brave.com/brave-browser-archive-keyring.gpg && echo "deb [signed-by=/usr/share/keyrings/brave-browser-archive-keyring.gpg] https://brave-browser-apt-release.s3.brave.com/ stable main"|sudo tee /etc/apt/sources.list.d/brave-browser-release.list && sudo apt update && sudo apt install -y brave-browser

Installing Rust.

Rust is a general-purpose, memory-safe, programming language.

• From the terminal, I install Rust:

sudo apt install build-essential && curl --proto '=https' --tlsv1.3 https://sh.rustup.rs -sSf | sh && source "$HOME/.cargo/env"

• I check to version:

rustup --version

• I open the docs:

rustup doc

Uninstalling Rust.

• I use the following command to uninstall Rust:

rustup self uninstall

Installing OBS Studio.

OBS Studio is a screen casting and streaming app.

• From the terminal, I install the repository:

sudo add-apt-repository ppa:obsproject/obs-studio

• I update, and upgrade, my system:

sudo apt update && sudo apt -y upgrade

• I install OBS Studio:

sudo apt install -y obs-studio

Installing DaVinci Resolve Studio.

DaVinci Resolve is a video editing, colour grading, and sound mixing app.

NOTE: DaVinci Resolve Studio requires a user license.

• I download the latest Linux copy of DaVinci Resolve 19 Studio:

https://www.blackmagicdesign.com/au/support/family/davinci-resolve-and-fusion

• From the terminal, I install the following packages:

sudo apt install -y libqt5x11extras5 libfuse2

• I go to the directory with the latest copy of DaVinci Resolve Studio:

cd /media/brian/Downloads/Ubuntu/Blackmagic_Design/DaVinci_Resolve/20.2.3_Studio

• I extract the contents of the downloaded ZIP file:

sudo unzip ./DaVinci_Resolve_*_Linux.zip

• I change the mode of the extracted RUN file to an executable:

sudo chmod +x ./DaVinci_Resolve_*_Linux.run

• I install the unzipped run file:

sudo SKIP_PACKAGE_CHECK=1 ./DaVinci_Resolve_*_Linux.run -i

NOTE: The SKIP_PACKAGE_CHECK=1 command bypasses the check system that looks for missing libraries during the installation.

• I make a new directory called disabled_libs:

sudo mkdir /opt/resolve/libs/disabled_libs

• I move the libglib, libgio, and libgmodule into the disabled_libs directory:

sudo mv /opt/resolve/libs/libglib-2.0.so* /opt/resolve/libs/libgio-2.0.so* /opt/resolve/libs/libgmodule-2.0.so* /opt/resolve/libs/disabled_libs/

NOTE: Moving these libraries forces Resolve to use the Ubuntu libraries.

• I update my NVIDIA drivers, if required:

sudo apt install -y nvidia-driver-580

NOTE: Resolve requires the 550 drivers or later.

• I run the application using the Desktop icon (in the Apps Drawer), or as a terminal session:

/opt/resolve/bin/resolve

Fixing the Resolve Scaling Issue.

• Open a project.

• Go to DaVinci Resolve (top left) > Preferences > User.

• Set the UI Display Scale to 200%.

Installing Fusion Studio.

Fusion Studio is a visual effects, 3D animation, and motion graphics app.

NOTE: Fusion Studio uses the same license that activates DaVinci Resolve Studio.

• I download the latest Linux copy of Fusion Studio 19:

https://www.blackmagicdesign.com/au/support/family/davinci-resolve-and-fusion

• I go to the directory with the latest copy of Fusion Studio:

cd /media/brian/Downloads/Ubuntu/Blackmagic_Design/Fusion/20.2.3_Studio

• I extract the contents of the downloaded ZIP file:

sudo unzip ./Blackmagic_Fusion_Studio_*.tar

• I change to the new sub-directory:

cd ./Blackmagic_Fusion_Studio_20.2.3_Linux

• I change the mode of the extracted RUN file to an executable:

sudo chmod +x ./Blackmagic_Fusion_Studio_*.run

• I install the unzipped run file:

sudo SKIP_PACKAGE_CHECK=1 ./Blackmagic_Fusion_Studio_*_installer.run -i

• I update my NVIDIA drivers, if required:

sudo apt install -y nvidia-driver-580

NOTE: Fusion requires the 550 drivers or later.

• I run the application using the Desktop icon (in the Apps Drawer), or as a terminal session:

/opt/BlackmagicDesign/Fusion19/Fusion

One Final Update.

• From the terminal, I update my system one last time:

sudo apt clean && \
sudo apt update && \
sudo apt dist-upgrade -y && \
sudo apt --fix-broken install && \
sudo apt autoclean && \
sudo apt autoremove -y

The Results.

Setting up a personalised Ubuntu 24.04 LTS system involves selecting and installing a variety of applications and utilities that cater to my specific needs. From essential software like package managers and partition tools to specialised applications for development, media, and productivity, each component plays a crucial role in enhancing my computing experience. By carefully choosing and configuring these tools, I can create a versatile and efficient environment that supports my daily tasks and long-term goals. I keep my system updated while exploring new tools that can further optimise my workflow.

In Conclusion.

I’ve improved my Ubuntu experience with these essential apps & utilities.

Over the past 10 years, I’ve discovered these must-have applications and utilities that let me tailor my system to my requirements. As a developer, a creative, and someone who loves a well-ordered digital workspace, this guide includes a minimum set of tools that I find essential.

From package managers like APT, Snap, and Flatpak, to partition managers like GNOME Disks and GParted, and the media utilities that ship in Ubuntu Studio, I have a standard set of tools that meets most of my daily needs.

With tools like Blender for 3D modelling, DaVinci Resolve Studio for video editing, and VS Code for app development, I can easily achieve any outcome that comes to mind.

I can stream my favourite tunes with Spotify while compiling new software using the Rust compiler. I can even enhance my app development with tools like Docker Desktop and Miniconda.

Keeping my system updated and exploring new tools will significantly optimise my workflow and support my daily tasks as well as my long-term goals.

What are your go-to applications? Share your favourites in the comments below!

Until next time: Be safe, be kind, be awesome.

Hash Tags.

#Ubuntu #Ubuntu-Studio #Linux #Open-Source #Productivity #Software-Development #Blender #DaVinci-Resolve-Studio #VS-Code #Docker #Spotify #Innovation #Tech-Community #Tech-Tools

Update: Saturday 18th February 2025.

This post is a guide to installing, setting up, and testing DSPy (Declarative Self-improving Python) and will cover the following topics:

• The prerequisites for assembling a DSPy development environment,

• The installation of Ollama and Miniconda,

• The creation of a Conda environment for DSPy,

• The installation of the DSPy framework,

• The installation and setup up of Jupyter Notebook,

• Running the test code in the newly assembled DSPy development environment, and

• Running the test code using Python.

The aim of this guide is to assemble, and test, a development environment for DSPy programming.

Attributions ↗:

https://dspy.ai/tutorials/rag/ ↗,

https://github.com/stanfordnlp/dspy ↗, and

https://dspy.ai/ ↗.

An Introduction.

DSPy is used to programmatically provide "a more systematic approach to solving hard tasks with advanced LMs." It exists to build simple Classifiers, sophisticated RAG pipelines, and Agentic processes.

The purpose of this post is to provide a procedure for creating a DSPy programming environment.

The Big Picture.

For classifiers, RAG (Retrieval-Augmented Generation), and agents, the main idea is to take advantage of advanced LM workflows, especially those systems that can retrieve relevant information while generating contextually accurate responses. By integrating retrieval mechanisms with generative models, these workflows aim to create intelligent systems that can autonomously navigate complex tasks, adapt to dynamic environments, and provide insightful solutions. This approach not only improves the accuracy and relevance of LM outputs but also empowers users to leverage AI for complex, problem-solving operations.

DSPy is a programmatic tool for creating advanced AI solutions that was originally designed to replace the clunky, and fragile, prompt engineering paradigm.

Prerequisites.

• A Debian-based Linux distro (I use Ubuntu).

Updating my Base System.

• From the (base) terminal, I update my (base) system:

sudo apt clean && \
sudo apt update && \
sudo apt dist-upgrade -y && \
sudo apt --fix-broken install && \
sudo apt autoclean && \
sudo apt autoremove -y

NOTE: The Ollama LLM manager is already installed on my (base) system.

What is Ollama?

Ollama is a tool that is used to download, set up, and run large language models on a local PC. It lets me use powerful models like Llama 2 and Mistral on my personal computer. Ollama natively runs on Linux, macOS, and Windows (in preview).

Installing Ollama.

• From the terminal, I install Ollama:

curl https://ollama.ai/install.sh | sh

• I list the LMs downloaded by Ollama:

ollama list

• If the above command fails, I run Ollama as a background service:

ollama serve &

• If the following error shows when running the previous command, that means Ollama is already running as a background service:

Error: listen tcp 127.0.0.1:11434: bind: address already in use

Pulling an Advanced LM.

• I pull an advanced LM:

ollama pull deepseek-r1:14b

NOTE: This model has 14B parameters, requires 9GB of VRAM, and runs on my RTX 3060 12GB GPU.

What is Miniconda?

Miniconda, a bootstrap version of Anaconda, is a virtual environment manager that is small, FREE, and also includes the conda package manager, Python, and other packages that are required or useful to a developer, like pip and zlib.

Installing Miniconda.

• I make the Miniconda directory:

mkdir -p ~/miniconda3

• I download the installation payload:

wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O ~/miniconda3/miniconda.sh

• I run the installation script:

bash ~/miniconda3/miniconda.sh -b -u -p ~/miniconda3

• I remove the installation script:

rm -rf ~/miniconda3/miniconda.sh

Initialising Miniconda.

• I initialize Miniconda:

~/miniconda3/bin/conda init bash

Updating Miniconda.

• I change the owner of the Miniconda directory to the current, logged-in account:

sudo chown -R $USER:$USER $HOME/miniconda3

• I update Miniconda:

conda update -n base -c defaults conda

Using Conda to Create the DSPy Environment.

• I use conda to display a list of Miniconda environments:

conda env list

• I use conda to create, and activate, a new environment named (-n) (DSPy):

conda create -n DSPy python=3.11 -y && conda activate DSPy

NOTE: This command creates the (DSPy) environment, then activates the (DSPy) environment.

Creating the DSPy Home Directory.

NOTE: I will define the home directory with settings in the environment directory.

• I create the DSPy home directory:

mkdir ~/DSPy

• I make new directories within the (DSPy) environment:

mkdir -p ~/anaconda3/envs/DSPy/etc/conda/activate.d

• I use the Nano text editor to create the set_working_directory.sh shell script:

sudo nano ~/anaconda3/envs/DSPy/etc/conda/activate.d/set_working_directory.sh

• I add the following, save (CTRL + S) the changes, and exit (CTRL + X) the Nano text editor:

cd ~/DSPy

• I activate the (base) environment:

conda activate

• I activate the (DSPy) environment:

conda activate DSPy

NOTE: I should now, by default, be in the ~/DSPy home directory.

Installing DSPy.

• From the (DSPy) terminal, I install the latest version of DSPy:

pip install git+https://github.com/stanfordnlp/dspy.git

• I can also use pip to install DSPy directly from PyPI:

pip install -U dspy

Installing Jupyter Notebook

• From the DSPy terminal, I install Jupyter Notebook:

pip install notebook

• I generate a Jupyter Notebook configuration file:

jupyter notebook --generate-config

• I open the configuration file with the Nano text editor:

sudo nano ~/.jupyter/jupyter_notebook_config.py

• I set a default browser*:

c.ServerApp.browser = '/bin/brave-browser %s'

• I save (CTRL + S) the changes and exit (CTRL + X) the Nano text editor,

• I upgrade Jupyter Notebook:

pip install --upgrade jupyter

• I upgrade a Jupyter Notebook dependency:

pip install --upgrade ipywidgets

• I run the Jupyter Notebook on port 8091:

jupyter notebook --port 8091

• In the file menu, I select "File > New > Notebook",

• I choose the default "Python 3 (ipykernel)" kernel, select the "Always start the preferred kernel" tick box, and click the blue "Select" button,

• In the file menu of the Notebook, I select "File > Rename...",

• I rename the Notebook as "hello-world.ipynb" and click the blue "Rename" button.

Testing the DSPy Environment.

• In the “hello-world“ Notebook, I define the local model that is used by DSPy:

import dspy

lm = dspy.LM(model='ollama/deepseek-r1:14b')
dspy.configure(lm=lm)

NOTE: Deepseek R1 uses chain-of-thought reasoning by default and, as a result, may take longer to compose a result. However, using this model results in a higher chance of generating a correct answer.

• In a new cell, I declare a module that takes a question (of type str) as input and produces a response as an output:

qa = dspy.Predict('question: str -> response: str')
response = qa(question="What is Hello World?")

print(response.response)

Running the Code with Python.

• From the (DSPy) terminal, I change to the DSPy directory:

cd ~/DSPy

• I use the Nano text editor to create the hello_world.py file:

sudo nano hello-world.py

• I add (CTRL + SHIFT + V) the following to the hello_world.py file:

import dspy

lm = dspy.LM(model='ollama/deepseek-r1:14b')
dspy.configure(lm=lm)

qa = dspy.Predict('question: str -> response: str')
response = qa(question="What is Hello World?")

print(response.response)

NOTE: The code above is exactly the same as the combined cells from the Notebook.

• I save (CTRL + S) the changes and exit (CTRL + X) the Nano text editor.

• I run the following command:

python3 hello_world.py

Advanced Testing: OPTIONAL

The previous “hello-world” test was to ensure the development software was installed correctly. These tests explore what tasks the deepseek-r1:14b LM can perform out of the box.

Also, these tests show a range of tasks that can be performed using DSPy programming techniques.

• At the (DSPy) terminal, I change to the DSPy directory:

cd ~/DSPy

• I install SGLang:

pip install "sglang[all]"

NOTE: SGLang is a fast serving framework for large language models and vision language models.

• I install FlashInfer:

pip install flashinfer -i https://flashinfer.ai/whl/cu121/torch2.4/

NOTE: FlashInfer is a library and kernel generator for Large Language Models that provides high-performance implementation of LLM GPU kernels such as FlashAttention, PageAttention and LoRA.

Maths.

• I run the Jupyter Notebook:

jupyter notebook --port 8091

• In the file menu, I select "File > New > Notebook",

• I choose the default "Python 3 (ipykernel)" kernel, select the "Always start the preferred kernel" tick box, and click the blue "Select" button,

• In the file menu of the Notebook, I select "File > Rename...",

• I rename the Notebook as "maths.ipynb" and click the blue "Rename" button.

• In the Notebook, I define the local model that is used by DSPy:

import dspy

lm = dspy.LM(model='ollama/deepseek-r1:14b')
dspy.configure(lm=lm)

• In a new cell, I add the following:

maths = dspy.ChainOfThought("question -> answer: float")
maths(question="Two dice are tossed. What is the probability that the sum equals two?")

ANSWER: 0.0277778.

RAG.

• In the Jupyter Notebook file menu, I select "File > New > Notebook",

• I choose the default "Python 3 (ipykernel)" kernel, select the "Always start the preferred kernel" tick box, and click the blue "Select" button,

• In the file menu of the Notebook, I select "File > Rename...",

• I rename the Notebook as "rag.ipynb" and click the blue "Rename" button.

• In the Notebook, I define the local model that is used by DSPy:

import dspy

lm = dspy.LM(model='ollama/deepseek-r1:14b')
dspy.configure(lm=lm)

• In a new cell, I add the following:

def search_wikipedia(query: str) -> list[str]:
    results = dspy.ColBERTv2(url='http://20.102.90.50:2017/wiki17_abstracts')(query, k=3)
    return [x['text'] for x in results]

rag = dspy.ChainOfThought('context, question -> response')

question = "What's the name of the castle that David Gregory inherited?"
rag(context=search_wikipedia(question), question=question)

ANSWER: Kinnairdy Castle.

Classification.

• In the Jupyter Notebook file menu, I select "File > New > Notebook",

• I choose the default "Python 3 (ipykernel)" kernel, select the "Always start the preferred kernel" tick box, and click the blue "Select" button,

• In the file menu of the Notebook, I select "File > Rename...",

• I rename the Notebook as "classification.ipynb" and click the blue "Rename" button.

• In the Notebook, I define the local model that is used by DSPy:

import dspy

lm = dspy.LM(model='ollama/deepseek-r1:14b')
dspy.configure(lm=lm)

• In a new cell, I add the following:

from typing import Literal

class Classify(dspy.Signature):
    """Classify sentiment of a given sentence."""

    sentence: str = dspy.InputField()
    sentiment: Literal['positive', 'negative', 'neutral'] = dspy.OutputField()
    confidence: float = dspy.OutputField()

classify = dspy.Predict(Classify)
classify(sentence="This book was super fun to read, though not the last chapter.")

ANSWER: sentiment='positive', confidence=0.75.

Information Extraction.

• In the Jupyter Notebook file menu, I select "File > New > Notebook",

• I choose the default "Python 3 (ipykernel)" kernel, select the "Always start the preferred kernel" tick box, and click the blue "Select" button,

• In the file menu of the Notebook, I select "File > Rename...",

• I rename the Notebook as "extraction.ipynb" and click the blue "Rename" button.

• In the Notebook, I define the local model that is used by DSPy:

import dspy

lm = dspy.LM(model='ollama/deepseek-r1:14b')
dspy.configure(lm=lm)

• In a new cell, I add the following:

class ExtractInfo(dspy.Signature):
    """Extract structured information from text."""

    text: str = dspy.InputField()
    title: str = dspy.OutputField()
    headings: list[str] = dspy.OutputField()
    entities: list[dict[str, str]] = dspy.OutputField(desc="a list of entities and their metadata")

module = dspy.Predict(ExtractInfo)

text = "Apple Inc. announced its latest iPhone 14 today." \
    "The CEO, Tim Cook, highlighted its new features in a press release."
response = module(text=text)

print(response.title)
print(response.headings)
print(response.entities)

ANSWER: Apple Announces iPhone 14 ['Announcement Details', 'Press Release Highlights', 'New Features'] [{'EntityType': 'Company', 'Description': 'Technology company known for iPhones'}, {'EntityType': 'Person', 'Description': 'CEO of Apple'}]

Agents.

• In the Jupyter Notebook file menu, I select "File > New > Notebook",

• I choose the default "Python 3 (ipykernel)" kernel, select the "Always start the preferred kernel" tick box, and click the blue "Select" button,

• In the file menu of the Notebook, I select "File > Rename...",

• I rename the Notebook as "agents.ipynb" and click the blue "Rename" button.

• In the Notebook, I define the local model that is used by DSPy:

import dspy

lm = dspy.LM(model='ollama/deepseek-r1:14b')
dspy.configure(lm=lm)

• In a new cell, I add the following:

def evaluate_math(expression: str):
    return dspy.PythonInterpreter({}).execute(expression)

def search_wikipedia(query: str):
    results = dspy.ColBERTv2(url='http://20.102.90.50:2017/wiki17_abstracts')(query, k=3)
    return [x['text'] for x in results]

react = dspy.ReAct("question -> answer: float", tools=[evaluate_math, search_wikipedia])

pred = react(question="What is 9362158 divided by the year of birth of David Gregory of Kinnairdy castle?")
print(pred.answer)

ANSWER: 5761.328

The Results.

Setting up DSPy involves creating a robust, development environment where complex tasks can leverage the capabilities of advanced, and powerful, language models. By following the outlined process, from installing Ollama and Miniconda, to creating a dedicated Conda environment, while setting up a Jupyter Notebook, I can use the resulting environment to efficiently manage (and execute) DSPy programmes. The whole purpose of this post is to setup a local workspace for DSPy development. With DSPy, I will be equipped to explore, and implement, advanced LM capabilities that provide leading, innovative solutions.

In Conclusion.

I am now ready to revolutionize my approach to complex tasks with advanced LMs. Meet DSPy (Declarative Self-improving Python) – my new best friend in systematic problem-solving!

Setting up DSPy is a breeze with a few essential steps. I start by installing Ollama and Miniconda, then I create a dedicated environment for DSPy.

Next, set up Jupyter Notebook to streamline my workflow and enhance productivity. With DSPy, I’m paving the way for innovative solutions across numerous domains.

By following this structured setup, I can efficiently manage and execute DSPy procedures, unlocking advanced LM capabilities.

Are you ready to explore the potential of DSPy in your projects? How do you plan to leverage advanced LMs for your next big idea? Let's discuss below!

Until next time: Be safe, be kind, be awesome.

Tags.

#DSPy #Python #LanguageModels #Innovation #ProblemSolving

This post provides a comprehensive guide on installing and uninstalling Docker and Docker Desktop on Ubuntu 24.04. It covers the prerequisites, step-by-step installation process, and troubleshooting tips, ensuring a smooth setup for managing containerized applications and microservices. The guide also highlights the benefits of using Docker Desktop for efficient software development.

Attributions:

https://www.docker.com/ ↗.

An Introduction.

Docker and Docker Desktop are essential tools for modern software development. Whether you're a beginner or an experienced developer, this article will help you enhance your development workflow.

The purpose of this post is to describe how to install Docker and Docker Desktop on Ubuntu 24.04.

The Big Picture.

Docker and Docker Desktop are pivotal to modern software development. The containerisation approach to coding enhances the portability and scalability of applications across different platforms, eliminating any “it runs on my system” obstacles.

Prerequisites.

• A Debian-based Linux distro (I use Ubuntu).

Updating my Base System.

• From the (base) terminal, I update my (base) system:

sudo apt clean && \
sudo apt update && \
sudo apt dist-upgrade -y && \
sudo apt --fix-broken install && \
sudo apt autoclean && \
sudo apt autoremove -y

NOTE: The Ollama LLM manager is already installed on my (base) system.

What is Docker?

Docker is used to containerise apps (and their dependencies) so they can run on any desktop and/or server operating system.

Installing Docker.

Attribution:

https://linuxiac.com/how-to-install-docker-on-ubuntu-24-04-lts/ ↗.

• From the terminal, I add HTTPS and the Curl utility:

sudo apt install -y apt-transport-https curl

• I import the Docker GPG repository key:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

• I add the official Docker repository to my system:

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

• I refresh my local repo list:

sudo apt update

• I install Docker:

sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

• I check to see if Docker is active:

sudo systemctl is-active docker

• I test the installation:

sudo docker run hello-world

Uninstalling Docker.

Attributions:

https://learnubuntu.com/uninstall-docker/ ↗.

• From the terminal, I stop the running Docker containers:

docker stop $(docker ps -a -q)

• I remove the Docker containers:

docker rm $(docker ps -a -q)

• I remove the Docker images:

docker rmi $(docker images -a -q)

• I prune the custom Docker networks:

docker network prune

• I prune the Docker containers, networks, images, cache and volumes:

docker system prune -a

• I purge every Docker package:

sudo apt purge docker-* containerd.io --auto-remove

• I remove the Docker files:

sudo rm -rf /var/lib/docker

• I remove the Docker group:

sudo groupdel docker

• I remove the Docker socket:

sudo rm -rf /var/run/docker.sock

• I remove Docker Compose:

sudo rm -rf /usr/local/bin/docker-compose && sudo rm -rf /etc/docker && sudo rm -rf ~/.docker

What is Docker Desktop?

Docker Desktop is used to build, share, and run containerized applications and microservices.

Installing Docker Desktop.

Attributions:

https://docs.docker.com/desktop/setup/install/linux/ubuntu/ ↗,

https://dev.to/chandrashekhar/docker-desktop-is-not-working-on-ubuntu-2404-lts--2kpa ↗.

• I download the latest version of Docker Desktop:

https://docs.docker.com/desktop/release-notes/

• From the terminal, I change to the Downloads directory:

cd ~/Downloads

• I install the DEB package:

sudo apt install ./docker-desktop*.deb

NOTE: Ignore the error message after installation.

• I fix the permissions issue:

echo 'kernel.apparmor_restrict_unprivileged_userns = 0' | sudo tee /etc/sysctl.d/20-apparmor-donotrestrict.conf

• I reboot my system:

reboot

• After the reboot, I return to a terminal and launch Docker Desktop:

systemctl --user start docker-desktop

• From the Apps Drawer, I pin the Docker Desktop icon to the Dock.

Uninstall Docker Desktop.

• From the terminal, I remove Docker Desktop from my system:

sudo apt remove docker-desktop

• I remove the configuration and data files:

sudo apt remove docker-desktop && sudo rm /usr/local/bin/com.docker.cli && sudo apt purge docker-desktop

The Results.

Setting up Docker Desktop on Ubuntu 24.04 requires a series of steps that ensures a smooth installation process. By following the outlined procedures, I can effectively manage containerized applications and microservices on my system. Docker Desktop provides a user-friendly interface and powerful tools so I can build, share, and run applications efficiently.

In Conclusion.

I have discovered how Docker Desktop can transform my workflow!

Docker is a game-changer, allowing me to containerize my apps and their dependencies, ensuring the app run seamlessly on any platform.

In guide guide, I walked through the steps of installing Docker and Docker Desktop on Ubuntu 24.04.

From updating my base system to fixing permissions issues, I've covered my simple installation process.

With Docker Desktop, I can easily build, share, and run containerized applications and microservices.

It's all about efficiency and user-friendly interfaces!

Curious about the uninstallation process? I've included that too, ensuring I have complete control over my rig.

By following these steps, I can effectively manage my containerized applications and microservices, making development a smoother and more efficient process.

Have you tried Docker Desktop on Ubuntu yet? What challenges did you face, and how did you overcome them? Let's discuss below!

Until next time: Be safe, be kind, be awesome.

Hash Tags.

#Docker #DockerDesktop #Ubuntu2404 #Containerization #Microservices #Linux #SoftwareDevelopment #DevOps #OpenSource #DockerInstallation #DockerUninstallation #DockerTips

Local code generation using the Bolt.diy agent and Ollama enables efficient development of full-stack applications directly from within a browser. By utilizing local LLMs, I can streamline workflows, enhance productivity, and maintain control over my development environment. This approach simplifies building and deploying applications while providing access to advanced models and technologies, shaping the future of web development.

Attributions:

https://github.com/stackblitz-labs/bolt.diy ↗.

An Introduction.

Bolt.diy and Ollama are two groundbreaking solutions that empower developers to create full-stack applications directly from our browsers. By leveraging local large language models (LLMs), these tools offer a seamless and efficient development experience. Discover how these tools can transform our workflow and keep us at the forefront of technological advancements.

he purpose of this post is to describe how I install Bolt.diy on my local system.

The Big Picture.

I want to highlight how Bolt.diy and is transforming web development by enabling developers to efficiently build full-stack applications, from our browsers, using local large language models. The Big Picture is to show how streamlining our workflows enhances productivity while we also maintain control over our development environments.

Prerequisites.

• A Debian-based Linux distro (I use Ubuntu),

• PNPM,

• Ollama,

• and Git.

The installation instructions are available for these prerequisites.

NOTE: Docker, NodeJS, and NPM are needed

Updating my Base System.

• From the (base) terminal, I update my (base) system:

sudo apt clean && \
sudo apt update && \
sudo apt dist-upgrade -y && \
sudo apt --fix-broken install && \
sudo apt autoclean && \
sudo apt autoremove -y

NOTE: The Ollama LLM manager is already installed on my (base) system.

What is PNPM?

PNPM ↗ (Performant Node Package Manager) is a JavaScript package manager, similar to NPM.

What is Ollama?

Ollama ↗ is a tool for downloading, setting up, and running LLMs (large language models). It lets me access powerful models like Llama and Qwen, and helps me run them on my local Linux, macOS, and Windows systems.

What is Git?

Git is a version control manager that tracks any changes that are made to the files in a directory and subdirectories.

What is Bolt?

Bolt ↗ is a web development agent that allows me to prompt, run, edit, and deploy full-stack applications directly from my browser.

Downloading the Models.

• From the terminal, I use Ollama to pull the DeepSeek Coder V2 16b model:

ollama pull deepseek-coder-v2

• I use Ollama to pull the Quen 2.5 Coder 14b model:

ollama pull qwen2.5-coder:14b

• I use Ollama to pull the Quen 2.5 Coder 7b model:

ollama pull qwen2.5-coder:7b

• I use Ollama to list the models:

ollama list

Installing the Bolt Agent.

• From the terminal, I check to see if /usr/local/bin is in my $PATH:

echo $PATH .

• I change to my home directory:

cd ~

• I clone the Bolt repository:

git clone https://github.com/stackblitz-labs/bolt.diy.git

• I change to the Bolt directory:

cd bolt.diy

Editing the Environment File.

• I rename .env.example to .env.local (using the move command):

mv .env.example .env.local

NOTE: Ollama runs locally and doesn't need an API key.

• I open the .env.local file in the Nano text editor:

sudo nano .env.local

• I set the Ollama API base URL:

OLLAMA_API_BASE_URL=http://localhost:11434

• I set the context length for the model being used:

DEFAULT_NUM_CTX=8192

• I save (CTRL + S) the changes and exit (CTRL + X) the Nano text editor.

Running the Bolt Agent.

• From the terminal, I install PNPM (if required):

sudo npm install -g pnpm

• I install the dependencies:

pnpm install

• I start the Bolt agent:

pnpm run dev

• I open the interface in a browser:

http://localhost:5173/

After the Bolt agent starts, there may be an error message. Simply refresh the page.

The Results.

Local code generation using Bolt.diy and Ollama offers a powerful and efficient way to develop full-stack applications directly from my browser. By leveraging AI-powered tools and local LLMs, I can streamline my workflow, enhance productivity, and maintain control over my development environment. This approach not only simplifies the process of building and deploying applications but also ensures that I have access to cutting-edge models and technologies. As the landscape of web development continues to evolve, tools like Bolt.diy and Ollama will play crucial roles in shaping the future of coding and application development.

In Conclusion.

Am I ready to revolutionize my web development process? Yes!! I want to discover how local code generation with Bolt.diy and Ollama can transform my workflow!

I can easily imagine developing full-stack applications directly from my browser, powered by AI and local LLMs. With Bolt.diy, I can prompt, run, edit, and deploy applications seamlessly, while Ollama ensures I have access to cutting-edge models like DeepSeek Coder V2 and Qwen 2.5 on my local system.

Here's what I need to get started: a Debian-based Linux distro, Git, Ollama, and PNPM. Once set up, I can pull powerful models and integrate them with the Bolt.diy agent for an efficient development experience.

By leveraging these tools, I can streamline my workflow, enhance productivity, and maintain control over my development environment. This approach not only simplifies building and deploying applications but also keeps me at the forefront of web development technology.

As the landscape of web development evolves, tools like Bolt.diy and Ollama are shaping the future of coding and application development.

Are you ready to take your app development process to the next level? How do you see AI-powered tools impacting your workflow? Let me know in the comments below.

Until next time: Be safe, be kind, be awesome.

Hash Tags.

#WebDevelopment #AI #Coding #Productivity #Innovation #TechTrends

Setting up Git and GitHub on a Debian-based Linux system involves several steps: updating my system, installing Git, installing and updating the GitHub CLI tool, configuring my identity, generating SSH keys, and pushing my local repositories to GitHub. This guide helps streamline my setup process so I can quickly manage, and secure, my code and projects.

Attributions:

https://docs.github.com/en/get-started/using-git/about-git ↗.

An Introduction.

In today's fast-paced development environment, efficient version control and collaboration are crucial for success. Git and GitHub, leading tools for creating, hosting, and managing code repositories, offers powerful processes that streamline version control. These tools are perfect for all developers. Setting up Git and GitHub on Debian-based Linux systems (like Ubuntu) will significantly enhance my workflow. This walk through follows the essential steps, from installing Git and GitHub CLI tool, to configuring my identity, and securing my projects with SSH keys. This is how I setup my Git and GitHub environments so they can immediately support the development of my various projects.

The purpose of this post is to cover the installation of Git and GitHub.

The Big Picture.

Version control is a system that records changes to a file, or set of files, over time so that I can recall specific versions, if required. It also allows multiple people to collaborate on a project, track changes, and revert to previous states, if necessary. This is particularly useful in software development, where version control helps manage source code changes, resolve conflicts, and maintain a history of modifications. Popular version control systems include Git, Subversion (SVN), and Mercurial.

Prerequisites.

• A Debian-based Linux distro (I use Ubuntu).

Updating my Base System.

• From the (base) terminal, I update my (base) system:

sudo apt clean && \
sudo apt update && \
sudo apt dist-upgrade -y && \
sudo apt --fix-broken install && \
sudo apt autoclean && \
sudo apt autoremove -y

NOTE: The Ollama LLM manager is already installed on my (base) system.

What is Git?

Git is a version control manager created by Linus Torvalds in 2005 and, since then, this project has been maintained by Junio Hamano. This utility helps me track the changes I make to my code. Git is used by development team members, who collaborate on software projects, to merge their individual changes to a local, or remote, repository (repo) at the end of each day.

https://git-scm.com/book/en/v2/Getting-Started-What-is-Git?↗.

What is GitHub?

GitHub hosts a collection of remote repos where local changes to a project can be saved to this off-site location. These remote repos can either be public or private. Alternatives to GitHub include GitLab and Bitbucket.

https://docs.github.com/en/get-started/using-git/about-git↗.

Installing the Git Utility.

• From the terminal, I install Git:

sudo apt install -y git-all

• I check the installation:

git -v

Installing the GitHub CLI Tool.

• From the terminal, I run the following command:

(type -p wget >/dev/null || (sudo apt update && sudo apt-get install wget -y)) \
&& sudo mkdir -p -m 755 /etc/apt/keyrings \
&& wget -qO- https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo tee /etc/apt/keyrings/githubcli-archive-keyring.gpg > /dev/null \
&& sudo chmod go+r /etc/apt/keyrings/githubcli-archive-keyring.gpg \
&& echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null \
&& sudo apt update \
&& sudo apt install -y gh

Updating the GitHub CLI Tool.

• I update my system:

sudo apt update

• I update the GitHub CLI tool:

sudo apt install -y gh

Adding an Identity.

• From the terminal, I add an email address to Git:

git config --global user.email "me@example.com"

• I add my name:

git config --global user.name "My Name"

Creating a New, Local Repo.

NOTE: Repo is the common, short name for "Repository".

• From the terminal, I navigate to where I want to create a new project directory.

• I create a new project directory:

md project

• I navigate into the project directory:

cd project

• I initialise the directory as a local Git repo:

git init

• I create a README.md file:

echo "# Project Name" >> README.md

Staging Changes for the Local Repo.

• From the terminal, I stage the README.md file for committing to the local repo:

git add README.md

• I can also stage ALL the files that have changed since the last commit:

git add -A

Committing Changes to the Local Repo.

• From the terminal, I navigate to the project folder.

• I commit any changes to the local repo, along with a message:

git commit -m "First commit"

Naming the Local Repo.

• From the terminal, I navigate to the project folder.

• I name the "main" branch of the repo:

git branch -M main

NOTE: Some “old school” engineers still call it the master branch.

Generating SSH Keys.

• From the terminal, I navigate to the project directory.

• I generate an SSH key pair and save them to /home/$USER/.ssh/projectname:

ssh-keygen -b 4096

• After generating the SSH keys, I start the ssh-agent:

eval "$(ssh-agent -s)"

• Once the ssh-agent is running, I add my SSH private key to the ssh-agent:

ssh-add ~/.ssh/projectname

Adding the SSH Public Key to GitHub

• In a text editor, I open the SSH public key file "~/.ssh/projectname.pub".

• I copy the contents of the SSH public key to the clipboard.

• I login to my GitHub.com account.

• In the top-right corner of the GitHub website, I click my icon and choose "Settings" from the drop-down menu.

• In the left menu, I choose "SSH and GPG keys".

• I click the green "New SSH key" button.

• In the "Title" field, I add a descriptive label for the new key.

• I paste the key into the "Key" field.

• I click the green "Add SSH key" button.

• If prompted, I confirm my GitHub password.

• I return to the GitHub home page.

• I create a remote repo that uses the project name.

Pushing the Local Repo to GitHub.

• From the terminal, I navigate to the project directory.

• I set a new origin for GitHub:

git remote add origin git@github.com:accountname/projectname.git

• I push the local repo to GitHub:

git push -u origin main

Cloning an Existing Repo.

• I visit an existing project on the GitHub repo to confirm the account name and the project name.

• From the terminal, I run the following Git command:

git clone https://github.com/accountname/projectname.git

• Alternatively, I can run the GitHub CLI command instead of the Git command:

gh repo clone accountname/projectname

NOTE: This command will download the project from GitHub to the location where the terminal ran the command.

The Results.

Setting up GitHub on a local, Debian-based Linux system (such as Ubuntu) involves several key steps. From installing and updating the GitHub CLI tool to configuring your identity and generating SSH keys, each step ensures a smooth workflow for managing your code repositories. By following this guide, I can efficiently create, commit, and push my local repositories to GitHub, as well as clone existing ones. This setup not only enhances collaboration but also secures my projects with SSH keys.

In Conclusion.

I secure my development workflow with Git and GitHub.

Setting up Git and GitHub on a Debian-based Linux system (like Ubuntu) can seem daunting, but it is easier than people think!

By following the steps in this post, I can efficiently manage my code repositories, enhance collaboration, and secure my projects with SSH keys.

Have you set up Git and GitHub on your Linux system yet? What challenges did you face? Let's discuss!

Until next time: Be safe, be kind, be awesome.

Hash Tags.

#Git #GitHub #GitHubSetup #GitTutorial #VersionControl #Linux #LinuxDevelopment #Ubuntu #UbuntuTips #DevOps #DevOpsTools #Coding #CodingLife #ProgrammingBasics #ProgrammingGuide #TechTips #TechHowTo #SoftwareDevelopment #SoftwareEngineering #OpenSource #OpenSourceProjects

SSH Setup for Ubuntu 24.04 LTS involves installing and configuring OpenSSH Server on the remote server, generating an RSA key pair on the local system, and uploading the local, public key to the remote system for secure, password-less authentication.

Attributions:

https://linuxconfig.org/quick-guide-to-enabling-ssh-on-ubuntu-24-04 ↗.

An Introduction.

Setting up SSH on Ubuntu 24.04 is a crucial task for anyone looking to manage remote servers securely and efficiently. SSH, or Secure Shell, provides a secure channel over an unsecured network, allowing remote command executions, remote server management, and file transfers. These steps will configure SSH on both my local system and remote server, ensuring a seamless and secure connection. This post establishes a robust SSH setup, enabling password-less authentication and enhancing my overall workflow.

The purpose of this post is to describe security between systems and servers.

The Big Picture.

SSH is widely used in app development for securely accessing and managing remote servers, deploying applications, and transferring files. It allows developers to execute commands on remote machines, manage version control systems, and automate deployment processes, ensuring a secure and efficient workflow.

Prerequisites.

• Two Debian-based Linux distros (I use Ubuntu), either virtual or actual.

Updating my Base System.

• From the (base) terminal, I update my (base) system:

sudo apt clean && \
sudo apt update && \
sudo apt dist-upgrade -y && \
sudo apt --fix-broken install && \
sudo apt autoclean && \
sudo apt autoremove -y

NOTE: The Ollama LLM manager is already installed on my (base) system.

What is SSH?

The Secure Shell (SSH) protocol is a way to safely send commands to a computer over an unsecured network. SSH uses special codes to check and protect connections between devices. It also allows for tunnelling, or port forwarding, which lets data packets go through networks they couldn't before. SSH is often used to control servers from a distance, manage infrastructure, and transfer files. It lets administrators manage servers and devices remotely. Older methods like Telnet sent commands that anyone could see. But SSH uses a secure connection, which is why it's called Secure Shell.

https://www.cloudflare.com/learning/access-management/what-is-ssh/↗.

Installing SSH on the Client.

SSH is used to safely send commands to a computer over an unsecured network.

• From the terminal, I install SSH:

sudo apt install -y ssh

• I make a copy of the existing SSH settings:

sudo cp /etc/ssh/sshd_config /etc/ssh/sshd_config.bak

• I open the SSH configuration file in the Nano text editor:

sudo nano /etc/ssh/sshd_config

• I change the following directives:

  • LoginGraceTime 20

  • PermitRootLogin no

  • MaxAuthTries 3

  • ⋮

  • PasswordAuthentication no

• I save the changes (CTRL + S) and exit (CTRL + X) the Nano text editor.

• I create a privilege separation directory:

sudo mkdir /run/sshd

• I test the SSH configuration for syntax errors:

sudo sshd -t

NOTE: If I do not get any output after running this command, then the changes I made are using valid syntax.

• I reload the daemon:

sudo systemctl daemon-reload

• I restart the SSH socket:

sudo systemctl restart ssh.socket

• I check the status of the SSH socket:

sudo systemctl status ssh.socket

NOTE: SSH is running when the Active status is active (listening).

• I exit the status command (CTRL + C).

Creating an RSA Key Pair on the Client.

• From the terminal, I start the ssh-agent:

eval "$(ssh-agent -s)"

• I generate a pair of RSA (Rivest-Shami-Adleman) keys and call the /home/brian/.ssh/key-name (where I replace "key-name" with the name of the remote server):

ssh-keygen -b 4096

NOTE: It is my convention to name the RSA keys after the remote server on which they will be applied.

• I add the SSH private key to my local system:

ssh-add /home/brian/.ssh/key-name

Uploading the Client Public Key to the Server.

• From the local terminal (CTRL + ALT + T), I use the ssh-copy-id command to upload the locally-generated public key to the remote server:

ssh-copy-id -i /home/brian/.ssh/key-name.pub account-name@192.168.?.?

NOTE: I replace the "?" with the actual IP address of the remote server.

Using RSA to Connect to the Server.

• From the local terminal (CTRL + ALT + T), I connect to the remote server:

ssh 'user-account@192.168.?.?'

Preparing the Server.

• From the remote terminal (CTRL + ALT + T), I update the remote server:

sudo apt clean && \
sudo apt update && \
sudo apt dist-upgrade -y && \
sudo apt --fix-broken install && \
sudo apt autoclean && \
sudo apt autoremove -y

• I install OpenSSH Server:

sudo apt install -y ssh

• I set the SSH Server to start on boot:

sudo systemctl enable ssh

• I check the status of the SSH Server:

sudo systemctl status ssh

• I start the SSH Server if it is not running:

sudo systemctl start ssh

• I add an entry to the UFW (Uncomplicated Firewall):

sudo ufw allow ssh

• I set the UFW to start on boot:

sudo ufw enable

Basic Server Security.

Security is an attitude, not a process.

Checking the Unattended Upgrades Settings.

• From the terminal, I install unattended upgrades:

sudo apt install -y unattended-upgrades

• I check if the upgrades are properly configured:

cat /etc/apt/apt.conf.d/20auto-upgrades

NOTE: The system will automatically update the package lists and perform unattended upgrades each day as long as Update-Package-Lists and Unattended-Upgrade are both set to ‘1’.

Configuring UFW.

• From the terminal, I check the UFW status:

sudo ufw status verbose

• I allow SSH:

sudo ufw allow ssh

• I allow port 80:

sudo ufw allow 80/tcp

• I allow port 443:

sudo ufw allow 443/tcp

• I enable UFW:

sudo ufw enable

NOTE: When setting up a remote server, I ensure SSH is setup on both the client and the server before enabling UFW.

• I check the UFW status:

sudo ufw status verbose

NOTE: There are other UFW commands that may be useful.

Installing Fail2Ban.

• From the terminal, I install Fail2Ban:

sudo apt install -y fail2ban

• I copy the jail.conf file as jail.local:

sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local

• I open the jail.local file in the Nano text editor:

sudo nano /etc/fail2ban/jail.local

• I change a few (SSH-centric) settings in the jail.local file:

[DEFAULT]
⋮
bantime = 1d
maxretry = 3
⋮
[sshd]
enabled = true
port = ssh,22

• I save (CTRL + S) the changes, and exit (CTRL + X) the Nano text editor.

• I restart Fail2Ban:

sudo systemctl restart fail2ban

• I check the status of Fail2Ban:

sudo systemctl status fail2ban

• I enable Fail2Ban to autostart on boot:

sudo systemctl enable fail2ban

Checking the AppArmor Status.

AppArmor, a Linux kernel security module, restricts per-program application capabilities like network access, raw socket access, and the permissions to read, write, or execute files.

• From the terminal, I check the AppArmor status:

sudo aa-status --verbose

Installing the Lynis Auditing Tool.

Lynis is a flexible security auditing tool for systems running Linux, FreeBSD, macOS, OpenBSD, Solaris, and other Unix-like operating systems, helping administrators and security professionals scan and strengthen system security.

• From the terminal, I install Lynis:

sudo apt install -y lynis

• I check the installation:

lynis -V

• I run a basic scan:

sudo lynis audit system --quick

NOTE: The log file, which is purged every scan, is /var/log/lynis.log and the report file is /var/log/lynis-report.dat.

• I check if Lynis is up-to-date:

lynis update check

Attribution:

https://cisofy.com/lynis/ ↗.

The Results.

Setting up SSH on Ubuntu 24.04 LTS is an essential process for ensuring secure and efficient remote server management. By following the steps outlined, I can establish a robust SSH configuration that enhances my workflow with password-less authentication. This setup not only secures my connections but also streamlines my ability to manage and deploy applications remotely. I keep my systems updated and maintain security best practices to protect my infrastructure.

In Conclusion.

Discover how I set up SSH on Ubuntu 24.04 LTS for secure, password-less authentication!

Setting up SSH is crucial for anyone managing remote servers. It provides a secure channel over unsecured networks, allowing for remote command executions, server management, and file transfers.

Here's a quick overview of the process:

1. Update My System: Ensure my base system is up-to-date for optimal performance.

2. Generate RSA Key Pair: Create a secure key pair on my local system to facilitate password-less authentication.

3. Upload Public Key: Use ssh-copy-id to transfer my public key to the remote system.

4. Install OpenSSH Server: On the remote system, install and configure OpenSSH Server for secure connections.

5. Configure Firewall: Set up UFW to allow SSH connections and ensure it starts on boot.

By following these steps, I can establish a robust SSH setup that enhances my workflow and secures my connections. I keep my systems updated and adhere to security best practices.

How do you ensure secure remote server management in your workflow? Share your tips below!

Until next time: Be safe, be kind, be awesome.

Hash Tags.

#Ubuntu-2404 #SSH #SSH-Keygen #ServerManagement #RemoteServer #RemoteWork #CyberSecurity #SecureConnection #PasswordlessAuthentication #LinuxSetup #TechTips #TechGuide

This post provides a comprehensive guide to securing and hardening an Ubuntu 24.04 LTS system. It covers essential steps such as updating the system, configuring unattended upgrades, setting up a firewall with UFW, installing Fail2Ban to prevent brute-force attacks, checking AppArmor status for application permissions, and using the Lynis auditing tool for vulnerability assessments. Regular updates and reviews of these configurations are emphasized to maintain system security and resilience against potential threats.

Attributions:

None ↗.

An Introduction.

In an era where cyber threats are increasingly sophisticated, securing an Ubuntu system is more important than ever. This guide walks through the essential steps to harden my system, from updating and automating upgrades to configuring firewalls and using security tools like Fail2Ban, AppArmor, and Lynis. By following these practices, I can enhance your system's resilience against potential threats and ensure my data remains protected.

The purpose of this post is to promote simple, cybersecurity practices.

The Big Picture.

Cybersecurity is the practice of protecting systems, networks, and programs from digital attacks. These cyberattacks are usually aimed at accessing, changing, or destroying sensitive information, extorting money from users, or interrupting normal business processes. As technology evolves, so do the tactics of cybercriminals, making it crucial for individuals and organizations to implement robust security measures. This involves a combination of technology, processes, and practices designed to safeguard networks, devices, programs, and data from attack, damage, or unauthorized access. A comprehensive cybersecurity strategy includes regular updates, threat assessments, and user education to ensure resilience against potential threats.

Prerequisites.

• A Debian-based Linux distro (I use Ubuntu).

Updating my Base System.

• From the (base) terminal, I update my (base) system:

sudo apt clean && \
sudo apt update && \
sudo apt dist-upgrade -y && \
sudo apt --fix-broken install && \
sudo apt autoclean && \
sudo apt autoremove -y

NOTE: The Ollama LLM manager is already installed on my (base) system.

Checking the Unattended Upgrades Settings.

• From the terminal, I install unattended upgrades:

sudo apt install -y unattended-upgrades

• I check if the upgrades are properly configured:

cat /etc/apt/apt.conf.d/20auto-upgrades

NOTE: The system will automatically update the package lists and perform unattended upgrades each day as long as Update-Package-Lists and Unattended-Upgrade are both set to ‘1’.

Configuring UFW.

• From the terminal, I check the UFW status:

sudo ufw status verbose

• I allow SSH:

sudo ufw allow ssh

• I allow port 80:

sudo ufw allow 80/tcp

• I allow port 443:

sudo ufw allow 443/tcp

• I enable UFW:

sudo ufw enable

NOTE: When setting up a remote server, ensure SSH is setup on both the client and the server before enabling UFW.

• I check the UFW status:

sudo ufw status verbose

NOTE: There are other UFW commands that may be useful.

Installing Fail2Ban.

• From the terminal, I install Fail2Ban:

sudo apt install -y fail2ban

• I copy the jail.conf file as jail.local:

sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local

• I open the jail.local file in the Nano text editor:

sudo nano /etc/fail2ban/jail.local

• I change a few (SSH-centric) settings in the jail.local file:

[DEFAULT]
⋮
bantime = 1d
maxretry = 3
⋮
[sshd]
enabled = true
port = ssh,22

• I save (CTRL + S) the configuration changes, and exit (CTRL + X) the Nano text editor.

• I restart Fail2Ban:

sudo systemctl restart fail2ban

• I check the status of Fail2Ban:

sudo systemctl status fail2ban

• I enable Fail2Ban to autostart on boot:

sudo systemctl enable fail2ban

Checking the AppArmor Status.

AppArmor, a Linux kernel security module, restricts per-program application capabilities like network access, raw socket access, and the permissions to read, write, or execute files.

• From the terminal, I check the AppArmor status:

sudo aa-status --verbose

Installing the Lynis Auditing Tool.

Lynis is a flexible security auditing tool for systems running Linux, FreeBSD, macOS, OpenBSD, Solaris, and other Unix-like operating systems, helping administrators and security professionals scan and strengthen system security.

• From the terminal, I install Lynis:

sudo apt install -y lynis

• I check the installation:

lynis -V

• I run a basic scan:

sudo lynis audit system --quick

NOTE: The log file, which is purged every scan, is /var/log/lynis.log and the report file is /var/log/lynis-report.dat.

• I check if Lynis is up-to-date:

lynis update check

Attribution:

https://cisofy.com/lynis/ ↗.

The Results.

Securing and hardening my Ubuntu 24.04 LTS system is a crucial step in protecting my data and maintaining system integrity. By following the outlined steps, such as updating my system, configuring unattended upgrades, setting up UFW, installing Fail2Ban, checking AppArmor status, and utilizing the Lynis auditing tool, I can significantly enhance my system's security posture. Regularly reviewing and updating these configurations will help ensure that my system remains resilient against potential threats.

In Conclusion.

Is my Ubuntu 24.04 LTS system as secure as it could be?

In today's digital landscape, securing my system is more crucial than ever.

Here's a quick guide to hardening my Ubuntu system:

1. Update My System: Regular updates are my first line of defence.

2. Unattended Upgrades: Automate my updates to ensure I’m always protected.

3. Configure UFW: Set up my firewall to control incoming and outgoing traffic.

4. Install Fail2Ban: Protect against brute-force attacks by banning suspicious IPs.

5. Check AppArmor Status: Ensure my applications have the right permissions.

6. Use Lynis Auditing Tool: Regularly audit my system for vulnerabilities.

By following these steps, I can significantly enhance my system's security posture.

Remember, regular reviews and updates are key to staying resilient against potential threats.

🔍 How do you ensure your systems are secure? Share your tips below!

Until next time: Be safe, be kind, be awesome.

Hash Tags.

#UbuntuSecurity #LinuxHardening #SystemSecurity #CyberSecurity #Fail2Ban #UFW #AppArmor #Lynis #StaySecure #Ubuntu2404LTS #TechTips

TL;DR.

This post provides a step-by-step guide to installing DaVinci Resolve 19 Studio on Ubuntu 24.04 LTS. It covers downloading the software, preparing the download, ensuring compatibility with necessary libraries, and updating my drivers. By following these instructions, I can effectively set up DaVinci Resolve Studio for professional video editing on my Linux system.

NOTE: This guide has only been tested with the Studio version of Resolve. Let me know, in the comments below, if this process also works with the FREE version of DaVinci Resolve. Thank-you.

Attributions:

hackmd.io ↗,

how2shout.com ↗.

An Introduction.

Resolve is a great tool for performing many video post production activities.

The purpose of this post is to describe how to install Resolve Studio on Ubuntu.

The Big Picture.

DaVinci Resolve Studio is traditionally thought of as an industry-standard colour correction and colour grading system. But since 2009, Resolve Studio has slowly evolved into a complete, powerful, video production tool with features like:

• Video editing,

• Special effects,

• Motion graphics, and

• Audio post-production.

For professional film productions, the Studio version of Resolve actively supports the workflows of many on-set DITs (Digital Imaging Technicians) as well as activities like editing, colour correction, colour grading, visual effects, green screen work, matte paintings, sound effects, audio post-processing and balancing, and audio mixing.

Prerequisites.

• A Debian-based Linux distro (I use Ubuntu).

Updating my Base System.

• From the (base) terminal, I update my (base) system:

sudo apt clean && \
sudo apt update && \
sudo apt dist-upgrade -y && \
sudo apt --fix-broken install && \
sudo apt autoclean && \
sudo apt autoremove -y

NOTE: The Ollama LLM manager is already installed on my (base) system.

What is DaVinci Resolve Studio?

DaVinci Resolve Studio is a paid video editing, colour grading and correction, visual effects, motion graphics, and audio post-production application for macOS, Windows, and Linux. It was originally developed by da Vinci Systems as da Vinci Resolve. Then in 2009, when da Vinci Systems was acquired by Blackmagic Design, the application was rebranded as DaVinci Resolve.

https://www.blackmagicdesign.com/↗.

Installing the Required Packages.

In a terminal, I install the required packages:

sudo apt install -y libqt5x11extras5

Downloading DaVinci Resolve Studio.

• I download the latest copy of DaVinci Resolve 19 Studio:

https://www.blackmagicdesign.com/au/support/family/davinci-resolve-and-fusion

Unzipping the Downloaded File.

• In a terminal, I go to the Downloads directory:

cd ~/Downloads

• I check if the downloaded ZIP file exists:

ls

• I install UNZIP (if required):

sudo apt install unzip

• I extract the contents of the ZIP file:

sudo unzip ./DaVinci_Resolve_*_Linux.zip

Changing the Mode of the RUN File.

• I change the mode of the extracted RUN file to an executable:

sudo chmod +x ./DaVinci_Resolve_Studio_*_Linux.run

Installing the Software.

• I install the software:

sudo SKIP_PACKAGE_CHECK=1 ./DaVinci_Resolve_*_Linux.run -i

NOTE: This command does not check for missing libraries during the installation.

• I change to the libs directory:

cd /opt/resolve/libs

• I make a new directory called disabled_libs:

sudo mkdir ./disabled_libs

• I move the libglib, libgio, and libgmodule into the disabled_libs directory:

sudo mv libglib-2.0.so* libgio-2.0.so* libgmodule-2.0.so* disabled_libs/

NOTE: Moving these libraries forces Resolve to use the Ubuntu 24.04 LTS libraries.

• I update my NVIDIA drivers, if required:

sudo apt install -y nvidia-driver-550

NOTE: Resolve Studio requires the 550 drivers (or later) for NVIDIA GTX GPUs.

• I run the application:

/opt/resolve/bin/resolve

The Results.

Installing DaVinci Resolve 19 Studio on Ubuntu 24.04 LTS involves several steps, including downloading the Resolve software and ensuring compatibility with the system drivers and libraries. By following this outlined process, I can successfully set up a powerful video editing tool on my Linux system. With Resolve Studio, I can enhance my video editing capabilities and create professional-level video content.

In Conclusion.

I discovered how to install DaVinci Resolve 19 Studio on Ubuntu 24.04!

DaVinci Resolve is a powerhouse application from Blackmagic Design. It is used for video editing, colour grading, visual effects, and more.

Here's my quick guide to getting started:

1. I use a Debian-based Linux distro (like Ubuntu).

2. I update my base system via the terminal.

3. I download the latest version of DaVinci Resolve 19 Studio from the Blackmagic Design website.

4. I unzip the downloaded file.

5. I make the unzipped RUN file executable.

6. I install the software while repressing error messages.

7. I move specific libraries to another directory.

8. I update my NVIDIA drivers to 550 or later.

9. I run the application and start creating professional-level video content!

By following these steps, I can harness the full potential of DaVinci Resolve Studio on my Linux system.

Are you ready to transform your video editing experience? What projects are you excited to work on with DaVinci Resolve Studio? Let me know in the comments!

Until next time: Be safe, be kind, be awesome.

Hash Tags.

#BlackmagicDesign #DaVinciResolve19 #DaVinciResolve19Studio #VideoEditing #ColourGrading #VideoProduction #VideoPost #VideoPostProduction #VideoContentCreation #FilmEditing #CreativeEditing #ProfessionalVideoEditing #MotionGraphics #AudioPostProduction #LinuxVideoEditing

TL;DR.

This post explores the significance of domain names in app and website development. It highlights the role of domain names in defining business units, generating income, and showcasing development projects. This article also provides a list of current and pending domain names, each representing unique projects across media, technology, business, and AI-driven applications. There is a palpable excitement about these projects and I invite my readers to share their thoughts on the most exciting domain-named project.

An Introduction.

The following is a list of current, and pending, domain names:

The purpose of this post is to list the projects the are under current development.

The Big Picture.

A domain name is my first step in creating an app or website. There are a number of reasons for these apps, including:

• Defining various, internal business units,

• Building income generating business units,

• Producing business units that can be sold to other companies, and

• Showcasing the range of apps and websites that I am able to produce.

Prerequisites.

• There are no prerequisites for enjoying this post.

What is a Domain Name?

The Internet uses an octet (8-bit) numbering system to identify the locations of the numerous, online resources. These locations are called IPs, or Internet Protocol v4 addresses. (IP v6 addresses are also available, but they are rarely used.) Trying to remember 4 sets of numbers is tiresome so, in the early 1970s, domain names were introduced. When I type a domain name into the address bar of a browser, that name resolves to a specific IP address thanks to the Domain Name System, or DNS. DNS is the phone book of the Internet and uses a distributed service that resolves domain names to IP addresses. (New domains can take up to 48-hours to resolve.) Now that the browser knows the IP address, it can start interacting with the services at that given location. The computer at that specific IP address may be hosting any number of services, including (but not limited to):

• Web servers,

• Email servers,

• Gaming servers, and

• FTP (File Transfer Protocol) servers.

Every device gets an IP address when it connects to the Internet. These dynamic IP addresses are pooled by each Internet Service Provider, or ISP. When a device disconnects from the Internet, the IP address is released and returned to the ISP pool. Companies (and people) that use domain names typically rent space on someone else's servers. They go to their domain name provider, point the domain name(s) to the DNS (Domain Name System) run by the host, activates some settings on the hosting service, and the domain name eventually points to the provided service (web hosting, email server, etc.) Less frequently, people like me rent static IPs from our ISPs, pass our domain name(s) through Cloudflare, use Cloudflare to resolve our domain names to our static IP addresses, and host our own services (web servers, email servers, etc.) on our own on-prem servers. (In my case, I use an Intel NUC v10.)

Domain Name Table.

Here is a list of the domains that are, or will be, available to my company. Some of these domains are [pending] and will be added to this list as they are secured.

The Results.

The domain names listed here represent a diverse range of projects and business units that highlight my capabilities in app and website development. Each domain serves a unique purpose, from media and technology sites to business and AI-driven applications. As these projects continue to develop and new domains are secured, they will further demonstrate the breadth and depth of what can be achieved in the ever-evolving digital landscape. Stay tuned for updates and new additions to this dynamic portfolio.

In Conclusion.

Thanks for exploring the future of my domain-named projects for 2024 and 2025.

In this post, I dove deep into the world of domain names and their pivotal role in app and website development. From defining internal business units to building income-generating projects, domain names are the first crucial step in creating my digital presence. But what exactly are domain names, and why are they important?

A domain name is more than just an address; it's a gateway to various online services like web servers, email servers, and more. Thanks to the Domain Name System (DNS), these names resolve to specific IP addresses, making it easier for users to navigate the web.

Here's a sneak peek at some of the exciting domains that are under development:

• Monty.co.nz - A smart phone camera app,

• SoloDev.app - A tech blog for developers,

• AuditorLog.com - An onboarding app for apprentices,

• TechLearnAI.com - A learning management system powered by AI,

• TechNewsAI.com - An AI-driven technology news publishing app, and

• CompanyLite.com - A business management app.

And I have other exciting endeavours on the horizon!!

Each domain represents a unique project that showcases a diverse range of capabilities, from media and technology, to business and AI-driven applications.

Curious to know more about these projects and how they might transform the digital landscape? I know I'm excited to start building these entities!!

What do you think is the most exciting domain-named project for 2024 and 2025? Let me know in the comments!

Until next time: Be safe, be kind, be awesome.

Hash Tags.

#SmartPhoneApps #OnboardingApp #DomainNames #TechInnovation #AI #WebDevelopment #BusinessGrowth #DigitalTransformation #DigitalPresence #FutureTech #AppDevelopment #WebsiteDevelopment #LearningManagementSystem #EmailMarketing #BusinessManager #AIApplications #TechProjects #TechBlog #MediaTech

TL;DR.

This post guides me through the process of installing WhisperAI from OpenAI for FREE. It covers prerequisites like a Debian-based Linux distro and Miniconda, steps to update my system, and installing essential technologies such as FFmpeg, CUDA Toolkit, PyTorch, and Whisper. It also covers how to set up a Miniconda environment, creating directories, and running Whisper for speech recognition and translation. A future post will further explore how to use Python and Whisper together.

Attributions:

https://docs.anaconda.com/free/miniconda/index.html↗,

https://openai.com/index/whisper/↗,

https://github.com/openai/whisper↗, and

https://www.youtube.com/watch?v=ABFqbY_rmEk↗.

An Introduction.

One of the earliest, and most important, AI projects for DigitalCore to complete is the VocalCue.com app. Whisper may become a lynch-pin technology for the success of the VocalCue project.

The purpose of this post is to install Whisper, and explore its' basic functionality.

Please note that VocalCue.com is a working title and may be replaced on launch.

The Big Picture.

Whisper is an open-source project from OpenAI and is available to the public under the MIT license. If I decide to use Whisper as part of my VocalCue teleprompter project, then I will also open-source my code under the same license. This post is all about installing the Whisper tool, as well as three other supporting technologies.

Prerequisites.

• A Debian-based Linux distro (I use Ubuntu),

• Miniconda.

Updating my Base System.

• From the (base) terminal, I update my (base) system:

sudo apt clean && \
sudo apt update && \
sudo apt dist-upgrade -y && \
sudo apt --fix-broken install && \
sudo apt autoclean && \
sudo apt autoremove -y

NOTE: The Ollama LLM manager is already installed on my (base) system.

What is FFmpeg?

FFmpeg is a top multimedia tool that can decode, encode, transcode, mux, demux, stream, filter, and play almost any format created by humans or machines. It supports both old and new formats, whether made by a standards group, the community, or a company. FFmpeg is also very portable: it can be compiled, run, and tested on Linux, Mac OS X, Windows, BSDs, Solaris, and more, across different build environments, machine types, and setups.

https://ffmpeg.org/ ↗.

1 of 4: Installing FFmpeg.

• I check to see which version of FFmpeg is installed:

ffmpeg -v

NOTE: FFmpeg will need installing if it is not already on my system.

• I install FFmpeg, if required, into my (base) environment:

sudo apt update && sudo apt install ffmpeg

What is CUDA?

CUDA is a parallel computing platform and programming model created by NVIDIA. It has been downloaded over 20 million times and helps developers speed up their applications using GPU accelerators. CUDA is used in many fields, not just high-performance computing and research. For example, pharmaceutical companies use CUDA to find new treatments, cars use it to improve self-driving, and stores use it to analyse customer data for recommendations and ads.

Some people think CUDA, launched in 2006, is just a programming language or an API. But with over 150 CUDA-based libraries, SDKs, and tools, it's much more than that. NVIDIA keeps innovating, and thousands of GPU-accelerated applications use the NVIDIA CUDA platform. CUDAs flexibility and programmability make it the top choice for developing new deep learning and parallel computing algorithms.

CUDA also helps developers easily use the latest GPU features, like those in the NVIDIA Ampere GPU architecture.

https://blogs.nvidia.com/blog/what-is-cuda-2/ ↗.

2 of 4: Installing the CUDA Toolkit.

NOTE: This section only applies to PCs that use NVIDIA GPUs. Other graphics processors, i.e. AMD GPUs, will need a different process. I replaced my SAPPHIRE Radeon Nitro+ RX-580 for an NVIDIA RTX-3060 with 12GB of VRAM.)

• The following command is available from the NVIDIA website:

https://developer.nvidia.com/cuda-downloads↗.

NOTE: I use the map at the above website to define the following command.

• I install the NVIDIA CUDA Toolkit into my (base) environment:

sudo apt install -y nvidia-cuda-toolkit

• I check my installed CUDA version:

nvcc --version

What is Anaconda and Miniconda?

Python projects can run in virtual environments. These isolated spaces are used to manage project dependencies. Different versions of the same package can run in different environments while avoiding version conflicts.

venv is a built-in Python 3.3+ module that runs virtual environments. Anaconda is a Python and R distribution for scientific computing that includes the conda package manager. Miniconda is a small, free, bootstrap version of Anaconda that also includes the conda package manager, Python, and other packages that are required or useful (like pip and zlib).

http://www.anaconda.com/↗,

https://docs.anaconda.com/free/miniconda/index.html↗, and

https://solodev.app/installing-miniconda.

I ensure Miniconda is installed (conda -V) before continuing with this post.

Creating a Miniconda Environment.

• I use the conda command to display a list of Miniconda environments:

conda env list

• I use conda to create, and activate, a new environment named (-n) (Whisper):

conda create -n Whisper python=3.10 -y && conda activate Whisper

NOTE: This command creates the (Whisper) environment, then activates the (Whisper) environment.

Creating the Whisper Home Directory.

NOTE: I will now define the home directory in the environment directory.

• I create the Whisper home directory:

mkdir ~/Whisper

• I make new directories within the (Whisper) environment:

mkdir -p ~/miniconda3/envs/Whisper/etc/conda/activate.d

• I use the Nano text editor to create the set_working_directory.sh shell script:

sudo nano ~/miniconda3/envs/Whisper/etc/conda/activate.d/set_working_directory.sh

• I copy the following, paste (CTRL + SHIFT + V) it to the set_working_directory.sh script, save (CTRL + S) the changes, and exit (CTRL + X) Nano:

cd ~/Whisper

• I activate the (base) environment:

conda activate

• I activate the (Whisper) environment:

conda activate Whisper

NOTE: I should now, by default, be in the ~/Whisper home directory.

What is PyTorch?

PyTorch is an open-source deep learning framework known for its flexibility and ease of use. It works well with Python, a popular language among machine learning developers and data scientists. PyTorch is a complete framework for building deep learning models, which are often used in tasks like image recognition and language processing. Since it is written in Python, most machine learning developers find it easy to learn and use. PyTorch was created by developers at Facebook AI Research and other labs. It combines fast and flexible GPU-accelerated back-end libraries from Torch.ch with an easy-to-use Python frontend. This makes it great for quick prototyping, readable code, and supporting many types of deep learning models. PyTorch allows AI engineers to use a familiar programming style while still creating graphs. It was open-sourced in 2017, and its' Python base has made it popular with machine learning developers.

https://pytorch.org/↗.

3 of 4: Installing PyTorch.

• The following command is available from the PyTorch website:

https://pytorch.org/get-started/locally/↗.

NOTE: I use the map at the above website to define the following command.

• I install PyTorch in the (Whisper) environment:

pip3 install torch torchvision torchaudio \
--index-url https://download.pytorch.org/whl/cu118

What is WhisperAI?

From the GitHub page↗:

Whisper is a speech recognition model. It is trained on a large set of audio types and can perform multiple tasks like recognizing different languages, transcribing spoken text, and translating multiple languages to English.

4 of 4: Installing Whisper AI.

• I use the pip command to install Whisper into the (Whisper) environment:

pip install -U openai-whisper

NOTE: The -U flag means upgrade, if Whisper is already installed.

Running WhisperAI.

• I place an audio file, called test.wav, into the Whisper directory.

• I run the following command:

whisper test1.wav

NOTE: I didn't set the --language flag. Whisper decided I was speaking Maori. Actually, the recording is of a Maori speaking. The model may have detected my accent. Or not. Who knows?

• Next, I test Whisper to see if FFmpeg can provide it with the original MP4 file:

whisper test2.mp4

NOTE: The MP4 test worked. Nice.

• Each time Whisper runs, it generates a number of files:

NOTE: Whisper can transcribe multiple files, where each file name is separated by a space.

Whisper has 5 Model Sizes.

NOTE: By default, Whisper uses the small model but there are other models, too.

• This time, I test Whisper on a bit of Shakespeare using a different model:

whisper richard3.mp4 --model medium

NOTE: Whisper got most of it, but my recording wasn't great. (I didn't warm up.)

Transcribing and Translating Other Languages.

• I can use the --language flag for recordings in other languages, instead of forcing Whisper to use auto-detect feature within the first 30-seconds:

whisper french.wav --language French

• I can also translate the audio thanks to the --task flag:

whisper french.wav --language French --task translate

NOTE: Translate only works from other languages to English. The other languages include (as per the --help flag) Afrikaans, Albanian, Amharic, Arabic, Armenian, Assamese, Azerbaijani, Bashkir, Basque, Belarusian, Bengali, Bosnian, Breton, Bulgarian, Burmese, Cantonese, Castilian, Catalan, Chinese, Croatian, Czech, Danish, Dutch, English, Estonian, Faroese, Finnish, Flemish, French, Galician, Georgian, German, Greek, Gujarati, Haitian, Haitian Creole, Hausa, Hawaiian, Hebrew, Hindi, Hungarian, Icelandic, Indonesian, Italian, Japanese, Javanese, Kannada, Kazakh, Khmer, Korean, Lao, Latin, Latvian, Letzeburgesch, Lingala, Lithuanian, Luxembourgish, Macedonian, Malagasy, Malay, Malayalam, Maltese, Mandarin, Maori, Marathi, Moldavian, Moldovan, Mongolian, Myanmar, Nepali, Norwegian, Nynorsk, Occitan, Panjabi, Pashto, Persian, Polish, Portuguese, Punjabi, Pushto, Romanian, Russian, Sanskrit, Serbian, Shona, Sindhi, Sinhala, Sinhalese, Slovak, Slovenian, Somali, Spanish, Sundanese, Swahili, Swedish, Tagalog, Tajik, Tamil, Tatar, Telugu, Thai, Tibetan, Turkish, Turkmen, Ukrainian, Urdu, Uzbek, Valencian, Vietnamese, Welsh, Yiddish, and Yoruba.

Whispers' performance varies widely depending on the language. Translations are not perfect, but they are good enough to be understood.

From the GitHub repo: The image below shows that a lower number means better performance. It is a breakdown of large-v3 and large-v2 models by language, using WERs (word error rates) or CER (character error rates, shown in Italic) evaluated on the Common Voice 15 and Fleurs datasets.

The Next Step.

In a follow-up post, I will look at using Python to manipulate Whisper. Python is an easy-to-learn programming language that is popular with AI scientists and engineers.

The Results.

Installing WhisperAI from OpenAI is a straightforward process if I follow these steps and prerequisites. By ensuring I have the right environment, tools like FFmpeg, CUDA Toolkit, PyTorch, and Whisper itself, I can effectively set up and utilize this powerful speech recognition model. Whispers' ability to transcribe text and translate audio to English, from multiple languages, makes it a versatile tool for numerous applications. In a future post, I will explore more advanced usage and customization by using Python, opening up even more possibilities for integrating Whisper into my projects.

In Conclusion.

I have unlocked the power of FREE speech recognition with Whisper.

I can install, and use, Whisper from OpenAI for FREE. Yes, you heard that right! Whisper, an open-source speech recognition model, is now available for everyone under the MIT license. I dived into how to set it up and start using it today.

Prerequisites:

1. A Debian-based Linux distro (I use Ubuntu)

2. Miniconda

Steps to Get Started:

1. I updated my (base) environment:

   • I make sure my system is up to date and stable.

2. I installed essential technologies:

   • FFmpeg: I checked for FFmpeg, and installed if it was not available.

   • CUDA Toolkit: The CUDA toolkit is used to access NVIDIA GPUs.

   • PyTorch: I installed PyTorch using the command from its' website.

   • WhisperAI: I used pip to install Whisper into a virtual environment.

3. Set Up Miniconda Environment:

   • I created and activated a new environment for Whisper.

4. Created the Whisper Home Directory:

   • I set up directories and scripts to streamline my workflow.

Running WhisperAI:

• I placed audio files into the Whisper directory and ran the Whisper command.

• Whisper can transcribe, and translate multiple languages to English, making it a versatile tool for numerous applications.

Whisper Models:

• Whisper comes with 5 different model sizes. I chose the ones that fit my needs.

Next Steps:

• In a future post, I will explore how to manipulate Whisper using Python, unlocking more flexibility for creating my own projects.

Results:

• Setting up Whisper is straightforward if I follow these steps and prerequisites. With tools like FFmpeg, CUDA Toolkit, PyTorch, and Whisper, I can effectively utilize this powerful speech recognition model.

Are you excited to try Whisper in your own projects? What other AI tools are you interested in exploring? Let's discuss in the comments below!

Until next time: Be safe, be kind, be awesome.

#WhisperAI #OpenAI #SpeechRecognition #Transcription #LanguageTranslation #AI #Python #PyTorch #NVIDIA #CUDA #FFmpeg #AItools #AIresearch #MachineLearning #DeepLearning #Miniconda #TechInnovation #FreeTools #OpenSource #TechTutorial #Ubuntu #Linux #Programming

1/ 🚀 Unlock the power of FREE speech recognition with WhisperAI from OpenAI! Dive into this step-by-step guide to install and explore Whisper for your projects. Ready to get started?

2/ First, ensure you have a Debian-based Linux distro (I use Ubuntu) and Miniconda installed. These are essential prerequisites for setting up WhisperAI.

3/ Update your base system to ensure it’s stable and up-to-date. This is a crucial step before installing any new software or dependencies.

4/ Whisper requires four key technologies: FFmpeg, CUDA Toolkit, PyTorch, and Whisper itself. I’ll walk you through installing each one.

5/ Check if FFmpeg is installed. If not, install it in your base environment. FFmpeg is crucial for handling audio files.

6/ If you have an NVIDIA GPU, install the CUDA Toolkit. This toolkit allows Whisper to leverage the power of your GPU for faster processing.

7/ Next, install PyTorch. This powerful deep learning framework is essential for running Whisper. Follow the command from the PyTorch website.

8/ With PyTorch installed, use pip to install Whisper into a new virtual environment created with Miniconda. This keeps dependencies isolated.

9/ Create and activate a new Miniconda environment specifically for Whisper. This keeps your Whisper setup organized and separate from other projects.

10/ Set up the Whisper home directory within your new environment. Create necessary directories and a script to streamline your workflow.

11/ Place your audio files into the Whisper directory and run the Whisper command. Whisper can transcribe and translate audio, making it incredibly versatile.

12/ Whisper offers five different model sizes. Choose the one that fits your needs for accuracy and performance. Experiment to find the best fit.

13/ In a future post, I’ll explore how to manipulate Whisper using Python, unlocking even more potential for your projects. Stay tuned!

14/ Setting up Whisper is straightforward if you follow these steps. With the right tools and environment, you can harness this powerful speech recognition model.

15/ Want to dive deeper? Read my full article on @SoloDev.app for a detailed guide on installing and using WhisperAI.

Until next time: Be safe, be kind, be awesome! 🚀

Using Flowise, with local LLMs like Ollama, allows for the creation of cost-effective, secure, and highly customizable AI-powered applications. Flowise provides a versatile environment that supports the integration of various tools and components, enhancing AI workflows and enabling the development of local chatbots and AI agents. This setup offers benefits in terms of data privacy and operational security, making it ideal for both business and personal AI projects.

Attributions:

A YouTube video produced by Leon van Zyl↗:

https://www.youtube.com/watch?v=85gZ7G-ze3c↗.

An Introduction.

Low-code GUI solutions like Flowise allows developers to focus on the big picture while maintaining an eye on the details:

The purpose of this post is to demonstrate how to build Chatflows.

The Big Picture.

This post is a continuation of the Langflow and Flowise installation post.

Flowise is an excellent low-code GUI for creating AI workflows and agents. It simplifies the use of LangChain and LlamaIndex solutions. LangChain is a Python library that makes it easier to develop, produce, and deploy applications using large language models (LLMs). It offers open-source components, integrations, and tools for different purposes, like question answering, chatbots, and more.

Prerequisites.

• A Debian-based Linux distro (I use Ubuntu),

• Miniconda,

• Ollama,

• An LLM↗,

• NPM, and

• Flowise UI.

Updating my Base System.

• From the (base) terminal, I update my (base) system:

sudo apt clean && \
sudo apt update && \
sudo apt dist-upgrade -y && \
sudo apt --fix-broken install && \
sudo apt autoclean && \
sudo apt autoremove -y

NOTE: The Ollama LLM manager is already installed on my (base) system.

What is Flowise?

Flowise is an open-source, low-code platform that helps me easily create customized AI workflows and agents. It simplifies the development of AI applications, which usually require many iterations, by allowing for quick changes from testing to production. Chatflows link AI models with various tools like memory, data loaders, and cache, along with over a hundred other integrations including LangChain and LlamaIndex. This setup enables the creation of autonomous agents and assistants that can perform diverse tasks using custom tools. I can build functional agents and OpenAI assistants, or opt for local AI models to save costs. Flowise supports extensions and integrations through APIs, SDKs, and embedded chat features. It is platform-agnostic, meaning Flowise can work with local, open-source AI models in secure, offline environments using local data storage. It is compatible with various platforms and technologies like Ollama, HuggingFace, AWS (Amazon Web Services), Azure, and GCP (Google Cloud Platform), offering flexibility in deployment.

https://docs.flowiseai.com/↗.

Running the Flowise UI.

• From the Terminal, I activate the Flow environment:

conda activate Flow

• I run Flowise:

npx flowise start

• I open the Flowise UI in the browser:

http://localhost:3000

Example 1: Local Chatbot.

• I click Chatflows button in the Main Menu, found on the left of the Flowise UI:

• At the top-right of the UI, I click the blue + Add New button.

• At the top-right of the Untitled chatflow canvas, I click the Save (💾) button:

• I name the canvas Local Chatbot and and click the blue Save button:

NOTE: On the left of the UI is a round, blue button with a plus symbol (+). This is the Add Nodes button. Clicking the Add Nodes button causes the blue button to change to a minus symbol (-) and a drop-down menu to display. Clicking the blue minus symbol (-) closes the drop-down menu. Within the drop-down menu are closed sub-menus (˅) that twirl open (˄) when clicked. Click an open sub-menu to close it again. The convention is to follow the path (>) to a node. All paths start with Add Nodes > and end with nodes being dragged onto the current canvas.

• I drag the Add Nodes > Chains > Conversation Chain onto the Local Chatbot canvas:

• I drag the Add Nodes > Chat Models > ChatOllama node onto the canvas.

• In the ChatOllama node, I I define the following settings:

• I connect the ChatOllama Output to the Chat Model * Input of the Conversation Chain by clicking-and-dragging a connector from one node to the other node:

• I drag the Add Nodes > Memory > Buffer Memory onto the canvas.

• I connect the Buffer Memory Output to the Memory * Input of the Conversation Chain:

• I save the changes to the Local Chatbot.

• On the right of the UI, I click the round, purple Chat icon to send the "Tell me a joke" message to the LLM:

• At the top-left of the UI, I click the left-pointing arrow to return to the Main Menu.

Example 2: Local RAG Chatbot.

• From the Main Menu ( on the left of the UI), I click Chatflows.

• In the Untitled chatflow canvas, I click the Save button (that looks like a floppy disk.)

• I rename the canvas Local RAG Chatbot.

NOTE: Remember, the Add Nodes button on the left is round, blue, and has a (+) symbol.

• I drag the Add Nodes > Chains > Conversational Retrieval QA Chain node to the canvas.

• I drag the Add Nodes > Chat Models > ChatOllama node to the canvas.

• I connect the ChatOllama node Output to the Conversational Retrieval QA Chain node Chat Model Input.

• In the ChatOllama node, I define the following settings:

• I drag the Add Nodes > Vector Stores > In-Memory Vector Store node to the canvas.

• I connect the In-Memory Vector Store node Output to the Conversational Retrieval QA Chain node Vector Store Retriever Input.

• I drag the Add Nodes > Embeddings > Ollama Embeddings node to the canvas.

• I connect the Ollama Embeddings node Output to the In-Memory Vector Store node Embeddings Input.

• In the Ollama Embeddings node, I define the following settings:

• I drag the Add Nodes > Document Loaders > Cheerio Web Scraper node to the canvas.

• I connect the Cheerio Web Scraper Output to the In-Memory Vector Store node Document Input.

• In the Cheerio Web Scraper node, I define the following settings:

• I save the changes to the Local RAG Chatbot.

• I insert data from the Cheerio Web Scraper into the In-Memory Vector Store by clicking the green DB button at the top-right of the screen.

• Once completed, I can chat with the results, e.g. "What is LangSmith?"

The Results.

Using Flowise with local LLMs offers a robust and flexible environment for developing advanced, AI-powered applications. By integrating tools like Ollama, and various Flowise components, I can create efficient, cost-effective, local chatbots and AI agents capable of performing a wide range of tasks. This setup enhances data privacy, operational security, and allows for extensive customization to meet specific needs. Whether for business processes, customer service, or personal projects, the ability to build and manage local AI models with Flowise opens up new possibilities for innovation and efficiency in AI application development.

In Conclusion.

I discovered how Flowise can transform my AI development process and revolutionize my AI workflows with local LLMs.

In today's tech-driven world, efficiency and customization in AI are crucial. That's why I'm excited to share my journey using Flowise with local LLMs, a robust platform that simplifies the creation of AI-powered applications.

With Flowise, I've built powerful local chatbots and AI agents that are not only cost-effective but also prioritize data privacy and operational security. This setup is perfect for businesses and individual developers looking to innovate, while also maintaining control over their data.

From integrating tools like Ollama to utilizing components like Chatflows and Memory Buffers, Flowise has allowed me to seamlessly transition from testing to production, ensuring my AI solutions are both dynamic and scalable.

Have you considered using local LLMs for your AI projects? What has been your biggest challenge in AI development?

Until next time: Be safe, be kind, be awesome.

#Flowise #AI #AIdevelopment #AIWorkflow #AIApplications #LocalLLMs #Chatbots #MachineLearning #TechInnovation #DataPrivacy #OperationalSecurity