LLM local no Android: PocketPal, MLC Chat (2026)

#Por que rodar um LLM local no Android

Executar um LLM local no Android atende a três necessidades concretas: confidencialidade total (seus prompts nunca saem do dispositivo), funcionamento offline (avião, áreas sem sinal, roaming caro) e uso gratuito (sem assinatura nem cobrança por token). A limitação é o tamanho: um telefone executa modelos muito menores que um PC, portanto menos capazes. Mas, para resumos, reformulações, traduções ou uma conversa simples, um modelo de 3B é mais que suficiente.

Privacidade

O modelo é executado no SoC do telefone. Nenhum dado é enviado pela Internet, o que pode ser verificado desligando o Wi-Fi e os dados móveis.

Offline

Após o modelo ser baixado, tudo funciona em modo avião. Útil para viagens ou em áreas sem rede.

Gratuito para uso

Sem conta, sem cota de uso, sem custo por token. Você paga apenas pela bateria consumida.

Limitação que você deve conhecer

Na prática, um smartphone fica limitado a cerca de 4 bilhões de parâmetros. Para raciocínio complexo ou programação, um LLM local no PC continua muito superior.

#Que tipo de celular é necessário

O fator determinante é a RAM, exatamente como no PC, onde é a VRAM que limita o tamanho do modelo. Um modelo de 3B quantizado em Q4 ocupa cerca de 2 GB, aos quais se soma a memória usada pelo sistema e pelo aplicativo. Na prática, é necessário ter uma margem, pois o Android fecha agressivamente os aplicativos que consomem memória demais.

RAM 6 GB

O mínimo viável. Modelos de 1B a 3B em Q4. Feche outros aplicativos antes de iniciar uma inferência.

RAM 8 GB

Confortável para modelos de 3B, possível com modelos de 4B. O ponto ideal dos smartphones intermediários recentes.

RAM de 12 GB ou mais

Celulares topo de linha recentes. Permitem rodar modelos de 4B sem problemas, ou até de 7B com quantização agressiva, mas lentamente.

Armazenamento

Reserve de 2 a 5 GB livres por modelo baixado. Os arquivos GGUF são volumosos.

SoC

Um Snapdragon da série 8 ou equivalente recente acelera significativamente. Os chips de entrada funcionam, mas continuam lentos.

#PocketPal: um LLM local em 5 minutos

O PocketPal AI é o aplicativo mais simples para começar. É um projeto open source disponível na Play Store que inclui o llama.cpp e um catálogo de modelos que podem ser baixados diretamente do Hugging Face, sem nenhuma linha de comando.

1. 01
   Instalar o aplicativo

   Procure « PocketPal AI » no Google Play Store e instale-o. O app é gratuito e open source (código disponível no GitHub).
2. 02
   Abrir o catálogo de modelos

   Na aba Models, percorra a lista de modelos recomendados. O PocketPal indica o tamanho do arquivo e destaca os adequados à sua RAM.
3. 03
   Baixar um modelo de 1 a 4B

   Escolha um modelo pequeno para começar, por exemplo, um Qwen 3.5 2B (~1,9 GB) ou um Granite 4.2 3B (~2,2 GB) em quantização Q4. O download é feito pela rede, apenas uma vez.
4. 04
   Carregar e conversar

   Aperte Load ao lado do modelo baixado, aguarde o carregamento na memória e então abra o chat. A primeira resposta começa após alguns segundos de pré-aquecimento.

O PocketPal também permite ajustar os parâmetros de inferência (temperatura, tamanho de contexto, número de threads CPU) e importar seus próprios arquivos GGUF se quiser um modelo que não esteja no catálogo. Para uma primeira experiência com LLM local no Android, é o caminho mais direto.

#MLC Chat e aceleração GPU

MLC Chat é o aplicativo de demonstração do projeto MLC LLM, que compila os modelos para aproveitar a GPU móvel via API Vulkan/OpenCL, em vez de executar tudo na CPU. Em um SoC recente, isso pode aumentar a velocidade e reduzir um pouco o consumo em comparação com uma execução exclusivamente na CPU.

1. 01
   Baixar o APK

   MLC Chat não está sempre disponível no Play Store. Baixe o APK oficial no site do projeto MLC LLM (llm.mlc.ai) e permita a instalação a partir de uma fonte externa.
2. 02
   Baixar um modelo compilado

   O aplicativo oferece modelos já convertidos para o formato MLC (Gemma, Qwen, Granite em versões pequenas). Escolha um adequado à sua RAM.
3. 03
   Iniciar o chat

   Selecione o modelo, aguarde a inicialização e então converse. O MLC exibe a velocidade em tokens por segundo no rodapé da tela.

#llama.cpp via Termux para ir mais longe

Para um controle total — escolher precisamente o modelo, a quantização, expor um servidor local — o caminho avançado passa por Termux, um emulador de terminal Android que dá acesso a um ambiente Linux sem root. Lá compilamos o llama.cpp e iniciamos a inferência pela linha de comando, como em um PC Linux.

1. 01
   Instalar e preparar o Termux

   Instale o Termux a partir do F-Droid, abra-o e depois atualize os pacotes básicos.
2. 02
   Instalar as ferramentas de build

   Baixe o compilador, git e cmake necessários para compilar llama.cpp.
3. 03
   Compilar llama.cpp

   Clone o repositório oficial e compile-o. Em dispositivos móveis, a compilação para CPU (ARM NEON) é a mais confiável.
4. 04
   Baixar um modelo GGUF

   Baixe um arquivo .gguf pequeno (1-3B em Q4) do Hugging Face usando curl ou wget.
5. 05
   Iniciar a inferência

   Use o llama-cli para conversar, ou o llama-server para expor uma API compatível com a OpenAI em localhost, acessível por um navegador.

# Mettre à jour les paquets
pkg update && pkg upgrade -y

# Outils de compilation
pkg install -y git cmake clang wget

git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
cmake -B build
cmake --build build --config Release -j$(nproc)

# Exemple : un petit modèle Q4 depuis Hugging Face
wget -O qwen3.5-2b-q4.gguf "<URL_DU_FICHIER_GGUF>"

# Discuter en ligne de commande
./build/bin/llama-cli -m qwen3.5-2b-q4.gguf -p "Résume ce texte : ..." -n 256

# Expose une API sur http://localhost:8080
./build/bin/llama-server -m qwen3.5-2b-q4.gguf --port 8080

O modo servidor é interessante: ele expõe um endpoint compatível com a OpenAI no localhost, que você pode consultar pelo navegador do celular ou por outro aplicativo. É a mesma lógica do servidor do Ollama no PC (que escuta por padrão na porta 11434), adaptada para o seu bolso.

#Quais modelos de 1 a 4B realmente rodam

Tudo se concentra na faixa de 1 a 4 bilhões de parâmetros, com quantização Q4_K_M (o melhor equilíbrio entre qualidade e tamanho, como no PC). Acima de 4B, um celular fica lento ou não tem RAM suficiente. Veja as famílias que dão os melhores resultados em francês.

Qwen 3.5 2B

Modelo pequeno padrão de 2026 (~1,9 GB em Q4). Excelente em múltiplos idiomas e em francês, contexto ampliado, licença Apache 2.0. Melhor ponto de partida para velocidade em um celular de 6 GB.

Qwen 3.5 4B

Um salto de qualidade (~3,4 GB em Q4) sem sair da categoria de modelos para dispositivos móveis. Coerente e capaz em Q4 se seu telefone tiver 8 GB ou mais. Apache 2.0.

Granite 4.2 3B

O pequeno modelo da IBM (~2,2 GB em Q4), com consumo de memória muito baixo e eficiente no uso de tokens. Um generalista offline sólido quando a RAM é limitada. Apache 2.0.

Gemma 4 E2B

Versão compacta do Google (~4,3 GB), multimodal e novamente sob a licença Apache 2.0 desde abril de 2026. Usar apenas em celulares com 8 GB ou mais.

#Velocidade, aquecimento e bateria: o que é necessário saber

A inferência de LLM utiliza a CPU (ou a GPU) ao máximo, o que tem três consequências muito concretas em um celular: a velocidade continua modesta, o aparelho esquenta e a bateria se descarrega rapidamente durante a geração. Nada disso impede o uso, mas é preciso ter essas ordens de grandeza em mente.

Velocidade

Conte com aproximadamente 5 a 15 tokens por segundo para um modelo 3B Q4 em um SoC de gama intermediária a alta. Dá para acompanhar a leitura em tempo real, mas o desempenho fica longe do de uma GPU de PC. Um modelo 1B é bem mais rápido.

Aquecimento e throttling

Após uma geração longa, a temperatura do SoC aumenta e seu desempenho é limitado (throttling), o que torna as respostas seguintes mais lentas. Dê um intervalo entre duas requisições longas.

Bateria

Uma sessão de uso contínuo pode consumir vários pontos percentuais da carga da bateria em poucos minutos. Para uso pontual, isso não é um problema; para uso intensivo, conecte o carregador.

Contexto

Quanto maior a janela de contexto, maiores serão o consumo de memória e o tempo de processamento. No celular, mantenha um contexto razoável (2k-4k tokens) para manter a fluidez.

#Solução de problemas

A aplicação fecha ao carregar o modelo

Falta de RAM. Feche todas as outras aplicações, escolha um modelo menor (1B ao invés de 3B) ou uma quantização mais leve.

Respostas muito lentas

Reduza o tamanho do contexto, diminua o número de tokens gerados ou mude para um modelo menor. Verifique também se o telefone não está reduzindo o desempenho devido ao calor.

Termux: comando não encontrado após a compilação

A compilação falhou silenciosamente. Execute a compilação novamente e leia os erros. Verifique se git, cmake e clang estão de fato instalados.

Termux abandonado / pacotes obsoletos

Você instalou a versão da Play Store. Desinstale-a e reinstale o Termux a partir do F-Droid ou do GitHub.

Respostas incoerentes

Normal para um modelo muito pequeno em uma tarefa complexa. Simplifique a solicitação ou aceite que um modelo de 1 a 3B tenha limites de raciocínio.

#Para se aprofundar

Depois que você se familiarizar com o uso no celular, provavelmente vai querer uma máquina mais potente em casa para tarefas pesadas. Estes guias do site complementam este guia:

Executar um LLM localmente sem GPU (somente CPU)

A mesma lógica usada em dispositivos móveis, mas no PC: modelos recomendados conforme a RAM e dicas para acelerar usando apenas a CPU.

Escolher sua quantização (Q4, Q5, Q8, FP16)

Entender por que o Q4_K_M é o equilíbrio recomendado, tanto no celular quanto no PC.

Instalar Ollama

Para um verdadeiro servidor LLM em casa, que você possa consultar pelo celular na rede local.