Trilha de AI Engineer: o mapa das fases

Esta nota é o mapa da trilha completa de aulas para quem quer chegar ao nível de AI Engineer descrito em Curriculo de um AI Engineer. Ela continua a Trilha de RAG, que já cobre o pilar de recuperação e a primeira metade da avaliação. As fases abaixo cobrem o que falta, na ordem de estudo: primeiro como falar com o modelo de forma previsível, depois como programar chamadas lentas e falíveis sem derrubar o sistema, depois agentes e MCP, que dependem das duas coisas anteriores, e por fim avaliação e inferência.

A ordem segue um critério simples: cada fase usa só o que as anteriores ensinaram. Agentes, por exemplo, são um laço de chamadas ao modelo com ferramentas, e esse laço fica frágil sem saída estruturada e sem controle de concorrência. Avaliação de agentes vem depois dos agentes porque só então existe algo para medir. A Avaliação de RAG deixou a camada de geração sem número medido, e a fase 5 é onde essa dívida é paga.

As aulas seguem o padrão da trilha de RAG: parágrafos corridos, código executado por mim com a saída colada, figuras animadas do ArchFlow e uma seção que declara o que não foi medido. Nenhuma aula desta trilha foi escrita ainda. Este mapa é o plano, e cada fase vira uma pasta própria em Tecnologia/AI/, como a de RAG.

Mapa da trilha

Fase	Tema	Aulas	Pilar do currículo	Entrega prática
1	Saídas estruturadas e engenharia de contexto	5	2	Validador de JSON Schema com Pydantic e reparo automático
2	Agentes e tool use	7	4	Agente em grafo com ferramentas, memória e limites de passos
3	MCP, o protocolo de ferramentas	4	4	Servidor MCP e cliente que o consome
4	Avaliação e observabilidade de agentes	6	5	Harness de regressão em CI para agentes, com tracing
5	Python assíncrono e streaming	8	1	Proxy de inferência com streaming SSE e controle de taxa
6	Inferência e fine-tuning	6	6	Servidor de modelo aberto e um ajuste com LoRA

Fase 1: saídas estruturadas e engenharia de contexto

Pergunta central: como obter do modelo uma resposta que o programa consegue ler sem adivinhar? É a base de tudo o que vem depois, porque ferramentas e agentes só funcionam se a saída do modelo for previsível.

Aula	Pergunta que responde
1.1 Chamando um modelo pela API	Quais são as mensagens, os parâmetros e os custos de uma chamada, e o que são tempo até o primeiro token e vazão?
1.2 Saídas estruturadas	Como pedir JSON e como a decodificação restrita garante que ele obedeça a um esquema?
1.3 Validação com Pydantic	Como validar o que o modelo devolve e o que fazer quando a validação falha?
1.4 Reparo e repetição	Quando vale reenviar o erro ao modelo, quantas vezes, e qual o custo disso?
1.5 Engenharia de contexto	Como organizar instruções, exemplos e histórico dentro de um orçamento de tokens?

Fase 2: agentes e tool use

Pergunta central: como deixar o modelo decidir quais ferramentas chamar, sem perder o controle do que acontece? Esta fase se apoia em Agents, que já existe como nota avulsa e será o ponto de partida.

Aula	Pergunta que responde
2.1 O laço do agente	O que é o ciclo pensar, agir e observar, e quando um workflow fixo é melhor que um agente?
2.2 Chamada de ferramentas	Como descrever uma ferramenta, como o modelo a escolhe e como tratar erros dela?
2.3 Máquinas de estado e grafos	Como representar o fluxo como um grafo com estado explícito em vez de um laço solto?
2.4 Limites e tolerância a falhas	Como impedir laços infinitos, estouro de custo e ações irreversíveis?
2.5 Memória	O que lembrar entre passos e entre conversas, e como não estourar o contexto?
2.6 Vários agentes	Quando separar em mais de um agente ajuda e quando só aumenta a confusão?
2.7 Segurança de agentes	O que é prompt injection por ferramenta e como limitar o estrago?

Fase 3: MCP, o protocolo de ferramentas

Pergunta central: como expor ferramentas e dados para qualquer agente sem reescrever a integração a cada vez? Parte da nota MCP.

Aula	Pergunta que responde
3.1 O protocolo	Que problema o MCP resolve e como são clientes, servidores, ferramentas, recursos e prompts?
3.2 Escrevendo um servidor	Como expor uma ferramenta e um recurso e testar o servidor sozinho?
3.3 Escrevendo um cliente	Como um agente descobre e chama as ferramentas de um servidor?
3.4 Autorização e segurança	Como autenticar, limitar permissões e confiar em servidores de terceiros?

Fase 4: avaliação e observabilidade de agentes

Pergunta central: como saber se um agente está bom e se uma mudança o piorou? Retoma a Avaliação de RAG e mede o que lá ficou só descrito.

Aula	Pergunta que responde
4.1 O que medir em um agente	Como separar acerto da resposta, da trajetória e do custo?
4.2 Conjuntos de teste para agentes	Como montar casos com ferramentas simuladas e resultado verificável?
4.3 LLM como juiz, medido	Qual a concordância real de um juiz com rótulos humanos, medida com kappa?
4.4 Fidelidade e citações	Como medir de verdade a camada de geração do RAG?
4.5 Tracing e custo	Como registrar cada passo, o tempo e o custo por requisição?
4.6 Regressão em CI	Como travar uma mudança que piora uma categoria de casos?

Fase 5: Python assíncrono e streaming

Pergunta central: como programar chamadas lentas, caras e instáveis sem bloquear nem derrubar o serviço? Esta fase é a que mais pesa em entrevistas, segundo o currículo, e se liga ao vault de Go, onde a nota de Channels mostra o mesmo problema de concorrência por outra linguagem.

Aula	Pergunta que responde
5.1 O laço de eventos	O que é concorrência cooperativa e por que uma chamada a um modelo não deve bloquear o processo?
5.2 Tarefas e TaskGroup	Como disparar várias chamadas ao mesmo tempo e juntar os resultados com segurança?
5.3 Timeout e cancelamento	Como impor prazos e cancelar trabalho sem deixar lixo para trás?
5.4 Clientes HTTP assíncronos	Como usar `httpx` com pools de conexão e quais armadilhas evitar?
5.5 Retentativa e disjuntor	Como fazer backoff exponencial e quando abrir um circuit breaker?
5.6 Controle de taxa	Como respeitar cotas de requisições e de tokens com semáforos e token bucket?
5.7 Streaming com SSE	Como entregar tokens ao cliente em tempo real com FastAPI?
5.8 Testes assíncronos	Como testar tudo isso sem chamar APIs reais?

Fase 6: inferência e fine-tuning

Pergunta central: quando vale rodar um modelo aberto por conta própria e como ajustá-lo? É a fase menos urgente para quem consome APIs, e por isso fica por último.

Aula	Pergunta que responde
6.1 Modelos abertos e fechados	Quais são os trade-offs de custo, privacidade e qualidade na escolha?
6.2 Como a inferência funciona	O que são cache de chaves e valores, lotes contínuos e por que a memória limita a vazão?
6.3 Servindo com vLLM	Como subir e medir um servidor de inferência?
6.4 Quantização	O que se perde em qualidade ao reduzir a precisão dos pesos, medido em um caso real?
6.5 Ajuste fino com LoRA	Quando ajustar em vez de melhorar o prompt ou o RAG, e como treinar com pouca memória?
6.6 Alinhamento e avaliação do ajuste	Como saber se o modelo ajustado ficou melhor e não apenas diferente?

Como as peças se encaixam

A fase 1 dá previsibilidade à saída do modelo. A fase 2 usa essa saída para decidir ações, e a fase 3 padroniza como as ferramentas dessas ações são oferecidas. A fase 4 mede o conjunto e fecha o ciclo aberto na Avaliação de RAG. A fase 5 é a engenharia que sustenta tudo em produção, e as aulas 5.5 e 5.6 voltam a aparecer, como aplicação, nos limites de custo da aula 2.4. Se o seu objetivo imediato for async, a fase 5 não depende das anteriores e pode ser estudada primeiro: ela só precisa de Python e de uma API de modelo qualquer.

Neste texto