Merge pull request #3447 from anupras-mohapatra-arm/summaries-and-faqs

adding 20 summaries and faqs to servers-and-cloud-computing

Author: jasonrandrews

content/learning-paths/servers-and-cloud-computing/adler32-kiro/_index.md

@@ -19,9 +19,59 @@ prerequisites:
   - An Arm Neoverse server running Ubuntu 26.04 with SVE support (for example, AWS Graviton3 or later, Google Axion, or Microsoft Cobalt 100)
   - Basic familiarity with C programming
 
+# START generated_summary_faq
+generated_summary_faq:
+  template_version: summary-faq-v3
+  generated_at: '2026-06-26T17:15:35Z'
+  generator: ai
+  ai_assisted: true
+  ai_review_required: true
+  model: gpt-5
+  prompt_template: summary-faq-v3
+  source_hash: 707a88ccf315ebefda3768211ac8a0ae0d142e6e28aca5597f6730b9e091d249
+  summary_generated_at: '2026-06-26T17:15:35Z'
+  summary_source_hash: 707a88ccf315ebefda3768211ac8a0ae0d142e6e28aca5597f6730b9e091d249
+  faq_generated_at: '2026-06-26T17:15:35Z'
+  faq_source_hash: 707a88ccf315ebefda3768211ac8a0ae0d142e6e28aca5597f6730b9e091d249
+  summary: >-
+    You'll transform a scalar Adler-32 checksum in C into a vector-length-agnostic
+    SVE implementation on Arm Neoverse servers with help from an AI coding assistant connected to
+    the Arm MCP server. First, you'll set up a small project and capture a reproducible scalar
+    baseline, then apply the `NMAX` technique to defer modulo operations and expose vectorization
+    opportunities. You'll learn core SVE concepts in context, including predication with `svwhilelt`,
+    reductions with `svaddv` for the `a` accumulator, and building the `b` accumulator with `svdot`
+    and weighted contributions. After each stage, you'll validate correctness against the scalar version
+    and measure performance changes.
+  faqs:
+  - question: How do I know my environment is ready to use SVE intrinsics?
+    answer: >-
+      Use an Arm Neoverse server with SVE support that matches the prerequisites.
+      If in doubt, choose an instance class listed in the Learning Path, such as one based on AWS
+      Graviton3 or later, and run the scalar baseline before writing SVE code.
+  - question: What should I record for the baseline before starting vectorization?
+    answer: >-
+      Capture the scalar Adler-32 checksum for a known input and record the timing you will compare
+      against later. Keep the input size and conditions consistent so results are reproducible
+      when you switch to the SVE version.
+  - question: When applying the `NMAX` optimization, where should the modulo be performed?
+    answer: >-
+      Defer the modulo operation and apply it after processing a block instead of on every byte.
+      This reduces division work and removes the dependency that blocks vectorization of the inner
+      loop.
+  - question: Which parts of the Adler-32 loop should be vectorized first?
+    answer: >-
+      Vectorize the `a` accumulator first because it maps cleanly to vector loads and a reduction
+      with `svaddv`. Then handle the `b` accumulator using a weighted approach and `svdot`, as each
+      element contributes differently within a block.
+  - question: How should I handle data lengths that are not a multiple of the SVE vector length?
+    answer: >-
+      Use a vector-length-agnostic loop with predication. Generate a predicate with `svwhilelt`
+      and apply it to loads and arithmetic so tails are processed correctly on any SVE width.
+# END generated_summary_faq
+
 author: Jason Andrews
 
-generate_summary_faq: true
+generate_summary_faq: false
 rerun_summary: false
 rerun_faqs: false
 

content/learning-paths/servers-and-cloud-computing/ai-agent-on-cpu/_index.md

@@ -17,9 +17,57 @@ prerequisites:
     - Basic understanding of Python and prompt engineering.
     - Understanding of LLM fundamentals.
 
+# START generated_summary_faq
+generated_summary_faq:
+  template_version: summary-faq-v3
+  generated_at: '2026-06-26T17:17:51Z'
+  generator: ai
+  ai_assisted: true
+  ai_review_required: true
+  model: gpt-5
+  prompt_template: summary-faq-v3
+  source_hash: 275878b5aa4c27dee394da12ad8b80e4c0d0235b3ddce66b1fe3f0e056ef3da9
+  summary_generated_at: '2026-06-26T17:17:51Z'
+  summary_source_hash: 275878b5aa4c27dee394da12ad8b80e4c0d0235b3ddce66b1fe3f0e056ef3da9
+  faq_generated_at: '2026-06-26T17:17:51Z'
+  faq_source_hash: 275878b5aa4c27dee394da12ad8b80e4c0d0235b3ddce66b1fe3f0e056ef3da9
+  summary: >-
+    You'll build and run a function-calling AI agent on Arm servers using
+    `llama.cpp` and the `llama-cpp-agent` framework with KleidiAI optimizations. After preparing
+    an Arm-based Ubuntu environment and obtaining a quantized Llama 3.1 8B model, you'll create
+    `agent.py` to connect the model to tool functions and structured outputs. You'll learn how the
+    agent selects functions based on input intent, then test the end-to-end workflow to observe
+    tool invocation and responses. By the end, you'll run an AI agent backed by an optimized
+    LLM, verify that the model loads, and inspect outputs that demonstrate function selection
+    and result handling.
+  faqs:
+  - question: Which operating system and instance setup do the steps target?
+    answer: >-
+      The steps are designed for Arm servers running Ubuntu 22.04 LTS. They were tested on an
+      Amazon EC2 `m7g.xlarge` instance powered by Graviton3, and expect at least four cores, 16 GB of memory, and
+      32 GB of disk.
+  - question: What should be ready before running the `agent.py` script?
+    answer: >-
+      Build `llama.cpp` and download the quantized Llama 3.1 8B model. Ensure the Python dependencies,
+      including `llama-cpp-agent` and `llama-cpp-python`, are installed in the active environment.
+  - question: Where should the model file be placed for the script to find it?
+    answer: >-
+      Place the downloaded model at the path referenced by `model_path` in `agent.py`. Keep the directory
+      structure consistent with the code so the model loads without modification.
+  - question: How do I know the agent used a function call rather than replying directly?
+    answer: >-
+      Check the script’s output for a selected tool/function name and its arguments, followed
+      by the function’s return data. If the agent replies directly, you will see a model-generated
+      response without a function invocation.
+  - question: How are functions exposed to the LLM in this application?
+    answer: >-
+      Functions are declared in `agent.py` and registered through `llama-cpp-agent`. The LLM analyzes
+      the input and selects among the predefined functions based on intent and context.
+# END generated_summary_faq
+
 author: Andrew Choi
 
-generate_summary_faq: true
+generate_summary_faq: false
 rerun_summary: false
 rerun_faqs: false
 
@@ -56,4 +104,3 @@ weight: 1                       # _index.md always has weight of 1 to order corr
 layout: "learningpathall"       # All files under learning paths have this same wrapper
 learning_path_main_page: "yes"  # This should be surfaced when looking for related content. Only set for _index.md of learning path content.
 ---
-

content/learning-paths/servers-and-cloud-computing/aks/_index.md

@@ -15,9 +15,57 @@ prerequisites:
     - An Azure account
     - A machine with [Terraform](/install-guides/terraform/), [Azure CLI](/install-guides/azure-cli), and [Kubectl](/install-guides/kubectl/) installed
 
+# START generated_summary_faq
+generated_summary_faq:
+  template_version: summary-faq-v3
+  generated_at: '2026-06-26T17:19:52Z'
+  generator: ai
+  ai_assisted: true
+  ai_review_required: true
+  model: gpt-5
+  prompt_template: summary-faq-v3
+  source_hash: 01c5cc8930650a8d81d67d4c48b62e0f9d7b1ebfc2d09a552e11046fb982fc52
+  summary_generated_at: '2026-06-26T17:19:52Z'
+  summary_source_hash: 01c5cc8930650a8d81d67d4c48b62e0f9d7b1ebfc2d09a552e11046fb982fc52
+  faq_generated_at: '2026-06-26T17:19:52Z'
+  faq_source_hash: 01c5cc8930650a8d81d67d4c48b62e0f9d7b1ebfc2d09a552e11046fb982fc52
+  summary: >-
+    You'll automate an Arm-based Azure Kubernetes Service (AKS) cluster deployment
+    with Terraform and then deploy a WordPress example workload. First, you'll configure AKS to use Azure
+    Dpsv5 virtual machines based on Ampere Altra Arm processors by following Terraform-driven
+    provisioning steps. After the cluster is available, you'll use a concise Kubernetes setup to run
+    WordPress backed by MySQL by creating three manifests: `kustomization.yaml`, `mysql-deployment.yaml`,
+    and `wordpress-deployment.yaml`. The result is a working application on an Arm-based AKS node
+    pool, with a clear separation between cluster provisioning and workload deployment to support
+    repeatable infrastructure-as-code workflows.
+  faqs:
+  - question: Can I run Terraform and `kubectl` from my laptop, or do I need an Azure VM?
+    answer: >-
+      You can use any computer with the required tools installed, including a desktop, laptop,
+      or a virtual machine. The steps don't require running on an Azure VM.
+  - question: How do I confirm the AKS cluster was created successfully before deploying workloads?
+    answer: >-
+      Verify that the AKS resource appears in the Azure portal and is reported as available. You
+      can proceed after the cluster is up and reachable with your configured tooling.
+  - question: How do I ensure the AKS node pool is Arm-based?
+    answer: >-
+      Configure the node pool in Terraform to use an Azure Dpsv5 VM size, which runs on Ampere
+      Altra Arm-based processors. Confirm that the VM size in your configuration references a
+      Dpsv5 option.
+  - question: Which files do I need to create for the WordPress example?
+    answer: >-
+      Create `kustomization.yaml`, `mysql-deployment.yaml`, and `wordpress-deployment.yaml` exactly
+      as shown in the Learning Path. The `kustomization.yaml` file includes a `secretGenerator` entry for
+      a secret named `mysql-pass`.
+  - question: What result should I expect after applying the WordPress manifests?
+    answer: >-
+      Kubernetes resources for MySQL and WordPress are created as defined in the YAML files. Continue
+      after the deployment is reported as ready by your tooling and the resources appear as expected.
+# END generated_summary_faq
+
 author: Jason Andrews
 
-generate_summary_faq: true
+generate_summary_faq: false
 rerun_summary: false
 rerun_faqs: false
 
@@ -67,4 +115,3 @@ weight: 1                       # _index.md always has weight of 1 to order corr
 layout: "learningpathall"       # All files under learning paths have this same wrapper
 learning_path_main_page: "yes"  # This should be surfaced when looking for related content. Only set for _index.md of learning path content.
 ---
-

content/learning-paths/servers-and-cloud-computing/alluxio-cobalt/_index.md

@@ -19,9 +19,53 @@ prerequisites:
   - Familiarity with SSH and remote server access
   - Basic understanding of data processing, storage systems, and caching concepts
 
+# START generated_summary_faq
+generated_summary_faq:
+  template_version: summary-faq-v3
+  generated_at: '2026-06-26T17:21:44Z'
+  generator: ai
+  ai_assisted: true
+  ai_review_required: true
+  model: gpt-5
+  prompt_template: summary-faq-v3
+  source_hash: a518336582a04b9bd5646608eeec314ec70fc6f5121299677d21ddb8819dcb85
+  summary_generated_at: '2026-06-26T17:21:44Z'
+  summary_source_hash: a518336582a04b9bd5646608eeec314ec70fc6f5121299677d21ddb8819dcb85
+  faq_generated_at: '2026-06-26T17:21:44Z'
+  faq_source_hash: a518336582a04b9bd5646608eeec314ec70fc6f5121299677d21ddb8819dcb85
+  summary: >-
+    You'll deploy Alluxio on an Arm-based virtual machine powered by Azure Cobalt 100
+    and use it as a data orchestration and caching layer for Apache Spark. After creating a Dpsv6
+    VM, you'll enable the Alluxio Web UI by adding an inbound rule for TCP port 19999 in the Azure
+    Network Security Group. You'll install and configure Alluxio with local storage and memory-backed
+    caching, then install Apache Spark under `/opt` and configure Spark to read through Alluxio.
+    The result is a set of read workloads comparing uncached and cached access that you can use to interpret the impact of in-memory caching on analytics tasks.
+  faqs:
+  - question: Which Azure VM size should I select for this setup?
+    answer: >-
+      Use a general-purpose VM in the Dpsv6 series to run on Azure Cobalt 100 Arm-based processors.
+      The creation steps focus on this series.
+  - question: How do I allow access to the Alluxio Web UI from the internet?
+    answer: >-
+      Add an inbound rule for TCP port 19999 in the Azure Network Security Group (NSG). You can attach the NSG to the VM’s network interface or its subnet.
+  - question: How can I confirm the Alluxio Web UI is reachable after opening the port?
+    answer: >-
+      After creating the NSG rule for port 19999, browse to the VM’s public IP using that port
+      to load the Alluxio Web UI. If it doesn't load, verify the NSG is correctly attached and
+      the rule allows inbound traffic.
+  - question: What preparation should I do on the VM before installing Alluxio?
+    answer: >-
+      Update the package index, apply available updates, and install basic tools such as `wget`,
+      `curl`, and `tar`. These tools download and extract the required software.
+  - question: Where should Apache Spark be installed and how is it used with Alluxio?
+    answer: >-
+      Install Apache Spark and place it under `/opt` as shown in the Learning Path. Spark is then configured
+      to read through Alluxio, so frequently accessed data can be cached in memory.
+# END generated_summary_faq
+
 author: Pareena Verma
 
-generate_summary_faq: true
+generate_summary_faq: false
 rerun_summary: false
 rerun_faqs: false
 

content/learning-paths/servers-and-cloud-computing/apache_arrow_and_flight/_index.md

@@ -19,9 +19,59 @@ prerequisites:
   - Basic understanding of data formats such as Parquet or ORC
   - Familiarity with Linux command-line operations
 
+# START generated_summary_faq
+generated_summary_faq:
+  template_version: summary-faq-v3
+  generated_at: '2026-06-26T17:22:13Z'
+  generator: ai
+  ai_assisted: true
+  ai_review_required: true
+  model: gpt-5
+  prompt_template: summary-faq-v3
+  source_hash: 90b638385267e085ea07a70a1c23f16578aa3caaeabeca1f651bcdcac5bf38fb
+  summary_generated_at: '2026-06-26T17:22:13Z'
+  summary_source_hash: 90b638385267e085ea07a70a1c23f16578aa3caaeabeca1f651bcdcac5bf38fb
+  faq_generated_at: '2026-06-26T17:22:13Z'
+  faq_source_hash: 90b638385267e085ea07a70a1c23f16578aa3caaeabeca1f651bcdcac5bf38fb
+  summary: >-
+    You'll set up a single-node analytics stack on Google Cloud C4A virtual machines powered by Google Axion processors. First, you'll provision an `arm64` C4A instance, configure
+    Google Cloud firewall rules for MinIO and Arrow Flight, and prepare a SUSE Linux Enterprise
+    Server environment with Apache Arrow. Then, you'll integrate MinIO object storage and use Apache Arrow
+    to read and write Parquet and ORC datasets, and explore predicate pushdown and column pruning
+    in a practical workflow. By the end, you'll have a working setup that serves and moves columnar
+    data with Arrow Flight and validates end-to-end data access using Arrow with MinIO on Arm-based
+    infrastructure.
+  faqs:
+  - question: Which Google Cloud instance and OS image should I choose for this setup?
+    answer: >-
+      Use a Google Axion C4A `arm64` virtual machine; the steps use `c4a-standard-4` (4 vCPUs, 16 GB).
+      Select an `arm64` SUSE Linux Enterprise Server image as shown in the Learning Path.
+  - question: Which network ports must be opened for the stack to work?
+    answer: >-
+      Open the ports listed in the firewall step, including MinIO’s S3 API on port 9000 and the
+      Arrow Flight port specified there. After creating the rule, confirm that inbound connections
+      to those services succeed from allowed sources.
+  - question: How do I confirm MinIO is ready before running Arrow jobs?
+    answer: >-
+      Verify the MinIO service is running and accessible on the configured port (including 9000
+      for the S3 API). Follow the Learning Path instructions to store a test object and read it back
+      to validate access.
+  - question: What result should I expect when testing predicate pushdown and column pruning with
+      Arrow?
+    answer: >-
+      Operations should return only the filtered rows and the selected columns from Parquet or
+      ORC. If unfiltered rows or extra columns appear, review the dataset, filter, and projection
+      arguments used in the example.
+  - question: How do I know the Arrow Flight server is reachable from a client?
+    answer: >-
+      Use the address and port from the steps. The client should connect and list or fetch data
+      without errors. Connection timeouts or refusals usually indicate a missing firewall rule
+      or a server that's not running.
+# END generated_summary_faq
+
 author: Pareena Verma
 
-generate_summary_faq: true
+generate_summary_faq: false
 rerun_summary: false
 rerun_faqs: false
 
@@ -77,4 +127,3 @@ weight: 1
 layout: "learningpathall"
 learning_path_main_page: yes
 ---
-