Merge pull request #2005 from ArmDeveloperEcosystem/main

Production update

Author: jasonrandrews

.wordlist.txt

@@ -4184,4 +4184,20 @@ subgenre
 submodule
 subword
 techcrunch
-transformative
+transformative
+Aude
+Gian
+Iodice
+SmolLM
+VME
+Vuilliomenet
+cpus
+fLO
+invalidations
+libtensorflowlite
+macos
+multithreaded
+Wix's
+ngrok's
+qs
+qu

assets/contributors.csv

@@ -85,5 +85,9 @@ Yiyang Fan,Arm,,,,
 Julien Jayat,Arm,,,,
 Geremy Cohen,Arm,geremyCohen,geremyinanutshell,,
 Barbara Corriero,Arm,,,,
-Nina Drozd,Arm,,ninadrozd,,
+Nina Drozd,Arm,NinaARM,ninadrozd,,
 Jun He,Arm,JunHe77,jun-he-91969822,,
+Gian Marco Iodice,Arm,,,,
+Aude Vuilliomenet,Arm,,,,
+Andrew Kilroy,Arm,,,,
+Peter Harris,Arm,,,,

content/learning-paths/cross-platform/mcp-ai-agent/intro-to-mcp-uv.md

@@ -17,7 +17,7 @@ The Model Context Protocol (MCP) is an open specification designed to connect La
 
 - **Security by design:** MCP encourages running servers inside your own infrastructure, so sensitive data stays within your infrastructure unless explicitly shared.
 
-- **Cross-ecosystem momentum:** recent roll-outs from an official C# SDK to Wix’s production MCP server and Microsoft’s Azure support show the MCP spec is gathering real-world traction.
+- **Cross-ecosystem momentum:** recent roll-outs from an official C# SDK to Wix's production MCP server and Microsoft’s Azure support show the MCP spec is gathering real-world traction.
 
 ## What is uv?
 

content/learning-paths/cross-platform/mcp-ai-agent/mcp-server.md

@@ -115,7 +115,7 @@ INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)
 
 You will now use ngrok to expose your locally running MCP server to the public internet over HTTPS.
 
-1. Add ngrok’s repo to the apt package manager and install:
+1. Add ngrok's repo to the apt package manager and install:
 ```bash
 curl -sSL https://ngrok-agent.s3.amazonaws.com/ngrok.asc \
   | sudo tee /etc/apt/trusted.gpg.d/ngrok.asc >/dev/null \

content/learning-paths/embedded-and-microcontrollers/_index.md

@@ -61,6 +61,7 @@ tools_software_languages_filter:
 - GitHub: 3
 - GitLab: 1
 - Himax SDK: 1
+- Hugging Face: 3
 - IP Explorer: 4
 - Jupyter Notebook: 1
 - K3s: 1

content/learning-paths/embedded-and-microcontrollers/llama-python-cpu/_index.md

@@ -28,7 +28,7 @@ tools_software_languages:
     - GenAI
     - Raspberry Pi
     - Python
-
+    - Hugging Face
 
 further_reading:
     - resource:

content/learning-paths/embedded-and-microcontrollers/rpi-llama3/_index.md

@@ -31,6 +31,7 @@ tools_software_languages:
     - LLM
     - GenAI
     - Raspberry Pi
+    - Hugging Face
 
 
 

content/learning-paths/embedded-and-microcontrollers/yolo-on-himax/_index.md

@@ -32,6 +32,8 @@ armips:
 tools_software_languages:
     - Himax SDK
     - Python
+    - Hugging Face
+
 operatingsystems:
     - Linux
     - macOS

content/learning-paths/laptops-and-desktops/_index.md

@@ -10,11 +10,11 @@ operatingsystems_filter:
 - Android: 2
 - ChromeOS: 1
 - Linux: 31
-- macOS: 7
-- Windows: 43
+- macOS: 8
+- Windows: 44
 subjects_filter:
 - CI-CD: 5
-- Containers and Virtualization: 5
+- Containers and Virtualization: 6
 - Migration to Arm: 28
 - ML: 2
 - Performance and Architecture: 25
@@ -39,7 +39,7 @@ tools_software_languages_filter:
 - Coding: 16
 - CSS: 1
 - Daytona: 1
-- Docker: 4
+- Docker: 5
 - GCC: 10
 - Git: 1
 - GitHub: 3
@@ -52,6 +52,7 @@ tools_software_languages_filter:
 - JavaScript: 2
 - Kubernetes: 1
 - Linux: 1
+- LLM: 1
 - LLVM: 1
 - llvm-mca: 1
 - MSBuild: 1
@@ -62,7 +63,7 @@ tools_software_languages_filter:
 - ONNX Runtime: 1
 - OpenCV: 1
 - perf: 4
-- Python: 5
+- Python: 6
 - Qt: 2
 - Remote.It: 1
 - RME: 1

content/learning-paths/laptops-and-desktops/docker-models/_index.md

@@ -0,0 +1,53 @@
+---
+title: Learn how to use Docker Model Runner in AI applications
+
+draft: true
+cascade:
+    draft: true
+
+minutes_to_complete: 45
+
+who_is_this_for: This is for software developers and AI enthusiasts who want to run AI models using Docker Model Runner.
+
+learning_objectives:
+    - Run AI models locally using Docker Model Runner.
+    - Easily build containerized applications with LLMs.
+
+prerequisites:
+    - A computer with at least 16GB of RAM (recommended) and Docker Desktop installed (version 4.40 or later).
+    - Basic understanding of Docker.
+    - Familiarity with Large Language Model (LLM) concepts.
+
+author: Jason Andrews
+
+### Tags
+skilllevels: Introductory
+subjects: Containers and Virtualization
+armips:
+    - Neoverse
+    - Cortex-A
+operatingsystems:
+    - Windows
+    - macOS
+tools_software_languages:
+    - Docker
+    - Python
+    - LLM
+
+further_reading:
+    - resource:
+        title: Docker Model Runner Documentation
+        link: https://docs.docker.com/model-runner/
+        type: documentation
+    - resource:
+        title: Introducing Docker Model Runner
+        link: https://www.docker.com/blog/introducing-docker-model-runner/
+        type: blog
+
+### FIXED, DO NOT MODIFY
+# ================================================================================
+weight: 1                       # _index.md always has weight of 1 to order correctly
+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/laptops-and-desktops/docker-models/_next-steps.md

@@ -0,0 +1,8 @@
+---
+# ================================================================================
+#       FIXED, DO NOT MODIFY THIS FILE
+# ================================================================================
+weight: 21                  # Set to always be larger than the content in this path to be at the end of the navigation.
+title: "Next Steps"         # Always the same, html page title.
+layout: "learningpathall"   # All files under learning paths have this same wrapper for Hugo processing.
+---

content/learning-paths/laptops-and-desktops/docker-models/compose-app.png

@@ -0,0 +1,123 @@
+---
+title: "Run a containerized AI chat app with Docker Compose"
+weight: 3
+layout: "learningpathall"
+---
+
+Docker Compose makes it easy to run multi-container applications. Docker Compose can also include AI models in your project.
+
+In this section, you'll learn how to use Docker Compose to deploy a web-based AI chat application that uses Docker Model Runner as the backend for AI inference.
+
+## Clone the example project
+
+The example project, named [docker-model-runner-chat](https://github.com/jasonrandrews/docker-model-runner-chat) is available on GitHub. It provides a simple web interface to interact with local AI models such as Llama 3.2 or Gemma 3.
+
+First, clone the example repository:
+
+```console
+git clone https://github.com/jasonrandrews/docker-model-runner-chat.git
+cd docker-model-runner-chat
+```
+
+## Review the Docker Compose file
+
+The `compose.yaml` file defines how the application is deployed using Docker Compose. 
+
+It sets up two services:
+
+- **ai-chat**: A Flask-based web application that provides the chat user interface. It is built from the local directory, exposes port 5000 for browser access, mounts the project directory as a volume for live code updates, loads environment variables from `vars.env`, and waits for the `ai-runner` service to be ready before starting.
+- **ai-runner**: This service uses the Docker Model Runner provider to run the selected AI model (for example, `ai/gemma3`). The configuration under `provider` tells Docker to use the model runner extension and specifies which model to load.
+
+The setup allows the web app to communicate with the model runner service as if it were an OpenAI-compatible API, making it easy to swap models or update endpoints by changing environment variables or compose options.
+
+Review the `compose.yaml` file to see the two services.
+
+```yaml
+services:
+  ai-chat:
+    build:
+      context: .
+    ports:
+      - "5000:5000"
+    volumes:
+      - ./:/app
+    env_file:
+      - vars.env
+    depends_on:
+      - ai-runner
+  ai-runner:
+    provider:
+      type: model
+      options:
+        model: ai/gemma3
+```
+
+## Start the application
+
+From the project directory, start the app with:
+
+```console
+docker compose up --build
+```
+
+Docker Compose will build the web app image and start both services.
+
+## Access the chat interface
+
+Open your browser and copy and paste the local URL below: 
+
+```console
+http://localhost:5000
+```
+
+You can now chat with the AI model using the web interface. Enter your prompt and view the response in real time.
+
+![Compose #center](compose-app.png)
+
+## Configuration
+
+You can change the AI model or endpoint by editing the `vars.env` file before starting the containers. The file contains environment variables used by the web application:
+
+- `BASE_URL`: The base URL for the AI model API. By default, it is set to `http://model-runner.docker.internal/engines/v1/`, which allows the web app to communicate with the Docker Model Runner service. This is the default endpoint setup by Docker to access the model. 
+- `MODEL`: The AI model to use (for example, `ai/gemma3` or `ai/llama3.2`).
+
+The `vars.env` file is shown below. 
+
+```console
+BASE_URL=http://model-runner.docker.internal/engines/v1/
+MODEL=ai/gemma3
+```
+
+To use a different model, change the `MODEL` value. For example:
+
+```console
+MODEL=ai/llama3.2
+```
+
+Make sure to change the model in the `compose.yaml` file also. 
+
+You can also change the `temperature` and `max_tokens` values in `app.py` to further customize the application.
+
+## Stop the application
+
+To stop the services, press `Ctrl+C` in the terminal.
+
+You can also run the command below in another terminal to stop the services.
+
+```console
+docker compose down
+```
+
+## Troubleshooting
+
+Use the steps below if you have any issues running the application:
+
+- Ensure Docker and Docker Compose are installed and running
+- Make sure port 5000 is not in use by another application
+- Check logs with:
+
+```console
+docker compose logs
+```
+
+In this section, you learned how to use Docker Compose to run a containerized AI chat application with a web interface and local model inference from Docker Model Runner.