IA Offline: Como Criar um LLM que Funciona Sem Internet

A energia caiu há nove horas, a rede celular está congestionada, e o freezer da sua garagem está cheio de carne que você comprou no sábado. Ainda é seguro comer? Normalmente você perguntaria a um chatbot. Agora, a internet é a primeira coisa que quebrou. Esse cenário é o briefing de design de uma classe crescente de ferramentas de IA offline-first: um assistente e uma biblioteca de referência que vivem inteiramente no seu laptop. O modelo, o corpus e o índice de busca rodam localmente, então perguntar “como purifico esta água” funciona exatamente igual com o cabo de rede desconectado. Acho isso mais interessante como exercício de arquitetura do que como equipamento de prepper. Tirar a rede da equação força um conjunto de decisões de engenharia que a IA hospedada na nuvem pode ignorar, e essas decisões se mostram úteis muito além de kits de emergência. Se você já pensou em rodar grandes modelos de linguagem no seu próprio hardware, as restrições de um assistente offline são a ponta afiada desse problema.

O Que a IA Offline-First Realmente Precisa Entregar

Um assistente em nuvem é enxuto: o seu cliente envia texto, um data center devolve tokens. Um assistente offline precisa replicar a pilha inteira em hardware de consumo, o que significa entregar três grandes componentes e mantê-los em harmonia. Primeiro, o motor de inferência. Na prática, isso significa llama.cpp ou um de seus derivados, porque ele roda em Apple Silicon, CPUs x86 comuns e GPUs de consumo com uma única árvore de dependências. O app para Mac já o empacota; o build para Windows o baixa durante a instalação. De qualquer forma, você não pode presumir que ele existe na máquina do usuário. Você o instala discretamente, na primeira execução. Segundo, o modelo. É aqui que fica interessante, e vou voltar a isso, porque escolher o modelo certo é o problema central de design. Terceiro, a biblioteca. Um assistente offline nesse espaço traz cerca de 930.000 artigos da Wikipédia (o subconjunto mais lido), referências médicas como MedlinePlus e WikiMed, orientações de emergência da FEMA e do CDC, manuais de sobrevivência militar, wikiHow, guias de reparo do iFixit e dumps de perguntas e respostas do Stack Exchange sobre temas como reparos domésticos e rádio amador. Tudo em texto puro, com as licenças preservadas e exibidas por artigo. O download completo tem cerca de 9 GB e cresce para 19 GB instalado; uma versão enxuta, sem Wikipédia e iFixit, tem 1,3 GB. Isso é tanto um ato de curadoria quanto de engenharia: alguém decidiu quais fontes sobrevivem ao corte. Tudo isso precisa caber num setup de três etapas que leva cinco minutos de cliques e até duas horas e meia de download. Esse último número importa mais do que parece: a janela de download é a sua única chance de buscar qualquer coisa, para sempre. É a mesma disciplina que você aplicaria a software que você não pode reiniciar nem alcançar, só que o ambiente inacessível é uma cozinha às escuras depois da tempestade.

O Problema da Escolha de Modelos: Um App, Muitos Cérebros

Aqui está a decisão que o software em nuvem nunca enfrenta: você não sabe qual hardware o seu usuário tem, não pode sondar a RAM dele e direcioná-lo a um cluster maior, e a resposta muda tanto o tamanho do download quanto a qualidade de cada resposta dali em diante. A solução nesta categoria de ferramentas é a escolha em camadas com base no hardware. Na primeira execução, o app verifica a memória do sistema e escolhe um modelo que caiba: - 128 GB ou mais: um modelo grande de classe topo (um build usa o NVIDIA Nemotron 3.5 Super, ~80 GB em disco), com 21 de 22 no teste cego do projeto sobre perguntas de apagão e primeiros socorros. - 32–96 GB: um modelo de porte médio com cerca de 27B parâmetros (~18 GB), também com 21 de 22. - 32 GB no Windows: um modelo de ~25 GB ajustado para velocidade, com 19 de 22. - 16–31 GB: um modelo da classe 8B (~6 GB), com 14 de 22. Leia a última linha de novo. A máquina que a maioria das pessoas realmente tem, um laptop de 16 GB, recebe um cérebro que erra o ponto principal das orientações oficiais cerca de um terço das vezes, em perguntas onde o ponto principal é coisas como “não coma o frango que ficou seis horas em temperatura ambiente”. Essa é a aritmética desconfortável da IA offline-first. Quantização e modelos pequenos ficaram genuinamente bons: um modelo 8B bem ajustado é um bom assistente de escrita e uma interface de busca decente. Mas a curva de qualidade não se dobra para caber nas suas restrições de deploy. Quando um app em nuvem quer um modelo mais inteligente, ele muda uma flag de configuração. Quando um app offline quer, o usuário precisa ter comprado um notebook maior três anos atrás. Você entrega a curva, e a curva entrega você. A mitigação honesta é a que essas ferramentas adotam: tratar o modelo pequeno como uma interface para o corpus, não como uma autoridade sobre ele. Cada resposta lista exatamente quais artigos foram lidos, com o trecho destacado, porque os designers sabem que o nível 8B vai errar às vezes.

A Recuperação Como Camada de Confiança, Não Como Funcionalidade

Todo sistema de geração aumentada por recuperação (RAG) mostra fontes hoje; na nuvem, é uma caixinha de funcionalidade, um pouco de teatro de transparência. Offline, a recuperação é estrutural. É a única coisa que fica entre uma alucinação plausível e um usuário agindo com base nela numa emergência real. O design que emerge se parece com isto: o modelo pesquisa a biblioteca em texto puro, lê as passagens principais e escreve uma resposta que cita o que leu. Se o usuário pedir que ele consulte algo, ele pesquisa mesmo que já tenha respondido de memória, e a interface informa de qual modo cada resposta veio: memória, artigos que ele abriu ou resultados de busca que ele nunca abriu. Essa última distinção é sutil e importante. “Encontrei trechos correspondentes” e “li o artigo” são afirmações diferentes, com confiabilidades diferentes, e a interface as trata como tal. Há também um detalhe de modo de falha que eu adoro: quando o modelo foi pesquisar e nunca escreveu uma resposta final, algo real que modelos pequenos fazem, o app agora força a entrada dos melhores artigos encontrados e faz o modelo tentar mais uma vez, em vez de não mostrar nada ao usuário. Offline, você não pode recorrer a um modelo maior nem a uma fila de retentativas. Você embute a retentativa no loop do agente. É um exemplo compacto do que as pessoas querem dizer quando afirmam que agentes de LLM se comportam como sistemas distribuídos: falhas parciais em todo lugar, e a tarefa da camada de orquestração é tornar a falha sobrevivível. Mais uma escolha arquitetural que vale copiar: o orçamento de raciocínio. O app expõe quantos tokens o modelo pode pensar antes de responder (desligado, 1.000, 4.000, 16.000 ou ilimitado), e, ao atingir o limite, o pensamento é cortado e o modelo responde com o que tem. Na bateria, um modelo que fica dando voltas não é só errado, é um dreno de energia. Um limite rígido transforma um problema de computação ilimitado em um limitado, que é exatamente o instinto que você quer quando a tomada na parede é teórica.

Os Céticos Têm Razão (Sobre a Metade Errada)

A crítica mais dura a esse gênero: por que não pular o LLM e entregar um arquivo pesquisável? O Kiwix faz exatamente isso há anos: Wikipédia e referências médicas, comprimidas, indexadas, pesquisáveis offline, sem risco de alucinação, rodando numa batata. E, para um conjunto de dados de texto curado, um mecanismo de busca é talvez a ferramenta mais confiável. Um testador perguntou ao assistente offline como construir um arco de fogo e recebeu as peças certas, mas o movimento errado: o modelo descreveu rolar o eixo entre as mãos, ignorando o arco por completo, e mencionou “abanar as faíscas”, o que uma fogueira por fricção não produz. Um mecanismo de busca não consegue cometer esse erro porque não gera nada. Mas acho que essa crítica erra o que o LLM realmente faz nesses sistemas, e a melhor defesa do design é reposicioná-lo: usar o modelo como inteligência de busca, não como oráculo. A busca por palavras-chave falha quando você não conhece o vocabulário, quando o que você tem são sintomas, não um diagnóstico, uma coisa quebrada, não o nome de uma peça. A recuperação semântica ajuda com “parecido em significado”, mas não com “conectado por mecanismo ou causa”, justamente a lacuna que um modelo generativo preenche: ele pode pegar “plantações amarelando nas bordas das folhas” e produzir os cinco caminhos de leitura que uma palavra-chave nunca encontraria. O trabalho do modelo é levar você às páginas certas. O trabalho das páginas é estar certas. A outra crítica, “se você precisa de um LLM durante o apocalipse, aprenda as habilidades”, é justa como conselho de vida e inútil como crítica de software. O conhecimento de primeiros socorros de ninguém cobre queimaduras pediátricas, química de purificação de água e conserto de gerador. Livros cobrem tudo isso; o argumento é só sobre a interface. Onde os céticos acertam em cheio é na faixa 14 de 22. Se a camada de interface erra um terço das vezes e toda resposta traz um aviso de “confira as fontes”, em algum momento o produto honesto é o arquivo com uma caixa de busca. O LLM só se justifica na medida em que comprovadamente leva não especialistas à passagem certa mais rápido do que Ctrl+F. Isso é uma questão empírica sobre os seus usuários, não um palpite.

Uma Pilha Mínima de IA Offline-First

Se você quisesse construir sua própria versão disso (e deveria, é um projeto de fim de semana genuinamente instrutivo), o esqueleto é menor do que você imagina. As partes interessantes são as escolhas, não o código. Um assistente local com recuperação em primeiro lugar, em Python, fica mais ou menos assim:

import subprocess
from pathlib import Path
CORPUS_DIR = Path("./library")          # plain-text articles, one file each
MODEL = "./models/granite-8b-q4.gguf"   # quantized to fit 16 GB RAM
def search_corpus(query: str, k: int = 5) -> list[dict]:
"""Dumb but honest: rank articles by keyword overlap.
Swap in BM25 or embeddings later; the interface is the point."""
terms = set(query.lower().split())
hits = []
for f in CORPUS_DIR.rglob("*.txt"):
text = f.read_text(errors="ignore")
score = sum(text.lower().count(t) for t in terms)
if score:
hits.append({"path": f.name, "score": score, "text": text[:3000]})
return sorted(hits, key=lambda h: -h["score"])[:k]
def answer(question: str) -> str:
sources = search_corpus(question)
context = "\n\n".join(
f"[SOURCE {i}: {s['path']}]\n{s['text']}"
for i, s in enumerate(sources, 1)
)
prompt = (
"Answer ONLY from the sources below. Cite them as [SOURCE n]. "
"If they don't cover it, say so.\n\n"
f"{context}\n\nQuestion: {question}\nAnswer:"
)
out = subprocess.run(
["llama-cli", "-m", MODEL, "-p", prompt,
"-n", "512", "--ctx-size", "8192"],
capture_output=True, text=True,
)
citations = "\n".join(f"[{i}] {s['path']}" for i, s in enumerate(sources, 1))
return out.stdout + "\n\n--- Sources ---\n" + citations
print(answer("how long is food safe in a fridge without power"))

Tudo o que faz isso parecer um produto e não um brinquedo está nas restrições embutidas nessas quarenta linhas: o prompt proíbe respostas com algo fora das fontes, as citações são anexadas mecanicamente (nunca confiando que o modelo as formate, pois um bug real envolveu modelos inventando uma linha “Fontes:” listando os próprios comandos de busca), e o tamanho da geração é limitado. Faltam aqui, mas são necessários em produção: um índice de embeddings para busca semântica, um orçamento de tokens de raciocínio, sondagem de memória para escolher o arquivo do modelo e metadados de licença por arquivo para que a interface possa exibi-la. Repare no que não está lá: nenhuma chamada de rede, nenhuma chave de API, nenhuma telemetria. Quando o arquivo do modelo e o corpus existem no disco, esse programa é fisicamente incapaz de vazar uma pergunta. A privacidade deixa de ser uma política e vira consequência do grafo de dependências.

As Restrições Que Voltam Com Você Para Casa

Quem constrói offline-first logo descobre algumas restrições nada óbvias que se tornam moradoras permanentes da sua arquitetura. **Armazenamento e janelas de instalação são de uso único.** A biblioteca completa precisa de cerca de 27 GB de espaço livre durante a instalação, antes de se estabilizar em 19 GB, e tudo precisa chegar durante o download inicial. Não existe carregamento preguiçoso de uma referência médica que faltou durante um furacão. Isso empurra você para uma curadoria agressiva: 930.000 artigos parecem muito até lembrar que a Wikipédia tem milhões; alguém ranqueou por audiência e cortou a cauda. **Energia é um recurso de primeira classe.** Medido num MacBook Pro, responder consome cerca de 100 W por 5 a 40 segundos por pergunta; uma bateria cheia compra algo entre 100 e 300 respostas. De repente, uma longa cadeia de raciocínio não é apenas lenta, é uma decisão de combustível. Orçamentos de raciocínio e níveis de modelos pequenos deixam de ser otimizações e viram o produto. **Seu canal de atualização é sua linha de vida.** O app precisa atualizar modelos, biblioteca e binário com um clique, sem quebrar o estado local, porque a próxima vez que o usuário tiver banda pode estar a meses de distância. E a disciplina de recursos em segundo plano importa de um jeito novo: uma correção numa versão fez o Cmd+Q realmente parar o motor de inferência, que mantinha um modelo de vários gigabytes residente na memória depois que a janela fechava. Na bateria, isso não é vazamento de memória, é um vazamento de calor e de horas. **Arquivos do usuário entram na fronteira de confiança.** Permitir que usuários soltem seus próprios PDFs (um manual de gerador, um plano familiar de emergência) significa que o seu pipeline de recuperação passa a lidar com entradas adversariamente bagunçadas: PDFs escaneados, codificações estranhas, arquivos enormes. Offline, você não pode terceirizar nada disso para um parser na nuvem.

Por Que Esse Padrão Importa Além das Emergências

A privacidade deixa de ser uma promessa de política e vira consequência do grafo de dependências. Um programa sem chamadas de rede não consegue vazar nada, nunca.

O enquadramento de emergência ganha as manchetes, mas a arquitetura é a história. A mesma pilha (inferência local, corpus curado, recuperação com citações, orçamentos rígidos de computação) é o que você quer para uma clínica com dados de pacientes que legalmente não podem sair do prédio, um chão de fábrica com máquinas isoladas da rede, um jornalista num país onde um registro de consultas é uma responsabilidade, ou um navio de pesquisa com internet por satélite cobrada por megabyte. Um praticante na discussão descreveu exatamente isso: uma biblioteca curada manualmente somada a modelos locais numa propriedade sem sinal de celular, atualizada antes de cada viagem, substituindo gradualmente a maior parte do uso diário de IA em nuvem, mesmo quando há fibra disponível. É essa a trajetória em que eu apostaria. A distância entre um modelo local 8B quantizado e uma API de modelo de fronteira é real, mas estreita o bastante para que, em tarefas ancoradas em recuperação (“encontre a passagem certa e resuma-a fielmente”), a opção local muitas vezes seja suficiente, e suficiência somada a custo marginal zero e privacidade garantida é um pacote convincente. Os modelos de fronteira continuam melhorando, mas a quantização também, e os modelos pequenos seguem a mesma onda de escala com algum atraso. Se você acompanha a ponta de eficiência dessa curva, os modelos da categoria flash são onde está a verdadeira história de eficiência de inferência. Minha recomendação se você estiver projetando algo nesse espaço: copie o padrão, não a estética de prepper. Cure sem piedade. Uma biblioteca de 200 documentos em que você confia vale mais do que 930.000 que você nunca leu. Faça as citações mecânicas, nunca geradas pelo modelo. Dê ao modelo um orçamento rígido para pensar. E decida, explicitamente, se o seu modelo é um oráculo ou uma interface de busca. As ferramentas que sobrevivem ao escrutínio são as honestas o bastante para serem a segunda opção.

A Conclusão

IA offline-first não é sobre sobreviver ao apocalipse. É sobre descobrir como é a sua arquitetura quando todas as saídas de emergência (um modelo maior, um fallback na nuvem, uma rede sempre ligada, energia ilimitada) estão soldadas. O que sobra é um corpus curado, um modelo quantizado dimensionado para um hardware que você não controla, uma recuperação que carrega a confiança e um loop de agente feito para falhar com elegância. Essas também se mostram boas disciplinas online. A tempestade só faz você aprendê-las mais rápido.