Strata-AMD

Strata-AMD

Docker app from Aurial's Repository

Overview

Strata AMD runs the Qwen3.8-Flash-Next mixture-of-experts model on an AMD GPU plus system RAM, and serves an OpenAI- and Anthropic-compatible API, a chat page and a live monitor. This template runs Strata's official image, ROCm build. For NVIDIA cards use the separate Strata template instead. Requirements: the amdgpu kernel driver, which Unraid ships as standard (Linux 6.8+) — no driver plugin needed. Pick your card family under Branch when installing: latest-rocm-gfx120x for the RX 9000 series and Radeon AI PRO R9700 (default), latest-rocm-gfx110x for the RX 7000 series, latest-rocm-gfx1151 for Ryzen AI Max (Strix Halo). The RX 6000 series has no image yet. You also need RAM for the model's experts plus about 10 GB: roughly 44 GB (Q2_0), 46 GB (IQ2_XS), 53 GB (IQ3_XXS) or 60 GB (IQ3_S) total, and room for the model on an SSD pool (about 80 GB IQ3_XXS, 90 GB IQ3_S). First start: downloads the model into the Data folder and prepares it, which takes a while; watch the log. A stopped download resumes where it left off. Later starts go straight to serving. The model name the API serves is listed at http://[IP]:[PORT:8080]/v1/models. RAM: by default Strata also copies the model's experts into system RAM, even ones the cards already hold — a two-card server used about 59 GiB this way. On a busy server cap it under Engine settings: resident-budget-gib=8 keeps in RAM only what the cards do not hold (about 23 GiB measured, with Parallel requests 2, costing about 9% on cold prompt speed). The model fills the GPU memory too: stop other GPU workloads before starting. API key: always on. Leave it empty and the first start makes one and keeps it in the Data folder; show it with: docker exec "Strata AMD" strata launch --show-key --preset docker (the container name has a space, so quote it). Clients send it as Authorization: Bearer KEY. Changing settings: the default image tags (latest-rocm-*) follow the maintainer; once your setup is tuned you can pin a version by editing the Repository tag, for example ghcr.io/niko1221/strata:0.2.7-rocm-gfx120x. Edit settings and Apply. The new values replace the saved ones on the next start; the model files and tuning stay in the Data folder. Template and Unraid problems: the Support link. Strata itself: the Project link.

Unraid Community Apps templates by Aurial

Two templates live in this repository: Strata AMD (the AMD/ROCm builds of Strata, a local LLM) and Phonon TTS (the official speech server for Gradium's Phonon text-to-speech models).

Strata AMD

An Unraid Community Applications template for the AMD (ROCm) builds of Strata, which runs the Qwen3.8-Flash-Next mixture-of-experts model on an AMD GPU plus system RAM. It serves an OpenAI- and Anthropic-compatible API, a chat page and a live monitor.

The template runs Strata's official image, ghcr.io/niko1221/strata:latest-rocm-gfx120x. Report template or Unraid problems in this repository's issues, and problems with Strata itself to the Strata project.

Why a separate listing

The Community Apps catalog already lists Strata, an NVIDIA-only template by williamkunz (CUDA images, Nvidia Driver plugin, --runtime=nvidia). That template cannot run on AMD cards. This listing covers the AMD side of the same upstream project: different image flavors (rocm-gfx120x / rocm-gfx110x / rocm-gfx1151), different host requirements (the amdgpu kernel driver Unraid already ships — no driver plugin), and device passthrough via /dev/kfd and /dev/dri instead of the NVIDIA runtime. Both templates use Strata's official image and expose the same settings.

Install

Search for Strata AMD in the Apps tab. Before installing you need:

  • an AMD card from one of the families Strata publishes images for. At install, pick your card under Branch — the template offers all three ROCm flavors as a dropdown:

    Branch shown at install Card
    latest-rocm-gfx120x (default) RX 9000 series, Radeon AI PRO R9700 (RDNA 4)
    latest-rocm-gfx110x RX 7000 series (RDNA 3)
    latest-rocm-gfx1151 Ryzen AI Max "Strix Halo" (Radeon 8060S)

    The RX 6000 series has no image yet. The host needs only the amdgpu kernel driver (Linux 6.8+), which Unraid ships as standard — no driver plugin to install.

  • 32 GB of RAM or more; more RAM allows a larger, better model (Strata's model guide)

  • room for the model on an SSD pool, mapped as a direct pool path (/mnt/cache/...), not /mnt/user

Do not set a memory limit on the container: Strata plans from the server's whole RAM. Do not pin CPUs: the engine sets its own thread affinity.

The first start downloads the model and prepares it. Later starts go straight to serving. The template's Overview explains each setting, and Strata's Docker guide covers them in full.

An API key is always on. If you leave it empty, the first start makes one; show it with:

docker exec "Strata AMD" strata launch --show-key --preset docker

(The container name contains a space, so quote it.)

Multi-GPU

The GPUs field takes the card numbers as the monitor lists them (0,1 splits the model across both by layer parallelism), or all / empty for the engine's choice. Every named card must match the Branch family. Under Advanced there is a GPU roles field for finer control (1=main,0=helper): main runs the final stage the answer comes from, helper holds a share of the model's layers, off leaves a card alone; cards you do not name are off, and Strata's automatic choice (faster card as main) is right for almost everyone. A split adds capacity more than speed — see Strata's multi-GPU guide.

Updates

The template follows latest-rocm-gfx120x, which Strata's maintainer moves to each new release when its image is published; the same holds for the other two Branch tags. Unraid shows the update on the Docker tab for whichever branch you installed. To stay on one release, change the Repository tag to a version such as 0.2.7-rocm-gfx120x.

Phonon TTS

An Unraid Community Applications template for ptts-openai-server, the official speech server for Phonon, Gradium's open-weight on-device text-to-speech models. It serves an OpenAI-compatible API (POST /v1/audio/speech) and the Wyoming protocol, so it plugs into Open WebUI, SillyTavern, Home Assistant and anything else with an "OpenAI TTS" setting — fully local, CPU-only, and fast enough to speak faster than real time even on a Raspberry Pi.

Search for Phonon TTS in the Apps tab; the defaults work out of the box: API port 8880, language en, and a model/voices cache (under about 1 GB) downloaded on first start and kept across restarts. The first start logs little until the model loads — watch the log. For Home Assistant, set Wyoming address to 0.0.0.0:10200, map the Wyoming port, then add the Wyoming Protocol integration pointing at this server. The template's Overview explains every setting, including other models (hf://owner/name), gated 40M checkpoints, voice aliases and OpenAI voice-name compatibility.

The server has no authentication on any port. Run it on a trusted network; never expose it to the internet.

The template follows latest, which Gradium moves with each release; pick a pinned tag (such as 0.5.0) under Branch at install to stay on one release.

Credits and licence

Strata and its images are by Niko1221 and the Strata contributors, under the MIT licence. The Strata icon is Strata's own. The Strata template follows the structure of the NVIDIA strata-docker template by William Kunz (MIT).

Phonon and the xn-ptts server are by Gradium and contributors, Apache-2.0; the models themselves carry their own licences on Hugging Face (the 31M models are Apache-2.0; the 40M models are gated — check their model cards). The Phonon icon in this repository is an original work by the template maintainer, MIT.

This repository is MIT licensed; see LICENSE.

Requirements

amdgpu kernel driver — Unraid ships it, no driver plugin needed (Linux 6.8+). An RDNA 3 / RDNA 4 / Strix Halo card: RX 7000 series, RX 9000 series, Radeon AI PRO R9700, or Ryzen AI Max — pick the matching Branch at install (gfx120x / gfx110x / gfx1151); the RX 6000 series has no image yet. Do not set a memory limit on the container: Strata plans from the server's whole RAM. Do not pin CPUs: the engine sets its own thread affinity.

Categories

Related apps

Explore more like this

Explore all

Details

Repository
ghcr.io/niko1221/strata:latest-rocm-gfx120x
Last Updated2026-11-02
First Seen2026-10-26

Runtime arguments

Web UI
http://[IP]:[PORT:8080]/
Network
bridge
Shell
bash
Privileged
false
Extra Params
--device /dev/kfd --device /dev/dri --group-add video --ulimit memlock=-1:-1 --shm-size=2g --stop-timeout 120

Template configuration

WebUI / API portPorttcp

Chat page, monitor and the API (/v1 for OpenAI clients, the root URL for Anthropic clients).

Target
8080
Default
8080
Value
8080
DataPathrw

The model, the prepared pack, presets, tuning and the API key: tens of GB, the log names the size. Use a direct pool path (/mnt/cache/... or /mnt/POOLNAME/...), not /mnt/user: the engine reads the model files while it runs. Typical space: about 80 GB (IQ3_XXS), 90 GB (IQ3_S); Unsloth files are bigger (UD-IQ4_XS 94 GB, UD-Q4_K_XL 111 GB downloads).

Target
/data
Default
/mnt/cache/appdata/strata-amd
Value
/mnt/cache/appdata/strata-amd
GPUsVariable

The cards the engine uses: numbers as the monitor lists them (0, or 0,1 to split the model across both), or all / empty for the engine's choice. Every named card must match the card family of the Branch.

Target
GPUS
Default
all
Value
all
GPU rolesVariable

Advanced, multi-card only: a role for each card, like 1=main,0=helper. main runs the final stage (the answer head; Strata picks the faster card by default), helper shares the model's layers, off leaves the card alone; cards you do not name are off. Not together with GPUs. Empty: Strata chooses.

Target
GPU_ROLES
ModelVariable

Empty: Strata picks the model it recommends for this server and says so in the log. Or a size such as IQ2_XS, IQ3_XXS, IQ3_S or Q2_0; see docs/MODELS.md in the Strata repository for what each needs.

Target
MODEL
Model familyVariable

Empty for the usual one. qwen, swift (thinks shorter) or coder, when the size exists in several families.

Target
FAMILY
Context lengthVariable

How much text it remembers at once; longer costs RAM. 128k suits chat; agentic clients (for example Hermes) want 256k.

Target
CONTEXT
Default
32k|64k|128k|256k
Value
128k
VisionVariable

on: the model reads pictures (about 0.9 GB more to download). gpu or cpu choose where the picture reader runs.

Target
VISION
Default
off|on|gpu|cpu
Value
off
API keyVariable

16 characters or more (openssl rand -hex 24 makes one). Empty: the first start makes one and keeps it in the Data folder.

Target
API_KEY
TuningVariable

Measures the best engine settings for this server, once, and keeps them. quick takes up to about 20 minutes on the first start, thorough up to about 2 hours.

Target
TUNE
Default
skip|quick|thorough
Value
skip
Tune againVariable

1 tunes again on the next start even if this preset is already tuned, for example after an update. Set it back to 0 afterwards.

Target
RETUNE
Default
0|1
Value
0
Parallel requestsVariable

Requests answered at the same time, 1 to 8; each extra request costs RAM. Empty: fitted to the card.

Target
PARALLEL
KV cache typeVariable

Conversation memory format: int8 (default), q4_0 (half the memory), k8v4, fp16.

Target
KV
Default
int8|q4_0|k8v4|fp16
Value
int8
Existing model folderPathro

Optional: a host folder of GGUF files you already have, mounted read-only at /models. Enter /models in Existing model files below and set Model too; nothing is downloaded for the model itself. Empty: no mount.

Target
/models
Existing model filesVariable

GGUF files you already have, as a path inside the container. Add a Path mapping for their folder (read-only is fine), e.g. /models, and enter that here; set Model too. Nothing is downloaded for the model itself.

Target
MODEL_PATH
Engine settingsVariable

Advanced engine settings, space separated, like strata launch --set. The most useful one on shared servers: resident-budget-gib=8 caps the experts kept in RAM (Strata otherwise also copies into RAM the experts the cards already hold: about 59 GiB measured on a two-card server, about 23 GiB capped, at about 9% cost on cold prompt speed).

Target
STRATA_SET