Sobre o livro

Nunca foi tão fácil criar uma demonstração impressionante com Inteligência Artificial. Algumas linhas de código, uma chamada de API e pronto: um assistente que conversa, resume documentos e responde perguntas. O difícil vem depois. A pergunta que mais ouço, em consultorias e em salas de aula, é sempre alguma variação de: "Ok, entendi o que é um LLM. Agora, como faço um sistema com LLMs funcionar em produção sem quebrar, sem custar uma fortuna e sem inventar respostas?"

Este livro é uma resposta a essa pergunta. Ele é um guia prático de Engenharia de IA: a disciplina de construir sistemas com LLMs (Large Language Models, grandes modelos de linguagem) que funcionam no mundo real não apenas em provas de conceito, mas em produção, com usuários reais e consequências tangíveis.

A jornada começa por uma mudança de mentalidade: sair do paradigma determinístico, em que a mesma entrada produz sempre a mesma saída, e aprender a projetar, testar e operar sistemas probabilísticos, em que a resposta pode variar e, ainda assim, precisa ser confiável. Sobre essa base, construímos o repertório completo da Engenharia de IA: prompts, RAG, agentes, fine-tuning (ajuste fino), dados, arquitetura, testes, observabilidade e deploy.

Como o livro está organizado

Os dez capítulos formam uma trilha contínua, do fundamento à produção:

1. A mudança de paradigma: o que muda ao sair do mundo determinístico para o probabilístico, e por que a Engenharia de IA é uma disciplina própria;

2. A anatomia dos LLMs: tokens, embeddings (representações vetoriais) e a arquitetura Transformer, sempre com foco nas consequências práticas: custo, latência e escolha de modelo;

3. Engenharia de Prompt e raciocínio: dos cinco componentes de um bom prompt às técnicas de raciocínio, como Chain of Thought e ReAct, passando por segurança e avaliação sistemática;

4. RAG: como dar memória externa aos LLMs: indexação, chunking (fatiamento), re-ranking (reordenação), busca híbrida e as métricas para saber se a resposta é fiel ao contexto;

5. Agentes e ferramentas: Function Calling (chamada de função), memória, padrões de raciocínio, sistemas multiagente e os limites de segurança que todo agente precisa ter;

6. Fine-tuning e adaptação de modelos: quando (e principalmente quando não) especializar um modelo, com SFT, DPO, LoRA e QLoRA;

7. Engenharia de Dados: governança, versionamento, dados sintéticos, pipelines e monitoramento de drift (mudança na distribuição dos dados): a fundação de que todo o resto depende;

8. Arquitetura, testes e observabilidade: arquiteturas de referência, a pirâmide de testes adaptada para IA, guardrails (barreiras de segurança) e o Model Context Protocol (MCP);

9. Serving, deploy e infraestrutura: hardware, quantização, métricas de performance e a conta de quando vale a pena sair da API para o self-hosting (hospedagem própria);

10. Projeto completo, ética e futuro: tudo junto em um projeto real, da definição do problema ao deploy, com auditoria ética e as tendências que vêm pela frente.

Do primeiro ao último capítulo, você acompanha a jornada de Ana, uma engenheira de software em transição para a Engenharia de IA. Os problemas que ela enfrenta, o protótipo que traz trechos irrelevantes, o agente que quase apagou dados de produção, o modelo que não cabe na GPU são os mesmos que você vai encontrar nos seus projetos, e cada capítulo mostra como resolvê-los. No capítulo final, construímos com ela um projeto completo, o Assistente de Análise de Contratos, que integra tudo o que foi visto.

Tecnologias utilizadas

Os exemplos são em Python, com nomes de variáveis e funções em português. Ao longo do livro usamos, entre outras ferramentas, as bibliotecas 'openai' (com o modelo 'gpt-4o-mini' na maioria dos exemplos), 'tiktoken', 'sentence-transformers', 'pydantic' e 'chromadb', além de 'peft' e 'transformers' para LoRA e QLoRA, DVC para versionamento de dados, 'pytest' e promptfoo para testes, e vLLM para servir modelos.

Mais importante que as ferramentas, porém, são os conceitos. Modelos e bibliotecas evoluem rápido — os citados no texto refletem o que estava disponível à época desta escrita —, mas os princípios de engenharia que você vai aprender continuam valendo quando a próxima geração chegar.

Exercícios e código-fonte

Todo capítulo termina com a seção "Mão na massa": três exercícios em níveis progressivos: básico, intermediário e desafio, que vão da reflexão guiada à implementação completa. Os códigos dos exemplos e as soluções comentadas de todos os exercícios estão disponíveis no repositório do livro: https://github.com/ileoh/solucoes-aieng-leonardo-pena.

Para quem é este livro

Este livro foi escrito para quem desenvolve software e quer dar o próximo passo: sair do "já testei a API do ChatGPT" para "eu projeto, construo e opero sistemas com LLMs em produção". Ele vai ajudar especialmente:

Pessoas desenvolvedoras e engenheiras de software que vieram do mundo determinístico, como Ana, a personagem que acompanha todo o livro, e querem incorporar LLMs aos seus sistemas com a mesma seriedade de engenharia que aplicam ao restante do código;

Cientistas e engenheiros de dados que já conhecem modelos, mas querem aprender a transformá-los em produto: RAG, agentes, testes, observabilidade e deploy;

Tech leads e arquitetos que precisam tomar decisões fundamentadas, RAG ou fine-tuning? API ou self-hosting? — e avaliar custo, risco e qualidade de sistemas de IA.

Pré-requisitos

Para aproveitar bem a leitura, você precisa de:

Python básico: ler e escrever scripts simples, instalar pacotes com 'pip' e executá-los no terminal. Os exemplos são curtos e não usam recursos avançados da linguagem;

Noções de desenvolvimento de software: o texto assume familiaridade com conceitos do dia a dia de quem programa, como APIs, JSON e controle de versão com Git;

Contato prévio com LLMs como usuário: já ter conversado com um ChatGPT, Claude ou similar e saber, na prática, o que essas ferramentas fazem.

Tão importante quanto é o que você não precisa: matemática avançada, Estatística ou experiência com treinamento de modelos. Sempre que um conceito técnico aparece — tokenização, embeddings, atenção, quantização —, ele é construído do zero, com analogias do cotidiano antes do formalismo. Priorizamos sempre o porquê, qual problema prático estamos resolvendo, para só então nos aprofundarmos no como.

Vale dizer também o que este livro não é. Ele não ensina a treinar LLMs do zero nem é um texto de pesquisa em deep learning; e não é um catálogo de prompts prontos, tampouco o manual de um framework específico. Frameworks mudam a cada semestre. O que este livro ensina é o que fica: os fundamentos e as decisões de engenharia por trás de qualquer sistema com LLMs.