Primeiras aulas do curso
Bem-vindas e bem-vindos a outro curso da Alura, no qual vamos trabalhar com o Claude utilizando apenas uma ferramenta como exemplo, para que possamos, de fato, discutir Engenharia de Contexto.
Audiodescrição: Pessoa instrutora aparece em plano médio, com cabelo curto, vestindo camisa lisa, em um estúdio com iluminação uniforme e fundo neutro.
Neste projeto, contamos com nosso assistente de IA. Trabalhamos com um único assistente em Claude Cowork, que vai solucionar todo o trabalho que precisamos realizar no dia a dia, seja código, gestão de pessoas, organização de metas ou registro de iniciativas. Esse assistente tem como objetivo resolver todos os nossos problemas para que possamos trabalhar com mais tranquilidade e eficiência.
Temos um problema: como mantemos um contexto amplo, com uma organização de "pastas" e muitos projetos em paralelo, nosso assistente não está sendo muito útil. Ele se confunde, não sabe exatamente o que deve fazer, entrega respostas sem muito sentido e preenche a janela de contexto muito rápido.
Audiodescrição: Nesta aula, ouvimos apenas a narração da pessoa instrutora, sem imagem em vídeo da pessoa. A tela exibe slides e o ambiente de desenvolvimento, com fundo claro.
A proposta é pegar este projeto, que está desorganizado, e estruturá-lo, além de mapear as estratégias possíveis que podemos aplicar no dia a dia caso também estejamos enfrentando esse tipo de problema com o contexto.
Se nosso assistente não responde como esperamos, se estamos gastando mais tokens (unidades de texto processadas) do que prevíamos e se ele confunde e mistura os temas sobre os quais queremos falar, precisamos entender quais estratégias são possíveis e por que isso ocorre.
Vamos compreender melhor a janela de contexto de que todas as pessoas falam, como ela funciona e como esse conhecimento nos ajudará a definir estratégias e a organizar este projeto para que funcione melhor.
Acompanhe-nos neste curso de Engenharia de Contexto na Alura.
Para iniciar este curso, vamos entender o que é a janela de contexto, frequentemente mencionada quando trabalhamos com LLMs (Large Language Models, Modelos de Linguagem de Grande Porte). Por que essa janela de contexto é tão importante quando falamos de engenharia de contexto? O próprio termo indica que o contexto está contido em uma janela. Precisamos compreender o que é essa janela para, então, entender quais estratégias podemos adotar para gerenciar esse contexto, ou realizar o que muitos chamam de context engineering (engenharia de contexto).
Primeiro, vamos construir uma analogia para pensar sobre a janela de contexto. Imaginemos nossa mesa de trabalho ao lidarmos com processos muito complexos, com diversas documentações e papéis que precisamos ler com atenção para encontrar evidências, como em uma investigação de um caso que seguirá para um júri e para o qual precisamos localizar as provas. Começamos lendo o documento pelo início: pegamos a página 1, depois a página 2, em seguida a página 3 e a página 4, e vamos encontrando nessas páginas as evidências, ou as partes importantes, que destacamos visualmente.
Ao chegar à página 4, ao olharmos para a mesa de trabalho na qual dispomos tudo, percebemos que o espaço está quase no fim. Observamos a pilha de documentos que ainda temos ao lado e notamos que não haverá espaço suficiente para manter todas as páginas abertas simultaneamente e ter uma visão de conjunto, mas seguimos trabalhando.
Quando chegamos à página 24, notamos que as primeiras páginas que estavam em nossa mesa no início — e nas quais havíamos encontrado evidências importantes — já não estão mais ali. Encontramos evidências relevantes nas páginas 20 e 23, mas ainda restam muitas páginas pela frente, e sabemos que há outras evidências espalhadas no meio desse processo. Temos, portanto, uma quantidade de trabalho que não cabe em nossa mesa; não cabe no espaço físico disponível para dispor e organizar tudo ao mesmo tempo.
Essa é a analogia de como podemos pensar a janela de contexto em um LLM (Large Language Model, Modelo de Linguagem de Grande Porte). Conforme o LLM interage conosco, lê os documentos que fornecemos e acompanha a própria conversa que organizamos, chegará um momento equivalente ao da página 24. Estaremos em uma conversa muito longa e extensa com esse assistente, ainda com muitas ações a realizar, mas as primeiras interações que tivemos — que provavelmente contêm informações importantes — já foram “esquecidas”; elas ficaram fora da área de trabalho que o LLM consegue reter como contexto.
Nessa analogia, nossa mesa de trabalho representa a janela de contexto: é a quantidade de memória efetiva que dizemos que os LLMs têm para processar informações. No final, eles não podem processar toda a informação de uma só vez. Embora a janela de contexto atualmente seja bastante ampla, ainda há um limite. Chega um ponto em que ultrapassamos esse limite e fornecemos mais informação do que o LLM consegue acessar naquele momento.
Essa característica é geral e vale para diversos modelos: ChatGPT, Gemini, Claude, Kiwi, entre outros. Em todos os casos, há um limite de janela de contexto — uma quantidade máxima de informação que podemos passar ao modelo, independentemente de onde ele esteja rodando e de qual modelo estejamos usando.
Diante disso, surge o problema: como reter tudo o que lemos nesse “caso”? Como, ao ler as páginas, retirar algumas da mesa, reorganizar o espaço e ainda assim lembrar de tudo no final? No cotidiano, já utilizamos ferramentas para isso: anotar, sublinhar, separar informações em lugares diferentes. Temos, portanto, instrumentos de trabalho para organizar esse tipo de informação.
Além disso, nossa memória, como pessoas, funciona de forma diferente da memória de um computador ou da memória operacional de um LLM. Há diferenças fundamentais; por isso, nenhuma analogia é 100% perfeita. Ainda assim, desenvolvemos estratégias para organizar nosso trabalho e a quantidade de informação que conseguimos reter e estruturar para, depois, lembrar ou dar continuidade ao que estamos fazendo.
Quais são, então, essas estratégias? Como fazemos para que isso funcione? O primeiro passo é entender como vamos organizar nosso próprio trabalho, pois esse entendimento abre caminho para as possíveis soluções relacionadas à janela de contexto. Teremos de organizar também o “trabalho” do LLM, facilitando sua atuação. Conhecendo o sistema e seu funcionamento, podemos elaborar estratégias mais eficazes — e é isso que veremos ao longo deste curso.
É útil trazer essa analogia para nosso contexto, porque também temos um limite. Chega um momento em que começamos a esquecer algumas coisas. Então, que estratégias adotamos para o trabalho quando lidamos com muitos contextos?
Quando atuamos em liderança ou gestão, podemos estar trabalhando em uma campanha de marketing (mercadologia), na qual falamos de público, datas importantes do produto que vamos promover, notas e comentários do serviço que já nos foram repassados para difundir ou mitigar na comunicação, bloqueios de compra quando queremos vender algo, precificação — tudo isso simultaneamente em nossa cabeça. Ao mesmo tempo, podemos estar gerenciando pessoas, porque atuamos como pessoas gestoras: o tamanho da equipe, as questões pessoais de cada pessoa da equipe, a restrição orçamentária, quando alguém solicita um aumento, ou quando temos um projeto que queremos realizar; a necessidade de individualizar essas conversas e problemas, como tratamos cada pessoa da equipe, próximos projetos — e, dentro da empresa, discutindo a estratégia da companhia. Temos stakeholders (partes interessadas), reuniões extensas e diferentes iniciativas que precisamos levar adiante no dia a dia. Tudo isso faz parte do trabalho de uma pessoa gestora, muitas vezes misturado, muitas vezes uma coisa colidindo com a outra, e precisamos de uma estratégia para organizar.
Devemos considerar que o LLM (Modelo de Linguagem Grande) vê tudo isso junto, e precisamos ajudá-lo com estratégias sobre como vamos fornecer a informação.
Por outro lado, quando atuamos na área técnica ou social, como pessoa no time de desenvolvimento que usa o LLM (Modelo de Linguagem Grande) para auxiliar no desenvolvimento de uma aplicação com código, precisamos aprimorar a eficiência da debug (depuração) do sistema: analisar o log (registro), o stack trace (rastreamento de pilha) e o número de linha de cada classe, porque, como pessoas desenvolvedoras, já sabemos que trabalhar com uma classe de 3.000 linhas não é confortável. Se para nós isso não é confortável, por que seria melhor para o LLM (Modelo de Linguagem Grande)?
A divisão de responsabilidades dentro do nosso código, a organização dos módulos — ou o fato de estar tudo dentro de um módulo grande com muitas dependências — são aspectos cruciais. O princípio DRY (don't repeat yourself — não se repita) e os princípios SOLID (conjunto de boas práticas de projeto orientado a objetos) são técnicas que já utilizamos para trabalhar com código e que podem orientar o LLM (Modelo de Linguagem Grande) a manipular um sistema seguindo práticas que conhecemos.
Se para o código já temos estratégias que facilitam a forma como interagimos com o código, ou interagimos com o contexto de gestão mencionado anteriormente, por que não aplicar algumas dessas estratégias também ao LLM (Modelo de Linguagem Grande)? Por que obrigá-lo a criar classes com 5.000 linhas, se para nós isso é prejudicial? Se depois tivermos de intervir, será incômodo. Precisamos que escreva um código mais fácil de ler, que tenda a ser mais modularizado e menor, porque também queremos recordar o que está acontecendo naquele código. Se algo nos facilita, não facilitará também ao LLM (Modelo de Linguagem Grande)?
Esse paralelo tem limites: há aspectos que nos facilitam e que não necessariamente facilitarão o LLM (Modelo de Linguagem Grande), e o inverso também é verdadeiro. Ainda assim, é um primeiro passo para refletirmos quando estamos nesse contexto técnico usando LLMs (Modelos de Linguagem Grande).
Em outro cenário, quando há um erro em produção, teremos novamente uma lista de logs (registros), muitas vezes um log gigantesco com milhões de linhas. Se passarmos tudo de uma vez para o LLM (Modelo de Linguagem Grande) processar, será que conseguirá processar tudo? Realmente tudo o que está no log é relevante para resolver o erro em produção? Não. Filtramos o que pode ser relevante, reduzimos a quantidade de itens a analisar e então realizamos uma análise mais focada.
Essas estratégias já fazem parte do nosso dia a dia. Ao longo deste curso, no qual apresentaremos quatro estratégias que irão ajudar, queremos que também pensemos no nosso cotidiano: como organizamos nosso trabalho? Há muitas práticas que já podemos aproveitar para auxiliar nessa engenharia de contexto.
É tentador termos uma ferramenta nova — hoje nem tão nova, pois muitas empresas já a utilizam — e simplesmente abusarmos dela: despejar tudo em um único assistente LLM (Modelo de Linguagem Grande), esperando que faça todo o projeto e que nunca precisemos organizar nada. Sabemos que não é assim, porque conhecemos os problemas que isso causa.
Quando começamos a liderar a engenharia de contexto e lidamos com informação em excesso, surgem problemas de alucinação, confusão, mudança de contexto, mistura nas respostas e respostas que não são exatamente o que queremos. Esses problemas acontecerão.
Voltemos à pergunta: quais são as ferramentas que temos no nosso trabalho, no dia a dia — seja em liderança, análise, trabalho técnico ou de marketing (mercadologia) — para organizar o trabalho? Quais estratégias utilizamos para manter tudo em ordem, ter uma visão do conjunto e dos vários projetos que estamos conduzindo?
Sabemos também que, hoje, mesmo atuando como pessoa analista individual, dificilmente estamos em apenas um projeto, executando uma tarefa por vez. Normalmente temos pelo menos dois ou três projetos em paralelo; enquanto um está parado, avançamos em outro, e então a liderança nos atribui mais um, porque é urgente. Portanto, já possuímos mecanismos naturais de organização. Quais são? Como os utilizamos?
Com isso em mente, vamos entender, na prática, como funciona essa janela de contexto. Apresentamos uma analogia; agora veremos como funciona na prática.
Já entendemos por que a janela de contexto é importante, como ela funciona de forma geral e quais paralelos podemos traçar com nosso dia a dia. Agora, vamos aprofundar nos problemas e no funcionamento prático dessa janela de contexto quando interagimos com os LLMs (Modelos de Linguagem Grande).
O termo original em inglês é context window (janela de contexto). Em essência, lidamos com interações sucessivas. Utilizamos o mesmo modelo e, em analogia, lemos a primeira e a segunda páginas de um caso que estamos investigando, depois a terceira e a quarta, e assim por diante, até chegarmos, por exemplo, à vigésima terceira página, momento em que precisamos manter a organização. No diagrama anterior, posicionamos o espaço entre duas barras como sendo nossa mesa, nossa área de trabalho. Aqui, o raciocínio é o mesmo: esse espaço continua sendo a área de trabalho do LLM (Modelo de Linguagem Grande), nosso assistente de IA que processa e se comunica conosco. A diferença é que, enquanto a mesa de trabalho é um espaço físico medido em centímetros ou metros, a medida aqui são os tokens (unidades de subpalavra).
Nos modelos mais atuais, tomando o Claude (modelo da Anthropic (empresa)) como referência, o limite da janela de contexto é de 200 mil tokens. Esse é o tamanho da janela que conseguimos usar. Um token é um pouco menos do que uma palavra inteira, pois, ao contar tokens, considera-se a segmentação semântica, e não necessariamente a palavra completa. Existem estimativas para aproximar esse valor, mas podemos pensar que um token se aproxima de uma palavra. Assim, conseguimos enviar aproximadamente um texto de 200 mil palavras para o LLM até o modelo começar a perder informações do início do histórico.
Iniciamos a interação com um primeiro prompt (instrução). Enviamos a primeira mensagem e obtemos uma resposta. Por exemplo, perguntamos quais são as prioridades para o dia, considerando que o assistente já tem um contexto anterior de uso. Ele responde: informa que hoje há uma reunião, identifica na agenda o horário correspondente, sugere a pauta provável, menciona um projeto em andamento, outro projeto que depende de uma decisão nossa e indica que uma pessoa da equipe deseja conversar sobre determinado assunto.
Em seguida, fazemos uma segunda interação: solicitamos que seja detalhada a pauta dessa reunião e que seja fornecido um histórico do que ocorreu anteriormente. Ao fazermos essa solicitação na segunda interação, o LLM possui a primeira interação e recebe a nova (representada em verde no diagrama), e então retorna uma resposta. Todo esse histórico compõe a janela de contexto: é a parte que ocupa a “memória” de trabalho do LLM, isto é, o texto que ele precisa processar para responder.
É importante destacar que, embora falemos em “memória do LLM”, na prática, nessa interação, não há uma memória persistente separada no lado do servidor. No caso do Claude, toda vez que criamos uma nova interação — por exemplo, após a primeira resposta com o resumo do dia, pedimos ajuda para definir melhor a pauta da reunião —, precisamos enviar toda a conversa anterior na chamada da API (Interface de Programação de Aplicações). O cliente sempre envia todo o histórico da conversa na chamada da API, porque o lado do servidor, onde o LLM está, não armazena o histórico. O histórico permanece no nosso computador. Portanto, em cada chamada, enviamos a primeira pergunta, a resposta do LLM e a nova pergunta, tudo junto, para o LLM processar e, então, devolver a resposta. É por isso que nos referimos a esse conteúdo enviado como a janela de contexto que estamos usando naquele momento.
Prosseguindo com as interações, o assistente ajuda a elaborar a pauta, fornece histórico, comenta sobre a pessoa envolvida e sobre os temas pertinentes, e seguimos iterando. Chega um momento em que ocupamos toda a capacidade disponível. Quando isso ocorre, algumas mensagens do histórico precisam ser excluídas. Se a primeira mensagem for aquela que descreve a reunião e define a pauta, e continuarmos falando da mesma reunião, enviando ao final algo como “ajude a priorizar estas entregas”, mas as mensagens iniciais tiverem sido descartadas, o modelo não terá o contexto necessário para responder adequadamente.
Esse é o problema quando lotamos a janela de contexto. Em determinado ponto, algumas mensagens — frequentemente as primeiras, embora não necessariamente — começam a ser removidas, pois é preciso fazer toda a conversa caber no espaço disponível, e esse espaço não pode ser aumentado arbitrariamente. Nesse processo, o LLM pode começar a confundir tópicos, perder a linha do raciocínio, responder coisas sem sentido ou “inventar” detalhes, porque já não possui exatamente as informações necessárias, mas ainda precisa fornecer uma resposta.
Conforme as conversas se alongam, aumenta a chance de o LLM confundir e atravessar contextos. Por exemplo, estamos tratando de uma reunião e, em seguida, mencionamos uma pessoa que deseja conversar sobre outro assunto; portanto, temos duas reuniões diferentes na mesma conversa. O modelo pode cruzar esses contextos, pois não consegue separá-los perfeitamente. Isso prejudica a qualidade das respostas e, em alguns momentos, produz saídas sem sentido.
Além disso, o contexto não é priorizado de forma uniforme. Embora possamos supor que as primeiras mensagens são sempre as descartadas, não é exatamente assim. As mensagens iniciais geralmente carregam um contexto muito importante, pois definem o tópico geral da conversa. No exemplo mencionado, primeiro solicitamos um resumo do dia e, depois, focamos em uma reunião específica com a direção naquele momento.
Quando pensamos em como o modelo vai priorizar, ele não prioriza necessariamente apenas as últimas mensagens. Ele não vai pegar somente o histórico e priorizar as últimas mensagens; também prioriza as primeiras. Se temos no eixo X a linha do tempo — quanto mais à direita, mais recente é a mensagem — e no eixo Y a prioridade — quanto mais alto, mais prioritária é —, o padrão tende a seguir um formato no qual as primeiras mensagens são priorizadas. O modelo tenta mantê-las dentro da janela de contexto. As mensagens do meio — aquele conjunto com o qual estamos trabalhando, ajustando e conversando para melhorar uma resposta — tendem a ser menos priorizadas. Essas são as mensagens que o modelo pode descartar. “Jogar fora” não é exatamente o que ele faz em todos os casos; pode ocorrer, mas não é a única estratégia. As mensagens mais recentes recebem peso maior, pois estamos tratando delas no momento e a resposta depende desse trecho da conversa.
Desse modo, identificamos três momentos: o início da conversa — que inclui os prompts(instruções) de sistema e as primeiras mensagens —, que ficam prioritados; as últimas mensagens enviadas, também com prioridade alta; e tudo o que está no meio, com prioridade baixa, podendo ser ignorado. Se for necessário liberar espaço na janela de contexto, especialmente ao exceder cerca de 200 mil tokens (no caso do Claude; cada modelo tem um tamanho de janela diferente), é o meio da conversa que o modelo começa a trabalhar e retirar da memória. Isso pode causar confusão e é um dos problemas conhecidos como lost in the middle(perda no meio): tudo que está no miolo da conversa se perde.
Assim, precisamos cuidar do tamanho da conversa e de como vamos conduzindo o fluxo. Uma estratégia simples é abrir novas sessões para tratar de assuntos diferentes.
Nossa interação — o que escrevemos como prompt(instrução) — não é a única coisa que ocupa a janela de contexto desde o início. Na primeira interação, a janela não está vazia. Temos nossa solicitação — por exemplo: “Dê um resumo do dia de hoje, como vamos fazer, o que precisamos fazer” —, mas, para responder, o modelo precisa saber quais são as skills(habilidades). Existe alguma skill(habilidade) associada à pergunta? Se sim, ela precisa ser carregada. Há algum MCP do nosso calendário? Se o modelo sabe da reunião, é porque acessou o MCP do calendário, obteve as informações e trouxe o contexto correspondente. Existe ainda o prompt(instrução) de sistema — por exemplo: “Queremos que você seja um assistente que ajude no dia a dia, de maneira formal, respondendo sempre diretamente” —, que configura o comportamento do modelo. Há também os próprios arquivos: se informamos que temos uma reunião sobre a pauta X, o arquivo dessa pauta X precisa ser lido em algum lugar. Além disso, há a memória, que pode estar em um arquivo que escrevemos ou em um arquivo interno que não vemos. Tudo isso compõe o contexto inicial de uma conversa.
Dependendo de como organizamos esses processos — skills(habilidades), MCPs, prompts(instruções) de sistema e arquivos de memória —, podemos começar uma janela nominalmente de 200 mil tokens com, na prática, um espaço muito reduzido para a nossa interação corrente. Isso é algo com o qual precisamos tomar cuidado.
Retomando os conceitos: o MCP basicamente é o conjunto de conectores com outras ferramentas, com nome da ferramenta, descrição (quando usar), quando o LLM(modelo de linguagem) deve utilizá-la, e o esquema que descreve as operações possíveis — por exemplo, no conector do calendário: marcar, alterar, aceitar reunião ou ler o calendário. Esses detalhes entram como esquemas e parâmetros. Há também notas e exemplos de como o LLM(modelo de linguagem) deve enviar as chamadas das ferramentas específicas — por exemplo: “Queremos marcar uma reunião no calendário com três pessoas” —, definindo o formato correto da chamada. O MCP funciona como uma documentação para o LLM(modelo de linguagem) ler e, então, fazer a chamada adequadamente.
As skills(habilidades) compõem uma parte mais recente do ecossistema — inclusive com Cowork e outras ferramentas. Quando uma skill(habilidade) está “fora de uso”, a janela de contexto mantém apenas o nome e a descrição. Quando o modelo resolve usá-la, precisa trazer o restante do arquivo da skill(habilidade) para a janela de contexto, pois esse arquivo delimita o processo a executar. Só então o modelo executa o processo. Esse arquivo, como um todo, precisa vir para a conversa para ser enviado ao servidor do LLM(modelo de linguagem) e prover o contexto necessário. Considerando que essa skill(habilidade) está em nosso computador inicialmente — e que, na maioria das conversas, o modelo (como OpenAI, Gemini ou Claude) está na nuvem, em um servidor, não em nossa máquina —, é preciso enviar a skill(habilidade) por uma chamada de API para o servidor ter acesso a ela. Portanto, o arquivo completo precisa ser carregado para o servidor.
Esse é, de maneira abrangente, o funcionamento da janela de contexto. A partir disso, podemos adotar estratégias para mitigar a ocupação de espaço:
Em seguida, veremos cada estratégia em detalhe e como aplicá-la no dia a dia de um projeto. Neste curso, vamos usar o Claude como exemplo, mas as mesmas ideias valem para OpenAI, Claude, Gemini ou qualquer outro modelo. Não devemos nos limitar à ferramenta apresentada.
O curso Context Engineering: otimização da janela de contexto de IAs possui 150 minutos de vídeos, em um total de 37 atividades. Gostou? Conheça nossos outros cursos de IA para Produto & Negócio em Inteligência Artificial, ou leia nossos artigos de Inteligência Artificial.
Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:
Todos os cursos, trilhas e certificados para evoluir.
7 dias para cancelar com reembolso
Aprenda mais rápido com IA, idiomas e imersões.
7 dias para cancelar com reembolso
TUDO DO PLUS, MAIS:
Aceleração de carreira: mentoria, vagas e prática guiada.
7 dias para cancelar com reembolso
TUDO DO PRO, MAIS:
