As dez lições anteriores foram peças soltas: capacidade, banda, quantização, motor, KV cache, a config do seu Mac, prática, visão. Esta as solda numa única máquina e fecha a ideia que abriu a Lição 01 — a diferença entre rodar um modelo e servir infraestrutura. O resultado construído é concreto: um DeepSeek-V4-Flash q2 (81 GB, 33,9 tok/s) mais o Qwen3-VL (que lê 99% das suas imagens) rodando offline, a $0 por token, no seu M5 Max — e plugados no funnel do Alembic.
Este curso destilou esse roadmap + medições reais neste M5 Max. Por que importa pra missão: o capstone prova que as 10 lições não eram teoria — elas montam o cérebro local que serve a Previdência Factory sem mandar um byte para fora.
Ao fechar este capstone, você consegue
Recuperar de cabeça as 11 ideias do curso e a ordem em que elas decidem um stack local.
Planejar a capacidade de qualquer Mac: dado tamanho + contexto, dizer se cabe em 128 GB e a velocidade esperada.
Distinguir rodar de servir e desenhar o roteamento dos dois endpoints (:8000 cérebro, :8081 visão).
Explicar por que este é o setup da década — o ativo durável é o raciocínio, não o peso trocável.
0 GB
DS4 q2 residente · cabe
0 tok/s
geração do cérebro (pico 33,9)
0%
das imagens lidas (Qwen3-VL)
$0
por token · 100% offline
01 · A espinha do curso, soldada
Todo o curso foi uma só pergunta destilada em onze respostas: o que cabe, roda rápido e continua inteligente neste Mac — e como eu sirvo isso como infraestrutura? Antes de montar o stack, recupere o arco inteiro. Cada lição entregou uma peça do raciocínio, e elas se encaixam numa ordem que não é acidental:
A ESPINHA · 11 lições → um cérebro local que serve
Onze peças, um arco: dos 3 gargalos (Lição 01) à visão (Lição 10), tudo desemboca na máquina que serve.
Os marcos, lição por lição
Esta é a tabela-resumo do curso — cada linha é uma ideia que você agora consegue aplicar de cabeça. Use-a como índice mental antes de montar o stack na próxima seção:
Lição
A ideia-chave
O que ela decide
01 · modelo mental
3 gargalos: capacidade · banda · stack
O que sequer é possível neste Mac
02 · memória
fórmula: params × bits ÷ 8
Se os pesos cabem na RAM
03 · banda
banda = velocidade (tok/s)
Se vai gerar rápido ou arrastado
04 · quantização
quantização assimétrica
Cortar tamanho sem matar a qualidade
05 · engines
escolha o engine por último
Qual motor casa com o seu workload
06 · KV cache
o KV cache cresce com o contexto
Quanto contexto cabe junto dos pesos
07 · DS4
DwarfStar / DS4 serve o gigante
Como um 284 B q2 vira endpoint local
08 · config M5 Max
a config 128 GB fechada
O orçamento de memória que fecha
09 · mãos à obra
prática: baixar, servir, medir
Sair do papel para o terminal
10 · visão
visão avaliada com suas imagens
Escolher o VLM pelo dado, não pela demo
A ordem não é acidental
Repare na sequência: primeiro o que cabe (01–02), depois se voa (03), depois como caber sem perder o cérebro (04), e só então o motor (05). Escolher engine antes de saber o que cabe é o erro clássico — por isso a Lição 05 insiste: engine por último.
Por que isso tudo importa: alugar vs. ser dono
Antes de montar nada, vale fixar o porquê — a tese que costura o curso inteiro. Há dois jeitos de ter inteligência artificial: alugar da nuvem (paga por token, dados saem) ou ser dono (paga o silício uma vez, cada token depois é grátis e privado). Esta é a primeira comparação lado a lado do capstone:
Dimensão
Alugar (nuvem)
Ser dono (local · este curso)
Custo por token
Pago a cada chamada, para sempre
$0 depois do hardware (custo fixo, uma vez)
Privacidade
Dados trafegam para um terceiro
Dados nunca saem da máquina
Disponibilidade
Depende de rede + uptime do provedor
Offline, sempre on em 127.0.0.1
Teto de uso
Rate limits + a conta cresce com o uso
Só o seu silício — uso ilimitado
Controle do modelo
Troca quando o provedor decide
Você escolhe e afina (ex.: ds4-legal)
CUSTO ACUMULADO NO TEMPO · alugar (cresce) vs. ser dono (degrau único) — esquemático
Esquemático (não medido): a inclinação e o ponto exato dependem do seu volume. A forma é o que importa — aluguel é reta que sobe; posse é degrau que estabiliza. [uncertain: valores absolutos não medidos]
02 · Monte seu stack local (interativo)
Hora de usar tudo. Escolha o seu objetivo e a RAM da sua máquina; o configurador aplica o raciocínio do curso e recomenda modelo + quantização + engine, mostrando se cabe no seu orçamento de memória. Não é mágica — é a fórmula da Lição 02 + a escolha de motor da Lição 05, automatizadas:
Por que essas recomendações? • Texto/código → o maior MoE que cabe em q2/q4 servido por DS4 (Lição 07): inteligência por dólar. • Visão → Qwen3-VL via MLX (Lição 10): leve, rápido, lê suas imagens reais. • Ambos → os dois tiers coexistindo na memória unificada — o cérebro residente + a visão sob demanda.
02b · Planeje a capacidade — passo a passo, depois você
O configurador deu a resposta pronta; agora vamos fazer a conta à mão, juntando o que você aprendeu nas Lições 02 (memória), 03 (banda) e 06 (KV cache). É a mesma pergunta de sempre — cabe? e voa? — só que agora você mesmo dirige o lápis. Comece prevendo:
Preveja antes de revelar
O DeepSeek-V4-Flash q2 ocupa 81 GB de pesos no seu M5 Max de 128 GB. Tirando ~10 GB de SO/apps e deixando contexto de trabalho, quantos GB sobram livres com um contexto moderado? E ele cruza o teto seguro de 80% (~102 GB)?
Pesos 81 + KV (contexto moderado) ~15 + SO/apps ~10 = ≈ 106 GB. O teto seguro de 80% é ~102 GB — ou seja, você fica logo acima dele. Por isso o q2 roda em 128 GB com contexto moderado, não com 1M de tokens: o KV cresce e estoura (Lição 06). Sobram só ~22 GB para tudo o mais — apertado, mas funcional.
Agora o procedimento completo, do tamanho do modelo até "cabe e a que velocidade". Cada passo cita a lição que o sustenta:
Planejamento de capacidade · DeepSeek-V4-Flash q2 no M5 Max de 128 GB
1
Pesos (Lição 02). Fórmula params × bits ÷ 8 = 284 × 2 ÷ 8 ≈ 71 GB (napkin). O GGUF assimétrico real (experts em 2 bits, atenção em Q8) pesa 81 GB — use o número real.
2
KV cache (Lição 06). A memória de trabalho cresce com o contexto. Para um contexto moderado, reserve ~15 GB. Quanto mais tokens, mais KV — é o que limita janelas gigantes.
3
SO + apps. macOS, navegador, editor: ~10 GB. Nunca conte com a RAM toda para o modelo.
4
Soma vs. teto (Lição 02). 81 + 15 + 10 = 106 GB. Teto seguro 80% de 128 = 102 GB. Está no limite → contexto moderado, não 1M tokens.
5
Velocidade (Lição 03).tok/s ≈ banda ÷ bytes-lidos-por-token. Num MoE só os experts ativos são lidos; medido neste M5 Max: ~25–34 tok/s (pico 33,9). Cabe e voa.
6
Agora você. Refaça para um 70 B q4: pesos 70 × 0,56 ≈ 39 GB; + KV ~10 + SO ~10 = ~59 GB. Cabe folgado em 128 GB → dá para um contexto bem maior. Confira no planejador abaixo. ↓
Este é o planejador novo — a ferramenta que faltava. Arraste tamanho do modelo, bits e contexto; ele recalcula, ao vivo, os GB de pesos + KV, se cabe nos 128 GB e a velocidade estimada. A barra empilha pesos (laranja) + KV (oliva) contra o teto seguro:
Leia o trade-off no planejador: baixe os bits → a barra de pesos encolhe (cabe mais), mas a Lição 04 lembra que a qualidade cai. Aumente o contexto → o bloco de KV (oliva) cresce e te empurra contra o teto. Aumente o tamanho → mais pesos e KV mais lento. Os três botões são exatamente as três alavancas do curso, juntas numa tela.
Por que um Mac, e não uma GPU? (memória unificada vs. discreta)
Talvez você se pergunte: por que 128 GB num Mac batem placas de vídeo caras para isso? Porque o M5 Max tem memória unificada — CPU, GPU e ANE compartilham o mesmo pool, sem cópia entre "RAM do sistema" e "VRAM da placa". É a terceira comparação do capstone, e a razão de um modelo de 81 GB sequer ser possível aqui:
MEMÓRIA UNIFICADA (M5 Max) vs. DISCRETA (CPU + GPU separadas)
É por isso que "128 GB de Mac" rende um modelo que nenhuma placa de consumo aguentaria: sem a parede RAM↔VRAM, todo o pool vira espaço de pesos.
03 · A árvore de decisão do curso
O configurador acima é a versão automática. Por baixo dele há um fluxo de decisão que você agora carrega na cabeça — hardware → workload → serviço → motor. Clique em cada nó para abrir o raciocínio da lição que o sustenta:
DA MÁQUINA AO MOTOR · clique nos nós para ver o porquê
Comece pelo hardware
Clique em um nó acima. A regra-mãe do curso: nunca escolha o motor antes de saber o que cabe. Hardware decide o possível; workload decide o necessário; só então o motor.
04 · De "roda" a "serve" — a ideia da Lição 01, fechada
A Lição 01 abriu com uma distinção: a maioria das pessoas roda um modelo (abre um app, digita, fecha). Você aprendeu a servir — transformar o Mac numa peça de infraestrutura que outros programas consomem. Compare os dois mundos; o botão troca o "antes" pelo "depois" que este curso construiu:
Rodar (o ponto de partida): um app de chat local, um modelo pequeno, uso manual. Funciona, mas é um beco: nenhum outro programa fala com ele, o contexto é descartável, e a "inteligência" para quando você fecha a janela. É consumo, não infraestrutura.
Servir (o que você construiu): dois endpoints HTTP locais falando OpenAI/Anthropic em 127.0.0.1. Claude Code, Codex e o funnel do Alembic apontam base_url para lá e não sabem que o backend é local. A inteligência vira um serviço sempre disponível, programável, a $0 por token.
Não, eu não dupliquei meu homelab para a nuvem. Meu homelab virou a nuvem que eu uso.— Ahmad Osman
Essa frase é a Lição 01 fechada. Rodar é alugar inteligência por token e mandar seus dados para fora. Servir é possuir a inteligência: custo fixo pago uma vez, cada token depois grátis, offline e privado. É a diferença entre alugar e ser dono — e é por isso que o stack não é brinquedo de dev, e sim a fundação de um produto.
A FRONTEIRA DE PRIVACIDADE · o dado entra, é processado e volta — sem cruzar para fora
É exatamente essa fronteira que torna o stack viável para documentos sensíveis (a Previdência Factory): o dado do cliente entra, é processado e a resposta volta — sem nunca cruzar para fora.
Como uma requisição é roteada (fluxograma)
"Servir" significa que algo decide, por requisição, qual endpoint responde. Siga o fluxo: a pergunta tem imagem? Sim → vai para a visão na :8081; não → vai para o cérebro na :8000. O caminho tracejado em movimento é a requisição viajando:
ROTEAMENTO DE UMA REQUISIÇÃO · do cliente ao tier certo (decisão: tem imagem?)
A decisão é trivial — texto puro vai ao cérebro residente; imagem desperta a visão. É a mesma máquina servindo dois cérebros por uma regra de uma linha.
De zero a servindo (o processo de boot)
E como você liga tudo isso? Em quatro passos, uma vez. Depois é só consumir. Este fluxograma é o resumo da Lição 09 (mãos à obra) condensado:
Tudo o que você derivou converge aqui. Um M5 Max de 128 GB hospeda dois endpoints locais: o Tier 1 é o cérebro — DeepSeek-V4-Flash q2 servido pelo DS4 na porta :8000, 81 GB residentes, ~25–34 tok/s (pico 33,9). O Tier 2 é a visão — Qwen3-VL via MLX na porta :8081, que descreve 99% das suas imagens. Os clientes falam OpenAI/Anthropic com 127.0.0.1 e não sabem que o backend é local. Este diagrama é o mapa-mãe de todo o curso:
O CÉREBRO LOCAL · dois tiers, duas portas, um silício
Esse cérebro não precisa ser genérico para sempre. A observação do antirez aponta o passo imediato: carregar o especialista que a pergunta pede. Um ds4-legal afinado em corpus jurídico entrega inferência jurídica de nível frontier — offline, a $0 por token, com a privacidade total que documentos previdenciários exigem. É a ponte direta para a Previdência Factory do fundador: a mesma máquina que você montou nas Lições 08–10 serve um cliente real sem mandar um único byte para fora.
Faz muito sentido ter modelos ds4-coding, ds4-legal, ds4-medical. Você carrega o que precisa dependendo da pergunta.— antirez, news/165
O ativo durável não é o peso, é o raciocínio
O DeepSeek-V4-Flash é a melhor peça que cabe hoje; amanhã troca. O que persiste é o que você aprendeu: ler capacidade × banda, fazer a math de memória, escolher o motor por último, raciocinar KV/quantização e servir um frontier local. Por isso se otimiza para a década, não para o lançamento — trocar de modelo vira só re-baixar pesos.
06 · O caminho de um token, ponta a ponta
Para selar o curso, siga um único token da sua pergunta até a resposta — atravessando todas as peças que você estudou, em ordem. Este é o mapa de dados que une as 11 lições num só fluxo:
UM TOKEN, DO PROMPT À RESPOSTA · prompt → engine → pesos (SSD→GPU) → KV cache → silício → token
O que acontece num token — em duas profundidades
A mesma ideia, ensinada de dois jeitos. Comece pelo simples (a analogia); só então abra o técnico (o mecanismo). Examples antes de abstrações:
Pense numa orquestra lendo uma partitura gigante. A partitura (os pesos) é enorme demais para decorar, então fica na estante (SSD) e o maestro puxa só as páginas necessárias para a mesa (GPU). A cada compasso (token), os músicos olham o que já tocaram (o KV cache) para manter o ritmo. Quanto mais rápido eles viram páginas (a banda), mais rápido a música sai. E como cada nota depende da anterior, não dá para pular à frente — é sequencial.
Mecanismo real: para cada token, o engine faz um forward pass — num MoE, o roteador ativa só alguns experts, então só parte dos 81 GB é lida da memória. A camada de atenção lê o KV cache (chaves/valores de todos os tokens anteriores) e anexa o seu próprio par. A velocidade é ≈ banda ÷ bytes-lidos-por-token: por isso um MoE q2 voa (lê pouco) e por isso a banda (460–614 GB/s) — não os FLOPs — é o gargalo da geração. O token amostrado vira entrada do passo seguinte.
Comparativo final: os dois tiers, lado a lado
E para fechar com a segunda comparação do capstone — o cérebro e a visão não são o mesmo tipo de peça. Um é residente e otimizado para inteligência por dólar; o outro é sob demanda e otimizado para ler imagens. Veja a divisão de trabalho:
Aspecto
Tier 1 · cérebro
Tier 2 · visão
Modelo
DeepSeek-V4-Flash q2 (MoE 284 B)
Qwen3-VL
Engine
DS4 / DwarfStar
MLX
Porta
127.0.0.1:8000
127.0.0.1:8081
Memória
~81 GB residente
~20 GB sob demanda (swap)
Aciona quando
texto / código / agentes
o payload tem imagem
Otimizado para
inteligência por dólar
ler 99% das imagens
Fixe o curso (flashcards)
Clique pra virar. Cada cartão recupera uma ideia de uma lição diferente — tente lembrar a resposta antes de virar. É o curso inteiro em quatro perguntas:
A banda da memória (≈ banda ÷ bytes lidos/token). Num MoE só os experts ativos são lidos → q2 voa.
L05 · engine
Quando escolher o motor?
clique pra virar ↻
Resposta
Por último. Primeiro o que cabe e voa; só então DS4 (gigante em :8000) ou MLX (visão em :8081).
L07 · servir
"Rodar" vs. "servir"?
clique pra virar ↻
Resposta
Rodar = app de chat, descartável. Servir = endpoint HTTP em 127.0.0.1 que outros programas consomem, sempre on, $0/token.
Revisão cumulativa — recupere de memória (lições 1–10)
Antes de clicar: responda de cabeça. Recuperar da memória (não reler) é o que fixa de verdade. As quatro opções têm o mesmo tamanho de propósito — sem pista pela forma.
0. (L02+L03) Um 70 B q4 (~0,56 GB/1B) no seu M5 Max de 128 GB: cabe? e por quê isso também o deixa rápido?
Correto: b. 70 × 0,56 ≈ 39 GB — sobra muito (L02), e menos bytes lidos por token ajuda a velocidade (L03). a erra a fórmula (39 GB ≠ 256). c confunde: o que pesa na velocidade é bytes lidos por token, não o "tamanho" abstrato. d inventa um streaming que não é o caminho normal — os pesos ficam na RAM unificada.
1. Qual é a tese central que faz este stack ser "o setup da década" e não "o setup do mês"?
Correto: c. "Eu não estou otimizando para o próximo lançamento, estou otimizando para a próxima década" (Ahmad). O ativo durável é o raciocínio + o stack; trocar de modelo vira só re-baixar pesos. a e d são absolutos falsos — modelos novos sempre virão, e você vai baixar outros; o ponto é justamente que isso é barato. b exagera: local nem sempre é mais barato em todo cenário (depende do volume — veja a curva de equilíbrio); a tese é durabilidade, não preço universal.
2. Pela espinha do curso, qual é a ordem correta de decisão antes de servir um modelo?
Correto: b. Lições 01→05 em ordem: o que cabe (memória), se voa (banda), como caber sem matar a qualidade (quantização), e só então o motor. a inverte a regra-mãe — escolher motor antes de saber o que cabe é o erro que a L05 manda evitar. c é a armadilha de contar com compressão de RAM do macOS, que não substitui a math. d erra a prioridade: visão é um tier sob demanda, não o gargalo que define a ordem.
3. Por que um ds4-legal rodando localmente é a ponte direta para a Previdência Factory?
Correto: a. "Você carrega o que precisa dependendo da pergunta" (antirez, news/165). Junte com o homelab-como-nuvem: inferência jurídica frontier, offline, $0/token, privada. É a fundação de um produto real. b erra ao generalizar "nuvem é sempre mais lenta" — a vantagem real é privacidade + custo, não latência garantida. c é o oposto da verdade: documentos previdenciários exigem privacidade máxima. d é fabricação — o antirez não trabalha na Previdência Factory; é só a fonte da ideia de especialistas ds4.
💬 Chegou ao fim — e agora? Eu sou seu professor neste curso. Pergunte o próximo passo: "Como afino um ds4-legal no meu corpus?", "Como ligo o endpoint :8000 ao funnel do Alembic?", "Vale somar o M4 Max de 36 GB via Thunderbolt?". É só dizer — o cérebro está montado, agora a gente o coloca para trabalhar.