A base que ninguém te ensina para sobreviver na era da IA (Parte 1)

Você consegue explicar por que o ChatGPT às vezes “alucina”?

Não estou perguntando se você sabe que ele alucina. Todo mundo sabe. Estou perguntando se você sabe o mecanismo técnico que causa isso. Se você consegue abrir o capô e apontar exatamente onde a engrenagem falha.

Se a resposta for não, eu tenho uma notícia desconfortável: você não é um profissional de IA. Você é um usuário. E na velocidade que essa indústria se move, a distância entre os dois está ficando cada vez mais perigosa.

Pense assim: todo mundo sabe dirigir um carro. Mas quando o motor faz um barulho estranho, 99% das pessoas levam ao mecânico. O mecânico entende o que está por baixo. E na era dos carros autônomos, quem só sabe dirigir vai ser substituído pelo software. Quem entende o motor vai construir o software.

Com IA é a mesma coisa. Milhões de pessoas sabem usar o ChatGPT, o Claude, o Gemini. Escrevem prompts, copiam respostas, colam no código. Mas quando algo dá errado, quando o modelo alucina, quando o custo explode, quando a latência estoura o SLA, elas não fazem ideia do que mexer. Porque nunca aprenderam o que está por baixo.

Existe uma base técnica moderna que separa quem vai prosperar nessa era de quem vai ser substituído. Não é um PhD em matemática. Não é decorar papers. São fundamentos específicos, práticos, que qualquer desenvolvedor com disciplina consegue aprender.

Neste post (Parte 1 de 2), vou te dar o mapa completo. Hoje cobrimos a teoria: matemática essencial, como LLMs realmente funcionam, e dados e representações. Na Parte 2, vamos para a prática: engenharia de sistemas com IA, avaliação e observabilidade.

Vamos lá.

O mapa: o que você realmente precisa saber

Antes de mergulhar, preciso te mostrar o mapa completo. São cinco áreas fundamentais, organizadas como uma árvore de habilidades de RPG. Cada uma desbloqueia a próxima:

#	Área	O que cobre	Parte
1	Matemática essencial	Álgebra linear, probabilidade, gradientes	Parte 1 (este post)
2	Como LLMs funcionam	Tokenização, embeddings, attention, geração	Parte 1 (este post)
3	Dados e representações	Bancos vetoriais, chunking, feature engineering	Parte 1 (este post)
4	Engenharia de sistemas com IA	RAG, agentes, guardrails, orquestração	Parte 2
5	Avaliação e observabilidade	Evals, métricas, monitoramento, custos	Parte 2

A ordem importa. Você não entende embeddings sem álgebra linear. Não entende attention sem probabilidade. Não constrói RAG sem entender bancos vetoriais. Cada nível é pré-requisito do próximo.

A boa notícia: você não precisa dominar tudo no nível acadêmico. Precisa de intuição funcional. Entender o suficiente para tomar decisões técnicas informadas, debugar problemas reais e ter conversas produtivas com quem vai mais fundo.

Matemática essencial: você não precisa de PhD, precisa de intuição

Essa é a parte que assusta a maioria dos desenvolvedores. “Matemática? Eu virei programador justamente pra fugir disso.” Eu entendo. Eu era esse cara. Mas a verdade é que a matemática por trás da IA moderna é surpreendentemente acessível se você focar no que importa e ignorar o que não importa.

Álgebra linear: a língua da IA

Se a IA tivesse uma língua nativa, seria álgebra linear. Tudo que um modelo de IA “vê”, “ouve” ou “lê” é transformado em vetores e matrizes antes de ser processado. Cada palavra, cada imagem, cada som vira uma lista de números.

Um vetor é simplesmente uma lista ordenada de números. Por exemplo, a palavra “café” pode ser representada como um vetor de 1536 números (no modelo text-embedding-3-small da OpenAI). Esses números capturam o “significado” da palavra num espaço matemático.

O exemplo mais famoso é a aritmética de palavras. Em 2013, pesquisadores do Google (Mikolov et al.) mostraram que com Word2Vec:

vetor("rei") - vetor("homem") + vetor("mulher") ≈ vetor("rainha")

Isso funciona porque os vetores capturam relações semânticas. A “direção” de homem para mulher é a mesma de rei para rainha. Parece mágica, mas é álgebra linear pura.

O conceito mais importante para o dia a dia é a similaridade coseno. Ela mede o quanto dois vetores apontam na mesma direção, independente do tamanho. É assim que sistemas de busca semântica encontram documentos relevantes, que RAG seleciona contexto, e que recomendações funcionam.

import numpy as np

def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

# Vetores fictícios para ilustrar
cafe = np.array([0.8, 0.6, 0.1])
cappuccino = np.array([0.75, 0.65, 0.15])
carro = np.array([0.1, 0.2, 0.9])

print(cosine_similarity(cafe, cappuccino))  # ~0.99 (muito similar)
print(cosine_similarity(cafe, carro))        # ~0.38 (pouco similar)

O que você precisa saber: vetores, matrizes, produto escalar (dot product), similaridade coseno, multiplicação de matrizes.

O que você NÃO precisa: decomposição espectral, autovalores/autovetores, espaços de Hilbert, álgebra tensorial avançada.

Probabilidade e estatística: a língua da incerteza

LLMs não “sabem” nada. Eles calculam probabilidades. Quando o ChatGPT responde sua pergunta, ele não está consultando uma base de conhecimento. Ele está fazendo next-token prediction: dado todo o texto anterior, qual é o próximo token mais provável?

Formalmente: P(próximo_token | todos_os_tokens_anteriores)

Cada vez que o modelo gera um token, ele calcula uma distribuição de probabilidade sobre todo o vocabulário (dezenas de milhares de tokens possíveis) e escolhe um. O parâmetro temperature controla como essa escolha é feita:

• Temperature = 0: sempre escolhe o token com maior probabilidade. Resultado mais “determinístico” e repetitivo.
• Temperature = 1: amostra proporcionalmente às probabilidades. Mais variado e “criativo”.
• Temperature > 1: aplaina a distribuição, tornando tokens improváveis mais prováveis. Mais caótico.

A função que transforma os scores brutos do modelo em probabilidades se chama softmax:

import numpy as np

def softmax(logits, temperature=1.0):
    scaled = logits / temperature
    exp_scaled = np.exp(scaled - np.max(scaled))
    return exp_scaled / exp_scaled.sum()

logits = np.array([2.0, 1.0, 0.5, 0.1])

print(softmax(logits, temperature=0.5))  # [0.72, 0.18, 0.07, 0.03] - concentrado
print(softmax(logits, temperature=1.0))  # [0.47, 0.17, 0.10, 0.07] - balanceado
print(softmax(logits, temperature=2.0))  # [0.34, 0.20, 0.16, 0.13] - espalhado

Veja como temperature baixa concentra quase toda a probabilidade no token com maior score, e temperature alta distribui mais uniformemente. Isso é tudo que você precisa saber sobre temperature para tomar decisões técnicas no dia a dia.

O que você precisa saber: distribuições de probabilidade, média e variância, teorema de Bayes (intuição, não a fórmula), softmax, amostragem.

O que você NÃO precisa: cadeias de Markov avançadas, processos estocásticos, teoria da informação formal.

Cálculo: só o mínimo para entender gradientes

Aqui é onde a maioria desiste. Mas eu prometo: você precisa de exatamente UM conceito de cálculo para entender como modelos de IA aprendem. Esse conceito é o gradiente.

Pense assim: você está no topo de uma montanha, no escuro total, e precisa descer até o vale. Você não enxerga nada. Mas pode sentir a inclinação do terreno com os pés. Então você dá um passo na direção mais íngreme para baixo, sente a inclinação de novo, ajusta a direção, e repete.

Isso é gradient descent. O modelo de IA começa com pesos aleatórios (posição na montanha), calcula o quão errada está a resposta (altitude), e ajusta os pesos na direção que reduz o erro (desce a montanha). O gradiente é a “inclinação” que diz qual direção ajustar.

O learning rate é o tamanho do passo. Grande demais: você pula por cima do vale e sobe do outro lado. Pequeno demais: leva uma eternidade para chegar.

O que você precisa saber: derivada como “taxa de mudança”, gradiente como “direção de maior mudança”, gradient descent como loop de aprendizado, learning rate como tamanho do passo.

O que você NÃO precisa: resolver integrais, séries de Taylor, equações diferenciais, backpropagation no nível do paper original.

Resumo: o que estudar vs o que ignorar

Tema	Precisa saber	Pode ignorar
Álgebra linear	Vetores, matrizes, dot product, cosine similarity	Decomposição espectral, autovalores
Probabilidade	Distribuições, Bayes (intuição), softmax	Cadeias de Markov avançadas, teoria da informação
Cálculo	Derivadas, gradientes, learning rate	Integrais, séries, equações diferenciais

Como LLMs realmente funcionam (sem bullshit)

Agora que você tem a base matemática, vamos abrir o capô de um LLM. Eu vou te explicar o fluxo completo, do prompt que você digita até a resposta que aparece na tela. Sem jargão desnecessário, sem simplificações que mentem.

Tokenização: o primeiro passo que ninguém explica

LLMs não leem palavras. Leem tokens. Um token é um pedaço de texto que pode ser uma palavra inteira, parte de uma palavra, um caractere especial, ou até um espaço.

A frase “Inteligência artificial é fascinante” não entra no modelo como 4 palavras. Ela é quebrada em tokens:

["Int", "elig", "ência", " artificial", " é", " fasc", "in", "ante"]

Por que isso importa no dia a dia?

Custo. Você paga por token, não por palavra. E línguas como português geram mais tokens que inglês para o mesmo conteúdo (porque o tokenizador foi treinado majoritariamente em inglês). Eu já escrevi sobre o custo invisível dos tokens desperdiçados em detalhe.

Limites de contexto. Quando um modelo tem “128K tokens de contexto”, são 128K tokens, não 128K palavras. Em português, isso é significativamente menos palavras do que parece.

Comportamento estranho. Modelos às vezes erram em tarefas simples de contagem de caracteres (“quantas letras R tem em ‘strawberry’?”) porque eles não veem caracteres individuais, veem tokens.

Você pode experimentar com o tiktoken da OpenAI:

import tiktoken

enc = tiktoken.encoding_for_model("gpt-4")
tokens = enc.encode("Inteligência artificial é fascinante")
print(f"Tokens: {len(tokens)}")  # provavelmente 6-8 tokens
print([enc.decode([t]) for t in tokens])  # mostra cada token

Embeddings: de tokens a vetores

Cada token é convertido em um vetor de números (um embedding). Se o modelo tem dimensão 4096, cada token vira uma lista de 4096 números. Esses números são os “pesos” que o modelo aprendeu durante o treinamento.

Tokens com significado similar acabam com vetores parecidos. “Cão” e “cachorro” ficam próximos no espaço vetorial. “Cão” e “economia” ficam distantes.

Essa conversão de token para vetor é a ponte entre texto (que humanos entendem) e matemática (que o modelo processa). Todo o resto do processamento acontece no espaço vetorial.

Na prática, você interage com embeddings o tempo todo:

from openai import OpenAI

client = OpenAI()

response = client.embeddings.create(
    model="text-embedding-3-small",
    input=["cachorro brincando no parque", "cão correndo no jardim"]
)

# Dois textos semanticamente similares terão embeddings próximos
embedding_1 = response.data[0].embedding  # vetor de 1536 dimensões
embedding_2 = response.data[1].embedding

Quando você faz busca semântica, RAG, ou classificação de texto com IA, está usando embeddings por baixo dos panos.

Attention: o mecanismo que mudou tudo

Em 2017, pesquisadores do Google publicaram o paper “Attention Is All You Need” (Vaswani et al.) e mudaram a história da IA. O mecanismo central desse paper é o self-attention.

A ideia é elegante: para cada token na sequência, o modelo calcula o quanto esse token deve “prestar atenção” em cada um dos outros tokens.

Exemplo: na frase “O banco está perto do rio”, como o modelo sabe que “banco” se refere a um banco de sentar e não a um banco financeiro? Porque o mecanismo de attention dá peso alto à conexão entre “banco” e “rio”. O contexto “rio” puxa o significado de “banco” para a direção certa.

Sem attention, o modelo processaria cada token isoladamente, como um saco de palavras. Com attention, ele entende relações entre tokens, independente da distância. “O gato que o vizinho do meu amigo adotou no ano passado fugiu” liga “gato” a “fugiu” mesmo com 10 tokens entre eles.

O que você precisa saber:

• Self-attention permite que cada token “olhe” para todos os outros na sequência
• É isso que torna Transformers poderosos para entender contexto
• A janela de contexto (128K, 200K, 1M tokens) é o limite de quantos tokens podem “se ver” simultaneamente
• Mais contexto = mais attention calculations = mais custo computacional (quadrático com o tamanho da sequência)

O loop de geração: next-token prediction

Agora vamos juntar tudo. O processo completo de gerar uma resposta funciona assim:

Passo	O que acontece
1. Input	Você digita “Qual a capital do Brasil?“
2. Tokenização	Texto é quebrado em tokens
3. Embeddings	Cada token vira um vetor
4. Attention layers	Tokens interagem entre si (dezenas de camadas)
5. Output	Modelo produz probabilidades para o próximo token
6. Sampling	Um token é escolhido (influenciado por temperature)
7. Loop	Token escolhido é adicionado à sequência, volta ao passo 3

O modelo gera um token por vez. “Brasília” não aparece de uma vez. Aparece como “Bras” + “ília” (ou algo similar, dependendo do tokenizador). E para cada token, o modelo roda todo o pipeline de novo.

Isso explica algo fundamental: alucinações. O modelo não consulta uma base de dados. Ele gera o token mais provável dado o contexto. Se o contexto estatístico sugere que “a capital do Brasil é” geralmente é seguido por “Brasília”, ele acerta. Mas se o padrão estatístico for ambíguo ou se o modelo nunca viu informação suficiente sobre o tema, ele gera o token mais provável mesmo que esteja errado. Ele não “sabe” que está errado porque não tem conceito de verdade. Tem conceito de probabilidade.

Dados e representações: garbage in, garbage out (agora com esteroides)

Na era da IA, o ditado “garbage in, garbage out” ganhou uma dimensão nova. Se os dados que alimentam seu sistema estão mal representados, mal estruturados, ou mal recuperados, nenhum modelo do mundo salva o resultado.

Bancos vetoriais: o novo banco de dados

Bancos de dados tradicionais (PostgreSQL, MySQL) são projetados para busca exata: “me dê todos os usuários com idade > 30”. Bancos vetoriais são projetados para busca por similaridade: “me dê os documentos mais parecidos com esta pergunta”.

Quando você armazena um embedding (vetor de 1536 números) num banco vetorial e depois faz uma busca, ele encontra os vetores mais “próximos” usando métricas como similaridade coseno. Isso é a base de:

• RAG (Retrieval-Augmented Generation): buscar documentos relevantes para enriquecer o contexto do LLM
• Busca semântica: encontrar resultados por significado, não por palavras exatas
• Memória de agentes: armazenar e recuperar experiências passadas

Os principais bancos vetoriais que você deveria conhecer:

Banco	Tipo	Melhor para
pgvector	Extensão PostgreSQL	Quem já usa Postgres e quer simplicidade
Chroma	Open-source, embarcado	Prototipagem rápida, projetos menores
Weaviate	Open-source, standalone	Produção com features avançadas
Pinecone	SaaS gerenciado	Quem não quer gerenciar infraestrutura
Qdrant	Open-source, Rust	Performance alta, escala grande

O conceito mais importante para entender é o HNSW (Hierarchical Navigable Small World), o algoritmo de indexação mais comum. Ele cria um grafo hierárquico que permite busca aproximada em tempo sublinear. Não é busca exata (por isso se chama ANN, Approximate Nearest Neighbor), mas é rápido o suficiente para produção.

Chunking e janela de contexto

LLMs têm limite de contexto. Mesmo os modelos mais recentes com 1 milhão de tokens não conseguem processar uma base de conhecimento inteira de uma vez. Você precisa dividir seus documentos em pedaços (chunks) e recuperar apenas os relevantes.

Três estratégias principais:

Fixed-size chunking: divide o texto em pedaços de N tokens. Simples, rápido, mas pode cortar frases no meio e perder contexto.

Semantic chunking: divide por limites semânticos (parágrafos, seções, mudanças de tópico). Melhor qualidade, mais complexo de implementar.

Recursive chunking: tenta dividir por limites grandes primeiro (seções), e se o chunk ainda for grande demais, divide por limites menores (parágrafos, frases). É o padrão do LangChain e funciona bem na maioria dos casos.

Chunking errado é a causa número 1 de RAG ruim. Se seus chunks cortam informação no meio, o modelo recebe contexto incompleto e gera respostas incompletas ou erradas. Eu aprofundo isso no post sobre RAG na prática.

Feature engineering na era dos embeddings

Antes dos LLMs, transformar dados brutos em representações úteis para modelos era um trabalho manual e artesanal. Você criava features como one-hot encoding para categorias, TF-IDF para texto, normalização para números.

Com embeddings, grande parte desse trabalho é automatizado. Um modelo de embedding transforma texto em vetores que capturam significado sem que você precise definir regras manualmente.

Mas atenção: embeddings não são bala de prata. A regra prática é:

• Dados estruturados (tabelas, números, categorias): features tradicionais ainda funcionam melhor. XGBoost com boas features bate LLM em muitas tarefas tabulares.
• Dados não-estruturados (texto, imagem, áudio): embeddings são superiores. Use modelos de embedding específicos para o tipo de dado.
• Dados mistos: combine ambos. Features numéricas + embeddings de texto concatenados num mesmo pipeline.

Isso conecta diretamente com o que discutimos no post sobre IA para tudo é o canhão que mata mosquito: saber quando usar embeddings e quando usar features tradicionais é parte de saber quando usar IA e quando não usar.

Próximo capítulo: da teoria à produção (Parte 2)

Tudo que cobrimos até agora é a teoria. A base. O alicerce. Mas saber a teoria sem saber construir é como saber anatomia sem saber operar. Você entende o corpo, mas não consegue salvar o paciente.

Na Parte 2, vamos para a mesa de cirurgia:

• Engenharia de sistemas com IA: como arquitetar RAG em produção, orquestrar agentes autônomos, implementar guardrails que previnem desastres, e decidir entre fine-tuning e prompting
• Avaliação e observabilidade: como medir se sua IA realmente funciona (spoiler: “parece bom” não é métrica), criar evals consistentes, monitorar custos e latência, e detectar degradação antes que o usuário reclame

A Parte 2 sai em breve. Se você chegou até aqui, já tem uma vantagem enorme sobre quem só sabe copiar prompts.

Conclusão: a IA faz tudo, menos pensar por você

Vamos recapitular o mapa:

1. Matemática essencial: álgebra linear para entender embeddings, probabilidade para entender geração, gradientes para entender aprendizado
2. Como LLMs funcionam: tokenização, embeddings, attention, next-token prediction
3. Dados e representações: bancos vetoriais, chunking, quando usar embeddings vs features tradicionais

Esses três pilares são o que separa quem pilota a IA de quem é pilotado por ela. A IA substitui execução, não compreensão. Ela gera código, mas não entende por que aquele código é a escolha certa. Ela responde perguntas, mas não sabe quando a resposta está errada. Ela processa dados, mas não sabe se os dados fazem sentido.

Quem entende os fundamentos consegue:

• Diagnosticar por que o modelo está alucinando (contexto ruim? chunking errado? temperatura alta?)
• Escolher a ferramenta certa para cada problema (LLM? embedding + busca vetorial? algoritmo tradicional?)
• Otimizar custos (reduzir tokens, cachear embeddings, usar modelos menores onde possível)
• Ter conversas técnicas produtivas com a equipe em vez de repetir buzzwords

Eu já escrevi sobre por que fundamentos importam mais que certificações de uma perspectiva filosófica. Este post é o complemento prático: o que exatamente são esses fundamentos e como começar a estudá-los.

Se esse post foi útil, compartilhe com aquele dev que acha que saber promptar é suficiente. Ele vai te agradecer quando o hype passar e os fundamentos ficarem.