diff --git a/website/.gitignore b/website/.gitignore
index cc87aecd0..2f17ad179 100644
--- a/website/.gitignore
+++ b/website/.gitignore
@@ -10,3 +10,5 @@ resources/
 .ipynb_checkpoints
 #
 .hugo_build.lock
+
+.DS_Store
\ No newline at end of file
diff --git a/website/config.toml b/website/config.toml
index 3c8769785..5f204d872 100644
--- a/website/config.toml
+++ b/website/config.toml
@@ -131,7 +131,7 @@ ignoreFiles = []
       # If you want this feature, but occasionally need to remove the "Feedback" section from a single page,
       # add "hide_feedback: true" to the page's front matter.
       [params.ui.feedback]
-        enable = true
+        enable = false
         # The responses that the user sees after clicking "yes" (the page was helpful) or "no" (the page was not helpful).
         yes = 'Glad to hear it! Please <a href="https://github.com/GoogleCloudPlatform/ai-on-gke/issues">tell us how we can improve</a>.'
         no = 'Sorry to hear that. Please <a href="https://github.com/GoogleCloudPlatform/ai-on-gke/issues">tell us how we can improve</a>.'
diff --git a/website/content/en/docs/Applications/Jupyter/_index.md b/website/content/en/docs/Applications/Jupyter/_index.md
new file mode 100644
index 000000000..6e3350e5d
--- /dev/null
+++ b/website/content/en/docs/Applications/Jupyter/_index.md
@@ -0,0 +1,201 @@
+---
+title: "Jupyterhub on GKE"
+linkTitle: "Jupyter"
+weight: 20
+---
+
+This repository contains a Terraform template for running [JupyterHub](https://jupyter.org/hub) on Google Kubernetes Engine.
+
+We've also included some example notebooks (`applications/ray/example_notebooks`), including one that serves a GPT-J-6B model with Ray AIR (see
+[here](https://docs.ray.io/en/latest/train/examples/deepspeed/gptj_deepspeed_fine_tuning.html) for the original notebook). To run these, follow the instructions at
+`applications/ray/README.md` to install a Ray cluster.
+
+
+This module deploys the following resources, once per user:
+* JupyterHub deployment
+* User namespace
+* Kubernetes service accounts
+
+## Prerequisites
+
+1. GCP Project with following APIs enabled
+    - container.googleapis.com
+    - gkehub.googleapis.com (required when using private clusters with Anthos Connect Gateway)
+    - iap.googleapis.com (required when using authentication with Identity Aware Proxy)
+
+2. A functional GKE cluster.
+    - To create a new standard or autopilot cluster, follow the instructions in [`infrastructure/README.md`](https://github.com/GoogleCloudPlatform/ai-on-gke/blob/main/infrastructure/README.md)
+    - Alternatively, you can set the `create_cluster` variable to true in `workloads.tfvars` to provision a new GKE cluster. This will default to creating a GKE Autopilot cluster; if you want to provision a standard cluster you must also set `autopilot_cluster` to false.
+
+3. This module is configured to use Identity Aware Proxy (IAP) as default authentication method for JupyterHub. It expects the brand & the OAuth consent configured in your org. You can check the details here: [OAuth consent screen](https://console.cloud.google.com/apis/credentials/consent)
+
+This code can also perform auto brand creation. Please check the details [below](#auto-brand-creation-and-iap-enablement)
+
+4. Preinstall the following on your computer:
+    * Terraform
+    * Gcloud CLI
+
+JupyterHub server can use either local storage or GCS to store notebooks and other artifcts. 
+To use GCS, create a bucket with your username. For example, when authenticating with IAP as username@domain.com, ensure your bucket name is `gcsfuse-<username>`
+
+## Installation
+
+### Configure Inputs
+
+1. If needed, clone the repo
+```
+ git clone https://github.com/GoogleCloudPlatform/ai-on-gke
+ cd ai-on-gke/applications/jupyter
+ ```
+
+2. Edit `workloads.tfvars` with your GCP settings. The `namespace` that you specify will become a K8s namespace for your JupyterHub services. For more information about what the variables do visit [here](https://github.com/GoogleCloudPlatform/ai-on-gke/blob/main/applications/jupyter/variable_definitions.md)
+
+**Important Note:**
+If using this with the Ray module (`applications/ray/`), it is recommended to use the same k8s namespace
+for both i.e. set this to the same namespace as `applications/ray/workloads.tfvars`.
+
+| Variable                    | Description                                                                                                    | Required |
+|-----------------------------|----------------------------------------------------------------------------------------------------------------|:--------:|
+| project_id                  | GCP Project Id                                                                                                 | Yes      |
+| cluster_name                | GKE Cluster Name                                                                                               | Yes      |
+| cluster_location            | GCP Region                                                                                                     | Yes      |
+| cluster_membership_id       | Fleet membership name for GKE cluster. <br /> Required when using private clusters with Anthos Connect Gateway | |
+| namespace                   | The namespace that JupyterHub and rest of the other resources will be installed in.                            | Yes      |
+| gcs_bucket                  | GCS bucket to be used for Jupyter storage                                                                      |       |
+| create_service_account      | Create service accounts used for Workload Identity mapping                                                     | Yes      |
+| gcp_and_k8s_service_account | GCP service account used for Workload Identity mapping and k8s sa attached with workload                       | Yes      |
+
+For variables under `JupyterHub with IAP`, please see the section below 
+
+### Secure endpoint with IAP
+
+> **_NOTE:_** To secure the Jupyter endpoint, this module enables IAP by default. It is _strongly recommended_ to keep this configuration. If you wish to disable it, do the following: set the `add_auth` flag to false in the `workloads.tf` file.
+
+3. If you already have a brand setup for your project, use the existing values to fill in the variable values in workloads.tf
+
+4. If you have not enabled the IAP API before or created a Brand for your project, please follow these steps:
+
+    - Navigate to the `brand` [page](https://console.cloud.google.com/apis/credentials/consent) to create your own brand:
+
+    See [here](#auto-brand-creation-and-iap-enablement) for more information about how to create a brand automatically. Please note, auto brand creation enables the application only for [internal (within the org) users](https://cloud.google.com/iap/docs/programmatic-oauth-clients#branding). This can be switched to external users from the [consent](https://console.cloud.google.com/apis/credentials/consent) screen.
+
+See the example `.tfvars` files under `/applications/jupyter` for different brand/IAP configurations.
+
+| Variable                 | Description                | Default Value | Required |
+| ------------------------ |--------------------------- |:-------------:|:--------:|
+| add_auth                 | Enable IAP on JupyterHub   | true          | Yes      |
+| brand                    | Name of the brand used for creating IAP OAuth clients. Only one is allowed per project. View existing brands: `gcloud iap oauth-brands list`. Leave it empty to create a new brand.  Uses [support_email](#support_email) |           |       |
+| support_email            | Support email assocated with the [brand](#brand). Used as a point of contact for consent for the ["OAuth Consent" in Cloud Console](https://console.cloud.google.com/apis/credentials/consent). Optional field if `brand` is empty.   |           |       |
+| default_backend_service  | default_backend_service   |           |       |
+| service_name             | Name of the Backend Service that gets created when enabling IAP.   |           |       |
+| url_domain_addr          | Provided by the user if they want to bring their own URL/Domain. Used by the IAP resources if filled in. Filling this in will disable automatic global IP reservation. Must also fill in [url_domain_name](#url_domain_name).   |           |       |
+| url_domain_name          | This variable will only be used if [url_domain_addr](#url_domain_addr) is provided. It is the name associated with the domain provided by the user. Since we are using Ingress, it will require the `kubernetes.io/ingress.global-static-ip-name` annotation along with the name associated.   |           |       |
+| client_id                | Client ID of an [OAuth 2.0 Client ID](https://console.cloud.google.com/apis/credentials) created by the user for enabling IAP. You must also input the [client_secret](#client_secret). If this variable is unset, the template will create an OAuth client for you - in this case, you must ensure the associated [brand](https://console.cloud.google.com/apis/credentials/consent) is `Internal` i.e. only principals within the organization can access the application.   |           |       |
+| client_secret            | Client Secret associated with the [client_id](#client_id). This variable will only be used when the client id is filled out.     |           |       |
+| members_allowlist        | Comma seperated values for users to be allowed access through IAP. Example values: `user:username@domain.com`  |      |       |
+
+
+### Install
+
+> **_NOTE:_** Terraform keeps state metadata in a local file called `terraform.tfstate`. Deleting the file may cause some resources to not be cleaned up correctly even if you delete the cluster. We suggest using `terraform destroy` before reapplying/reinstalling.
+
+5. Ensure your gcloud application default credentials are in place. 
+```
+gcloud auth application-default login
+```
+
+6. Run `terraform init`
+
+7. Run `terraform apply --var-file=./workloads.tfvars`. It can take upto 5 minutes on standard clusters & upto 10 minutes on AutoPilot clusters. Due to some IAP limitations, this is expected to fail with an error `Error retrieving IAM policy for iap webbackendservice` which will be resolved by the next step.
+
+8. If using authentication with IAP (i.e. `add_auth = true`), rerun terraform apply again. This is needed to configure Jupyter with IAP correctly.
+
+    * Verify the backend service for IAP has been created (takes 5-10 mins) with `gcloud compute backend-services list`
+        - Should have `jupyter-proxy-public` in the name eg.: `k8s1-63da503a-jupyter-proxy-public-80-74043627`.
+    * Run `terraform apply --var-file=./workloads.tfvars`
+
+## Using JupyterHub
+
+### If Auth with IAP is disabled
+
+1. Extract the randomly generated password for JupyterHub login
+
+```
+terraform output jupyterhub_password
+```
+
+2. Setup port forwarding for the frontend: `kubectl port-forward service/proxy-public -n <namespace> 8081:80 &`, and open `localhost:8081` in a browser.
+
+### If Auth with IAP is enabled
+
+1. Note down the value for the `domain` from the terraform output section: `terraform output domain`. You can open this in a browser & login with your credentials. Alternatively, domain value for Jupyter Ingress can be found on [Certificate Manager](https://console.cloud.google.com/security/ccm/list/lbCertificates) page.
+
+2. Ensure the managed cert for the domain has finished provisioning: `kubectl get managedcertificate -n <namespace>`.
+This can take 10 - 20 minutes. You may see an SSL error if you try to hit the domain when the cert isn't `Active`.
+
+3. Open the external IP in a browser and login. If you get an access error, see the `Setup Access` section below.
+Please note there may be some propagation delay after adding IAP principals (5-10 mins).
+
+4. Select profile and open a Jupyter Notebook
+
+> **_NOTE:_** Domain specific managed certificate may take some time to finish provisioning. This can take between 10-15 minutes. The browser may not display the login page correctly until the certificate provisioning is complete.
+
+### Setup Access
+
+In order for users to login to JupyterHub via IAP, their access needs to be configured. To allow access for users/groups: 
+
+1. Navigate to the [GCP IAP Cloud Console](https://console.cloud.google.com/security/iap) and select your backend-service for `<namespace>/proxy-public`.
+
+2. Click on `Add Principal`, insert the username / group name and select under `Cloud IAP` with role `IAP-secured Web App User`. Once presmission is granted, these users / groups can login to JupyterHub with IAP. Please note there may be some propagation delay after adding IAP principals (5-10 mins).
+
+## Persistent Storage
+
+JupyterHub is configured to provide 2 choices for storage:
+
+1. Default JupyterHub Storage - `pd.csi.storage.gke.io` with reclaim policy `Delete`
+
+2. GCSFuse - `gcsfuse.csi.storage.gke.io` uses GCS Buckets and require users to pre-create buckets with name format `gcsfuse-{username}`
+
+For more information about Persistent storage and the available options, visit [here](https://github.com/GoogleCloudPlatform/ai-on-gke/blob/main/applications/jupyter/storage.md)
+
+## Running GPT-J-6B
+
+This example is adapted from Ray AIR's examples [here](https://docs.ray.io/en/latest/train/examples/deepspeed/gptj_deepspeed_fine_tuning.html).
+
+1. Open the `gpt-j-online.ipynb` notebook under `ai-on-gke/applications/ray/example_notebooks`.
+
+2. Open a terminal in the Jupyter session and install Ray AIR:
+
+    ```cmd
+    pip install ray[air]
+    ```
+
+3. Run through the notebook cells. You can change the prompt in the last cell:
+
+    ```jupyter
+    prompt = (
+        ## Input your own prompt here
+    )
+    ```
+
+4. This should output a generated text response.
+
+## Auto Brand creation and IAP enablement
+
+**IMPORTANT** If you enable automatic brand creation, only `Internal` brand will be created, allowing only the users under the same org as the project to access the application.
+Make sure [Policy for Restrict Load Balancer Creation Based on Load Balancer Types](https://cloud.google.com/load-balancing/docs/org-policy-constraints) allows EXTERNAL_HTTP_HTTPS.
+
+Ensure that the following variables within `workloads.tfvars` are set:
+
+* enable_iap_service - Enables the IAP service API. Leave as false if IAP is enabled before.
+* brand - creates a brand for the project. Only one is currently allowed per project. Leave it empty to create a new brand
+* support_email - used by brand, required field.
+* **IMPORTANT** client_id and client_secret - If your brand is `external`, you must provide your own client_id and client_secret. If your brand is `internal`, you can choose to leave the variable as is and allow terraform to create one for you.
+* if you do bring your own OAuth client, you must add to the `Authorized redirect URIs` Field:  `https://iap.googleapis.com/v1/oauth/clientIds/<client ID>:handleRedirect`
+
+**Note:**
+This module uses `<ip>.nip.io` as the domain name with a global static ipv4 address that is configured automatically. Optionaly you can also use a custom doamin & existing ingress ip address in the `workloads.tfvars` file.
+
+## Additional Information
+
+For more information about JupyterHub profiles and the preset profiles visit [here](https://github.com/GoogleCloudPlatform/ai-on-gke/blob/main/applications/jupyter/profiles.md)
diff --git a/website/content/en/docs/Applications/Rag/_index.md b/website/content/en/docs/Applications/Rag/_index.md
new file mode 100644
index 000000000..9beb3c6d8
--- /dev/null
+++ b/website/content/en/docs/Applications/Rag/_index.md
@@ -0,0 +1,246 @@
+---
+title: "Rag on GKE"
+linkTitle: "Rag"
+weight: 15
+---
+
+This is a sample to deploy a Retrieval Augmented Generation (RAG) application on GKE. 
+
+The latest recommended release is branch release-1.1.
+
+# What is RAG?
+
+[RAG](https://cloud.google.com/blog/products/ai-machine-learning/rag-with-databases-on-google-cloud) is a popular approach for boosting the accuracy of LLM responses, particularly for domain specific or private data sets.
+
+RAG uses a semantically searchable knowledge base (like vector search) to retrieve relevant snippets for a given prompt to provide additional context to the LLM. Augmenting the knowledge base with additional data is typically cheaper than fine tuning and is more scalable when incorporating current events and other rapidly changing data spaces.
+
+### RAG on GKE Architecture
+1. A GKE service endpoint serving [Hugging Face TGI inference](https://huggingface.co/docs/text-generation-inference/en/index) using `mistral-7b`.
+2. [Cloud SQL `pgvector` instance](https://github.com/pgvector/pgvector) with vector embeddings generated from an input dataset.
+3. A [Ray](https://docs.ray.io/en/latest/ray-overview/getting-started.html) cluster running on GKE that runs jobs to generate embeddings and populate the vector DB.
+5. A [Jupyter](https://docs.jupyter.org/en/latest/) notebook running on GKE that reads the dataset using GCS fuse driver integrations and runs a Ray job to populate the vector DB.
+3. A front end chat interface running on GKE that prompts the inference server with context from the vector DB.
+
+This tutorial walks you through installing the RAG infrastructure in a GCP project, generating vector embeddings for a sample [Kaggle Netflix shows](https://www.kaggle.com/datasets/shivamb/netflix-shows) dataset and prompting the LLM with context.
+
+# Prerequisites
+
+### Install tooling (required)
+
+Install the following on your computer:
+* [Kubectl](https://kubernetes.io/docs/tasks/tools/#kubectl)
+* [Terraform](https://developer.hashicorp.com/terraform/tutorials/aws-get-started/install-cli)
+* [Helm](https://helm.sh/docs/intro/install/)
+* [Gcloud](https://cloud.google.com/sdk/docs/install)
+
+### Bring your own cluster (optional)
+
+By default, this tutorial creates a cluster on your behalf. We highly recommend following the default settings.
+
+If you prefer to manage your own cluster, set `create_cluster = false` and make sure the `network_name` is set to your cluster's network in the [Installation section](#installation). Creating a long-running cluster may be better for development, allowing you to iterate on Terraform components without recreating the cluster every time.
+
+Use gcloud to create a GKE Autopilot cluster. Note that RAG requires the latest Autopilot features, available on the latest versions of 1.28 and 1.29.
+
+```
+gcloud container clusters create-auto rag-cluster \
+  --location us-central1 \
+  --cluster-version 1.28
+```
+
+### Bring your own VPC (optional)
+
+By default, this tutorial creates a new network on your behalf with [Private Service Connect](https://cloud.google.com/vpc/docs/private-service-connect) already enabled. We highly recommend following the default settings.
+
+If you prefer to use your own VPC, set `create_network = false` in the in the [Installation section](#installation). This also requires enabling [Private Service Connect](https://cloud.google.com/vpc/docs/private-service-connect) for your VPC. Without Private Service Connect, the RAG components cannot connect to the vector DB:
+
+1. [Create an IP allocation](https://cloud.google.com/vpc/docs/configure-private-services-access#procedure)
+
+2. [Create a private connection](https://cloud.google.com/vpc/docs/configure-private-services-access#creating-connection).
+
+# Installation
+
+This section sets up the RAG infrastructure in your GCP project using Terraform.
+
+**NOTE:** Terraform keeps state metadata in a local file called `terraform.tfstate`. Deleting the file may cause some resources to not be cleaned up correctly even if you delete the cluster. We suggest using `terraform destroy` before reapplying/reinstalling.
+
+1. `cd ai-on-gke/applications/rag`
+
+2. Edit `workloads.tfvars` to set your project ID, location, cluster name, and GCS bucket name. Ensure the `gcs_bucket` name is globally unique (add a random suffix). Optionally, make the following changes:
+    * (Recommended) [Enable authenticated access](#configure-authenticated-access-via-iap-recommended) for JupyterHub, frontend chat and Ray dashboard services.
+    * (Optional) Set a custom `kubernetes_namespace` where all k8s resources will be created.
+    * (Optional) Set `autopilot_cluster = false` to deploy using GKE Standard.
+    * (Optional) Set `create_cluster = false` if you are bringing your own cluster. If using a GKE Standard cluster, ensure it has an L4 nodepool with autoscaling and node autoprovisioning enabled. You can simplify setup by following the Terraform instructions in [`infrastructure/README.md`](https://github.com/GoogleCloudPlatform/ai-on-gke/blob/main/infrastructure/README.md).
+    * (Optional) Set `create_network = false` if you are bringing your own VPC. Ensure your VPC has Private Service Connect enabled as described above.
+
+3. Run `terraform init`
+
+4. Run `terraform apply --var-file workloads.tfvars`
+
+# Generate vector embeddings for the dataset
+
+This section generates the vector embeddings for your input dataset. Currently, the default dataset is [Netflix shows](https://www.kaggle.com/datasets/shivamb/netflix-shows). We will use a Jupyter notebook to run a Ray job that generates the embeddings & populates them into the `pgvector` instance created above.
+
+Set your the namespace, cluster name and location from `workloads.tfvars`):
+
+```
+export NAMESPACE=rag
+export CLUSTER_LOCATION=us-east4
+export CLUSTER_NAME=rag-cluster
+```
+
+Connect to the GKE cluster:
+
+```
+gcloud container clusters get-credentials ${CLUSTER_NAME} --location=${CLUSTER_LOCATION}
+```
+
+1. Connect and login to JupyterHub:
+   * If IAP is disabled (`jupyter_add_auth = false`):
+        - Port forward to the JupyterHub service: `kubectl port-forward service/proxy-public -n ${NAMESPACE} 8081:80 &`
+        - Go to `localhost:8081` in a browser
+        - Login with these credentials:
+            * username: admin
+            * password: use `terraform output jupyterhub_password` to fetch the password value
+   * If IAP is enabled (`jupyter_add_auth = true`):
+        - Fetch the domain: `terraform output jupyterhub_uri`
+        - If you used a custom domain, ensure you configured your DNS as described above. 
+        - Verify the domain status is `Active`:
+            - `kubectl get managedcertificates jupyter-managed-cert -n ${NAMESPACE} --output jsonpath='{.status.domainStatus[0].status}'`
+            - Note: This can take up to 20 minutes to propagate.
+        - Once the domain status is Active, go to the domain in a browser and login with your Google credentials.
+        - To add additional users to your JupyterHub application, go to [Google Cloud Platform IAP](https://console.cloud.google.com/security/iap), select the `rag/proxy-public` service and add principals with the role `IAP-secured Web App User`.
+
+2. Load the notebook:
+    - Once logged in to JupyterHub, choose the `CPU` preset with `Default` storage. 
+    - Click [File] -> [Open From URL] and paste: `https://raw.githubusercontent.com/GoogleCloudPlatform/ai-on-gke/main/applications/rag/example_notebooks/rag-kaggle-ray-sql-interactive.ipynb`
+
+3. Configure Kaggle:
+    - Create a [Kaggle account](https://www.kaggle.com/account/login?phase=startRegisterTab&returnUrl=%2F).
+    - [Generate an API token](https://www.kaggle.com/settings/account). See [further instructions](https://www.kaggle.com/docs/api#authentication). This token is used in the notebook to access the [Kaggle Netflix shows](https://www.kaggle.com/datasets/shivamb/netflix-shows) dataset.
+    - Replace the variables in the 1st cell of the notebook with your Kaggle credentials (can be found in the `kaggle.json` file created while generating the API token):
+        * `KAGGLE_USERNAME`
+        * `KAGGLE_KEY`
+
+4. Generate vector embeddings: Run all the cells in the notebook to generate vector embeddings for the Netflix shows dataset (https://www.kaggle.com/datasets/shivamb/netflix-shows) and store them in the `pgvector` CloudSQL instance via a Ray job.
+    * When the last cell says the job has succeeded (eg: `Job 'raysubmit_APungAw6TyB55qxk' succeeded`), the vector embeddings have been generated and we can launch the frontend chat interface. Note that running the job can take up to 10 minutes.
+    * Ray may take several minutes to create the runtime environment. During this time, the job will appear to be missing (e.g. `Status message: PENDING`).
+    * Connect to the Ray dashboard to check the job status or logs:
+        - If IAP is disabled (`ray_dashboard_add_auth = false`):
+            - `kubectl port-forward -n ${NAMESPACE} service/ray-cluster-kuberay-head-svc 8265:8265`
+            - Go to `localhost:8265` in a browser
+        - If IAP is enabled (`ray_dashboard_add_auth = true`):
+            - Fetch the domain: `terraform output ray-dashboard-managed-cert`
+            - If you used a custom domain, ensure you configured your DNS as described above.
+            - Verify the domain status is `Active`:
+                - `kubectl get managedcertificates ray-dashboard-managed-cert -n ${NAMESPACE} --output jsonpath='{.status.domainStatus[0].status}'`
+                - Note: This can take up to 20 minutes to propagate.
+            - Once the domain status is Active, go to the domain in a browser and login with your Google credentials.
+            - To add additional users to your frontend application, go to [Google Cloud Platform IAP](https://console.cloud.google.com/security/iap), select the `rag/ray-cluster-kuberay-head-svc` service and add principals with the role `IAP-secured Web App User`.
+
+# Launch the frontend chat interface
+
+1. Connect to the frontend:
+    * If IAP is disabled (`frontend_add_auth = false`):
+        - Port forward to the frontend service: `kubectl port-forward service/rag-frontend -n ${NAMESPACE} 8080:8080 &`
+        - Go to `localhost:8080` in a browser
+    * If IAP is enabled (`frontend_add_auth = true`):
+        - Fetch the domain: `terraform output frontend_uri`
+        - If you used a custom domain, ensure you configured your DNS as described above.
+        - Verify the domain status is `Active`:
+            - `kubectl get managedcertificates frontend-managed-cert -n ${NAMESPACE} --output jsonpath='{.status.domainStatus[0].status}'`
+            - Note: This can take up to 20 minutes to propagate.
+        - Once the domain status is Active, go to the domain in a browser and login with your Google credentials.
+        - To add additional users to your frontend application, go to [Google Cloud Platform IAP](https://console.cloud.google.com/security/iap), select the `rag/rag-frontend` service and add principals with the role `IAP-secured Web App User`.
+2. Prompt the LLM
+    * Start chatting! This will fetch context related to your prompt from the vector embeddings in the `pgvector` CloudSQL instance, augment the original prompt with the context & query the inference model (`mistral-7b`) with the augmented prompt.
+
+# Configure authenticated access via IAP (recommended)
+
+We recommend you configure authenticated access via IAP for your services.
+
+1) Make sure the [OAuth Consent Screen](https://developers.google.com/workspace/guides/configure-oauth-consent#configure_oauth_consent) is configured for your project. Ensure `User type` is set to `Internal`.
+2) Make sure [Policy for Restrict Load Balancer Creation Based on Load Balancer Types](https://cloud.google.com/load-balancing/docs/org-policy-constraints) allows EXTERNAL_HTTP_HTTPS.
+3) Set the following variables in `workloads.tfvars`:
+    * `jupyter_add_auth = true`
+    * `frontend_add_auth = true`
+    * `ray_dashboard_add_auth = true`
+4) Allowlist principals for your services via `jupyter_members_allowlist`, `frontend_members_allowlist` and `ray_dashboard_members_allowlist`.
+5) Configure custom domains names via `jupyter_domain`, `frontend_domain` and `ray_dashboard_domain` for your services. 
+6) Configure DNS records for your custom domains:
+    - [Register a Domain on Google Cloud Domains](https://cloud.google.com/domains/docs/register-domain#registering-a-domain) or use a domain registrar of your choice.
+    - Set up your DNS service to point to the public IP
+        * Run `terraform output frontend_ip_address` to get the public ip address of frontend, and add an A record in your DNS configuration to point to the public IP address.
+        * Run `terraform output jupyterhub_ip_address` to get the public ip address of jupyterhub, and add an A record in your DNS configuration to point to the public IP address.
+        * Run `terraform output ray_dashboard_ip_address` to get the public ip address of ray dashboard, and add an A record in your DNS configuration to point to the public IP address.
+    - Add an A record: If the DNS service of your domain is managed by [Google Cloud DNS managed zone](https://cloud.google.com/dns/docs/zones), there are two options to add the A record:
+        1. Go to https://console.cloud.google.com/net-services/dns/zones, select the zone and click ADD STANDARD, fill in your domain name and public IP address.
+        2. Run `gcloud dns record-sets create <domain address>. --zone=<zone name> --type="A" --ttl=<ttl in seconds> --rrdatas="<public ip address>"`
+
+# Cleanup
+
+1. Run `terraform destroy --var-file="workloads.tfvars"`
+    - Network deletion issue: `terraform destroy` fails to delete the network due to a known issue in the GCP provider. For now, the workaround is to manually delete it.
+
+# Troubleshooting
+
+Set your the namespace, cluster name and location from `workloads.tfvars`:
+
+```
+export NAMESPACE=rag
+export CLUSTER_LOCATION=us-central1
+export CLUSTER_NAME=rag-cluster
+```
+
+Connect to the GKE cluster:
+
+```
+gcloud container clusters get-credentials ${CLUSTER_NAME} --location=${CLUSTER_LOCATION}
+```
+
+1. Troubleshoot Ray job failures:
+    - If the Ray actors fail to be scheduled, it could be due to a stockout or quota issue.
+        - Run `kubectl get pods -n ${NAMESPACE} -l app.kubernetes.io/name=kuberay`. There should be a Ray head and Ray worker pod in `Running` state. If your ray pods aren't running, it's likely due to quota or stockout issues. Check that your project and selected `cluster_location` have L4 GPU capacity.
+    - Often, retrying the Ray job submission (the last cell of the notebook) helps.
+    - The Ray job may take 15-20 minutes to run the first time due to environment setup.
+
+2. Troubleshoot IAP login issues:
+    - Verify the cert is Active:
+        - For JupyterHub `kubectl get managedcertificates jupyter-managed-cert -n ${NAMESPACE} --output jsonpath='{.status.domainStatus[0].status}'`
+        - For the frontend: `kubectl get managedcertificates frontend-managed-cert -n ${NAMESPACE} --output jsonpath='{.status.domainStatus[0].status}'`
+    - Verify users are allowlisted for JupyterHub or frontend services:
+        - JupyterHub: Go to [Google Cloud Platform IAP](https://console.cloud.google.com/security/iap), select the `rag/proxy-public` service and check if the user has role `IAP-secured Web App User`.
+        - Frontend: Go to [Google Cloud Platform IAP](https://console.cloud.google.com/security/iap), select the `rag/rag-frontend` service and check if the user has role `IAP-secured Web App User`.
+    - Org error:
+        - The [OAuth Consent Screen](https://developers.google.com/workspace/guides/configure-oauth-consent#configure_oauth_consent) has `User type` set to `Internal` by default, which means principals external to the org your project is in cannot log in. To add external principals, change `User type` to `External`.
+
+3. Troubleshoot `terraform apply` failures:
+    - Inference server (`mistral`) fails to deploy:
+        - This usually indicates a stockout/quota issue. Verify your project and chosen `cluster_location` have L4 capacity.
+    - GCS bucket already exists:
+        - GCS bucket names have to be globally unique, pick a different name with a random suffix.
+    - Cloud SQL instance already exists:
+        - Ensure the `cloudsql_instance` name doesn't already exist in your project.
+    - GMP operator webhook connection refused:
+        - This is a rare, transient error. Run `terraform apply` again to resume deployment.
+
+4. Troubleshoot `terraform destroy` failures:
+    - Network deletion issue:
+        - `terraform destroy` fails to delete the network due to a known issue in the GCP provider. For now, the workaround is to manually delete it.
+
+5. Troubleshoot error: `Repo model mistralai/Mistral-7B-Instruct-v0.1 is gated. You must be authenticated to access it.` for the pod of deployment `mistral-7b-instruct`.
+
+   The error is because the RAG deployments uses `Mistral-7B-instruct` which is now a gated model on Hugging Face. Deployments fail as they require a Hugging Face authentication token, which is not part of the current workflow.
+   While we are actively working on long-term fix. This is how to workaround the error:
+    - Use [the guide](https://cloud.google.com/kubernetes-engine/docs/tutorials/serve-gemma-gpu-tgi#generate-token) as a reference to create an access token.
+    - Go to the [model card](https://huggingface.co/mistralai/Mistral-7B-Instruct-v0.1) in Hugging Face and click "Agree and access repository"
+    - Create [a secret](https://cloud.google.com/kubernetes-engine/docs/tutorials/serve-gemma-gpu-vllm#create_a_kubernetes_secret_for_hugging_face_credentials) as noted in with the Hugging Face credential called `hf-secret` in the name space where your `mistral-7b-instruct` deployment is running.
+    - Add the following entry to `env` within the deployment `mistral-7b-instruct` via `kubectl edit`.
+
+```
+        - name: HUGGING_FACE_HUB_TOKEN
+          valueFrom:
+            secretKeyRef:
+              name: hf-secret
+              key: hf_api_token
+```
+
diff --git a/website/content/en/docs/Applications/Ray/_index.md b/website/content/en/docs/Applications/Ray/_index.md
new file mode 100644
index 000000000..bfec725e9
--- /dev/null
+++ b/website/content/en/docs/Applications/Ray/_index.md
@@ -0,0 +1,64 @@
+---
+title: "Ray on GKE Templates"
+linkTitle: "Ray"
+weight: 10
+---
+
+This repository contains a Terraform template for running [Ray](https://www.ray.io/) on Google Kubernetes Engine.
+See the [Ray on GKE](/ray-on-gke/) directory to see additional guides and references.
+
+## Prerequisites
+
+1. GCP Project with following APIs enabled
+    - container.googleapis.com
+    - iap.googleapis.com (required when using authentication with Identity Aware Proxy)
+
+2. A functional GKE cluster.
+    - To create a new standard or autopilot cluster, follow the instructions in [`infrastructure/README.md`](https://github.com/GoogleCloudPlatform/ai-on-gke/blob/main/infrastructure/README.md)
+    - Alternatively, you can set the `create_cluster` variable to true in `workloads.tfvars` to provision a new GKE cluster. This will default to creating a GKE Autopilot cluster; if you want to provision a standard cluster you must also set `autopilot_cluster` to false.
+
+3. This module is configured to optionally use Identity Aware Proxy (IAP) to protect access to the Ray dashboard. It expects the brand & the OAuth consent configured in your org. You can check the details here: [OAuth consent screen](https://console.cloud.google.com/apis/credentials/consent)
+
+4. Preinstall the following on your computer:
+    * Terraform
+    * Gcloud CLI
+
+## Installation
+
+### Configure Inputs
+
+1. If needed, clone the repo
+```
+git clone https://github.com/GoogleCloudPlatform/ai-on-gke
+cd ai-on-gke/applications/ray
+```
+
+2. Edit `workloads.tfvars` with your GCP settings.
+
+**Important Note:**
+If using this with the Jupyter module (`applications/jupyter/`), it is recommended to use the same k8s namespace
+for both i.e. set this to the same namespace as `applications/jupyter/workloads.tfvars`.
+
+| Variable                    | Description                                                                                                    | Required |
+|-----------------------------|----------------------------------------------------------------------------------------------------------------|:--------:|
+| project_id                  | GCP Project Id                                                                                                 | Yes      |
+| cluster_name                | GKE Cluster Name                                                                                               | Yes      |
+| cluster_location            | GCP Region                                                                                                     | Yes      |
+| kubernetes_namespace        | The namespace that Ray and rest of the other resources will be installed in.                                   | Yes      |
+| gcs_bucket                  | GCS bucket to be used for Ray storage                                                                          | Yes      |
+| create_service_account      | Create service accounts used for Workload Identity mapping                                                     | Yes      |
+
+
+### Install
+
+> **_NOTE:_** Terraform keeps state metadata in a local file called `terraform.tfstate`. Deleting the file may cause some resources to not be cleaned up correctly even if you delete the cluster. We suggest using `terraform destory` before reapplying/reinstalling.
+
+3. Ensure your gcloud application default credentials are in place. 
+```
+gcloud auth application-default login
+```
+
+4. Run `terraform init`
+
+5. Run `terraform apply --var-file=./workloads.tfvars`. 
+
diff --git a/website/content/en/docs/Applications/index.md b/website/content/en/docs/Applications/_index.md
similarity index 100%
rename from website/content/en/docs/Applications/index.md
rename to website/content/en/docs/Applications/_index.md
diff --git a/website/content/en/docs/Benchmarks/_index.md b/website/content/en/docs/Benchmarks/_index.md
new file mode 100644
index 000000000..ce5224c19
--- /dev/null
+++ b/website/content/en/docs/Benchmarks/_index.md
@@ -0,0 +1,142 @@
+---
+title: "AI on GKE Benchmarking"
+linkTitle: "Benchmarks"
+weight: 25
+menu:
+  main:
+    weight: 25
+---
+
+This framework enables you to run automated benchmarks on GKE for AI workloads via Terraform automation.
+You can find the current set of supported cluster deployments under `infra/` and the supported inference servers
+under `inference-server/`.
+
+Note that you can run any stage separate from another. For example, you can deploy your own inference server
+on a cluster created via these terraform scripts. And vice versa, you can deploy the inference servers
+via these terraform scripts on a Standard cluster that you've created yourself.
+
+## Pre-requisites
+
+### Terraform
+
+Install Terraform by following the documentation at https://developer.hashicorp.com/terraform/tutorials/aws-get-started/install-cli.
+This requires a minimum Terraform version of 1.7.4
+
+## Deploy and serve an ML model
+
+This section goes over an end to end example to deploy and serve the Falcon 7b model using (TGI)[https://huggingface.co/docs/text-generation-inference/en/index] on a Standard GKE Cluster with GPUs.
+
+Each step below has more details in their respective directoy README.md. It is recommended
+that you read through the available options at least once when testing your own models.
+
+### Create the cluster
+
+Set up the infrastructure by creating a GKE cluster with appropriate accelerator
+configuration.
+
+To create a GPU cluster, run
+```
+# Stage 1 creates the cluster.
+cd infra/stage-1
+
+# Copy the sample variables and update the project ID, cluster name and other
+parameters as needed in the `terraform.tfvars` file.
+cp sample-terraform.tfvars terraform.tfvars
+
+# Initialize the Terraform modules.
+terraform init
+
+# Run plan to see the changes that will be made.
+terraform plan
+
+# Run apply if the changes look good by confirming the prompt.
+terraform apply
+```
+To verify that the cluster has been set up correctly, run
+```
+# Get credentials using fleet membership
+gcloud container fleet memberships get-credentials <cluster-name>
+
+# Run a kubectl command to verify
+kubectl get nodes
+```
+
+### Configure the cluster
+
+To configure the cluster to run inference workloads we need to set up workload
+identity, GCS Fuse and DCGM for GPU metrics.
+```
+# Stage 2 configures the cluster for running inference workloads.
+cd infra/stage-2
+
+# Copy the sample variables and update the project number and cluster name in
+# the fleet_host variable "https://connectgateway.googleapis.com/v1/projects/<project-number>/locations/global/gkeMemberships/<cluster-name>"
+# and the project name and bucket name parameters as needed in the
+# `terraform.tfvars` file. You can specify a new bucket name in which case it
+# will be created.
+cp sample-terraform.tfvars terraform.tfvars
+
+# Initialize the Terraform modules.
+terraform init
+
+# Run plan to see the changes that will be made.
+terraform plan
+
+# Run apply if the changes look good by confirming the prompt.
+terraform apply
+```
+
+### Deploy the inference server
+
+To deploy TGI with a sample model, run
+```
+cd inference-server/text-generation-inference
+
+# Copy the sample variables and update the project number and cluster name in
+# the fleet_host variable "https://connectgateway.googleapis.com/v1/projects/<project-number>/locations/global/gkeMemberships/<cluster-name>"
+# in the `terraform.tfvars` file.
+cp sample-terraform.tfvars terraform.tfvars
+
+# Initialize the Terraform modules.
+terraform init
+
+# Run plan to see the changes that will be made.
+terraform plan
+
+# Run apply if the changes look good by confirming the prompt.
+terraform apply
+```
+
+To verify that the model is running, you can run
+```
+kubectl get deployment -n benchmark
+```
+This should show the TGI server running.
+
+### Deploy the benchmark
+
+To prepare the dataset for the Locust inference benchmark, view the README.md file in:
+```
+cd benchmark/dataset/ShareGPT_v3_unflitered_cleaned_split
+```
+
+To deploy the Locust inference benchmark with the above model, run
+```
+cd benchmark/tools/locust-load-inference
+
+# Copy the sample variables and update the project number and cluster name in
+# the fleet_host variable "https://connectgateway.googleapis.com/v1/projects/<project-number>/locations/global/gkeMemberships/<cluster-name>"
+# in the `terraform.tfvars` file.
+cp sample-terraform.tfvars terraform.tfvars
+
+# Initialize the Terraform modules.
+terraform init
+
+# Run plan to see the changes that will be made.
+terraform plan
+
+# Run apply if the changes look good by confirming the prompt.
+terraform apply
+```
+
+To further interact with the Locust inference benchmark, view the README.md file in `benchmark/tools/locust-load-inference`
diff --git a/website/content/en/docs/Benchmarks/index.md b/website/content/en/docs/Benchmarks/index.md
deleted file mode 100644
index 34c67abb8..000000000
--- a/website/content/en/docs/Benchmarks/index.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-title: "Benchmarks"
-linkTitle: "Benchmarks"
-weight: 25
-menu:
-  main:
-    weight: 25
----
diff --git a/website/content/en/docs/BestPractices/ml-platform/_index.md b/website/content/en/docs/BestPractices/ml-platform/_index.md
index 558a05ede..a687db761 100644
--- a/website/content/en/docs/BestPractices/ml-platform/_index.md
+++ b/website/content/en/docs/BestPractices/ml-platform/_index.md
@@ -2,9 +2,6 @@
 title: "ML Platform"
 linkTitle: "ML Platform"
 weight: 10
-menu:
-  main:
-    weight: 10
 ---
 
 # Machine learning platform (MLP) on GKE reference architecture for enabling Machine Learning Operations (MLOps)
diff --git a/website/content/en/docs/BestPractices/startuplatency.md b/website/content/en/docs/BestPractices/startuplatency.md
index 16a643ab3..6b5455781 100644
--- a/website/content/en/docs/BestPractices/startuplatency.md
+++ b/website/content/en/docs/BestPractices/startuplatency.md
@@ -2,23 +2,17 @@
 title: "Startup Latency"
 linkTitle: "Startup Latency"
 weight: 10
-menu:
-  main:
-    weight: 10
 ---
 
 ## Best Practices for Faster Workload Cold Start
 
 This doc  provides best practices to help achieve faster workload cold start on Google Kubernetes Engine (GKE), and discusses factors that determine the workload startup latency.
 
-
-# Introduction
+## Introduction
 
 The cold start problem occurs when workloads are scheduled to nodes that haven't hosted the workloads before. Since the new node has no pre-existing container images, the initial startup time for the workloads can be significantly longer. This extended startup time can lead to latency issues on the overall application performance, especially for handling traffic surge by node autoscaling.
 
-
-# Best Practices
-
+## Best Practices
 
 #### Use ephemeral storage with local SSDs or larger boot disks for Node
 
@@ -131,8 +125,6 @@ Nodes will mount the Kubelet and container runtime (docker or containerd) root d
   </tr>
 </table>
 
-
-
 #### Enable container image streaming
 
 [Use Image streaming to pull container images | Google Kubernetes Engine (GKE)](https://cloud.google.com/kubernetes-engine/docs/how-to/image-streaming)
@@ -147,16 +139,12 @@ gcloud container clusters create CLUSTER_NAME \
     --enable-image-streaming
 ```
 
-
 Customers can benefit from image streaming to allow workloads to start without waiting for the entire image to be downloaded, which leads to significant improvements in workload startup time. For example, Nvidia Triton Server (5.4GB container image) end-to-end startup time (from workload creation to server up for traffic) can be reduced from 191s to 30s.
 
-
 #### Use Zstandard compressed container images
 
 Zstandard compression is a feature supported in ContainerD. Please note that 
 
-
-
 1. Use the zstd builder in docker buildx
 
 ```
@@ -165,7 +153,6 @@ docker buildx create --name zstd-builder --driver docker-container \
 docker buildx use zstd-builder
 ```
 
-
 2. Build and push an image
 
 ```
@@ -177,18 +164,14 @@ IMAGE_TAG=v1
 docker buildx build --file Dockerfile --output type=image,name=$IMAGE_URI:$IMAGE_TAG,oci-mediatypes=true,compression=zstd,compression-level=3,force-compression=true,push=true .
 ```
 
-
-
 Now you can use `IMAGE_URI `for your workload which will have zstd compression image format. And [Zstandard benchmark](https://engineering.fb.com/2016/08/31/core-data/smaller-and-faster-data-compression-with-zstandard/) shows zstd is >3x faster decompression than gzip (the current default).
 
-
 #### Use a preloader DaemonSet to preload the base container on nodes
 
 ContainerD reuse the image layers across different containers if they share the same base container. And the preloader DaemonSet can start running even before the GPU driver is installed (driver installation takes ~30 seconds). So it can preload required containers before the GPU workload can be scheduled to the GPU node and start image pulling ahead of time.
 
 Below is an example of the preloader DaemonSet.
 
-
 ```
 apiVersion: apps/v1
 kind: DaemonSet
@@ -224,13 +207,10 @@ spec:
 
 ```
 
-
-
 #### Use GCS Fuse to access DataSet via file system interface
 
 [Cloud Storage FUSE and CSI driver now available for GKE | Google Cloud Blog](https://cloud.google.com/blog/products/containers-kubernetes/announcing-cloud-storage-fuse-and-gke-csi-driver-for-aiml-workloads) enables workloads to on-demand access GCS data with a local filesystem API.
 
-
 #### Use VolumeSnapshot to quickly replicating data to pods by PVC with disk image 
 
 [Using volume snapshots | Google Kubernetes Engine (GKE)](https://cloud.google.com/kubernetes-engine/docs/how-to/persistent-volumes/volume-snapshots#create-snapshotclass) with Disk image [parameters](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/blob/ec41c54ffaafe4db2793d02f079e4153ac3b2ac0/pkg/common/parameters.go#L38) to provision volumes used by Pods. This is because the disk image's base storage is reused by all disks created from it in the location, so new disk creation can be done much faster.
diff --git a/website/content/en/docs/Tools/GKE-disk-image-builder/_index.md b/website/content/en/docs/Tools/GKE-disk-image-builder/_index.md
new file mode 100644
index 000000000..6b134a8d9
--- /dev/null
+++ b/website/content/en/docs/Tools/GKE-disk-image-builder/_index.md
@@ -0,0 +1,241 @@
+---
+title: "GKE Disk Image Builder"
+linkTitle: "Disk Image Builder"
+weight: 10
+---
+
+**[github.com/GoogleCloudPlatform/ai-on-gke/gke-disk-image-builder](https://github.com/GoogleCloudPlatform/ai-on-gke/gke-disk-image-builder)**
+is a Go module that pulls a given list of container images and creates a disk
+image from the unpacked snapshots of the images. The generated disk image be
+consumed by GKE at the time of node pool creation via secondary-boot-disk
+feature. The goal of this module is preloading a disk image with the container
+images to improve the startup latency of k8s pods on GKE nodes using the GKE
+secondary-boot-disk feature.
+
+## Usage
+This is a Go module that can be used as a library as well as a CLI . Find the
+examples below to understand how this tool work better.
+
+### Preconditions
+
+1.  For GCP authentication, either:
+    1.  `~/.config/gcloud/application_default_credentials.json` must exit. If it
+        does not exist, create it by running `gcloud auth application-default
+        login`.
+    1.  You must provide a `credentials.json` file to the tool via the
+        `--gcp-oauth` flag. The path to `credentials.json` must be absolute.
+1.  If a container image resides in a private registry, the tool runner must
+    have access to it (See examples below).
+1.  Compute Engine API must be enabled.
+    (https://console.developers.google.com/apis/api/compute.googleapis.com/overview?project=$PROJECT_NAME)
+1.  Verify that `$PROJECT_NUMBER-compute@developer.gserviceaccount.com` has
+    `storage.objectCreator` permissions to the provided *GCS path* for the logs.
+    You can run the following command to grant proper permissions for this:
+
+    ```shell
+      gcloud storage buckets add-iam-policy-binding gs://$GCS_PATH \
+      --project=$PROJECT_NAME \
+      --member=serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com \
+      --role=roles/storage.objectCreator
+    ```
+
+1.  If a disk image with the given name (via the **--image-name** flag) already
+    exists, the tool will error out. Please provide a new name for the image.
+
+### Available Flags
+
+Flag                | Required | Default | Description
+------------------- | -------- | ------- | -----------
+*--project-name*    | Yes      | nil     | Name of a gcp project where the script will be run
+*--image-name*      | Yes      | nil     | Name of the image that will be generated
+*--image-family-name* | No | secondary-disk-image | Name of the image family associated with the created disk image
+*--image-labels* | No | nil | Labels tagged to the disk image. This flag can be specified multiple times. The accepted format is `--image-labels=key=val`.
+*--job-name*        | No       | secondary-disk-image | Name of the workflow. This name is used to provision some of the intermediate resources (disks, VMs) needed by the workflow. The maximum length is 50 characters
+*--zone*            | Yes      | nil     | Zone where the resources will be used to create the image creator resources
+*--gcs-path*        | Yes      | nil     | GCS path prefix to dump the logs
+*--container-image* | Yes      | nil     | Container image to include in the disk image. This flag can be specified multiple times
+*--gcp-oauth*       | No       | nil     | Path to GCP service account credential file
+*--disk-size-gb*    | No       | 10      | Size of a disk that will host the unpacked images
+*--image-pull-auth* | No       | 'None'  | Auth mechanism to pull the container image, valid values: [None, ServiceAccountToken]. None means that the images are publically available and no authentication is required to pull them. ServiceAccountToken means the service account oauth token will be used to pull the images. For more information refer to https://cloud.google.com/compute/docs/access/authenticate-workloads#applications
+*--timeout*         | No       | '20m'   | Default timeout for each step. Must be set to a proper value if the image is large to account for the pull and image creation time step.
+*--network*         | No       | 'default'   | VPC network used by the GCE resources used for creating the disk image.
+*--subnet*          | No       | 'default'   | Subnet used by the GCE resources used for creating the disk image.
+*--service-account* | No       | 'default'   | Service Account email assigned to the GCE instance used for creating the disk image.
+
+### Go
+
+Run the tool by simply running it as a Go file:
+
+```shell
+go run ./cli \
+    --project-name=$PROJECT_NAME \
+    --image-name=$IMAGE_NAME \
+    --zone=$ZONE \
+    --gcs-path=gs://$GCS_PATH/ \
+    --disk-size-gb=$DISK_SIZE_GB \
+    --container-image=$IMAGE_NAME
+```
+
+### Cloud Build
+
+Cloud Build API must be enabled.
+(https://console.cloud.google.com/apis/library/cloudbuild.googleapis.com?project=$PROJECT_NAME)
+
+The Cloud Build service account must have the `compute.admin` and
+`roles/compute.serviceAgent` roles:
+
+```shell
+gcloud projects add-iam-policy-binding $PROJECT_NAME \
+--member serviceAccount:$PROJECT_NUMBER@cloudbuild.gserviceaccount.com \
+--role roles/compute.admin \
+--role roles/compute.serviceAgent
+```
+
+Create a Cloud Build config file, named **cloudbuild.yaml**:
+
+```yaml
+steps:
+- name: 'gcr.io/cloud-builders/git'
+  args: ['clone', 'https://github.com/GoogleCloudPlatform/ai-on-gke.git']
+- name: 'gcr.io/cloud-builders/go:1.21'
+  env: ['GOPATH=./ai-on-gke/gke-disk-image-builder']
+  dir: './ai-on-gke/gke-disk-image-builder'
+  args:
+    - 'run'
+    - './cli'
+    - --project-name={project-name}
+    - --image-name={image-name}
+    - --zone={zone}
+    - --gcs-path=gs://{gcs-path}/
+    - --disk-size-gb={disk-size-gb}
+    - --container-image={image-name}
+```
+
+And then submit it:
+
+```shell
+gcloud builds submit --config cloudbuild.yaml --no-source
+```
+
+### CLI
+
+You can compile the module and use the generated binary:
+
+```shell
+go build -o image-builder ./cli
+./image-builder \
+    --project-name=$PROJECT_NAME \
+    --image-name=$IMAGE_NAME \
+    --zone=$ZONE \
+    --gcs-path=gs://$GCS_PATH/ \
+    --disk-size-gb=$DISK_SIZE_GB \
+    --container-image=$IMAGE_NAME
+```
+
+## Examples
+
+Here are some examples on how to use the tool.
+
+### Environment Variable
+
+**Note:** Setting this environment variables are not necessary to use the tool.
+This only simplify presenting the examples.
+
+```shell
+PROJECT_NAME=my-project-name
+IMAGE_NAME=example-image
+ZONE=us-west1-b
+GCS_PATH=gke-disk-image-builder-logs
+```
+
+### Pull an image from a public registry
+
+```shell
+go run ./cli \
+    --project-name=$PROJECT_NAME \
+    --image-name=$IMAGE_NAME \
+    --zone=$ZONE \
+    --gcs-path=gs://$GCS_PATH/ \
+    --container-image=docker.io/library/nginx:latest
+```
+
+### Pull multiple images from a public registry
+
+All the images will be pulled, unpacked and put on the same disk image. The
+generated disk image is consumable by GKE the same as a single image one.
+
+```shell
+go run ./cli \
+    --project-name=$PROJECT_NAME \
+    --image-name=$IMAGE_NAME \
+    --zone=$ZONE \
+    --gcs-path=gs://$GCS_PATH/ \
+    --container-image=docker.io/library/python:latest \
+    --container-image=docker.io/library/nginx:latest
+```
+
+### Pull a large image from a public registry
+
+Use the **--disk-size-gb** flag to create a larger disk as follows. This value
+will be the size of output disk image.
+
+```shell
+go run ./cli \
+    --project-name=$PROJECT_NAME \
+    --image-name=$IMAGE_NAME \
+    --zone=$ZONE \
+    --gcs-path=gs://$GCS_PATH/ \
+    --disk-size-gb=50 \
+    --container-image=nvcr.io/nvidia/tritonserver:23.09-py3
+```
+
+### Pull an image from a private registry
+
+The tool uses OAuth token of the GCE service account to authenticate to the
+private registry. First, you must grant it read permission on the registry.
+
+Use the **--image-pull-auth** flag as follows:
+
+```shell
+go run ./cli \
+    --project-name=$PROJECT_NAME \
+    --image-name=$IMAGE_NAME \
+    --zone=$ZONE \
+    --gcs-path=gs://$GCS_PATH/ \
+    --image-pull-auth=ServiceAccountToken \
+    --container-image=$CONTAINER_IMAGE_FROM_PRIVATE_REGISTRY
+```
+
+### Run the tool with a GCP OAuth token
+
+By default the tool uses the OAuth credentials stored in
+`~/.config/gcloud/application_default_credentials.json`.
+
+**Note:** The path of the `--gcp-oauth` must be absolute.
+
+**Note:** Run `gcloud auth application-default login` to create
+`~/.config/gcloud/application_default_credentials.json` file.
+
+```shell
+go run ./cli \
+    --project-name=$PROJECT_NAME \
+    --image-name=$IMAGE_NAME \
+    --zone=$ZONE \
+    --gcs-path=gs://$GCS_PATH/ \
+    --gcp-oauth=/usr/local/google/home/username/another_credentials.json \
+    --container-image=docker.io/library/nginx:latest
+```
+### Customize the image family name and attach labels to the built image
+```
+go run ./cli \
+    --project-name=$PROJECT_NAME \
+    --image-name=$IMAGE_NAME \
+    --zone=$ZONE \
+    --gcs-path=gs://$GCS_PATH/ \
+    --container-image=docker.io/library/python:latest \
+    --container-image=docker.io/library/nginx:latest \
+    --image-family-name=customize-image-family \
+    --image-labels=pokemon=pikachu \
+    --image-labels=band=ac-dc \
+    --image-labels=theory=ramsey_theory
+```
diff --git a/website/content/en/docs/Tools/Saxml/_index.md b/website/content/en/docs/Tools/Saxml/_index.md
new file mode 100644
index 000000000..8f518fc2a
--- /dev/null
+++ b/website/content/en/docs/Tools/Saxml/_index.md
@@ -0,0 +1,379 @@
+---
+title: "Inferencing using Saxml and an HTTP Server"
+linkTitle: "Saxml on GKE"
+weight: 10
+---
+
+## Background
+
+[Saxml](https://github.com/google/saxml) is an experimental system that serves [Paxml](https://github.com/google/paxml), [JAX](https://github.com/google/jax), and [PyTorch](https://pytorch.org/) models for inference. A Sax cell (aka Sax cluster) consists of an admin server and a group of model servers. The admin server keeps track of model servers, assigns published models to model servers to serve, and helps clients locate model servers serving specific published models.
+
+In order to interact with the Sax cluster today, users can use the command line tool, [saxutil](https://github.com/google/saxml#use-sax), or interact directly with the [Sax client](https://github.com/google/saxml/tree/main/saxml/client/).
+
+This tutorial uses an HTTP Server to handle HTTP requests to Sax, supporting features such as model publishing, listing, updating, unpublishing, and generating predictions. The HTTP server uses the [Python Sax client](https://github.com/google/saxml/tree/main/saxml/client/python) in order to communicate with the Sax cluster and handle routing within the Sax system. With an HTTP server, interaction with Sax can also expand to further than at the VM-level. For example, integration with GKE and load balancing will enable requests to Sax from inside and outside the GKE cluster.
+
+**This tutorial focuses on the deployment of the HTTP server and assumes you have already deployed a Sax Admin Server and Sax Model Server according to the [OSS SAX Docker Guide](https://github.com/google/saxml/tree/main/saxml/tools/docker)**
+
+### Build Dockerfile.http
+
+Build the HTTP Server image:
+
+```
+docker build -f Dockerfile -t sax-http .
+```
+
+### Run the HTTP Server Locally
+
+If you haven't already, create a GCS Bucket to store Sax Cluster information:
+
+```
+GSBUCKET=${USER}-sax-data
+gcloud storage buckets create gs://${GSBUCKET}
+```
+
+```
+docker run -e SAX_ROOT=gs://${GSBUCKET}/sax-root -p 8888:8888 -it sax-http
+```
+
+In another terminal:
+
+```
+curl localhost:8888
+```
+
+You will see the output below:
+
+```json
+{
+  "message": "HTTP Server for SAX Client"
+}
+```
+
+### Publish a model
+
+```
+curl --request POST \
+--header "Content-type: application/json" \
+--silent \
+localhost:8888/publish \
+--data \
+'{
+    "model": "/sax/test/lm2b",
+    "model_path": "saxml.server.pax.lm.params.lm_cloud.LmCloudSpmd2BTest",
+    "checkpoint": "None",
+    "replicas": 1
+}'
+```
+
+You will see the output below:
+
+```json
+{
+  "model": "/sax/test/lm2b",
+  "path": "saxml.server.pax.lm.params.lm_cloud.LmCloudSpmd2BTest",
+  "checkpoint": "None",
+  "replicas": 1
+}
+```
+
+### List all models in a Sax Cell
+
+```
+curl --request GET \
+--header "Content-type: application/json" \
+--silent \
+localhost:8888/listall \
+--data \
+'{
+    "sax_cell": "/sax/test"
+}'
+```
+
+You will see the output below:
+
+```json
+["/sax/test/lm2b"]
+```
+
+### List a Sax Cell
+
+```
+curl --request GET \
+--header "Content-type: application/json" \
+--silent \
+localhost:8888/listcell \
+--data \
+'{
+    "model": "/sax/test/lm2b"
+}'
+```
+
+You will see the output below:
+
+```json
+{
+  "model": "/sax/test/lm2b",
+  "model_path": "saxml.server.pax.lm.params.lm_cloud.LmCloudSpmd2BTest",
+  "checkpoint": "None",
+  "max_replicas": 1,
+  "active_replicas": 1
+}
+```
+
+### Generate a prediction
+
+```
+curl --request POST \
+--header "Content-type: application/json" \
+--silent \
+localhost:8888/generate \
+--data \
+'{
+    "model": "/sax/test/lm2b",
+    "query": "Q: Who is Harry Potter's mom? A: "
+}'
+```
+
+The result should be printed in the terminal
+
+### Unpublish a model
+
+```
+$ curl --request POST \
+--header "Content-type: application/json" \
+--silent \
+localhost:8888/unpublish \
+--data '
+{
+    "model": "/sax/test/lm2b"
+}
+'
+```
+
+You will see the output below:
+
+```json
+{
+  "model": "/sax/test/lm2b"
+}
+```
+
+## Saxml HTTP Server APIs
+
+The following are the APIs implemented in this HTTP Server, the complete [Python client interface](https://github.com/google/saxml/blob/main/saxml/client/python/sax.pyi) is available in the [google/saxml repository](https://github.com/google/saxml)
+
+### generate
+
+`/generate` is use to generate a response from a specific model.
+
+#### generate Request
+
+JSON object of the following format:
+
+```
+{
+    "model": <String>,
+    "query": <String>,
+    "extra_inputs": {
+        "temperature": <Number>,
+        "per_example_max_decode_steps": <Number>,
+        "per_example_top_k": <Number>,
+        "per_example_top_p": <Number>
+    }
+}
+```
+
+- `model` is the name of the model to query.
+- `query` is the prompt to send to the model.
+- `extra_inputs` is an optional object that overrides the default decoding configuration of the model.
+  - `temperature`: is a floating point number for the decoding temperature.
+  - `per_example_max_decode_steps`: is an integer for the maximum decoding steps for each request. Needs to be smaller than maximum value of max_decode_steps configured for the published model.
+  - `per_example_top_k`: is an integer for the topK used for decoding.
+  - `per_example_top_p`: is a floating point number for the topP used for decoding.
+
+#### generate Response
+
+JSON object with the following format:
+
+```
+[
+    [
+        <String>,
+        <Number>
+    ],
+    ...
+]
+```
+
+`[[<String>, <Number>]]` is an array of arrays
+
+- `<String>` is the response from the model.
+- `<Number>` is a floating point number for the score of the response.
+
+### listall
+
+`/listall` is used to list all model in a specific cell
+
+#### listall Request
+
+JSON object of the following format:
+
+```
+{
+    "sax_cell": <String>
+}
+```
+
+- `sax_cell` is the path to list.
+
+#### listall Response
+
+JSON object with the following format:
+
+```
+[
+    <String>,
+    ...
+]
+```
+
+- `[<String>]` is an array Strings.
+  - `<String>` is a model name.
+
+### listcell
+
+`/listcell` is used to list a specific model.
+
+#### listcell Request
+
+JSON object of the following format:
+
+```
+{
+    "model": <String>
+}
+```
+
+- `model` is the name of the model.
+
+#### listcell Response
+
+JSON object with the following format:
+
+```
+{
+    "model": <String>,
+    "model_path": <String>,
+    "checkpoint": <String>,
+    "max_replicas": <Number>,
+    "active_replicas": <Number>
+}
+```
+
+- `model` is the name of the model.
+- `model_path` is the path of the model in the Saxml model registry.
+- `checkpoint` is the location of the model checkpoint.
+- `max_replicas` is an integer for the maximum number of replicas the model be deployed on.
+- `active_replicas` is an integer for the number of replicas the model is currently deployed on.
+
+### publish
+
+`/publish` is used to publish a new model.
+
+#### publish Request
+
+JSON object of the following format:
+
+```
+{
+    "model": <String>,
+    "model_path": <String>,
+    "checkpoint": <String>,
+    "replicas": <Number>
+}
+```
+
+- `model` is the name of the model.
+- `model_path` is the path of the model in the Saxml model registry.
+- `checkpoint` is the location of the model checkpoint.
+- `replicas` is an integer for the number of replicas of the model to deploy.
+
+#### publish Response
+
+JSON object with the following format:
+
+```
+{
+    "model": <String>
+}
+```
+
+- `model` is the name of the model published.
+
+### unpublish
+
+`/unpublish` is used to unpublish a model.
+
+#### unpublish Request
+
+JSON object of the following format:
+
+```
+{
+    "model": <String>
+}
+```
+
+- `model` is the name of the model to unpublish.
+
+#### unpublish Response
+
+JSON object with the following format:
+
+```
+{
+    "model": <String>
+}
+```
+
+- `model` is the name of the model unpublished.
+
+### update
+
+`/update` is used to updated an existing model.
+
+#### update Request
+
+JSON object of the following format:
+
+```
+{
+    "model": <String>,
+    "model_path": <String>,
+    "checkpoint": <String>,
+    "replicas": <Number>
+}
+```
+
+- `model` is the name of the model.
+- `model_path` is the path of the model in the Saxml model registry.
+- `checkpoint` is the location of the model checkpoint.
+- `replicas` is an integer for the number of replicas of the model to deploy.
+
+#### update Response
+
+JSON object with the following format:
+
+```
+{
+    "model": <String>,
+    "model_path": <String>,
+    "checkpoint": <String>,
+    "replicas": <Number>
+}
+```
+
+- `model` is the name of the model.
+- `model_path` is the path of the model in the Saxml model registry.
+- `checkpoint` is the location of the model checkpoint.
+- `replicas` is an integer for the number of replicas of the model to deploy.
diff --git a/website/content/en/docs/Tools/index.md b/website/content/en/docs/Tools/_index.md
similarity index 100%
rename from website/content/en/docs/Tools/index.md
rename to website/content/en/docs/Tools/_index.md
diff --git a/website/content/en/docs/Tutorials and Samples/GPU/_index.md b/website/content/en/docs/Tutorials and Samples/GPU/_index.md
new file mode 100644
index 000000000..9ed6b9964
--- /dev/null
+++ b/website/content/en/docs/Tutorials and Samples/GPU/_index.md	
@@ -0,0 +1,7 @@
+---
+title: "GPU"
+linkTitle: "GPU"
+weight: 10
+---
+
+GPU Tutorials and Samples
\ No newline at end of file
diff --git a/website/content/en/docs/Tutorials and Samples/GPU/a100-jax/_index.md b/website/content/en/docs/Tutorials and Samples/GPU/a100-jax/_index.md
new file mode 100644
index 000000000..0370b6e81
--- /dev/null
+++ b/website/content/en/docs/Tutorials and Samples/GPU/a100-jax/_index.md	
@@ -0,0 +1,11 @@
+---
+title: "JAX 'Hello World' on GKE + A100-80GB"
+linkTitle: "JAX on GKE A100"
+weight: 10
+---
+
+[![Open in Cloud Shell](https://gstatic.com/cloudssh/images/open-btn.svg)](https://ssh.cloud.google.com/cloudshell/editor?cloudshell_git_repo=https://github.com/GoogleCloudPlatform/kubernetes-engine-samples&cloudshell_tutorial=README.md&cloudshell_workspace=ai-ml/gke-a100-jax)
+
+This tutorial shows how to run a simple JAX program using NVIDIA GPUs A100-80GB on a GKE cluster
+
+Visit https://cloud.google.com/blog/products/containers-kubernetes/machine-learning-with-jax-on-kubernetes-with-nvidia-gpus to follow the tutorial
diff --git a/website/content/en/docs/Tutorials and Samples/GPU/online-serving-single-gpu/_index.md b/website/content/en/docs/Tutorials and Samples/GPU/online-serving-single-gpu/_index.md
new file mode 100644
index 000000000..96bbb4e1f
--- /dev/null
+++ b/website/content/en/docs/Tutorials and Samples/GPU/online-serving-single-gpu/_index.md	
@@ -0,0 +1,7 @@
+---
+title: "Serve a model with a GPU on GKE Autopilot"
+linkTitle: "Serve on a Single GPU"
+weight: 10
+---
+
+Please follow the How-to at TO DO: add link to how-to
diff --git a/website/content/en/docs/Tutorials and Samples/GPU/training-single-gpu/_index.md b/website/content/en/docs/Tutorials and Samples/GPU/training-single-gpu/_index.md
new file mode 100644
index 000000000..88218ccf7
--- /dev/null
+++ b/website/content/en/docs/Tutorials and Samples/GPU/training-single-gpu/_index.md	
@@ -0,0 +1,7 @@
+---
+title: "Training a Model with GPUs on GKE Standard Mode"
+linkTitle: "Training on a Single GPU"
+weight: 10
+---
+
+Please follow the Quick Start at https://cloud.google.com/kubernetes-engine/docs/quickstarts/train-model-gpus-standard
diff --git a/website/content/en/docs/Tutorials and Samples/TPU/_index.md b/website/content/en/docs/Tutorials and Samples/TPU/_index.md
new file mode 100644
index 000000000..a598556c0
--- /dev/null
+++ b/website/content/en/docs/Tutorials and Samples/TPU/_index.md	
@@ -0,0 +1,7 @@
+---
+title: "TPU"
+linkTitle: "TPU"
+weight: 10
+---
+
+TPU Tutorials and Samples
diff --git a/website/content/en/docs/Tutorials and Samples/TPU/mnist-single-tpu/_index.md b/website/content/en/docs/Tutorials and Samples/TPU/mnist-single-tpu/_index.md
new file mode 100644
index 000000000..c03545be9
--- /dev/null
+++ b/website/content/en/docs/Tutorials and Samples/TPU/mnist-single-tpu/_index.md	
@@ -0,0 +1,7 @@
+---
+title: "Train a model with TPUs on GKE Standard mode"
+linkTitle: "Train a model with TPU"
+weight: 10
+---
+
+Please follow the Quick Start at https://cloud.google.com/kubernetes-engine/docs/quickstarts/train-model-tpus-standard
diff --git a/website/content/en/docs/Tutorials and Samples/index.md b/website/content/en/docs/Tutorials and Samples/_index.md
similarity index 100%
rename from website/content/en/docs/Tutorials and Samples/index.md
rename to website/content/en/docs/Tutorials and Samples/_index.md
diff --git a/website/content/en/docs/Tutorials and Samples/genAI-LLM/_index.md b/website/content/en/docs/Tutorials and Samples/genAI-LLM/_index.md
new file mode 100644
index 000000000..b8707b6f8
--- /dev/null
+++ b/website/content/en/docs/Tutorials and Samples/genAI-LLM/_index.md	
@@ -0,0 +1,7 @@
+---
+title: "GenAI-LLM"
+linkTitle: "GenAI"
+weight: 15
+---
+
+GenAI and LLM Tutorials.
\ No newline at end of file
diff --git a/website/content/en/docs/Tutorials and Samples/genAI-LLM/e2e-genai-langchain-app/_index.md b/website/content/en/docs/Tutorials and Samples/genAI-LLM/e2e-genai-langchain-app/_index.md
new file mode 100644
index 000000000..c7f1d5763
--- /dev/null
+++ b/website/content/en/docs/Tutorials and Samples/genAI-LLM/e2e-genai-langchain-app/_index.md	
@@ -0,0 +1,111 @@
+---
+title: "E2E GenAI application with Langchain, Ray, Flask API backend, React frontend"
+linkTitle: "E2E App with Langchain"
+weight: 15
+---
+
+In this tutorial you will deploy a end-to-end application that will use GenAI model from Hugging Face on the backend, Ray Serve for inference, Flask API backend, and simple React frontend.
+
+## Before you begin
+
+Create or select an existing GCP project and open Cloud Shell. You can use [these steps](https://cloud.google.com/kubernetes-engine/docs/deploy-app-cluster#before-you-begin)
+
+## Infrastructure Installation
+
+1. If needed, `git clone https://github.com/GoogleCloudPlatform/ai-on-gke.git`
+1. Create a new GKE cluster and install the kuberay operator
+    1. cd `gke-platform`
+    1. Edit `variables.tf` with your GCP settings. Make sure you change `project_id` and `cluster_name`.
+    1. Run `terraform init`
+    1. Run `terraform apply`
+1. Configure credentials to point to the cluster: `gcloud container clusters get-credentials <cluster-name> --location=<region>`
+1. Install Ray on GKE
+    1. cd `ray-on-gke/user`
+    1. Edit variables.tf with your GCP settings. Make sure you set: `project_id`, `namespace`, `service_account`.
+    1. Note the namespace setting. All microservices in this sample will be deployed to this same namespace for simplicity.
+    1. Run `terraform init`
+    1. Run `terraform apply`
+1. Install Jupyter on GKE. These steps are needed to experimentation (see the section below). You can skip it if you want to go straight to building the application. 
+    1. cd `jupyter-on-gke`
+    1. Edit `variables.tf` with your GCP settings. Make sure that you set `project_id`, `project_number`, `namespace`. Use the same namespace as above.
+    1. Configure higher resource limits and guarantees. In `jupyter_config/config.yaml` change the following:
+        ```yaml
+        singleuser:
+        cpu:
+            limit: 1
+            guarantee: .5
+        memory:
+            limit: 4G
+            guarantee: 1G
+        ```
+    1. Run terraform init
+    1. Run terraform apply
+
+## Experimentation
+
+Experiment with the model in Jupyter Notebook:
+1. Get the address of your Jupyter hub:
+![Jupyter Hub IP](./open_jupyter.png)
+    ```
+    kubectl get service proxy-public -n <namespace name> -o jsonpath='{.status.loadBalancer.ingress[0].ip}'
+    ```
+1. Configure IAP and open Jupyter Hub by following the steps in [here](../../jupyter-on-gke/README.md).
+1. From JupyterHub open this notebook: `https://raw.githubusercontent.com/GoogleCloudPlatform/ai-on-gke/main/tutorials/langchain/nb1.ipynb` and run it step by step
+1. The first section shows how to run the model directly
+1. The second section shows how to do the same using `Ray Serve`.
+
+## Build the end-to-end application
+
+1. We used Jupyter Notebook to experiment, but now let's build the Flask backend that calls into `Ray Serve`.
+    1. Observe `model.py`: it loads the model and creates `Ray.Serve` function that uses `Langchain` library to run two nested prompts.
+    1. Observe `main.py`: it uses Flask framework to create API route that calls into `Ray.Serve` endpoint
+    1. Containerize and deploy the backend image to the registry. Do these steps from `backend` directory:
+        ```bash
+        PROJECT_ID=<YOUR_PROJECT_ID>
+        # configure GCR
+        gcloud auth configure-docker
+        # build the image
+        docker build -t hf-lc-ray:latest .
+        # tag the image for GCR
+        docker tag hf-lc-ray:latest gcr.io/${PROJECT_ID}/hf-lc-ray:latest
+        # push the image to GCR
+        docker push gcr.io/${PROJECT_ID}/hf-lc-ray:latest
+        ```
+    1. Deploy backend to the cluster. Open `src/backend/deploy.yaml` and change `PROJECT_ID` to your project (you can also use `sed`:  `sed -i "s/YOUR_PROJECT/${PROJECT_ID}/" src/backend/deploy.yaml` ). Then run
+        ```bash
+        kubectl apply -f deploy.yaml -n <YOUR_NAMESPACE>
+        ```
+    1. Find backend IP on the services page: `hf-lc-ray-service`: ![Backend IP](./backend_ip.png)
+        ```
+        kubectl get service hf-lc-ray-service -n <namespace name> -o jsonpath='{.status.loadBalancer.ingress[0].ip}'
+        ```
+    1. To test that backend works you can run:
+        ```
+        ENDPOINT='http://<IP>/run'
+        curl -XPOST "${ENDPOINT}?text=football"
+        ```
+        You will get a response similar to:
+        ```
+        ["a football player is a player who plays for a team","Un joueur de football est un player qui joue pour un \u00e9quipe."]
+        ```
+
+1. Finally, let's deploy React frontend. Note that in a production distributed application, you can use [K8s Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/) with routes for `backend` and `frontend` to avoid taking dependcy on the IP, this approach is provided for simplicity.
+    1. Update the `API_ENDPOINT` in `src/frontend/src/index.tsx`
+    1. Containerize and deploy the frontend image to the registry. Do these steps from `src/frontend` directory:
+        ```bash
+        PROJECT_ID=<YOUR_PROJECT_ID>
+        # configure GCR
+        gcloud auth configure-docker
+        # build the image
+        docker build -t hf-lc-ray-fe:latest .
+        # tag the image for GCR
+        docker tag hf-lc-ray-fe:latest gcr.io/${PROJECT_ID}/hf-lc-ray-fe:latest
+        # push the image to GCR
+        docker push gcr.io/${PROJECT_ID}/hf-lc-ray-fe:latest
+        ```
+    1. Deploy frontend to the cluster. Open `src/frontend/deploy.yaml` and change `PROJECT_ID` to your project (you can also use `sed`:  `sed -i "s/YOUR_PROJECT/${PROJECT_ID}/" src/frontend/deploy.yaml` ). Then run
+        ```bash
+        kubectl apply -f deploy.yaml -n <YOUR_NAMESPACE>
+        ```
+    1. Find frontend IP on the services page: `hf-lc-ray-fe-service`: ![Frontend IP](./frontend_ip.png)
+    1. Click to navigate and give it a try! ![Frontend App](./frontend_app.png)
diff --git a/website/content/en/docs/Tutorials and Samples/genAI-LLM/e2e-genai-langchain-app/backend_ip.png b/website/content/en/docs/Tutorials and Samples/genAI-LLM/e2e-genai-langchain-app/backend_ip.png
new file mode 100644
index 000000000..8f004eb74
Binary files /dev/null and b/website/content/en/docs/Tutorials and Samples/genAI-LLM/e2e-genai-langchain-app/backend_ip.png differ
diff --git a/website/content/en/docs/Tutorials and Samples/genAI-LLM/e2e-genai-langchain-app/frontend_app.png b/website/content/en/docs/Tutorials and Samples/genAI-LLM/e2e-genai-langchain-app/frontend_app.png
new file mode 100644
index 000000000..05b449666
Binary files /dev/null and b/website/content/en/docs/Tutorials and Samples/genAI-LLM/e2e-genai-langchain-app/frontend_app.png differ
diff --git a/website/content/en/docs/Tutorials and Samples/genAI-LLM/e2e-genai-langchain-app/frontend_ip.png b/website/content/en/docs/Tutorials and Samples/genAI-LLM/e2e-genai-langchain-app/frontend_ip.png
new file mode 100644
index 000000000..e8a00acc4
Binary files /dev/null and b/website/content/en/docs/Tutorials and Samples/genAI-LLM/e2e-genai-langchain-app/frontend_ip.png differ
diff --git a/website/content/en/docs/Tutorials and Samples/genAI-LLM/e2e-genai-langchain-app/open_jupyter.png b/website/content/en/docs/Tutorials and Samples/genAI-LLM/e2e-genai-langchain-app/open_jupyter.png
new file mode 100644
index 000000000..331fe78ed
Binary files /dev/null and b/website/content/en/docs/Tutorials and Samples/genAI-LLM/e2e-genai-langchain-app/open_jupyter.png differ
diff --git a/website/content/en/docs/_index.md b/website/content/en/docs/_index.md
index 7797e06cb..e9333e288 100755
--- a/website/content/en/docs/_index.md
+++ b/website/content/en/docs/_index.md
@@ -19,4 +19,3 @@ A robust AI/ML platform considers the following layers:
 ## Architecture
 
 The diagram displays the open source tools, Kubernetes operators and frameworks that run on Kubernetes.
-
diff --git a/website/layouts/_default/content.html b/website/layouts/_default/content.html
new file mode 100644
index 000000000..f79b20df4
--- /dev/null
+++ b/website/layouts/_default/content.html
@@ -0,0 +1,19 @@
+<div class="td-content">
+	<h1>{{ .Title }}</h1>
+	{{ with .Params.description }}<div class="lead">{{ . | markdownify }}</div>{{ end }}
+	<header class="article-meta">
+		{{ partial "taxonomy_terms_article_wrapper.html" . }}
+		{{ if (and (not .Params.hide_readingtime) (.Site.Params.ui.readingtime.enable)) }}
+			{{ partial "reading-time.html" . }}
+		{{ end }}
+	</header>    
+	{{ .Content }}
+	{{ if (and (not .Params.hide_feedback) (.Site.Params.ui.feedback.enable) (.Site.GoogleAnalytics)) }}
+		{{ partial "feedback.html" .Site.Params.ui.feedback }}
+		<br />
+	{{ end }}
+	{{ if (.Site.Params.DisqusShortname) }}
+		<br />
+		{{ partial "disqus-comment.html" . }}
+	{{ end }}
+</div>
diff --git a/website/layouts/docs/baseof.html b/website/layouts/docs/baseof.html
new file mode 100644
index 000000000..eb3bc892f
--- /dev/null
+++ b/website/layouts/docs/baseof.html
@@ -0,0 +1,31 @@
+<!doctype html>
+<html itemscope itemtype="http://schema.org/WebPage" lang="{{ .Site.Language.Lang }}" class="no-js">
+  <head>
+    {{ partial "head.html" . }}
+  </head>
+  <body class="td-{{ .Kind }}{{ with .Page.Params.body_class }} {{ . }}{{ end }}">
+    <header>
+      {{ partial "navbar.html" . }}
+    </header>
+    <div class="container-fluid td-outer">
+      <div class="td-main">
+        <div class="row flex-xl-nowrap">
+          <aside class="col-12 col-md-3 col-xl-2 td-sidebar d-print-none">
+            {{ partial "sidebar.html" . }}
+          </aside>
+          <aside class="d-none d-xl-block col-xl-2 td-sidebar-toc d-print-none">
+            {{ partial "toc.html" . }}
+            {{ partial "taxonomy_terms_clouds.html" . }}
+          </aside>
+          <main class="col-12 col-md-9 col-xl-8 ps-md-5" role="main">
+            {{ partial "version-banner.html" . }}
+            {{ if not .Site.Params.ui.breadcrumb_disable }}{{ partial "breadcrumb.html" . }}{{ end }}
+            {{ block "main" . }}{{ end }}
+          </main>
+        </div>
+      </div>
+      {{ partial "footer.html" . }}
+    </div>
+    {{ partial "scripts.html" . }}
+  </body>
+</html>
\ No newline at end of file
diff --git a/website/layouts/docs/list.html b/website/layouts/docs/list.html
new file mode 100644
index 000000000..aaf79a422
--- /dev/null
+++ b/website/layouts/docs/list.html
@@ -0,0 +1,22 @@
+{{ define "main" }}
+<div class="td-content">
+	<h1>{{ .Title }}</h1>
+  {{ with .Params.description }}<div class="lead">{{ . | markdownify }}</div>{{ end }}
+	<header class="article-meta">
+		{{ partial "taxonomy_terms_article_wrapper.html" . }}
+		{{ if (and (not .Params.hide_readingtime) (.Site.Params.ui.readingtime.enable)) }}
+			{{ partial "reading-time.html" . }}
+		{{ end }}
+	</header>
+	{{ .Content }}
+        {{ partial "section-index.html" . }}
+	{{ if (and (not .Params.hide_feedback) (.Site.Params.ui.feedback.enable) (.Site.GoogleAnalytics)) }}
+		{{ partial "feedback.html" .Site.Params.ui.feedback }}
+		<br />
+	{{ end }}
+	{{ if (.Site.DisqusShortname) }}
+		<br />
+		{{ partial "disqus-comment.html" . }}
+	{{ end }}
+</div>
+{{ end }}