Guides 2

src/content/Docs/_sequence.ts

@@ -83,6 +83,7 @@ export const docsSequence = [
               { label: "AI Art" },
               { label: "Jupyter Notebook" },
               { label: "Text-Generation-WebUI" },
+              { label: "Mistral 7B"}
             ],
           },
           {
@@ -136,11 +137,22 @@ export const docsSequence = [
           },
           {
             label: "Data Visualizations",
-            subItems: [{ label: "Redash" }, { label: "Dash" }],
+            subItems: [
+              { label: "Redash" },
+              { label: "Dash" },
+              { label: "Metabase" },
+              { label: "KNIME"},
+            ],
           },
           {
             label: "Frameworks",
-            subItems: [{ label: "Next.js" }],
+            subItems: [
+              { label: "Next.js" },
+              { label: "React" },
+              { label: "Astro" },
+              { label: "Angular" },
+              { label: "Django" },
+            ],
           },
           {
             label: "Benchmarkings",

src/content/Docs/guides/data-viz/dash/index.md

@@ -2,8 +2,8 @@
 categories: ["Guides"]
 tags: ["Data Visualization"]
 weight: 1
-title: "Redash"
-linkTitle: "Redash"
+title: "Dash"
+linkTitle: "Dash"
 ---
 
 [Dash](https://dash.plotly.com) is an open-source web framework for Python that enables you to build interactive web applications, typically for data visualization, using Plotly. It's particularly useful for creating complex dashboards with minimal coding effort.

src/content/Docs/guides/data-viz/dataiku/index.md

@@ -0,0 +1,92 @@
+---
+categories: ["Guides"]
+tags: ["Data Visualization"]
+weight: 1
+title: "DATAIKU"
+linkTitle: "DATAIKU"
+---
+
+**Prerequisites**
+
+1. Install the [Akash CLI](/docs/getting-started/quickstart-guides/akash-cli/) on your machine.
+2. Fund your Akash wallet with the required AKT for deployment.
+3. Set up the necessary environment variables:
+    - AKASH_NODE (Akash node endpoint)
+    - AKASH_KEY_NAME (Your Akash wallet name)
+    - AKASH_CHAIN_ID (The Akash chain ID)
+    - AKASH_ACCOUNT_ADDRESS (Your wallet address)
+
+## Step 1: Create the `deploy.yaml` File
+
+To get started, create a new file called `deploy.yaml`. This file will contain the configuration for deploying Dataiku on Akash, including settings for resources, environment variables, and services.
+
+Below is an example `deploy.yaml` file that you can modify to fit your specific requirements:
+
+```
+version: "2.0"
+
+services:
+  dataiku:
+    image: "dataiku/dss:latest"  # Replace with the specific Dataiku DSS image version if needed
+    expose:
+      - port: 10000              # The default port for Dataiku DSS
+        as: 80
+        to:
+          - global
+    env:
+      DSS_PORT: 10000             # Dataiku DSS environment variable for the port
+      DSS_USER: "dataiku"         # Default user for the DSS
+      DSS_LICENSE_KEY: "your-license-key" # Dataiku license key (replace this with a valid license key)
+    args:
+      - "start"                   # Command to start Dataiku DSS
+
+profiles:
+  compute:
+    dataiku:
+      resources:
+        cpu:
+          units: 1
+        memory:
+          size: "4Gi"             # Memory allocation for the Dataiku instance
+        storage:
+          size: "10Gi"            # Storage space required for Dataiku installation and data processing
+
+deployment:
+  dataiku:
+    profile: dataiku
+    count: 1                      # Number of instances to deploy
+
+```
+
+## Step 2: Deploy the Application
+
+1. **Initialize Deployment**: Use the Akash CLI to initialize the deployment:
+
+```
+akash tx deployment create deploy.yaml --from $AKASH_KEY_NAME --chain-id $AKASH_CHAIN_ID --node $AKASH_NODE
+```
+
+2. **Check Lease Status**: After deploying, you need to monitor the lease and ensure it’s active. Run:
+
+```
+akash query market lease list --owner $AKASH_ACCOUNT_ADDRESS --node $AKASH_NODE --chain-id $AKASH_CHAIN_ID
+```
+3. **Obtain Lease Information**: Once the lease is confirmed, fetch the details:
+
+```
+akash query market lease status --owner $AKASH_ACCOUNT_ADDRESS --chain-id $AKASH_CHAIN_ID --node $AKASH_NODE --provider <provider-address>
+```
+Make sure to replace <provider-address> with the provider's actual address from the lease status.
+
+4. **Access Dataiku**: Use the deployment IP address and assigned port to access Dataiku through a browser. The URL format will be:
+
+```
+http://<provider-ip>:<port>
+```
+Replace <provider-ip> and <port> with the actual values from your lease information.
+
+## Step 3: Configure and Secure Dataiku (Optional)
+To secure your Dataiku instance:
+
+- Configure firewall settings to restrict access to trusted IPs only.
+- Set up SSH tunneling if your application requires more secure access.

src/content/Docs/guides/data-viz/knime/index.md

@@ -0,0 +1,112 @@
+---
+categories: ["Guides"]
+tags: ["Data Visualization"]
+weight: 1
+title: "KNIME"
+linkTitle: "KNIME"
+---
+
+To deploy KNIME (an open-source data analytics platform) on Akash, we’ll guide you through the steps to create a `deploy.yaml` file, leveraging Akash’s SDL template structure. This file will specify the configuration for deploying KNIME as a Docker container on Akash’s decentralized cloud infrastructure.
+
+## Prerequisites
+
+1. **Akash Wallet**: Ensure you have an Akash wallet and sufficient tokens for deployment.
+2. **Akash CLI**: Install and configure the Akash CLI.
+3. **Dockerized KNIME Image**: You’ll need a Docker image of KNIME. You can either build your own or use a pre-built image from Docker Hub.
+
+## Step 1: Define the deploy.yaml file Structure
+
+Akash SDL (Service Definition Language) files are structured YAML files used to specify resources and configurations for your deployment. Below is a sample `deploy.yaml` file that includes a configuration to deploy KNIME on Akash.
+
+### `deploy.yaml` File
+
+Here’s a structured `deploy.yaml` file for deploying KNIME on Akash:
+
+```
+---
+version: "2.0"
+
+services:
+  knime:
+    image: "knime/knime"  # Docker image for KNIME
+    expose:
+      - port: 8080
+        as: 80
+        to:
+          - global: true   # Allow global access to KNIME UI
+        proto: tcp
+
+profiles:
+  compute:
+    knime-server:
+      resources:
+        cpu:
+          units: 1      # Adjust CPU units as needed
+        memory:
+          size: 2Gi     # Allocate at least 2GB of memory for KNIME
+        storage:
+          size: 5Gi     # Allocate storage space
+  placement:
+    west-coast:
+      attributes:
+        host: akash       # Provider attribute
+      pricing:
+        knime-server:
+          denom: uakt
+          amount: 100     # Specify the bid price per block
+
+deployment:
+  knime:
+    west-coast:
+      profile: knime-server
+      count: 1
+```
+
+## Step 2: Configure Each Section
+
+1. **Services Section**:
+
+- Define the `knime` service and specify the Docker image for KNIME.
+- Set up port `8080` (or the port KNIME uses) to be exposed globally so it’s accessible via a web interface.
+
+2. **Profiles Section**:
+
+- The compute profile outlines the hardware resources.
+    - CPU Units: Define the number of CPU units.
+    - Memory Size: Allocate memory (at least 2Gi for KNIME).
+    - Storage Size: Set storage size based on data needs.
+- The placement profile allows you to specify the deployment region and pricing details.
+
+3. **Deployment Section**:
+
+- Here, you reference the profiles and regions you defined.
+- Set the profile (`knime`) and the count (1 instance for this example).
+
+## Step 3: Deploy on Akash
+
+1. **Create the Deploymen**t:
+
+- Use the Akash CLI to submit your deployment:
+
+```
+akash tx deployment create deploy.yaml --from <wallet_name> --node <node>
+```
+
+2. **Set Up Lease**:
+
+- Once deployed, create a lease with the provider to make your service accessible:
+```
+akash tx deployment lease create <deployment-id> --from <wallet_name> --node <node>
+```
+
+3. **Access KNIME**:
+
+- After successful deployment, retrieve the lease’s public IP and navigate to <public-ip>:80 to access the KNIME interface.
+
+## Notes and Tips
+- **Pricing**: Set the amount for `uakt` tokens based on network costs.
+- **Memory & Storage**: Adjust resource allocations depending on the complexity of workflows in KNIME.
+- **Monitoring**: Monitor deployment status using the Akash CLI to ensure successful setup and to check resource usage.
+
+This `deploy.yaml` file should give you a solid starting point for deploying KNIME on Akash with adjustable resources and configuration for custom setups. 
+

src/content/Docs/guides/data-viz/metabase/index.md

@@ -0,0 +1,7 @@
+---
+categories: ["Guides"]
+tags: ["Data Visualization"]
+weight: 1
+title: "Metabase"
+linkTitle: "Metabase"
+---