Merge branch 'ArmDeveloperEcosystem:main' into content_review

pareenaverma · web-flow · commit f57f5e9aa4bb · 2026-03-06T15:17:33.000-05:00
diff --git a/content/learning-paths/cross-platform/automate-mcp-with-testcontainers/_index.md b/content/learning-paths/cross-platform/automate-mcp-with-testcontainers/_index.md
@@ -1,20 +1,23 @@
 ---
 title: Automate MCP Server testing using Pytest and Testcontainers
 
+draft: true
+cascade:
+    draft: true
+
 minutes_to_complete: 60
 
-who_is_this_for: This is an intermediate topic for anyone interested in automating their end-to-end testing of MCP (Model Context Protocol) servers using specialized software packages called TestContainers and PyTest. 
+who_is_this_for: This is an introductory topic for software developers and QA engineers who want to automate integration testing of MCP (Model Context Protocol) servers using Testcontainers and PyTest.
 
 learning_objectives:
-    - Understand how TestContainers work for containerized testing of MCP servers.
-    - Write integration tests for MCP servers using PyTest and TestContainers.
-    - Configure GitHub Actions to run MCP integration tests in CI/CD pipelines.
+    - Set up Testcontainers with PyTest for containerized testing of MCP servers
+    - Write and run integration tests that validate MCP server functionality
+    - Configure GitHub Actions to automate MCP server testing in CI/CD pipelines
 
 prerequisites:
-    - A machine that can run Python 3 and Docker. 
-    - Familiarity with [Docker](/install-guides/docker/) and container concepts.
-    - Basic knowledge of Python and Pytest.
-    - The [Arm MCP Server](https://github.com/arm/mcp) running with AI assistant client.
+    - A computer with [Docker](/install-guides/docker/) and Python 3.11 or later installed
+    - Basic familiarity with Python, PyTest, and container concepts
+    - Familiarity with the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) specification
 
 author: Neethu Elizabeth Simon
 
@@ -36,6 +39,11 @@ tools_software_languages:
     - Testcontainers
     - MCP
 
+shared_path: true
+shared_between:
+    - servers-and-cloud-computing
+    - laptops-and-desktops
+
 further_reading:
     - resource:
         title: Arm MCP Server GitHub Repository
diff --git a/content/learning-paths/cross-platform/automate-mcp-with-testcontainers/introduction.md b/content/learning-paths/cross-platform/automate-mcp-with-testcontainers/introduction.md
@@ -8,9 +8,9 @@ layout: learningpathall
 
 ## What is MCP?
 
-The Model Context Protocol (MCP) is an open standard that enables AI assistants to securely connect to external data sources and tools. MCP servers provide AI models with context aware capabilities, such as code analysis, knowledge base lookups, and system introspection.
+The Model Context Protocol (MCP) is an open standard that enables AI assistants to securely connect to external data sources and tools. MCP servers provide AI models with context-aware capabilities, such as code analysis, knowledge base lookups, and system introspection.
 
-The Arm MCP Server is a reference implementation that provides AI assistants with tools and knowledge specifically for Arm architecture development, migration, and optimization. It includes capabilities like container architecture checking, code analysis with LLVM-MCA, and access to Arm Learning Paths.
+The Arm MCP Server provides AI assistants with tools and knowledge specifically for Arm architecture development, migration, and optimization. It includes capabilities like container architecture checking, code analysis with LLVM-MCA, and a knowledge base with content from Arm Learning Paths and other documentation.
 
 ## Why automate MCP server testing?
 
@@ -25,7 +25,7 @@ MCP servers expose multiple tools that AI assistants can invoke. As these tools
 
 Testcontainers is a Python library that provides lightweight, throwaway instances of Docker containers for testing. Instead of mocking your MCP server, you can spin up the actual Docker container, run tests against it, and tear it down automatically.
 
-![testcontainers alt-text#center](testcontainers.png "Figure 1. Testcontainers Flow")
+![Diagram showing Testcontainers workflow: test code creates a Docker container, runs tests against it, and automatically tears it down after completion#center](testcontainers.png "Figure 1. Testcontainers Flow")
 
 This approach offers several benefits:
 
diff --git a/content/learning-paths/cross-platform/automate-mcp-with-testcontainers/setup-environment.md b/content/learning-paths/cross-platform/automate-mcp-with-testcontainers/setup-environment.md
@@ -10,10 +10,18 @@ layout: learningpathall
 
 Before you begin, ensure you have the following installed on your machine:
 
-- Python 3.11 or later
+- Python 3.11 or later with the ability to create Python virtual environments
 - Docker Engine or Docker Desktop
 - Git
 
+If you are on Linux, you need the Python virtual environment package.
+
+For Debian or Ubuntu, run:
+
+```bash
+sudo apt install -y python3-venv
+```
+
 You can verify Docker is running by executing:
 
 ```bash
@@ -84,12 +92,6 @@ testcontainers
 pytest
 ```
 
-You can also install these packages directly:
-
-```bash
-pip install testcontainers pytest
-```
-
 ## Verify your setup
 
 Run a quick verification to ensure everything is configured correctly:
diff --git a/content/learning-paths/servers-and-cloud-computing/apache_arrow_and_flight/_index.md b/content/learning-paths/servers-and-cloud-computing/apache_arrow_and_flight/_index.md
@@ -1,13 +1,9 @@
 ---
 title: Deploy High-Performance Analytics with Apache Arrow and Arrow Flight on Google Cloud C4A Axion processors
 
-draft: true
-cascade:
-    draft: true
-    
 minutes_to_complete: 30
 
-who_is_this_for: This learning path is designed for data engineers, platform engineers, and developers who aim to build high-performance analytics pipelines on Arm64-based Google Cloud C4A Axion processors using Apache Arrow and Arrow Flight.
+who_is_this_for: This is an introductory topic for data engineers, platform engineers, and developers who aim to build high-performance analytics pipelines on Arm64-based Google Cloud C4A Axion processors using Apache Arrow and Arrow Flight.
 
 learning_objectives:
  - Deploy Apache Arrow–based data processing workloads on Google Cloud C4A Axion processors
diff --git a/content/learning-paths/servers-and-cloud-computing/apache_arrow_and_flight/background.md b/content/learning-paths/servers-and-cloud-computing/apache_arrow_and_flight/background.md
@@ -34,7 +34,7 @@ Common use cases include interactive analytics, data lake acceleration, machine
 
 To learn more, visit the [Apache Arrow website](https://arrow.apache.org/) and explore the [Arrow Flight documentation](https://arrow.apache.org/docs/format/Flight.html).
 
-## What you've accomplished and what's next
+## What you've learned and what's next
 
 In this section, you learned about:
 
diff --git a/content/learning-paths/servers-and-cloud-computing/apache_arrow_and_flight/columnar-analytics-with-arrow.md b/content/learning-paths/servers-and-cloud-computing/apache_arrow_and_flight/columnar-analytics-with-arrow.md
@@ -226,7 +226,7 @@ In the arrow-data bucket after refreshing, you should now see:
 
 ![MinIO object browser showing dataset.orc stored inside the arrow-data bucket alt-txt#center](images/datset-orc.png "MinIO Web UI displaying dataset.orc object in arrow-data bucket")
 
-## What you've accomplished and what's next
+## What you've learned and what's next
 
 In this section, you have:
 
@@ -238,10 +238,4 @@ In this section, you have:
 
 This forms the core analytics layer used by modern engines such as Spark, DuckDB, Trino, and Polars.
 
-## What's next
-
-In the next section, you will enable high-speed memory-to-memory analytics using Apache Arrow Flight, demonstrating:
-
-- gRPC-based data transfer
-- Zero-copy serialization
-- High-throughput analytics communication
+In the next section, you will enable high-speed memory-to-memory analytics using Apache Arrow Flight, demonstrating gRPC-based data transfer, zero-copy serialization, and high-throughput analytics communication.
diff --git a/content/learning-paths/servers-and-cloud-computing/apache_arrow_and_flight/environment-and-minio.md b/content/learning-paths/servers-and-cloud-computing/apache_arrow_and_flight/environment-and-minio.md
@@ -217,13 +217,11 @@ AWS_ACCESS_KEY_ID=minioadmin
 
 to communicate with MinIO exactly like Amazon S3.
 
-## What you've accomplished and what's next
+## What you've learned and what's next
 
 - Prepared a SUSE arm64 analytics environment
 - Installed Apache Arrow and dependencies
 - Deployed MinIO as S3-compatible object storage
 - Configured secure access for analytics workloads
 
-## What's next
-
 In the next section, you will use Apache Arrow to write and read Parquet and ORC datasets from MinIO using vectorized analytics APIs.
diff --git a/content/learning-paths/servers-and-cloud-computing/apache_arrow_and_flight/firewall-setup.md b/content/learning-paths/servers-and-cloud-computing/apache_arrow_and_flight/firewall-setup.md
@@ -45,7 +45,7 @@ Finally, select **Specified protocols and ports** under the **Protocols and port
 
 ![Google Cloud Console firewall rule form showing protocols and ports section with TCP selected and ports 9000,9001,8815 specified alt-txt#center](images/network-port.png "Specifying TCP ports for Apache Arrow and MinIO")
 
-## What you've accomplished and what's next
+## What you've learned and what's next
 
 You've successfully:
 
diff --git a/content/learning-paths/servers-and-cloud-computing/apache_arrow_and_flight/high-speed-analytics-with-arrow-flight.md b/content/learning-paths/servers-and-cloud-computing/apache_arrow_and_flight/high-speed-analytics-with-arrow-flight.md
@@ -133,7 +133,7 @@ Rows: 1000
 - Data was transferred directly from server memory
 - Arrow’s columnar format was preserved end-to-end
 
-## What you've accomplished and what's next
+## What you've learned and what's next
 
 In this section, you:
 
diff --git a/content/learning-paths/servers-and-cloud-computing/apache_arrow_and_flight/instance.md b/content/learning-paths/servers-and-cloud-computing/apache_arrow_and_flight/instance.md
@@ -46,7 +46,7 @@ A new browser window opens with a terminal connected to your VM.
 
 ![Browser-based SSH terminal window with black background showing Linux command prompt and Google Cloud branding at top alt-txt#center](images/gcp-shell.png "Terminal session connected to the VM")
 
-## What you've accomplished and what's next
+## What you've learned and what's next
 
 In this section:
 
diff --git a/content/learning-paths/servers-and-cloud-computing/arm-soc-migration-learning-path/_index.md b/content/learning-paths/servers-and-cloud-computing/arm-soc-migration-learning-path/_index.md
@@ -1,9 +1,5 @@
 ---
 title: Migrate applications between Arm platforms using Kiro Arm SoC Migration Power
-
-draft: true
-cascade:
-    draft: true
     
 minutes_to_complete: 60
 
diff --git a/content/learning-paths/servers-and-cloud-computing/arm-soc-migration-learning-path/graviton-development.md b/content/learning-paths/servers-and-cloud-computing/arm-soc-migration-learning-path/graviton-development.md
@@ -22,7 +22,7 @@ tar -xzf sensor-monitor.tar.gz
 cd sensor-monitor
 ```
 
-The archive includes the complete source code, a Makefile, and platform-specific implementations. You will analyze and migrate this code using the Arm SoC Migration Power.
+The archive includes the complete source code, a Makefile, and platform-specific implementations. You will analyze and migrate this code using the Perform Migration between Arm SoC Power.
 
 ### Upload to the Graviton instance for testing
 
@@ -89,4 +89,4 @@ In this section:
 - You confirmed the toolchain and build process work correctly on Arm64 Linux
 - You established your baseline for migration validation
 
-In the next section, you'll use the Arm SoC Migration Power to analyze the codebase and migrate it to the target platform.
+In the next section, you'll use the Perform Migration between Arm SoC Power to analyze the codebase and migrate it to the target platform.
diff --git a/content/learning-paths/servers-and-cloud-computing/arm-soc-migration-learning-path/migration.md b/content/learning-paths/servers-and-cloud-computing/arm-soc-migration-learning-path/migration.md
@@ -6,9 +6,9 @@ weight: 4
 layout: learningpathall
 ---
 
-## Use Arm SoC Migration Power for AI-guided migration
+## Use Perform Migration between Arm SoC Power for AI-guided migration
 
-In this section, you use the Arm SoC Migration Power to migrate your application between Arm-based platforms. The example demonstrates migration from:
+In this section, you use the Perform Migration between Arm SoC Power to migrate your application between Arm-based platforms. The example demonstrates migration from:
 
 - **Source:** AWS Graviton3 (Neoverse-V1, Arm64 Linux, cloud deployment)
 - **Target:** Raspberry Pi 5 (BCM2712, Cortex-A76, edge deployment)
@@ -19,11 +19,11 @@ For each step below, an example prompt for the Graviton-to-Pi-5 scenario is prov
 
 ### Initiate migration
 
-Open Kiro and describe your migration clearly using the Arm SoC Migration Power.
+Open Kiro and describe your migration clearly using the Perform Migration between Arm SoC Power.
 
 Example prompt:
 ```
-I want to use the Arm SoC Migration Power to migrate my sensor monitoring 
+I want to use the Perform Migration between Arm SoC Power to migrate my sensor monitoring 
 application from AWS Graviton3 to Raspberry Pi 5 (BCM2712). The application 
 currently uses simulated sensors on Graviton and needs to work with real 
 GPIO and SPI hardware on the Pi 5.
@@ -184,7 +184,7 @@ add_executable(sensor_monitor ${COMMON_SOURCES} ${PLATFORM_SOURCES})
 
 In this section:
 
-- You used the Arm SoC Migration Power to analyze architecture differences between Graviton3 and BCM2712
+- You used the Perform Migration between Arm SoC Power to analyze architecture differences between Graviton3 and BCM2712
 - You designed a HAL that abstracts platform differences and preserves portability
 - You generated platform-specific code for the target device
 - You updated the build system for multi-platform support
diff --git a/content/learning-paths/servers-and-cloud-computing/arm-soc-migration-learning-path/setup.md b/content/learning-paths/servers-and-cloud-computing/arm-soc-migration-learning-path/setup.md
@@ -36,15 +36,14 @@ The Arm SoC Migration Power extends Kiro with specialized knowledge and tools fo
 
 - Open Kiro IDE
 - Navigate to the **Powers** panel. Press Cmd + Shift + P (Mac) or Ctrl + Shift + P (Windows)
-- Select the Arm SoC Migration Power in the **Recommended** section
+- Select the Perform Migration between Arm SoC in the **Recommended** section
 - Select **Install**
 
-### Verify installation
-
-After installation, enter the following prompt in Kiro:
+### Verify install
+After installation, you can either click on the "Try power" button or enter the following prompt in Kiro:
 
 ```text
-I just installed the Arm SoC Migration Power and want to use it.
+I just installed the arm-soc-migration power and want to use it.
 ```
 The Power should respond and guide you through any additional setup steps.
 
@@ -58,7 +57,7 @@ It supports migrations across a wide range of Arm-based platforms, including:
 
 ### Install prerequisites
 
-The Arm SoC Migration Power uses the Arm MCP (Model Context Protocol) server to provide specialized Arm migration capabilities. The Arm MCP server runs via Docker.
+The Perform Migration between Arm SoC uses the Arm MCP (Model Context Protocol) server to provide specialized Arm migration capabilities. The Arm MCP server runs via Docker.
 
 Install Docker on your local development machine (required for ARM MCP server):
 
@@ -87,7 +86,7 @@ docker --version
 ```
 
 {{% notice Note %}}
-Ensure Docker is running before using the Arm SoC Migration Power. The Power will automatically pull and run the Arm MCP server container when needed.
+Ensure Docker is running before using the Perform Migration between Arm SoC. The Power will automatically pull and run the Arm MCP server container when needed.
 {{% /notice %}}
 
 ### Launch AWS Graviton3 instance (source platform)
@@ -170,7 +169,7 @@ sudo dnf install -y gcc make wget tar
 
 In this section:
 
-- You installed Kiro IDE and the Arm SoC Migration Power
+- You installed Kiro IDE and the Perform Migration between Arm SoC Power
 - You provisioned an AWS Graviton3 instance as your source platform
 - You installed the build tools needed for the migration example
 
diff --git a/content/learning-paths/servers-and-cloud-computing/arm-soc-migration-learning-path/validation.md b/content/learning-paths/servers-and-cloud-computing/arm-soc-migration-learning-path/validation.md
@@ -10,7 +10,7 @@ layout: learningpathall
 
 Migration is not complete until the application is validated on both source and target platforms under realistic conditions.
 
-In this section, you will use the Arm SoC Migration Power's testing recommendations to:
+In this section, you will use the Perform Migration between Arm SoC Power's testing recommendations to:
 
 - Verify functional correctness
 - Confirm platform compatibility
@@ -114,6 +114,6 @@ The Power will analyze platform-specific characteristics. Example analysis:
 
 ## What you've accomplished
 
-You've completed the full migration workflow: you validated the source platform build, cross-compiled for the target, ran platform-specific tests, and compared performance between Graviton3 and Raspberry Pi 5. The Arm SoC Migration Power guided each step with architecture-aware recommendations rather than generic advice.
+You've completed the full migration workflow: you validated the source platform build, cross-compiled for the target, ran platform-specific tests, and compared performance between Graviton3 and Raspberry Pi 5. The Perform Migration between Arm SoC Power guided each step with architecture-aware recommendations rather than generic advice.
 
 The Discovery → Analysis → Planning → Implementation → Validation workflow you followed here applies to any Arm SoC migration, whether cloud-to-edge, edge-to-edge, or between any pair of Arm-based platforms. The HAL pattern preserves your application's business logic across different Arm SoCs so you can adapt the same codebase without starting from scratch.
