O que é um LLM e como ele funciona por dentro (explicado para devs)

Você usa Claude Code, ChatGPT ou Cursor todo dia, manda um prompt, recebe código pronto e segue a vida

Mas o que acontece entre o Enter e a resposta? 🙂

A maioria de nós usa essas ferramentas como caixa-preta, e tá tudo bem até a hora que algo dá errado: a IA esquece o que você falou lá no começo, inventa uma função que não existe ou responde diferente pra mesma pergunta

Entender tokens, previsão do próximo token, janela de contexto e a diferença entre treino e inferência muda MUITO o jeito que você escreve prompt e lê os limites da ferramenta

Se você já sabe o que é o Claude Code e usa no dia a dia, esse post é a base conceitual que fica embaixo dele

Bora abrir o capô?

O que significa LLM (Large Language Model)?

LLM é a sigla de Large Language Model, ou modelo de linguagem grande

Em linguagem de dev: é um modelo de deep learning treinado em uma coleção enorme de texto (livros, sites, artigos) pra compreender, gerar e manipular linguagem humana

Ele não tem um banco de regras gramaticais escrito na mão, nem um if pra cada pergunta possível

O que ele tem é um monte de padrões aprendidos a partir de texto, e é isso que permite gerar respostas que fazem sentido

De onde vem a arquitetura dos LLMs?

Quase tudo que você usa hoje se apoia no Transformer

Essa arquitetura foi proposta no paper Attention Is All You Need, de 2017, escrito por Ashish Vaswani e colegas (Google Brain/Google Research e Universidade de Toronto) e apresentado na NIPS 2017

A sacada do paper: uma arquitetura baseada só em mecanismos de atenção, sem recorrência e sem convoluções

E o que é atenção? Por enquanto pensa assim: é o mecanismo que deixa o modelo olhar pra várias partes do texto ao mesmo tempo e decidir o que é relevante pra cada pedaço

O Transformer acabou virando a arquitetura principal de vários sistemas de IA, incluindo os LLMs 😀

O que é um token e por que ele importa?

Aqui vem o primeiro conceito que muda tudo: o modelo não lê texto como a gente lê

Ele lê tokens

Token é a unidade básica que o LLM processa, e pode ser uma palavra inteira, um pedaço de palavra (subpalavra), uma pontuação ou até um único caractere

Se você conhece o lexer de um compilador, a ideia é parecida: antes de qualquer coisa, a entrada é quebrada em unidades menores que o resto do sistema sabe manipular

Tokens: a ponte entre texto e números

O modelo trabalha com números, não com letras

Os tokens fazem essa ponte: a entrada é quebrada em tokens, e a saída é gerada concatenando tokens, um depois do outro

Ou seja, quando a resposta aparece "digitando" na tela, é literalmente o modelo montando o texto token a token

Como a OpenAI tokeniza o texto?

Um exemplo concreto é a biblioteca tiktoken, usada pelos tokenizadores da OpenAI

Ela usa Byte Pair Encoding (BPE), um processo reversível, sem perdas, que comprime o texto

Reversível quer dizer que dá pra ir do texto pros tokens e voltar pro texto exatamente igual, sem perder nada

Nesses tokenizadores, um token corresponde em média a cerca de 4 caracteres em texto em inglês

Tome cuidado com esse número! Ele é média, vale pra inglês e pros tokenizadores da OpenAI

Não dá pra pegar isso e sair aplicando em português ou em modelos de outros provedores, cada tokenizador quebra o texto do seu jeito

Como um LLM gera texto: a previsão do próximo token

Agora a parte mais importante do post, e que muita gente não sabe

Um LLM gera texto escolhendo o próximo pedaço de texto mais plausível

Só isso, repetido muiiitas vezes

O fluxo por dentro é mais ou menos esse:

1. Texto: o seu prompt
2. Tokens: o texto quebrado em unidades
3. Vetores: cada token vira uma representação numérica
4. Rede neural: esses números passam pelas camadas do modelo
5. Atenção: o modelo pesa o que é relevante no contexto
6. Previsão: sai o próximo token mais plausível

E aí o token gerado entra no contexto, e o ciclo roda de novo pra prever o próximo

Como fica o loop de geração em código?

Se liga nesse pseudocódigo, que é só ilustrativo (não é API real de nenhum provedor):

# Pseudocódigo ilustrativo do loop de geração de um LLM

contexto = tokenizar(prompt_do_usuario)

while not terminou(contexto):
    probabilidades = modelo.prever_proximo(contexto)  # rede neural + atenção
    proximo_token = escolher(probabilidades)          # aqui entram temperatura e top-p
    contexto.append(proximo_token)                    # o token gerado volta pro contexto

resposta = destokenizar(contexto)

Repara no detalhe: cada token gerado vira entrada pra prever o seguinte

É como um autocomplete do celular, só que absurdamente mais sofisticado e rodando em loop até fechar a resposta haha

Temperatura e top-p: por que a resposta muda?

No pseudocódigo ali em cima tem uma função escolher, e é nela que mora a variação

O modelo não tem só um candidato pro próximo token, ele tem vários, cada um com uma probabilidade

A temperatura é o parâmetro que controla o quanto o modelo tende a escolher opções diferentes pro próximo token

O top-p limita a escolha aos tokens de maior probabilidade, cortando as opções mais improváveis

É por isso que a mesma pergunta, feita duas vezes, pode voltar com respostas diferentes 🙂

Janela de contexto: a memória de trabalho do modelo

Segundo a Anthropic, a janela de contexto é todo o texto que o modelo consegue consultar ao gerar um texto novo, mais o próprio texto que ele gera

Se liga nesse "mais": a resposta do modelo também ocupa espaço na janela

E tem outra distinção importante: janela de contexto não é o corpus de treino

Ela funciona como uma memória de trabalho, tipo a RAM da sua máquina, enquanto o que o modelo aprendeu no treino seria mais parecido com o que já vem gravado no disco

O que o tamanho da janela de contexto muda?

Uma janela maior permite lidar com prompts mais longos e complexos

Uma janela menor limita prompts longos e a coerência em conversas extensas

No dia a dia do dev isso aparece assim:

• Aquela conversa gigante em que a IA começa a "esquecer" o que você combinou lá no início
• Arquivos e logs colados no chat, que consomem contexto que poderia ir pra outra coisa
• Respostas longas, que também entram na conta

É por isso que ferramentas mais espertas tentam carregar no contexto só o que é necessário na hora, e dá pra ver bem esse raciocínio em como funcionam as skills do Claude Code

Treino vs inferência: qual a diferença?

Essas duas palavras aparecem em todo lugar e muita gente usa como se fossem a mesma coisa

Não são!

Treino é quando o modelo é ajustado, inferência é quando o modelo já treinado é usado pra gerar texto

Resumindo: quando você conversa com a IA, você está na inferência

O que você escreve no chat entra na janela de contexto, não no treino do modelo

Pré-treino, fine-tuning e RLHF: como o modelo aprende a seguir instruções?

O treino não é uma etapa só

Pelo glossário da Anthropic, modelos autorregressivos, como o modelo base do Claude, são pré-treinados pra prever a próxima palavra a partir do contexto anterior do documento

Só que tem uma pegadinha: o modelo só pré-treinado não é bom, por natureza, em responder perguntas ou seguir instruções

Ele sabe continuar texto, mas não sabe ser um assistente

Aí entram duas etapas de refino:

• Fine-tuning (ajuste fino): pega o modelo que já passou pelo pré-treino e refina ele, em vez de começar do zero
• RLHF (Reinforcement Learning from Human Feedback): aprendizado por reforço a partir de feedback humano, que treina o modelo pra se comportar de acordo com preferências humanas

E o que muda com o RLHF na prática? 🙂

O pré-treino ensina o modelo a continuar texto, e o RLHF puxa esse comportamento na direção do que as pessoas preferem receber como resposta

Ou seja: o pré-treino dá a base, o fine-tuning refina, e o RLHF ajusta o jeito de se comportar

É essa combinação que transforma um "completador de texto" no assistente que responde sua dúvida de código 😀

O que isso muda no seu uso de ferramentas de IA?

Beleza, teoria entendida

Agora o que interessa: como isso muda o seu dia com Claude Code, ChatGPT, Cursor e por aí vai

O modelo prevê texto plausível, não consulta a verdade

O LLM gera o próximo token mais plausível, e plausível não é sinônimo de correto

Por isso a função inventada, o import que não existe, a flag que parece certa mas não é

Revise a saída, sempre, principalmente no modo 100% vibe coder 😛

O que não está no contexto, o modelo não vê

Na hora de gerar, o modelo consulta a janela de contexto

Se a regra do projeto, o arquivo relevante ou a decisão de arquitetura não estão ali, ele não tem como levar em conta

Então vale colocar no prompt o que importa de verdade pra tarefa

Conversa longa cobra seu preço

Como a janela é limitada e conversas extensas afetam a coerência, aquele chat que já dura a tarde inteira tende a degringolar

Quando a IA começar a se perder, às vezes é melhor começar uma conversa nova com um resumo do que importa

Entrada e saída dividem o mesmo espaço

Lembra que a janela inclui o texto que o modelo gera?

Pedir uma resposta gigante também consome contexto, então pedir algo mais focado ajuda

Respostas diferentes pra mesma pergunta são normais

Temperatura e top-p explicam isso: o modelo escolhe entre vários tokens possíveis

Não é bug, é como a geração funciona

Resumo: o LLM por dentro em quatro ideias

Se você chegou até aqui, já sabe o que é LLM num nível que a maioria dos usuários de IA não sabe 🙂

Recapitulando:

1. Tokens: o texto vira unidades (palavra, subpalavra, pontuação ou caractere), que fazem a ponte com os números do modelo
2. Previsão do próximo token: o modelo escolhe o próximo pedaço mais plausível e repete, com temperatura e top-p controlando a variação
3. Janela de contexto: a memória de trabalho, que inclui o que você manda e o que o modelo gera
4. Treino vs inferência: o treino ajusta o modelo (pré-treino, fine-tuning e RLHF), a inferência usa o modelo pronto pra gerar

O próximo passo é prático: na sua próxima sessão com a ferramenta de IA, pensa no prompt como uma janela de contexto que você organiza

O que entra, o que fica de fora, o que é essencial pra tarefa

Depois disso, vale seguir pelos conteúdos de prompt e de Claude Code aqui do blog, que agora vão fazer MUITO mais sentido

Até o próximo post! 😀