Add vessl-docs

examples/models.md

@@ -0,0 +1,43 @@
+---
+title: Models
+description: See VESSL Run in action with the latest open-source models
+version: EN 
+---
+
+<CardGroup cols={2}>
+  <Card title="Llama2-7B Fine-tuning"  href="/examples/models/llama2">
+    Fine-tune Llama2-7B with a code instructions dataset. 
+    <br/>
+    <img className="rounded-md" src="/images/examples/hub-llama2.png" />
+  </Card>
+
+  <Card title="Mistral-7B Playground" href="/examples/models/mistral">
+    Launch a GPU-accelerated Streamlit app of Mistral 7B.
+    <br/>
+    <img className="rounded-md" src="/images/examples/hub-mistral.png" />
+  </Card>
+  
+  <Card title="SSD-1B Playground" href="/examples/models/ssd">
+    Interactive playground of a lighter and faster version of Stable Diffusion XL.
+    <br/>
+    <img className="rounded-md" src="/images/examples/hub-ssd.png" />
+  </Card>
+
+  <Card title="Whisper V3 Playground" href="/examples/models/whisper3">
+    Translate audio snippets into text on a Streamlit playground.
+    <br/>
+    <img className="rounded-md" src="/images/examples/hub-whisper.png" />
+  </Card>
+
+  <Card title="Stable Diffusion Playground" href="/examples/models/diffusion">
+    Generate images with a prompt on the web, powered with Stable Diffusion. 
+    <br/>
+    <img className="rounded-md" src="/images/examples/hub-sd.png" />
+  </Card>
+
+  <Card title="Launch your next model" href="/examples/usecases/batch-run">
+    Start from our template YAML to build and deploy your next model.
+    <br/>
+    <img className="rounded-md" src="/images/examples/hub-vessl.png" />
+  </Card>
+</CardGroup>

examples/models/llama2.md

@@ -0,0 +1,59 @@
+---
+title: Llama2-7B Fine-tuning
+description: Fine-tune Llama2-7B with a code instructions dataset
+version: EN
+---
+
+## Try out this model on [VESSL Hub](https://vessl.ai/hub).
+
+This example fine-tunes [Llama 2](https://ai.meta.com/llama/) on a code instruction dataset. The code instruction dataset is consisted of 1.6K samples and follows the format of Stanford's [Alpaca dataset](https://github.com/gururise/AlpacaDataCleaned). 
+To optimize the training process into a single GPU with moderate memory, the model uses [8 bit quantization](https://huggingface.co/blog/hf-bitsandbytes-integration) and LoRA (Low-Rank Adaptation).
+
+In the code we are referencing under `/code/`, we added our Python SDK for logging key metrics like loss and learning rate. You can check these values in real-time under Plots. The run completes by uploading the model checkpoint to VESSL AI model registry, as defined under `export`. 
+
+<img
+  className="rounded-md"
+  src="/images/llama2-metrics.png"
+/>
+<img
+  className="rounded-md"
+  src="/images/llama2-uploaded-model.png"
+/>
+
+## Running the model
+
+You can run the model with our quick command.
+```sh
+vessl run create -f llama2_fine-tuning.yaml
+```
+
+Here's a rundown of the `llama2_fine-tuning.yaml` file.
+```yaml
+name: llama2-finetuning
+description: finetune llama2 with code instruction alpaca dataset
+resources:
+  cluster: vessl-gcp-oregon
+  preset: v1.l4-1.mem-27
+image: quay.io/vessl-ai/hub:torch2.1.0-cuda12.2-202312070053
+import:
+  /model/: vessl-model://vessl-ai/llama2/1
+  /code/:
+    git:
+      url: https://github.com/vessl-ai/hub-model
+      ref: main
+  /dataset/: vessl-dataset://vessl-ai/code_instructions_small_alpaca
+export:
+  /trained_model/: vessl-model://vessl-ai/llama2-finetuned
+  /artifacts/: vessl-artifact://
+run:
+  - command: |-
+      pip install -r requirements.txt
+      mkdir /model_
+      cd /model
+      mv llama_2_7b_hf.zip /model_
+      cd /model_
+      unzip llama_2_7b_hf.zip
+      cd /code/llama2-finetuning
+      python finetuning.py
+    workdir: /code/llama2-finetuning
+```

examples/models/mistral.md

@@ -0,0 +1,50 @@
+---
+title: Mistral-7B Playground
+description: Launch a text-generation Streamlit app using Mistral-7B
+version: EN
+---
+
+## Try out this model on [VESSL Hub](https://vessl.ai/hub).
+
+This example runs an app for inference using Mistral-7B which is an open-source LLM developed by [Mistral AI](https://mistral.ai/). The model utilizes a grouped query attention (GQA) and a sliding window attention mechanism (SWA), which enable faster inference and handling longer sequences at smaller cost than other models. As a result, it achieves both efficiency and high performance. Mistral-7B outperforms Llama 2 13B on all benchmarks and Llama 1 34B in reasoning, mathematics, and code generation benchmarks.
+
+<img
+  className="rounded-md"
+  src="/images/mistral-streamlit.png"
+/>
+
+## Running the model
+
+You can run the model with our quick command.
+```sh
+vessl run create -f mistral_7b.yaml
+```
+
+Here's a rundown of the `mistral_7b.yaml` file.
+```yaml
+name: mistral-7b-streamlit
+description: A template Run for inference of Mistral-7B with streamlit app
+resources:
+  cluster: vessl-gcp-oregon
+  preset: v1.l4-1.mem-42
+image: quay.io/vessl-ai/hub:torch2.1.0-cuda12.2-202312070053
+import:
+  /model/: hf://huggingface.co/VESSL/Mistral-7B
+  /code/:
+    git:
+      url: https://github.com/vessl-ai/hub-model
+      ref: main
+run:
+  - command: |-
+      pip install -r requirements_streamlit.txt
+      streamlit run streamlit_demo.py --server.port 80
+    workdir: /code/mistral-7B
+interactive:
+  max_runtime: 24h
+  jupyter:
+    idle_timeout: 120m
+ports:
+  - name: streamlit
+    type: http
+    port: 80
+```

examples/models/ssd.md

@@ -0,0 +1,52 @@
+---
+title: SSD-1B Playground
+description: Interactive playground of a lighter and faster version of Stable Diffusion XL
+version: EN
+---
+
+## Try out this model on [VESSL Hub](https://vessl.ai/hub).
+
+This examples runs an inference app for SSD-1B. After launching, you can access a streamlit web app to generate images with your own prompts. [The Segmind Stable Diffusion Model (SSD-1B)](https://www.segmind.com/) is a distilled 50% smaller version of the Stable Diffusion XL (SDXL), offering a 60% speedup while maintaining high-quality text-to-image generation capabilities.
+
+<img
+  className="rounded-md"
+  src="/images/ssd-streamlit.png"
+/>
+
+## Running the model
+
+You can run the model with our quick command.
+```sh
+vessl run create -f ssd-streamlit.yaml
+```
+
+Here's a raundom of the `ssd-streamlit.yaml` file.
+```yaml
+name: SSD-1B-streamlit
+description: A template Run for inference of SSD-1B with streamlit app
+resources:
+  cluster: vessl-gcp-oregon
+  preset: v1.l4-1.mem-42
+image: quay.io/vessl-ai/hub:torch2.1.0-cuda12.2-202312070053
+import:
+  /code/:
+    git:
+      url: https://github.com/vessl-ai/hub-model
+      ref: main
+  /model/: hf://huggingface.co/VESSL/SSD-1B
+run:
+  - command: |-
+      pip install --upgrade pip
+      pip install -r requirements.txt
+      pip install git+https://github.com/huggingface/diffusers
+      streamlit run ssd_1b_streamlit.py --server.port=80
+    workdir: /code/SSD-1B
+interactive:
+  max_runtime: 24h
+  jupyter:
+    idle_timeout: 120m
+ports:
+  - name: streamlit
+    type: http
+    port: 80
+```

examples/models/stable-diffusion.md

@@ -0,0 +1,54 @@
+---
+title: Stable Diffusion Playground
+description: Generate images with a prompt on the web, powered with Stable Diffusion
+version: EN
+---
+
+## Try out this model on [VESSL Hub](https://vessl.ai/hub).
+
+A simple web app for [stable diffusion](https://stability.ai/) inference is deployed in this example. Some SD model checkpoints are mounted with a VESSL Model so you can try some generation instantly.
+
+Stable diffusion is a deep learning, text-to-image model that uses a diffusion technique, which generates an image from noise by iterating gradual denoising steps. Unlike other text-to-image models, stable diffusion performs a diffusion process in the latent space with smaller dimensions and reconstructs the result to the image in a real dimension. Also, a cross-attention mechanism is added for multi-modal tasks such as text-to-image and layout-to-image tasks.
+
+<img
+  className="rounded-md"
+  src="/images/sd-webui-grumpy-cat.png"
+/>
+
+## Running the model
+
+You can run the model with our quick command.
+```sh
+vessl run crewate -f sd-webui.yaml
+```
+
+Here's a rundown of the `sd-webui.yaml` file.
+```yaml
+name: stable-diffusion-webui
+description: A template Run for stable diffusion webui app
+resources:
+  cluster: google-oregon
+  preset: v1.l4-1.mem-42
+image: quay.io/vessl-ai/hub:torch2.1.0-cuda12.2-202312070053
+import:
+  /code/:
+    git:
+      url: https://github.com/vessl-ai/hub-model
+      ref: main
+  /models/protogen-infinity/: hf://huggingface.co/darkstorm2150/Protogen_Infinity_Official_Release
+  /models/sd-v1-5/: hf://huggingface.co/VESSL/stable-diffusion-v1-5-checkpoint
+  /models/sd-v2-1/: hf://huggingface.co/VESSL/stable-diffusion-v2-1-checkpoint
+run:
+  - command: |-
+      pip install -r requirements.txt
+      python -u launch.py --no-download-sd-model --ckpt-dir /models --no-half --no-gradio-queue --listen 
+    workdir: /code/stable-diffusion-webui
+interactive:
+  max_runtime: 24h
+  jupyter:
+    idle_timeout: 120m
+ports:
+  - name: gradio
+    type: http
+    port: 7860
+```

examples/models/whisper.md

@@ -0,0 +1,46 @@
+---
+title: Whisper V3 Playground
+description: Translate audio snippets into text on a Streamlit playground.
+version: EN
+---
+
+## Try out this model on [VESSL Hub](https://vessl.ai/hub).
+
+This example runs a general-purpose speech recognition model,  [Whisper V3](https://github.com/openai/whisper). It is trained on a 680k hours of diverse labelled audio. Whisper is also a multitasking model that can perform multilingual speech recognition, speech translation, and language identification. It can generalize to many domains without additional fine-tuning.
+
+<img
+  className="rounded-md"
+  src="/images/whisper-results.png"
+/>
+
+## Running the model
+
+You can run the model with our quick command.
+```sh
+vessl run create -f whisper.yaml
+```
+
+If you open log pages, you can see the result of inference for first 5 data in [Librispeech_asr dataset](https://www.openslr.org/12).
+
+
+Here's a rundown of the `whisper.yaml` file.
+```yaml
+name: whisper-v3
+description: A template Run for inference of whisper v3 on librispeech_asr test set
+resources:
+  cluster: vessl-gcp-oregon
+  preset: v1.l4-1.mem-42
+image: quay.io/vessl-ai/hub:torch2.1.0-cuda12.2-202312070053
+import:
+  /model/: hf://huggingface.co/VESSL/Whisper-large-v3
+  /dataset/: hf://huggingface.co/datasets/VESSL/librispeech_asr_clean_test
+  /code/:
+    git:
+      url: https://github.com/vessl-ai/hub-model
+      ref: main
+run:
+  - command: |-
+      pip install -r requirements.txt
+      python inference.py
+    workdir: /code/whisper-v3
+```

examples/uses.md

@@ -0,0 +1,25 @@
+---
+title: Use cases
+description: See VESSL Run in action with common use cases and workflows
+version: EN 
+---
+
+<CardGroup cols={2}>
+  <Card title="Launch batch jobs on GPUs"  href="/examples/uses/job">
+    Leverge the power of GPUs to efficiently train batch runs
+    <br/>
+    {/* <img className="rounded-md" src="/images/hub-llama2.png" /> */}
+  </Card>
+
+  <Card title="Spin-up a notebook server on GPUs" href="/examples/uses/notebook">
+    Enable a real-time session of interacitve run on GPUs.
+    <br/>
+    {/* <img className="rounded-md" src="/images/hub-mistral.png" /> */}
+  </Card>
+  
+  <Card title="Backup & Restore data with Artifacts" href="/examples/uses/artifact">
+    Run, Backup, Repeat: VESSL Run with VESSL Artifact
+    <br/>
+    {/* <img className="rounded-md" src="/images/hub-ssd.png" /> */}
+  </Card>
+</CardGroup>

examples/uses/artifact.md

@@ -0,0 +1,67 @@
+---
+title: Backup & Restore data with Artifacts
+description: VESSL Run with VESSL Artifact
+version: EN
+---
+
+# Backup and restore data with VESSL Artifact
+VESSL Artifact provides a manged storage solution to backup and restore data seamlessly during your runs. By setting up the `export` and `import` options in your YAML configuration or through the Web Console, you can easily save and retrieve volumes. This guide covers how to use these features for data persistence.
+
+## Backing Up Data
+When you initiate a run, you can specify volumes to be exported and saved into VESSL Artifact for later use.
+
+### Using YAML
+In your YAML configuration, add the `export` keyword and specify the target volume and artifact name as shown below:
+```yaml
+export: 
+  /target/path/: vessl-artifact://{organizationName}/{projectName}/{artifactName}
+```
+Here, `/target/path/` is the path of the volume in your run container that you wish to export, and `{artifactName}` is the name you want to give to the saved artifact.
+
+### Using Web Console
+Navigate to the `Project > Runs` section in the VESSL Web Console. Locate the `Volumes` section and click `Export > VESSL Artifact` at the target path. 
+
+![export_vessl_artifact_1](/images/run/export_vessl_artifact_1.png)
+
+Click `Backup Volume` option and specify the `Artifact Name`.
+
+![export_vessl_artifact_2](/images/run/export_vessl_artifact_2.png)
+
+Once the run is executed, the specified volume will be exported and saved into VESSL Artifact with the given artifact name after run.
+
+## Restoring Data
+To use the saved data in another run, you can specify the artifact to be imported.
+
+### Using YAML
+In your YAML configuration for the new run, use the `import` keyword as shown:
+
+```yaml
+import:
+  /target/path/: vessl-artifact://{organizationName}/{projectName}/{artifactName}
+```
+`/target/path/` is the path of the volume in your run container that you wish to import, and `{artifactName}` is the name you have saved before.
+
+
+### Using Web Console
+Navigate to the `Project > Runs"` section in the VESSL Web Console. Locate the `Volumes` section when creating or editing a run.
+![import_vessl_artifact_1](/images/run/import_vessl_artifact_1.png)
+Once the new run is executed, the specified volume will be populated with the data from the imported artifact.
+
+## What's Next
+For more detailed YAML reference and definitions, please visit:
+<CardGroup cols={2}>
+  <Card
+    title="YAML Reference"
+    icon="book"
+    href="/yaml-reference/en/yaml"
+  >
+    A complete descriptions of YAML references.
+  </Card>
+  <Card
+    title="YAML Cheat Sheet"
+    icon="file-lines"
+    href="/yaml-reference/en/yaml_cheat_sheet"
+  >
+    A complete list of YAML definitions.
+  </Card>
+</CardGroup>

examples/uses/job.md

@@ -0,0 +1,79 @@
+---
+title: Launch batch jobs on GPUs
+description: Leverge the power of GPUs to efficiently train batch runs
+version: EN
+---
+
+## Batch Run
+Batch runs are designed to execute a series of commands defined in your YAML configuration and then terminate. Batch job is suitable for large-scale, long-running tasks. These tasks are powered by the robustness of GPU capabilities, which significantly hasten model training times.
+
+### A Simple Batch Run
+Here is an example of a simple batch run YAML configuration. It specifies Docker image to be used, the resource required for the run, and the commands to be exectued during the run.
+
+```yaml Simple batch run definition
+name: gpu-batch-run
+description: Run a GPU-backed batch run.
+image: quay.io/vessl-ai/ngc-pytorch-kernel:22.10-py3-202306140422
+resources:
+  cluster: vessl-gcp-oregon
+  preset: v1.l4-1.mem-42
+run:
+  - command: |
+      nvidia-smi
+```
+In this example, the `resources.preset=v1.v100-1.mem-52` will request a V100 GPU instance. Next, the `nvidia-smi` command will be executed to display the 
+NVIDIA system management inteface and then terminate the run.
+
+### Termination Protection
+
+You can also define termination protection in a batch run. Termination protection keeps your run active for a specified duration even after your commands have finished executing. This can be usefrul for debugging or retrieving intermediate files.
+```yaml Enable termination protection
+name: gpu-batch-run
+description: Run a GPU-backed batch run.
+image: quay.io/vessl-ai/ngc-pytorch-kernel:22.10-py3-202306140422
+resources:
+  cluster: vessl-gcp-oregon
+  preset: v1.l4-1.mem-42
+run:
+  - command: |
+      nvidia-smi
+termination_protect: true
+```
+In this example, the `termination_protect` will protect the container termination after running `nvidia-smi` command.
+
+## Train a Thin-Plate Spline Motion Model with GPU resource
+Now let's dive in more complex batch run configuration. This configuration file describes a batch run for training a Thin-Plate Spline Motion Model utilizing a V100 GPU.
+
+```yaml Batch run YAML for training Thin-Plate Spline Motion Model
+name: Thin-Plate-Spline-Motion-Model
+description: "Animate your own image in the desired way with a batch run on VESSL."
+image: nvcr.io/nvidia/pytorch:21.05-py3
+resources:
+  cluster: vessl-gcp-oregon
+  preset: v1.l4-1.mem-42
+run:
+  - workdir: /root/examples/thin-plate-spline-motion-model
+    command: |
+      pip install -r requirements.txt
+      python run.py --config config/vox-256.yaml --device_ids 0
+import:
+  /root/examples: git://github.com/vessl-ai/examples
+  /root/examples/vox: s3://vessl-public-apne2/vessl_run_datasets/vox/
+```
+In this batch run, the Docker image `nvcr.io/nvidia/pytorch:21.05-py3` is used, and a V100 GPU (`resources.preset=v1.v100-1.mem-52`) is allocated for the run. This will ensure that the training job runs on top of the V100 GPU.
+
+The model and scripts used in this run are fetched from a Github repository (`/root/examples: git://github.com/vessl-ai/examples`).
+
+The commands executed in the run first install the requriements, and train the model using the `run.py` script.
+
+This example demonstrates how you can set up a batch run for GPU-backed training a machine learning model with a single YAML configuration.
+
+## What's Next
+For more advanced configurations and examples. please visit [VESSL Hub](https://vesslai.notion.site/9e42f785bbdf42379b2112b859d8c873?v=8d1527bc18154381b9baf35d4068b227&pvs=4).
+<Card
+  title="VESSL Hub"
+  icon="database"
+  href="https://vesslai.notion.site/9e42f785bbdf42379b2112b859d8c873?v=8d1527bc18154381b9baf35d4068b227&pvs=4"
+>
+  A variatey of YAML examples that you can use as references
+</Card>

examples/uses/notebook.md

@@ -0,0 +1,81 @@
+---
+title: Spin-up a notebook server on GPUs
+description: Enable a real-time session of interacitve run on GPUs.
+version: EN
+---
+
+## Interactive run
+Interactive runs are designed to using Jupyter or SSH for live interaction with your data, code, and GPUs. Interactive runs are useful for tasks such as data exploration, model debugging, and algorithm development. They also allow you to expose additional ports on the container and communicate through those ports.
+
+### A Simple Interactive Run
+Here is an example of a simple interactive run. It specifies resources, a container image, and the duration of the interactive runtime. It's important to note that by default, port `22/tcp` is exposed for SSH and `8888/http` is exposed for JupyterLab.
+
+```yaml Simple interactive run definition
+name: gpu-interactive-run
+description: Run an interactive GPU-backed Jupyter and SSH server.
+resources:
+  cluster: vessl-gcp-oregon
+  preset: v1.l4-1.mem-42
+image: quay.io/vessl-ai/ngc-pytorch-kernel:22.10-py3-202306140422
+interactive:
+  max_runtime: 24h
+  jupyter:
+    idle_timeout: 120m
+```
+
+### Port
+You can also specify additional ports to be exposed during an interactive run.
+
+```yaml Simple interactive run definition
+name: gpu-interactive-run
+description: Run an interactive GPU-backed Jupyter and SSH server.
+resources:
+  cluster: vessl-gcp-oregon
+  preset: v1.l4-1.mem-42
+image: quay.io/vessl-ai/ngc-pytorch-kernel:22.10-py3-202306140422
+interactive:
+  max_runtime: 24h
+  jupyter:
+    idle_timeout: 120m
+ports:
+  - 8501
+```
+In this example, in addition to the default ports, 8501 will be exposed. Note that the `ports` field takes a list, so you can specify multiple ports if necessary. Also if you want to specify a TCP port, you can append `/tcp` to the port number; otherwise, `/http` is used implicitly.
+
+## Run a stable diffusion demo with GPU resources
+
+Now move onto running a stable diffusion demo. The following configuration outlines an interactive run set up to execute a Stable Diffusion demo utilizing a V100 GPU and exposing the interactive Streamlit demo on port 8501.
+```yaml Interactive run YAML for a Stable Diffsuion inference demo
+name: Stable Diffusion Web
+description: Run an inference web app of stable diffusion demo.
+image: nvcr.io/nvidia/pytorch:22.10-py3
+resources:
+  cluster: vessl-gcp-oregon
+  preset: v1.l4-1.mem-42
+run:
+  - command: |
+      exit
+      bash <(wget -qO- https://raw.githubusercontent.com/AUTOMATIC1111/stable-diffusion-webui/master/webui.sh)
+      bash webui.sh
+interactive: 
+  max_runtime: 24h
+  jupyter:
+    idle_timeout: 120n
+ports:
+  -8501
+```
+In this interactive run, the Docker image `image=nvcr.io/nvidia/pytorch:22.10-py3` is utilized, and a V100 GPU (`resources.preset=v1.v100-1.mem-52`) is allocated for the run. The interactive run is designed to run for 24 hours (`interactive.max_runtime: 24h`) and the Streamlit demo will be accessible via port 8501.
+
+The run commands first execute a bash script from a remote location (`bash <(wget -qO- https://raw.githubusercontent.com/AUTOMATIC1111/stable-diffusion-webui/master/webui.sh)`), followed by the execution of `webui.sh`.
+
+This configuration provides an example of setting up an interactive run for executing a GPU-accelerated demo with real-time user interaction facilitated via a specified port.
+
+## What's Next
+For more advanced configurations and examples. please visit [VESSL Hub](https://vesslai.notion.site/9e42f785bbdf42379b2112b859d8c873?v=8d1527bc18154381b9baf35d4068b227&pvs=4).
+<Card
+  title="VESSL Hub"
+  icon="database"
+  href="https://vesslai.notion.site/9e42f785bbdf42379b2112b859d8c873?v=8d1527bc18154381b9baf35d4068b227&pvs=4"
+>
+  A variatey of YAML examples that you can use as references
+</Card>

guides/clusters/access.md

@@ -0,0 +1,39 @@
+---
+title: Access control
+version: EN
+---
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/access/1_access.png"
+/>
+
+Under **Access Control**, you can grant, manage, and retrieve access to shared clusters.&#x20;
+
+#### (1) Grant access
+
+Click **Grant access** and define the following parameters.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/access/2_grant.png"
+/>
+
+* **Organization name** — Name of the Organization that you want to cluster with.&#x20;
+* **Kubernetes namespace** — [🔗 Kubernetes namespaces](https://www.aquasec.com/cloud-native-academy/kubernetes-101/kubernetes-namespace/) separate a cluster into logical units. It helps granularly organize, allocate, manage, and secure cluster resources. If you are using a naming convention like `group-subgroup`, use a namespace `subgroup`.&#x20;
+* **Node** — Select the nodes to share by clicking the checkbox.&#x20;
+
+#### (2) Edit access
+
+Click **Edit** to edit access to certain nodes.&#x20;
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/access/3_edit.gif"
+/>
+
+#### (3) Revoke access
+
+Click **Revoke** to remove the organization from accessing the clusters.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/access/4_revoke.gif"
+/>
+

guides/clusters/aws.md

@@ -0,0 +1,12 @@
+---
+title: AWS
+version: EN
+---
+
+<Note>
+Private cloud support for AWS, Google Cloud, Microsoft Azure, and Oracle Cloud is currently in development.&#x20;
+
+In the meantime, you can contact our support team to receive AWS integration support backed by our engineering team or request early access.&#x20;
+
+Contact us at [[email protected]](https://vessl.ai/talk-to-sales) or through our [community Slack](https://join.slack.com/t/vessl-ai-community/shared\_invite/zt-1a6schu04-NyjRKE0UMli58Z\_lthBICA).&#x20;
+</Note>

guides/clusters/laptops.md

@@ -0,0 +1,101 @@
+---
+title: Personal laptops
+version: EN
+---
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/laptops/1_mac.png"
+/>
+
+Integrating your Mac or Linux machine to VESSL allows you to use your personal machines as a Kubernetes-backed single-node cluster and optimize your laptop for ML.
+
+* Launch training jobs in seconds on VESSL's easy-to-use web interface or CLI, without writing YAML or scrappy scripts.
+* Build a baseline model on your laptop and transition seamlessly to VESSL Cloud to scale your model.
+* Keep track of your hardware and runtime environments together with `vessl.log`.
+
+VESSL Clusters' single-line CLI command automatically checks, installs, and configures all dependencies such as Kubernetes, and connects your laptop to VESSL.
+
+## Step-by-step Guide
+
+<Warning>There is an ongoing [🔗 issue related to Kubernetes hostname](https://github.com/kubernetes/kubernetes/issues/71140#issue-381687745) containing capital letters. Please make sure your machine's hostname is in lowercase.&#x20;</Warning>
+
+### (1) Prerequisites
+
+You should first have **Docker**, **Helm**, and **VESSL SDK** installed on your machine.&#x20;
+
+#### Install Docker and Helm
+
+Install Docker and Helm. If you are on Mac and have Homebrew installed, the easiest way is to `brew install`. Check out the [🔗 Docker](https://docs.docker.com/get-docker/) and [🔗 Helm](https://helm.sh/docs/intro/install/) installation guides for more details.&#x20;
+
+```bash
+brew install docker
+```
+
+```bash
+brew install helm
+```
+
+<Note>You should have Docker running in the background with your [account](https://hub.docker.com/signup) logged in while using your laptop with VESSL Clusters.&#x20;</Note>
+
+#### **Set up the VESSL environment**
+
+Set up a VESSL environment on your laptop and grant access. Refer to our docs on  VESSL Client for more detailed setup guides.
+
+```bash
+pip install vessl
+```
+
+```bash
+vessl configure
+```
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/laptops/2_token.png"
+/>
+
+### (2) VESSL integration
+
+The following single-line command connects your Mac.&#x20;
+
+```
+vessl cluster create --name '[CLUSTER_NAME_HERE]' --mode single
+```
+
+The most common flags used with `vessl cluster create` commands are as follows. Check out our docs on VESSL CLI for additional flags.
+
+* `--name` — Define your cluster name
+* `--mode single` — Specifies that are installing a single-node cluster. &#x20;
+* `--help` — See additional command options.&#x20;
+
+The command will automatically check dependencies and ask you to install Kubernetes. This process will take a few minutes. Proceed by entering `y`.&#x20;
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/laptops/3_create.png"
+/>
+
+If you have Kubernetes installed on your machine, the command will then ask you to install VESSL agent on the Kubernetes cluster. Enter `y` and proceed.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/laptops/4_install.png"
+/>
+
+By this point, you have successfully completed the integration.
+
+### (3) Confirm integration
+
+Confirm your integration using the `list` command which returns all the clusters available in your Organization.&#x20;
+
+```bash
+vessl cluster list
+```
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/laptops/5_list.png"
+/>
+
+Finally, try running a training job on your laptop. Your first run may take a few minutes to get the Docker images installed on your device.
+
+<iframe>
+	src="https://www.youtube.com/watch?v=HUa-EVd25hA"
+</iframe>
+
+<Note>Windows support for single-node cluster integration is currently in beta. Cluster usage and status monitoring may be limited for Windows machines.&#x20;</Note>

guides/clusters/managed.md

@@ -0,0 +1,38 @@
+---
+title: Managed cloud
+version: EN
+---
+
+Out-of-the-box, VESSL comes with a fully managed AWS and provides the easiest way to run compute-demanding jobs on the cloud. VESSL Cloud solves the common engineering overheads in ML in the cloud, such as volume mount, runtime customization, spot instances, and model checkpoints — at zero additional cost.  
+
+VESSL Cloud provides support for two different [🔗 AWS Regions](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RegionsAndAvailabilityZones.html#Concepts.RegionsAndAvailabilityZones.Regions) — Asia Pacific (Seoul, ap-northeast-2) and US West (Oregon, us-west-2). In addition to your default region, you can an additional region on the web. 
+
+Users on the Pro plan can take advantage of the powerful GPU instances. Below are the GPU specs and equivalent Amazon EC2 instances that VESSL Cloud supports. Check out the links for more details.
+
+* T4 — [🔗 EC2 G4 Instances](https://aws.amazon.com/ec2/instance-types/g4/)
+* K80 — [🔗 EC2 P2 Instances](https://aws.amazon.com/ec2/instance-types/p2/)
+* V100 — [🔗 EC2 P3 Instances](https://aws.amazon.com/ec2/instance-types/p3/)
+
+## Step-by-step Guide
+
+To add an alternative region follow the following steps.
+
+#### (1) Click **New cluster**.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/managed/1_new.png"
+/>
+
+#### (2) Under VESSL Cloud, select your **Region** and **Cluster**.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/managed/2_manㅁged.png"
+/>
+
+#### (3) Click **Done** to complete the setup and confirm your integration under **🗂️ Clusters**.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/managed/3_lisㅅ.png"
+/>
+
+<Warning>If you are on the Enterprise plan and wish to deactivate VESSL Cloud for preventive measures, contact [[email protected]](mailto:[email protected]).</Warning>

guides/clusters/monitoring.md

@@ -0,0 +1,105 @@
+---
+title: Monitor clusters
+version: EN
+---
+
+VESSL Clusters comes with a built-in **cluster dashboard** that provides a visualization of cluster usage and status down to each node and workload. This is enabled by the  **VESSL Cluster Agent** which sends real-time information about the clusters and workloads running on the cluster such as node specifications and model metrics. 
+
+Dashboard setup is done automatically as you integrate your cloud or on-prem servers using `vessl cluster create` command.
+
+<Note>
+    Users on the Enterprise can use VESSL's custom cluster agent to route the monitoring information to your monitoring tools like Datadog and Grafana.&#x20;
+    Contact us at [[email protected]](https://vessl.ai/talk-to-sales) or through our [community Slack](https://join.slack.com/t/vessl-ai-community/shared\_invite/zt-1a6schu04-NyjRKE0UMli58Z\_lthBICA) for more details.
+</Note>
+
+## Cluster-level Monitoring
+
+Multi-cluster monitoring of resource usage and ongoing workloads is available under **🗂️ Clusters**. Here, you can get an overview of the integrated clusters.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/monitoring/1_cluster_.png"
+/>
+
+* Cluster status — Connection and incident status of a cluster.
+* Available nodes — Available number of worker nodes.
+* Real-time resource usage — Real-time resource usage of CPU cores, RAM, and GPUs.
+* Ongoing workloads by type — The number of running notebook servers (Workspaces) and training jobs (Experiments).
+
+Clicking the cluster guides you to the **Summary** tab which holds more detailed information about the cluster.
+
+#### (1) Summary
+
+The summary section presents the basic information about the cluster including the connection and incident status.
+
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/monitoring/2_summar.png"
+/>
+
+#### (2) Quotas & Usage
+
+Quotas & Usage shows the organization-wide and personal resource quota for the cluster, including the number of GPU hours and occupiable GPUs and CPUs. This is set by the organization admin. Refer to our next section in the documentation VESSL Cluster's features on cluster administration.&#x20;
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/monitoring/3_quotas.png"
+/>
+
+#### (3) Resource Statistics
+
+This section shows you how much CPU, GPU, and memory have been requested (and allocated) and are currently being used.&#x20;
+
+<Note>Note that when you are using VESSL Workspaces (notebook servers) you may be occupying a node without actively using the resources — you are only actively using the resources only when the cell is running.</Note>
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/monitoring/4_stats.png"
+/>
+
+#### (4) Workloads
+
+This section shows all ongoing workloads on the cluster with information on the occupying node, resource consumption, creator, and the created date. If you are an organization admin, clicking the workload name guides you to the detailed workload page under **🗂️ Projects** or **🗂️ Workspaces**.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/monitoring/5_workloads.png"
+/>
+
+## Node-level Monitoring
+
+Under **Nodes**, you can view all the worker nodes tied to the cluster with their real-time CPU, Memory, and GPU usage, ongoing workloads by their type, and incident status. You can select the checkbox to get more in-depth information.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/monitoring/6_node.png"
+/>
+
+#### (1) Metadata
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/monitoring/7_node-meta.png"
+/>
+
+#### (2) System metrics
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/monitoring/8_node-systems.png"
+/>
+
+#### (3) Workloads
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/monitoring/9_node-workloads-.png"
+/>
+
+#### (4) Issues
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/monitoring/10_node-issues.png"
+/>
+
+## Workload-level Monitoring
+
+Under **Workloads**, you can view the workload log related to the cluster with the current status, occupying node, resource consumption, and a visualization of the usage history.&#x20;
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/monitoring/11_workloads.png"
+/>
+
+<Note>If you are on the Enterprise plan and wish to send the cluster information collected by VESSL Cluster Agent to your central infra monitoring tool such as Datadog and Grafana, contact us at [[email protected]](https://vessl.ai/talk-to-sales).</Note>

guides/clusters/onprem.md

@@ -0,0 +1,151 @@
+---
+title: On-premise clusters
+version: EN
+---
+
+In the background, VESSL Clusters leverages GPU-accelerated Docker containers and Kubernetes pods. It abstracts the complex compute backends and system details of Kubernetes-backed GPU infrastructure into an easy-to-use web interface and simple CLI commands. Data Scientists and Machine Learning Researchers without any software or DevOps backgrounds can use VESSL's single-line CURL command to set up and configure on-premise GPU servers for ML. 
+
+VESSL’s cluster integration is composed of four primitives.
+
+- **VESSL API Server** — Enables communication between the user and the GPU clusters, through which users can launch containerized ML workloads.
+- **VESSL Cluster Agent** — Sends information about the clusters and workloads running on the cluster such as the node specifications and model metrics.
+- **Control plane node** — Acts as the [🔗 cluster-wide control tower](https://www.containiq.com/post/kubernetes-control-plane) and orchestrates subsidiary worker nodes. 
+- **Worker nodes** — Run specified ML workloads based on the runtime spec and environment received from the control plane node.
+
+![](<../../../../assets/clusters/clusters-clsuter_integrations-onprem (1).png>)
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/onprem/1_onprem.png"
+/>
+
+Integrating more powerful, multi-node GPU clusters for your team is as easy as integrating your personal laptop. To make the process easier, we’ve prepared a **single-line curl command** that installs all the binaries and dependencies on your server.&#x20;
+
+## Step-by-step Guide
+
+<Warning>There is an ongoing [🔗 issue related to Kubernetes hostname](https://github.com/kubernetes/kubernetes/issues/71140#issue-381687745) containing capital letters. Please make sure your machine's hostname is in lowercase.&#x20;</Warning>
+
+### (1) Prerequisites
+
+Note that **Ubuntu 18.04** or **CentOS 7.9** or higher Linux OS is installed on your server.
+
+#### Install dependencies
+
+You can install all the dependencies required for cluster integration using a single-line `curl` command. The command
+
+- Installs [🔗 Docker](https://docs.docker.com/get-docker/) if it’s not already installed.
+- Installs and configures [🔗 NVIDIA container runtime](https://developer.nvidia.com/nvidia-container-runtime).
+- Installs [🔗 k0s](https://k0sproject.io/), a lightweight Kubernetes distribution, and designates and configures a control plane node.
+- Generates a token and a command for connecting worker nodes to the control plane node configured above.
+
+If you wish to use your control plane solely for the control plane node — meaning not running any ML workloads on the control plane node and only using it for admin and monitoring purposes — add a `--taint-controller` flag at the end of the command.
+
+```bash
+curl -sSLf https://install.vessl.ai/bootstrap-cluster/bootstrap-cluster.sh | sudo bash -s -- --role=controller
+```
+
+![](<../../../../assets/clusters/clusters-clsuter_integrations-onprem-1 (1).png>)
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/onprem/2_curl.png"
+/>
+
+Upon installing all the dependencies, the command returns a follow-up command with a token. You can use this to add worker nodes to the control plane. If you don’t want to add an additional worker node you can skip to the next step.&#x20;
+
+```bash
+curl -sSLf https://install.vessl.ai/bootstrap-cluster/bootstrap-cluster.sh | sudo bash -s -- --role worker --token '[TOKEN_HERE]'
+```
+
+You can confirm that your control plane and worker node have been successfully configured using a `k0s` command.
+
+```bash
+sudo k0s kubectl get nodes
+```
+
+![](../../../../assets/clusters/clusters-clsuter_integrations-onprem-2.png)
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/onprem/3_k0s.png"
+/>
+
+### (2) VESSL integration
+
+You are now ready to integrate the Kubernetes cluster with VESSL. Make sure you have VESSL Client installed on the server and configured for your organization.
+
+```bash
+pip install vessl --upgrade
+```
+
+```bash
+vessl configure
+```
+
+The following single-line command connects your Kubernetes-backed GPU cluster to VESSL.
+
+```bash
+vessl cluster create
+```
+
+Follow through prompting your configurtaion options. You can press `Enter` to use the default values.
+
+By this point, you have successfully completed the integration.
+
+### (3) Confirm integration
+
+You can use VESSL CLI command or visit **🗂️ Clusters** to confirm your integration.&#x20;
+
+```bash
+vessl cluster list
+```
+
+![](../../../../assets/clusters/clusters-clsuter_integrations-onprem-5.png)
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/onprem/4_clusters.png"
+/>
+
+### Common troubleshooting commands
+
+Here are common problems that our users face as they integrate on-premise Clusters. You can use the `journalctl` command to get a more detailed log of the issue. Please share this log as you reach out for support.
+
+```
+sudo journalctl -u k0scontroller | tail -n 20
+```
+
+#### VesslApiException: PermissionDenied (403): Permission denied.
+
+```
+kernel_clsuter.py111] VESSL cluster agent installed. Waiting for the agent to be connected with VESSL...
+_base.py:107] VesslApiException: PermissionDenied (403): Permission denied.
+```
+
+It's likely that you don't have full access to install VESSL cluster agent on the server. Contact your organization's cluster and infrastructure administrator to receive help.&#x20;
+
+#### VesslApiException: NotFound (404) Requested entity not found.
+
+```
+kernel_cluster.py:289] Existing VESSL cluster installation found! getting cluster information...
+_base.py:107] VesslApiException: NotFound (404) Requested entity not found.
+```
+
+Try again after running the following command:&#x20;
+
+```bash
+sudo helm uninstall vessl =n vessl --kubeconfig="var/lib/k0s/pki/admin/conf"
+```
+
+**Invalid value: "k0s-ctrl-\[HOSTNAME]"**
+
+```
+leaderelection.go:334] error initially creating leader election record: Lease.coordination.k8s.io "k0s-ctrl-[HOSTNAME]" is invalide: metadata.name: Invalid value: "k0s-ctrl-[HOSTNAME]": a lowercase RFC 1123 subdomain must consist of lowercase alphanumeric characters.
+```
+
+There is an ongoing [🔗 issue related to Kubernetes hostname](https://github.com/kubernetes/kubernetes/issues/71140#issue-381687745) containing capital letters. Your hostname must be in lowercase alphanumeric characters.&#x20;
+
+You can solve this issue by contacting your organization's cluster and infrastructure administrator to change your hostname, or by changing your hostname yourself using the following `sudo` command:
+
+<Warning>Changing your hostname may have unexpected side effects, and might be prohibited depending on your organization's IT policy.&#x20;</Warning>
+
+```
+sudo hostname [HOSTNAME]
+sudo systemctl restart k0scontroller.
+```
+
+## Troubleshooting
+
+If you're experiencing issues with your on-premises cluster, or can't figure out what's causing them, try [VESSL Flare](/docs/troubleshooting/vessl-flare.md).

guides/clusters/overview.md

@@ -0,0 +1,24 @@
+---
+title: Overview
+version: EN
+---
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/overview/1_clusters.png"
+/>
+
+VESSL enables seamless scaling of containerized ML workloads from a personal laptop to cloud instances or Kubernetes-backed on-premise clusters. &#x20;
+
+While VESSL comes with an out-of-the-box, fully managed AWS, you can also integrate **an unlimited number** of (1) personal Linux machines, (2) on-premise GPU servers, and (3) private clouds. You can then use VESSL as a single point of access to multiple clusters.&#x20;
+
+VESSL Clusters simplifies the end-to-end management of large-scale, organization-wide ML infrastructure from integration to monitoring. These features are available under **🗂️ Clusters**.
+
+* **Single-command Integration** — Set up a hybrid or multi-cloud infrastructure with a single command.
+* **GPU-accelerated workloads** — Run training, optimization, and inference tasks on GPUs in seconds
+* **Resource optimization** — Match and scale workloads automatically based on the required compute resources
+* **Cluster Dashboard** — Monitor real-time usage and incident & health status of clusters down to each node.
+* **Reproducibility** — Record runtime metadata such as hardware and instance specifications.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/overview/2_figure.png"
+/>

guides/clusters/quotas.md

@@ -0,0 +1,25 @@
+---
+title: Quotas and limits
+version: EN
+---
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/quotas/1_quotas.png"
+/>
+
+Under **Cluster Quotas**, you can set quotas for the entire Organization or certain user groups based on the number of GPU hours, occupiable GPUs, run hours, and disk size.&#x20;
+
+* Shared Quotas — Set a quota for all organizations or users that have access to the cluster.
+* Individually Defined Quotas — Set individually defined quotas for specific organizations or users.
+
+## Step-by-step Guide
+
+Click **Add new quota** and set the following parameters.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/quotas/2_create.png"
+/>
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/quotas/3_user.png"
+/>

guides/clusters/remove.md

@@ -0,0 +1,28 @@
+---
+title: Remove a cluster
+version: EN
+---
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/remove/1_delete.png"
+/>
+
+<Warning>Once you delete a cluster, there is no going back.&#x20;</Warning>
+
+#### Remove cluster from VESSL
+
+Under **General**, you can remove your clusters from VESSL. Click Delete cluster to proceed. Note that you should first terminate all ongoing workloads.&#x20;
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/remove/2_modal.png"
+/>
+
+#### Remove all dependencies from the cluster
+
+To remove all dependencies including the VESSL cluster agent from the cluster, run the following command.&#x20;
+
+```
+docker stop vessl-k0s && docker rm vessl-k0s 
+docker run -it --rm --privileged --pid=host alpine nsenter -t 1 -m -- sh -c “rm -rfv /var/lib/k0s”
+```
+

guides/clusters/specs.md

@@ -0,0 +1,58 @@
+---
+title: Default resource specs
+version: EN
+---
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/specs/1_specs.png"
+/>
+
+Under **Resource Specs**, you can set custom resource presets that users can only select and use to launch ML workloads. You can also specify the **priority** of the defined options. For example, when you set the resource specs as above users will only be able to select the four options below.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/specs/2_resource.png"
+/>
+
+These default options can help admins optimize resource usage by (1) preventing someone from occupying an excessive number of GPUs and (2) preventing unbalanced resource requests which cause skewed resource usage. As for average users, they can simply get going without thinking and configuring the exact number of CPU cores and memories they need to request.
+
+## Step-by-step Guide
+
+Click **New resource spec** and define the following parameters.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/specs/3_add.png"
+/>
+
+* **Name** — Set a name for the preset. Use names that well represent the preset like `a100-2.mem-16.cpu-6`.
+* **Processor type** — Define the preset by the processor type, either by CPU or GPU.&#x20;
+* **CPU limit** — Enter the number of CPUs. For `a100-2.mem-16.cpu-6`, enter `6`.
+* **Memory limit** — Enter the amount of memory in GB. For `a100-2.mem-16.cpu-6`, the number would be 16.
+* **GPU type** — Specify which GPU you are using. You can get this information by using the `nvidia-smi` command on your server. In the following example, the value is `a100-sxm-80gb`.
+
+```bash
+nvidia-smi
+```
+
+```bash
+Thu Jan 19 17:44:05 2023
++-----------------------------------------------------------------------------+
+| NVIDIA-SMI 510.73.08    Driver Version: 510.73.08    CUDA Version: 11.6     |
+|-------------------------------+----------------------+----------------------+
+| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
+| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
+|                               |                      |               MIG M. |
+|===============================+======================+======================|
+|   0  <a data-footnote-ref href="#user-content-fn-1">NVIDIA A100-SXM</a>...  On   | 00000000:01:00.0 Off |                    0 |
+| N/A   40C    P0    64W / 275W |      0MiB / 81920MiB |      0%      Default |
+|                               |                      |             Disabled |
++-------------------------------+----------------------+----------------------+
+```
+
+* **GPU limit** — Enter the number of GPUs. For `gpu2.mem16.cpu6`, enter `2`. You can also place decimal values if you are using Multi-Instance GPUs (MIG).
+* **Priority** — Using different values for priority disables FIFO scheduler and assigns workloads according to priority, with lower priority being first. The example preset below always puts workloads running on `gpu-1` ahead of any other workloads.&#x20;
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/clusters/specs/4_list.png"
+/>
+
+* **Available workloads** — Select the type of workloads that can use the preset. With this, you can guide users to use 🗂️ **Experiments** by preventing them from running ️ **Workspaces** with 4 or 8 GPUs. &#x20;

guides/datasets/create.md

@@ -0,0 +1,60 @@
+---
+title: Create a new model
+version: EN
+---
+
+When you click the **NEW DATASET** under **DATASET** page, you will be asked to add new dataset either from local or external data source. You have three data provider options: VESSL, Amazon Simple Storage Service, and Google Cloud Storage.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/datasets/create/1_new.png"
+/>
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/datasets/create/2_datasets.png"
+/>
+
+<Tabs>
+  <Tab title="Managed">
+    When you select a VESSL dataset, you can upload data from the local disk. To create a VESSL dataset:
+
+    1. Enter **Dataset Name**
+    2. Click **Upload Files**
+    3. Click **Submit**
+  </Tab>
+
+  <Tab title="S3">
+    You can retrieve dataset from S3 by selecting Amazon Simple Storage Service. To create a dataset from S3
+
+    1. Enter **Dataset Name**
+    2. Enter **ARN**
+    3. Enter **Bucket Path**
+    4. Click **Create**
+  </Tab>
+
+  <Tab title="GCS">
+    You also have an option to retrieve dataset from Google Cloud Storage. To create a dataset from GCS:
+
+    1. Enter **Dataset Name**
+    2. Enter **Bucket Path**
+    3. Click **Create** button
+  </Tab>
+
+  <Tab title="Local storage">
+    If the dataset exists inside the cluster (NAS, host machine, etc.) and you want to mount it only inside the cluster, you can select Local Storage option. In this case, VESSL only stores the location of the dataset, and mounts the path when an experiment is created.
+
+    VESSL supports 3 types of local mounts
+
+    * NFS
+    * HostPath
+    * FlexVolume (e.g. [CIFS mount](tips-and-limitations.md#cifs-mount))
+
+    <img style={{ borderRadius: '0.5rem' }}
+      src="/images/datasets/create/3_nfs.png"
+    />
+
+
+    Since **VESSL does not have access to the local dataset**, you cannot browse local dataset files on VESSL.
+  </Tab>
+</Tabs>
+
+<Note>A detailed integration guide is provided on each **Create Dataset** dialog.</Note>

guides/datasets/manage.md

@@ -0,0 +1,25 @@
+---
+title: Manage models
+version: EN
+---
+
+Under Datasets, you can view the file tree of your dataset. Here, you can also upload file, create folder.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/datasets/manage/files.png"
+/>
+
+### Dataset Versioning (Enterprise only)
+
+**Dataset Version** is a specific snapshot of a dataset captured at a particular point in time. To enable this feature, you have to check `Enable Versioning` when creating dataset.
+
+Dataset Version can be created by yourself on the `VERSIONS` tab, or be automatically created when an experiment is created to provider reproducibility of the experiment. You can also choose the specific dataset version to use when creating an experiment.&#x20;
+
+<Warning>This feature is currently unavailable for AWS S3 or GCS dataset source types.</Warning>
+
+#### How it works
+
+If you enable versioning when creating a dataset, all dataset files are incrementally saved as blob. Each Version stores the mapping from blob to actual file path.
+
+Each blob is stored incrementally by hashsum - the dataset size does not increase even if dataset version is created frequently, unless the files are changed.
+

guides/datasets/overview.md

@@ -0,0 +1,15 @@
+---
+title: Overview
+version: EN
+---
+
+VESSL **dataset** is a collection of data sourced from local disks or cloud vendors such as AWS S3 and Google Cloud Storage. You can mount the registered dataset to the experiment container in runtime.
+
+### Managing Dataset on Web Console
+
+Click **DATASETS** tab to view your organization's datasets. 
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/datasets/overview/datasets.png"
+/>
+

guides/datasets/tips.md

@@ -0,0 +1,23 @@
+---
+title: Tips & Limitations
+version: EN
+---
+
+### CIFS mount
+
+VESSL providers FlexVolume storage type to support CIFS mount.
+
+1. Install [CIFS FlexVolume plugin](https://github.com/fstab/cifs). 
+2. Create `secret.yml` for CIFS mount.
+3. Fill the options in the create dataset dialog.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/datasets/tips/cifs.png"
+/>
+
+### Use other mount options not supported by VESSL
+
+By using HostPath mount, you can work around to use other mount options which are not supported by VESSL.
+
+1. Mount the storage on all host machines, in the same path. (e.g. `/mnt/s3fs-mnist-data`)
+2. Mount dataset with the HostPath option.

guides/experiments/create.md

@@ -0,0 +1,125 @@
+---
+title: Create a new experiment
+---
+
+To create an experiment, first specify a few options such as cluster, resource, image, and start command. Here is an explanation of the config options.
+
+<img style={{ borderRadius: '0.5rem' }}
+	src="/images/experiment/create/1_experiment.jpeg"
+/>
+
+### Cluster & Resource (Required) <a href="#runtime" id="runtime"></a>
+
+You can run your experiment on either VESSL's managed cluster or your custom cluster. Start by selecting a cluster.&#x20;
+
+<Tabs>
+  <Tab title="Managed Cluster">
+    Once you selected VESSL's managed cluster, you can view a list of available resources under the dropdown menu.&#x20;
+
+    <img style={{ borderRadius: '0.5rem' }}
+  	  src="/images/experiment/create/2_cluster-managed.png"
+    />
+
+
+    You also have an option to use spot instances.
+
+    Check out the full list of resource types and corresponding prices:
+  </Tab>
+
+  <Tab title="Custom Cluster">
+    Your custom cluster can be either on-premise or on-cloud. For on-premise clusters, you can specify the processor type and resource requirements. The experiment will be assigned automatically to an available node based on the input resource requirements.&#x20;
+
+    <img style={{ borderRadius: '0.5rem' }}
+	    src="/images/experiment/create/3_cluster-custom.png"
+    />
+
+  </Tab>
+</Tabs>
+
+### Distribution Mode (Optional) <a href="#image" id="image"></a>
+
+You have an option to use multi-node distributed training. The default option is single-node training.&#x20;
+
+<img style={{ borderRadius: '0.5rem' }}
+	src="/images/experiment/create/4_distributed.png"
+/>
+
+
+### Image (Required) <a href="#image" id="image"></a>
+
+Select the Docker image that the experiment container will use. You can either use a managed image provided by VESSL or your own custom image.&#x20;
+
+<Tabs>
+  <Tab title="Managed Image">
+    Managed images are pre-pulled images provided by VESSL. You can find the available image tags at VESSL's [Amazon ECR Public Gallery](https://gallery.ecr.aws/vessl/kernels)_._&#x20;
+
+    <img style={{ borderRadius: '0.5rem' }}
+    	src="/images/experiment/create/5_image-managed.png"
+    />
+  </Tab>
+
+  <Tab title="Custom Image">
+    You can pull your own custom images from either [Docker Hub](https://hub.docker.com) or [Amazon ECR](https://aws.amazon.com/ecr/).&#x20;
+
+    #### Public Images
+
+    To pull images from the public Docker registry, simply pass the image URL. The example below demonstrates pulling the official TensorFlow development GPU image from Docker Hub.&#x20;
+
+    <img style={{ borderRadius: '0.5rem' }}
+      src="/images/experiment/create/6_image-custom.png"
+    />
+
+    #### Private Images
+
+    To pull images from the private Docker registry, you should first integrate your credentials in organization settings.
+
+    Then, check the private image checkbox, fill in the image URL, and select the credential.
+
+    <img style={{ borderRadius: '0.5rem' }}
+      src="/images/experiment/create/7_image-custom.png"
+    />
+  </Tab>
+</Tabs>
+
+### Start Command (Required) <a href="#start-command" id="start-command"></a>
+
+Specify the start command in the experiment container. Write a running script with command-line arguments just as you are using a terminal. You can put multiple commands by using the `&&` command or a new line separation.&#x20;
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/experiment/create/8_command.png"
+/>
+
+### Volume (Optional)
+
+You can mount the project, dataset, and files to the experiment container.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/experiment/create/9_volume.png"
+/>
+
+
+Learn more about volume mount on the following page:
+
+### Hyperparameters
+
+You can set hyperparameters as key-value pairs. The given hyperparameters are automatically added to the container as environment variables with the given key and value. A typical experiment will include hyperparameters like `learning_rate` and `optimizer`.&#x20;
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/experiment/create/10_hyperparam.png"
+/>
+
+You can also use them at runtime by appending them to the start command as follows.
+
+```bash
+python main.py  \
+  --learning-rate $learning_rate  \
+  --optimizer $optimizer
+```
+
+### Termination Protection&#x20;
+
+Checking the termination protection option puts experiments in idle once it completes running, so you to access the container of a finished experiment.&#x20;
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/experiment/create/11_termination.png"
+/>

guides/experiments/distributed.md

@@ -0,0 +1,78 @@
+---
+title: Run distributed training jobs
+---
+
+<Note>Only the PyTorch framework is supported distributed experiment currently.</Note>
+
+### What is a distributed experiment?
+
+A **distributed experiment** is a single machine learning run on top of multi-node or multi-GPUs. The distributed experiment results are consist of logs, metrics, and artifacts for each worker which you can find under corresponding tabs.
+
+<Warning>Multi-node training is not always an optimal solution. We recommend you try several experiments with a few epochs to see if multi-node training is the correct choice for you.</Warning>
+
+#### Environment variables
+
+VESSL automatically sets the below environment variables based on the configuration.
+
+`NUM_NODES`: Number of workers
+
+`NUM_TRAINERS`: Number of GPUs per node
+
+`RANK`: The global rank of node
+
+`MASTER_ADDR`: The address of the master node service
+
+`MASTER_PORT`: The port number on the master address
+
+### Creating a distributed experiment
+
+#### Using Web Console
+
+Running a distributed experiment on the web console is similar to a single node experiment. To create a distributed experiment, you only need to specify the number of workers. Other options are the same as those of a single node experiment.
+
+#### Using CLI
+
+To run a distributed experiment using CLI, the number of nodes must be set to an integer greater than one.
+
+```bash
+vessl experiment create --worker-count 2 --framework-type pytorch
+```
+
+### Examples: Distributed CIFAR
+
+You can find the full example codes [here](https://github.com/savvihub/examples/tree/main/distributed\_cifar).
+
+#### Step 1: Prepare CIFAR-10 dataset
+
+Download the CIFAR dataset with the scripts below. and add a vessl type dataset to your organization.
+
+```bash
+wget -c --quiet https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz
+tar -xvzf cifar-10-python.tar.gz
+```
+
+Or, you can simply add an AWS S3 type dataset to your organization with the following public bucket URI.
+
+```
+s3://savvihub-public-apne2/cifar-10
+```
+
+#### Step 2: Create a distributed experiment
+
+To run a distributed experiment we recommend to use [`torch.distributed.launch`](https://pytorch.org/docs/stable/distributed.html) package. The example start command that runs on two nodes and one GPU for each node is as follows.
+
+```
+python -m torch.distributed.launch  \
+  --nnodes=$NUM_NODES  \
+  --nproc_per_node=$NUM_TRAINERS  \
+  --node_rank=$RANK \
+  --master_addr=$MASTER_ADDR \
+  --master_port=$MASTER_PORT \
+  examples/distributed_cifar/pytorch/main.py
+```
+
+VESSL will automatically set environment variables of `--node_rank`, `--master_addr`, `--master_port`, `--nproc_per_node` and `--nnodes`.
+
+### Files
+
+In a distributed experiment, all workers share an output storage. Please be aware that files can be overrided by other workers when you use same output path.

guides/experiments/local.md

@@ -0,0 +1,17 @@
+---
+title: Run local experiments
+---
+
+# Local Experiments
+
+On VESSL, you can also monitor experiments that you have run locally. This can easily be done by adding a few lines to your code.
+
+Start monitoring your experiment using [`vessl.init`](../../api-reference/python-sdk/utils/vessl.init.md) . This will launch a new experiment under your project. You can view the experiment output under [**LOGS**](experiment-results.md#logs), just like you would in a VESSL-managed experiment. Your local environment's system metrics are also monitored and can be viewed under [**PLOTS**](experiment-results.md#plots).
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/experiment/local/metrics.png"
+/>
+
+In a VESSL-managed experiment, files under the output volume are saved by default. In a local experiment, you can use [`vessl.upload`](../../api-reference/python-sdk/utils/vessl.upload.md) to upload any output files. You can view these files under [**FILES**](experiment-results.md#files).
+
+By default, VESSL will stop monitoring your local experiment when your program exits. If you wish to stop it manually, you can use [`vessl.finish`](../../api-reference/python-sdk/utils/vessl.finish.md).

guides/experiments/manage.md

@@ -0,0 +1,62 @@
+---
+title: Manage experiments
+---
+
+Under the experiments page, you can view the details of each experiment such as experiment status and logs. Here, you can also terminate or reproduce experiments. 
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/experiment/manage/1_actions.png"
+/>
+
+### Experiment Status
+
+| Type          | Description                                                                                                           |
+| ------------- | --------------------------------------------------------------------------------------------------------------------- |
+| **Pending**   | An experiment is created with a pending status until the experiment node is ready. (VESSL-managed experiment only)    |
+| **Running**   | The experiment is running.                                                                                            |
+| **Completed** | The experiment has successfully finished (exited in 0).                                                               |
+| **Idle**      | The experiment is completed but still approachable due to the termination protection. (VESSL-managed experiment only) |
+| **Failed**    | The experiment has unsuccessfully finished.                                                                           |
+
+<Note>VESSL-managed experiments' status depends on its [Kubernetes pod lifecycle](https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/).</Note>
+
+<Note>To track the progress of your running experiment, use [`vessl.progress`](../../api-reference/python-sdk/utils/vessl.progress.md). VESSL will calculate the remaining running time, which you can view by hovering over the status mark.</Note>
+
+### Experiment Terminal
+
+If you activate the **TERMINAL**, you can SSH access the experiment container through a web terminal. You can directly attach the SSH terminal to the experiment process or open a new experiment shell.&#x20;
+
+#### Attaching to the experiment process
+
+By attaching SSH directly to the experiment process, you can view the same logs displayed on the Web Console under the **LOGS** tab. You can take various commands such as interrupting the process.&#x20;
+
+#### Creating a new shell
+
+Opening a new SSH terminal allows you to navigate the experiment container to see where the datasets or projects are mounted.
+
+### Reproducing Experiments
+
+One of the great features of VESSL is that all the experiments can be reproduced. VESSL keeps track of all experiment configurations including the dataset snapshot and source code version. and allows you to reproduce any experiment with just a single click. You can reproduce experiments either on the Web Console or via VESSL CLI. &#x20;
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/experiment/manage/2_reproduce.png"
+/>
+
+### Terminating Experiments
+
+You can stop running the experiment and delete the experiment pod.
+
+### Unpushed Changes
+
+A warning titled **UNPUSHED CHANGES** will appear in the experiment details if you run an experiment through CLI without pushing the local changes to GitHub. To solve this issue, download the `.patch` file containing `git diff` and apply it by running the following commands.&#x20;
+
+```
+# Change directory to your project
+cd path/to/project
+
+# Checkout your recent commit with SHA
+git checkout YOUR_RECENT_COMMIT_SHA
+
+# Apply .patch file to the commit
+git apply your_git_diff.patch
+```

guides/experiments/monitor.md

@@ -0,0 +1,53 @@
+---
+title: Monitor experiment results
+---
+
+### Experiment Summary
+
+Under **SUMMARY**, you can view all the experiment configurations such as environment variables, quick reproduce via CLI, Docker image, and resource specification.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/experiment/monitor/1_summary.png"
+/>
+
+### Logs
+
+Under **LOGS**, you can monitor the logs from the experiment Docker container including status updates and `print()` statements.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/experiment/monitor/2_logs.png"
+/>
+
+### Plots
+
+<Note>You need to use VESSL's Python SDK to view metrics or multimedia files.&#x20;</Note>
+
+Under **PLOTS**, you can view key metrics for your experiments such as accuracy and loss. You can also filter out the outliers by checking **ignore outlier** box and controlling the **smoothing** of the curves.&#x20;
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/experiment/monitor/3_plots.png"
+/>
+
+#### Multimedia
+
+You can also view images. You can configure the number of displayed images using VESSL's Python SDK.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/experiment/monitor/4_media.png"
+/>
+
+#### System Metrics
+
+You can monitor system metrics such as CPU, GPU, memory, disk, and network usage.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/experiment/monitor/5_metrics.png"
+/>
+
+### Files
+
+Under **FILES**, you can navigate and download the output and input files. You can also do this using VESSL Client CLI.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/experiment/monitor/6_files.png"
+/>

guides/experiments/overview.md

@@ -0,0 +1,13 @@
+---
+title: Overview
+---
+
+An **experiment** is a single machine learning run in a project with a specific dataset. The experiment results consist of logs, metrics, and artifacts, which you can find under corresponding tabs.
+
+### Managing Experiments on Web Console
+
+You can find a list of experiments under each project page. You delve into the details of the experiment by clicking the name of the experiment. 
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/experiment/overview/experiments.png"
+/>

guides/get-started/gpu-notebook.md

@@ -0,0 +1,160 @@
+---
+title: GPU-accelerated Notebook
+description: Launch a Jupyter Notebook server with an SSH connection
+icon: "circle-1"
+version: EN
+---
+
+This example deploys a Jupyter Notebook server. You will also learn how you can connect to the server on VS Code or an IDE of your choice.
+
+<CardGroup cols={2}>
+  <Card icon="sparkles" title="Try it on VESSL Hub"  href="https://vessl.ai/hub/jupyter-notebook">
+    Try out the Quickstart example with a single click on VESSL Hub.
+  </Card>
+
+  <Card icon="github" title="See the final code" href="https://github.com/vessl-ai/hub-model/">
+    See the completed YAML file and final code for this example. 
+  </Card>
+</CardGroup>
+
+## What you will do
+
+<img
+  style={{ borderRadius: '0.5rem' }}
+  src="/images/get-started/quickstart-title.png"
+/>
+
+- Launch a GPU-accelerated interactive workload
+- Set up a Jupyter Notebook
+- Use SSH to connect to the workload
+
+
+## Writing the YAML 
+
+Let's fill in the `notebook.yml` file.
+
+<Steps titleSize="h3">
+  <Step title="Spin up a workload">
+    Let's repeat the steps from [Quickstart](quickstart.mdx) and define the compute resource and runtime environment for our workload. Again, we will use the L4 instance from our managed cloud and the latest PyTorch container from NVIDIA NGC. 
+
+    ```yaml
+    name: Jupyter notebook
+    description: A Jupyter Notebook server with an SSH connection
+    resources:
+      cluster: vessl-gcp-oregon
+      preset: gpu-l4-small
+    image: quay.io/vessl-ai/torch:2.1.0-cuda12.2-r3
+    ```
+  </Step>
+
+  <Step title="Configure an interactive run">
+    By default, workloads launched with VESSL Run are batch jobs like the one we launched in our Quickstart example. On the other hand, interactive runs are essentially virtual machines running on GPUs for live interaction with your models and datasets.
+
+    You can enable this with the `interactive` key, followed by the `jupyter` key. Interactive runs come with a default field for idle culler which automatically shuts down user notebook servers when they have not been used for a certain period. 
+    
+    `max_runtime` works with `idle_timeout` as an additional measure to prevent resource overuse
+
+    ```yaml
+    name: Jupyter notebook
+    description: A Jupyter Notebook server with an SSH connection
+    resources:
+      cluster: vessl-gcp-oregon
+      preset: gpu-l4-small
+    image: quay.io/vessl-ai/torch:2.1.0-cuda12.2-r3
+    interactive:
+      jupyter:
+        idle_timeout: 120m
+      max_runtime: 24h
+    ```
+  </Step> 
+</Steps>
+
+## Running the workload
+
+Now that we have a completed YAML, we can once again run the workload with `vessl run`.
+
+```
+vessl run create -f notebook.yml
+```
+
+<img
+style={{ borderRadius: '0.5rem' }}
+src="/images/get-started/quickstart-notebook.png"
+/>
+
+Running the command will verify your YAML and show you the current status of the workload. Click the output link in your terminal to see the full details and realtime logs of the Run on the web. Click Jupyter under Connect to launch a notebook. 
+
+<img
+style={{ borderRadius: '0.5rem' }}
+src="/images/get-started/quickstart-workspace.jpeg"
+/>
+
+<img
+style={{ borderRadius: '0.5rem' }}
+src="/images/get-started/quickstart-jupyter.jpeg"
+/>
+
+## Create an SSH connection
+
+An interactive run is essentially a GPU-accelerated workload on a cloud with a port and an endpoint for live interactions. This means you can access the remote workload using SSH.
+
+1. First, get an SSH key pair. 
+    ```
+    ssh-keygen -t ed25519 -C "vesslai"
+    ```
+    <img
+    style={{ borderRadius: '0.5rem' }}
+    src="/images/get-started/gpu-notebook_ssh-keygen.png"
+    />
+
+2. Add the generated key to your account.
+    ```
+    vessl ssh-key add
+    ```
+    <img
+    style={{ borderRadius: '0.5rem' }}
+    src="/images/get-started/gpu-notebook_ssh-add.png"
+    />
+
+3. Connect via SSH.
+    Use the workload address from the Run Summary page to connect. You are ready to use [VS Code](https://code.visualstudio.com/docs/remote/ssh) or an IDE of your choice for remote development. 
+    
+    <img
+    style={{ borderRadius: '0.5rem' }}
+    src="/images/get-started/gpu-notebook_ssh-info.jpeg"
+    />
+
+    ```
+    ssh -p 22 [email protected] 
+    ```
+
+
+## Tips & tricks
+
+Keep in mind that GPUs are fully dedicated to a notebook server --and therefore consume VSSL credits-- even when you are not running compute-intensive cells. To optimize GPU usage, use tools like [nbconvert](https://nbconvert.readthedocs.io/en/latest/usage.html#executable-script) to convert the notebook into a Python file or package it as a Python container and run it as a batch job.
+
+You can also mount volumes to interactive workloads by defining `import` and reference files or datasets from your notebook.
+
+## Using our web interface
+
+You can repeat the same process on the web. Head over to your [Organization](https://vessl.ai), select a project, and create a New run. 
+
+<iframe 
+  src="https://scribehow.com/embed/GPU-accelerated_notebook__KXkgSEfXS_2wPYbjRCDpRw?skipIntro=true&removeLogo=true" 
+  width="100%" height="640" allowfullscreen frameborder="0"
+  style={{ borderRadius: '0.5rem' }} >
+</iframe>
+
+## What's next?
+
+Next, let's see how you use our interactive workloads to host a web app on the cloud using tools like Streamlit and Gradio. 
+
+<CardGroup cols={2}>
+  <Card title="Stable Diffusion Playground" href="get-started/stable-diffusion">
+    Launch an interactive web application for Stable Diffusion
+  </Card>
+
+  <Card title="Mistral-7B Playground" href="get-started/stable-diffusion">
+    Launch a text-generation Streamlit app powered with Mistral-7B
+  </Card>
+</CardGroup>

guides/get-started/llama2.md

@@ -0,0 +1,191 @@
+---
+title: Llama 2 Fine-tuning
+description: Fine-tune Llama2-7B with instruction datasets
+icon: "circle-3"
+version: EN
+---
+
+This example fine-tunes Llama2-7B with a code instruction dataset, illustrating how VESSL AI offloads the infrastructural challenges of large-scale AI workloads and help you train multi-billion-parameter models in hours, not weeks. 
+
+This is the most compute-intensive workload yet but you will see how VESSL AI's efficient training stack enables you to seamlessly scale and execute multi-node training. For a more in-depth guide, refer to our [blog post](https://blog.vessl.ai/ai-infrastructure-llm). 
+
+<CardGroup cols={2}>
+  <Card icon="sparkles" title="Try it on VESSL Hub"  href="https://vessl.ai/hub/ssd-1b-inference">
+    Try out the Quickstart example with a single click on VESSL Hub.
+  </Card>
+
+  <Card icon="github" title="See the final code" href="https://github.com/vessl-ai/hub-model/tree/main/SSD-1B">
+    See the completed YAML file and final code for this example. 
+  </Card>
+</CardGroup>
+
+## What you will do
+
+<img
+  style={{ borderRadius: '0.5rem' }}
+  src="/images/get-started/llama2-title.png"
+/>
+
+- Fine-tune an LLM with zero-to-minimum setup
+- Mount a custom dataset
+- Store and export model artifacts
+
+## Writing the YAML
+
+Let's fill in the `llama2_fine-tuning.yml` file.
+
+<Steps titleSize="h3">
+  <Step title="Spin up a training job">
+    Let's set spin up an instance. Nothing new here. 
+
+		```yaml
+    name: Llama2-7B fine-tuning 
+    description: Fine-tune Llama2-7B with instruction datasets
+    resources:
+    	cluster: vessl-gcp-oregon
+    	preset: gpu-l4-small
+    image: quay.io/vessl-ai/torch:2.1.0-cuda12.2-r3
+		```
+	</Step>
+
+	<Step title="Mount the code, modal, and dataset">
+	Here, in addition to our GitHub repo and Hugging Face model, we are also mounting a Hugging Face dataset. 
+	
+	As with our HF model, mountint data is as simple as referencing the URL beginnging with the `hf://` scheme -- this goes the same for other cloud storages as well, `s3://` for Amazon S3 for example.	
+
+	```yaml
+	name: llama2-finetuning
+	description: Fine-tune Llama2-7B with instruction datasetst
+	resources:
+		cluster: vessl-gcp-oregon
+		preset: gpu-l4-small
+	image: quay.io/vessl-ai/torch:2.1.0-cuda12.2-r3
+	import:
+		/model/: hf://huggingface.co/VESSL/llama2
+		/code/:
+			git:
+				url: https://github.com/vessl-ai/hub-model
+				ref: main
+  /dataset/: hf://huggingface.co/datasets/VESSL/code_instructions_small_alpaca
+	```
+	</Step>
+
+	<Step title="Write the run commands">
+	Now that we have the three pillars of model development mounted on our remote workload, we are ready to define the run command. Let's install additiona Python dependencies and run `finetuning.py` -- which calls for our HF model and datasets in the `config.yaml` file. 
+
+	```yaml
+	name: llama2-finetuning
+	description: Fine-tune Llama2-7B with instruction datasetst
+	resources:
+		cluster: vessl-gcp-oregon
+		preset: gpu-l4-small
+	image: quay.io/vessl-ai/torch:2.1.0-cuda12.2-r3
+	import:
+		/model/: hf://huggingface.co/VESSL/llama2
+		/code/:
+			git:
+				url: https://github.com/vessl-ai/hub-model
+				ref: main
+		/dataset/: hf://huggingface.co/datasets/VESSL/code_instructions_small_alpaca
+	run:
+		- command: |-
+				pip install -r requirements.txt
+				python finetuning.py
+			workdir: /code/llama2-finetuning
+	```
+	</Step>
+
+	<Step title="Export a model artifact">
+		You can keep track of model checkpoints by dedicating an `export` volume to the workload. After training is finished, trained models are uploaded to the `artifact` folder as model checkpoints.
+
+		```yaml
+		name: llama2-finetuning
+		description: Fine-tune Llama2-7B with instruction datasetst
+		resources:
+			cluster: vessl-gcp-oregon
+			preset: gpu-l4-small
+		image: quay.io/vessl-ai/torch:2.1.0-cuda12.2-r3
+		import:
+			/model/: hf://huggingface.co/VESSL/llama2
+			/code/:
+				git:
+					url: https://github.com/vessl-ai/hub-model
+					ref: main
+			/dataset/: hf://huggingface.co/datasets/VESSL/code_instructions_small_alpaca
+		run:
+			- command: |-
+					pip install -r requirements.txt
+					python finetuning.py
+				workdir: /code/llama2-finetuning
+		export:
+  		/artifacts/: vessl-artifact://
+	```
+	</Step>
+</Steps>
+
+## Running the workload
+
+Once the workload is completed, you can follow the link in the terminal to get the output files including the model checkpoints under Files.
+
+```
+vessl run create -f llama2_fine-tuning.yml
+```
+
+<img
+  style={{ borderRadius: '0.5rem' }}
+  src="/images/get-started/llama2-artifacts.jpeg"
+/>
+
+## Behind the scenes 
+
+With VESSL AI, you can launch a full-scale LLM fine-tuning workload on any cloud, at any scale, without worrying about these underlying system backends. 
+
+* **Model checkpointing** — VESSL AI stores .pt files to mounted volumes or model registry and ensures seamless checkpointing of fine-tuning progress.
+* **GPU failovers** — VESSL AI can autonomously detect GPU failures, recover failed containers, and automatically re-assign workload to other GPUs.
+* **Spot instances** — Spot instance on VESSL AI works with model checkpointing and export volumes, saving and resuming the progress of interrupted workloads safely.
+* **Distributed training** — VESSL AI comes with native support for PyTorch `DistributedDataParallel` and simplifies the process for setting up multi-cluster, multi-node distributed training.
+* **Autoscaling** — As more GPUs are released from other tasks, you can dedicate more GPUs to fine-tuning workloads. You can do this on VESSL AI by adding the following to your existing fine-tuning YAML.
+
+## Tips & tricks
+
+In addition to the model checkpoints, you can track key metrics and parameters with `vessl.log` Python SDK. Here's a snippet from [finetuning.py](https://github.com/vessl-ai/hub-model/blob/a74e87564d0775482fe6c56ff811bd8a9821f809/llama2-finetuning/finetuning.py#L97-L109).
+
+```python
+class VesslLogCallback(TrainerCallback):
+    def on_log(self, args, state, control, logs=None, **kwargs):
+        if "eval_loss" in logs.keys():
+            payload = {
+                "eval_loss": logs["eval_loss"],
+            }
+            vessl.log(step=state.global_step, payload=payload)
+        elif "loss" in logs.keys():
+            payload = {
+                "train_loss": logs["loss"],
+                "learning_rate": logs["learning_rate"],
+            }
+            vessl.log(step=state.global_step, payload=payload)
+```
+
+## Using our web interface
+
+You can repeat the same process on the web. Head over to your [Organization](https://vessl.ai), select a project, and create a New run. 
+
+<iframe 
+  src="https://scribehow.com/embed/Llama_2_Fine-tuning_with_VESSL_AI__3UJWTqUgTguq1vYrjNu9MA?skipIntro=true&removeLogo=true"
+  width="100%" height="640" allowfullscreen frameborder="0"
+  style={{ borderRadius: '0.5rem' }} >
+</iframe>
+
+## What's next?
+
+We shared ho you can use VESSL AI to go from a simple Python container to a full-scale AI workload. We hope these guides give you a glimpse of what you can achieve with VESSL AI. For more resources, follow along our example models or use casese. 
+
+<CardGroup cols={2}>
+  <Card icon="wand" title="Explore more models" href="https://vessl.ai/hub">
+    See VESSL AI in action with the latest open-source models and our example Runs.
+  </Card>
+
+  <Card icon="rectangles-mixed" title="Explore more use casees" href="use-cases/">
+    See the top use casese of VESSL AI from experiment tracking to cluster management.
+  </Card>
+</CardGroup>

guides/get-started/overview.md

@@ -0,0 +1,109 @@
+---
+title: Overview
+description: Launch and scale AI workloads without the hassle of managing infrastructure
+icon: "hand-wave"
+version: EN
+---
+
+## VESSL AI -- Purpose-built cloud for AI
+
+VESSL AI provides a unified interface for training and deploying AI models on the cloud. Simply define your GPU resource and pinpoint to your code & dataset. VESSL AI does the orchestration & heavy lifting for you:
+1. Create a GPU-accelerated container with the right Docker Image.
+2. Mount your code and dataset from GitHub, Hugging Face, Amazon S3, and more.
+3. Launcs the workload on our fully managed GPU cloud.
+
+<CardGroup cols={2}>
+  <Card title="One any cloud, at any scale" href="#">
+    Instantly scale workloads across multiple clouds. 
+    <br/>
+    <img className="rounded-md" src="/images/get-started/overview-cloud.png" />
+  </Card>
+
+  <Card title="Streamlined interface" href="#">
+    Launch any AI workloads with a unified YAML definition.
+    <br/>
+    <img className="rounded-md" src="/images/get-started/overview-yaml.png" />
+  </Card>
+  
+  <Card title="End-to-end coverage" href="#">
+    A single platform for fine-tuning to deployment.
+    <br/>
+    <img className="rounded-md" src="/images/get-started/overview-pipeline.png" />
+  </Card>
+
+  <Card title="A centralized compute platform" href="#">
+    Optimize GPU usage and save up to 80% in cloud.
+    <br/>
+    <img className="rounded-md" src="/images/get-started/overview-gpu.png" />
+  </Card>
+</CardGroup>
+
+## What can you do?
+
+- Run compute-intensive AI workloads remotely within seconds.
+- Fine-tune LLMs with distributed training and auto-failover with zero-to-minimum setup. 
+- Scale training and inference workloads horizontally.
+- Deploy an interactive web applicaiton for your model.
+- Serve your AI models as web endpoints.
+
+## How to get started
+
+Head over to [vessl.ai](https://vessl.ai) and sign up for a free account. No `docker build` or `kubectl get`.
+1. Create your account at [vessl.ai](https://vessl.ai) and get $30 in free GPU credits.
+2. Install our Python package — `pip install vessl`.
+3. Follow our [Quickstart](/get-started/quickstart) guide or try out our example models at [VESSL Hub](https://vessl.ai/hub). 
+
+## How does it work?
+
+VESSL AI abstracts the obscure infrastructure and complex backends inherent to launching AI workloads into a simple YAML file, so you don't have to mess with AWS, Kubernetes, Docker, or more. Here's an example that launches a web app for Stable Diffusion.
+
+```yaml
+resources:
+  cluster: vessl-gcp-oregon
+  preset: gpu-l4-small
+image: quay.io/vessl-ai/torch:2.1.0-cuda12.2-r3
+import:
+  /code/:
+    git:
+      url: https://github.com/vessl-ai/hub-model
+      ref: main
+  /model/: hf://huggingface.co/VESSL/SSD-1B
+run:
+  - command: |-
+      pip install -r requirements.txt
+      streamlit run ssd_1b_streamlit.py --server.port=80
+    workdir: /code/SSD-1B
+interactive:
+  max_runtime: 24h
+  jupyter:
+    idle_timeout: 120m
+ports:
+  - name: streamlit
+    type: http
+    port: 80
+
+```
+
+With every YAML file, you are creating a VESSL Run. VESSL Run is an atomic unit of VESSL AI, a single unit of Kubernetes-backed AI workload. You can use our YAML definition as you progress throughout the AI lifecycle from checkpointing models for fine-tuning to exposing ports for inference.
+
+## What's next?
+
+See VESSL AI in action with our examples Runs and pre-configured open-source models.
+
+<CardGroup cols={2}>
+  <Card title="Quickstart – Hello, world!"  href="get-started/quickstart">
+    Fine-tune Llama2-7B with a code instructions dataset. 
+  </Card>
+
+  <Card title="GPU-accelerated notebook" href="get-started/gpu-notebook">
+    Launch a GPU-accelerated Streamlit app of Mistral 7B.
+  </Card>
+  
+  <Card title="SSD-1B Playground" href="get-started/stable-diffusion">
+    Interactive playground of a lighter and faster version for Stable Diffusion XL.
+  </Card>
+
+  <Card title="Llama2-7B Fine-tuning" href="get-started/llama2">
+    Translate audio snippets into text on a Streamlit playground.
+  </Card>
+</CardGroup>

guides/get-started/quickstart.md

@@ -0,0 +1,192 @@
+---
+title: Quickstart – Hello, world!
+description: Launch a barebone GPU-accelerated workload
+icon: "circle-play"
+version: EN
+---
+
+This quickstart deploys a barebone GPU-accelerated workload, a Python container that prints `Hello, world!`. It illustrates the basic components of a single run and how you can deploy one.
+
+<CardGroup cols={2}>
+  <Card icon="sparkles" title="Try it on VESSL Hub"  href="https://vessl.ai/hub/create-your-own">
+    Try out the Quickstart example with a single click on VESSL Hub.
+  </Card>
+
+  <Card icon="github" title="See the final code" href="https://github.com/vessl-ai/hub-model/tree/main/quickstart">
+    See the completed YAML file and final code for this example. 
+  </Card>
+</CardGroup>
+
+## What you will do
+
+<img
+  style={{ borderRadius: '0.5rem' }}
+  src="/images/get-started/quickstart-title.png"
+/>
+
+- Launch a GPU-acclerated workload
+- Set up a runtime for your model
+- Mount a Git codebase
+- Run a simple command
+
+## Installation & setup
+
+After creating a free account at [vessl.ai](https://vessl.ai), install our Python package and get an API authentication. Set your primary Organization and Project for your account and let's get going.
+
+```bash
+pip install --upgrade vessl
+vessl configure
+```
+
+## Writing the YAML
+
+Launching a workload on VESSL AI begins with writing a YAML file. Our quickstart YAML is in four parts:
+
+- Compute resource -- typically in terms of GPUs -- this is defined under `resources`
+- Runtime environment that points to a Docker Image -- this is defined under `image`
+- Input & output for code, dataset, and others defined under `import` & `export`
+- Run commands executed inside the workload as defined under `run`
+
+Let's start by creating `quickstart.yml` and define the key-value pairs one by one.
+
+<Steps titleSize="h3">
+  <Step title="Spin up a compute instance">
+    `resources` defines the hardware specs you will use for your run. Here's an example that uses our managed cloud to launch an L4 instance. 
+    
+    You can see the full list of compute options and their string values for `preset` under [Resources](/resources/price). Later, you will be able to add and launch workloads on your private cloud or on-premise clusters simply by changing the value for `cluster`. 
+
+    ```yaml
+    resources:
+      cluster: vessl-gcp-oregon
+      preset: gpu-l4-small
+    ```
+  </Step>
+
+  <Step title="Configure a runtime environment">
+    VESSL AI uses Docker images to define a runtime. We provide a set of base images as a starting point but you can also bring your own custom Docker images by referencing hosted images on Docker Hub or Red Hat Quay.
+    
+    You can find the full list of Images and the dependencies for the latest build [here](https://quay.io/repository/vessl-ai/kernels?tab=tags&tag=py39-202310120824). Here, we'll use the latest go-to PyTorch container from NVIDIA NGC. 
+
+    ```yaml
+    resources:
+      cluster: vessl-gcp-oregon
+      preset: gpu-l4-small
+    image: quay.io/vessl-ai/torch:2.1.0-cuda12.2-r3
+    ```
+  </Step>
+
+  <Step title="Mount a GitHub repository">
+    Under `import`, you can mount models, codebases, and datasets from sources like GitHub, Hugging Face, Amazon S3, and more. 
+
+    In this example, we are mounting a GitHub repo to `/code/` folder in our container. You can switch to different versions of code by changing `ref` to specific branches like `dev`. 
+
+    ```yaml
+    resources:
+      cluster: vessl-gcp-oregon
+      preset: gpu-l4-small
+    image: quay.io/vessl-ai/torch:2.1.0-cuda12.2-r3
+    import:
+      /code/:
+        git:
+          url: https://github.com/vessl-ai/hub-model
+          ref: main
+    ```
+  </Step>
+
+  <Step title="Write a run command">
+    Now that we defined the specifications of the compute resource and the runtime environment for our workload, let's run [`main.py`](https://github.com/vessl-ai/hub-model/blob/main/quickstart/main.py). 
+
+    We can do this by defining `command` under `run` and specifying the working directory `workdir`.
+
+    ```yaml
+    resources:
+      cluster: vessl-gcp-oregon
+      preset: gpu-l4-small
+    image: quay.io/vessl-ai/torch:2.1.0-cuda12.2-r3
+    import:
+      /code/:
+        git: 
+          url: https://github.com/vessl-ai/hub-model
+          ref: main
+    run:
+      - command: |
+          python main.py
+        workdir: /code/quickstart
+    ```
+  </Step>
+
+  <Step title="Add metadata">
+    Finally, let's polish up by giving our Run a name and description. Here's the completed `.yml`:
+
+    ```yaml
+    name: Quickstart
+    description: A barebone GPU-accelerated workload
+    resources:
+      cluster: vessl-gcp-oregon
+      preset: gpu-l4-small
+    image: quay.io/vessl-ai/torch:2.1.0-cuda12.2-r3
+    import:
+      /code/:
+        git: 
+          url: https://github.com/vessl-ai/hub-model
+          ref: main
+    run:
+      - command: |
+          python main.py
+        workdir: /code/quickstart
+    ```
+  </Step>
+</Steps>
+
+## Running the workload
+
+Now that we have a completed YAML, we can run the workload with `vessl run`.
+
+```
+vessl run create -f quickstart.yml
+```
+
+<img
+  style={{ borderRadius: '0.5rem' }}
+  src="/images/get-started/quickstart-run.png"
+/>
+
+Running the command will verify your YAML and show you the current status of the workload. Click the output link in your terminal to see full details and a realtime logs of the Run on the web, including the result of the run command. 
+
+<img
+  style={{ borderRadius: '0.5rem' }}
+  src="/images/get-started/quickstart-result.jpeg"
+/>
+
+## Behind the scenes
+
+When you `vessl run`, VESSL AI performs the following as defined in `quickstart.yml`:
+
+1. Launch an empty Python container on the cloud with 1 NVIDIA L4 Tensor Core GPU.
+2. Configure runtime with CUDA compute-capable PyTorch 22.09.
+3. Mount a GitHub repo and set the working directory. 
+3. Execute `main.py` and print `Hello, world!`.
+
+## Using our web interface
+
+You can repeat the same process on the web. Head over to your [Organization](https://vessl.ai), select a project, and create a New run. 
+
+<iframe 
+  src="https://scribehow.com/embed/Quickstart__Hello_world__BzwSynUuQI-0R3mMGwJzHw?skipIntro=true&removeLogo=true" 
+  width="100%" height="640" allowfullscreen frameborder="0"
+  style={{ borderRadius: '0.5rem' }} >
+</iframe>
+
+## What's next?
+
+Now that you've run a barebone workload, continue with our guide to launch a Jupyter server and host a web app.
+
+<CardGroup cols={2}>
+  <Card title="GPU-accelerated notebook" href="get-started/gpu-notebook">
+    Launch a Jupyter Notebook server with an SSH connection
+  </Card>
+
+  <Card title="SSD-1B Playground" href="get-started/stable-diffusion">
+    Launch an interactive web application for Stable Diffusion
+  </Card>
+</CardGroup>

guides/get-started/stable-diffusion.md

@@ -0,0 +1,180 @@
+---
+title: Stable Diffusion Playground
+description: Launch an interactive web app for Stable Diffusion
+icon: "circle-2"
+version: EN
+---
+
+This example deploys a simple web app for Stable Diffusion. You will learn how you can set up an interactive workload for inference -- mounting models from Hugging Face and opening up a port for user inputs. For a more in-depth guide, refer to our [blog post](https://blog.vessl.ai/thin-plate-spline-motion-model-for-image-animation). 
+
+<CardGroup cols={2}>
+  <Card icon="sparkles" title="Try it on VESSL Hub"  href="https://vessl.ai/hub/ssd-1b-inference">
+    Try out the Quickstart example with a single click on VESSL Hub.
+  </Card>
+
+  <Card icon="github" title="See the final code" href="https://github.com/vessl-ai/hub-model/tree/main/SSD-1B">
+    See the completed YAML file and final code for this example. 
+  </Card>
+</CardGroup>
+
+## What you will do
+
+<img
+  style={{ borderRadius: '0.5rem' }}
+  src="/images/get-started/ssd-title.png"
+/>
+
+- Host a GPU-accelerated web app built with [Streamlit](https://streamlit.io/) 
+- Mount model checkpoints from [Hugging Face](https://huggingface.co/)
+- Open up a port to an interactive workload for inference
+
+## Writing the YAML 
+
+Let's fill in the `stable-diffusion.yml` file.
+
+<Steps titleSize="h3">
+  <Step title="Spin up an interactive workload">
+    We already learned how you can launch an interactive workload in our [previous](/get-started/gpu-notebook) guide. Let's copy & paste the YAML we wrote for `notebook.yml`.
+
+    ```yaml
+    name: Stable Diffusion Playground
+    description: An interactive web app for Stable Diffusion
+    resources:
+      cluster: vessl-gcp-oregon
+      preset: gpu-l4-small
+    image: quay.io/vessl-ai/torch:2.1.0-cuda12.2-r3
+    interactive:
+      jupyter:
+        idle_timeout: 120m
+      max_runtime: 24h
+    ```
+  </Step>
+
+  <Step title="Configure an interactive run">
+    Let's mount a [GitHub repo](https://github.com/vessl-ai/hub-model/tree/main/SSD-1B) and import a model checkpoint from Hugging Face. We already learned how you can mount a codebase from our [Quickstart](/get-started/quickstart) guide.  
+    
+    VESSL AI comes with a native integration with Hugging Face so you can import models and datasets simply by referencing the link to the Hugging Face repository. Under `import`, let's create a working directory `/model/` and import the [model](https://huggingface.co/VESSL/SSD-1B/tree/main). 
+
+    ```yaml
+    name: Stable Diffusion Playground
+    description: An interactive web app for Stable Diffusion
+    resources:
+      cluster: vessl-gcp-oregon
+      preset: gpu-l4-small
+    image: quay.io/vessl-ai/torch:2.1.0-cuda12.2-r3
+		import:
+			/code/:
+				git:
+					url: https://github.com/vessl-ai/hub-model
+					ref: main
+			/model/: hf://huggingface.co/VESSL/SSD-1B
+    interactive:
+      jupyter:
+        idle_timeout: 120m
+      max_runtime: 24h
+    ```
+  </Step> 
+
+  <Step title="Open up a port for inference">
+
+    The `ports` key expose the workload ports where VESSL AI listens for HTTP requests. This means you will be able to interact with the remote workload -- sending input query and receiving an generated image through port `80` in this case. 
+
+    ```yaml
+    name: Stable Diffusion Playground
+    description: An interactive web app for Stable Diffusion
+    resources:
+      cluster: vessl-gcp-oregon
+      preset: gpu-l4-small
+    image: quay.io/vessl-ai/torch:2.1.0-cuda12.2-r3
+		import:
+			/code/:
+				git:
+					url: https://github.com/vessl-ai/hub-model
+					ref: main
+			/model/: hf://huggingface.co/VESSL/SSD-1B
+    interactive:
+      jupyter:
+        idle_timeout: 120m
+      max_runtime: 24h
+    ports:
+      - name: streamlit
+        type: http
+        port: 80
+    ```
+  </Step>
+
+    <Step title="Write the run commands">
+
+    Let's install additional Python dependencies with [`requirements.txt`](https://github.com/vessl-ai/hub-model/blob/main/SSD-1B/requirements.txt) and finally run our app [`ssd_1b_streamlit.py`](https://github.com/vessl-ai/hub-model/blob/main/SSD-1B/ssd_1b_streamlit.py). 
+    
+    Here, we see how our Streamlit app is using the port we created previously with the `--server.port=80` flag. Through the port, the app receives a user input and generates an image with the Hugging Face model we mounted on `/model/`. 
+
+    ```yaml
+    name: Stable Diffusion Playground
+    description: An interactive web app for Stable Diffusion
+    resources:
+      cluster: vessl-gcp-oregon
+      preset: gpu-l4-small
+    image: quay.io/vessl-ai/torch:2.1.0-cuda12.2-r3
+    import:
+      /code/:
+        git:
+          url: https://github.com/vessl-ai/hub-model
+          ref: main
+      /model/: hf://huggingface.co/VESSL/SSD-1B
+    run:
+      - command: |-
+        pip install -r requirements.txt
+        streamlit run ssd_1b_streamlit.py --server.port=80
+        workdir: /code/SSD-1B
+    interactive:
+      max_runtime: 24h
+      jupyter:
+        idle_timeout: 120m
+    ports:
+      - name: streamlit
+        type: http
+        port: 80
+    ```
+  </Step>
+</Steps>
+
+## Running the app
+
+Once again, running the workload will guide you to the workload Summary page. 
+
+```
+vessl run create -f stable-diffusion.yml
+```
+
+Under ENDPOINTS, click the `streamlit` link to launch the app. 
+
+<img
+  style={{ borderRadius: '0.5rem' }}
+  src="/images/get-started/ssd-summary.jpeg"
+/>
+
+<img
+  style={{ borderRadius: '0.5rem' }}
+  src="/images/get-started/ssd-streamlit.jpeg"
+/>
+
+## Using our web interface
+
+You can repeat the same process on the web. Head over to your [Organization](https://vessl.ai), select a project, and create a New run. 
+
+<iframe 
+  src="https://scribehow.com/embed/Stable_Diffusion_Playground__D9ujQM9ZQtGz_Aj9oiyXSg?skipIntro=true&removeLogo=true"
+  width="100%" height="640" allowfullscreen frameborder="0"
+  style={{ borderRadius: '0.5rem' }} >
+</iframe>
+
+## What's next?
+
+See how VESSL AI takes care of the infrastructural challenges of fine-tuning a large language model with a custom dataset. 
+
+<CardGroup cols={2}>
+  <Card title="Llama 2 Fine-tuing" href="get-started/llama2">
+    Launch an interactive web application for Stable Diffusion
+  </Card>
+</CardGroup>

guides/models/create.md

@@ -0,0 +1,46 @@
+---
+title: Create a new model
+version: EN
+---
+
+You can add a model to a model registry by selecting a previous experiment or by uploading local checkpoint files. To create a model, create a model repository first under **MODELS**. We recommend following our naming conventions to improve project maintainability.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/models/create/1_button.png"
+/>
+
+### Creating a model from experiment
+
+<Note>Only `completed` experiments can be sourced to create models.</Note>
+
+There are two entry points to create a model in the repository.
+
+#### 1. Create a model from the model repository page
+
+You can create models on the model repository page. Click the `New Model` button, set the model description and tag, find the experiment you want, and choose the desired directory you want to put in the model.&#x20;
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/models/create/2_new.png"
+/>
+
+#### 2. Create a model from the experiment detail page
+
+If you find an experiment that you want to create a model from its output files, you can create one by clicking the `Create Model` button under the `Actions` button on the experiment detail page. Select the model repository and click`SELECT` on the dialog.&#x20;
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/models/create/3_create.png"
+/>
+
+Then, set the model description and tag, and choose the desired directory among the output files of the experiment on the model create page. You can include or exclude specific directories in the output files checkbox section.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/models/create/4_select.png"
+/>
+
+### Creating a model from local files
+
+Uploading the checkpoint files on your local machine to VESSL is another way to utilize the model registry feature. If you select the `model from local` type when selecting **Source** in `Models>Model Repository>New Model`, you can create a model by uploading a local file.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/models/create/5_upload.png"
+/>

guides/models/deploy.md

@@ -0,0 +1,114 @@
+---
+title: Deploy models
+version: EN
+---
+
+You can use VESSL to quickly deploy your models into production for use from external applications via APIs. You can register it via the SDK and deploy it in the Web UI in one click.
+
+### Register a model using the SDK
+
+A model file cannot be deployed on its own - we need to provide instructions on how to setup the server, handle requests, and send responses. This step is called registering a model.
+
+There are two ways you can register a model. One is to use an existing model - that is, a VESSL model exists and a model file is stored in it. The other is to train a model from scratch and register it. The two options are further explained below.
+
+### 1. Register an existing model
+
+In most cases, you will have already trained model and have the file ready, either through [VESSL's experiment](../experiment/creating-an-experiment.md#creating-an-experiment) or in your local environment. After [creating a model](creating-a-model.md#creating-a-model), you will need to register it using the SDK. The below example shows how you can do so.
+
+```python
+import torch
+import torch.nn as nn
+from io import BytesIO
+
+import vessl
+
+class Net(nn.Module):
+    # Define model
+
+class MyRunner(vessl.RunnerBase):
+    @staticmethod
+    def load_model(props, artifacts):
+        model = Net()
+        model.load_state_dict(torch.load("model.pt"))
+        model.eval()
+        return model
+
+    @staticmethod
+    def preprocess_data(data):
+        return torch.load(BytesIO(data))
+
+    @staticmethod
+    def predict(model, data):
+        with torch.no_grad():
+            return model(data).argmax(dim=1, keepdim=False)
+
+    @staticmethod
+    def postprocess_data(data):
+        return {"result": data.item()}
+
+vessl.configure()
+vessl.register_model(
+    repository_name="my-repository",
+    model_number=1,
+    runner_cls=MyRunner,
+    requirements=["torch"],
+)
+```
+
+First, we redefine the layers of the torch model. (This is assuming we only saved the `state_dict`, or the model's parameters. If you saved the model's layers as well, you do not have to redefine the layers.)
+
+Then, we define a `MyRunner` which inherits from `vessl.RunnerBase`, which provides instructions for how to serve our model. You can read more about each method [here](../../api-reference/python-sdk/auto-generated/serving.md#runnerbase).
+
+Finally, we register the model using `vessl.register_model`. We specify the repository name and number, pass `MyRunner` as the runner class we will use for serving, and list any requirements to install.
+
+After executing the script, you should see that two files have been generated: `vessl.manifest.yaml`, which stores metadata and `vessl.runner.pkl`, which stores the runner binary. Your model has been registered and is ready for serving.
+
+### 2. Register a model from scratch
+
+In some cases, you will want to train the model and register it within one script. You can use `vessl.register_model` to register a new model as well:
+
+```python
+# Your training code
+# model.fit()
+
+vessl.configure()
+vessl.register_model(
+    repository_name="my-repository",
+    model_number=None,
+    runner_cls=MyRunner,
+    model_instance=model,
+    requirements=["tensorflow"],
+)
+```
+
+After executing the script, you should see that three files have been generated: `vessl.manifest.yaml`, which stores metadata, `vessl.runner.pkl`, which stores the runner binary, and `vessl.model.pkl`, which stores the trained model. Your model has been registered and is ready for serving.
+
+#### PyTorch models
+
+If you are using PyTorch, there is an easier way to register your model. You only need to optionally define `preprocess_data` and `postprocess_data` - the other methods are autogenerated.
+
+```python
+# Your training code
+# for epoch in range(epochs):
+#     train(model, epoch)
+
+vessl.configure()
+vessl.register_torch_model(
+    repository_name="my-model",
+    model_number=1,
+    model_instance=model,
+    requirements=["torch"],
+)
+```
+
+<Note>Check out the documentation [`vessl.register_model`](../../api-reference/python-sdk/auto-generated/serving.md#registermodel) and [`vessl.register_torch_model`](../../api-reference/python-sdk/auto-generated/serving.md#registertorchmodel).</Note>
+
+### Deploy a registered model
+
+You can deploy your model with [VESSL Serve](../../user-guide/serve/README.md)
+
+Once you deployed your model with VESSL Serve, you can make predictions using your service by sending HTTP requests to the service endpoint. As in the example request, use the POST method and pass your authentication token as a header. Pass your input data in the format you've specified in your runner when you registered the model. You should receive a response with the prediction.
+
+```
+curl -X POST -H "X-AUTH-KEY:[YOUR-AUTHENTICATION-TOKEN]" -d [YOUR-DATA] https://service-zl067zvrmf69-service-8000.uw2-dev-cluster.savvihub.com
+```

guides/models/manage.md

@@ -0,0 +1,24 @@
+---
+title: Manage models
+version: EN
+---
+
+When you enter each model page, you can see the metadata and files tabs. Under actions, you can run an experiment with the model, and also edit or delete the model.
+
+### Model status
+
+| Type              | Description                                                                                            |
+| ----------------- | ------------------------------------------------------------------------------------------------------ |
+| **Pending**       | A model is created with a pending status until the model volume files are fully created.               |
+| **Ready**         | A model is ready to use.                                                                               |
+| **Error**         | The model has unsuccessfully created.                                                                  |
+| **Deploying**     | The model is being deployed for model serving.                                                         |
+| **In Production** | The model has been deployed for model serving. (Note that the actual server instance may have failed.) |
+
+### Running Experiments
+
+You can create an experiment with a model volume mounted on the model page. It can be used to evaluate the model. The generated experiments are added to the model's related experiments.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/models/manage/run.png"
+/>

guides/models/overview.md

@@ -0,0 +1,14 @@
+---
+title: Overview
+version: EN
+---
+
+A **model registry** is a centralized space for managing model versions. Model governance and security are strengthened by securing an independent space separated from code or dataset. You can collaborate with organization members by monitoring model status and performance.
+
+### Managing model on Web Console
+
+To view and manage model repositories and a list of versioned models, click **MODELS** on the web console.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/models/overview/overview.png"
+/>

guides/organization/billing.md

@@ -0,0 +1,16 @@
+---
+title: Manage billing
+version: EN
+---
+
+# Billing Information
+
+You can check your payment information and credit balance on the billing page. 
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/organization/billing/billing.png"
+/>
+
+### How is usage calculated?
+
+VESSL charges based on compute, storage, and network usage. Check the our pricing table for each resource type.&#x20;

guides/organization/create.md

@@ -0,0 +1,18 @@
+---
+title: Create a new Organization
+version: EN
+---
+
+Once you signed up, you can create or add an organization by clicking **ADD ORGANIZATION** on the organizations page. You can always come back to this page by clicking the VESSL logo on the top left corner. 
+
+![](<../../../assets/image (120).png>)
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/organization/create/add.png"
+/>
+
+**Name** your organization and choose the default **region** for the organization. For a detailed guide to specifying regions, refer to [AWS Regions and Zones](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html) page.
+
+![](<../../../assets/image (164).png>)
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/organization/create/create.png"
+/>

guides/organization/integrations.md

@@ -0,0 +1,40 @@
+---
+title: Add integrations
+version: EN
+---
+
+### Integrating your service to VESSL
+
+You can integrate various services to VESSL using AWS, Docker, and SSH Keys. The integrated AWS and Docker credentials are used to manage private docker images, whereas the SSH Keys are used for authorized keys for SSH connection.
+
+### AWS Credentials 
+
+To integrate your AWS account, you need an AWS access key associated with your [IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html). You can create this key by following this [guide from AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id\_credentials\_access-keys.html). Once you have your key, click **ADD INTEGRATION** and fill in the form. 
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/organization/integrations/1_aws.png"
+/>
+
+You can integrate multiple AWS credentials to your organization. You can also revoke your credentials by simply clicking the trash button on the right.&#x20;
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/organization/integrations/2_aws-cred.png"
+/>
+
+<Note>If you want to pull images from [ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html) , make sure to provide the [ECR pull policy granted account.](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policy-examples.html)</Note>
+
+### Docker Credentials
+
+To integrate your Docker account, click **ADD INTEGRATION** and fill in your Docker credentials.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/organization/integrations/3_docker.png"
+/>
+
+### GitHub
+
+To integrate your GitHub account, click ADD INTEGRATION. Grant repository access to VESSL App in the repository access section and click save in GitHub.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/organization/integrations/4_github.png"
+/>

guides/organization/members.md

@@ -0,0 +1,12 @@
+---
+title: Add members
+version: EN
+---
+
+### Collaborate with your teammates
+
+Invite your teammates to your organization by sending an invitation mails. If you add an email address on the **Member** list, VESSL will send an invitation links. Your teammates can sign up by clicking this link. 
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/organization/members/add.png"
+/>

guides/organization/notification.md

@@ -0,0 +1,21 @@
+---
+title: Create a new Organization
+version: EN
+---
+
+You can receive either a **Slack** or **Email Notification** for your experiments. VESSL will notify your teammates when your experiment starts running, fails to run, or is completed. 
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/organization/notification/add.png"
+/>
+
+To add Slack Notifications,&#x20;
+
+1. Click **Add to Slack**.
+2. Specify Slack Workplace and Channel.
+3. Click Allow.
+
+To add Email Notifications,&#x20;
+
+1. Type your email address.
+2. Click **ADD**.

guides/organization/overview.md

@@ -0,0 +1,18 @@
+---
+title: Overview
+version: EN
+---
+
+**Organization** is a shared working environment where you can create projects, datasets, experiments, and services. Once you signed-up, you can create an organization with a specified region and invite teammates to collaborate. 
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/organization/overview/1_view.png"
+/>
+
+### Managing Organization on Web Console
+
+Once you entered an organization, you can navigate to other organizations by clicking your profile on the top right corder. If you wish to create a new organization, go back to the organization page by clicking the VESSL logo.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/organization/overview/2_manage.png"
+/>

guides/project/create.md

@@ -0,0 +1,30 @@
+---
+title: Create a new project
+version: EN
+---
+
+# Creating a Project
+
+To create a project, click **NEW PROJECT** on the project page. 
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/projects/create/1_new.png"
+/>
+
+
+### Basic information
+
+On the project create page, you should specify the name and the description of the project. Note that the project name should be unique within the organization.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/projects/create/2_info.png"
+/>
+
+### Connect Project Repository
+
+If you want to connect the GitHub repository to the project, choose the GitHub account and the repository here. If you haven't install VESSL GitHub App, integrate your GitHub account in [`Organization Settings > Add Integrations`](../organization/organization-settings/add-integrations.md#github).
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/projects/create/3_repo.png"
+/>
+

guides/project/overview.md

@@ -0,0 +1,14 @@
+---
+title: Overview
+version: EN
+---
+
+Machine learning projects require both code and datasets. VESSL **project** is a conceptual space where you can easily manage codes and datasets as a basic element within the organization. You can share projects with organization members to collaborate on a machine learning project.
+
+### Managing Projects on Web Console
+
+You can find the Project tab under the organization menu. Click the tab to view the full list of ongoing projects.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/projects/overview/web.png"
+/>

guides/project/repo-dataset.md

@@ -0,0 +1,45 @@
+---
+title: Project-level repo & datasets
+version: EN
+---
+
+Project provides a way to connect code repositories and datasets. VESSL provides the following with project repositories & project datasets 
+
+* Download codes & datasets when a experiment / a sweep is created
+* Track versions and file diffs between experiments
+
+### Add Project Repository
+
+Project Repository can be configured in creating project and project settings. 
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/projects/repo-dataset/1_settings.png"
+/>
+
+Add project repository and select github repositories in the dialog. If you have not integrated github with VESSL, you should integrate github first in the organization settings (link will be given in the add dialog.)
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/projects/repo-dataset/2_repo.png"
+/>
+
+### Add Project Dataset
+
+Project dataset can be configured in the same way as the project repository. Unlike project repository, project dataset is allowed to specify the mount path in the experiment/sweep.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/projects/repo-dataset/3_tree.png"
+/>
+
+Once after you connected repositories and datasets, they are mounted by default when creating an experiment / a sweep.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/projects/repo-dataset/4_result.png"
+/>
+
+#### Connect cluster-scoped local dataset ([docs](../dataset/adding-new-datasets.md))
+
+You can connect the cluster-scoped dataset to project dataset. If you use different cluster from the cluster specified in the dataset during creating an experiment, an error may occur. To resolve it, you need to choose the cluster specified in the dataset or continue without the certain dataset.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/projects/repo-dataset/5_dataset.png"
+/>

guides/project/summary.md

@@ -0,0 +1,86 @@
+---
+title: Project summary
+version: EN
+---
+
+**Project Overview** provides a bird's-eye view of the progress of your machine learning projects. On the project overview dashboard, you can manage and track key information about your project:
+
+* **Key Metrics**: Keep track of essential evaluation metrics of your experiments such as accuracy, loss, and MSE.
+* **Sample Media**: Log images, audio, and other media from your experiment and explore your model's prediction results to compare your experiments visually.
+* **Starred Experiments**: Star and keep track of meaningful experiments. 
+* **Project Notes**: Make a note of important information about your project and share it with your teammates – similar to README.md of Git codebase. 
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/projects/summary/1_summary.png"
+/>
+
+## Key Metrics
+
+VESSL AI automatically marks metrics of best-performing experiments as key metrics. You can also manually bookmark key metrics and keep track of your model's meaningful evaluation metrics.&#x20;
+
+To add or remove Key Metrics
+
+1. Click the settings icon on top of the Key Metrics card.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/projects/summary/2_metrics.png"
+/>
+
+2\. Select **up to 4 metrics** and choose whether your goal is to minimize or maximize the target value.&#x20;
+
+* If you select **Minimize**, an experiment with the smallest target value will be updated to the key metric charts.
+* If you select **Maximize**, an experiment with the greatest target value will be updated to the key metric chart.&#x20;
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/projects/summary/3_select.png"
+/>
+
+## Sample Media
+
+You can log images or audio clips generated from your experiment to explore your model's prediction results and make visual (or auditory) comparisons.&#x20;
+
+<Note>For more information about logging media during your experiment, refer to [`vessl.log`](../../api-reference/python-sdk/utils/vessl.log/) in our Python SDK.&#x20;</Note>
+
+To see the media file, select an experiment and specify the media type using the dropdown menu on the upper right corner of Sample Media card.&#x20;
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/projects/summary/4_audio.png"
+/>
+
+## Starred Experiment
+
+You can mark important experiments as **Starred Experiments** to keep track of meaningful achievements in the project. Starred Experiments displayed with the tags and key metrics.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/projects/summary/5_starred.png"
+/>
+
+To star or unstar experiments
+
+1. Go to the experiment tracking dashboard
+2. Select experiments
+3. Click 'Star' or 'Unstar' on the dropdown menu.&#x20;
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/projects/summary/6_experiments.png"
+/>
+
+You can also star or unstar experiments on the experiment summary page.&#x20;
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/projects/summary/7_star.png"
+/>
+
+## Project Notes
+
+**Project Notes** is a place for noting and sharing important information about the project together with your team. It works like README.md of your Git codebase.
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/projects/summary/8_note.png"
+/>
+
+To modify project note, click the settings icon on top of Project Notes card. You will be given a markdown editor to update your notes.&#x20;
+
+<img style={{ borderRadius: '0.5rem' }}
+  src="/images/projects/summary/9_note-edit.png"
+/>

guides/resources/changelog.md

@@ -0,0 +1,38 @@
+---
+title: Changelog
+description: See what's new in VESSL AI
+icon: megaphone
+version: EN
+---
+
+## January 31, 2024
+
+<img
+  style={{ borderRadius: '0.5rem' }}
+  src="/images/changelog/jan.png"
+/>
+
+### New Get started guide
+
+We've updated our documenation with a new get started guide. The new guide covers everything from product overview to the latest use cases of our product in Gen AI & LLM.
+
+Follow along our new guide [here](https://run-docs.vessl.ai/docs/en/get-started/quickstart). 
+
+### New & Improved
+
+- Added a new managed cloud option built on Google Cloud 
+- Renamed our default managed Docker images to `torch:2.1.0-cuda12.2-r3`
+
+## December 28, 2023
+
+### Announcing VESSL Hub
+
+<img
+  style={{ borderRadius: '0.5rem' }}
+  src="/images/changelog/dec.png"
+/>
+
+VESSL Hub is a collection of one-click recipes for the latest open-source models like Llama2, Mistral 7B, and StableDiffusion. Built on our fullstack AI infrastructure, Hub provides the easiest way to explore and deploy models.
+ 
+Fine-tune and deploy the latest models on our production-grade fullstack cloud infrastructure with just a single click. 
+Read about the release on our [blog](https://blog.vessl.ai/vessl-hub) or try it out now at [vessl.ai/hub](https://vessl.ai/hub).