Lokale LLMs auf dem Framework Desktop ausführen (Max+ 395

Dieser Artikel dokumentiert, wie ich meinen Framework Desktop PC (Max+ 395 mit 128GB Unified Memory) konfiguriert habe, um lokale LLMs sowohl mit llama.cpp als auch mit Ollama in Docker-Containern auszuführen.

Hardware-Überblick

Der Framework Desktop Max+ 395 verfügt über den AMD Ryzen AI Max 395-Prozessor mit integrierter Radeon-Grafik (Strix Halo) und bietet:

128GB Unified Memory (gemeinsam von CPU/GPU genutzt)
AMD RDNA 3.5-Architektur
gfx1151 GPU-Target

https://frame.work/gb/en/desktop

GPU-Speicherkonfiguration

Um die vollen 128GB Unified Memory für GPU-Workloads zu aktivieren, ist die folgende Konfiguration erforderlich. Diese Anleitung fasst den Ubuntu-basierten Guide aus dem technigmaai-wiki mit dem LLM-Benchmark-Setup aus lhl/strix-halo-testing für Fedora 43. zusammen.

BIOS-Setup

Neustarten und ins BIOS/UEFI wechseln
Integrated Graphics/UMA Frame Buffer Size auf 512MB setzen
IOMMU deaktivieren

Fedora 43 GRUB-Konfiguration

Bearbeite /etc/default/grub und ändere die Zeile GRUB_CMDLINE_LINUX_DEFAULT:

GRUB_CMDLINE_LINUX_DEFAULT="quiet splash amd_iommu=off amdgpu.gttsize=131072 ttm.pages_limit=33554432"

Dann GRUB aktualisieren und neu starten:

sudo grub2-mkconfig -o /boot/grub2/grub.cfg
sudo reboot

Speichereinstellungen verifizieren

Nach dem Neustart prüfen, ob die Parameter angewendet wurden:

cat /proc/cmdline
sudo dmesg | grep -i gtt
sudo dmesg | grep -i ttm

Diese Konfiguration aktiviert ungefähr 128GB GTT-Speicher für GPU-Workloads, was essenziell ist, um große Modelle wie Qwen3-Coder-Next mit seinem 256K-Context-Window auszuführen.

Alternative Kernelmodul-Konfiguration

Für eine feinere Steuerung erstelle /etc/modprobe.d/amdgpu_llm_optimized.conf:

options amdgpu gttsize=120000
options ttm pages_limit=31457280
options ttm page_pool_size=15728640

Danach initramfs neu erzeugen:

sudo dracut --force

Warum Fedora 43 für LLMs?

Während viele Anleitungen auf Ubuntu abzielen, bietet Fedora 43 mehrere Vorteile für lokale LLM-Workloads:

Aktuellerer Kernel: Fedora 43 wird mit Kernel 6.18.4+ ausgeliefert, der bessere Unterstützung für ROCm 7.x und die GPU des Ryzen AI Max 395 bietet

Bessere ROCm-Unterstützung: Verbesserungen am AMDGPU-Treiber im Linux-Kernel in neueren Kerneln führen zu besserem Unified-Memory-Management und VRAM-Allokation für LLM-Workloads

Aktualität der Pakete: Fedoras Rolling-Release-Modell liefert neuere Versionen wichtiger Abhängigkeiten, z. B.:

LLVM/Clang für HIP-Kompilierung
Vulkan-Treiber (Mesa RADV/AMDVLK)
CMake und Build-Toolchains

SELinux-Aspekte: Während SELinux zusätzliche Konfiguration erfordert (z. B. container_use_devices=1), bietet es bessere Sicherheitsisolation für containerisierte LLM-Workloads

Die wichtigsten Quellen, die diesen Ansatz geprägt haben, sind:

Docker-basierte LLM-Container

Ich habe Docker-Container auf Basis von kyuz0/amd-strix-halo-toolboxes erstellt, um sowohl llama.cpp als auch Ollama auszuführen.

Container-Voraussetzungen

Bevor du Container startest, aktiviere SELinux so, dass Container Zugriff auf GPU-Devices erhalten:

sudo setsebool container_use_devices=1

Dies ist eine einmalige Konfiguration, die Neustarts überdauern muss:

sudo setsebool -P container_use_devices=1

Ollama mit Vulkan (funktioniert)

Das Vulkan-Backend funktioniert mit Ollama unter Fedora 43. perfekt.

Dockerfile: ollama-vulkan/Dockerfile Docker Compose: ollama-vulkan/docker-compose.yml

# Ollama + Vulkan on Strix Halo (Fedora 43)
FROM registry.fedoraproject.org/fedora-minimal:43

# Base runtime deps + Vulkan userspace
RUN microdnf -y --nodocs --setopt=install_weak_deps=0 install \
      bash ca-certificates curl tar \
      libatomic libstdc++ libgcc \
      vulkan-loader vulkan-loader-devel vulkaninfo \
      mesa-vulkan-drivers radeontop \
      pciutils procps-ng wget gzip zstd \
  && microdnf clean all && rm -rf /var/cache/dnf/*

# Install AMDVLK (optional, can use Mesa RADV)
RUN curl -L -o /tmp/amdvlk-2025.Q2.1.x86_64.rpm \
    https://github.com/GPUOpen-Drivers/AMDVLK/releases/download/v-2025.Q2.1/amdvlk-2025.Q2.1.x86_64.rpm \
 && microdnf -y install /tmp/amdvlk-*.rpm \
 && rm -f /tmp/amdvlk-*.rpm

# Install Ollama (generic Linux build with Vulkan support)
RUN wget -P /tmp https://github.com/ollama/ollama/releases/download/v0.15.5-rc2/ollama-linux-amd64.tar.zst \
 && tar --zstd -C /usr -xf /tmp/ollama-linux-amd64.tar.zst \
 && rm -f /tmp/ollama-linux-amd64.tar.zst

RUN mkdir -p /root/.ollama

ENV OLLAMA_VULKAN=1 \
    GGML_VK_VISIBLE_DEVICES=0 \
    OLLAMA_HOST=0.0.0.0 \
    OLLAMA_ORIGINS="*"

EXPOSE 11434

CMD ["/usr/bin/ollama", "serve"]

Ollama mit Vulkan starten:

# Build the image
docker build -t ollama-strix-vulkan -f ollama-vulkan/Dockerfile .

# Or using Docker Compose
cd ollama-vulkan
docker compose up -d

Auf Ollama zugreifen:

ollama list
ollama pull qwen3-coder-next

Ollama mit ROCm (funktioniert nicht - Fix ausstehend)

Die ROCm-Implementierung von Ollama funktioniert derzeit nicht unter Fedora 43 mit ROCm 7.x. Das Problem wird unter ROCm issue #5902 verfolgt.

Dockerfile: ollama-rocm/Dockerfile Docker Compose: ollama-rocm/docker-compose.yml

# Ollama + Vulkan on Strix Halo (Fedora 43)
FROM registry.fedoraproject.org/fedora:43

RUN dnf -y --nodocs --setopt=install_weak_deps=False install \
  make gcc cmake lld clang clang-devel compiler-rt libcurl-devel \
  radeontop git vim patch curl ninja-build tar xz aria2c wget zstd \
  && dnf clean all && rm -rf /var/cache/dnf/*


# find & fetch the latest Linux 7.x.x tarball (gfx1151)
WORKDIR /tmp
ARG ROCM_MAJOR_VER=7
ARG GFX=gfx1151
RUN set -euo pipefail; \
  BASE="https://therock-nightly-tarball.s3.amazonaws.com"; \
  PREFIX="therock-dist-linux-${GFX}-${ROCM_MAJOR_VER}"; \
  KEY="$(curl -s "${BASE}?list-type=2&prefix=${PREFIX}" \
  | tr '<' '\n' \
  | grep -o "therock-dist-linux-${GFX}-${ROCM_MAJOR_VER}\..*\.tar\.gz" \
  | sort -V | tail -n1)"; \
  echo "Latest tarball: ${KEY}"; \
  aria2c -x 16 -s 16 -j 16 --file-allocation=none "${BASE}/${KEY}" -o therock.tar.gz
RUN mkdir -p /opt/rocm-7.0 \
  && tar xzf therock.tar.gz -C /opt/rocm-7.0 --strip-components=1

ENV ROCM_PATH=/opt/rocm-7.0 \
  HIP_PLATFORM=amd \
  HIP_PATH=/opt/rocm-7.0 \
  HIP_CLANG_PATH=/opt/rocm-7.0/llvm/bin \
  HIP_INCLUDE_PATH=/opt/rocm-7.0/include \
  HIP_LIB_PATH=/opt/rocm-7.0/lib \
  HIP_DEVICE_LIB_PATH=/opt/rocm-7.0/lib/llvm/amdgcn/bitcode \
  PATH=/opt/rocm-7.0/bin:/opt/rocm-7.0/llvm/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin \
  LD_LIBRARY_PATH=/opt/rocm-7.0/lib:/opt/rocm-7.0/lib64:/opt/rocm-7.0/llvm/lib \
  LIBRARY_PATH=/opt/rocm-7.0/lib:/opt/rocm-7.0/lib64 \
  CPATH=/opt/rocm-7.0/include \
  PKG_CONFIG_PATH=/opt/rocm-7.0/lib/pkgconfig

RUN printf '%s\n' \
  'export ROCM_PATH=/opt/rocm-7.0' \
  'export HIP_PLATFORM=amd' \
  'export HIP_PATH=/opt/rocm-7.0' \
  'export HIP_CLANG_PATH=/opt/rocm-7.0/llvm/bin' \
  'export HIP_INCLUDE_PATH=/opt/rocm-7.0/include' \
  'export HIP_LIB_PATH=/opt/rocm-7.0/lib' \
  'export HIP_DEVICE_LIB_PATH=/opt/rocm-7.0/lib/llvm/amdgcn/bitcode' \
  'export PATH="$ROCM_PATH/bin:$HIP_CLANG_PATH:$PATH"' \
  'export LD_LIBRARY_PATH="$HIP_LIB_PATH:$ROCM_PATH/lib:$ROCM_PATH/lib64:$ROCM_PATH/llvm/lib"' \
  'export LIBRARY_PATH="$HIP_LIB_PATH:$ROCM_PATH/lib:$ROCM_PATH/lib64"' \
  'export CPATH="$HIP_INCLUDE_PATH"' \
  'export PKG_CONFIG_PATH="$ROCM_PATH/lib/pkgconfig"' \
  > /etc/profile.d/rocm.sh \
  && chmod +x /etc/profile.d/rocm.sh \
  && echo 'source /etc/profile.d/rocm.sh' >> /etc/bashrc

# Install the Ollama ROCm drivers (v0.15.2)
RUN wget -P /tmp https://github.com/ollama/ollama/releases/download/v0.15.5-rc3/ollama-linux-amd64-rocm.tar.zst \
 && tar -C /usr --use-compress-program=unzstd -xf /tmp/ollama-linux-amd64-rocm.tar.zst \
 && rm -f /tmp/ollama-linux-amd64-rocm.tar.zst

# Install ollama (v0.15.2)
RUN wget -P /tmp https://github.com/ollama/ollama/releases/download/v0.15.5-rc3/ollama-linux-amd64.tar.zst \
 && tar -C /usr --use-compress-program=unzstd -xf /tmp/ollama-linux-amd64.tar.zst \
 && rm -f /tmp/ollama-linux-amd64.tar.zst

# Make Ollama + ROCm shared libs visible to the runtime linker
RUN printf '%s\n' \
  /usr/lib/ollama \
  /opt/rocm-7.0/lib \
  > /etc/ld.so.conf.d/ollama-rocm.conf \
  && ldconfig

# Create /opt/rocm symlink that Ollama expects
RUN ln -sfn /opt/rocm-7.0 /opt/rocm

# Data directory
RUN mkdir -p /root/.ollama

# Expose Ollama API port
EXPOSE 11434

# profile
RUN printf '%s\n' \
  'export ROCBLAS_USE_HIPBLASLT=1' \
  > /etc/profile.d/rocm.sh && chmod +x /etc/profile.d/rocm.sh \
  && echo 'source /etc/profile.d/rocm.sh' >> /etc/bashrc

ENV OLLAMA_HOST=0.0.0.0 \
    OLLAMA_ORIGINS="*"

# Start the server
CMD ["/usr/bin/ollama", "serve"]

Das ROCm-Backend scheitert mit „out of memory“-Fehlern, selbst wenn das System ~111GB verfügbaren VRAM meldet. Das scheint eine Regression in ROCm 7.2 zu sein, die Ollamas Speicherberechnung betrifft.

Aktueller Status: Warte auf einen Upstream-Fix vom AMD/ROCm-Team.

llama.cpp mit Vulkan

Dockerfile: llamacpp/Dockerfile.llamacpp-strix-vulkan

# build stage
FROM registry.fedoraproject.org/fedora:43 AS builder

# deps
RUN dnf -y --nodocs --setopt=install_weak_deps=False install \
      git vim \
      make gcc cmake ninja-build lld clang clang-devel compiler-rt libcurl-devel \
      vulkan-loader-devel vulkaninfo mesa-vulkan-drivers \
      radeontop glslc \
    && dnf clean all && rm -rf /var/cache/dnf/*

# llama.cpp
WORKDIR /opt/llama.cpp
RUN git clone --recursive https://github.com/ggerganov/llama.cpp.git .

# build
RUN git clean -xdf \
 && git submodule update --recursive \
 && cmake -S . -B build -G Ninja \
      -DGGML_VULKAN=ON \
      -DCMAKE_BUILD_TYPE=Release \
      -DGGML_RPC=ON \
      -DCMAKE_INSTALL_PREFIX=/usr \
      -DLLAMA_BUILD_TESTS=OFF \
      -DLLAMA_BUILD_EXAMPLES=ON \
      -DLLAMA_BUILD_SERVER=ON \
 && cmake --build build --config Release \
 && cmake --install build --config Release

# libs
RUN find /opt/llama.cpp/build -type f -name 'lib*.so*' -exec cp {} /usr/lib64/ \; \
 && ldconfig


# runtime stage
FROM registry.fedoraproject.org/fedora-minimal:43

# runtime deps
RUN microdnf -y --nodocs --setopt=install_weak_deps=0 install \
      bash ca-certificates libatomic libstdc++ libgcc \
      vulkan-loader vulkan-loader-devel vulkaninfo mesa-vulkan-drivers radeontop \
  && microdnf clean all && rm -rf /var/cache/dnf/*

# copy
COPY --from=builder /usr/ /usr/
COPY --from=builder /usr/local/ /usr/local/
COPY --from=builder /opt/llama.cpp/build/bin/rpc-* /usr/local/bin/

# ld
RUN echo "/usr/local/lib"  > /etc/ld.so.conf.d/local.conf \
 && echo "/usr/local/lib64" >> /etc/ld.so.conf.d/local.conf \
 && ldconfig \
 && cp -n /usr/local/lib/libllama*.so* /usr/lib64/ 2>/dev/null || true \
 && ldconfig

# shell
CMD ["/bin/bash"]

Das Vulkan-Backend für llama.cpp ist stabil und gut getestet. Es liefert zuverlässige Performance für alle Modellgrößen.

Docker-Compose-Eintrag:

qwen-3-coder-vulkan:
  image: llamacpp-strix-vulkan
  container_name: llamacpp
  restart: unless-stopped
  devices:
    - /dev/dri:/dev/dri
  group_add:
    - "video"
  volumes:
    - /home/mark/running-llms/:/root/running-llms
  ports:
    - "8080:8080"
  security_opt:
    - seccomp=unconfined
  command: >
    bash -c "llama-server --alias Qwen3-Coder-30B -m /root/running-llms/hf-models/unsloth/Qwen3-Coder-30B-A3B-Instruct-1M-BF16/BF16/Qwen3-Coder-30B-A3B-Instruct-1M-BF16-00001-of-00002.gguf --ctx-size 262144 -fa 1 --no-mmap --host 0.0.0.0 --port 8080 --temp 0.7 --top-k 20 --min-p 0.01 --top-p 0.8 --repeat-penalty 1.05 --jinja -ngl 99 --threads -1"

llama.cpp mit ROCm (schneller - ~30% Performance-Boost)

Dockerfile: llamacpp/Dockerfile.llamacpp-rocm

# build
FROM registry.fedoraproject.org/fedora:43 AS builder

RUN dnf -y --nodocs --setopt=install_weak_deps=False install \
  make gcc cmake lld clang clang-devel compiler-rt libcurl-devel \
  radeontop git vim patch curl ninja-build tar xz aria2c \
  && dnf clean all && rm -rf /var/cache/dnf/*

# find & fetch the latest Linux 7.x.x tarball (gfx1151)
WORKDIR /tmp
ARG ROCM_MAJOR_VER=7
ARG GFX=gfx1151
RUN set -euo pipefail; \
  BASE="https://therock-nightly-tarball.s3.amazonaws.com"; \
  PREFIX="therock-dist-linux-${GFX}-${ROCM_MAJOR_VER}"; \
  KEY="$(curl -s "${BASE}?list-type=2&prefix=${PREFIX}" \
  | tr '<' '\n' \
  | grep -o "therock-dist-linux-${GFX}-${ROCM_MAJOR_VER}\..*\.tar\.gz" \
  | sort -V | tail -n1)"; \
  echo "Latest tarball: ${KEY}"; \
  aria2c -x 16 -s 16 -j 16 --file-allocation=none "${BASE}/${KEY}" -o therock.tar.gz
RUN mkdir -p /opt/rocm-7.0 \
  && tar xzf therock.tar.gz -C /opt/rocm-7.0 --strip-components=1

ENV ROCM_PATH=/opt/rocm-7.0 \
  HIP_PLATFORM=amd \
  HIP_PATH=/opt/rocm-7.0 \
  HIP_CLANG_PATH=/opt/rocm-7.0/llvm/bin \
  HIP_INCLUDE_PATH=/opt/rocm-7.0/include \
  HIP_LIB_PATH=/opt/rocm-7.0/lib \
  HIP_DEVICE_LIB_PATH=/opt/rocm-7.0/lib/llvm/amdgcn/bitcode \
  PATH=/opt/rocm-7.0/bin:/opt/rocm-7.0/llvm/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin \
  LD_LIBRARY_PATH=/opt/rocm-7.0/lib:/opt/rocm-7.0/lib64:/opt/rocm-7.0/llvm/lib \
  LIBRARY_PATH=/opt/rocm-7.0/lib:/opt/rocm-7.0/lib64 \
  CPATH=/opt/rocm-7.0/include \
  PKG_CONFIG_PATH=/opt/rocm-7.0/lib/pkgconfig

RUN printf '%s\n' \
  'export ROCM_PATH=/opt/rocm-7.0' \
  'export HIP_PLATFORM=amd' \
  'export HIP_PATH=/opt/rocm-7.0' \
  'export HIP_CLANG_PATH=/opt/rocm-7.0/llvm/bin' \
  'export HIP_INCLUDE_PATH=/opt/rocm-7.0/include' \
  'export HIP_LIB_PATH=/opt/rocm-7.0/lib' \
  'export HIP_DEVICE_LIB_PATH=/opt/rocm-7.0/lib/llvm/amdgcn/bitcode' \
  'export PATH="$ROCM_PATH/bin:$HIP_CLANG_PATH:$PATH"' \
  'export LD_LIBRARY_PATH="$HIP_LIB_PATH:$ROCM_PATH/lib:$ROCM_PATH/lib64:$ROCM_PATH/llvm/lib"' \
  'export LIBRARY_PATH="$HIP_LIB_PATH:$ROCM_PATH/lib:$ROCM_PATH/lib64"' \
  'export CPATH="$HIP_INCLUDE_PATH"' \
  'export PKG_CONFIG_PATH="$ROCM_PATH/lib/pkgconfig"' \
  > /etc/profile.d/rocm.sh \
  && chmod +x /etc/profile.d/rocm.sh \
  && echo 'source /etc/profile.d/rocm.sh' >> /etc/bashrc

WORKDIR /opt/llama.cpp
RUN git clone --recursive https://github.com/ggerganov/llama.cpp.git . \
  && git clean -xdf \
  && git submodule update --recursive

RUN cmake -S . -B build \
  -DGGML_HIP=ON \
  -DAMDGPU_TARGETS=gfx1151 \
  -DCMAKE_BUILD_TYPE=Release \
  -DGGML_RPC=ON \
  -DLLAMA_HIP_UMA=ON \
  && cmake --build build --config Release -- -j$(nproc) \
  && cmake --install build --config Release

# keep bin; drop headers/docs/static libs (retain llama.cpp for rpc binaries)
RUN find /opt/rocm-7.0 -type f -name '*.a' -delete \
  && rm -rf /opt/rocm-7.0/include /opt/rocm-7.0/share \
  /opt/rocm-7.0/llvm/include /opt/rocm-7.0/llvm/share

# runtime
FROM registry.fedoraproject.org/fedora-minimal:43

RUN microdnf -y --nodocs --setopt=install_weak_deps=0 install \
  bash ca-certificates libatomic libstdc++ libgcc radeontop vim procps-ng \
  && microdnf clean all && rm -rf /var/cache/dnf/*

COPY --from=builder /opt/rocm-7.0 /opt/rocm-7.0
COPY --from=builder /usr/local/ /usr/local/
COPY --from=builder /opt/llama.cpp/build/bin/rpc-* /usr/local/bin/

# COPY gguf-vram-estimator.py /usr/local/bin/
# RUN chmod +x /usr/local/bin/gguf-vram-estimator.py

ENV ROCM_PATH=/opt/rocm-7.0 \
  HIP_PLATFORM=amd \
  HIP_PATH=/opt/rocm-7.0 \
  HIP_CLANG_PATH=/opt/rocm-7.0/llvm/bin \
  HIP_INCLUDE_PATH=/opt/rocm-7.0/include \
  HIP_LIB_PATH=/opt/rocm-7.0/lib \
  HIP_DEVICE_LIB_PATH=/opt/rocm-7.0/lib/llvm/amdgcn/bitcode \
  PATH=/opt/rocm-7.0/bin:/opt/rocm-7.0/llvm/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin \
  LD_LIBRARY_PATH=/opt/rocm-7.0/lib:/opt/rocm-7.0/lib64:/opt/rocm-7.0/llvm/lib \
  LIBRARY_PATH=/opt/rocm-7.0/lib:/opt/rocm-7.0/lib64 \
  CPATH=/opt/rocm-7.0/include \
  PKG_CONFIG_PATH=/opt/rocm-7.0/lib/pkgconfig

RUN printf '%s\n' \
  'export ROCM_PATH=/opt/rocm-7.0' \
  'export HIP_PLATFORM=amd' \
  'export HIP_PATH=/opt/rocm-7.0' \
  'export HIP_CLANG_PATH=/opt/rocm-7.0/llvm/bin' \
  'export HIP_INCLUDE_PATH=/opt/rocm-7.0/include' \
  'export HIP_LIB_PATH=/opt/rocm-7.0/lib' \
  'export HIP_DEVICE_LIB_PATH=/opt/rocm-7.0/lib/llvm/amdgcn/bitcode' \
  'export PATH="$ROCM_PATH/bin:$HIP_CLANG_PATH:$PATH"' \
  'export LD_LIBRARY_PATH="$HIP_LIB_PATH:$ROCM_PATH/lib:$ROCM_PATH/lib64:$ROCM_PATH/llvm/lib"' \
  'export LIBRARY_PATH="$HIP_LIB_PATH:$ROCM_PATH/lib:$ROCM_PATH/lib64"' \
  'export CPATH="$HIP_INCLUDE_PATH"' \
  'export PKG_CONFIG_PATH="$ROCM_PATH/lib/pkgconfig"' \
  > /etc/profile.d/rocm.sh \
  && chmod +x /etc/profile.d/rocm.sh \
  && echo 'source /etc/profile.d/rocm.sh' >> /etc/bashrc

# make /usr/local libs visible without touching env
RUN echo "/usr/local/lib"  > /etc/ld.so.conf.d/local.conf \
  && echo "/usr/local/lib64" >> /etc/ld.so.conf.d/local.conf \
  && ldconfig

CMD ["/bin/bash"]

Das ROCm-Backend für llama.cpp liefert ungefähr 30% bessere Performance als Vulkan. Das liegt daran, dass ROCm AMDs native GPU-Compute-Plattform ist, optimiert für compute-lastige Workloads wie LLM-Inferenz.

Docker-Compose-Eintrag:

qwen-3-coder-rocm:
  image: llamacpp-rocm
  container_name: llamacpp
  restart: unless-stopped
  devices:
    - /dev/dri:/dev/dri
    - /dev/kfd:/dev/kfd
  group_add:
    - "video"
    - "render"
  volumes:
    - /home/mark/running-llms/:/root/running-llms
  ports:
    - "8080:8080"
  security_opt:
    - seccomp=unconfined
  command: >
    bash -c "llama-server --alias Qwen3-Coder-30B -m /root/running-llms/hf-models/unsloth/Qwen3-Coder-30B-A3B-Instruct-1M-BF16/BF16/Qwen3-Coder-30B-A3B-Instruct-1M-BF16-00001-of-00002.gguf --ctx-size 262144 -fa 1 --no-mmap --host 0.0.0.0 --port 8080 --temp 0.7 --top-k 20 --min-p 0.01 --top-p 0.8 --repeat-penalty 1.05 --jinja -ngl 99 --threads -1"

Modelle ausführen

Qwen3-Coder-Next (80B MoE)

Hier zeigt der Framework Desktop wirklich seine Stärken. Ich kann die vollständige UD-Q8_K_XL-Version von Qwen3-Coder-Next mit dem kompletten 256K-Context-Window laufen lassen.

Links:

Die Modell-Spezifikationen:

Architektur: 80B MoE (3B aktive Parameter)
Context Window: 262,144 Tokens
Erforderlicher Speicher: ~93.4 GB für UD-Q8_K_XL (8-bit)
Empfohlene Einstellungen: temp=1.0, top_p=0.95, top_k=40, min_p=0.01

Aktuelles Modell-Setup

Meine docker-compose.yml definiert mehrere Services:

Service	Backend	Model	Context
qwen-3-coder-next-rocm	ROCm	Qwen3-Coder-Next (UD-Q8_K_XL)	262k
qwen-3-coder-next-vulkan	Vulkan	Qwen3-Coder-Next	262k
qwen-3-next-rocm	ROCm	Qwen3-Next-80B-A3B-Thinking	32k
gpt-oss-rocm	ROCm	gpt-oss-120b-GGUF	131k
glm-4.7	Vulkan	GLM-4.7	16k

Startbefehle

Ollama-Service starten:

cd ollama-vulkan
docker compose up -d

llama.cpp für ein bestimmtes Modell starten:

docker compose up -d qwen-3-coder-next-rocm

Alle Services stoppen:

docker compose down

Agentische Workflows und Claude Code

Ich lasse vollständig autonome Claude-Code-Sessions über viele Stunden mit dieser Konfiguration laufen. Der Framework Desktop hat den Großteil dieses Artikels in diesen autonomen Sessions geschrieben.

Claude-Code-Konfiguration

export ANTHROPIC_AUTH_TOKEN=ollama
export ANTHROPIC_API_KEY=""
export ANTHROPIC_BASE_URL=http://your-framework-desktop-ip:11434

claude --model qwen3-coder-next

Hinweis: Ersetze your-framework-desktop-ip durch deine tatsächliche Domain oder IP-Adresse.

Aktuelle Probleme

Ich bin auf ein Problem mit Ollama in agentischen Workflows gestoßen - siehe Ollama issue #13939. Claude Code versucht gelegentlich, Modellnamen zu verwenden, die lokal nicht verfügbar sind, was zu Timeouts führt.

Workaround: llama.cpp direkt zu verwenden, liefert in meinem Setup zuverlässigere Ergebnisse für agentische Workflows. Die Stabilität und Konsistenz sind merklich besser.

Warum ich von diesem Setup begeistert bin

Unendliche „Tokens“ kostenlos

Diese Konfiguration erlaubt mir, unendlich viele LLM-Tokens 24x7 kostenlos zu „verbrauchen“. Während bezahlte Modelle schneller sind, ermöglicht dieses Setup:

Endloses Experimentieren mit verschiedenen Modellen und Prompts
Lang laufende autonome Agent-Sessions
Keine Per-Token-Kosten, über die man sich Gedanken machen muss
Vollständige Datenprivatsphäre und Offline-Betrieb

Performance-Eigenschaften

Langsamer als bezahlte Modelle: Ja, aber der Unterschied ist für die meisten Aufgaben akzeptabel
Besser fürs Programmieren: Die lokalen Modelle sind stark bei Code-Completion und Verständnis
Unbegrenzter Kontext: Das 256K-Context-Window bei Qwen3-Coder-Next ist ein Game-Changer

Die Zukunft

Diese Konfiguration war extrem produktiv. Ich:

Lasse vollständig autonome Claude-Code-Sessions stundenlang laufen
Experimentiere mit verschiedenen Quantisierungen und Modellarchitekturen
Entwickle eigene Agent-Workflows, die die lokale GPU nutzen

Ich werde bald einen Artikel über mein Claude-Code-Setup hinzufügen und wie ich es so konfiguriere, dass es mit diesen lokalen Modellen funktioniert.

Attribution und Dank

Dieses Setup wäre ohne die unglaubliche Arbeit der Open-Source-Community nicht möglich gewesen. Ein riesiges Dankeschön an:

kyuz0/amd-strix-halo-toolboxes - Die Inspiration für die Docker-Container, mit vorgefertigten Images für Vulkan- und ROCm-Backends
technigmaai-wiki - Umfassende Schritt-für-Schritt-Anleitung zur GPU-Speicherkonfiguration
lhl/strix-halo-testing - Detailliertes LLM-Benchmarking-Setup für Strix Halo
Unsloth - Stellt großartige GGUF-optimierte Modelle bereit
ROCm - Der offene GPU-Software-Stack
llama.cpp - Die unglaubliche Arbeit von ggerganov und den Mitwirkenden

Diese Ressourcen sind mit erheblichem Aufwand verbunden und repräsentieren den Stand der Technik für lokale LLM-Inferenz auf AMD-Hardware.

Lokale LLMs auf dem Framework Desktop ausführen (Max+ 395 - 128GB)