Executando LLMs locais no desktop Framework (Max+ 395

Este artigo documenta como eu configurei meu Framework Desktop PC (Max+ 395 com 128GB de memória unificada) para executar LLMs localmente usando tanto llama.cpp quanto Ollama com containers Docker.

Visão geral do hardware

O Framework Desktop Max+ 395 vem com o processador AMD Ryzen AI Max 395 com gráficos Radeon integrados (Strix Halo), com:

128GB de memória unificada (CPU/GPU compartilhadas)
Arquitetura AMD RDNA 3.5
alvo de GPU gfx1151

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

Configuração de memória da GPU

Para habilitar os 128GB completos de memória unificada para cargas de trabalho de GPU, é necessária a configuração abaixo. Estas instruções sintetizam o guia baseado em Ubuntu do technigmaai-wiki com o setup de benchmark de LLM do lhl/strix-halo-testing para Fedora 43.

Configuração da BIOS

Reinicie e entre na BIOS/UEFI
Defina Integrated Graphics/UMA Frame Buffer Size como 512MB
Desative o IOMMU

Configuração do GRUB no Fedora 43

Edite /etc/default/grub e modifique a linha GRUB_CMDLINE_LINUX_DEFAULT:

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

Em seguida, atualize o GRUB e reinicie:

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

Verificar configurações de memória

Após reiniciar, verifique se os parâmetros foram aplicados:

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

Essa configuração habilita aproximadamente 128GB de memória GTT para cargas de trabalho de GPU, o que é essencial para rodar modelos grandes como o Qwen3-Coder-Next com sua janela de contexto de 256K.

Configuração alternativa via módulo do kernel

Para um controle mais granular, crie /etc/modprobe.d/amdgpu_llm_optimized.conf:

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

Em seguida, regenere o initramfs:

sudo dracut --force

Por que Fedora 43 para LLMs?

Embora muitos guias foquem no Ubuntu, o Fedora 43 oferece várias vantagens para cargas de trabalho de LLM local:

Kernel mais recente: o Fedora 43 vem com kernel 6.18.4+, que oferece melhor suporte ao ROCm 7.x e à GPU do Ryzen AI Max 395

Melhor suporte ao ROCm: as melhorias no driver AMDGPU do kernel Linux em kernels mais novos se traduzem em melhor gerenciamento de memória unificada e alocação de VRAM para cargas de trabalho de LLM

Atualidade dos pacotes: o modelo de release do Fedora fornece versões mais recentes de dependências-chave, como:

LLVM/Clang para compilação HIP
Drivers Vulkan (Mesa RADV/AMDVLK)
CMake e toolchains de build

Considerações sobre SELinux: embora o SELinux exija configuração adicional (como container_use_devices=1), ele fornece melhor isolamento de segurança para cargas de trabalho de LLM em containers

As principais fontes que embasaram esta abordagem são:

Containers de LLM baseados em Docker

Criei containers Docker baseados em kyuz0/amd-strix-halo-toolboxes para executar tanto llama.cpp quanto Ollama.

Pré-requisitos dos containers

Antes de executar quaisquer containers, habilite o SELinux para permitir que o container acesse dispositivos de GPU:

sudo setsebool container_use_devices=1

Esta é uma configuração única que precisa persistir entre reinicializações:

sudo setsebool -P container_use_devices=1

Ollama com Vulkan (Funcionando)

O backend Vulkan funciona perfeitamente com o Ollama no Fedora 43.

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"]

Iniciar o Ollama com Vulkan:

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

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

Acessar o Ollama:

ollama list
ollama pull qwen3-coder-next

Ollama com ROCm (Não funcionando - correção pendente)

A implementação ROCm do Ollama atualmente não funciona no Fedora 43 com ROCm 7.x. O problema está registrado em Issue ROCm #5902.

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"]

O backend ROCm falha com erros de "out of memory" mesmo quando o sistema reporta ~111GB de VRAM disponível. Isso parece ser uma regressão no ROCm 7.2 que afeta o cálculo de memória do Ollama.

Status atual: aguardando correção upstream da equipe AMD/ROCm.

llama.cpp com 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"]

O backend Vulkan para o llama.cpp é estável e bem testado. Ele fornece desempenho confiável para todos os tamanhos de modelo.

Entrada no Docker Compose:

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 com ROCm (Mais rápido - ~30% de ganho de performance)

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"]

O backend ROCm para o llama.cpp fornece aproximadamente 30% de desempenho melhor do que o Vulkan. Isso acontece porque o ROCm é a plataforma nativa de computação em GPU da AMD, otimizada para cargas de trabalho intensivas de computação como inferência de LLM.

Entrada no Docker Compose:

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"

Executando modelos

Qwen3-Coder-Next (80B MoE)

É aqui que o Framework Desktop realmente brilha. Eu consigo rodar a versão completa UD-Q8_K_XL do Qwen3-Coder-Next com a janela de contexto completa de 256K.

Links:

As especificações do modelo:

Arquitetura: 80B MoE (3B parâmetros ativos)
Janela de contexto: 262.144 tokens
Memória necessária: ~93.4 GB para UD-Q8_K_XL (8-bit)
Configurações recomendadas: temp=1.0, top_p=0.95, top_k=40, min_p=0.01

Setup atual de modelos

Meu docker-compose.yml define múltiplos serviços:

Serviço	Backend	Modelo	Contexto
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

Comandos de inicialização

Iniciar o serviço do Ollama:

cd ollama-vulkan
docker compose up -d

Iniciar o llama.cpp para um modelo específico:

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

Parar todos os serviços:

docker compose down

Workflows agênticos e Claude Code

Tenho executado sessões totalmente autônomas do Claude Code por muitas horas nesta configuração. O Framework Desktop escreveu a maior parte deste artigo durante essas sessões autônomas.

Configuração do Claude Code

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

claude --model qwen3-coder-next

Observação: substitua your-framework-desktop-ip pelo seu domínio ou endereço IP real.

Problemas atuais

Encontrei um problema com o Ollama em workflows agênticos - veja Issue do Ollama #13939. O Claude Code ocasionalmente tenta usar nomes de modelo que não estão disponíveis localmente, resultando em timeouts.

Contorno: usar llama.cpp diretamente fornece resultados mais confiáveis para workflows agênticos no meu setup. A estabilidade e a consistência são visivelmente melhores.

Por que estou empolgado com este setup

"Tokens" infinitos de graça

Esta configuração me permite "queimar" tokens de LLM infinitos 24x7 de graça. Embora modelos pagos sejam mais rápidos, este setup permite:

Experimentação infinita com modelos e prompts diferentes
Sessões longas de agentes autônomos
Sem custos por token para se preocupar
Privacidade total de dados e operação offline

Características de desempenho

Mais lento do que modelos pagos: sim, mas a diferença é aceitável para a maioria das tarefas
Melhor para programação: os modelos locais se destacam em completar e entender código
Contexto ilimitado: a janela de contexto de 256K no Qwen3-Coder-Next muda o jogo

O futuro

Esta configuração tem sido incrivelmente produtiva. Agora estou:

Rodando sessões totalmente autônomas do Claude Code por horas
Experimentando diferentes quantizações e arquiteturas de modelo
Desenvolvendo workflows de agentes personalizados que aproveitam a GPU local

Vou adicionar em breve um artigo sobre meu setup do Claude Code e como eu o configuro para funcionar com esses modelos locais.

Atribuição e agradecimentos

Este setup não teria sido possível sem o trabalho incrível da comunidade open-source. Um grande obrigado a:

kyuz0/amd-strix-halo-toolboxes - A inspiração para os containers Docker, com imagens pré-construídas para backends Vulkan e ROCm
technigmaai-wiki - Instruções completas passo a passo para configuração de memória da GPU
lhl/strix-halo-testing - Setup detalhado de benchmarking de LLM para Strix Halo
Unsloth - Fornecendo modelos incríveis otimizados para GGUF
ROCm - O stack open de software de GPU
llama.cpp - O trabalho incrível de ggerganov e colaboradores

Esses recursos representam um esforço significativo e representam o estado da arte de inferência local de LLM em hardware AMD.

Executando LLMs locais no desktop Framework (Max+ 395 - 128GB)