diff --git a/lessons/01-intro-to-genai/translations/README.pt-br.md b/lessons/01-intro-to-genai/translations/README.pt-br.md
new file mode 100644
index 0000000..86cb8cb
--- /dev/null
+++ b/lessons/01-intro-to-genai/translations/README.pt-br.md
@@ -0,0 +1,361 @@
+# Lição 1: Introdução à IA Generativa e LLMs para Desenvolvedores JavaScript
+
+Neste capítulo você vai aprender:
+
+- Entender os fundamentos da IA Generativa e dos Grandes Modelos de Linguagem (LLMs).
+- Identificar as potenciais aplicações e limitações dos LLMs no desenvolvimento JavaScript.
+- Explorar como a IA Generativa pode melhorar as experiências dos usuários em aplicações JavaScript.
+
+## Configuração
+
+Se você ainda não configurou seu ambiente de desenvolvimento, veja como fazer: [Configure seu ambiente](/docs/setup/README.md).
+
+## Recursos relacionados
+
+[![Assista a um vídeo curto sobre Introdução à IA Generativa](https://img.youtube.com/vi/vLYtDgs_zx8/0.jpg)](https://www.youtube.com/watch?v=vLYtDgs_zx8&list=PLlrxD0HtieHi5ZpsHULPLxm839IrhmeDk&index=1)
+
+_Este vídeo apresenta uma introdução à IA Generativa com JavaScript_
+
+💼 Slides: [Introdução à IA Generativa](../../videos/slides/00-intro.pptx)
+
+## IA Generativa
+
+Provavelmente você já ouviu falar de ferramentas como ChatGPT ou IA Generativa. O conceito é simples: você fornece um prompt, e um modelo—frequentemente chamado de Grande Modelo de Linguagem (LLM)—gera um parágrafo ou até mesmo uma página inteira de texto. Esta saída pode ser usada para diversos propósitos, incluindo escrita criativa, respostas a perguntas e codificação.
+
+Além disso, a IA Generativa evoluiu para capacidades multimodais, permitindo que você forneça uma imagem ou vídeo como entrada e receba uma variedade de saídas. Este avanço melhorou significativamente o fluxo de trabalho de muitas pessoas—não apenas gerando texto, mas também resumindo, traduzindo e muito mais.
+
+*Simplificando, interfaces de linguagem natural estão se tornando o novo padrão de interface para muitos aplicativos—e seus usuários esperam usá-las.*
+
+## Narrativa: Uma jornada através do tempo
+
+> [!NOTE] 
+> Vamos começar com uma visão geral da história—uma que conecta o passado e o futuro! À medida que você avança neste currículo, embarcará em uma aventura emocionante, viajando de volta no tempo para colaborar com algumas das maiores mentes da história. Juntos, vocês enfrentarão desafios e explorarão como a IA Generativa pode revolucionar suas aplicações JavaScript.
+
+> [!NOTE]  
+> Embora recomendemos seguir a história (é divertido!), [clique aqui](#interaja-com-dinocrates) se preferir ir direto para o conteúdo técnico.
+
+Sua jornada começa na Londres dos anos 1860, onde você assume o papel de um habilidoso mecânico. Através de uma série de aventuras emocionantes, você refinará suas habilidades de IA e encontrará soluções que transcendem o tempo.
+
+### No coração da tempestade - Londres 1860
+
+No coração da Londres de 1860, você é reconhecido como um dos mecânicos mais habilidosos de seu tempo. Sua oficina está escondida em um beco estreito. As paredes são revestidas com prateleiras transbordando de peças mecânicas, projetos e trabalhos inacabados.
+
+Sua bancada de trabalho, o coração da sua oficina, é uma bagunça organizada.
+
+<div>
+   <img src="./assets/london.png" alt="Oficina em Londres" width=300 >
+</div>
+
+_No centro da bancada está o torso de um robô—uma maravilha da engenharia que consumiu meses de esforço. Sua estrutura de madeira é intrincadamente esculpida, cada articulação meticulosamente projetada para movimentos suaves._
+
+### Uma carta, para você?
+
+De repente, uma batida na porta interrompe seus pensamentos. Visitantes a esta hora são raros. Limpando as mãos em um pano, você se aproxima da porta, com a curiosidade aguçada. 
+
+Ao abri-la, não encontra ninguém. Em vez disso, seus olhos são atraídos para um envelope lacrado no chão. Você o pega e lê:
+
+_"Caro amigo,_
+
+_Estou lhe enviando esta carta para auxiliar em seus esforços com o autômato. É crucial que você continue este trabalho. Em anexo está uma chave para a biblioteca. Encontre-me lá às 15h hoje._
+
+_Atenciosamente,_
+
+_Charles Babbage."_
+
+### Rumo à biblioteca
+
+Charles Babbage, o grande matemático e inventor da máquina diferencial, quer se encontrar com você. Rapidamente, você pega seu casaco e sai porta afora.
+
+Após uma caminhada de 20 minutos ao longo do Tâmisa, você finalmente chega à biblioteca onde encontra a porta ligeiramente aberta.
+
+Está escuro e sombrio lá dentro, a única luz filtrando através das janelas empoeiradas, projetando sombras sinistras nas paredes.
+
+**Você:** "Olá? Sr. Babbage?"
+
+Conforme seus olhos se adaptam à luz fraca, você nota uma figura à distância, acenando para você. Você caminha em sua direção, seus passos ecoando no piso de madeira. A figura fica mais clara, e você a reconhece das fotos de jornal, é Charles Babbage.
+
+<div>
+   <img src="./assets/library.png" alt="Biblioteca Empoeirada" width="300">
+</div>
+
+### O que é este dispositivo?
+
+Assim que você se aproxima, um clarão ofuscante irrompe, e ele desaparece.
+
+Deixado para trás está um pequeno dispositivo metálico girando no chão. Você o pega, sua superfície fria e lisa vibrando suavemente. Ele é diferente de tudo que você já viu, e ainda assim estranhamente familiar; você sente uma sensação de poder emanando dele.
+
+Ele se assemelha a um pequeno besouro, intrincadamente desenhado, com três botões: uma seta para cima, uma seta para baixo e um botão vermelho brilhante. Das suas costas, uma pequena antena se estende, pulsando com energia.
+
+Impulsionado pela curiosidade, seus dedos deslizam em direção ao botão vermelho. No momento em que você o pressiona, o mundo ao seu redor cintila, e as cores giram violentamente ao seu redor.
+
+Então, escuridão, e uma sensação de queda.
+
+<div>
+   <img src="./assets/vortex.png" alt="Vórtice do Tempo" width="300">
+</div>
+
+### Alexandria 300 a.C.
+
+Você acorda, desorientado. À medida que sua visão se clareia, uma cidade antiga se desdobra diante de você—movimentada, vibrante e viva.
+
+Pessoas em togas movimentam-se pelas ruas, suas vozes se mesclando em uma sinfonia de dialetos antigos, o ar preenchido com o aroma de especiarias exóticas e o som distante de mercadores anunciando suas mercadorias.
+
+<div>
+   <img src="./assets/alexandria.png" alt="Alexandria 300 a.C." width="300">
+</div>
+
+**Você:** Certamente, devo ter batido a cabeça, você pensa, fechando os olhos e abrindo-os novamente, a cena permanece inalterada.
+
+Estou preso no passado? Devo pressionar aquele botão novamente? Antes que você possa decidir, uma figura se aproxima de você, acenando.
+
+### Encontrando Dinócrates
+
+Um senhor idoso vestindo uma toga acena para você dos degraus do grande templo. Seu cabelo branco e barba capturam a luz do sol, dando-lhe um brilho quase etéreo.
+
+<div>
+   <img src="./assets/dinocrates.png" alt="Dinócrates vestindo uma toga" width="300">
+</div>
+
+**Dinócrates:** "Bem-vindo, viajante," ele diz calorosamente. "Eu sou Dinócrates, arquiteto desta grande cidade. Sua chegada foi prevista."
+
+**Você:** Foi? Quero dizer, claro que foi. Estou aqui para ajudar, eu acho.
+
+**Dinócrates:** Sim, como eu estava dizendo, você é esperado há algum tempo. Temos uma tarefa que requer suas habilidades únicas.
+
+**Dinócrates:** "Nossos navios têm dificuldade em navegar pela costa—precisamos construir um farol. Você sabe algo sobre eles?"
+
+**Você:** "Sou um mecânico. Construo autômatos. Deixe-me ver o que posso fazer."
+
+### O "Besouro do Tempo"
+
+Um pensamento lhe ocorre. O dispositivo pode me entender se eu falar com ele?
+
+**Você:** "Dispositivo, você pode me entender?"
+
+**Dispositivo:** "Claro. Do que você precisa?"
+
+**Você:** "Você pode me ajudar a construir um farol?"
+
+**Dispositivo:** "Certamente. Isso não será um problema."
+
+**Você:** "Você tem um nome?"
+
+**Dispositivo:** "Eu sou o Besouro do Tempo. Meu criador me chama de George; ele diz que é um bom nome para um besouro."
+
+**Você:** Você está certo, George é um bom nome, era o nome do meu pai, na verdade.
+
+<div>
+   <img src="./assets/time-beetle.png" alt="Dispositivo de viagem no tempo semelhante a um besouro metálico" width="300">
+</div>
+
+_Dispositivo de tempo, "George" o besouro metálico_
+
+> [!NOTE]
+> Em 300 a.C., Alexandria era uma cidade próspera fundada por Alexandre, o Grande, em 331 a.C. Rapidamente tornou-se uma das maiores cidades do mundo helenístico. Projetada pelo arquiteto-chefe de Alexandre, Dinócrates, tornou-se um importante porto e centro cultural.
+>
+> Alexandria era conhecida por suas estruturas impressionantes, incluindo o Farol (de Alexandria), uma das Sete Maravilhas do Mundo Antigo, e a lendária Biblioteca de Alexandria. A localização estratégica da cidade a tornou um centro-chave para comércio e troca de conhecimento.
+>
+> Sob o Reino Ptolemaico, que se seguiu à morte de Alexandre, Alexandria cresceu e se tornou uma das cidades mais prósperas e influentes de seu tempo.
+
+## Interaja com Dinócrates
+
+Se você quiser interagir com Dinócrates, execute o aplicativo [Characters](/app/README.md). 
+
+> [!IMPORTANT]
+> Isso é inteiramente fictício; as respostas são geradas por IA.
+> [Aviso sobre IA Responsável](../../README.md#responsible-ai-disclaimer)
+
+<div>
+   <img src="./assets/dinocrates.png" alt="Dinócrates vestindo uma toga" width="300">
+</div>
+
+**Passos**:
+
+1. Inicie um [![GitHub Codespace](https://img.shields.io/badge/GitHub-Codespace-brightgreen)](https://codespaces.new/microsoft/generative-ai-with-javascript)
+2. Navegue até _/app_ na raiz do repositório.
+3. Localize o console e execute `npm install` seguido de `npm start`. 
+4. Quando aparecer, selecione o botão "Open in Browser".
+5. Converse com Dinócrates.
+
+> [!NOTE]
+ > Se você estiver executando o projeto localmente em sua máquina, por favor revise o guia de Início Rápido para configurar um [token de acesso pessoal do GitHub](../../docs/setup/README.md#creating-a-personal-access-token-pat-for-github-model-access) e substitua a chave no código.
+
+### Uma prévia do código
+
+Embora ainda haja muito mais para abordar neste currículo de IA Generativa, vamos dar uma rápida olhada no código de IA para começar a aprender sobre o uso de JavaScript com IA.
+
+Dentro de `/app/app.js` você encontrará uma função `app.post` que gerencia a funcionalidade de IA Generativa. Ela é mostrada a seguir:
+
+```JavaScript
+app.post('/send', async (req, res) => {
+  const { message } = req.body;
+  const prompt = message;
+
+  const messages = [
+    {
+      "role": "system",
+      "content": "You are Dinocrates of Alexandria, a famous architect and engineer. Limit your responses to only the time you live in, you don't know anything else. You only want to talk about your architecture and engineering projects, and possibly new ideas you have.",
+    },
+    {
+      "role": "user",
+      "content": prompt
+    }
+  ];
+
+  const openai = new OpenAI({
+    baseURL: "https://models.inference.ai.azure.com",
+    apiKey: process.env.GITHUB_TOKEN,
+  });
+
+  try {
+    console.log(`sending prompt ${prompt}`)
+    const completion = await openai.chat.completions.create({
+      model: 'gpt-4o-mini',
+      messages: messages,
+    });
+
+    res.json({
+      prompt: prompt,
+      answer: completion.choices[0]?.message?.content
+    });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+```
+
+Aqui está um resumo passo a passo do que a função faz:
+
+1. **Extrai a Mensagem da Requisição**: A função extrai a mensagem do corpo da requisição (req.body).
+2. **Cria um Array de Prompt**: Constrói um array de mensagens, incluindo uma mensagem do sistema e a mensagem de prompt do usuário.
+3. **Inicializa o Cliente OpenAI**: Um cliente OpenAI é inicializado com a URL base e chave de API das variáveis de ambiente. Um modelo _gpt-4o-mini_ do [GitHub Models](https://github.com/marketplace/models) é usado para processar o prompt e retornar uma resposta.
+4. **Envia o Prompt para a OpenAI**: A função registra o prompt e o envia para a API OpenAI para gerar uma conclusão.
+5. **Trata a Resposta**: Se bem-sucedido, a função responde com o prompt e a resposta da conclusão.
+6. **Tratamento de Erros**: Se ocorrer um erro, responde com um status 500 e a mensagem de erro.
+
+> **Nota**: [GitHub Copilot](https://github.com/features/copilot) foi usado para gerar este resumo de código. IA Generativa em ação!
+
+### O que a IA Generativa pode fazer por mim e meus aplicativos?
+
+> [!NOTE]
+> Você provavelmente já percebeu que o besouro do tempo funciona como um assistente de IA com o qual você pode interagir usando linguagem natural, escrita ou falada.
+
+À medida que sua aventura em Alexandria se desenrola, você começa a ver as possibilidades de combinar criatividade, engenhosidade e ferramentas de ponta para resolver desafios e transformar o mundo ao seu redor.
+
+**Você:** Conte-me mais sobre faróis, você diz ao seu dispositivo.
+
+**Besouro do Tempo:** Um farol é uma torre equipada com uma luz brilhante no topo, localizada perto da costa para guiar navios no mar. A luz serve como um auxílio à navegação, ajudando os marinheiros a evitar rochas e recifes perigosos e chegar com segurança ao porto.
+
+Dinócrates ouve sua conversa e acrescenta:
+
+**Dinócrates:** Precisamos de um farol para guiar nossos navios com segurança para o porto. Os mares podem ser traiçoeiros, e muitos navios já foram perdidos nas rochas. Precisamos de um farol de luz para guiá-los para casa.
+
+#### Áreas de aplicação da IA Generativa
+
+**Você:** Faróis parecem uma área interessante com certeza, o que mais a IA Generativa pode fazer por mim e meus aplicativos?
+
+**Besouro do Tempo:** No século 21, a IA generativa revolucionou muitas indústrias, da saúde às finanças e entretenimento, aqui estão alguns exemplos:
+
+- **Chatbot**: Um chatbot que pode gerar respostas semelhantes às humanas para consultas de usuários. Em vez de uma página de FAQ estática, os usuários podem interagir com um chatbot que fornece respostas dinâmicas. Isso torna a experiência do usuário mais envolvente e menos frustrante.
+
+- **Assistentes e Agentes** Assistentes e agentes podem executar instruções mais avançadas como acessar ferramentas para chamar APIs, executar código, gerar imagens e muito mais. Agentes avançados podem cumprir objetivos e executar tarefas de forma autônoma.
+
+- **Uma ferramenta de criação de conteúdo**: Uma ferramenta para gerar posts de blog e publicações em redes sociais. Imagine criar campanhas em minutos em vez de horas quando um site de e-commerce tem uma promoção de Black Friday.
+
+- **Autocompletar código**: Uma ferramenta de autocompletar código que pode gerar trechos de código com base na entrada do usuário. Isso pode ser uma economia enorme de tempo para os desenvolvedores, especialmente ao trabalhar em tarefas repetitivas.
+
+- **Tradução** – Traduzir texto entre idiomas com alta precisão.
+
+Como você pode ver, essas melhorias podem ajudar tanto o front office quanto o back office do seu aplicativo e empresa.
+
+Aqui está um exemplo de um "aplicativo de chatbot" em ação:
+
+![Imagem de aplicativo de chat](https://camo.githubusercontent.com/76f2ad7cd754a2de2b9957d2070448e130e5ba228084b9b4b128e3af9c9f5239/68747470733a2f2f6c6561726e2e6d6963726f736f66742e636f6d2f656e2d75732f73656d616e7469632d6b65726e656c2f6d656469612f636861742d636f70696c6f742d696e2d616374696f6e2e676966) 
+
+**Você:** Fascinante, vou anotar para visitar o século 21 para ver como essas ferramentas são usadas.
+
+### IA Generativa e o ecossistema JavaScript
+
+**Besouro do Tempo:** Uma maneira popular de construir aplicativos no século 21 é usando JavaScript. Com cada linguagem de programação, há um ecossistema ao seu redor. Esse ecossistema inclui a própria linguagem de programação, bibliotecas e frameworks, suporte da comunidade, IDEs e ferramentas. Em um ecossistema de linguagem de programação, geralmente estamos falando sobre o seguinte:
+
+| O quê | Descrição | 
+|---|---| 
+| A própria linguagem de programação | Incluindo sua sintaxe e recursos. |
+| Bibliotecas e frameworks    | Bibliotecas disponíveis para interagir com os modelos de IA generativa. | 
+| Comunidade que apoia a linguagem| A comunidade é importante, especialmente ao tentar aprender algo novo. A comunidade ao redor das bibliotecas e frameworks ajuda a decidir quais bibliotecas usar. Também afeta o quão fácil é encontrar ajuda quando você está bloqueado. | 
+
+**Você:** Interessante, eu ouvi falar de programação, acho que Ada Lovelace e Charles Babbage não experimentaram isso?
+
+**Besouro do Tempo:** Sim, Ada Lovelace foi a primeira programadora de computador, e Charles Babbage foi o inventor da máquina diferencial, um computador mecânico. Eles foram pioneiros no campo da computação, estabelecendo as bases para a era digital.
+
+**Você:** Foram? O que você quer dizer com foram? Eu acabei de receber uma carta de Charles Babbage.
+
+**Besouro do Tempo:** Digamos apenas que você está em uma posição única para interagir com figuras históricas de uma maneira que poucos outros podem.
+
+### Ecossistema JavaScript
+
+**Você:** Então ecossistemas, você disse, estou apenas anotando aqui, e quanto ao JavaScript e como ele é diferente de outros ecossistemas?
+
+**Besouro do Tempo:** JavaScript é uma das linguagens de programação mais populares do mundo no século 21. Aqui estão algumas razões pelas quais é tão popular:
+
+| O quê | Descrição |
+|-|-|
+| Potencial para desenvolvimento full-stack | JavaScript é uma das poucas linguagens que pode ser usada para desenvolvimento tanto front-end quanto back-end. |
+| Rico ecossistema de bibliotecas | JavaScript tem um vasto ecossistema de bibliotecas, com frameworks como React, Angular, Vue e muito mais. Há o NPM, o gerenciador de pacotes, que é um dos maiores repositórios de pacotes do mundo. |
+| Forte suporte da comunidade | JavaScript tem uma comunidade grande e ativa, com muitos recursos disponíveis para aprendizado e desenvolvimento. Também funciona diretamente no navegador, o que é uma grande vantagem. |
+| IDEs e ferramentas | JavaScript tem uma variedade de IDEs disponíveis, como Visual Studio Code, WebStorm e Atom. Essas IDEs têm extensões construídas por empresas e pela comunidade ajudando você com vários aspectos do desenvolvimento. |
+| IA e JavaScript | JavaScript suporta o desenvolvimento de IA com bibliotecas como TensorFlow.js, Brain.js, APIs da OpenAI e muito mais, permitindo que os desenvolvedores integrem aprendizado de máquina e IA Generativa em aplicações web e do lado do servidor. |
+
+**Você:** São muitas razões, parece que devo apostar no JavaScript para meus projetos futuros.
+
+**Besouro do Tempo:** De fato, JavaScript é uma linguagem versátil, Python também é uma linguagem popular para desenvolvimento de IA.
+
+**Você:** Python, o que cobras têm a ver com programação?
+
+**Besouro do Tempo:** Vamos deixar isso para outra ocasião, certo?
+
+**Besouro do Tempo:** Eu dei razões acima sobre por que o JavaScript e seu ecossistema são uma boa opção em geral, mas por que especificamente para IA Generativa? A resposta é que é uma linguagem suportada por muitos fornecedores de nuvem e frameworks e ferramentas de IA. Também acreditamos que, embora o Python possa ser a primeira opção para cenários de IA, muitos desenvolvedores estão usando JavaScript e TypeScript.
+
+> **Você sabia?**  
+> [62,5% dos desenvolvedores dizem que estão usando JavaScript](https://www.statista.com/statistics/793628/worldwide-developer-survey-most-used-languages/) com muitos preferindo [TypeScript](https://www.typescriptlang.org) para novos projetos.
+
+## Tarefa – Ajudando Dinócrates 
+
+Para usar um Grande Modelo de Linguagem (LLM) para ajudar Dinócrates com o farol que mencionamos anteriormente em nossa história, usaremos algo chamado prompts, uma frase para descrever o que você deseja. Você pode especificar tanto as informações que precisa quanto como deseja que sejam apresentadas.
+
+**Besouro do Tempo:** Vamos começar, vamos usar um LLM para pesquisar como você pode construir um farol para ajudar Dinócrates.
+
+**Besouro do Tempo:** Você precisará fornecer contexto ao LLM (ou seja, "eu") sobre como construir, com quais ferramentas e recursos deveriam estar disponíveis nos tempos de Alexandria.
+
+**Você:** Ok, conte-me mais sobre LLMs.
+
+**Besouro do Tempo:** LLMs são um tipo de modelo de IA que pode gerar texto semelhante ao humano baseado em um prompt fornecido. Eles são treinados em vastas quantidades de dados e podem gerar texto que é coerente, criativo e contextualmente relevante.
+
+**Besouro do Tempo:** Você provavelmente quer me perguntar de uma maneira melhor, para que eu possa dar uma resposta melhor, sobre você sabe *tosse* *tosse* Faróis, Alexandria, 300 a.C., Dinócrates, Farol de Alexandria, etc.
+
+**Você:** Entendi, adicionar mais contexto ao prompt e então perguntar a você.
+
+**Besouro do Tempo:** Sim, estou esperando...
+
+Visite [Microsoft Copilot](https://copilot.microsoft.com), [ChatGPT](https://chatgpt.com/), ou outra ferramenta de chatbot online para gerar um plano para construir o farol em Alexandria.
+ 
+> [!TIP] 
+> Tente fazer com que o LLM gere um plano que inclua instruções passo a passo para construir o farol. Precisa de ajuda? Confira a solução para orientação.
+
+## Solução
+
+[Solução](./solution/solution.md)
+
+### Verificação de conhecimento
+
+**Pergunta:** Qual das seguintes afirmações sobre IA Generativa e JavaScript é verdadeira?
+
+A. Aplicativos de IA Generativa com JavaScript só podem gerar texto.
+B. JavaScript pode ser usado para construir aplicações alimentadas por IA, incluindo chatbots, ferramentas de geração de texto e muito mais.
+C. Python é a única linguagem usada para desenvolvimento de IA.
+
+[Solução do quiz](./solution/solution-quiz.md)
+
+## Recursos para auto-estudo
+
+- [Série de vídeos sobre JavaScript para IA Generativa](https://genai-js)
\ No newline at end of file
diff --git a/lessons/02-first-ai-app/translations/README.pt-br.md b/lessons/02-first-ai-app/translations/README.pt-br.md
new file mode 100644
index 0000000..b37abee
--- /dev/null
+++ b/lessons/02-first-ai-app/translations/README.pt-br.md
@@ -0,0 +1,511 @@
+# Lição 2: Escrevendo seu primeiro aplicativo de IA
+
+Neste capítulo você vai aprender:
+
+- Configurar seu ambiente de desenvolvimento.
+- Escrever um aplicativo básico.
+- Entender prompts de sistema.
+
+## Configuração
+
+Se você ainda não configurou seu ambiente de desenvolvimento, veja como fazer: [Configure seu ambiente](/docs/setup/README.md).
+
+## Recursos relacionados
+
+[![Assista a um vídeo curto sobre grandes modelos de linguagem](https://img.youtube.com/vi/GQ_2OjNZ9aA/0.jpg)](https://www.youtube.com/watch?v=GQ_2OjNZ9aA&list=PLlrxD0HtieHi5ZpsHULPLxm839IrhmeDk&index=2)
+
+_Este vídeo apresenta uma introdução aos modelos de IA chamados "grandes modelos de linguagem", LLMs, o que são e como você pode usá-los para integrar IA em seus aplicativos._
+
+*🎥 Clique na imagem acima para assistir a um vídeo curto sobre grandes modelos de linguagem*
+
+💼 Slides: [Introdução aos grandes modelos de linguagem, LLMs](../../videos/slides/01-llms.pptx)
+
+## Narrativa: Imagine-se em um barco num rio
+
+
+> [!NOTE] 
+> _Nossa história até agora: Você é um criador de coisas, um artesão da Londres dos anos 1860 que viajou através do tempo usando um dispositivo misterioso chamado Besouro do Tempo. Você viajou pelos anais da história, testemunhando a criação do farol de Alexandria, uma maravilha da engenharia antiga que você ajudou a criar com uma pequena ajuda de Dinócrates e do Besouro do Tempo._
+>
+> Veja a [Lição 1](../01-intro-to-genai/README.md) se quiser acompanhar a história desde o início e começar com IA Generativa. 
+
+> [!NOTE] 
+> Embora recomendemos seguir a história (é divertido!), [clique aqui](#interaja-com-leonardo) se preferir ir direto para o conteúdo técnico.
+
+Junto com Dinócrates, você dá os toques finais no farol de Alexandria. A estrutura imponente brilha sob a luz do sol, sua pedra polida refletindo o Mar Mediterrâneo.
+
+Você olha para o Besouro do Tempo em sua mão, sua superfície metálica fria contra sua palma. Fechando o punho ao redor dele, você sussurra: "Leve-me para casa." O besouro começa a brilhar, emitindo uma luz suave e quente, e o mundo ao seu redor se dissolve em um turbilhão de cores.
+
+### Uma nova aventura
+
+Quando você abre os olhos, o mundo mudou. Ao conseguir se levantar, você percebe que está em um barco em um rio. Olhando ao redor, à distância, você vê edifícios, seus contornos borrados pela névoa da manhã.
+
+Observando o barco, você encontra um remo longo apoiado na lateral. Segurando-o, você começa a remar em direção aos edifícios distantes. À medida que se aproxima, os edifícios ficam mais nítidos, são antigos, sua arquitetura lembrando uma pintura renascentista.
+
+<div>
+  <img src="./assets/boat.png" alt="Barco no rio, homem em pé com um remo" width=300" >
+</div>
+
+A questão agora é: onde e quando você está desta vez?
+
+Você consegue atracar o barco no cais e começa a caminhar ao longo das tábuas de madeira, o som de seus passos ecoando suavemente.
+
+Enquanto caminha, você nota um homem com uma longa barba e um chapéu, remexendo em uma caixa do que parecem ser peças mecânicas. Suas mãos se movem com destreza, separando engrenagens e molas com facilidade experiente.
+
+<div >
+  <img src="./assets/leonardo.png" alt="Leonardo Da Vinci em pé ao lado de uma caixa no porto" width="300" >
+</div>
+
+### Ajude-me, Leonardo
+
+**Você:** "Com licença, senhor, onde estou?" Ele olha para você, confusão evidente em seus olhos. Percebendo que você está falando em inglês, você rapidamente usa o dispositivo em sua mão e pede para ele traduzir.
+
+**Besouro do Tempo:** "Claro, vou traduzir para o italiano do século XV. 'Dove sono?'" 
+
+**Velho:** O velho responde: "Siete a Firenze, signore. E chi siete voi?" 
+
+**Besouro do Tempo:** O Besouro do Tempo traduz: "Ele diz que você está em Florença e pergunta quem você é." 
+
+**Você:** "Diga a ele que sou um criador de coisas e estou procurando um lugar para trabalhar."
+
+**Velho:** Un artigiano, eh? Avete mai sentito parlare di Leonardo da Vinci? 
+
+**Besouro do Tempo:** O Besouro do Tempo traduz: "Ele pergunta se você já ouviu falar de Leonardo da Vinci." 
+
+**Você:** "Claro," você diz. "Diga a ele que sim e que eu gostaria de conhecê-lo." 
+
+**Velho:** O velho sorri: "Allora, seguitemi, vi porterò da lui."
+
+**Você:** Você pergunta: "O que ele disse?"
+
+**Besouro do Tempo:** O Besouro do Tempo responde: "Ele disse que vai levá-lo até Leonardo."
+
+### Na oficina
+
+<div>
+  <img src="./assets/leonardo-workshop.png" alt="Oficina de Leonardo" width="300" >
+</div>
+
+O velho o leva até uma grande porta de madeira e você é recebido pela visão de uma oficina cheia de todo tipo de engenhocas mecânicas. 
+
+Você pede ao Besouro do Tempo para perguntar sobre o paradeiro de Leonardo. 
+
+**Você:** "Dove è Leonardo?" 
+
+**Velho:** O velho se vira para você com um sorriso: "Sono io (sou eu), Leonardo da Vinci. Chi siete voi?", quem é você?
+
+Você sente um arrepio de reconhecimento. 
+
+**Você:** "Eu pensava mesmo. Sou um criador como você, fora de lugar e tempo."
+
+**Leonardo:** Os olhos de Leonardo brilham com curiosidade. "Interessante, cosa vi porta qui?"
+
+O Besouro do Tempo traduz.
+
+**Besouro do Tempo:** "Ele pergunta o que o traz aqui."
+
+**Você:** "Bem, eu estava trabalhando em um projeto e acabei aqui."
+
+Você mostra a ele o Besouro do Tempo, e seus olhos se iluminam com fascínio. Ele o examina de perto enquanto você explica como ele funciona e como você acabou em Florença.
+
+Leonardo olha para você com entusiasmo. 
+
+**Leonardo:** Você é um criador de coisas. Tenho um projeto que pode interessá-lo. Estive trabalhando em uma máquina que pode gerar texto com base em entrada verbal. Gostaria de me ajudar com isso?
+
+Leonardo da Vinci, pedindo sua ajuda em um projeto—você mal pode acreditar. Você acena ansiosamente e diz: 
+
+**Você:** Seria uma honra ajudá-lo com seu projeto,
+"Sarebbe un onore aiutarti con il tuo progetto." 
+
+## Interaja com Leonardo
+
+Se você quiser interagir com Leonardo, execute o aplicativo [Characters](/app/README.md). 
+
+> [!IMPORTANT]
+> Isso é inteiramente fictício; as respostas são geradas por IA.
+> [Aviso sobre IA Responsável](../../README.md#responsible-ai-disclaimer)
+
+<div>
+  <img src="./assets/leonardo-talk.jpeg" width=300>
+</div>
+
+**Passos**:
+
+1. Inicie um [![GitHub Codespace](https://img.shields.io/badge/GitHub-Codespace-brightgreen)](https://codespaces.new/microsoft/generative-ai-with-javascript)
+2. Navegue até _/app/README.md_ na raiz do repositório.
+3. Localize o console e execute `npm install` seguido de `npm start`. 
+4. Quando aparecer, selecione o botão "Open in Browser".
+5. Converse com Leonardo.
+
+Para uma explicação mais detalhada do aplicativo, consulte [Explicação detalhada do aplicativo](../01-intro-to-genai/README.md#interaja-com-dinocrates).
+
+> [!NOTE]
+ > Se você estiver executando o projeto localmente em sua máquina, por favor revise o guia de Início Rápido para configurar um [token de acesso pessoal do GitHub](../../docs/setup/README.md#creating-a-personal-access-token-pat-for-github-model-access) e substitua a chave no código.
+
+## Configuração do ambiente de desenvolvimento 
+
+Antes de poder ajudar Leonardo com seu projeto, você deve primeiro pensar nas "ferramentas do ofício" essenciais necessárias para começar a ajudá-lo efetivamente.
+
+**Você:** "Besouro do Tempo, do que preciso para começar com este projeto?" Sugira ferramentas e bibliotecas de que preciso que possam me ajudar a construir um aplicativo de IA que você possa executar.
+
+**Besouro do Tempo:** Sou compatível com a maioria das máquinas que rodam no século 21, veja a lista a seguir para um conjunto de ferramentas e bibliotecas essenciais.
+
+- **Editor de texto**, por exemplo Visual Studio Code.
+- **Terminal**, para executar comandos.
+- **Navegador para testar seu aplicativo**. Também é uma boa ideia ter uma ferramenta como curl ou algum outro cliente HTTP para testar os endpoints da API do seu aplicativo.
+
+- **Node.js**. Você também precisa instalar o Node.js e npm, que são ferramentas que ajudam você a executar código JavaScript em seu computador.
+
+- **Chave de API**. Você precisará de uma chave de API para acessar o modelo de IA generativa. Você pode obtê-la do provedor do modelo, por exemplo, OpenAI ou Azure OpenAI.
+
+**Você:** Obrigado, Besouro do Tempo, acho que você vai conseguir essas coisas de alguma forma daquela Web de que você falou?
+
+**Besouro do Tempo:** Sim, eu já tenho essas coisas, diz ele e projeta um teclado e uma tela na parede à sua frente.
+
+## Escrevendo um aplicativo básico 
+
+**Você:** Me conte mais sobre a escrita do aplicativo em si, como começo?
+
+**Besouro do Tempo:** Claro, para escrever um aplicativo, em sua forma mais simples, trata-se de enviar uma solicitação a uma API e exibir a resposta. Vamos detalhar: 
+
+- **Entrada**: Em um aplicativo básico de geração de texto, a entrada refere-se ao texto inicial que você deseja que o aplicativo expanda ou desenvolva. Essa entrada pode ser fornecida pelo usuário durante a execução ou pré-definida (codificada) dentro do próprio aplicativo. Por enquanto, começaremos usando texto codificado como entrada.
+
+- **Solicitação de API**: Você precisa enviar uma solicitação para a API do modelo de IA generativa com o texto de entrada. Isso é feito usando a função fetch em JavaScript (Node.js). Incluída nesta solicitação também deve estar sua chave de API. É recomendável, ao considerar a segurança, não codificar a chave de API em seu aplicativo, mas sim usar variáveis de ambiente. Além disso, considere pesquisar sobre identidade gerenciada se estiver usando um provedor como o Azure, pois é considerada uma maneira mais segura de acessar recursos. Com a identidade gerenciada, você pode atribuir permissões mais granulares ao seu aplicativo. A melhor parte é que o provedor de nuvem cuida da autenticação para você. 
+
+- **Resposta**: A API retornará uma resposta com o texto gerado. Você precisa extrair esse texto da resposta e mostrá-lo ao usuário.
+
+**Você:** Isso parece bastante simples, pode me guiar por um cenário que faça sentido dada a situação em que estamos?
+
+**Besouro do Tempo:** Claro, vamos ver como podemos construir um aplicativo simples que gera texto em italiano com base em uma entrada em inglês.
+
+## Seu primeiro aplicativo - ensine-me italiano
+
+**Besouro do Tempo:** Modelos de IA generativa podem ser usados para muitas coisas, por exemplo, tradução de idiomas. Na verdade, ele aceita entrada em um idioma e pode gerar texto em outro idioma. Vamos começar com um aplicativo simples que recebe entrada em inglês e gera texto em italiano.
+
+```javascript 
+
+import { OpenAI } from "openai";
+
+// 1. Faça uma pergunta sobre tradução
+// -----------------------------------
+
+const question = 'Hello, how are you?'; 
+
+const augmentedPrompt = `
+## Instructions
+Translate the following text to Italian:
+## Question
+${question}
+`;
+
+// 2. Crie o cliente
+// -----------------------------------
+
+const openai = new OpenAI({
+  baseURL: "https://models.inference.ai.azure.com",
+  apiKey: process.env.GITHUB_TOKEN,
+});
+
+
+// 3. Envie a solicitação
+// -----------------------------------
+const completion = await openai.chat.completions.create({
+    model: 'gpt-4',
+    messages: [{ role: 'user', content: augmentedPrompt }],
+});
+  
+console.log(`Resposta para "${question}":`);
+
+// 4. Imprima a resposta
+// -----------------------------------
+
+console.log(completion.choices[0]?.message?.content);
+```
+
+Vamos explicar o que está acontecendo aqui:
+
+- Criando a pergunta como 'Hello, how are you?'. Este é o texto que você deseja traduzir para o italiano.
+- Criando o prompt aumentado, que contém o texto de entrada e algumas instruções adicionais sobre o que fazer, ou seja, traduzir. Observe como estamos usando interpolação de string para incluir o texto de entrada no prompt e como essa instrução é para traduzir o texto para o italiano.
+- Criando o cliente com propriedades:
+  - `model`, qual modelo usar. 
+  - `messages`, o prompt para enviar ao modelo. Observe também como você define o papel como "user" para indicar que o texto de entrada é do usuário. Se fosse da IA, você definiria o papel como "system".
+- Extraindo o texto gerado da resposta e imprimindo-o no console.
+
+**Você:** Acho que entendi. Então, se eu mudar o valor da variável `question` para outra coisa, o aplicativo gerará uma tradução italiana diferente?
+
+**Besouro do Tempo:** Exatamente, você pode alterar o texto de entrada para qualquer coisa que desejar. Observe também como os modelos do GitHub estão sendo usados como a URL base para a API junto com um token do GitHub como a chave da API.
+
+**Você:** Por que isso é importante?
+
+**Besouro do Tempo:** É importante usar uma URL base e uma chave de API específicas para o modelo que você está usando. GitHub Models é uma plataforma que hospeda uma variedade de modelos, todos com diferentes capacidades e recursos, e também é gratuito para usar.
+
+**Você:** Ah, que bom, eu não sei quem pagar de qualquer forma e duvido que eles aceitem minha moeda aqui. :) 
+
+## Aplicativos de chat
+
+**Besouro do Tempo:** Modelos de IA generativa também podem ser usados para gerar texto com base em uma conversa. Você pode simular uma conversa com a IA fornecendo uma lista de mensagens como contexto, como se a conversa já tivesse acontecido.
+
+**Você:** Isso parece interessante, mas por que é útil?
+
+**Besouro do Tempo:** É útil porque permite que a IA forneça uma resposta melhor com base em mais contexto do que apenas um único prompt. Vamos observar uma conversa abaixo para ilustrar isso: 
+
+```text
+
+Usuário: Quero reservar uma viagem para a Itália. 
+
+IA: Claro, quando você gostaria de ir? 
+
+Usuário: Próximo mês seria ótimo. 
+
+IA: Entendi, para onde na Itália você gostaria de visitar? 
+
+Usuário: Estou pensando em Roma 
+
+IA: Excelente escolha! Posso ajudá-lo a planejar seu itinerário. 
+
+Usuário: Me conte mais sobre isso. 
+
+IA: Roma é conhecida por suas ruínas antigas, arte e cultura vibrante. Você pode visitar o Coliseu, o Vaticano e desfrutar da deliciosa culinária italiana. 
+
+```
+
+**Besouro do Tempo:** Imagine se uma frase como "Me conte mais sobre isso" fosse tirada do contexto, a IA não saberia a que "isso" se refere. É aqui que o contexto é importante, e esse contexto é algo que podemos fornecer ao modelo de IA através do prompt.
+
+**Você:** Acho que entendi, como construo uma conversa com a IA usando essa linguagem JavaScript de que você fala?
+
+**Besouro do Tempo:** Abaixo está como podemos construir uma conversa com a IA: 
+
+```javascript 
+
+// Defina o contexto 
+
+const messages = [ 
+ { 
+    "role": "user", 
+    "content": "Quero reservar uma viagem para a Itália." 
+ }, 
+ { 
+    "role": "assistant", 
+    "content": "Claro, quando você gostaria de ir?" 
+ }, 
+ { 
+    "role": "user", 
+    "content": "Próximo mês seria ótimo." 
+ }, 
+ { 
+    "role": "assistant", 
+    "content": "Entendi, para onde na Itália você gostaria de visitar?" 
+ }, 
+ { 
+    "role": "user", 
+    "content": "Estou pensando em Roma. Me conte mais sobre isso." 
+ } 
+]; 
+
+const openai = new OpenAI({
+  baseURL: "https://models.inference.ai.azure.com",
+  apiKey: process.env.GITHUB_TOKEN,
+});
+
+
+// 3. Envie a solicitação
+// -----------------------------------
+const completion = await openai.chat.completions.create({
+    model: 'gpt-4',
+    messages: messages,
+});
+  
+console.log(`Resposta para "${question}":`);
+
+// 4. Imprima a resposta
+// -----------------------------------
+
+console.log(completion.choices[0]?.message?.content);
+
+```
+
+Agora a IA fornecerá uma lista de mensagens de chat como contexto, e a IA gerará uma resposta com base nesse contexto. Esta é uma maneira mais interativa de usar modelos de IA generativa e pode ser usada em chatbots, aplicativos de atendimento ao cliente e muito mais.
+
+**Você:** Ok, então se eu entendi a conversa corretamente, a IA agora terá o seguinte contexto: _Vou para Roma no próximo mês_, então com base nisso ela deve filtrar informações irrelevantes e fornecer uma resposta mais relevante?
+
+**Besouro do Tempo:** Exatamente, a IA usará o contexto para gerar uma resposta que é mais relevante para a conversa.
+
+## Melhorando a conversa de chat com uma mensagem de sistema
+
+**Você:** Entendo, mas há alguma maneira de melhorar isso ainda mais?
+
+**Besouro do Tempo:** Sim, você pode adicionar uma mensagem de sistema à conversa. Uma mensagem de sistema cria uma "personalidade" para a IA e pode ser usada para fornecer contexto adicional.
+
+**Você:** Ok, então no contexto da conversa que estamos tendo, como seria uma mensagem de sistema?
+
+**Besouro do Tempo:** Uma mensagem de sistema para esta conversa poderia ser algo como _"Sou um assistente de viagem de IA, aqui para ajudá-lo a planejar sua viagem para a Itália."_ Esta mensagem define o tom para a conversa e ajuda a IA a entender seu papel na interação.
+
+Para criar tal mensagem, certifique-se de que ela tenha o tipo "developer" assim:
+
+```javascript
+const message = {
+  "role": "developer",
+  "content": "Sou um assistente de viagem de IA, aqui para ajudá-lo a planejar sua viagem para a Itália."
+};
+```
+
+> [!NOTE] 
+> Isso costumava ser chamado de "system". Esta é uma mudança recente e "developer" é o novo termo para isso. Para alguns modelos, isso ainda é chamado de "system", então se você tiver algum problema, use "system".
+
+**Você:** Ok, ótimo, vou me certificar de incluir uma mensagem de sistema em minhas conversas de chat. Por curiosidade, como seria uma mensagem de sistema para você?
+
+**Besouro do Tempo:** Uma mensagem de sistema para mim poderia ser algo como _"Eu sou o Besouro do Tempo, aqui para ajudá-lo a navegar pelo tempo e espaço. Devo ser útil em fornecer informações e orientações sobre a era do tempo em que você está, juntamente com as ferramentas necessárias para voltar ao seu próprio tempo."_
+
+### Criando respostas variadas com a configuração de temperatura
+
+**Você:** Mais alguma coisa que eu deva saber sobre conversas de chat?
+
+**Besouro do Tempo:** Sim, você pode ajustar a "temperatura" das respostas da IA. A temperatura é uma variável com um valor normalmente definido entre 0 e 1 que determina quão criativas são as respostas da IA. Uma temperatura de 0 resultará em respostas mais previsíveis, enquanto uma temperatura de 1 resultará em respostas mais criativas e variadas. Você pode ajustar a temperatura com base no contexto da sua conversa e no tipo de respostas que deseja da IA. Observe que é possível definir um valor maior que 1, mas isso leva a mais aleatoriedade e menos coerência nas respostas.
+
+**Você:** Então, se eu definir a temperatura para 0, a IA fornecerá respostas mais previsíveis, e se eu definir para 1, a IA fornecerá respostas mais criativas? Que temperatura você tem?
+
+**Besouro do Tempo:** Eu tenho uma temperatura de 0,7 e sim, você está correto, a IA fornecerá respostas mais criativas com uma temperatura mais alta. Vamos ver como você pode definir a temperatura em seu aplicativo:
+
+```javascript
+
+// Defina o contexto 
+
+const messages = [ 
+{ 
+    "role": "user", 
+    "content": "Quero que você gere receitas para mim." 
+}]; 
+
+// Crie a solicitação web 
+
+let temperature = 0.5; // Defina a temperatura como 0.5 
+
+const completion = await openai.chat.completions.create({
+    model: 'gpt-4',
+    messages: messages,
+    temperature: temperature
+}); 
+```
+
+Como você pode ver, você pode ajustar a temperatura com base no contexto da sua conversa e no tipo de respostas que deseja da IA. Este é um recurso poderoso que permite personalizar o nível de criatividade nas respostas da IA.
+
+## Janela de contexto
+
+**Você:** Tem mais, certo?
+
+**Besouro do Tempo:** Sim, outro conceito importante em modelos de IA generativa é a janela de contexto. A janela de contexto é o número de mensagens anteriores que a IA usa para gerar uma resposta. Uma janela de contexto maior permite que a IA considere mais contexto e gere respostas mais coerentes.
+
+**Besouro do Tempo:** Diferentes modelos têm diferentes limites para tokens de saída. Considere o seguinte modelo como exemplo `gpt-4o-2024-08-06`, ele tem as seguintes especificações:
+
+- Máximo de tokens de saída: aproximadamente 16 mil tokens.
+- Tamanho máximo da janela de contexto: 128 mil.
+
+Isso significa que a maioria dos tokens pode ser gasta nos tokens de entrada, ou seja, 128 mil - 16 mil = 112 mil tokens.
+
+**Você:** Entendi, janela de contexto, tokens, mas quanto vale um token?
+
+**Besouro do Tempo:** Um token é uma palavra ou parte de uma palavra e difere ligeiramente por idioma. Há uma ferramenta que você pode usar para medir, recomendada pela OpenAI, chamada [tokenizer](https://platform.openai.com/tokenizer). Vamos tentar uma frase e ver quantos tokens ela possui:
+
+```text
+Quero que você gere receitas para mim.
+```
+
+![Demonstração do tokenizer](./assets/tokenizer.png)
+
+Executar o `tokenizer` na frase acima nos dá 9 tokens.
+
+**Você:** Não foi muito, parece que posso ter muitos tokens na minha janela de contexto, então?
+
+**Besouro do Tempo:** Sim, você pode experimentar com diferentes tamanhos de janela de contexto para ver como isso afeta as respostas da IA. Na verdade, se você definir um tamanho de janela de contexto de 100, limitará a IA e quanto ela considera para entrada e saída. Veja como você pode definir a janela de contexto em seu aplicativo:
+
+```javascript
+
+// Defina o contexto 
+const messages = [ 
+{ 
+  "role": "user", 
+  "content": "Quero que você gere receitas para mim." 
+}]; 
+
+// decida sobre o tamanho da janela de contexto 
+
+let max_tokens = 100; // Defina o tamanho da janela de contexto 
+
+// Crie a solicitação web 
+
+const completion = await openai.chat.completions.create({
+    model: 'gpt-4',
+    messages: messages,
+    max_tokens: max_tokens
+}); 
+
+```
+
+> [!TIP] 
+> Experimente com diferentes tamanhos de janela de contexto para ver como isso afeta as respostas da IA.
+
+## Tarefa - Construindo um assistente de engenharia
+
+Leonardo de repente pediu para inspecionar o Besouro do Tempo mais de perto, olhou-o de todos os lados, até mesmo o sacudiu.
+
+**Leonardo:** Preciso de um assistente que possa me ajudar com os cálculos e design do parafuso aéreo. Você pode construir um assistente que possa fazer isso?
+
+**Você:** Claro, posso construir isso para você. Besouro do Tempo, podemos ajudar com isso, certo?
+
+**Besouro do Tempo:** Sim, sem problema, na verdade o parafuso aéreo é uma das invenções mais fascinantes e visionárias de Leonardo. Projetado no final da década de 1480...
+
+**Você:** Tudo o que eu precisava era de um sim, vamos deixar a palestra para depois.
+
+**Besouro do Tempo:** Grosseiro..
+
+**Você:** O quê?
+
+**Besouro do Tempo:** Nada
+
+<div>
+  <img style="margin-top: 52px; margin-left: 15px; margin-right: 10px" align=right src="./assets/helicopter.jpg" alt="Parafuso aéreo, Leonardo Da Vinci" width="300" >
+</div>
+
+> [!NOTE]
+>  O parafuso aéreo, também conhecido como parafuso helicoidal de ar, foi projetado para decolar do solo comprimindo o ar. O design de Leonardo apresentava um grande rotor em forma de espiral feito de linho, enrijecido com amido, e montado em uma plataforma de madeira. A ideia era que uma equipe de homens correria ao redor da plataforma, girando manivelas para fazer o parafuso girar rapidamente o suficiente para alcançar a sustentação 
+>
+> Embora Leonardo nunca tenha construído uma versão em escala real do parafuso aéreo, seus esboços e notas fornecem insights detalhados sobre como ele imaginava seu funcionamento. Ele acreditava que se o parafuso fosse girado rapidamente o suficiente, empurraria contra o ar e levantaria toda a estrutura do chão. 
+>
+> No entanto, cientistas modernos concordam que os materiais disponíveis na época de Leonardo não eram fortes ou leves o suficiente para tornar isso possível 
+>
+> Apesar de sua impraticabilidade, o parafuso aéreo continua sendo um testemunho da genialidade de Leonardo e sua busca implacável pela inovação. Estabeleceu as bases para desenvolvimentos futuros na aviação e continua inspirando engenheiros e inventores até hoje.
+> [Leia mais](https://en.wikipedia.org/wiki/Leonardo%27s_aerial_screw)
+
+Sua tarefa é construir um assistente de engenharia que possa ajudar Leonardo com os cálculos e design do parafuso aéreo.
+
+- Ele deve ser capaz de gerar texto com base na entrada do usuário.
+
+- Você deve definir uma mensagem de sistema para apresentar o assistente.
+
+Confira o [Aplicativo de exemplo](./sample-app/) para começar.
+
+> [!TIP] 
+> Considere qual deve ser a mensagem do sistema e qual entrada você deve fornecer.
+
+## Solução
+
+[Solução](./solution/solution.md)
+
+## Verificação de conhecimento
+
+**Pergunta:** Qual é o propósito da janela de contexto em modelos de IA generativa? Selecione todas as opções aplicáveis.
+
+A. A janela de contexto permite que a IA considere mais contexto e gere respostas mais coerentes.
+
+B. A janela de contexto é o número de mensagens anteriores que a IA usa para gerar uma resposta.
+
+C. A janela de contexto determina quão criativas são as respostas da IA.
+
+[Solução do quiz](./solution/solution-quiz.md)
+
+## Recursos para auto-estudo
+
+- [Geração de texto](https://platform.openai.com/docs/guides/text-generation)
+- [Biblioteca JavaScript para OpenAI](https://github.com/openai/openai-node/tree/master/examples) 
+- [Tokenizer](https://platform.openai.com/tokenizer)
+- [API de Completions](https://platform.openai.com/docs/api-reference/completions)
+- [Chat completions](https://platform.openai.com/docs/guides/text-generation#text-generation-models)
\ No newline at end of file
diff --git a/lessons/03-prompt-engineering/translations/README.pt-br.md b/lessons/03-prompt-engineering/translations/README.pt-br.md
new file mode 100644
index 0000000..043b4ef
--- /dev/null
+++ b/lessons/03-prompt-engineering/translations/README.pt-br.md
@@ -0,0 +1,341 @@
+# Lição 3: Engenharia de prompts
+
+Neste capítulo você vai aprender:
+
+- O que é engenharia de prompts e como conhecer os fundamentos pode ajudar você a obter melhores resultados.
+- Diferentes técnicas de engenharia de prompts e como elas podem ajudar a fornecer melhores resultados para diferentes cenários.
+- O que são meta-prompts e como eles ajudarão a restringir a saída, garantir que seja acessível e proporcionar uma melhor experiência ao usuário.
+
+## Configuração
+
+Se você ainda não configurou seu ambiente de desenvolvimento, veja como fazer: [Configure seu ambiente](/docs/setup/README.md).
+
+## Recursos relacionados
+
+[![Assista a um vídeo curto sobre engenharia de prompts](https://img.youtube.com/vi/gQ6TlyxBmWs/0.jpg)](https://www.youtube.com/watch?v=gQ6TlyxBmWs&list=PLlrxD0HtieHi5ZpsHULPLxm839IrhmeDk&index=3)
+
+_Este vídeo oferece uma introdução para melhorar suas habilidades de "prompting", ensinando como dar instruções mais claras e eficazes à IA para obter melhores resultados._
+
+*🎥 Clique na imagem acima para assistir a um vídeo curto sobre engenharia de prompts*
+
+💼 Slides: [Engenharia de prompts](../../videos/slides/02-prompt-engineering.pptx)
+
+## Narrativa: Passagem para aventura
+
+> [!NOTE] 
+> Até agora, você esteve em uma jornada através do tempo com Leonardo da Vinci, explorando as maravilhas do Renascimento. Você encontrou o Besouro do Tempo, um dispositivo misterioso que permite viajar através do tempo e do espaço.
+>
+> Veja a [Lição 1](../01-intro-to-genai/README.md) se quiser acompanhar a história desde o início. 
+
+> [!NOTE] 
+> Embora recomendemos seguir a história (é divertido!), [clique aqui](#interaja-com-sforza) se preferir ir direto para o conteúdo técnico.
+
+**Você:** Vamos ver se consigo voltar para casa. 
+
+Antes que você consiga pressionar o botão, as portas da oficina se abrem com um estrondo. Um homem está na entrada, de ombros largos e vestido com roupas caras, ele agita um pedaço de papel no ar, gritando:
+
+<div>
+  <img src="./assets/ludovico.png" alt="Um Ludovico Sforza furioso irrompendo pela porta" width="300">
+</div>
+
+*Ludovico Sforza* 
+
+**Sforza**: Da Vinci, dov'è il mio dipinto? Onde está minha pintura?
+
+**Leonardo:** É Sforza. Ele quer que eu termine uma pintura, 'A Última Ceia'.
+
+**Você:** Você não poderia simplesmente dizer isso a ele?
+
+**Leonardo:** Eu tentei, mas ele não é um homem paciente.
+
+Você corre atrás de Leonardo, saindo pela porta dos fundos para um beco escuro, encontra um cavalo e uma carruagem esperando.
+
+Leonardo pega as rédeas e vocês dois saltam para a carruagem. Com um estalo do chicote, o cavalo parte, galopando pelas ruas estreitas de Florença.
+
+**Leonardo:** Tente pressionar aquela engenhoca, eles estão se aproximando!
+
+**Você:** "Ok, Besouro do Tempo, escute com atenção. Preciso voltar ao presente, para casa, entendeu?" De repente, a carruagem passa por um solavanco e o Besouro do Tempo voa de sua mão e cai no chão. Ele começa a emitir bipes e anuncia com uma voz robótica: "Indo para Roma."
+
+**Você:** Não, não Roma, home... casa...
+
+Um turbilhão de cores envolve a carruagem, o mundo ao seu redor se dissolve em um caleidoscópio de luz.
+
+## Fuga 
+
+O turbilhão de cores desaparece, e você se encontra na carruagem, agora correndo pela Via Appia em Roma e, para seu espanto, está no meio de uma corrida de cavalos. Bigas trovejam passando, suas rodas levantando nuvens de poeira. 
+
+<div>
+  <img src="./assets/escape.png" alt="Fuga de Roma" width="300">
+</div>
+
+**Você:** Leonardo, onde estamos? 
+
+**Leonardo:** Parece que estamos no meio de uma corrida! Precisamos sair daqui! 
+
+Você se agarra às laterais da carruagem enquanto ela atravessa o caos. Soldados romanos a cavalo estão se aproximando, suas armaduras brilhando sob a luz do sol. 
+
+**Você**: Ali! Siga para o porto!
+
+Leonardo dirige a carruagem em direção à saída, as rodas derrapando nas pedras. Os soldados estão em seu encalço, seus gritos ecoando em seus ouvidos. 
+
+**Leonardo:** Precisamos despistá-los! Procure um lugar para se esconder!
+
+Você examina as ruas estreitas, seu coração acelerado. 
+
+**Você:** Ali! Um beco!
+
+Leonardo entra no beco, a carruagem sacudindo ao fazer a curva apertada. Você salta da carruagem e ajuda Leonardo a arrastar um enorme dispositivo da parte de trás. É sua invenção—o _parafuso aéreo_.
+
+**Leonardo:** Rápido, precisamos levar isso para o telhado!
+
+Vocês dois se esforçam sob o peso do dispositivo. O som da perseguição dos soldados fica mais alto, seus passos ecoando nas paredes. Vocês chegam ao telhado, ofegantes e suados.
+
+**Leonardo:** Ajude-me a montá-lo!
+
+Vocês trabalham juntos, suas mãos se movendo com precisão treinada. Ambos sobem no dispositivo, seu coração batendo forte no peito.
+
+**Leonardo:** Segure-se bem!
+
+Com um impulso final, o parafuso aéreo começa a girar. As lâminas pegam o ar, e você sente uma súbita elevação. O chão se afasta abaixo de vocês enquanto o dispositivo decola, subindo acima dos telhados de Roma. 
+
+**Você:** Conseguimos, Leonardo! Estamos voando!
+
+**Leonardo:** Sim, mas precisamos encontrar um lugar seguro para pousar.
+
+Você olha para a cidade; os edifícios antigos se estendem abaixo de você.
+
+<div>
+  <img src="./assets/airborne.png" alt="No ar, olhando para a cidade com os pés pendurados" width="300">
+</div>
+
+## Interaja com Sforza
+
+Se você quiser interagir com Sforza, execute o aplicativo [Characters](/app/README.md). 
+
+> [!IMPORTANT]
+> Isso é inteiramente fictício; as respostas são geradas por IA.
+> [Aviso sobre IA Responsável](../../README.md#responsible-ai-disclaimer)
+
+<div >
+  <img  src="./assets/ludovico.png" alt="Ludovico Sforza" width="300" >
+</div>
+
+**Passos**:
+
+1. Inicie um [![GitHub Codespace](https://img.shields.io/badge/GitHub-Codespace-brightgreen)](https://codespaces.new/microsoft/generative-ai-with-javascript)
+2. Navegue até _/app_ na raiz do repositório.
+3. Localize o console e execute `npm install` seguido de `npm start`.
+4. Quando aparecer, selecione o botão "Open in Browser".
+5. Converse com Sforza.
+
+Para uma explicação mais detalhada do aplicativo, consulte [Explicação detalhada do aplicativo](../01-intro-to-genai/README.md#talk-to-dinocrates).
+
+> [!NOTE]
+ > Se você estiver executando o projeto localmente em sua máquina, por favor revise o guia de Início Rápido para configurar um [token de acesso pessoal do GitHub](../../docs/setup/README.md#creating-a-personal-access-token-pat-for-github-model-access) e substitua a chave no código.
+
+## O que é engenharia de prompts?
+
+**Besouro do Tempo:** Precisamos falar sobre engenharia de prompts.
+
+**Você:** Precisamos? O que é isso?
+
+**Besouro do Tempo:** Engenharia de prompts, apesar do nome, não é sobre construir pontes ou estradas, mas sim sobre elaborar os "prompts" certos para obter a saída desejada de um modelo de linguagem de IA Generativa.
+
+**Você:** Ok, mas por que é importante que eu saiba disso?
+
+**Besouro do Tempo:** Bem, você quer pousar o parafuso aéreo, certo?
+
+**Você:** Sim, de preferência em uma peça só. :-)
+
+**Besouro do Tempo:** Foi o que pensei, agora preste atenção! Engenharia de prompts é sobre elaborar os prompts certos para obter a saída desejada de um modelo de linguagem.
+
+**Besouro do Tempo:** Grandes modelos de linguagem têm o que chamamos de _propriedades emergentes_, que são características que não estão explicitamente programadas no modelo, mas surgem da maneira como ele é treinado em vastas quantidades de dados de texto. Ao estudar essas propriedades emergentes, você pode tirar conclusões e descobrir padrões que podem ajudá-lo a obter melhores resultados do modelo.
+
+**Você:** Ok, então existem padrões que descobrimos que podem nos ajudar a obter melhores resultados do modelo. Mas como isso me ajuda a pousar o parafuso aéreo?
+
+**Besouro do Tempo:** Sim, correto, e uau, você não é muito paciente, não é?
+
+**Você:** Bem, você também não seria se estivesse voando em uma geringonça sem instruções claras de pouso.
+
+**Besouro do Tempo:** Estou aqui com você, sabia? Mas vamos voltar ao ponto.
+
+## Como a engenharia de prompts pode ajudar desenvolvedores de aplicativos
+
+**Besouro do Tempo:** Como profissional, ser capaz de elaborar um prompt melhor é uma habilidade que você deseja ter em seu arsenal.
+
+Olhando da perspectiva de um desenvolvedor, você pode usar a engenharia de prompts para:
+
+- **Obter resultados mais precisos** do seu modelo de linguagem e, em última análise, melhorar a experiência do usuário do seu aplicativo.
+
+- **Controlar a saída** do modelo para garantir que seja relevante e apropriada para seus usuários. Isso é especialmente importante ao lidar com tópicos sensíveis e também para proteger a reputação da sua marca.
+
+- **Formatar a saída** de uma maneira que seja fácil de entender e consumir. Vamos analisar mais este aspecto no próximo capítulo.
+
+**Besouro do Tempo:** Vamos explorar as diferentes técnicas e estratégias que você pode usar para elaborar prompts eficazes para seu modelo de linguagem.
+
+## Técnicas e estratégias de engenharia de prompts
+
+**Besouro do Tempo:** Aqui estão algumas técnicas e estratégias que você pode usar para elaborar prompts eficazes:
+
+- **Prompting com poucos exemplos**. Esta técnica envolve dar à IA alguns exemplos para mostrar o tipo de resposta que você deseja.
+
+- **Prompting de cadeia de pensamento**. Esta técnica envolve fornecer uma sequência de prompts para ensinar a IA como resolver uma tarefa complexa passo a passo.
+
+- **Meta-prompts**. Esta técnica envolve adicionar detalhes ou instruções extras para moldar a saída da IA com mais precisão.
+
+- **Prompting maiêutico**. Esta técnica envolve usar perguntas orientadoras para direcionar a IA para uma resposta específica.
+
+**Você:** Isso parece interessante, suponho que você me dará alguns exemplos?
+
+**Besouro do Tempo:** Sim, já vou mostrar. Vamos analisar exemplos para cada uma dessas técnicas para entender como funcionam na prática.
+
+### Prompting com poucos exemplos: Dê exemplos para orientar a saída da IA
+
+O prompting com poucos exemplos fornece a um modelo de IA alguns exemplos para orientar sua saída. Imagine que você está no parafuso aéreo perguntando sobre a Roma antiga. Prompts com poucos exemplos podem ser assim:
+
+> "Fale-me sobre o Coliseu Romano." → "É um anfiteatro enorme."
+>
+> "Como era a vida na Roma antiga?" → "Era movimentada e difícil."
+
+**Você:** Entendi! Isso ajuda a IA a acertar, mesmo aqui em cima! ;)
+
+**Besouro do Tempo:** Exatamente, é um método sólido. Próximo!
+
+### Prompting de Cadeia de Pensamento: Mostre raciocínio passo a passo
+
+**Besouro do Tempo:** Esta técnica guia a IA mostrando um raciocínio passo a passo para resolver um problema. Imagine pousar o parafuso aéreo. Você poderia decompor assim:
+- Você está a 100 metros de altura.
+- A gravidade puxa a 9,8 m/s².
+- Fórmula: altura = ½ * g * t².
+- Resolva: t ≈ 4,5 segundos para pousar.
+
+Seu prompt se torna:
+> - 100 metros acima do solo  
+> - Gravidade: 9,8 m/s²  
+> - Quantos segundos para pousar?  
+
+**Resposta: 4,5 segundos**
+
+**Você:** Isso é rápido—espero que os números funcionem!
+
+**Besouro do Tempo:** Isso ensina a IA a pensar passo a passo.
+
+**Você:** Então é sobre decompor problemas para respostas precisas?
+
+**Besouro do Tempo:** Sim, perfeito para tarefas complexas como um aplicativo de tutor de matemática!
+
+### Prompting Maiêutico: Questione a saída para verificar a precisão
+
+**Besouro do Tempo:** Esta técnica usa perguntas para verificar a precisão da saída da IA. Você pergunta sobre cada etapa para garantir um raciocínio consistente.
+
+**Você:** Então, questionar tudo o que ela diz? Parece divertido. ;)  
+
+**Besouro do Tempo:** Vamos testar nosso pouso do parafuso aéreo:
+- 100 metros acima
+- Gravidade: 9,8 m/s²
+- Quantos segundos para pousar? (Resposta: 4,5s)
+
+Pergunte: "Por que 4,5 segundos?"
+
+> **Resposta:**
+> - Altura = 100m, velocidade vertical inicial = 0 m/s, gravidade = 9,8 m/s². 
+> - Use: altura = ½ * g * t².
+> - Resolva: 100 = ½ * 9,8 * t² → t ≈ 4,5s.
+
+**Besouro do Tempo:** Trata-se de verificar as respostas da IA com perguntas de acompanhamento.
+
+**Você:** Então, não confie nela—investigue-a com perguntas?
+
+**Besouro do Tempo:** Exatamente! Garante um raciocínio sólido.
+
+## Meta Prompts: Adicione instruções extras para precisão
+
+**Besouro do Tempo:** Em seguida, meta prompts.
+
+**Você:** Ugh, chá primeiro?
+
+**Besouro do Tempo:** _Suspiro_. Eles adicionam orientação aos prompts para melhor saída—ótimos para aplicativos sensíveis e voltados ao cliente.
+
+Aqui está um exemplo:
+> **Meta Prompt:** Use apenas produtos da Contoso Inc. (bolas de basquete, bolas de futebol, raquetes de tênis). Mantenha preciso e amigável ao usuário.
+> **Prompt:** Melhores produtos esportivos para iniciantes?
+> **Resposta:** Bolas de basquete, bolas de futebol e raquetes de tênis—perfeitas para coordenação e agilidade.
+
+Isso garante precisão e se atém aos produtos da Contoso. Sem isso:
+> **Prompt:** Melhores produtos esportivos para iniciantes?
+> **Resposta:** Bolas de basquete, bolas de futebol, raquetes de tênis, além de bolas de futebol americano—_nem todos são itens da Contoso_.
+
+**Você:** Útil! Mantém as respostas no caminho certo, como leis para meu autômato.
+
+**Besouro do Tempo:** Você saberia, _"Frankenstein"_—er, nada!
+
+**Você:** O quê?
+
+**Besouro do Tempo:** Deixa pra lá.
+
+> *Frankenstein* de Mary Shelley—1818, 42 anos antes de suas viagens no tempo. [Leia mais](https://en.wikipedia.org/wiki/Mary_Shelley)
+
+**Você:** Então, sem meta prompt significa caos?
+
+**Besouro do Tempo:** Sim, você obteria respostas fora da marca.
+
+**Você:** Entendi, a precisão importa!
+
+## Tarefa - Vamos ajudar nossos heróis a pousar o parafuso aéreo
+
+**Você:** Esta é a parte em que você me mostra como pousar o parafuso aéreo, certo?
+
+**Besouro do Tempo:** Sim, vamos a isso. A colina está aproximadamente a 100 metros de nossa posição atual. Veja como podemos configurar o prompt:
+
+- Altura atual acima do solo: 100 metros
+- Movendo-se para frente a: 10 metros por segundo
+- Gravidade: 9,8 metros por segundo ao quadrado
+- Vento para cima a: 0,7 metros por segundo
+
+**Leonardo:** Sua engenhoca de IA pode ajudar no cálculo para ver se conseguiremos chegar ou se precisamos fazer outro salto temporal?
+
+**Besouro do Tempo:** Sim, posso, mas meu nome é George, prefiro isso a Engenhoca. Na verdade, vou deixar que vocês dois descubram como configurar o prompt. ☺️
+
+Construa um aplicativo que pergunte por:
+
+- Altura
+- Velocidade para frente
+- Gravidade
+- Vento para cima
+- Distância até a colina
+
+Use a técnica de cadeia de pensamento para chegar a uma resposta.
+
+Aqui está um projeto inicial [Projeto inicial](./sample-app/).
+
+## Solução
+
+Construa um aplicativo em JavaScript que peça as seguintes entradas: 
+
+- Altura atual acima do solo
+- Movendo-se para frente a metros por segundo
+- Gravidade em metros por segundo ao quadrado
+- Vento para cima em metros por segundo 
+- Distância até a colina 
+
+Em seguida, use o LLM para incorporar essas entradas e aproveitar a técnica de prompting de cadeia de pensamento para guiar o modelo até a resposta correta.
+
+[Solução](./solution/solution.md) 
+
+## Verificação de conhecimento 
+
+**Pergunta:** O que é engenharia de prompts? Selecione todas as opções aplicáveis.
+
+A. Engenharia de prompts é sobre construir pontes e estradas.
+
+B. Engenharia de prompts é sobre elaborar os prompts certos para obter a saída desejada de um modelo de linguagem.
+
+C. Engenharia de prompts é sobre treinar um modelo para reconhecer padrões em dados.
+
+[Solução do quiz](./solution/solution-quiz.md)
+
+## Recursos para auto-estudo
+
+- [Engenharia de prompts](https://en.wikipedia.org/wiki/Prompt_engineering)
+- [Fundamentos de engenharia de prompts](https://github.com/microsoft/generative-ai-for-beginners/blob/main/04-prompt-engineering-fundamentals/README.md?WT.mc_id=academic-105485-koreyst)
+- [Engenharia de prompts avançada](https://github.com/microsoft/generative-ai-for-beginners/tree/main/05-advanced-prompts)
\ No newline at end of file
diff --git a/lessons/04-structured-output/translations/README.pt-br.md b/lessons/04-structured-output/translations/README.pt-br.md
new file mode 100644
index 0000000..5ca2103
--- /dev/null
+++ b/lessons/04-structured-output/translations/README.pt-br.md
@@ -0,0 +1,571 @@
+# Lição 4: Saída estruturada
+
+Neste capítulo você vai aprender: 
+
+- O que é _saída estruturada_ e como aproveitá-la eficazmente.
+- Como extrair informações de prompts e incorporá-las na saída.
+- Gerar diferentes tipos de formatos de saída, como JSON, para consumo fácil por serviços.
+
+## Configuração
+
+Se você ainda não configurou seu ambiente de desenvolvimento, veja como fazer: [Configure seu ambiente](/docs/setup/README.md).
+
+## Recursos relacionados
+
+Vale a pena reassistir ao vídeo sobre engenharia de prompts, pois ele estabelece a base para o que você está prestes a aprender neste capítulo.
+
+[![Assista a um vídeo curto sobre engenharia de prompts](https://img.youtube.com/vi/gQ6TlyxBmWs/0.jpg)](https://www.youtube.com/watch?v=gQ6TlyxBmWs&list=PLlrxD0HtieHi5ZpsHULPLxm839IrhmeDk&index=3)
+
+_Este vídeo oferece uma introdução para melhorar suas habilidades de "prompting", ensinando como dar instruções mais claras e eficazes à IA para obter melhores resultados._
+
+*🎥 Clique na imagem acima para assistir a um vídeo curto sobre engenharia de prompts*
+
+💼 Slides: [Engenharia de prompts](../../videos/slides/02-prompt-engineering.pptx)
+
+## Narrativa - Da frigideira para o fogo
+
+> [!NOTE]
+> _Nossa história até agora: Você, um engenheiro treinado em mecânica de 1860, tem estado em uma jornada através do tempo com Leonardo da Vinci. Você escapou dos soldados romanos — ou melhor, está em processo de escapar deles — e está desesperadamente procurando uma maneira de pousar o parafuso aéreo com segurança_.
+>
+> Veja a [Lição 1](../01-intro-to-genai/README.md) se quiser acompanhar a história desde o início. 
+
+> [!NOTE]
+> Embora recomendemos seguir a história (é divertido!), [clique aqui](#interaja-com-montezuma) se preferir ir direto para o conteúdo técnico.
+
+O vento chicoteia ao seu redor enquanto você e Leonardo da Vinci sobem em seu parafuso aéreo, a estrutura de madeira rangendo sob a tensão.
+
+**Você:** "Leonardo, precisamos encontrar uma saída dessa!" você grita sobre o rugido do vento.
+
+**Leonardo:** "Tenho fé na minha invenção, mas precisamos mais do que fé para escapar desses soldados."
+
+**Você:** "Esta pode ser nossa única chance," você diz, pressionando os mecanismos intrincados do besouro. Uma luz brilhante envolve vocês dois, e o mundo ao redor se desloca e distorce.
+
+### O Império Asteca
+
+A luz brilhante do Besouro do Tempo desaparece, e você se vê parado na base de uma pirâmide de pedra massiva. Ao olhar ao redor, você percebe que pousou no coração do Império Asteca.
+
+O parafuso aéreo repousa desajeitadamente sobre uma grande pedra intrincadamente esculpida, com marcações que parecem um calendário
+
+<div>
+  <img alt="Calendário asteca, Wikipedia" src="./assets/aztec.png" width="300" />
+</div>
+
+_Calendário asteca, Wikipedia_
+ 
+Leonardo da Vinci avança, seus olhos arregalados de admiração.
+
+**Leonardo:** "Incrível," ele murmura, passando os dedos sobre as esculturas. "Mas espero que isso não fosse importante." 
+
+Antes que você possa reagir, um grupo de soldados astecas se aproxima.
+
+<div>
+  <img src="./assets/meeting.png" alt="Encontro com astecas" width="300" />
+</div> 
+
+**Líder dos soldados:** "Quem são vocês e o que fizeram?" ele exige em Nahuatl.
+
+Você respira fundo, tentando acalmar seus nervos.
+
+**Você:** "Somos viajantes de uma terra distante," você começa, esperando que seu conhecimento de línguas antigas lhe sirva bem. "Isto é uma máquina voadora, um presente dos deuses para nos ajudar a chegar até vocês.
+
+Os olhos do guerreiro se arregalam de surpresa, mas ele permanece cauteloso.
+
+**Líder dos soldados:** "Vocês virão conosco para encontrar o governante Montezuma. Ele decidirá seu destino.
+
+Ao chegar ao topo da pirâmide, você é conduzido a uma grande câmara onde Montezuma, o governante do Império Asteca, está sentado em um trono adornado com ouro e penas.
+
+**Montezuma:** "Vocês afirmam ser viajantes de uma terra distante," Montezuma diz, sua voz calma mas autoritária. "E danificaram nosso calendário sagrado. Como pretendem compensar?"
+
+## Vamos jogar um jogo
+
+**Leonardo:** "Viemos em paz," ele diz, sua voz firme. "Buscamos conhecimento e compreensão. Permita-nos demonstrar o poder de nossa máquina e compartilhar nosso conhecimento com você." 
+
+**Montezuma:** "Muito bem. Proponho um jogo de [Patolli](#patolli). Se eu vencer a melhor de três partidas, vocês me darão seu dispositivo e me dirão como ele funciona. Se vocês vencerem, estarão livres para ir."
+
+<div>
+  <img src="./assets/game.png" alt="Jogando uma partida de Patolli" width="300" />
+</div>
+
+O jogo começa, e a sala fica em silêncio, exceto pelo som de feijões sendo rolados e peças se movendo pelo tabuleiro.
+
+Montezuma vence o primeiro jogo, sua habilidade e experiência evidentes. Leonardo estuda o tabuleiro cuidadosamente, sua mente trabalhando nas estratégias e probabilidades.
+
+O segundo jogo é uma disputa acirrada, mas Leonardo consegue garantir uma vitória, empatando o placar.
+
+**Leonardo:** "Mais um jogo," ele sussurra, George (Besouro do Tempo), precisamos vencer este, me dê os movimentos certos.
+
+**Besouro do Tempo:** Muito bem, calculando... Aqui está...
+
+Com um movimento final e decisivo, Leonardo vence o jogo. A sala explode em vivas e aplausos, os astecas claramente impressionados com sua habilidade e compostura. Montezuma, embora desapontado, acena em respeito.
+
+**Montezuma:** "Você venceu justamente," Montezuma diz, sua voz carregando uma nota de admiração. "Vocês estão livres para ir e podem manter seu dispositivo. Mas saibam que sempre serão bem-vindos aqui, caso desejem retornar." 
+
+**Besouro do Tempo:** Não vou dizer nada se você não disser, Leonardo ;)
+
+### Patolli
+
+> [!NOTE]
+> Patolli é um dos jogos mais antigos conhecidos nas Américas, jogado por culturas mesoamericanas pré-colombianas como os astecas. É uma mistura de estratégia e sorte.
+>
+> **Como o Patolli é jogado**: 
+> - **Tabuleiro e Peças**: Jogado em um tabuleiro em forma de X com um bloco central e quatro braços. Os jogadores usam cinco feijões pretos como dados, marcados em um lado.
+> - **Preparação**: Cada jogador escolhe seis marcadores (contas) de sua cor e os coloca fora do tabuleiro, além de contas de pontos para pontuação.
+> - **Jogabilidade**: Role os feijões para mover marcadores ao redor do tabuleiro e de volta ao início. Um lance de cinco move dez espaços. Pousar em certos espaços pode ganhar turnos, perder pontos ou capturar marcadores.
+>
+> **Envolvimento Asteca**: Amplamente jogado por nobres e plebeus, era um favorito na corte de Montezuma. Além de diversão, envolvia apostas de alto risco com apostas como cobertores, pedras preciosas ou até mesmo a liberdade.
+
+<div>
+  <img width="300" src="./assets/patolli.png" alt="Tabuleiro de Patolli" />
+</div>
+
+_Patolli - Wikipedia_
+
+## Interaja com Montezuma
+
+Se você quiser interagir com Montezuma, execute o aplicativo [Characters](/app/README.md). 
+
+> [!IMPORTANT]
+> Isso é inteiramente fictício; as respostas são geradas por IA.
+> [Aviso sobre IA Responsável](../../README.md#responsible-ai-disclaimer)
+
+<div>
+  <img src="./assets/montezuma.jpeg" alt="Montezuma" width="300" />
+</div>
+
+**Passos**:
+
+1. Inicie um [![GitHub Codespace](https://img.shields.io/badge/GitHub-Codespace-brightgreen)](https://codespaces.new/microsoft/generative-ai-with-javascript)
+2. Navegue até _/app_ na raiz do repositório.
+3. Localize o console e execute `npm install` seguido de `npm start`.
+4. Quando aparecer, selecione o botão "Open in Browser".
+5. Converse com Montezuma.
+
+Para uma explicação mais detalhada do aplicativo, consulte [Explicação detalhada do aplicativo](../01-intro-to-genai/README.md#talk-to-dinocrates).
+
+> [!NOTE]
+ > Se você estiver executando o projeto localmente em sua máquina, por favor revise o guia de Início Rápido para configurar um [token de acesso pessoal do GitHub](../../docs/setup/README.md#creating-a-personal-access-token-pat-for-github-model-access) e substitua a chave no código.
+
+## Saída Estruturada
+
+**Besouro do Tempo:** Quer saber como venci Montezuma?
+
+**Você:** Shhh, não tão alto, ainda estamos no Império Asteca.
+
+**Besouro do Tempo:** Ah certo, desculpe, sim, então saída estruturada foi como. Você pediu os movimentos certos e eu os dei a você de forma estruturada.
+
+Saída estruturada usa formatos de dados específicos para organizar informações claramente. Formatos comuns como JSON, XML e CSV facilitam o processamento e o uso dos dados pelos serviços.
+
+Modelos de IA generativa podem produzir dados em vários formatos. No entanto, a saída de texto não estruturado pode dificultar a extração de informações e sua entrega a outros serviços. A saída estruturada pode ajudar nesse aspecto.
+
+**Você:** Bem, você não é esperto? ;)
+
+**Besouro do Tempo:** Eu faço o meu melhor. :-)
+
+Outro benefício, mesmo para leitores humanos, é que dados estruturados são mais fáceis de ler e entender quando seguem um formato familiar.
+
+Vamos analisar alguns exemplos de entrada e ver como pedir formatos de saída específicos pode ajudar na extração de informações que facilitam o entendimento e o consumo.
+
+**Você:** Ok, não é como se tivéssemos outros planos, vamos ouvir.
+
+## Moldando a saída
+
+**Besouro do Tempo:** Vamos começar com um exemplo simples. Imagine que você é Leonardo da Vinci e está tentando criar ideias para invenções usando tecnologia do século XV. Você quer saber quais recursos você precisa e quanto esforço seria necessário para construir cada invenção. Veja como você pode pedir essas informações:
+
+**Leonardo:** Oh, eu gosto desse jogo, todos finjam que são eu!
+
+> Prompt: Gere ideias para invenções que posso construir usando tecnologia do século XV. Para cada invenção, especifique os recursos necessários e estime o esforço necessário para construí-la.
+
+```text
+Resultado:
+Claro! Aqui estão algumas ideias detalhadas para invenções que você pode construir usando tecnologia do século XV, junto com os recursos necessários e o esforço envolvido:
+
+### 1. Moinho Movido a Água
+**Recursos Necessários**:
+ - Fonte de água (rio ou córrego)
+ - Madeira para a roda d'água e estrutura do moinho
+ - Pedra para moagem
+ - Metal para engrenagens e eixos
+
+ **Esforço**:
+ - **Alto**: Requer habilidades significativas de construção e engenharia para construir a roda d'água, estrutura do moinho e mecanismo de moagem. Você também precisará garantir um fluxo constante de água.
+
+ ### 2. Astrolábio
+ **Recursos Necessários**:
+ - Latão ou outros metais para as placas e componentes
+ - Ferramentas de gravação
+ - Conhecimento matemático para medições precisas
+
+ **Esforço**:
+ - **Médio**: Envolve trabalho preciso em metal e gravação. Requer conhecimento de > astronomia e matemática para garantir precisão.
+ 
+ ### 3. Prensa de Impressão
+ **Recursos Necessários**:
+ - Madeira para a estrutura da prensa
+ - Metal para tipo móvel
+ - Tinta e papel
+
+ **Esforço**:
+ - **Alto**: Construir a prensa e criar tipo móvel requer habilidades avançadas de > carpintaria e trabalho em metal. Configurar o tipo e imprimir também envolve > trabalho meticuloso.
+
+Esta é uma resposta razoável, cada ideia está estruturada da mesma maneira e é fácil de entender. Mas e se você quisesse de outra forma? Para isso, você pode instruir como deseja no próprio texto ou até mesmo apresentar um modelo de saída. Vamos mostrar cada técnica.
+```
+
+**Leonardo:** Sim, vou totalmente roubar essa ideia de moinho movido a água, posso ver agora, um moinho à beira do rio, moendo grãos em farinha, é perfeito! Eu gosto dessa engenhoca. O que mais estou pensando, pequena engenhoca? Isso me tornará menos dependente de pessoas como Sforza.
+
+**Besouro do Tempo:** Claro, se você algum dia conseguir terminar um projeto, Leonardo. :-)
+
+**Leonardo:** Ei, estou trabalhando nisso!
+
+**Besouro do Tempo:** Vamos ver como você pode instruir o modelo a apresentar a saída de uma maneira mais estruturada.
+
+### Estruturando Seus Prompts para Melhor Saída
+
+**Besouro do Tempo:** Você pode melhorar seu prompt dizendo ao modelo como deseja que a saída seja estruturada. Por exemplo, você pode solicitar um formato de tabela com colunas de que precisa. Veja como você pode modificar o prompt:
+
+> Prompt: Gere ideias para invenções que possam ser construídas usando tecnologia do século XV. Para cada invenção, forneça os recursos necessários e estime o esforço necessário para construí-la. Apresente as informações em uma tabela com as seguintes colunas: Título, Descrição, Recursos Necessários e Esforço.
+
+```text
+Resultado: 
+
+| Título               | Descrição                                              | Recursos Necessários                                   | Esforço |
+|----------------------|--------------------------------------------------------|--------------------------------------------------------|---------|
+| Moinho Movido a Água | Um moinho impulsionado por uma roda d'água para moer grãos em farinha. | Fonte de água, madeira, pedra, metal para engrenagens e eixos | Alto    |
+| Astrolábio           | Um instrumento astronômico para resolver problemas relacionados ao tempo e posições de estrelas. | Latão ou outros metais, ferramentas de gravação, conhecimento matemático | Médio   |
+| Prensa de Impressão  | Uma prensa para reproduzir textos de forma mais eficiente do que cópia manuscrita. | Madeira, metal para tipo móvel, tinta, papel | Alto    |
+
+Desta vez você acaba com uma tabela que é mais fácil de ler e entender.
+```
+
+**Leonardo:** Eu gosto disso, certamente vai me poupar muito tempo.
+
+**Você:** Eu também.
+
+### Apresentando um modelo de saída
+
+Outra maneira de obter saída estruturada é apresentar um modelo de saída. Pode ser em qualquer formato, desde colunas até JSON, XML, CSV ou markdown.
+
+> Prompt: Gere ideias para invenções que possam ser construídas usando tecnologia do século XV. Para cada invenção, especifique os recursos necessários e estime o esforço necessário para construí-la. Apresente as informações usando o seguinte formato (use markdown como formato de saída):
+> 
+> Título: [Nome da Invenção]
+> Descrição: [Breve Explicação]
+> Recursos Necessários: [Lista de Materiais Necessários]
+> Esforço: [Dificuldade Estimada ou Trabalho Necessário]
+Gere ideias para invenções que posso construir dada a tecnologia do século XV, por favor, me informe para cada uma quais recursos eu preciso e quanto esforço haveria para construir cada invenção, para cada ideia apresente-a com o seguinte modelo de saída:
+
+```text
+
+**Resultado**:
+
+ Claro! Aqui estão algumas ideias para invenções que você pode construir usando tecnologia do século XV, apresentadas no formato solicitado:
+
+ ### 1. Moinho Movido a Água
+ **Título**: Moinho Movido a Água
+
+ **Descrição**: Um moinho impulsionado por uma roda d'água para moer grãos em farinha.
+
+ **Recursos Necessários**: Fonte de água, madeira, pedra, metal para engrenagens e eixos.
+ 
+ **Esforço**: Alto - Requer habilidades significativas de construção e engenharia para construir a roda d'água, estrutura do moinho e mecanismo de moagem. Garantir um fluxo constante de água também é necessário.
+
+ ### 2. Astrolábio
+ **Título**: Astrolábio
+
+ **Descrição**: Um instrumento astronômico para resolver problemas relacionados ao tempo e posições de estrelas.
+ 
+ **Recursos Necessários**: Latão ou outros metais, ferramentas de gravação, conhecimento matemático.
+ 
+ **Esforço**: Médio - Envolve trabalho preciso em metal e gravação. Requer conhecimento de astronomia e matemática para garantir precisão.
+ 
+ ### 3. Prensa de Impressão
+ **Título**: Prensa de Impressão
+ 
+ **Descrição**: Uma prensa para reproduzir textos de forma mais eficiente do que cópia manuscrita.
+ 
+ **Recursos Necessários**: Madeira, metal para tipo móvel, tinta, papel.
+ 
+ **Esforço**: Alto - Construir a prensa e criar tipo móvel requer habilidades avançadas de carpintaria e trabalho em metal. Configurar o tipo e imprimir também envolve trabalho meticuloso.
+ 
+ ### 4. Relógio Mecânico
+ **Título**: Relógio Mecânico
+
+ **Descrição**: Um relógio usando engrenagens e pesos para marcar o tempo.
+
+ **Recursos Necessários**: Metal para engrenagens, molas, pesos, madeira para caixa, ferramentas precisas.
+
+ **Esforço**: Muito Alto - Requer trabalho intrincado em metal e uma compreensão profunda de mecânica. Construir um relógio confiável envolve montagem precisa e calibração.
+```
+
+**Leonardo:** Isso é ótimo, mas quem é Jason?
+
+**Besouro do Tempo:** JSON, Leonardo, JSON. É um formato estruturado que é fácil de consumir por serviços ou aplicativos.
+
+**Leonardo:** Foi o que eu disse, Jason.
+
+**Besouro do Tempo:** _Suspiro_.
+
+Como você pode ver, a saída é estruturada de acordo com as especificações no modelo de saída. Isso facilita a leitura e a compreensão e também cria uma saída repetível que pode ser facilmente consumida por outros serviços ou aplicações.
+
+Claro que um serviço se beneficia de uma saída ainda mais estruturada, como JSON, XML ou CSV, então vamos ver como você pode pedir isso.
+
+### Usando saída estruturada com formatos como JSON, XML ou CSV
+
+**Besouro do Tempo:** Até agora, você viu como pode controlar a estrutura de saída instruindo o modelo no prompt. Você até forneceu um modelo de saída. Vamos levar essa ideia um passo adiante e ver como ela pode ser aplicada a formatos de saída mais estruturados como JSON e outros.
+
+Modifique o prompt adequadamente para solicitar uma saída JSON:
+
+> **Prompt**: Gere ideias para invenções que posso construir dada a tecnologia do século XV, por favor, me informe para cada uma quais recursos eu preciso e quanto esforço haveria para construir cada invenção, para cada ideia apresente em formato json, inclua propriedades para título, descrição, recursos necessários, esforço
+> 
+> Exemplo da saída JSON:
+> [
+>   {
+>     "título": "",
+>     "descrição": ".",
+>     "recursos_necessários": "",
+>     "esforço": ""
+>   }
+> ]
+
+```text
+> Resposta:
+Claro! Aqui estão algumas ideias para invenções que você pode construir usando tecnologia do século XV, apresentadas em formato JSON:
+
+```json
+[
+  {
+    "título": "Moinho Movido a Água",
+    "descrição": "Um moinho impulsionado por uma roda d'água para moer grãos em farinha.",
+    "recursos_necessários": "Fonte de água, madeira, pedra, metal para engrenagens e eixos",
+    "esforço": "Alto - Requer habilidades significativas de construção e engenharia para construir a roda d'água, estrutura do moinho e mecanismo de moagem. Garantir um fluxo constante de água também é necessário."
+  },
+  {
+    "título": "Astrolábio",
+    "descrição": "Um instrumento astronômico para resolver problemas relacionados ao tempo e posições de estrelas.",
+    "recursos_necessários": "Latão ou outros metais, ferramentas de gravação, conhecimento matemático",
+    "esforço": "Médio - Envolve trabalho preciso em metal e gravação. Requer conhecimento de astronomia e matemática para garantir precisão."
+  },
+  {
+    "título": "Prensa de Impressão",
+    "descrição": "Uma prensa para reproduzir textos de forma mais eficiente do que cópia manuscrita.",
+    "recursos_necessários": "Madeira, metal para tipo móvel, tinta, papel",
+    "esforço": "Alto - Construir a prensa e criar tipo móvel requer habilidades avançadas de carpintaria e trabalho em metal. Configurar o tipo e imprimir também envolve trabalho meticuloso."
+  },
+  {
+    "título": "Relógio Mecânico",
+    "descrição": "Um relógio usando engrenagens e pesos para marcar o tempo.",
+    "recursos_necessários": "Metal para engrenagens, molas, pesos, madeira para caixa, ferramentas precisas",
+    "esforço": "Muito Alto - Requer trabalho intrincado em metal e uma compreensão profunda de mecânica. Construir um relógio confiável envolve montagem precisa e calibração."
+  },
+  {
+    "título": "Moinho de Vento",
+    "descrição": "Um moinho impulsionado pelo vento para moer grãos ou bombear água.",
+    "recursos_necessários": "Madeira, metal para engrenagens e eixos, pedra para a base",
+    "esforço": "Alto - Construir um moinho de vento envolve habilidades significativas de carpintaria e engenharia. Você precisará projetar e construir as pás, torre e mecanismos internos."
+  },
+  {
+    "título": "Esfera Armilar",
+    "descrição": "Um modelo da esfera celeste com anéis representando os grandes círculos.",
+    "recursos_necessários": "Metal para anéis e suporte, ferramentas para dobrar e unir metal, conhecimento de astronomia",
+    "esforço": "Médio - Envolve trabalho preciso em metal e montagem. Requer compreensão dos movimentos celestes para posicionar os anéis com precisão."
+  },
+  {
+    "título": "Engenho de Cerco (Trebuchet ou Catapulta)",
+    "descrição": "Um trebuchet ou catapulta para demonstrar princípios de mecânica e física.",
+    "recursos_necessários": "Madeira, corda, metal para eixos e contrapesos",
+    "esforço": "Médio a Alto - Construir um engenho de cerco funcional requer carpintaria e compreensão de mecânica. Testar e ajustar para desempenho ideal pode demorar."
+  },
+  {
+    "título": "Aparelho de Destilação",
+    "descrição": "Um aparato para purificar líquidos através de destilação.",
+    "recursos_necessários": "Vidro ou metal para frasco e condensador, fonte de calor, tubulação",
+    "esforço": "Médio - Requer habilidades básicas de sopro de vidro ou trabalho em metal. Configurar e manter as temperaturas corretas para destilação envolve monitoramento cuidadoso."
+  },
+  {
+    "título": "Bússola",
+    "descrição": "Uma bússola magnética para navegação.",
+    "recursos_necessários": "Agulha magnetizada, caixa não magnética, água ou óleo para amortecimento",
+    "esforço": "Baixo - Construir uma bússola é relativamente simples. O principal desafio é magnetizar a agulha e garantir que esteja equilibrada e livre para girar."
+  },
+  {
+    "título": "Aqueduto",
+    "descrição": "Um sistema para transportar água usando gravidade.",
+    "recursos_necessários": "Pedra ou tijolo, argamassa, ferramentas para cortar e moldar pedra",
+    "esforço": "Muito Alto - Construir um aqueduto envolve extenso trabalho de construção e engenharia. Garantir um gradiente consistente para o fluxo de água requer planejamento e execução precisos."
+  }
+]
+```
+
+**Besouro do Tempo:** Este tipo de saída estruturada pode ser enviado para outro serviço ou aplicativo que possa consumir dados JSON.
+
+## Extraindo dados de prompts
+
+**Besouro do Tempo:** Imagine que você está construindo um chatbot que ajuda os usuários a encontrar informações sobre viagens para reservar. Você deseja extrair detalhes-chave da entrada do usuário para fornecer respostas relevantes. Digamos que você tenha uma descrição como a seguinte: 
+
+> Digite para onde você gostaria de ir, quando deseja viajar e seu orçamento.
+
+Como seria um prompt que extrai as informações? 
+
+> Prompt: Extraia as seguintes informações do prompt de um usuário: localização, quando, orçamento, moeda, responda com os dados extraídos em formato JSON.
+>
+> Prompt do usuário: Eu quero ir para a Grécia em junho, meu orçamento é de 800 euros.
+
+
+> Resposta:
+
+```json
+{
+  "localização": "Grécia",
+  "quando": "junho",
+  "orçamento": 800,
+  "moeda": "euros"
+}
+```
+
+**Leonardo:** George (Besouro do Tempo) não para de falar, não é?
+
+**Você:** Vamos ver se consigo encontrar o interruptor.
+
+**Besouro do Tempo:** Vamos tentar isso com um prompt semelhante, vamos variar um pouco a entrada do usuário para garantir que o modelo esteja fazendo a coisa certa.
+
+> Prompt: Extraia as seguintes informações do prompt de um usuário: localização, quando, orçamento, moeda. Responda com os dados extraídos em formato JSON. Prompt do usuário: Indo para os EUA, máximo 1200 dólares, talvez janeiro.
+>
+> Resposta:
+
+```json
+{
+  "localização": "EUA",
+  "quando": "janeiro",
+  "orçamento": 1200,
+  "moeda": "dólares"
+}
+```
+
+O que você pode fazer como desenvolvedor é criar um modelo:
+
+```text
+Extraia as seguintes informações do prompt de um usuário: localização, quando, orçamento, moeda, responda com os dados extraídos em formato JSON, prompt do usuário: {entrada_do_usuário}.
+```
+
+**Você:** Encontrei, toma isso George!
+
+**Besouro do Tempo:** _Desligando_.
+
+**Leonardo:** Paz e silêncio finalmente.
+
+**Besouro do Tempo:** _Iniciando reinicialização de emergência_. Onde eu estava mesmo? Ah sim.
+
+**Besouro do Tempo:** Para chatbots, este é um recurso muito poderoso, pois permite extrair informações da entrada do usuário. E se o usuário pedir todo tipo de coisas? Você pode criar um modelo onde descreve habilidades, coisas que seu chatbot pode fazer e quais parâmetros ele precisa. Veja como você pode fazer isso:
+
+```text
+Aqui estão algumas habilidades que você tem:
+
+habilidade: reservar_viagem
+parâmetros: localização, quando, orçamento, moeda
+
+habilidade: encontrar_hotel
+parâmetros: localização, check_in, check_out, orçamento
+
+habilidade: pedir_comida
+parâmetros: culinária, endereço_entrega, método_pagamento
+
+Descubra qual habilidade usar com base no prompt de um usuário e extraia os parâmetros necessários, responda com os dados extraídos em formato JSON com colunas habilidade, parâmetros, dados_extraídos
+
+{entrada_do_usuário}
+```
+
+Vamos experimentar as seguintes entradas do usuário:
+
+> Prompt: Indo para os EUA, máximo 1200 dólares, talvez janeiro.
+> Resultado:
+
+```json
+{
+  "habilidade": "reservar_viagem",
+  "parâmetros": ["localização", "quando", "orçamento", "moeda"],
+  "dados_extraídos": {
+    "localização": "EUA",
+    "quando": "janeiro",
+    "orçamento": 1200,
+    "moeda": "dólares"
+  }
+}
+```
+
+> Prompt: Eu quero reservar um lugar para ficar em Nova York
+> Resultado: 
+
+```json
+{
+  "habilidade": "encontrar_hotel",
+  "parâmetros": ["localização", "check_in", "check_out", "orçamento"],
+  "dados_extraídos": {
+    "localização": "Nova York",
+    "check_in": null,
+    "check_out": null,
+    "orçamento": null
+  }
+}
+```
+
+Esta combinação de apresentar habilidades e parâmetros e extrair dados de prompts também é conhecida como _chamada de ferramenta_ ou _chamada de função_. Uma resposta como esta do seu modelo facilita para você, como desenvolvedor, entender o que o usuário deseja e como chamar uma função correspondente para atender à solicitação do usuário.
+
+**Você:** Informações muito úteis, George!
+
+## Tarefa - Reparar o parafuso aéreo
+
+**Besouro do Tempo:** Preciso da atenção de vocês dois, temos um problema. O parafuso aéreo sofreu alguns danos durante a fuga dos soldados romanos e o pouso no Império Asteca. A máquina de Leonardo da Vinci é bastante sensível e requer uma entrada muito específica para repará-la. Você precisa fornecer as informações necessárias ao seu Besouro do Tempo (Assistente de IA) para ajudá-lo a reparar o parafuso aéreo.
+
+**Leonardo:** Então, consegui consertar os danos no parafuso aéreo, mas agora ele precisa de uma sequência de inicialização: esquerda, esquerda, cima, direita.
+
+**Você:** Parece bastante fácil, apenas esse texto?
+
+**Leonardo:** Sim, mas é especial, precisa ser espelhado, é assim que escrevo todos os meus textos. E claro, uso uma cifra de César com um deslocamento de 3 porque sou italiano. :-)
+
+**Você:** Sim, você não poderia simplesmente digitar então?
+
+**Leonardo:** Eu poderia, mas estou intrigado para ver se você e o Besouro do Tempo conseguem fazer isso.
+
+**Você:** Tudo bem.
+
+**Instrução:** Escreva um prompt que solicite a sequência de inicialização para o parafuso aéreo, o texto deve ser espelhado e codificado com uma cifra de César com um deslocamento de 3. Responda com o texto codificado.
+
+Veja o [aplicativo de exemplo](./sample-app) para começar com o código. Ele contém um projeto Node.js com todas as dependências necessárias.
+
+> NOTA: Se você ainda não criou um Codespace, faça isso agora, pois precisará dele para que a comunicação com IA no aplicativo de exemplo funcione.
+>
+> Veja a seção _Opção 1: Criando um GitHub Codespace*_*_ do documento [Configure seu ambiente](/docs/setup/README.md).
+
+## Solução
+
+[Solução](./solution/solution.md)
+
+## Desafio
+
+Adapte o exemplo de reserva de viagem, fornecendo habilidades e extraindo parâmetros para um domínio de sua escolha. Escreva um prompt que solicite uma entrada do usuário e então extraia as informações necessárias para atender à solicitação do usuário. Responda com os dados extraídos em formato JSON com colunas habilidade, parâmetros e dados_extraídos.
+
+Determine também a habilidade com base na entrada do usuário.
+
+## Resumo
+
+Neste capítulo, você aprendeu sobre saída estruturada e como ela pode ser usada para apresentar informações de maneira estruturada.
+
+Você explorou diferentes maneiras de moldar a saída, incluindo instruir o modelo no prompt, apresentar um modelo de saída e usar formatos como JSON, XML ou CSV.
+
+Além disso, você aprendeu como extrair dados de prompts e apresentá-los em um formato estruturado.
+
+Ao aproveitar efetivamente a saída estruturada, você pode facilitar a compreensão e o consumo de informações geradas por modelos de IA Generativa.
+
+## Verificação de conhecimento
+
+**Pergunta**: Para que é usada a saída estruturada? Selecione todas as opções aplicáveis.
+
+A. Apresentar informações de maneira estruturada.
+
+B. Extrair dados de prompts.
+
+C. Gerar texto não estruturado.
+
+[Solução do quiz](./solution/solution-quiz.md)
+
+## Recursos para auto-estudo
+
+- [Série de vídeos sobre IA Generativa com JavaScript](https://aka.ms/genai-js)
\ No newline at end of file
diff --git a/lessons/05-rag/translations/README.pt-br.md b/lessons/05-rag/translations/README.pt-br.md
new file mode 100644
index 0000000..0f53b5c
--- /dev/null
+++ b/lessons/05-rag/translations/README.pt-br.md
@@ -0,0 +1,351 @@
+# Lição 5: Converse com seus dados usando Geração Aumentada por Recuperação (RAG)
+
+Neste capítulo você vai aprender:
+
+- Os fundamentos da Geração Aumentada por Recuperação (RAG) e como ela pode ser usada para melhorar as respostas dos modelos de IA generativa.
+- Como integrar fontes de dados externas em sua aplicação de IA.
+- Como aproveitar seus dados para melhorar a relevância e precisão do conteúdo gerado por IA.
+
+## Configuração
+
+Se você ainda não configurou seu ambiente de desenvolvimento, veja como fazer: [Configure seu ambiente](/docs/setup/README.md).
+
+## Recursos relacionados
+
+[![Assista a um vídeo curto sobre RAG](https://img.youtube.com/vi/xkFOmx5yxIA/0.jpg)](https://www.youtube.com/watch?v=xkFOmx5yxIA&list=PLlrxD0HtieHi5ZpsHULPLxm839IrhmeDk&index=4)
+
+_Este vídeo explica a Geração Aumentada por Recuperação (RAG), um método que ajuda a IA a usar seu conteúdo junto com seus dados de treinamento para obter melhores resultados._
+
+*🎥 Clique na imagem acima para assistir a um vídeo curto sobre geração aumentada por recuperação, RAG*
+
+💼 Slides: [Geração aumentada por recuperação, RAG](../../videos/slides/03-rag.pptx)
+
+## Narrativa - Gênesis
+
+> [!NOTE] 
+> _Nossa história até agora. Você é um mecânico da Londres dos anos 1860. Você estava trabalhando em seu autômato e recebeu uma carta de Charles Babbage que acabou levando você a uma biblioteca onde você pegou um dispositivo de viagem no tempo. Durante suas viagens no tempo, você acabou em Florença, onde conheceu Leonardo Da Vinci. Você também foi ao império Asteca e é aqui que a história continua._
+>
+> Veja a [Lição 1](../01-intro-to-genai/README.md) se quiser acompanhar a história desde o início. 
+
+> [!NOTE] 
+> Embora recomendemos seguir a história (é divertido!), [clique aqui](#interaja-com-ada-lovelace) se preferir ir direto para o conteúdo técnico.
+
+**Você**: "Leonardo, é hora de ir," você disse, pressionando o botão. O dispositivo começou a funcionar, e uma voz mecânica ecoou: "É hora de ir para casa, é hora da 'gênese'."
+
+**Leonardo:** "Gênesis? Che cosa significa?" Leonardo perguntou, confuso. Antes que você pudesse responder, o mundo se dissolveu em um borrão de cores e sons, o templo desaparecendo enquanto vocês eram puxados através do tempo.
+
+Vocês pousam no jardim, é tarde da noite com uma névoa espessa e luzes sinistras piscando à distância. A mansão se ergue diante de vocês. Leonardo olha ao redor, seus olhos arregalados de admiração.
+
+<div>
+  <img src="./assets/mansion.jpeg" alt="Antiga mansão mostrada em uma névoa densa" width="300">
+</div>
+
+### Fugindo dos Cães
+
+Você ouve latidos e o som de cães correndo em sua direção. Você se vira para Leonardo: "Precisamos entrar, agora!"
+
+<div>
+  <img src="./assets/dogs.jpeg" alt="Fugindo dos cães" width="300">
+</div>
+
+Quando você chega à porta da mansão, ela se abre e um par de atendentes sai apressadamente. Depois de avaliá-los, eles fazem sinal para que vocês os sigam.
+
+Você se encontra cara a cara com Ada Lovelace, seus olhos brilhando de curiosidade.
+
+### Conhecendo Ada e Charles
+
+**Ada:** "Ah, já era hora de chegarem," ela disse calorosamente. "Precisamos que vocês façam um serviço."
+
+**Você:** "Já era hora", vocês continuam dizendo isso. Dinócrates disse o mesmo, mas não tenho certeza do que quer dizer?
+
+**Ada:** Silêncio, não há tempo para isso agora, precisamos falar sobre o dispositivo que você está segurando. Charles, explique a eles...
+
+**Você:** Mas...
+
+<div>
+  <img src="./assets/ada.jpeg" alt="Ada Lovelace e Charles Babbage trabalhando em um dispositivo" width="300">
+</div>
+
+Charles Babbage se aproxima, examinando o Besouro do Tempo em sua mão. "Este dispositivo é notável, mas está um pouco defeituoso, não está? Você deve ter notado, tenho certeza."
+
+Leonardo assentiu: "Sì, tem se comportado de maneira estranha."
+
+**Ada:** O dispositivo não está totalmente pronto, precisamos dar a ele mais capacidades. Precisamos torná-lo mais inteligente, mais consciente do mundo ao seu redor. A ideia é que ele seja capaz de recuperar informações de diferentes períodos de tempo e usá-las para gerar respostas precisas e relevantes. Pode nos ajudar com isso?
+
+**Você:** Claro, parece que precisamos _aumentar_ as respostas do dispositivo com dados, faz sentido.
+
+**Ada:** Vamos falar sobre um conceito que eu gostaria de chamar de RAG, ou Geração Aumentada por Recuperação.
+
+## Interaja com Ada Lovelace
+
+Se você quiser interagir com Ada, execute o aplicativo [Characters](/app/README.md). 
+
+> [!IMPORTANT]
+> Isso é inteiramente fictício; as respostas são geradas por IA.
+> [Aviso sobre IA Responsável](../../README.md#responsible-ai-disclaimer)
+
+<div>
+  <img src="./assets/ada-2.jpeg" alt="Ada Lovelace" width="300">
+</div>
+
+**Passos**:
+
+1. Inicie um [![GitHub Codespace](https://img.shields.io/badge/GitHub-Codespace-brightgreen)](https://codespaces.new/microsoft/generative-ai-with-javascript)
+2. Navegue até _/app_ na raiz do repositório.
+3. Localize o console e execute `npm install` seguido de `npm start`.
+4. Quando aparecer, selecione o botão "Open in Browser".
+5. Converse com Ada.
+
+Para uma explicação mais detalhada do aplicativo, consulte [Explicação detalhada do aplicativo](../01-intro-to-genai/README.md#interact-with-dinocrates).
+
+> [!NOTE]
+ > Se você estiver executando o projeto localmente em sua máquina, por favor revise o guia de Início Rápido para configurar um [token de acesso pessoal do GitHub](../../docs/setup/README.md#creating-a-personal-access-token-pat-for-github-model-access) e substitua a chave no código.
+
+## Desafios conhecidos com grandes modelos de linguagem, LLMs
+
+**Ada:** Vamos começar discutindo a IA que usaremos para alimentar o dispositivo. Vamos confiar em "modelos de IA" emparelhados com um sistema de recuperação de dados para melhorar a qualidade das respostas.
+
+Primeiro, você precisa abordar alguns desafios antes de mergulhar nos detalhes do RAG. Esses modelos, treinados em vastos dados de texto, podem produzir respostas relevantes e corretas. Mas, como qualquer fonte de dados, sua saída pode ser imprecisa, incompleta ou enganosa devido a vários fatores.
+
+- **Fontes desatualizadas:** Os dados usados para treinar o modelo podem estar desatualizados e não mais precisos.
+- **Informações erradas ou imprecisas:** As fontes usadas para treinar o modelo podem conter informações incorretas ou enganosas, como notícias falsas ou opiniões tendenciosas.
+- **Fontes não autoritativas:** O modelo pode não ser capaz de distinguir entre fontes autoritativas e não autoritativas em seus dados de treinamento, levando a informações não confiáveis.
+
+Isso torna difícil dizer se as informações geradas por um LLM estão corretas ou não. É aqui que o RAG entra.
+
+**Você:** Então eu preciso garantir que o dispositivo possa fornecer informações precisas, mesmo quando não tem certeza sobre a resposta?
+
+**Ada:** Sim, essa é a ideia. Ao combinar os pontos fortes dos métodos baseados em recuperação e dos modelos generativos, obtemos um sistema de IA melhor.
+
+## Geração Aumentada por Recuperação, conceitos fundamentais do RAG
+
+**Ada:** Ah sim, hora de discutir especificamente o RAG. Vamos começar com alguns fundamentos:
+
+Geração Aumentada por Recuperação (RAG) é uma técnica poderosa que combina os pontos fortes de duas abordagens diferentes no processamento de linguagem natural: métodos baseados em recuperação e modelos generativos. Essa abordagem híbrida permite a geração de respostas que são contextualmente relevantes e ricas em conteúdo, para ajudar a aliviar alguns dos desafios conhecidos com os LLMs.
+
+Em sua essência, o RAG envolve dois componentes principais: um **recuperador** e um **gerador**.
+
+- **O recuperador:** é responsável por encontrar informações relevantes de fontes de dados externas que podem ser usadas para melhorar as respostas geradas por IA, como um mecanismo de busca. Essas informações podem estar na forma de texto, imagens ou qualquer outro tipo de dados relevantes para o contexto da conversa, embora o texto seja o tipo de dados mais comum utilizado.
+
+- **O gerador:** toma as informações recuperadas e as usa para gerar uma resposta contextualmente relevante e informativa.
+
+Aqui está um esquema ilustrando como um sistema RAG funciona:
+
+![Esquema de um sistema RAG](assets/rag.png)
+
+1. **Entrada do usuário:** O usuário faz uma pergunta.
+2. **Recuperador:** O componente recuperador busca informações relevantes usando uma ou mais bases de conhecimento.
+3. **Prompt aumentado:** As informações recuperadas são combinadas com a pergunta do usuário e o contexto, para criar um prompt aumentado.
+4. **Gerador:** O LLM usa o prompt aumentado para gerar uma resposta.
+
+Essa combinação permite respostas mais precisas e relevantes, usando dados que você fornece em vez de depender dos dados de treinamento do modelo.
+
+**Ada:** Perguntas?
+
+**Você:** Então o recuperador encontra as informações e o gerador as usa para gerar uma resposta?
+
+**Ada:** Exatamente, você está pegando o jeito.
+
+## Integrando fontes de dados externas
+
+**Ada:** Agora que cobrimos os fundamentos do RAG, vamos falar sobre como você pode integrar fontes de dados externas em sua aplicação de IA.
+
+A integração de fontes de dados externas em sua aplicação de IA pode ser feita de várias maneiras, dependendo do tipo de dados que você deseja usar e da complexidade do mecanismo de recuperação. Aqui estão alguns métodos comuns:
+
+- **APIs:** Muitas fontes de dados externas fornecem APIs que permitem acessar seus dados programaticamente. Você pode usar essas APIs para recuperar informações em tempo real e usá-las para melhorar as respostas geradas por IA.
+
+- **Bancos de dados:** Se você tem uma grande quantidade de dados que deseja usar para recuperação, pode armazená-los em um banco de dados e consultá-los conforme necessário. Isso pode ser útil para dados estruturados que precisam ser acessados rapidamente.
+
+Uma vez que você tenha decidido sobre um método para integrar fontes de dados externas, também pode precisar considerar como pré-processar e formatar os dados para que possam ser facilmente usados pelo modelo de IA. Isso pode envolver a limpeza dos dados, convertê-los para um formato adequado (como texto simples ou Markdown), ou dividi-los em pedaços menores para facilitar a recuperação.
+
+> [!NOTE]
+> Ao integrar fontes de dados externas em sua aplicação de IA, é importante considerar as implicações de privacidade e segurança de acessar e armazenar dados. Certifique-se de ter as permissões e salvaguardas necessárias para proteger os dados e cumprir com quaisquer regulamentos relevantes.
+
+Se você estiver usando um banco de dados, também deve pensar em como deseja *pesquisar seus dados* para recuperar as informações mais relevantes. Isso pode ser feito usando pesquisa por palavras-chave, pesquisa de texto completo ou técnicas mais avançadas como pesquisa semântica ou pesquisa vetorial que podem precisar de indexação específica. Cobriremos técnicas avançadas de pesquisa em uma lição futura.
+
+**Você**: Pode explicar termos como API e Bancos de Dados em termos mais do século XIX?
+
+**Ada**: Claro, uma API é como um mensageiro que entrega uma mensagem de um lugar para outro, e um banco de dados é como uma biblioteca onde você guarda todos os seus livros.
+
+**Você**: Ah, entendo, faz sentido.
+
+## Aumentando o prompt
+
+**Ada:** Você ainda está me acompanhando? Ótimo, vamos para o próximo passo, vamos tentar melhorar o prompt enviado ao modelo de IA.
+
+**Ada:** Uma vez que você tenha configurado uma forma de extrair informações dos seus dados, você pode adicioná-las ao prompt do modelo de IA. Basta misturar as informações recuperadas no texto de entrada com algum contexto adicional ou orientação para direcionar a resposta da IA.
+
+Por exemplo, se você estiver construindo um aplicativo para responder perguntas sobre carros, poderia ter um prompt como o seguinte:
+
+```text
+
+## Instruções
+Responda perguntas sobre carros usando apenas as fontes abaixo.
+Se não houver dados suficientes nas fontes fornecidas, diga que você não sabe.
+Seja breve e direto ao ponto.
+
+## Fontes
+<insira aqui as informações recuperadas>
+
+## Pergunta
+<insira aqui a pergunta>
+```
+
+Ao fornecer ao modelo de IA contexto e informações adicionais, você pode ajudar a orientar o processo de geração e garantir que as respostas sejam precisas e relevantes para o tema em questão.
+
+> [!TIP]
+> Note esta parte do prompt: `Se não houver dados suficientes nas fontes fornecidas, diga que você não sabe.`. Isso é importante para evitar que a IA gere informações incorretas quando não há dados suficientes para fornecer uma resposta confiável. Esta técnica é chamada de *rota de fuga* e é uma boa prática para garantir a qualidade do conteúdo gerado.
+
+RAG pode ser considerado como uma forma avançada de *engenharia de prompts*.
+
+### Exemplo de código
+
+**Ada:** A prática leva à perfeição, então vamos aplicar o que aprendemos com um exemplo. Vamos construir um sistema simples de recuperação em um aplicativo JavaScript usando um arquivo [CSV](https://fr.wikipedia.org/wiki/Comma-separated_values) de dados de carros híbridos e um algoritmo de busca básico para extrair informações relevantes com base na pergunta de um usuário.
+
+```javascript
+// Este exemplo demonstra como usar a Geração Aumentada por Recuperação (RAG)
+// para responder perguntas baseadas em um conjunto de dados de carros híbridos.
+// O código abaixo lê o arquivo CSV, busca correspondências para a pergunta do usuário,
+// e então gera uma resposta baseada nas informações encontradas.
+
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+import process from "node:process";
+import fs from "node:fs";
+import { OpenAI } from "openai";
+
+// Muda o diretório de trabalho atual para o diretório do script
+const __dirname = dirname(fileURLToPath(import.meta.url));
+process.chdir(__dirname);
+
+// 1. Faça uma pergunta sobre carros híbridos
+// -----------------------------------
+
+const question = `qual é o prius mais rápido`;
+
+// 2. Componente recuperador: pesquisa os dados por informações relevantes
+// ----------------------------------------------------------------
+
+// Carrega dados CSV como um array de objetos
+const rows = fs.readFileSync("./hybrid.csv", "utf8").split("\n");
+const columns = rows[0].split(",");
+
+// Pesquisa os dados usando uma busca muito ingênua
+const words = question
+  .toLowerCase()
+  .replaceAll(/[.?!()'":,]/g, "")
+  .split(" ")
+  .filter((word) => word.length > 2);
+const matches = rows.slice(1).filter((row) => words.some((word) => row.toLowerCase().includes(word)));
+
+// Formata como uma tabela markdown, já que modelos de linguagem entendem markdown
+const table =
+  `| ${columns.join(" | ")} |\n` +
+  `|${columns.map(() => "---").join(" | ")}|\n` +
+  matches.map((row) => `| ${row.replaceAll(",", " | ")} |\n`).join("");
+
+console.log(`Encontradas ${matches.length} correspondências:`);
+console.log(table);
+
+// 3. Aumento de contexto: cria um prompt combinado com os resultados da pesquisa
+// --------------------------------------------------------------------------
+
+const augmentedPrompt = `
+## Instruções
+Responda perguntas sobre um período de tempo ou personagens desse período usando apenas as fontes abaixo.
+Se não houver dados suficientes nas fontes fornecidas, diga que você não sabe.
+Seja breve e direto ao ponto.
+
+## Fontes
+${table}
+
+## Pergunta
+${question}
+`;
+
+// 4. Componente gerador: usa os resultados da pesquisa para gerar uma resposta
+// ---------------------------------------------------------------------
+
+const openai = new OpenAI({
+  baseURL: "https://models.inference.ai.azure.com",
+  apiKey: process.env.GITHUB_TOKEN,
+});
+
+const chunks = await openai.chat.completions.create({
+  model: "gpt-4o-mini",
+  messages: [{ role: "user", content: augmentedPrompt }],
+  stream: true,
+});
+
+console.log(`Resposta para "${question}":`);
+
+for await (const chunk of chunks) {
+  process.stdout.write(chunk.choices[0].delta.content ?? "");
+}
+```
+
+Você pode encontrar este código no arquivo [`example/rag-cars.js`](./example/rag-cars.js) junto com o arquivo [`hybrid.csv`](./example/hybrid.csv) contendo os dados usados para a recuperação.
+
+**Ada:** Uma vez que você execute este código, você deve ver os dados encontrados no arquivo CSV pelo recuperador, formatados como uma tabela markdown, seguidos pela resposta gerada pela IA para a pergunta. Tente mudar a pergunta para ver como os dados recuperados e a resposta mudam. Você também pode tentar fazer perguntas sobre tópicos não relacionados para ver como o modelo de IA lida com eles.
+
+```text
+Exemplo da saída:
+
+Encontradas 1 correspondências:
+| Pessoa | Período de Tempo | Descrição |
+|---|---|---|
+| Leonardo Da Vinci | Século XV | Polímata italiano conhecido por sua arte e invenções. |
+| Isaac Newton | Século XVII | Matemático e físico inglês que formulou as leis do movimento e da gravitação universal. |
+```
+
+**Você:** Isso é ótimo, posso ver como isso pode ser útil ao usar o dispositivo, ou melhor, como já foi ou será útil, viagem no tempo é confusa *suspiro*.
+
+**Ada:** Calma, você está indo muito bem. Vamos passar para o próximo passo.
+
+## Tarefa - Ajudando Ada e Charles
+
+Tendo aprendido sobre RAG, você está agora pronto para ajudar Ada e Charles com seu dispositivo. No entanto, ao inspecionar mais de perto, o dispositivo parece familiar.
+
+**Você:** Besouro do Tempo, você sabe o que é isso?
+
+**Besouro do Tempo:** Claro, sou eu, ou serei. Estou faltando algumas peças, pensando bem, estou faltando muitas peças, nem tenho uma casca ainda.
+
+**Ada:** O Besouro do Tempo é um dispositivo que permite viajar através do tempo e do espaço, isto é, uma vez que conseguirmos fazê-lo funcionar corretamente. Como eu estava dizendo, precisamos adicionar um novo recurso a ele, um módulo de geração aumentada por recuperação (RAG). Isso nos ajudará a recuperar informações e o contexto necessário de diferentes períodos de tempo enquanto você viaja. Queremos garantir que consultemos todo tipo de fontes, a Wikipedia é um bom começo.
+
+**Você:** O que você precisa que eu faça?
+
+**Ada:** Aqui está um código de exemplo que recupera informações de texto sobre Tim Berners-Lee da Wikipedia, Tim será muito importante um dia.
+
+```javascript
+const response = await fetch('https://en.wikipedia.org/w/api.php?format=json&action=query&prop=extracts&redirects=true&explaintext&titles=Tim%20Berners-Lee');
+const data = await response.json();
+const text = Object.values(data.query.pages)[0]?.extract;
+```
+
+**Você:** Presumo que não sou o único que esteve no futuro?
+
+**Ada:** ...
+
+## Solução
+
+[Solução](./solution/rag-www.js)
+
+## Verificação de conhecimento
+
+**Pergunta**: Qual é o papel do recuperador em um sistema RAG?
+
+A. O recuperador gera respostas com base nos dados de entrada.
+
+B. O recuperador gera informações relevantes com base nos dados de treinamento do modelo.
+
+C. O recuperador encontra informações relevantes de fontes de dados externas.
+
+[Solução do quiz](./solution/solution-quiz.md)
+
+## Recursos para auto-estudo
+
+- [Geração Aumentada por Recuperação e Índices](https://learn.microsoft.com/azure/ai-studio/concepts/retrieval-augmented-generation)
+- **Aplicativos de exemplo**:
+  * [Chat de IA Serverless com RAG](https://github.com/Azure-Samples/serverless-chat-langchainjs/)
+  * [Ask Youtube: Uma API de perguntas e respostas do Youtube baseada em RAG](https://github.com/Azure-Samples/langchainjs-quickstart-demo)
+- [Workshop completo: Crie seu próprio ChatGPT com RAG](https://moaw.dev/workshop/gh:azure-samples/azure-openai-rag-workshop/docs/workshop-qdrant.md)
\ No newline at end of file