docs: add versioned documentation for v0.7.x (#1521)

This PR adds versioned documentation for release v0.7.x.

## Changes
- ✅ Created \`versioned_docs/version-v0.7.x/\` directory with current
docs content
- ✅ Created \`versioned_sidebars/version-v0.7.x-sidebars.json\` with
current sidebar configuration
- ✅ Updated \`versions.json\` to include the version
- ✅ Fixed relative links in markdown files to account for versioned docs
directory structure

## Release Type
🆕 **Minor Release**: This creates new versioned documentation for a new
minor version.

## Triggered by
Release tag: \`v0.7.0\`

## What's next?
After merging this PR, the documentation for version v0.7.x will be
available at:
- Latest: \`/docs/\` (if this is the latest version)
- Versioned: \`/docs/v0.7.x/\`

The version will also appear in the documentation version dropdown." \
  --head "$BRANCH_NAME" \
  --base main

Signed-off-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: chewong <10557231+chewong@users.noreply.github.com>

Author: github-actions[bot]

website/versioned_docs/version-v0.7.x/aikit.md

@@ -0,0 +1,133 @@
+# AIKit Integration with KAITO
+
+[AIKit](https://github.com/kaito-project/aikit/) provides a streamlined way to package and deploy large language models (LLMs) as container images.
+
+This document demonstrates how to integrate AIKit-built models with KAITO workspaces for efficient AI model deployment on Kubernetes, including CPU-based inference and custom model creation with a variety of supported formats, such as GGUF, GPTQ, EXL2, and more.
+
+For more detailed information about AIKit, please refer to the [AIKit documentation](https://kaito-project.github.io/aikit/docs/). For any AIKit-related issues, please open an issue in the [AIKit repository](https://github.com/kaito-project/aikit/issues).
+
+## Overview
+
+AIKit enables you to:
+
+- 📦 [Package AI models](https://kaito-project.github.io/aikit/docs/create-images) as OCI container images with minimal configuration
+- 🤏 Minimal image size, resulting in less vulnerabilities and smaller attack surface with a custom distroless-based image
+- 🏃 Run models with a variety of inference backends, such as text or image generation
+- 🖥️ Supports [AMD64 and ARM64 CPUs](https://kaito-project.github.io/aikit/docs/create-images#multi-platform-support) and [GPU-accelerated inferencing with NVIDIA GPUs](https://kaito-project.github.io/aikit/docs/gpu)
+- 🪄 Integrate seamlessly with KAITO's infrastructure management and deployment workflows
+
+:::note
+
+While AIKit and KAITO integrate well, they are separate projects. AIKit focuses on model packaging and deployment, while KAITO provides infrastructure management and Kubernetes deployment workflows via controllers. There may be differences in what model formats are supported by each project.
+
+:::
+
+## Deploying AIKit Models to KAITO
+
+### Cluster Setup
+
+This guide will provide instructions using a [kind](https://kind.sigs.k8s.io/) cluster for local development and testing so it's easy to get started.
+
+Please note that if you already have a Kubernetes cluster set up, you can skip the cluster setup section.
+
+- Download and install [kind](https://kind.sigs.k8s.io/docs/user/quick-start/)
+
+- Create a kind cluster:
+
+```bash
+kind create cluster --name kaito
+```
+
+- Install [KAITO workspace controller](installation.md#install-kaito-workspace-controller) on your cluster
+
+### KAITO Workspace Configuration
+
+Create a KAITO workspace configuration file to deploy your model. Here's a complete example:
+
+```yaml title="aikit-workspace.yaml"
+apiVersion: kaito.sh/v1beta1
+kind: Workspace
+metadata:
+  name: workspace-llama-3point2-3b
+resource:
+  labelSelector:
+    matchLabels:
+      apps: llama-3point2-3b
+  preferredNodes:
+    - kaito-control-plane
+inference:
+  template:
+    spec:
+      containers:
+        - name: llama-3point2-3b
+          image: ghcr.io/kaito-project/aikit/llama3.2:3b
+          args:
+            - "run"
+            - "--address=:5000"
+```
+
+:::info Memory Requirements
+Before deploying models, check the model's memory requirements to avoid Out of Memory (OOM) errors. Add appropriate `resources.requests.memory` and `resources.limits.memory` to your container spec based on the model requirements.
+
+For GGUF models:
+
+- 7B models generally require at least 8GB of RAM
+- 13B models generally require at least 16GB of RAM
+- 70B models generally require at least 64GB of RAM
+
+You can use [gguf-parser-go](https://github.com/gpustack/gguf-parser-go) to get a better estimate for the memory requirements for a given GGUF model, and quantization.
+:::
+
+Label the nodes with the applicable label to ensure the workspace can schedule pods on them.
+
+```bash
+kubectl label nodes kaito-control-plane apps=llama-3point2-3b
+```
+
+Deploy the workspace using:
+
+```bash
+kubectl apply -f aikit-workspace.yaml
+```
+
+AIKit provides a number of pre-built and curated models that can be used directly. Please refer to [Pre-made Models](https://kaito-project.github.io/aikit/docs/premade-models) for available options.
+
+:::tip
+
+Alternatively, if you are on a supported cloud provider and want the cloud provider to auto-provision the nodes for you, you can define an `instanceType` for KAITO to autoprovision nodes, including CPU and GPU nodes.
+
+You can specify the instance type based on your cloud provider's offerings. For example, for Azure, you can specify a `Standard_D2ads_v5`, which is a CPU SKU like this:
+
+```yaml
+resource:
+  instanceType: "Standard_D2ads_v5"
+  labelSelector:
+    matchLabels:
+      apps: llama-3point2-3b
+```
+
+:::
+
+After workspace deployment succeeds, please refer to [Quick Start](quick-start#monitor-deployment) for monitoring the workspace and testing model inference.
+
+#### Custom Model Creation and Integration
+
+AIKit provides a simple way to create custom models without additional tools except for [Docker](https://docs.docker.com/desktop/install/linux-install/)!
+
+Here's an example on how to create a custom model and integrate it with KAITO:
+
+```bash
+export IMAGE_NAME="your-registry/your-model:latest"
+
+docker buildx build -t $IMAGE_NAME --push \
+    --build-arg="model=huggingface://TheBloke/Llama-2-7B-Chat-GGUF/llama-2-7b-chat.Q4_K_M.gguf" \
+    "https://raw.githubusercontent.com/kaito-project/aikit/main/models/aikitfile.yaml"
+```
+
+After building the image, you can use it in your KAITO workspace configuration by updating the `image` field.
+
+For more information on creating custom models, refer to the [AIKit documentation](https://kaito-project.github.io/aikit/docs/create-images).
+
+:::info
+AIKit supports a subset of backends, (such as [`llama.cpp`](https://kaito-project.github.io/aikit/docs/llama-cpp), [`diffusers`](https://kaito-project.github.io/aikit/docs/diffusion), [`exllamav2`](https://kaito-project.github.io/aikit/docs/exllama2), and others) from [LocalAI](https://localai.io/) at this time. Please see [Inference Supported Backends](https://kaito-project.github.io/aikit/docs/) section for more details, and updates.
+:::

website/versioned_docs/version-v0.7.x/aws.md

@@ -0,0 +1,72 @@
+---
+title: AWS Setup
+---
+
+This guide covers setting up auto-provisioning capabilities for KAITO on Amazon Elastic Kubernetes Service (EKS). Auto-provisioning allows KAITO to automatically create GPU nodes when needed for your AI workloads.
+
+## Prerequisites
+
+- An EKS cluster with KAITO workspace controller installed (see [Installation](installation))
+- [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) for managing AWS resources
+- [eksctl](https://eksctl.io/installation/) for EKS cluster management
+- [kubectl](https://kubernetes.io/docs/tasks/tools/) configured to access your EKS cluster
+
+## Understanding Auto-Provisioning on AWS
+
+KAITO can use [Karpenter](https://karpenter.sh/) to automatically provision GPU nodes. This controller:
+
+- Creates new GPU nodes when workspaces require specific instance types
+- Supports various AWS GPU instances (g4, g5, p3, p4 series, etc.)
+- Manages node lifecycle based on workload demands
+- Integrates with AWS IAM for secure access
+
+:::note
+Alternative: If you already have GPU nodes or manage them separately, use the preferred nodes approach in the [Quick Start](quick-start) instead.
+:::
+
+## Set Up Auto-Provisioning
+
+### Create EKS Cluster and install Karpenter
+
+Follow the instructions [here](https://karpenter.sh/docs/getting-started/getting-started-with-karpenter/) to create an EKS cluster and install Karpenter.
+
+Then update the KAITO workspace controller Helm chart values for AWS:
+
+```bash
+helm update kaito-workspace --namespace kaito-workspace --set cloudProviderName=aws
+```
+
+### Using Auto-Provisioning
+
+Once Karpenter is set up, you can create workspaces that automatically provision GPU nodes:
+
+```yaml title="phi-4-workspace.yaml"
+apiVersion: kaito.sh/v1beta1
+kind: Workspace
+metadata:
+  name: workspace-phi-4-mini
+resource:
+  instanceType: "g5.4xlarge" # Will trigger node creation
+  labelSelector:
+    matchLabels:
+      apps: phi-4-mini
+inference:
+  preset:
+    name: phi-4-mini-instruct
+```
+
+Apply the workspace:
+
+```bash
+kubectl apply -f phi-4-workspace.yaml
+```
+
+## Supported AWS GPU Instance Types
+
+The GPU provisioner supports various AWS GPU SKUs, see [supported options here](https://github.com/kaito-project/kaito/blob/main/pkg/sku/aws_sku_handler.go).
+
+For the complete list and specifications, see the [AWS GPU instance documentation](https://docs.aws.amazon.com/dlami/latest/devguide/gpu.html).
+
+## Clean Up
+
+See the Karpenter documentation for instructions on how to clean up your EKS cluster and remove Karpenter [here](https://karpenter.sh/docs/getting-started/getting-started-with-karpenter/#9-delete-the-cluster).

website/versioned_docs/version-v0.7.x/azure.md

@@ -0,0 +1,174 @@
+---
+title: Azure Setup
+---
+
+This guide covers setting up auto-provisioning capabilities for KAITO on Azure Kubernetes Service (AKS). Auto-provisioning allows KAITO to automatically create GPU nodes when needed for your AI workloads.
+
+## Prerequisites
+
+- An AKS cluster with KAITO workspace controller installed
+  - See [Step 1](#step-1-create-and-configure-an-aks-cluster) to create an AKS cluster
+  - See [Installation](installation) to install the KAITO workspace controller
+- [Azure CLI](https://learn.microsoft.com/cli/azure/install-azure-cli) for managing Azure resources
+- [kubectl](https://kubernetes.io/docs/tasks/tools/) configured to access your AKS cluster
+
+## Understanding Auto-Provisioning on Azure
+
+KAITO can use the [Azure GPU Provisioner](https://github.com/Azure/gpu-provisioner) to automatically provision GPU nodes. This controller:
+
+- Creates new GPU nodes when workspaces require specific instance types
+- Supports various Azure GPU SKUs (Standard_NC series, etc.)
+- Manages node lifecycle based on workload demands
+- Integrates with Azure's managed identity system for secure access
+
+### When to Use Auto-Provisioning
+
+Choose auto-provisioning when:
+- You want KAITO to manage GPU node creation automatically
+- Your workloads have varying GPU requirements
+- You prefer to specify exact Azure instance types in your workspaces
+
+:::note
+Alternative: If you already have GPU nodes or manage them separately, use the [preferred nodes approach](quick-start#option-1-using-preferred-nodes-existing-gpu-nodes) instead.
+:::
+
+## Set Up Auto-Provisioning
+
+### Step 1: Create and configure an AKS Cluster
+
+If you don't have an AKS cluster yet, you can create one using the Azure CLI:
+
+```bash
+export RESOURCE_GROUP="kaito-rg"
+export CLUSTER_NAME="kaito-cluster"
+export LOCATION="eastus"
+az group create --name $RESOURCE_GROUP --location $LOCATION
+az aks create --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME --enable-oidc-issuer --enable-workload-identity --enable-managed-identity --generate-ssh-keys
+```
+
+Connect to the cluster:
+```bash
+az aks get-credentials --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME
+```
+
+### Step 2: Create Managed Identity
+
+Create a managed identity for the GPU provisioner with the necessary permissions:
+
+```bash
+export SUBSCRIPTION=$(az account show --query id -o tsv)
+export IDENTITY_NAME="kaitoprovisioner"
+
+# Create the managed identity
+az identity create --name $IDENTITY_NAME -g $RESOURCE_GROUP
+
+# Get the principal ID for role assignment
+export IDENTITY_PRINCIPAL_ID=$(az identity show --name $IDENTITY_NAME -g $RESOURCE_GROUP --subscription $SUBSCRIPTION --query 'principalId' -o tsv)
+
+# Assign Contributor role to the cluster
+az role assignment create \
+  --assignee $IDENTITY_PRINCIPAL_ID \
+  --scope /subscriptions/$SUBSCRIPTION/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.ContainerService/managedClusters/$CLUSTER_NAME \
+  --role "Contributor"
+```
+
+### Step 3: Install GPU Provisioner
+
+Install the Azure GPU Provisioner using Helm:
+
+```bash
+export GPU_PROVISIONER_VERSION=0.3.6
+
+# Download and configure Helm values
+curl -sO https://raw.githubusercontent.com/Azure/gpu-provisioner/main/hack/deploy/configure-helm-values.sh
+chmod +x ./configure-helm-values.sh && ./configure-helm-values.sh $CLUSTER_NAME $RESOURCE_GROUP $IDENTITY_NAME
+
+# Install GPU provisioner
+helm install gpu-provisioner \
+  --values gpu-provisioner-values.yaml \
+  --set settings.azure.clusterName=$CLUSTER_NAME \
+  --wait \
+  https://github.com/Azure/gpu-provisioner/raw/gh-pages/charts/gpu-provisioner-$GPU_PROVISIONER_VERSION.tgz \
+  --namespace gpu-provisioner \
+  --create-namespace
+```
+
+### Step 4: Create Federated Credential
+
+Create the federated identity credential to allow the GPU provisioner to access Azure resources:
+
+```bash
+export AKS_OIDC_ISSUER=$(az aks show -n $CLUSTER_NAME -g $RESOURCE_GROUP --subscription $SUBSCRIPTION --query "oidcIssuerProfile.issuerUrl" -o tsv)
+
+az identity federated-credential create \
+  --name kaito-federatedcredential \
+  --identity-name $IDENTITY_NAME \
+  -g $RESOURCE_GROUP \
+  --issuer $AKS_OIDC_ISSUER \
+  --subject system:serviceaccount:"gpu-provisioner:gpu-provisioner" \
+  --audience api://AzureADTokenExchange \
+  --subscription $SUBSCRIPTION
+```
+
+## Verify Setup
+
+Check that the GPU provisioner is running correctly:
+
+```bash
+# Check Helm installations
+helm list -n gpu-provisioner
+helm list -n kaito-workspace
+
+# Check GPU provisioner status
+kubectl describe deploy gpu-provisioner -n gpu-provisioner
+kubectl get pods -n gpu-provisioner
+```
+
+The GPU provisioner pod should be in a `Running` state. If it's failing, check the logs:
+
+```bash
+kubectl logs --selector=app.kubernetes.io/name=gpu-provisioner -n gpu-provisioner
+```
+
+## Using Auto-Provisioning
+
+Once set up, you can create workspaces that automatically provision GPU nodes:
+
+```yaml title="phi-4-workspace.yaml"
+apiVersion: kaito.sh/v1beta1
+kind: Workspace
+metadata:
+  name: workspace-phi-4-mini
+resource:
+  instanceType: "Standard_NC6s_v3"  # Will trigger node creation
+  labelSelector:
+    matchLabels:
+      apps: phi-4-mini
+inference:
+  preset:
+    name: phi-4-mini-instruct
+```
+
+Then apply the workspace:
+
+```bash
+kubectl apply -f phi-4-workspace.yaml
+```
+
+## Supported Azure GPU Instance Types
+
+The GPU provisioner supports various Azure GPU SKUs, see [supported options here](https://github.com/kaito-project/kaito/blob/main/pkg/sku/azure_sku_handler.go).
+
+For the complete list and specifications, see the [Azure GPU-optimized VM sizes documentation](https://learn.microsoft.com/en-us/azure/virtual-machines/sizes-gpu).
+
+## Clean Up
+
+To remove the auto-provisioning setup:
+
+```bash
+# Uninstall GPU provisioner
+helm uninstall gpu-provisioner -n gpu-provisioner
+
+# Delete the managed identity (optional)
+az identity delete --name $IDENTITY_NAME -g $RESOURCE_GROUP
+```