### Quick Start: Installing Airflow UI

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/adrs/adr-0036-apache-airflow-workflow-orchestration-integration.md

This command provides a basic installation command for the Airflow UI, typically used in a quick start or setup guide.

```bash
airflow webserver -p 8080 -D
airflow scheduler -D
```

--------------------------------

### Install Git and Clone Repository (Bash)

Source: https://github.com/qubinode/qubinode_navigator/blob/main/QUICKSTART.md

Installs the Git package if it's not already present and then clones the Qubinode Navigator repository from GitHub. This is the first step in setting up the project.

```bash
sudo dnf install -y git
git clone https://github.com/Qubinode/qubinode_navigator.git
cd qubinode_navigator
```

--------------------------------

### Quick Start Deployment of Qubinode Navigator

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/CLEAN-INSTALL-GUIDE.md

This bash script provides a streamlined installation process for Qubinode Navigator. It clones the repository, navigates into the directory, and executes the main deployment script. The script automates OS detection, DNS configuration, package installation, KVM setup, networking, and storage configuration.

```bash
# Clone the repository
git clone https://github.com/Qubinode/qubinode_navigator.git
cd qubinode_navigator

# Run the one-shot deployment
sudo ./deploy-qubinode.sh
```

--------------------------------

### Run Qubinode Navigator Setup Script

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/deployments/setup-sh.markdown

Executes the setup.sh script to perform the full installation and configuration of Qubinode Navigator. This includes package installation, environment setup, and deployment tasks.

```bash
./setup.sh
```

--------------------------------

### Example Configuration: Google Gemini Default

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/AI-MODEL-CONFIGURATION.md

An example .env file configuration using Google Gemini for all AI Assistant roles (Manager, Developer, Deployment). This is the recommended fast and free default setup.

```bash
# .env
MANAGER_MODEL=google-gla:gemini-2.0-flash
DEVELOPER_MODEL=google-gla:gemini-2.0-flash
PYDANTICAI_MODEL=google-gla:gemini-2.0-flash
GEMINI_API_KEY=your-gemini-api-key
```

--------------------------------

### Example Configuration: Local Ollama Models

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/AI-MODEL-CONFIGURATION.md

An example .env file configuration for using local AI models served by Ollama. This setup does not require external API keys and uses the specified Ollama base URL.

```bash
# .env
MANAGER_MODEL=ollama:granite3.3:8b
DEVELOPER_MODEL=ollama:llama3.2
PYDANTICAI_MODEL=ollama:granite3.3:8b
OLLAMA_BASE_URL=http://localhost:11434
```

--------------------------------

### Manual Installation Steps for Qubinode Navigator

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/CLEAN-INSTALL-GUIDE.md

This bash script details the manual installation procedure for Qubinode Navigator, intended for advanced users. It includes updating the system, installing Git, cloning the repository, configuring the environment by editing the .env file, and making the deployment script executable before running it.

```bash
# Update system
sudo dnf update -y

# Install git
sudo dnf install -y git

# Clone repository
git clone https://github.com/Qubinode/qubinode_navigator.git
cd qubinode_navigator

# Create configuration
cp .env.example .env
vim .env  # Edit with your settings

# Make script executable
chmod +x deploy-qubinode.sh

# Run deployment
sudo ./deploy-qubinode.sh
```

--------------------------------

### Legacy Installation Script

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/index.markdown

This script executes a traditional setup script for compatibility purposes. It is a simpler installation method compared to the modernized script.

```bash
# Traditional setup script (compatibility mode)
./setup.sh
```

--------------------------------

### Explore Qubinode Documentation

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/CLEAN-INSTALL-GUIDE.md

Lists available documentation directories and specific guides such as deployment guides and Architectural Decision Records (ADRs). This helps users find relevant information for understanding and using Qubinode.

```bash
# View available documentation
ls docs/

# Read deployment guides
ls docs/deployments/

# Check ADRs (Architectural Decision Records)
ls docs/adrs/
```

--------------------------------

### Configure HCP Vault Integration Steps

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/adrs/machine-specific-todo.md

These steps guide the user through configuring HashiCorp Vault integration using HCP credentials. It involves following the HCP setup guide, configuring the `.env` file with HCP and RHEL subscription details, creating an HCP application, storing secrets, and testing the integration.

```bash
cat docs/vault-setup/HCP-VAULT-SETUP.md
vim .env
./setup-vault-integration.sh
```

--------------------------------

### Modern Installation Script

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/index.markdown

This script clones the Qubinode Navigator repository and then executes a modernized setup script to install the platform. It requires Git and a shell environment.

```bash
# Clone the repository
git clone https://github.com/Qubinode/qubinode_navigator.git
cd qubinode_navigator

# Run the modernized setup script with plugin framework
./setup_modernized.sh
```

--------------------------------

### Display Setup Script Help

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/deployments/setup-sh.markdown

Runs the setup.sh script with the --help option to display the help message and available command-line options. This is useful for understanding script functionality.

```bash
./setup.sh --help # Show help message
```

--------------------------------

### Quick Start: Make Scripts Executable and Test VM Creation

Source: https://github.com/qubinode/qubinode_navigator/blob/main/airflow/QUICK-REFERENCE.md

Provides essential steps for a quick start: making shell scripts executable and running the test script for VM creation. This is the initial setup and validation phase.

```bash
# 1. Make scripts executable (one-time)
cd /opt/qubinode_navigator/airflow/scripts
chmod +x *.sh

# 2. Test VM creation
./test-kcli-create-vm.sh

# 3. Check if it worked
./test-kcli-list-vms.sh
```

--------------------------------

### Start Airflow Standalone Installation (Bash)

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/airflow-integration-guide.md

Commands to start the Airflow webserver and scheduler for a standalone installation. This method is suitable for development or testing. It requires Airflow to be installed and configured with AIRFLOW_HOME.

```bash
# Terminal 1: Start webserver
export AIRFLOW_HOME=~/airflow
airflow webserver --port 8080

# Terminal 2: Start scheduler
export AIRFLOW_HOME=~/airflow
airflow scheduler
```

--------------------------------

### Start Development Server and Run Tests

Source: https://github.com/qubinode/qubinode_navigator/blob/main/templates/CONTRIBUTING-template.md

Commands to start the development server and execute the full test suite for verifying setup and code functionality.

```bash
# Start development server
npm run dev  # or python manage.py runserver

# Run full test suite
npm run test:full  # or pytest --cov
```

--------------------------------

### Create RHEL 10 Deployment Guide

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/AI_ECOSYSTEM_ROADMAP.md

This bash command creates a sample Markdown file detailing a RHEL 10 KVM setup on specific hardware. It includes sections for hardware configuration and specific setup steps, intended for ingestion into the RAG knowledge base.

```bash
# User shares successful RHEL 10 deployment guide
echo "# RHEL 10 KVM Setup on Dell R750
## Hardware Configuration
- CPU: Intel Xeon Gold 6338
- RAM: 256GB DDR4
- Storage: NVMe RAID 1

## Specific Steps
1. Enable VT-x in BIOS (F2 during boot)
2. Configure SR-IOV for networking
3. Set up NUMA topology..." > rhel10-dell-guide.md
```

--------------------------------

### Install Podman and Podman Compose (Bash)

Source: https://github.com/qubinode/qubinode_navigator/blob/main/QUICKSTART.md

Installs the podman container runtime and podman-compose package using the dnf package manager. These are essential for running containerized services in Qubinode Navigator.

```bash
dnf install -y podman podman-compose
```

--------------------------------

### Quick Start Deployment Scripts

Source: https://context7.com/qubinode/qubinode_navigator/llms.txt

Provides Bash scripts for a quick start deployment of the full Qubinode stack, including AI Assistant, Airflow, and PostgreSQL. It covers cloning the repository, running preflight checks, and executing the main deployment script. Also includes steps for setting up a non-root user for deployment.

```bash
# Clone and deploy (full stack)git clone https://github.com/Qubinode/qubinode_navigator.git
cd qubinode_navigator

# Run preflight checks and fix issues
./scripts/preflight-check.sh --fix

# Deploy everything (AI Assistant + Airflow + PostgreSQL)
sudo -E ./scripts/development/deploy-qubinode.sh

# Alternative: Deploy with Airflow orchestration
sudo -E ./deploy-qubinode-with-airflow.sh

# Non-root deployment (recommended)
curl -OL https://gist.githubusercontent.com/tosin2013/385054f345ff7129df6167631156fa2a/raw/configure-sudo-user.sh
chmod +x configure-sudo-user.sh && ./configure-sudo-user.sh lab-user
sudo su - lab-user
ssh-keygen -f ~/.ssh/id_rsa -t rsa -N ''
ssh-copy-id lab-user@$(hostname -I | awk '{print $1}')

```

--------------------------------

### Setup Development Environment and Hooks

Source: https://github.com/qubinode/qubinode_navigator/blob/main/templates/CONTRIBUTING-template.md

Steps to copy the environment template, set up pre-commit hooks, and run initial tests to verify the development environment.

```bash
# Copy environment template
cp .env.example .env

# Setup pre-commit hooks
./scripts/setup-precommit-hooks.sh

# Run initial tests
npm test  # or pytest
```

--------------------------------

### AI Assistant Error Guidance Example

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/user-guides/ai-assistant-guide.md

An example of the AI Assistant's output when a deployment error occurs, providing specific troubleshooting steps for package installation failures on RHEL.

```text
[ERROR] Failed to install RHEL 10 packages
[AI ASSISTANT] Analyzing error and providing troubleshooting guidance...
╔══════════════════════════════════════════════════════════════╗
║                    AI ASSISTANT GUIDANCE                     ║
╚══════════════════════════════════════════════════════════════╝
The package installation failure on RHEL 10 is likely due to:

1. Repository connectivity issues
   - Check: ping 8.8.8.8
   - Verify: dnf repolist

2. Insufficient system resources
   - Check: free -h (need 8GB+ RAM)
   - Check: df -h (need 50GB+ disk)

3. Missing RHEL subscription
   - Run: subscription-manager status
   - Register if needed: subscription-manager register

Try running the deployment again after addressing these issues.

For more help, visit: http://localhost:8080

```

--------------------------------

### Correct kcli VM Creation Syntax

Source: https://github.com/qubinode/qubinode_navigator/blob/main/airflow/QUICK-REFERENCE.md

Demonstrates the correct syntax for creating a VM using kcli, highlighting the expected parameter format. Incorrect syntax examples are also provided for contrast.

```bash
# ✅ CORRECT kcli syntax
kcli create vm <name> -i <image> -P memory=<MB> -P numcpus=<N> -P disks=[<GB>]

# ❌ WRONG (don't use these flags)
kcli create vm <name> --image <image> --memory <MB> --cpus <N>
```

--------------------------------

### Quick Start: Local Vault Setup

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/vault-setup/VAULT-OPTIONS-COMPARISON.md

Commands to start a local development instance of HashiCorp Vault using Docker, for integration with Qubinode Navigator. It assumes Docker is installed and running.

```bash
# Follow Local guide
cat docs/vault-setup/LOCAL-VAULT-SETUP.md
docker run -d --name vault-dev -p 8200:8200 hashicorp/vault:latest
```

--------------------------------

### Test Installation from Release Tag (Bash)

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/how-to/create-release.md

This snippet shows how to clone the repository, checkout a specific release tag, and run the installation script. This is useful for verifying the release after it has been created.

```bash
git clone https://github.com/Qubinode/qubinode_navigator.git
cd qubinode_navigator
git checkout vX.Y.Z
./setup_modernized.sh
```

--------------------------------

### Clone and Deploy Qubinode Navigator (Bash)

Source: https://github.com/qubinode/qubinode_navigator/blob/main/README.md

This snippet demonstrates the recommended modern setup for Qubinode Navigator. It involves cloning the repository, running pre-flight checks, and then deploying the full suite including AI Assistant, Airflow, and PostgreSQL. Ensure you have the necessary prerequisites and sufficient RAM.

```bash
# Clone the repository
git clone https://github.com/Qubinode/qubinode_navigator.git
cd qubinode_navigator

# Run pre-flight checks
./scripts/preflight-check.sh --fix

# Deploy everything (AI Assistant + Airflow + PostgreSQL)
sudo -E ./scripts/development/deploy-qubinode.sh
```

--------------------------------

### Example Log Output Format

Source: https://github.com/qubinode/qubinode_navigator/blob/main/airflow/LOGGING-GUIDE.md

This is an example of the enhanced log output format automatically included in Qubinode DAGs. It includes task start time, execution details, parameters, results, and error information.

```text
# ================================================================================ 🚀 Starting Task: create_vm ⏰ Execution Date: 2025-11-19T08:00:00+00:00 🔄 Try Number: 1 📋 DAG ID: example_kcli_vm_provisioning

# 📝 Task Parameters: • vm_name: test-vm • image: centos-stream-10 • memory: 2048 • cpus: 2 [... task execution ...]

# ✅ Task create_vm Completed Successfully 📊 Result: {'vm_name': 'test-vm', 'status': 'created', 'ip': '192.168.122.10'} ⏱️  Completed At: 2025-11-19T08:05:30.123456
```

--------------------------------

### Resolve Package Installation Failures

Source: https://github.com/qubinode/qubinode_navigator/blob/main/QUICK_START.md

This snippet offers solutions for common package installation failures during Qubinode Navigator deployment. It includes commands to clean the package cache, update the package list, and check repository configurations.

```bash
# Update package cache
dnf clean all
dnf makecache

# Check repository configuration
dnf repolist
```

--------------------------------

### Install Dependencies and Setup Qubinode Navigator (Bash)

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/deployments/demo-hetzner-com.markdown

Installs essential packages like tmux, curl, git, and vim. Clones the .tmux configuration, sets up local tmux configuration, downloads a remote script, makes it executable, and initiates a tmux session to run the script.

```bash
sudo dnf install -y tmux curl git vim
git clone https://github.com/gpakosz/.tmux.git
ln -s -f .tmux/.tmux.conf
cp .tmux/.tmux.conf.local .
curl -OL https://raw.githubusercontent.com/Qubinode/qubinode_navigator/main/rocky-linux-hetzner.sh
chmod +x rocky-linux-hetzner.sh
tmux new-session -s rocky-linux-hetzner
source notouch.env && sudo -E  ./rocky-linux-hetzner.sh
```

--------------------------------

### Make Setup Script Executable

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/deployments/setup-sh.markdown

Grants execute permissions to the setup.sh script. This allows the script to be run directly from the terminal.

```bash
chmod +x setup.sh
```

--------------------------------

### Initiate Qubinode Deployment

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/user-guides/ai-assistant-guide.md

This bash script initiates the Qubinode deployment process. It's the primary command to start the setup and triggers the AI Assistant if errors occur.

```bash
./deploy-qubinode.sh

```

--------------------------------

### Quick Start: OpenShift Vault Setup

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/vault-setup/VAULT-OPTIONS-COMPARISON.md

Commands to set up Vault within an OpenShift environment for Qubinode Navigator integration. This includes creating a new project and potentially following external guides.

```bash
# Follow OpenShift guide
cat docs/vault-setup/OPENSHIFT-VAULT-SETUP.md
oc new-project vault-system
```

--------------------------------

### Environment Configuration with .env Example (Bash & INI)

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/deployments/demo-hetzner-modern.markdown

This section demonstrates how to copy an example environment file and edit it to configure Qubinode Navigator. It includes a detailed example of Hetzner-specific settings for domain, user, cluster name, deployment mode, network, and cloud integration.

```bash
# Copy and edit configuration
cp .env.example .env
vi .env
```

```ini
# =============================================================================
# HETZNER CLOUD DEPLOYMENT CONFIGURATION
# =============================================================================

# Basic Configuration
QUBINODE_DOMAIN=qubinodelab.io
QUBINODE_ADMIN_USER=lab-user
QUBINODE_CLUSTER_NAME=hetzner-cluster
QUBINODE_DEPLOYMENT_MODE=production

# Hetzner-Specific Settings
INVENTORY=hetzner
SSH_USER=lab-user
CICD_PIPELINE=true
ENV_USERNAME=lab-user

# Network Configuration
FORWARDER=1.1.1.1
INTERFACE=bond0
ACTIVE_BRIDGE=false

# Cloud Integration
USE_ROUTE53=true
HETZNER_TOKEN=your_hetzner_token

# AI Assistant (Recommended)
QUBINODE_ENABLE_AI_ASSISTANT=true
AI_ASSISTANT_PORT=8080

# Optional: HashiCorp Vault Integration
USE_HASHICORP_VAULT=false
# USE_HASHICORP_CLOUD=true
# HCP_CLIENT_ID=your_client_id
# HCP_CLIENT_SECRET=your_client_secret
```

--------------------------------

### Deploy a Test VM using kcli

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/GETTING_STARTED.md

A simple command to create a test virtual machine named 'test-vm' using the 'centos9stream' image. This is a practical example for users to quickly deploy a VM and test the environment.

```bash
sudo kcli create vm test-vm -i centos9stream
```

--------------------------------

### Local Development Setup and Run (Bash)

Source: https://github.com/qubinode/qubinode_navigator/blob/main/ai-assistant/README.md

Provides commands for setting up the local development environment by installing dependencies, running the FastAPI application, and testing the CLI interface.

```bash
# Install dependencies
pip install -r requirements.txt

# Run locally
cd src
python main.py

# Test CLI
../scripts/qubinode-ai --health
```

--------------------------------

### Find Config Files in Airflow DAG (Python)

Source: https://github.com/qubinode/qubinode_navigator/blob/main/airflow/CONFIG-SYNC-GUIDE.md

Python code using helper functions to get the OpenShift agent installation directory and find specific configuration files within an Airflow DAG.

```python
from dag_helpers import get_config_file_path, get_openshift_agent_install_dir

# Get base directory
agent_dir = get_openshift_agent_install_dir()

# Find specific file (searches multiple locations)
try:
    env_file = get_config_file_path("examples/jfrog-disconnected-vlan/env/passthrough.env")
    print(f"Found: {env_file}")
except FileNotFoundError as e:
    print(f"Config not found: {e}")
```

--------------------------------

### RHEL 9 Post-Setup Installation Verification

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/adrs/machine-specific-todo.md

Commands to verify the installation of Ansible Navigator, Podman, and the Ansible inventory after the RHEL 9 hypervisor setup.

```bash
# Check Ansible Navigator
ansible-navigator --version

# Check Podman
podman --version

# Test inventory
ansible-navigator inventory --list -m stdout
```

--------------------------------

### Query Documentation for VM Creation with kcli

Source: https://github.com/qubinode/qubinode_navigator/blob/main/airflow/MCP-SERVER-GUIDE.md

Shows how to query documentation for specific commands, such as creating a VM using `kcli`. The `query_documents` tool is used with a relevant query string.

```text
User: How do I use kcli to create a VM?

Claude: [Calls query_documents tool with query="kcli create vm"]
Found documentation:

## Result 1 (Score: 0.95)
**Source:** QUICK-REFERENCE.md

To create a VM with kcli:
```bash
kcli create vm <name> -i <image> -P memory=<MB> -P numcpus=<count>
````

Example:

```bash
kcli create vm test-vm -i centos10stream -P memory=2048 -P numcpus=2
```
```

--------------------------------

### Example Configuration: OpenRouter with Mixed Models

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/AI-MODEL-CONFIGURATION.md

An example .env file configuration demonstrating the use of different AI models from various providers via OpenRouter for Manager, Developer, and Deployment roles.

```bash
# .env
MANAGER_MODEL=openrouter:anthropic/claude-3.5-sonnet
DEVELOPER_MODEL=openrouter:google/gemini-2.0-flash-exp
PYDANTICAI_MODEL=openrouter:openai/gpt-4o
OPENROUTER_API_KEY=sk-or-your-api-key
```

--------------------------------

### Simple Qubinode Deployment DAG (Python)

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/airflow-integration-guide.md

An example Airflow DAG that orchestrates a simple Qubinode deployment. It uses BashOperators to run validation scripts, the deployment setup script, and post-deployment verification commands, followed by a notification task.

```python
# airflow/dags/qubinode_simple_deploy.py

from airflow import DAG
from airflow.operators.bash import BashOperator
from datetime import datetime, timedelta

default_args = {
    'owner': 'qubinode',
    'depends_on_past': False,
    'start_date': datetime(2025, 11, 15),
    'email_on_failure': True,
    'email_on_retry': False,
    'retries': 2,
    'retry_delay': timedelta(minutes=5),
}

dag = DAG(
    'qubinode_simple_deploy',
    default_args=default_args,
    description='Simple Qubinode deployment workflow',
    schedule_interval=None,  # Manual trigger only
    catchup=False,
    tags=['qubinode', 'deployment'],
)

# Pre-deployment validation
validate = BashOperator(
    task_id='validate_prerequisites',
    bash_command='cd /opt/qubinode_navigator && ./scripts/validate.sh',
    dag=dag,
)

# Deploy Qubinode
deploy = BashOperator(
    task_id='deploy_qubinode',
    bash_command='cd /opt/qubinode_navigator && ./setup.sh',
    dag=dag,
)

# Post-deployment verification
verify = BashOperator(
    task_id='verify_deployment',
    bash_command='systemctl is-active libvirtd && virsh list --all',
    dag=dag,
)

# Notification
notify = BashOperator(
    task_id='send_notification',
    bash_command='echo "Deployment complete!" | mail -s "Qubinode Deployed" admin@example.com',
    dag=dag,
)

validate >> deploy >> verify >> notify

```

--------------------------------

### Configure Qubinode Navigator with .env File

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/CLEAN-INSTALL-GUIDE.md

This sequence of bash commands outlines the process for customizing Qubinode Navigator's installation. It involves copying an example environment file, editing it with specific settings, and optionally configuring deployment mode, AI assistant, and KVM version. Key required settings include domain, admin user, and cluster name.

```bash
# Copy the example configuration
cp .env.example .env

# Edit with your settings
vim .env

# Required settings in .env file
QUBINODE_DOMAIN=your-domain.local
QUBINODE_ADMIN_USER=your-username
QUBINODE_CLUSTER_NAME=your-cluster-name

# Optional Settings
# Deployment mode (development, staging, production)
QUBINODE_DEPLOYMENT_MODE=production

# AI Assistant (true/false)
QUBINODE_ENABLE_AI_ASSISTANT=true

# KVM version
KVM_VERSION=0.10.4
```

--------------------------------

### Execute Qubinode Bootstrap Assistant Interactively

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/AI_ECOSYSTEM_ROADMAP.md

This command initiates the interactive setup process for Qubinode Navigator after the bootstrap assistant has been downloaded and prepared. It launches the assistant, which then guides the user through the setup with AI assistance.

```bash
# Interactive AI-guided setup
./qubinode-bootstrap
```

--------------------------------

### AI Assistant Guidance for Equinix Metal Optimization

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/deployments/demo-redhat-modern.markdown

Example output from the AI Assistant, showing optimization steps for the Equinix Metal environment, including network interface configuration and security settings.

```text
🤖 AI: "Optimizing for Equinix Metal bare metal servers.
Configuring bond0 interface for network redundancy.
Applying enterprise-grade security settings..."
```

--------------------------------

### Start Airflow Services (Bash)

Source: https://github.com/qubinode/qubinode_navigator/blob/main/QUICKSTART.md

Starts all services defined in the Airflow podman-compose configuration in detached mode. This is used to bring up the Airflow environment.

```bash
cd airflow && podman-compose up -d
```

--------------------------------

### Legacy Qubinode Navigator Setup (Bash)

Source: https://github.com/qubinode/qubinode_navigator/blob/main/README.md

This snippet provides a legacy method for setting up Qubinode Navigator by piping a setup script directly into bash. This method might be used for older installations or specific environments where the modern setup is not applicable. It's a simpler, single-command approach.

```bash
curl https://raw.githubusercontent.com/Qubinode/qubinode_navigator/main/setup.sh | bash
```

--------------------------------

### Enable and Start SSH Tunnel Service on Linux

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/SSH-TUNNELING-GUIDE.md

Commands to enable the `systemd` user service for the SSH tunnel, ensuring it starts on boot, and to start it immediately.

```bash
systemctl --user enable qubinode-tunnel
systemctl --user start qubinode-tunnel
```

--------------------------------

### Initial Server Setup and Qubinode Navigator Cloning (Bash)

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/deployments/demo-hetzner-modern.markdown

This script guides through SSHing into a Hetzner server, creating a new user with sudo privileges, cloning the Qubinode Navigator repository, and navigating into the project directory. It assumes basic familiarity with Linux commands and SSH.

```bash
# SSH into your Hetzner server as root
ssh root@your-hetzner-server.com

# Create lab-user (if needed)
curl -OL https://gist.githubusercontent.com/tosin2013/385054f345ff7129df6167631156fa2a/raw/b67866c8d0ec220c393ea83d2c7056f33c472e65/configure-sudo-user.sh
chmod +x configure-sudo-user.sh
./configure-sudo-user.sh lab-user

# Clone Qubinode Navigator
git clone https://github.com/Qubinode/qubinode_navigator.git
cd qubinode_navigator
```

--------------------------------

### Deploy MCP Services with deploy-fastmcp-production.sh

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/tutorials/mcp-production-and-client.md

This script deploys MCP services by stopping existing MCP profile services and starting them using podman-compose. It waits for the Airflow MCP server container to be reported as 'Up'. Ensure you have podman and podman-compose installed and the qubinode_navigator repository cloned.

```bash
cd /opt/qubinode_navigator  # or the path where you cloned the repo

./deploy-fastmcp-production.sh
```

--------------------------------

### Install HCP CLI (Bash)

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/vault-setup/HCP-VAULT-SETUP.md

Installs the HashiCorp Cloud Platform Command Line Interface on Debian/Ubuntu-based systems using apt. Requires root privileges for installation.

```bash
# Install HCP CLI (Linux)
curl -fsSL https://apt.releases.hashicorp.com/gpg | sudo apt-key add -
sudo apt-add-repository "deb [arch=amd64] https://apt.releases.hashicorp.com $(lsb_release -cs) main"
sudo apt-get update && sudo apt-get install hcp
```

--------------------------------

### Setup Kcli Base with Setup Script

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/deployments/setup-sh.markdown

Executes the setup.sh script with the --setup-kcli-base option to set up the Kcli base environment. This option is used for configuring Kcli.

```bash
./setup.sh --setup-kcli-base # Set up Kcli base
```

--------------------------------

### Get Help for kcli VM Creation Script

Source: https://github.com/qubinode/qubinode_navigator/blob/main/airflow/QUICK-REFERENCE.md

This command shows how to access help information for the 'test-kcli-create-vm.sh' script. This is useful for understanding the script's options, arguments, and usage patterns before execution.

```bash
./scripts/test-kcli-create-vm.sh --help
```

--------------------------------

### Install Qubinode Bootstrap Assistant

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/AI_ECOSYSTEM_DEMO.md

Installs the Qubinode bootstrap assistant using a curl command. This script downloads and executes the installer, enabling AI-guided setup for users.

```bash
# Install bootstrap assistant
curl -sSL https://get.qubinode.io | bash
```

--------------------------------

### Deploy Qubinode Navigator with One-Shot Script

Source: https://github.com/qubinode/qubinode_navigator/blob/main/QUICK_START.md

This snippet details the process of deploying Qubinode Navigator using a single bash script. It includes making the script executable and then running it to initiate the deployment. This is the primary method for setting up the Qubinode Navigator solution.

```bash
# Make script executable (if needed)
chmod +x deploy-qubinode.sh

# Deploy with AI Assistant support
./deploy-qubinode.sh
```

--------------------------------

### Deploy FreeIPA Server using AI Orchestrator via curl

Source: https://github.com/qubinode/qubinode_navigator/blob/main/docs/GETTING_STARTED.md

Demonstrates how to deploy a FreeIPA server for identity management using the AI Orchestrator. This is achieved by sending a POST request to the '/orchestrator/intent' endpoint with a JSON payload specifying the intent, parameters, and execution settings. This example is used in E2E tests.

```bash
# Via curl (as used in our E2E tests)
curl -X POST http://localhost:8080/orchestrator/intent \
  -H "Content-Type: application/json" \
  -d '{
    "intent": "Deploy FreeIPA server for identity management",
    "params": {"vm_name": "freeipa", "action": "create"},
    "auto_approve": true,
    "auto_execute": true
  }'
```