Fundamentos de IA e LLMs para Devs

1.1 Breve história da IA

A ideia de uma "máquina que pensa" é muito mais velha que o computador. O que mudou nos últimos anos não foi o sonho, e sim três coisas que finalmente apareceram juntas: dados em escala de internet, hardware paralelo (GPUs) e uma arquitetura que aproveita os dois (o Transformer).

Antes do computador

Mitos gregos já falavam de autômatos, como o gigante de bronze Talos. Aristóteles formalizou o raciocínio lógico com os silogismos. No século XIII, Ramon Llull imaginou combinar conceitos mecanicamente para gerar verdades. No XVII, Leibniz sonhou com um calculus ratiocinator, uma álgebra capaz de resolver discussões por cálculo. Em 1843, Ada Lovelace, escrevendo sobre a máquina analítica de Babbage, previu que ela poderia compor música, mas afirmou que ela nunca "originaria" nada. É uma objeção que ainda ouvimos hoje.

Linha do tempo moderna

• 1943McCulloch e Pitts propõem um modelo matemático do neurônio.
• 1950Alan Turing publica "Computing Machinery and Intelligence" e propõe o Jogo da Imitação (o Teste de Turing).
• 1956Na conferência de Dartmouth, o termo "Inteligência Artificial" é adotado como campo de pesquisa.
• 1958Rosenblatt cria o Perceptron, a primeira rede neural que aprende com exemplos.
• 1969Minsky e Papert mostram que um perceptron simples não aprende o XOR. O entusiasmo esfria (você vai resolver esse problema na aula 1.3).
• anos 70Primeiro "inverno da IA": promessas grandes demais, financiamento cortado.
• anos 80Sistemas especialistas (regras escritas à mão) chegam às empresas. Em 1986 a retropropagação (backpropagation) é popularizada e permite treinar redes com várias camadas.
• fim dos 80Segundo inverno: sistemas especialistas são caros de manter e frágeis.
• 1997Deep Blue, da IBM, vence Kasparov no xadrez, ainda com busca e regras, não com aprendizado.
• 2012AlexNet vence o ImageNet com folga usando redes profundas treinadas em GPU. Começa a era do Deep Learning.
• 2013word2vec mostra que palavras podem virar vetores com significado (embeddings).
• 2016AlphaGo vence Lee Sedol no Go, um jogo considerado difícil demais para máquinas.
• 2017O artigo "Attention Is All You Need" apresenta o Transformer, a base de todos os LLMs atuais.
• 2018–2020GPT, BERT e GPT-3 mostram que modelos maiores, treinados com mais texto, ganham habilidades novas.
• nov/2022O ChatGPT populariza os LLMs. Em dois meses, ultrapassa 100 milhões de usuários.
• 2023Corrida de modelos: GPT-4, Claude, Gemini e modelos de pesos abertos como o Llama.
• 2024Modelos de raciocínio passam a "pensar" antes de responder. Surge o MCP, um protocolo padrão para conectar modelos a ferramentas.
• 2025–2026Agentes de código e agentes autônomos entram no dia a dia do dev; janelas de contexto chegam a milhões de tokens.

1.2 O mapa: IA, Machine Learning, Deep Learning e LLMs

Os termos se encaixam um dentro do outro:

Programação tradicional vs. Machine Learning

Os três tipos de aprendizado

• Supervisionado: exemplos com resposta (foto → "gato"). Classificação e regressão.
• Não supervisionado: só dados, sem resposta. O modelo encontra grupos e estruturas.
• Por reforço: um agente age, recebe recompensa ou punição e aprende uma estratégia.

Um LLM usa um pouco de cada: o pré-treino é autossupervisionado (o próprio texto fornece a resposta, que é a próxima palavra), o ajuste fino é supervisionado, e o alinhamento usa reforço. Você verá isso na aula 1.5.

1.3 Tensores e redes neurais: como uma máquina aprende

Tensores: só arrays com dimensões

Tudo em uma rede neural é número organizado em tensores:

GPUs são boas em IA porque multiplicam tensores grandes em paralelo. "Treinar um modelo" é, no fundo, fazer bilhões dessas multiplicações.

Um neurônio

Um neurônio artificial faz uma soma ponderada das entradas e passa por uma função não linear:

saida = ativacao(w1*x1 + w2*x2 + ... + b)

Os pesos (w) e o viés (b) são o que a rede aprende. A ativação (sigmoide, tanh, ReLU…) é o que permite à rede representar coisas que não são retas. Sem ela, empilhar camadas seria inútil: várias multiplicações lineares equivalem a uma só.

Como a rede aprende: o ciclo de treino

1. Forward: a entrada passa pelas camadas e vira uma previsão.
2. Perda (loss): um número que diz o tamanho do erro. Quanto menor, melhor.
3. Backpropagation: usando a regra da cadeia do cálculo, calcula quanto cada peso contribuiu para o erro (o gradiente).
4. Gradiente descendente: move cada peso um passinho na direção que reduz o erro. O tamanho do passo é a taxa de aprendizado.

Imagine estar numa montanha com neblina, tentando chegar ao vale. Você não vê o vale, mas sente a inclinação sob os pés. Cada passo morro abaixo é uma iteração de gradiente descendente.

O ciclo completo de um projeto de ML

A validação usa dados que o modelo nunca viu no treino. Se ele vai bem no treino e mal na validação, ele decorou em vez de aprender: isso é overfitting. Você vai ver isso acontecer de verdade no projeto do módulo.

python python/01_rede_neural_xor.py
# ou
cd typescript && npx tsx 01-rede-neural-xor.ts

época     0  perda 0.8299
época  1000  perda 0.0055
...
acurácia: 100%
0 XOR 1 = 0.999  ->  1
1 XOR 1 = 0.001  ->  0

1.4 Como um LLM funciona: tokens, embeddings e atenção

Um LLM faz uma única coisa: dado um texto, prevê qual token vem a seguir. Repetindo isso milhares de vezes, ele escreve respostas, código e análises. Vamos abrir a caixa em quatro etapas.

1. Tokenização: texto vira números

O modelo não lê letras nem palavras: lê tokens, pedaços de texto de um vocabulário fixo (dezenas a centenas de milhares de itens). Palavras comuns viram um token; palavras raras são quebradas em pedaços.

"Engenharia de IA aplicada"
→ ["Engen", "haria", " de", " IA", " aplic", "ada"]
→ [ 48213,  9921,   409,  15818,  32001,   1940 ]   (ids ilustrativos)

Consequências práticas que você vai sentir no dia a dia:

• Você paga por token, de entrada e de saída. Textos em português costumam gastar mais tokens que o mesmo texto em inglês.
• Limites são em tokens: a janela de contexto e o tamanho máximo da resposta.
• O modelo "vê" pedaços, por isso pode errar ao contar letras de uma palavra ou inverter uma string.
• Cada modelo tem seu tokenizador. Para contar tokens com precisão, use a API de contagem do provedor.

2. Embeddings: números com significado

Cada token vira um vetor com centenas ou milhares de dimensões. No treino, tokens usados em contextos parecidos acabam com vetores parecidos. Isso cria um "espaço de significado":

vetor("rei") - vetor("homem") + vetor("mulher") ≈ vetor("rainha")
distância("cachorro", "gato")  <  distância("cachorro", "parafuso")

Essa mesma ideia é a base da busca semântica e do RAG (Módulo 4): transformar documentos e perguntas em vetores e buscar pelo significado, não pela palavra exata.

3. Atenção: cada token olha para os outros

Em "O banco estava cheio de peixes", a palavra "banco" precisa olhar para "peixes" para saber que não é uma agência bancária. A atenção é o mecanismo que permite isso. Para cada token, o modelo calcula três vetores:

• Query (Q): "o que eu estou procurando?"
• Key (K): "o que eu ofereço?"
• Value (V): "a informação que eu passo adiante"

A compatibilidade entre a query de um token e as keys dos outros vira um peso (via softmax), e o token recebe uma mistura dos values ponderada por esses pesos:

Atenção(Q, K, V) = softmax( Q·Kᵀ / √d ) · V

Em modelos que geram texto, uma máscara causal impede que um token olhe para o futuro, já que ele ainda não foi escrito.

4. O Transformer: empilhando tudo

Um bloco Transformer alterna atenção (misturar informação entre tokens) com uma pequena rede neural aplicada a cada token (processar essa informação). Modelos grandes empilham dezenas desses blocos, com várias "cabeças" de atenção em paralelo, cada uma especializada em um tipo de relação. Os parâmetros do modelo, que hoje chegam a centenas de bilhões, são os pesos de todas essas camadas.

A grande vantagem sobre as redes recorrentes anteriores: a atenção processa todos os tokens em paralelo. É isso que permitiu treinar com trilhões de tokens em milhares de GPUs.

python python/02_atencao.py

                 o     gato    subiu       no  telhado
        o     1.00     0.00     0.00     0.00     0.00
     gato     0.38     0.62     0.00     0.00     0.00
    subiu     0.25     0.31     0.44     0.00     0.00
       no     0.31     0.19     0.19     0.32     0.00
  telhado     0.17     0.17     0.19     0.19     0.28

1.5 Do modelo base ao assistente

Um assistente como o ChatGPT, o Claude ou o Gemini passa por várias fases de treino:

Modelos de raciocínio

Desde 2024, os principais modelos podem gerar uma etapa de raciocínio antes da resposta final: decompor o problema, testar hipóteses, revisar. Na prática, para quem desenvolve:

• As APIs expõem um controle de esforço (por exemplo, low, medium, high). Mais esforço significa mais qualidade em tarefas difíceis, e também mais tokens, latência e custo.
• Os tokens de raciocínio são cobrados como saída, mesmo quando você não os vê.
• Prompts antigos do tipo "pense passo a passo" perdem importância: o modelo já faz isso. Fica mais importante dar contexto completo e critérios claros do que a receita de como pensar.

Modelos abertos vs. proprietários

Modelos proprietários (acessados por API) costumam liderar em capacidade e não exigem infraestrutura. Modelos de pesos abertos (Llama, Mistral, Qwen, DeepSeek, Gemma e outros) podem rodar na sua máquina ou servidor, o que dá controle de dados e custo previsível em troca de operação própria. Você vai rodar modelos locais no Módulo 11.

1.6 Como o texto é gerado: amostragem e janela de contexto

Um token por vez

A cada passo, o modelo devolve uma pontuação (logit) para cada token do vocabulário. O softmax transforma isso em probabilidades, um token é sorteado, adicionado ao texto, e o processo se repete até um token de fim ou o limite de tamanho. Por isso:

• A resposta é gerada da esquerda para a direita. O modelo não "planeja a frase inteira" antes, a menos que raciocine primeiro.
• Gerar saída é mais lento e mais caro que ler entrada. Ler é paralelo; escrever é sequencial.
• O streaming é natural: dá para mostrar cada token assim que sai.

Temperatura e top-p

• Temperatura divide os logits antes do softmax. Baixa deixa a distribuição pontuda (sempre escolhe o mais provável); alta achata a distribuição (mais variedade e mais risco).
• Top-p (nucleus) sorteia só entre os tokens mais prováveis cuja soma chega a p, cortando a cauda de opções absurdas.

Janela de contexto

É o máximo de tokens que o modelo considera de uma vez: instruções de sistema + histórico da conversa + documentos + a resposta sendo gerada. Hoje vai de dezenas de milhares a mais de um milhão de tokens. Três verdades práticas:

• O modelo não tem memória entre chamadas. Cada requisição é independente: o "histórico" de um chat é você reenviando a conversa toda.
• Contexto custa. Reenviar 100 mil tokens a cada mensagem pesa no orçamento. O cache de prompt (Módulo 2) existe para isso.
• Mais contexto não é automaticamente melhor. Informação irrelevante distrai. Escolher o que entra no contexto é uma habilidade central, chamada engenharia de contexto.

python python/03_amostragem.py

=== temperatura 0.2 ===
     pão  93.4% ██████████████████████████████████████████████
 tapioca   4.6% ██
=== temperatura 2.0 ===
     pão  26.1% █████████████
 tapioca  19.4% █████████
    café  17.5% ████████
    ...

1.7 Sua primeira chamada de API: tokens e custo

Todo provedor (Anthropic, OpenAI, Google, Mistral…) segue o mesmo formato básico: você envia instruções de sistema e uma lista de mensagens, e recebe a resposta e a contagem de tokens usados. Os labs usam o SDK oficial da Anthropic, mas os conceitos se transferem para qualquer provedor (e o Módulo 2 compara vários).

Passo 1: chave de API

1. Crie uma conta no console do provedor (para os labs: platform.claude.com) e gere uma chave.
2. Coloque a chave em uma variável de ambiente, nunca no código:

export ANTHROPIC_API_KEY="sk-ant-..."

Passo 2: a chamada

O núcleo do typescript/04-primeira-chamada.ts:

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic(); // lê ANTHROPIC_API_KEY do ambiente

const resposta = await client.beta.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 2000,
  system: "Você é um professor de engenharia de IA. Responda em português, de forma curta.",
  messages: [{ role: "user", content: "Em 3 frases: o que é um token?" }],
  output_config: { effort: "low" },          // pergunta simples → pouco raciocínio
  betas: ["server-side-fallback-2026-07-01"],
  fallbacks: "default",                      // se houver recusa por filtro, tenta outro modelo
});

if (resposta.stop_reason === "refusal") throw new Error("Recusado");

for (const bloco of resposta.content) {
  if (bloco.type === "text") console.log(bloco.text);
}
console.log(resposta.usage); // { input_tokens, output_tokens, ... }

A versão Python (python/04_primeira_chamada.py) é equivalente. Rode qualquer uma:

python python/04_primeira_chamada.py "O que é uma janela de contexto?"
# ou
cd typescript && npx tsx 04-primeira-chamada.ts "O que é uma janela de contexto?"

Anatomia da resposta

• content: uma lista de blocos (texto, chamadas de ferramenta, raciocínio…). Sempre filtre pelo tipo.
• stop_reason: por que parou. end_turn (terminou), max_tokens (cortada: aumente o limite), refusal (recusou), tool_use (quer usar uma ferramenta, tema do Módulo 2).
• usage: tokens de entrada e de saída. É a base do custo.

Passo 3: calcular o custo

custo = tokens_entrada × preço_entrada / 1.000.000
      + tokens_saída   × preço_saída   / 1.000.000

Preços de referência (US$ por milhão de tokens, nov/2026; confira sempre a página de preços do provedor):

Repare: a saída custa 5× a entrada, e a diferença entre modelos chega a 40×. Escolher o modelo certo por tarefa é uma das decisões de maior impacto financeiro (Módulo 9).

1.8 Limites: o que todo engenheiro de IA precisa respeitar

Cada limite abaixo é a razão de existir de um módulo do curso:

Projeto do módulo: um modelo de linguagem do zero

Você vai construir a versão mais simples possível de um LLM: um modelo que, dado um caractere, prevê o próximo. É pequeno o bastante para rodar em segundos no notebook e completo o bastante para mostrar tokenização, treino, validação, overfitting e amostragem com temperatura.

python python/projeto_modelo_de_linguagem.py
python python/projeto_modelo_de_linguagem.py --temperatura 0.3

O que o código faz

1. Tokeniza o corpus (dados/corpus.txt) em caracteres e separa 10% das frases para validação.
2. Parte A, contando: monta uma tabela de "quantas vezes o caractere B vem depois do A" e converte em probabilidades.
3. Parte B, aprendendo: uma rede neural de uma camada, treinada com gradiente descendente, que aprende a mesma tabela sem ninguém mandar contar.
4. Gera texto novo sorteando caractere por caractere, com temperatura.

O que observar na saída

Parte B — rede neural treinando
  época    0  perda treino 3.663 | validação 3.300
  época  100  perda treino 2.071 | validação 2.379
  época  300  perda treino 2.037 | validação 2.417   ← validação subindo!

A perda de treino continua caindo, mas a de validação volta a subir depois da época 100. É overfitting ao vivo: com só 20 frases, a rede começa a decorar o treino. Na vida real, a solução é mais dados, regularização ou parar o treino mais cedo (early stopping).

Entregáveis

1. Troque o corpus por um texto seu, com pelo menos 50 mil caracteres (letras de música, um livro em domínio público, a documentação de um projeto).
2. Implemente early stopping: pare quando a validação piorar por 3 checagens seguidas.
3. Estenda para trigramas (prever com base nos 2 últimos caracteres) e compare a perda de validação.
4. Gere amostras com temperaturas 0.3, 0.8 e 1.5 e descreva a diferença.
5. Publique no seu GitHub com um README explicando, com suas palavras, como isso se relaciona com um LLM de verdade.

Critérios de avaliação

Recursos para aprofundar

• 3Blue1Brown — Neural Networks · vídeos visuais sobre redes, gradiente, backprop e Transformers
• Andrej Karpathy — Neural Networks: Zero to Hero · do zero ao GPT, em código
• Jay Alammar — The Illustrated Transformer · o Transformer explicado com diagramas
• Transformer Explainer · um GPT-2 interativo no navegador
• TensorFlow Playground · treine redes pequenas visualmente
• Attention Is All You Need (2017) · o artigo original do Transformer
• Documentação da API da Anthropic · referência dos labs; compare com a de outros provedores