Executei LLMs locais usando o iGPU mais barato da Intel e os resultados foram surpreendentemente decentes

Ao contrário dos modelos de IA baseados em nuvem, os grandes modelos de linguagem hospedados localmente são notórios por seus altos requisitos de sistema, com os modelos mais poderosos exigindo muitos núcleos tensores e grandes VRAM. Embora eu argumente que, com o descarregamento EM, os modelos Mixture of Experts podem ser executados até mesmo em sistemas antigos, você ainda precisará de uma placa gráfica discreta para executar esses LLMs volumosos.

Mas e se eu abandonasse completamente a GPU dedicada e tentasse executar o LLM em hardware enxuto – de preferência um que tenha um iGPU, mas que não custe um braço e uma perna? Considerando que o Intel N100 é um dos processadores x86 mais baratos do mercado, parecia a solução perfeita para esta estranha experiência. E agora que executei alguns modelos em meu painel N100, tenho que admitir que é uma solução bastante decente para tarefas leves de LLM.

Usei uma configuração com tecnologia LXC para meus experimentos LLM

Transferir o iGPU para o contêiner não exigiu muito esforço

Como acontece com qualquer projeto de laboratório doméstico, eu tinha muitas maneiras (e dispositivos) de colocar o LLM com motor N100 em funcionamento. Originalmente, eu queria usar uma configuração Arch ou DietPi superleve, mas acabei optando pelo LXC rodando em uma máquina Proxmox. Isso ocorre principalmente porque eu não queria usar instantâneos para restaurar rapidamente as configurações se o mecanismo de inferência começasse a gerar erros no meio da compilação. Para referência, o sistema em questão é o LattePanda Mu, um módulo de computação N100 acessível com 8 GB de RAM.

Quanto ao mecanismo de inferência, eu realmente não queria usar o Ollama, embora seja a opção mais amigável para iniciantes para hospedar LLMs locais. Seu alto desempenho já o torna uma opção terrível para hardware tão fraco, e ele simplesmente não é flexível o suficiente para acomodar todos os parâmetros extras que uso ao servir meus LLMs. Então, o bom e velho llama.cpp foi minha escolha principal, e tive que começar implantando o LXC especificamente para este mecanismo de inferência.

Assim que o contêiner estiver instalado e funcionando, era hora de entregar os gráficos integrados ao LXC. Felizmente, esse processo foi tão fácil quanto entrar /dev/dri/renderD128 LXC em Passagem de dispositivo na guia Recursos e inserindo 0666 como modo de passagem. Depois de executar o LXC, digitei os seguintes comandos para instalar os drivers necessários junto com o utilitário vaifo, que confirmou que o LXC era capaz de usar o iGPU.

apt update
apt install -y intel-media-va-driver vainfo

Como tive alguns problemas ao tentar compilar a versão Vulkan do llama.cpp em minha GTX 1080, estava disposto a recarregar o snapshot antigo algumas vezes para que tudo funcionasse corretamente. Felizmente, só tive que recarregar duas vezes, embora tenha sido um pouco trabalhoso corrigir o erro.

Lançamento apt instalar git cmake curl glslc glslang-tools libvulkan1 ferramentas vulkan libvulkan-dev spirv-tools spirv-headers build-essential comando extraiu todos os pacotes iniciais necessários para llama.cpp. Depois que terminaram a instalação, executei clone do git https://github.com/ggml-org/llama.cpp para pegar os arquivos do mecanismo de inferência e executar cd llama.cpp para mudar para seu diretório.

Então eu executou cmake -B build -DGGML_VULKAN=ON para configurar o ambiente de construção, que surpreendentemente funcionou sem problemas. No entanto cmake -B construir cmake –build construir — -j1 sempre que eu tentava compilar llama.cpp, o comando falhava na marca de 18%. Além disso, o LXC me pedia para entrar sempre que o processo falhava. Depois de pesquisar em alguns fóruns, finalmente descobri que a RAM (ou a falta dela) era a culpada.

Meu sistema tinha apenas 8 GB de memória e eu aloquei 5 GB para o LXC, que acabou ficando sem RAM e o arquivo de troca de 512 MB também não ajudou. Então aumentei a RAM para impressionantes 7 GB antes de jogar fora os 3 GB extras de alocação de swap. E com certeza, o processo de compilação funcionou bem, sem erros, e removi o arquivo de troca após instalar o llama.cpp para evitar atrapalhar minhas atribuições de LLM com a velocidade de inferência mais lenta do meu SSD.

O N100 pode lidar com modelos de tamanho decente

É definitivamente mais rápido que o Raspberry Pi

Dado que meu Raspberry Pi estava tendo problemas para executar o Gemma 3 (4B), imaginei que poderia iniciar minha carga de trabalho de hospedagem LLM a partir daí. Então, criei uma instância do lama-server usando ./llama-server -m “/root/llama.cpp/models/gemma-3-4b-it-Q4_K_M.gguf” – host 0.0.0.0 – porta 8082 comando e comecei a solicitá-lo na interface da web. Ao contrário do meu Raspberry Pi, o LLM funcionou a uma velocidade decente, muito mais do que eu esperava. Aumentar a janela de contexto para 16K também não esgotou a memória, o que foi um bom sinal.

Qwen3 (4B) também teve resultados semelhantes, e para uma configuração sem GPU, sem VRAM dedicada e apenas 24 unidades de execução, meu LattePanda Mu parecia uma boa opção para executar LLMs menores. Ainda assim, eu queria ver até onde poderia ir, então transferi o volumoso DeepSeek R1 (especificamente, o DeepSeek R1-Distill-Qwen-7B) do meu mainframe para o LXC com motor N100 e liguei-o. ./llama-server -m “/root/llama.cpp/models/DeepSeek-R1-Distill-Qwen-7B-Q4_K_M.gguf” –host 0.0.0.0 –port 8082. Para minha surpresa, ele criou uma instância do servidor lhama e, para ver até onde eu poderia empurrá-la, copiei uma longa cadeia de logs dela para a interface da web do LXC e pedi ao LLM para lê-los. Embora a taxa de inferência do token tenha permanecido em torno de 2,9 t/s, o DeepSeek R1-Distill-Qwen-7B foi capaz de gerar resultados surpreendentemente corretos, embora eu eventualmente obstruísse a janela de contexto se começasse a expandir o bate-papo adicionando mais logs aos prompts.

Não é perfeito, mas é um servidor LLM secundário decente

Tenho uma cópia do Gemma4-26B-A4B em execução na minha GTX 1080 24 horas por dia, 7 dias por semana e uso-a para a maioria das minhas tarefas de inferência, enquanto o Qwen3.6-35B-A3B serve como meu assistente de codificação no meu sistema RTX 3080 Ti. Portanto, duvido que usaria o módulo de computação N100 para os modelos 7B em baixas velocidades. Mas se eu precisasse de um LLM secundário para certas tarefas de inferência, ou precisasse de um modelo de incorporação para trabalhar em conjunto com meus volumosos clankers, provavelmente escolheria meu LattePanda Mu. Afinal, este host Proxmox possui os LXCs necessários, então colocar um servidor LLM nele não seria um grande problema, já que pretendo executá-lo o tempo todo.