Models
Escopo: transversal. Aplica-se a qualquer linguagem ou stack do projeto.
Um modelo de IA é o conjunto de pesos e parâmetros que sobrou do treinamento em um volume enorme de dados. Na hora de usar um em produção, a primeira decisão separa dois caminhos. O modelo cloud (em nuvem) roda no servidor do provedor, você o acessa por API (Application Programming Interface · Interface de Programação de Aplicações) e paga por token consumido. O modelo local roda na sua máquina, sem custo por chamada e sem enviar dado nenhum para fora.
Conceitos fundamentais
| Conceito | O que é |
|---|---|
| Parameters (parâmetros) | Valores numéricos aprendidos durante o treinamento; "tamanho" do modelo, medido em bilhões (B) |
| MoE (Mixture of Experts · Mistura de Especialistas) | Arquitetura que ativa apenas uma fração dos parâmetros por inferência, reduzindo custo computacional |
| Multimodal (multimodal) | Modelo que processa mais de um tipo de entrada: texto, imagem, áudio |
| Open weights (pesos abertos) | Modelo cujos pesos são públicos, podendo ser rodados localmente |
| Proprietary (proprietário) | Modelo cujos pesos não são públicos; acesso via API |
| Context window (janela de contexto) | Total de tokens (entrada + saída) processados em uma chamada |
| Quantization (quantização) | Técnica que reduz a precisão dos pesos (ex: de 32 bits para 4 bits) para diminuir uso de memória |
| GGUF (GPT-Generated Unified Format · formato unificado gerado por GPT) | Formato binário do llama.cpp para armazenar e executar modelos quantizados localmente |
Modelos em nuvem: o provedor executa e cobra por token
Você fala com o modelo por uma API REST (Representational State Transfer · Transferência de Estado Representacional), envia os tokens de entrada e paga pelo que entrou e pelo que saiu. O hardware pesado fica todo do lado do provedor, e a sua máquina só precisa saber fazer uma requisição HTTP.
Claude (Anthropic)
Claude é a família de modelos da Anthropic, com foco em segurança, raciocínio e uso agêntico.
| Modelo | Perfil de uso | Context window |
|---|---|---|
| Claude Opus 4.7 | Máxima inteligência; raciocínio xhigh; verifica os próprios outputs | 1M tokens |
| Claude Sonnet 4.6 | Velocidade + inteligência; melhor desempenho agêntico; uso geral em produção | 1M tokens |
| Claude Haiku 4.5 | Modelo leve e rápido; latência mínima; tarefas simples e alto volume | 200K tokens |
GPT (OpenAI)
Família de modelos da OpenAI. Os modelos o são especializados em raciocínio estendido via chain-of-thought (cadeia de raciocínio interna).
| Modelo | Perfil de uso |
|---|---|
| GPT-4.1 | Contexto de 1 milhão de tokens; uso geral em produção |
| GPT-5 | Topo de linha da família GPT; raciocínio avançado |
| o3 | Raciocínio profundo; benchmarks STEM e código |
| o4-mini | Raciocínio com baixo custo; excelente em matemática e código |
Gemini (Google)
Família de modelos do Google DeepMind. Todos com suporte nativo a entrada multimodal.
| Modelo | Perfil de uso |
|---|---|
| Gemini 2.5 Pro | Contexto de 1 milhão de tokens; modo Deep Think; topo do LMArena |
| Gemini 2.5 Flash | Contexto de 1 milhão de tokens; raciocínio dinâmico com orçamento controlável; baixa latência |
Llama (Meta)
Família open weights da Meta. Llama 4 adota arquitetura MoE e processamento multimodal nativo.
| Modelo | Parâmetros | Context window |
|---|---|---|
| Llama 4 Scout | 17B ativos / 109B total | 10 milhões de tokens |
| Llama 4 Maverick | 17B ativos / 400B total | 1 milhão de tokens |
Os pesos do Llama são públicos, então os mesmos modelos da tabela acima rodam na sua máquina via Ollama.
Mistral
Família de modelos da Mistral AI, com foco em código e eficiência. Distribuídos sob Apache 2.0.
| Modelo | Perfil de uso |
|---|---|
| Mistral Large 3 | 41B ativos / 675B total; 256K contexto; uso geral |
| Devstral 2 | 123B; estado da arte open-source para agentes de código (72.2% SWE-bench) |
| Ministral 3/8B | Modelos compactos; rodam em laptop |
| Magistral | Família de raciocínio da Mistral |
Modelos locais: os pesos rodam na sua máquina
O modelo local processa tudo na sua máquina, e nenhum byte do prompt sai dela. Isso serve para prototipar sem gastar, para trabalhar sem internet e para os casos em que o dado não pode chegar a um servidor de terceiro.
Ollama
O Ollama baixa e executa um modelo com um comando só. Cada modelo é identificado por nome:tag (por exemplo llama3.1:8b-q4_K_M), e o download vem em camadas, como uma imagem Docker.
# baixar e executar modelo
ollama run llama3.1:8b
# listar modelos disponíveis
ollama list
Modelos populares disponíveis no Ollama: llama4, qwen2.5, mistral, gemma3, phi4, deepseek-r1.
LM Studio
O LM Studio é a interface gráfica para rodar modelos GGUF sem linha de comando. Ele sobe um servidor local compatível com a API da OpenAI, então uma ferramenta que já fala com a OpenAI passa a falar com o modelo local trocando a URL.
Quantização: encolher os pesos para caber na memória
Quantizar é guardar cada peso do modelo com menos bits, saindo do ponto flutuante de 32 bits (FP32) para representações como Q8 ou Q4. O arquivo encolhe, o modelo cabe em menos memória e a inferência acelera. Em troca, a resposta perde um pouco de qualidade, e o quanto ela perde depende do nível escolhido.
O formato GGUF (do llama.cpp) é o padrão dos modelos quantizados locais. Cada arquivo .gguf traz os pesos já quantizados junto com os metadados da arquitetura, o que permite carregar o modelo sem nenhum outro arquivo ao lado.
Níveis de quantização
| Nível | Bits | Tamanho relativo | Qualidade | Indicação |
|---|---|---|---|---|
| FP16 | 16 | 100% (referência) | Máxima | GPU com VRAM suficiente |
| Q8_0 | 8 | ~50% | Alta (quase FP16) | GPU ou CPU com RAM folgada |
| Q4_K_M | 4 | ~25-30% | Boa (~95% de FP16) | Ponto de equilíbrio: uso geral local |
| Q3_K_S | 3 | ~20% | Razoável | Hardware muito limitado |
A notação K_M indica os K-quants com superblocks, que preservam mais qualidade que os formatos antigos com o mesmo número de bits. Para a maioria dos casos, Q4_K_M é a escolha padrão na comunidade: o modelo ocupa cerca de um quarto do tamanho original e mantém perto de 95% da qualidade.
Exemplo: modelo 7B em diferentes quantizações
| Quantização | Tamanho do arquivo | RAM necessária |
|---|---|---|
| FP16 | ~14 GB | ~16 GB |
| Q8_0 | ~7 GB | ~8 GB |
| Q4_K_M | ~4.1 GB | ~5 GB |
| Q3_K_S | ~3.0 GB | ~4 GB |
A tabela explica por que Q4_K_M virou padrão: um modelo de 7 bilhões de parâmetros passa a caber em 5 GB de RAM, o que roda em um laptop comum.
DoDocs v3.7.0 · Desenvolvido por @thiagocajadev · Baseado no trabalho de pmndrs/docs · Poimandres.