[Imersão IA} Criando seu primeiro chatbot com IA generativa

E aí, pessoal, boas-vindas a essa aula 4 da nossa imersão IA da Alura com o Google. Eu sou o Fabrício Carraro, estou novamente aqui com os queridos Luciano Martins e Valquíria Alencar, para falar muito sobre IA. E essa eu acho que vai ser a primeira aula mais pesadinha para quem não é da área da programação, nunca mexeu em código. Vocês já tiveram a live intermediária, com uma masterclass de Python comigo e com a Val, para te ensinar os pontos mais importantes do Python, coisas como variáveis, funções, operadores, ifs e tudo mais, que vamos acabar usando

nessa aula aqui de hoje E também na aula de amanhã, mas essa aula talvez seja a mais importante até agora, não só por ser um conhecimento novo, para você aprender coisas novas se você nunca mexeu com programação, mas também porque ela vai ser bastante importante quando formos falar sobre o prêmio da nossa Imersão IA. Isso, tem que construir o projeto para concorrer ao prêmio. Exatamente. Mas eu quero já tirar de cara uma coisa que vocês talvez possam pensar, pessoas principalmente que nunca programaram, e falar, putz, lá vem eles falando isso aqui, o prêmio é só

para quem é dev. Não é isso, né pessoal? Exatamente. Vamos dar oportunidade para todas as pessoas concorrerem, você vai poder... Vamos explicar ao longo desse curso também, e já fizemos uma premiação dessa na última Imersão IA no ano passado aqui também com o Google Gemini, onde a pessoa que ganhou, o Anderson, ele não era uma pessoa dev. Foi o primeiro prêmio, ganhou o primeiro prêmio da imersão e ele não era dev. Vamos até deixar um depoimento dele aqui para vocês darem uma olhada e talvez até se inspirar no Anderson. É bem legal o impacto que

causou e mostra como pensar em soluções, com a inteligência artificial pode ajudar, não precisa ser muito revolucionário, Coisas assim do seu dia a dia, da sua vida, da sua rotina, que você pode mudar a sua e a vida de outras pessoas, isso é muito bacana. O que me motivou foi a questão do aprendizado, que eu sempre busco aprender coisas novas e principalmente pelo tema que está muito em alta, inteligência artificial, e engraçado que naquela época, enquanto fazíamos as imersões, eu faço um comparativo de antes com agora, que na época havia até aquela diferença de, poxa,

engenheiro de Prompt, a nova modinha, e a Alura e o Google não, já viram o que estava ali na frente, então os modelos atuais são baseados nas técnicas que aprendemos ali, Então isso que foi impactante naquele momento, vendo para trás, mas na época a motivação mesmo foi o aprendizado, de desenvolver projetos, não ser algo muito longo, de ser algo curto, mas profundo, e que foi importante as lives de aprofundamento também, do desenvolvimento, e principalmente também o projeto, o projeto ali que foi proposto dá uma motivação, ter a comunidade também ali, cada um comentando como estava,

como estavam seus projetos, aquilo ali vai dando uma motivação extra para chegar no objetivo final. Apesar de trabalhar com ferramentas de análise de dados, Power BI, um pouco de SQL, de programação ali, não muita coisa, então todo o aprendizado foi durante as imersões e principalmente com as lives de aprofundamento, então todo o conteúdo, tudo que foi construído no aplicativo, estava nas aulas. Foi uma correria, não foi fácil, porque principalmente com a minha rotina de terapias com o Gabriel, então assim, mas nessa dificuldade eu vi uma oportunidade, então o tempo que ele passava ali nas terapias,

eu assistia às aulas, na parte da manhã, e à noite, que aí já estava dormindo, já estava mais tranquilo, Eu conseguia rever o conteúdo e aplicar de fato na prática, que também é importante, não só assistir, mas também fazer. Acho que a primeira coisa é ver o seu dia a dia, como você tem a disponibilidade, e não desperdiçar nenhum momento. Se você tem aquela disponibilidade, se propôs a resolver naquele horário, faça, não pule, não perca o foco, tem muitos assuntos na própria internet, nós às vezes queremos nos aprofundar, mas o que já é dado na

imersão, já é suficiente para você construir O projeto que você se propôs a fazer. E com relação ao projeto, eu proponho que seja algo que a pessoa, se for assim livre, como foi o nosso, que a pessoa se coloque no sentido de um propósito, de colocar algo que realmente vai afetar a vida nem que seja de uma pessoa, mas que possa ter esse impacto, e aí você possa mostrar para outras pessoas, para você poder divulgar, mostrar: olha o que eu fiz, olha que bacana, olha o que foi proporcionado, para você compartilhar, ter algo para compartilhar,

porque isso foi muito importante também. Quando eu compartilhei o meu projeto, eu tive um retorno muito legal, Muitas pessoas foram impactadas, não só pelo uso, mas pela notícia e pela oportunidade que a inteligência artificial dá de fazer essa construção e mudar a vida de outra pessoa. Bacana. Então, tirado esse problema da frente, esse potencial problema na sua cabeça, vem conosco aqui, que vamos voltar para o Google AI Studio, onde estávamos ontem, lembra lá onde fomos pegar a API Key e tudo mais? Vamos mostrar mais uma coisinha que eu acho que é bem legal, lá no

Google AI Studio, e depois já vamos mergulhar no código. O que é essa coisa, Luciano? Bom, conversamos bastante, voltando lá na primeira e na segunda aula, que o modelo tem o seu corte de conhecimento, a sua data limite de conhecimento, e que o mecanismo que desenvolvemos para vocês conseguirem ter informações mais recentes, é usando a busca do Google como referência. Agora conseguimos ver aqui no AI Studio, e é algo que vamos fazer nos exemplos de código também, como fazemos isso na prática. Vamos usar um exemplo meio triste, mas muito visual de como isso funciona? Você

pode perguntar para o Gemini qual foi o resultado da última partida de futebol entre o Brasil e a Argentina. Tá, estou aqui com o modelo, né, no lado direito superior, eu fui lá no Gemini 2.0 Flash, padrãozinho, mais rapidinho. E eu vou perguntar aqui para ele, rápido, qual foi o resultado do último jogo de futebol masculino entre o Brasil e a Argentina. Você podia copiar esse prompt para depois passar ele mesmo. Vou dar um "Ctrl+C", copiar ele aqui. Rodar. O último jogo foi dia 21 de novembro de 2023. Foi lá, naquele dia, pelas eliminatórias da

Copa de 2026, a Argentina venceu o Brasil por 1 a 0. Isso é uma informação antiga.. 2023, é. Estamos em 2025. Porque o conhecimento do modelo vai até janeiro de 2025. O que vamos fazer aqui para ver na prática a diferença? No menu do lado direito, tem vários botõezinhos que você pode ativar e desativar. Na seção Tools. E a última opção desse submenu se chama Grounding with Google Search. Que, numa tradução meio literal, seria "embasar os resultados na busca do Google". O único esforço que você tem é ativar esse botão. Vai ficar azulzinho. Ativado. Beleza.

Ele já colocou lá que a fonte das informações vai ser o Google Search. E você pode colar o prompt que você acabou de fazer. Nem precisa criar uma nova conversa. E enviar de novo. A diferença dessa execução é que agora o modelo vai buscar, vai dar um Google, vai fazer uma busca no Google antes de responder. E agora ele trouxe a informação correta. A última partida que aconteceu foi no dia 25 de março de 2025, Algumas semanas, alguns meses atrás, que a Argentina venceu de 4 a 1. Então ele trouxe tanto a informação correta, a

informação mais atual, quanto as referências, se você quiser validar se realmente aquela informação é verdadeira e tal, ele já traz todo o mecanismo. E uma coisa legal que ele faz também, ali embaixo onde tem o G colorido do Google, são botões para você fazer essa mesma busca na busca do Google. Se você clicar em alguma das duas opções, ele vai abrir uma aba nova. E você tem a busca do Google que ele fez para achar o resultado. Então tem forma diferente de você validar o resultado. Muito legal. E se eu clicar nesse abre e fecha

lá, que lembra que vimos ontem que mostrava o código? Aqui temos o Google Search. Ele vai estar habilitado o Google Search? Sim. Você vai ter nessa linha 51 e 52, você tem a declaração de uma tool ou de uma ferramenta, que ele chama de GoogleSearch(), abre e fecha parênteses. Perfeito, bacana. Aqui são coisas que vamos talvez, quem sabe, usar amanhã? Não sei. Hoje talvez? É isso. Bacana. Mas voltando, pessoal, a última coisa que vamos ver no Google AI Studio hoje é só uma recapitulação rapidinha de como você pegar a sua API Key. Lembrando que estou

na minha conta do Google, que já tem alguns projetinhos, já tem API Keys criadas, mas você pode tanto clicar aqui em Get API Key, na parte superior da tela, e ele já vai abrir direto, ou você poderia ter ido aqui no Studio, clicar em Dashboard, é a mesma tela, dá na mesma basicamente. E aí, eu tenho aqui uma chave já criada, eu posso simplesmente clicar aqui para usar a mesma chave, pegar e copiar ela, ou se não, clicar em Criar Chave de API, e aí ele vai abrir, pesquisar um projeto novo, se você tiver algum

projeto, você vai criar uma chave de API em um projeto atual, ele vai gerar uma nova chave aqui para mim. Gerada, já mostrou essa chave que termina em qeck, que eu posso copiar, eu posso apagá-la, no meu caso eu vou só apagá-la. Bom, e agora a partir desse ponto, eu acho que vai entrar a programação, pessoal. É isso, vamos! Eba! Não se assustem, vamos segurar a sua mão, eu, a Val e o Luciano, e a programação não vai ser feita no Google AI Studio. Onde ela vai ser feita? Numa ferramenta gratuita do Google, chamada o

Google Colab. Beleza, para entrar no Google Colab, você vai digitar esse link que está aparecendo agora aqui embaixo da minha cara, ou então clicar no mesmo link que também está aparecendo aqui na descrição, Que novamente, como sempre, não entra direto lá no Google Colab, esse aqui é um link especial que geramos especificamente para você que está fazendo essa imersão de IA conosco. Essa é a carinha do Google Colab, então você olha, tem um bloquinho aqui que você pode começar a escrever. Comece a programar ou gere código com IA, analise arquivos com Gemini, tem um monte

de coisa aqui, mas é uma interface bem limpa, eu acho até. Tem aqui código, tem mais texto, e só, basicamente, né, isso aqui é o importante. Mas o que que vamos fazer? Qual que vai ser o projetinho que vamos fazer nessa aula 4? É o chatbot. É o chatbot, exatamente. É o primeiro exemplo que dá para fazer, para começar a brincar com a ferramenta do Google, mexer com código em Python e também mexer com como conectar com o Gemini lá no servidor do Google para ele responder para nós aqui, não via site, não via aplicativo,

mas via código também. Exato. Então, como é que eu começo, pessoal? Primeira coisa: tem um botão ali de conectar no canto direito superior. Tá. Vamos ter que conectar ali o ambiente. Tá, porque isso aqui é como se fosse um grande blocão de textos para escrevermos o nosso código, mas conectado com o servidor do Google, que vai rodar para nós lá, não vai rodar aqui no meu computador. Isso aí. Boa, olha, já deu aqui o RAM. Por que que estamos usando isso? Algumas pessoas já podem ter alguma experiência com desenvolvimento, já usam a sua ferramenta local,

VSCode, JetBrains, a que preferirem. Nós acabamos usando o Google Colab por dois motivos. Primeiro, porque ele é gratuito para todo mundo, então não tem nenhum requisito de equipamento, uma CPU poderosa, muita memória, então fica fácil para todo mundo utilizar. E também porque é um local centralizado de dependência. Então, se cada um tivesse que instalar o seu Python e as suas bibliotecas, ia ser bem mais trabalhoso para vocês. E aqui tudo que precisamos já está pré-instalado, Ou a maioria das coisas já está pré-instalada, podemos seguir na mesma experiência igual para todo mundo. Perfeito. Maravilha. Então, como

é que eu começo aqui? O que é o código que eu tenho que começar? Eu tenho que me conectar de alguma forma com essas ferramentas do Gemini. Exato. Da IA generativa lá do Google. Acho que podemos começar fazendo uma instalação aí, né, Luciano? É, talvez a primeira coisa que podemos fazer, Fabrício, é... Aí, assim, um conceito novo, especialmente para quem está começando com o desenvolvimento agora, Quando temos um produto ou uma ferramenta como o Gemini que uma empresa como o Google provê para os desenvolvedores acessarem, normalmente as empresas criam um pacote ou uma biblioteca que

chamamos de SDK, que é o Kit de Desenvolvimento de Software. A SDK é uma forma mais simplificada para as pessoas conseguirem acessar os serviços. Você vai escrever menos código no final das contas. Você vai escrever menos código do que, por exemplo, usamos dentro do Google para acessar. Ou seja, é uma simplificação do acesso para deixar mais fácil e mais divertido o processo para quem está desenvolvendo. Então, a primeira coisa que vamos fazer vai ser instalar essa SDK dentro do nosso Colab. Como eu instalo coisas no meu colab? Como o Colab se baseia na linguagem Python,

então toda a nossa experiência hoje e amanhã vai ser com Python, em qualquer ambiente Python, se vocês usam Windows, Linux, Mac, qualquer coisa, quem já conhece Python, existe uma ferramenta no Python chamada PIP. O PIP é a ferramenta que a gente usa para instalar as bibliotecas do Python. Aqui vamos usar o PIP também, mas como estamos numa interface web, Tem um comandinho especial que usamos para conseguir executar esse código. Esse comandinho especial pode ser o sinal de percento, de percentual, perdão, ou pode ser o ponto de exclamação. Aí fica a seu critério aí, Fabrício, qual

dos dois você quer usar. Eu sou um cara mais exclamação, eu acho. Eu sou um cara mais assertivo. Aí você vai digitar pip, P-I-P, espaço install, de instalar em inglês, e o nome da SDK, o nome do pacote que vamos instalar é google-genai, de generative AI, tudo junto. Isso. Aí aqui você tem duas opções. Ou você vai segurar o Ctrl, ou o Cmd para quem é do Mac, apertar "Enter", ou você pode clicar naquele botãozinho de Play que tem do lado da caixinha preta, do lado da célula. Eu vou clicar aqui, vamos começar. Aí para

quem nunca executou um notebook na vida, enquanto a caixinha está com a animação de estar girando, quer dizer que esse código está em execução, e quando a caixinha fica com o check verde do lado, quer dizer que a execução acabou e está tudo certo. É, no nosso caso está verdinho e ele falou aqui: um segundo. Demorou, foi rapidinho. Se fosse cinco segundos, ia mostrar 5s. Isso, exatamente. Exatamente. Boa. Beleza? Show. Esse foi o nosso primeiro bloco de código. Parabéns, você é uma pessoa programadora! Agora o que podemos fazer é colocar aquela nossa chave de API

aqui dentro do Google Colab. Tem uma parte especial para fazer isso aqui. Excelente, Val. Como a Val nos lembrou, nós criamos a nossa API aqui no AI Studio. Como trazemos para dentro do Colab? O Colab tem como se fosse um cofre para guardarmos as senhas. Algumas pessoas usam o do próprio Google, o do Chrome, para ir salvando as senhas para nós, para não ter que lembrar de tudo, mas salvar de uma forma segura. E o Colab tem a sua própria ferramentinha, o seu próprio cofre de senhas, que no lado esquerdo tem um menu com vários

desenhinhos, é o penúltimo. O último é uma pastinha e o penúltimo é uma chave. Sim, é o Secrets. Exatamente, é o Secrets. O que você vai fazer? No primeiro acesso que vocês vão ter, vocês não vão ter essa quantidade de chaves que o Fabrício já tem, que ele já experimentou com outras coisas, já testou outras coisas, já salvou várias. O de vocês vai estar vazio. A forma mais fácil de vocês conseguirem a chave da Gemini API, vai ter um botão ali: Chaves da API Gemini. Vocês clicam nesse botão e depois Importar chave do AI Studio.

Basicamente, o Colab vai verificar o que vocês já criaram lá no AI Studio. Vocês criaram, como última etapa da aula de ontem, uma chave nova. Essa chave vai aparecer aqui, é só clicar no botão Importar. Nossa, bem prático. Super prático. Maravilha. E ela foi importada aqui como a secret GOOGLE_API_KEY, que é esse último, que inclusive já está ativado. As minhas outras chaves, antes elas estavam desabilitadas, nessa instância, nesse notebook, nesse caderninho do Colab. E eu poderia desativar, ou clicar aqui para ativar e pronto. Mas tá, agora ela está no meu cofre, como é que eu

pego para usá-la? Já tem uma ajuda ali embaixo. Olha, tem uma cola! Tem uma colinha. Então eu posso simplesmente, clicar nesse Copiar aqui, ou simplesmente selecionar tudo e dar um "Ctrl+C" também. E eu vou fechar essa chave, os Secrets. Para criar um novo bloco de código aqui, é só você pôr o seu mouse no final da resposta anterior. Ele fez um monte de instalações aqui, Não vêm ao caso. Mas você pode criar um bloquinho de código, ou de texto, no nosso caso vai ser um bloquinho de código mesmo. E eu vou dar um colar, um

"Ctrl+V" no from google.colab import userdata, você não precisa memorizar isso, porque já tem lá, nós simplesmente copiamos e colamos. A única coisa que você tem que saber, é que em "userdata.get('secretName')", Esse secretName vamos ter que mudar. Isso, é o nome da variável que o importador do AI Studio criou, que é GOOGLE, tudo no maiúsculo, _API_KEY. Olha, é só substituir. Eu substituí, e lembra, ele tem que ficar entre aspas. Pode ser aspas simples ou aspas duplas, mas tem que estar entre essas aspas. Beleza. Então, já temos o código aqui, meio que importado. A API key, na

verdade, importada no nosso código. A última coisa que você tem que fazer, antes de executar essa célula, é que temos que guardar essa API key em algum lugar para ser usado no nosso código. Nas famosas variáveis, que eles viram na live intermediária. Exatamente. Vamos criar o que chamamos de variável de ambiente, ou seja, não vamos declarar uma variável Com nomezinho "API key", por exemplo, e salvar. E sim, vamos guardar na memória do nosso Colab. Então, para isso, o que você vai fazer? Você vai clicar lá, antes do from, a primeira linha dessa célula. Aqui em

cima? Isso. Aí, aí em cima, você vai fazer um import, você vai importar uma nova biblioteca do Python, vai dar um espaço, e vai escrever "os", que seria a sigla de Sistema Operacional em inglês. Operating System. Daí, o que você vai fazer? Lá na linha onde você tem userdata.get, você vai para o comecinho dessa linha também. Vamos até dar um espaço aqui, para separar. É mais uma questão visual, de organização, Exato. Você vai criar uma variável de ambiente, também chamada Google API Key. Como você vai fazer isso? Você vai usar aquela biblioteca OS, daí você

vai digitar, no começo dessa linha... Aqui? É, na linha de baixo. Tudo de baixo. Beleza. OS, ponto... Vamos criar uma variável de ambiente. Ambiente, em inglês, seria a palavra environment. Environment, sim. Então, a propriedade de OS seria environment sem o T no final. Por que não tem o T no final? Não sei. Mas não tem. O legal é que, quando você dá o "os.", Ele já dá um monte de sugestões aqui. Então, ao invés de digitar, você pode só ir para baixo. E aqui, environ. Está sem o "ment" também. Ah, é verdade. É sem o

mente, é verdade. Porque o Gemini não mente. Beleza. Como criamos uma variável, já que apontamos para o OS que queremos uma variável? Você vai abrir e fechar os colchetes. Colchetes, aqui. E dentro desses colchetes, você vai escrever entre aspas, podem ser aspas simples ou aspas duplas, como você preferir, o nome da variável que você quer. Que, no caso, vai ser a mesma GOOGLE_API_KEY. Vou copiar e colar aqui dentro. Exato. Aí você dá um espaço entre o fechar colchete e o userdata. Coloca um igual (=). Aí, dá um espacinho de novo. Mais por uma questão estética,

você não necessariamente precisa desse espaço. Aí, agora sim, você pode clicar no botãozinho play dessa célula, e o que você está fazendo? Você está, basicamente, copiando a API key que está dentro do cofre do Colab para dentro da sua variável de ambiente chamada GOOGLE_API_KEY. E essa variável de ambiente também não existia. Só falamos: cria aí, ambiente, uma nova variável e o nome dela é GOOGLE_API_KEY, e o que vai estar dentro dela é a Google API key que está lá no meu cofre. Exatamente. Bom, eu acho que esse bloquinho já está terminado, basicamente. Podemos criar mais

um bloquinho. E agora? Agora temos que configurar o nosso cliente para conseguir acessar ali o modelo. Exatamente. Quando vamos usar uma SDK, e isso vale para a maioria das SDKs, não é algo exclusivo do Google Gemini, normalmente, no seu código, você declara ou você cria um objeto que, normalmente, chamamos de cliente da SDK, que vai ser o objeto que você vai usar para interagir com esse serviço. Perfeito. Então, como a Val falou, vamos agora declarar, ou vai começar a usar nossa SDK. A primeira coisa que você tem que fazer é importar a biblioteca da SDK,

que foi aquela que instalamos lá na primeira célula, chamada google-genai. Posso copiar? Você nem precisa copiar, vamos chamá-la de uma forma específica. Legal. Você vai usar de novo o comando import. Beleza, e depois do import, você vai digitar google. Lembrando que nossa SDK se chama google-genai. Então, você vai fazer import google... A IA do Google já acha que vamos importar sei lá o que aqui. Ela está tentando ser espertinha, não necessariamente é o que queremos agora. Mas isso é uma coisa interessante que você falou, é uma funcionalidade do Colab. O Colab vai seguir tentando sugerir

código para facilitar a sua vida. Nem sempre vai ser exatamente o que você quer, como é o caso aqui. Mas ele vai tentar ajudar de alguma forma. Na verdade, podemos fazer um pouco diferente esse import, Fabrício. Perdão, você pode apagar essa linha toda. Como a biblioteca se chama google-genai, o que vamos fazer? Vamos usar, igual o segundo import que fizemos na célula anterior, ao invés de fazer o import, vamos usar o from, que é para pegar um sub-módulo ou uma sub-parte de alguma biblioteca. Não baixa a biblioteca inteira. Isso, exatamente. Só uma coisinha. Então, você

vai fazer um from, espaço google, espaço import, Espaço genai. Agora ele acertou. Exatamente. E para completar, se eu quiser que ele autocomplete, eu dou um "Tab". Exatamente. "Tab" aqui, completou. Beleza. Aí, você pode dar dois "Enters" aí, podemos usar essa célula mesmo. Por enquanto, estamos só importando a biblioteca da SDK. Para instanciar, ou para criar um client dessa SDK, você vai declarar como client, vamos chamar a variável de cliente de client, para ficar mais fácil, Igual (=)... E ele já ajudou você. genai, que é o nome do módulo que importamos. Esse daqui, import genai. Isso.

.Client, com C maiúsculo, abre e fecha parênteses. Lembrando que, quando você é um cliente em um mercadinho, em uma loja, você recebe um produto. Aqui, você vai receber coisas do servidor do Google, que no caso é o que o Gemini vai te falar. É a resposta do Gemini que você vai receber. Por isso que você é um cliente. E agora podemos definir qual é o modelo que nós vamos utilizar aqui. Exatamente. Como fazemos isso? Também podemos criar uma variável para armazená-lo. Como eu chamo? Eu chamo de model? Modelo? Pode ser model. Você sabe todos os

modelos que você tem disponível para usar? Eu não sei. São muitos modelos. Então, o que podemos fazer? Antes de escolher, aí, assim, mais por curiosidade, para a galera ver como é que faz também, Você pode rodar essa célula. Em vez de rodar agora, vou ser aventureiro: "Ctrl+Enter" em vez de dar o Play lá. rodou igual. Boa. Aí, a última opção, já para pensar nas alternativas, você podia ter rodado também com "Shift+Enter". Aí ele não só ia executar, como ele ia criar uma nova célula vazia embaixo para você também. Manda a ver. "Shift+Enter". Olha, ele rodou

e criou mais um bloquinho. Boa. Beleza. Como você lista os modelos? Basicamente, com essa variável client, você pode rodar ou executar qualquer coisa que a API do Gemini suporte. Então, o que vamos fazer? Você vai criar um laço for... Igual fizemos na Live Intermediária. Igual na Live Intermediária. Para iterar, fazer repetições. Exatamente. Existe um método, ou existe uma função dentro do SDK Que serve para listar todos os modelos que ela tem. Então, o que você vai fazer? Você vai fazer um for, aí, você vai criar uma variável temporária que ele já fez para você, chamada

model. Aí, in, que é a estrutura do for, daí, vamos usar, não é exatamente como o Colab está sugerindo, você vai usar client.models, no plural, que aí apareceu a opção para você aí. .list, que também aparece para você. Ah, está aqui. Deixa eu apertar o ponto. O list está aqui. Aí, você abre e fecha parênteses para forçar que você quer a função ou o método list. Daí, você vai dar dois pontos. Vai dar um "Enter" para ir para a próxima linha. Você pode fazer um print. Aí, não vamos nem criar nenhuma condição. Vamos listar tudo

o que aparecer. E você pode usar o parâmetro name. model.name Eu só quero o nome do modelo. Aí, você pode dar o playzinho lá do lado. Ah, que legal. E basicamente, você listou todos os modelos, todas as variantes do Gemini que você tem disponível para uso na API. Até as mais antigas, 1.0... Exatamente. Eu lembro dessas aí. Gemma, olha aqui. Gemma são os modelos open source, abertos. Veo que é de vídeo... Mas temos ali o nosso Flash, o 2.0 Flash. Exatamente. Que é o que mais estamos usando hoje. É! Aí, se você quiser, você já

pode selecionar exatamente esse que você acabou de passar o mouse, o 2.0 Flash, que é o que estamos usando em todos os cenários. Na próxima célula, você pode criar uma variável chamada model ou o nome que você quiser. Só para não termos que ficar repetindo o uso dessa string que você salvou. E você abre e fecha aspas. E cola o nome do modelo que vamos usar. Beleza. Não precisa do models/ (barra), só o nome direto. Exatamente. Dentro dessa célula mesmo, só para não termos que ficar com mais uma célula adicional, você já pode fazer a

sua primeira requisição para a API. Ou seja, da mesma forma que escrevíamos a pergunta e apertávamos o botão de Enviar no Gemini App e no AI Studio, vamos fazer isso via código agora. Então, você vai criar uma variável chamada response. Response, que é a resposta. Posso fazer em português? Pode ser em português, sem problema. Igual (=)... Daí você vai chamar o client de novo, .models... Ponto... Aí você tem um método um pouco maior agora, chamado generate_content. Esse daqui, que ele já até sugeriu para nós. Exatamente. Daí você abre e fecha os parênteses. E dentro dos

parênteses agora... Aí assim, meio que a sequência vai meio intuitiva. Você está chamando a SDK, que é a variável client. Dos clients, você quer interagir com modelos. E dos modelos, você quer gerar conteúdo. Então, meio que a sequência que você está seguindo faz um pouco de sentido para a ação que você quer tomar. Dentro dos parênteses, você vai precisar passar duas variáveis. Ou dois parâmetros, como normalmente falamos para uma função. O primeiro parâmetro se chama model. Então, dentro do parênteses, você vai colocar model =. E coincidentemente, a nossa variável de modelo também se chama model.

Posso até mudar. Posso pôr modelo. Pronto, fica mais claro, em português. Beleza, model = modelo. Parâmetro model lá do SDK vai receber o nosso modelo. Talvez, só para reforçar, podemos mudar o nome das nossas variáveis a hora que quisermos. Os parâmetros das funções, sempre temos que obedecer a forma que elas foram criadas. Então, se você tentar rodar o generate_content com modelo = modelo, vai dar erro, porque esse parâmetro não existe. Então, o model tem que ser sempre model. Depois do model, você vai pôr uma vírgula. E você vai usar outro parâmetro chamado contents, ou conteúdo.

Que é basicamente o prompt que você quer enviar. Começamos a escrever cont e ele já sugere contents =. Daí, entre aspas, de novo, Você pode fazer a pergunta que você quiser. Vamos perguntar quem é a empresa por trás dos modelos Gemini? Perfeito. Eu vou até dar um "Enter" depois dessa vírgula para ficar mais organizadinho para nós. Ele entende sem problemas. Posso rodar? Pode rodar. Mas aí não vai acontecer nada, porque eu só estou guardando na variável. Eu não estou imprimindo. Mas vamos rodar aqui, assim mesmo. Depois eu posso mudar. Mas, olha... Ele está buscando algo.

Olha, três segundos... Não aconteceu nada, aparentemente. Por quê? Ele guardou, pegou lá algo nesse modelo, que é o model = modelo, que é o Gemini 2.0 flash. Essa era a pergunta que ele fez. Ele guardou, eu imagino, a resposta dessa pergunta nessa variável resposta. E agora, para eu ver, eu posso até criar, por exemplo, um novo bloco aqui, e dar resposta aqui. Só mostrar a resposta. Ele vai mostrar coisas. Um monte de coisas. Aí é uma visão, assim, mais programática, assim, para um desenvolvedor num estágio mais avançado da sua jornada e da criação da sua

aplicação. Aí tem muitas informações que vão ser úteis para essa pessoa. Mas, para o momento que estamos experimentando com o início da utilização da Gemini API, dentro desses vários campos de resposta, tem um campo chamado text, de texto em inglês. Achei aqui. Podemos acessar apenas ele. Isso, exatamente. Então, para você não ver isso tudo, você ver só a sua resposta, Lá onde você digitou só resposta, você adiciona .text. Vou rodar novamente. Fechou. Você está capturando só essa informação de dentro daquela estrutura grandona. Excelente. Então, acabamos de fazer a nossa primeira comunicação com o Gemini. Batemos

lá no servidor do Google e voltamos. Somos programadores. Eu estou bem feliz com isso. E uma coisa a mais, se você está um pouco confuso, confusa aí, com esse código aqui, esse client.models, vamos voltar nesse bloquinho aqui. Se você for na parte superior direita, Tem uma seta para cima e para baixo, não clica nisso, mas no terceiro ícone, Recursos de IA Disponíveis, que é o Gemini. É o Gemini dando respostas, nos ajudando dentro do Google Colab. Se eu clicar nele, tem uma opção Gerar código, que não é o caso, mas tem Explicar o código. E

aqui ele vai abrir, do lado direito, meio que uma explicação. Ele está explicando em inglês, porque é a linguagem base do Colab. Ele gerou aqui a resposta. O modelo está assigning the model, blá, blá, blá, um monte de coisa. Não falo inglês, traduza para o português. E aí eu rodo, e ele vai começar a pensar, e vai fazer exatamente o mesmo, traduzindo para o português. É um modo a mais de você aprender sobre esse código que você está escrevendo. Eu quero criar mais código, galera. Estou animado. Bom, acho que agora podemos começar, então, a criar

o nosso chatbot, já que o Fabrício está aí animado. É, só estávamos aqui... Dei uma pergunta, ele deu uma resposta e acabou. Não tem uma conversa. A ideia é realmente conversar. É ter um chatbot, realmente. Beleza, vamos começar a criar, então? Vamos nessa, vamos nessa, então. Então, beleza. O que fizemos até agora foi, basicamente, ter algumas interações únicas com o modelo. Enviávamos uma pergunta, recebíamos uma resposta. Qual é a diferença de criar um chatbot? Normalmente, quando temos uma interação com chatbot, começamos a ter um histórico de conversa. E esse histórico é algo que o próprio

modelo pode reusar, para facilitar a nossa conversa. Posso ser clubista aqui? Claro. Um exemplo que eu sempre dou para o pessoal é que eu pergunto uma primeira pergunta: Quem foi o Rogério Ceni? E qual esporte ele praticou? Assim, curiosamente. E aí, o modelo (Gemini, por exemplo) podia responder: Rogério Ceni foi um jogador de futebol do São Paulo Futebol Clube, que jogava, enfim, futebol. E aí, numa próxima pergunta, eu poderia perguntar: Ok, qual time ele defendeu durante a carreira? E quando foi inventado esse esporte? Ele vai saber que "ele", de "ele" defendeu, se refere ao Rogério

Ceni, porque está guardado na memória do chat. E que "esse esporte" é o futebol também, que foi a primeira resposta. Exatamente isso. Então, isso é útil, tanto para fazermos essas referências mais simples, como também se precisarmos resgatar alguma pergunta. Um teste que vocês podem fazer, por exemplo, quando acabarmos de construir o nosso chatbot, você pode perguntar explicitamente: qual foi a primeira pergunta que eu fiz? O modelo entende a estrutura de histórico das perguntas empilhadas E vai conseguir resgatar qual foi a primeira que você fez, qual foi a segunda que você fez, ou algo assim, entendeu?

E não temos ainda essa estrutura de chat pronta aqui. Vamos ter que criar em código. Exatamente isso. Vamos fazer isso agora. O que eu faço? Bom, beleza. Vamos criar um objeto chamado chat, que vai ser o objeto principal do nosso chatbot. E para criar esse chatbot, você pode dar um espaço, Igual (=), espaço de novo, vamos chamar o nosso client, igual chamamos para fazer o generate_content, agora vamos fazer .chats... .create Ah, tá! É legal que, como você falou, segue mais ou menos o mesmo padrão. Aqui em cima temos client.model, queríamos só um modelo para gerar

um conteúdo único. Exatamente. Aqui temos o client, que é o mesmo cara, mas não é um modelo que vamos buscar, queremos criar um chat. E aí .create, que é criar em inglês. Exatamente. Daí você vai abrir e fechar a parênteses e dentro do parênteses, nesse momento, vamos usar um parâmetro só, que é mais uma vez o parâmetro model. Vamos fazer model = modelo, que é a variável lá do Gemini 2.0 Flash, que já criamos antes. É a mesma variável aqui. E uma curiosidade, pessoal: aqui estamos usando a variável modelo Porque isso é um padrão da

programação e tudo mais, muito usada, mas, tecnicamente, poderíamos simplesmente copiar esse nome, gemini-2.0-flash, entre aspas e pôr aqui ou pôr aqui, que daria na mesma. Isso, exato. Beleza. Mas vamos continuar com o modelo. Daí o que você já pode fazer... Com isso você já criou, entre aspas, a sua estrutura de chatbot. Daí, nessa mesma célula, você pode dar um "Enter" e você cria de novo uma variável resposta. Podemos continuar reusando essa, não tem problema. É igual. Aí você vai fazer um chat, vai chamar o objeto, ponto, a função que ele já está mostrando para você,

send_message. E aí você pode fazer uma primeira pergunta que você quiser, até pode ser um oi. Oi, tudo bem? Boa. E de novo, você vai estar armazenando o resultado na variável resposta e se você já quiser fazer tudo na mesma célula, você coloca mais uma linha e coloca a resposta.text. O mesmo .text? Exatamente o mesmo do outro. Exatamente. Posso rodar isso aqui já? Pode rodar. Vamos ver o que vai acontecer aqui. Buscou. Tudo bem por aqui, como posso te ajudar hoje? Legal. Boa. Qual é o primeiro desafio que encontramos quando criamos um chatbot? Para continuarmos

essa conversa, você pode copiar essas duas, a segunda e a terceira linha. Você não precisa recriar o chatbot, vamos continuar reusando ele. Você pode criar uma nova célula e você pode voltar a fazer a nossa primeira pergunta: o que é inteligência artificial? Copiando e colando, né? No lugar do "Oi, tudo bem?". Boa. Aí você pode executar. O que pode ser um desafio dependendo da interação que temos? Quando estamos criando um chatbot ou quando estamos interagindo com chatbot num site, num aplicativo, algo assim, esperamos que as respostas sejam sucintas. Porque se você está no celular e

você tem que ficar rolando um monte a tela para ler, não é uma experiência legal para quem está usando, não necessariamente para quem está desenvolvendo. Então, para termos esse tipo de controle na criação dos resultados, existe um parâmetro comum em LLMs que existe no Google Gemini também, chamado System Instruction. As instruções do sistema. As instruções do sistema são as orientações, ou as instruções de fato, que o modelo tem que seguir sempre que ele gerar uma resposta. Isso conecta com a nossa aula 2 de engenharia de prompt, Que falamos "aja como uma pessoa de marketing". Exatamente,

"tenha tal tom de voz". A grande diferença... Vamos fazer esse teste então. Primeiro, você edita lá onde está "o que é inteligência artificial", nessa célula mesmo. E antes da pergunta, você escreve por extenso, assim: você é um assistente pessoal... Dentro das aspas, né? É. Você é um assistente pessoal e você sempre responde de forma sucinta. Aí você dá um ponto, espaço e manda a sua pergunta agora. Beleza, o mesmo aqui. Vamos dar conexão, rodar. Nossa, olha a diferença. Ele foi bem sucinto. Foi super sucinto. Foi o que pedimos! Exatamente. Isso aqui resolve o problema? De

certa forma, resolve. Qual é o problema para você como desenvolvedor? Você vai ter que copiar e colar essa orientação Em todas as interações, para sempre no seu programa. Então, isso é uma das utilidades das System Instructions. Você pega algo que você teria que ficar enviando sempre, você envia uma vez só, a API, o modelo, vai entender que aquilo tem que ser sempre seguido e vai passar a seguir isso daí para frente. Isso está cheirando a variável. Vou guardar isso em alguma variável. Exatamente, exatamente. Beleza, o que vamos fazer, então? Só para separarmos as estruturas, você

pode criar uma célula de novo. E agora vamos criar uma variável chamada chat_config, Ou as configurações do nosso chat. Perfeito. Especificamente para System Instructions, aí isso entra um padrão da utilização das APIs. Assim, é uma estrutura que parece um pouco complexa, mas sempre que criarmos uma System Instruction vai ser assim, você vai criar uma estrutura... Você volta um pouco o código? Eu acho que temos que importar outro módulo antes de fazer isso. Lá na parte dos imports. Tá, ainda não importamos o módulo que vamos precisar. Então, nessa célula nova, A primeira coisa que você vai

digitar lá no finalzinho... Lá na última célula, perdão. Nós primeiro vamos importar o módulo que precisamos. Isso, aí você vai escrever from google.genai import types que são os tipos de informação que a SDK suporta. Agora sim, agora você vai criar no seu chat_config. Você vai usar um tipo que é... Você vai digitar types, ponto... Dentro dos tipos, tem um monte aqui, você vai ter um que começa com generate. Vamos lá na letra G... Aqui, olha, generate, tem um monte também. Isso, é GenerateContentConfig. Configurações de geração de conteúdo. Exatamente isso. Daí você vai abrir e fechar

parênteses. Aí você pode fazer naquele formato que você gosta, você pode quebrar em outra linha para ficar mais estruturado. Mas quem quiser continuar escrevendo por extenso está tudo certo também. E dentro dessa config você vai criar uma configuração, você vai usar um parâmetro de configuração chamado system_instructions. System_instructions... No singular. System_instruction. Daí você vai abrir e fechar parênteses. Aspas, perdão. E você... Ah, ele já colou para você. Ele já até entendeu que é a instrução que demos aqui em cima. Posso dar um "Tab", que é o que vamos usar nesse caso. Daí você pode dar um

"Enter" depois de fechar parênteses. E vamos criar o nosso objeto chat mais uma vez. Que é essa sugestão que ele está dando para nós. Isso. Podemos segui-la, podemos copiar daqui também, esse do bloco anterior que criamos o chat. Talvez aí, assim, é mais manual fazer isso, mas eu sugiro que quem tenha tempo, tenha paciência, siga digitando mesmo. Até para praticar, ao invés de ficar usando o "Tab". Vamos digitar, vamos lá. Eu gostei disso. Então, chat recebe client, ponto, não era o models, era o chats. No plural. E aí, create para criar um chat. Daí, agora

ao invés de usar só o model como parâmetro, vamos usar o model e o config. Config, ah, legal. Igual (=) a variável que criamos ali em cima chamada config. Config, bacana. Essa variável que aqui era chat, quando rodarmos esse cara aqui, ele vai sobrescrevê-la. Ele vai apagar o que tinha antes, colocar esse novo que, o anterior não tinha configuração, esse atual tem. Exatamente, é isso aí. Posso rodar ou tem mais coisa para fazer? Bom, por enquanto você só vai criar o objeto do chat. Então você pode rodar, não vai acontecer nada, ele só vai declarar

tudo que você precisa. Agora você vai repetir a mesma experiência de antes. resposta =... Vamos até copiar e colar isso daqui. chat.send_message. Aí você pode deletar essa orientação especial, você pode até fazer outra pergunta para não parecer que ele só sabe responder essa. Alguma outra pergunta mais... Olha, qual é a capital da Turquia? É que essa vai ser curta. Tá bom, justo. Ah, vamos pensar em algum outro conceito. Vocês podem pensar em qualquer conceito da área que vocês trabalham. Para mim acaba sendo mais fácil pensar em conceitos de computação. Então você pode, por exemplo, perguntar

o que é computação quântica. Difícil. E vejam, a primeira vez que fizemos uma pergunta mais ampla como essa, sem nenhuma configuração prévia... Nós apagamos, né? Foi, nós reescrevemos. Enfim... O modelo escreveu um parágrafo, ou alguns parágrafos, que é a forma padrão de ele explicar. Igual quando perguntamos no Gemini App, igual quando perguntamos no AI Studio. Aqui já temos uma System Instruction para o modelo sempre responder de forma sucinta. Então o que esperamos é que essa resposta seja mais curta. Vamos tentar. Vamos rodar aqui. Olha, foi bem curtinha mesmo a resposta. Bacana. Excelente. Então daqui nós

já... O que temos até aqui? Temos a nossa estrutura de chatbot criada e a nossa configuração, ou a nossa customização de tamanho das respostas. Qual é a última coisa que podemos fazer aqui, antes de dar o próximo passo? Você cria uma nova célula. Existe uma estrutura dentro desse objeto chat que guarda o histórico da conversa. Então se você digitar chat ponto, aí vai ter um get_history, e abrir e fechar os parênteses e executar essa célula, o que ele vai trazer para você É um histórico das interações. Estou achando aqui, é um text, um texto, "o

que é a computação quântica", e aqui embaixo outro text, "a computação quântica usa fenômenos...". Com a resposta. Inclusive tem uma orientação, se você ver na primeira onde tem a pergunta, tem um campo chamado role, que é a função de quem mandou aquela pergunta. Ah, que é o user, o usuário. Isso, aí teve uma mensagem do usuário que foi a pergunta, e a próxima tem um role, tem uma função modelo, que deu a resposta. Então você consegue entender quem está perguntando, quem está respondendo. Perfeito! Beleza? E agora, Val? O que você acha que pode ser o

nosso próximo passo? Bom, acho que agora podemos fazer o loop, para conseguir interagir aqui e estabelecer as nossas conversas. Para ter uma conversa parecida com o chatbot mesmo, que aqui estamos indo célula a célula manualmente. É, porque estamos pegando a resposta e acabou, printamos, mostra a resposta, mas não tem o chat. Como você acha que podemos fazer esse laço aí? Podemos fazer com o while. Boa! Nós aprendemos o while na live intermediária de Python. Bom, podemos começar aqui criando uma variável que vai ser a entrada do usuário. Podemos chamar de prompt, por exemplo. Prompt, uma

variávelzinha. E aí vamos dar um igual (=) ali e colocar o que agora? É o input! Ah, lembra da live intermediária de Python? O pessoal também já deve ter aprendido. Então esse input vai ser o que a pessoa vai enviar ali. Então podemos até colocar entre parênteses aqui uma mensagem para pessoa saber que ela precisa enviar algo. Pode ser colocar entre aspas algo como "Esperando prompt" e dois pontos. Ele até tinha dado uma sugestão, "envie sua pergunta" e tudo, mas dá na mesma e eu recomendo dar um espaço depois dos dois pontos porque é mais

padrão. Perfeito! E agora podemos criar aquele while, para fazer esse lance de conseguir interagir. Temos que pensar numa palavra para acabar o while. Se estamos fazendo um chat com um bot, temos que ter alguma palavra que decidirmos que, quando digitarmos essa palavra, a conversa acaba. É igual eu tinha com uma ex-namorada minha, Quando estávamos no meio de uma briga muito ruim, nós tínhamos uma palavra secreta para "olha, vamos dar um tempo, vamos cadar para o seu canto, vamos parar, que não queremos piorar a situação". Então, é uma palavra-chave. Isso. Perfeito! E você pode escolher qualquer

palavra. Pode ser algo como "fim" mesmo. Sim, tranquilo. Perfeito! Então eu posso começar com o while, que é o enquanto, o nosso prompt, que foi o que pegamos do usuário. Não for igual a fim, for diferente disso, lembrando, diferente é não igual. Aí podemos especificar isso com a exclamação e o símbolo de igual. E colocar o fim ali entre aspas depois. E lembrando... Perdão, pode falar, por favor. Talvez seja a mesma coisa! Aqui estamos colocando fim com a letra minúscula, você tem que escrever exatamente como está aqui. Se você escrever com letra maiúscula, ele não

vai entender. Ou pôr um ponto no final, qualquer coisa assim. Tem que ser exatamente esses três caracteres. Pode até colocar outra palavra que você quiser, mas vamos usar fim aqui que é mais lógico. Perfeito. Colocamos os dois pontinhos ali no final. Aí vamos para próxima linha ali para fazer o nosso while. Então, quando não tivermos fim, enquanto não tiver o fim, colocamos a nossa resposta. Resposta. Vai receber o quê? Ela vai ser igual ao nosso chat que nós já criamos. Vamos dar aquele ponto e fazer o send_message. Como está aqui, ele até sugere e tal.

Mandando o prompt ali dentro. Estamos mandando para quem? Estamos mandando para o Gemini, o próprio servidor do Google. Perfeito. Beleza. Colocamos o prompt, legal. Com essa resposta, vamos imprimi-la, mostrar para o usuário. Então, podemos ir para próxima linha e fazer um print. Print. Seria aqui o resposta.text. Se dermos um print(resposta), ele vai mostrar tudo isso daqui. Essa coisa inteira. Queremos mostrar só o texto. Exato. Podemos colocar, inclusive, antes do resposta.text, um "Resposta" ali entre aspas, mais formatado para ficar mais bonitão. Podemos colocar "Resposta" e dois pontos (:). Dois pontos, espaço. Precisamos dar uma vírgula ali

depois para colocar a resposta.text. Boa. E aí também podemos colocar para ele pular uma linha ali. Uma ou duas linhas para facilitar a leitura. Eu vou colocar isso aqui, para quem não sabe como pula linha, isso aqui podemos só copiar, coloca entre aspas uma barra invertida + n. Pode colocar até duas, como a Val sugeriu. Dois barras+n. É, se for só uma, pode escrever só um print. Só uma também, é, exatamente. E aí, por fim, vamos ter a variável prompt ali, que vai ser igual ao input. É basicamente o que colocamos ali em cima. É,

para o bot esperar a próxima pergunta. É, porque senão, se a gente rodar assim, ele vai, olha... Pegou uma primeira pergunta aqui. Quem foi o Rogério Ceni? Aí ele vai ver: enquanto esse prompt for diferente de fim. O prompt é: quem foi o Rogério Ceni? Não é fim, vou entrar aqui. Manda esse prompt lá para o Gemini, a resposta vai ficar armazenada nessa variável resposta, eu vou imprimir o texto dessa variável, dar um espacinho aqui a mais... E aí? E a variável não é fim, então ele não vai acabar nunca. Ele vai parecer que está

travado. Então temos que fazer uma nova pergunta, para saber se essa nova pergunta, esse novo prompt, vai ser um fim ou outra pergunta. Então colocamos igualzinho o que fizemos ali no início. Podemos simplesmente copiar, porque essa variável prompt é a variável que está sendo comparada aqui com fim no while. Então terminou isso aqui, ele vai voltar para o começo, para essa primeira linha do while, ele vai ver: Olha, essa nova questão aqui, ela é fim? Sim ou não. E aí vai entrar de novo ou terminar o nosso loop aqui, a nossa interação. Vamos rodar. E

eu quero usar esse mesmo exemplo. Olha, como usamos o input apareceu a caixinha agora para mandar a mensagem. Quem foi o Rogério Ceni? Dá um "Enter" aqui. Respondeu: Rogério Ceni é um ex-jogador e atual treinador de futebol brasileiro. Ele atuava como goleiro. E agora ele está esperando um novo prompt. É isso. O que eu coloco? Qual foi o time onde ele mais jogou? São Paulo. E olha que ele está respondendo super sucintamente, porque configuramos aqui em cima, no nosso System Instruction, que ele sempre responde de forma sucinta. E agora ele está esperando de novo. Aí,

uma coisa interessante, voltando para a própria explicação que você deu. Você fez a pergunta falando "ele". É, que "ele" mais jogou. Ele quem? Exato, o bot entendeu, pelo histórico da conversa, Que com "ele" você está se referindo à última pessoa que você mencionou ou que ele mencionou. E também você pode fazer a pergunta do exemplo que eu comentei: qual foi a primeira pergunta que eu fiz? Boa. Vamos lá. Aí, a primeira pergunta que você fez, se você voltar a tela lá para cima... Quando a gente criou o objeto do chatbot... Foi "o que é a

computação quântica?", que não tem nada a ver com o Rogério Ceni. Aí, agora você pode digitar fim para sairmos. fim minúsculo aqui. E terminou. Ficou o check verde. Aí, você pode criar uma nova célula. Como última verificação que podemos fazer aqui, e ver o histórico do chatbot. É o mesmo aqui. O chat.get_history. Ele até completa para nós. Abre e fecha parênteses. Vamos rodar. E agora o histórico está maior, porque teve mais interações. Mas você tem lá: o que é a computação quântica, a resposta, quem foi o Rogério Ceni, aqui com o role user, que o

usuário perguntou, Aí, a resposta, qual o time que ele mais jogou e por aí vai. E eu quero brincar com mais uma coisa do nosso System Prompt aqui, antes de começarmos a finalizar a aula, que é: demos uma instrução de sistema que é muito coxinha, vamos dizer assim. É muito tranquila, responde aí de forma sucinta. Mas eu quero voltar aqui. Pode voltar para a mesma célula que estávamos ou eu posso copiar essa parte aqui para baixo para criar um novo chat. Isso. Para não perder o nosso histórico aqui. Criar um código. Vou mudar essa System

Instruction. Eu quero: você é um assistente pessoal. Vou colocar chat_config_2, talvez. chat_2, ou algo nesse sentido. E aqui embaixo vai a chat_config_2. Você é um assistente pessoal que sempre responde de forma muito sarcástica. Não tem nada a ver com o nosso anterior. Vamos... Geramos a configuração, Geramos o nosso cliente de chat aqui. E aqui para ver se ele está funcionando, podemos copiar só a resposta. Não precisa nem ser o chat inteiro, a lógica inteira. Mas só vamos gerar aqui. Mas quem vai gerar não vai ser o chat, vai ser o chat_2. Acabamos de criar o

chat_2 aqui. Vamos mandar essa mensagem. O que é computação quântica? Pode ser inclusive a mesma pergunta aqui do Luciano. Ah, computação quântica. Basicamente, é como uma computação normal, mas com mais passos inexplicáveis E a promessa de resolver problemas que ninguém consegue sequer entender. Ele foi extremamente sarcástico. Então, foi exatamente o que pedimos para ele ser lá na instrução do sistema. Perfeito. Então, já fica aí a dica para o pessoal: testar diferentes coisas nesse System Instruction, para ir mudando o jeito que o modelo está respondendo e tal. E isso vai ser uma coisa que vamos usar

muito amanhã, na nossa aula 5, a nossa aula de agentes. As instruções que vamos dar para os nossos agentes, de quem ele é, qual é a persona e tudo mais. Então, treinem bastante aí hoje. Perfeito. E bom pessoal, esse é o fim da nossa aula 4, assustadora a aula de código, que eu acho que nem foi tão assustadora assim. Foi super tranquila. E agora é o momento da verdade que a gente comentamos lá no começo da imersão, na aula 1. Comentamos também no começo da aula de hoje, da aula 4, que é aqui que vamos

dar o enunciado do projeto que vocês vão desenvolver para ganhar o prêmio, todas as premiações, os 10 prêmios que vamos ter nessa imersão de IA da Alura com o Google Gemini. O regulamento vai ter alguns pontos importantes. O primeiro deles é que você vai ter que gerar um projetinho usando a API Key aqui do Google Gemini, que ensinamos vocês ontem onde pegar ela lá no Google AI Studio, recapitulamos hoje também onde você a pega. E aí você vai poder começar a criar o seu projeto já hoje, amanhã, também no sábado, para você enviar um projeto

completo até no final do sábado à noite. Mas estamos dando o recado agora para você já ter um tempo a mais, alguns dias a mais, para começar a pensar nas ideias de como desenvolver o seu projeto. Você pode ir no próprio Gemini para pegar ideias de que tipo de projeto você pode desenvolver, Para te ajudar com a parte do código se você quiser fazer um código mais complexo... Mas como vimos lá no começo desse episódio, você não precisa ser uma pessoa de código. O Anderson, que foi campeão da nossa última imersão, não era uma pessoa

de código. Mas o projeto dele ficou tão legal, tão útil, tão criativo, que ele foi a pessoa que ganhou o prêmio número 1 daquela imersão. Então isso não é o mais importante, mas você vai sim ter que usar a API key, a chave de API do Google Gemini no seu projeto. E aí você vai poder fazer algo parecido com o que fizemos hoje, mas não faça um chatbot tão básico assim Que acredito que não vai ser votado pela comunidade, não vai ser votado por nós para ser o primeiro prêmio. Vai ter amanhã a aula de

agentes, onde vamos dar mais conteúdo ainda para você mais ideias de coisas que você vai poder aplicar para criar o seu projetão. Quais são os pontos mais importantes? Você vai ter acesso a um formulário do Google Forms que vai estar na descrição da aula de hoje, da aula de amanhã, vai estar no guia de mergulho também, onde você vai ter apenas 3 campos para você entrar lá. O primeiro campo é o seu nome completo, o segundo campo é o seu e-mail, para podermos te contatar de alguma forma caso você seja uma das pessoas vencedoras, E

o terceiro campo vai ser um espaço para você colocar o link do seu projeto no GitHub. Se você não sabe o que é GitHub, onde colocar, como criar um repositório, essas coisas assim, não tem problema. Aqui também embaixo dessa aula, e também da próxima aula, tem um link de uma aula extra para você assistir, onde ensinamos tim-tim por tim-tim: como criar um repositório lá no GitHub, como mexer no README, que é a aba onde você vai ler e colocar as informações mais importantes do seu projeto. E você pode até usar o próprio Gemini para criar

um README mais bacanudo, mais legal, uma apresentação mais legal para nós também. Mas não se preocupe com isso, que isso é a parte fácil. É um formulário com simplesmente 3 campos: nome, e-mail e o link que você vai mandar do seu projeto para o GitHub. Próximo ponto. Você pode mandar mais de um projeto, mas só um projeto vai realmente concorrer e vai ser selecionado por nós para concorrer ao prêmio. Então se você mandar 557 projetos, a comunidade vai ter uma votação lá, e se tiver 30 projetos seus que forem eleitos, só um deles, o que

tiver mais votos, vai valer. Você pode criar mais se você tiver muitas ideias legais, mas só um vai valer porque você não vai poder ganhar mais de um prêmio. Então fica de olho nisso. E também é interessante pensar que talvez valha mais você colocar mais energia em um projeto, para ele ficar muito bom, muito destacado, do que fazer 15 projetos meia boca que não vão ter tanta chance assim. Uma dica aqui de pessoa que já participou e acompanhou imersões no passado. Próximo ponto. O envio desse formulário só vai ser liberado no sábado, à meia noite

de sexta-feira para sábado, quando der zero horas, até as 23h59 do próprio sábado. Vai ser um dia inteiro. Então você vai ter hoje para desenvolver o seu projeto, amanhã, o sábado inteiro também, mas você tem que enviar ele lá nesse link do formulário do Google Forms até as 23h59 do sábado, dia 17 de maio de 2025. Essa é a próxima regra. E depois disso, o que vai acontecer? Vamos ter uma primeira seleção, porque eu imagino que vai ter muitos projetos de todos vocês que estão acompanhando a imersão de IA. E essa primeira seleção vai ser

feita lá no Discord da imersão. Vai ter uma abinha especial que vamos mostrar aqui no Guia de Mergulho como acessar, onde fica, não se preocupe com isso. Para quem tem medo de Discord, não se preocupe, é muito fácil de você achar essa abinha de onde colocar o seu projeto. Nós mesmos vamos liberar esses projetos para serem votados só no domingo à meia noite. Sábado você vai ter como enviar esse projeto até 23h59, quando passar um minutinho, meia noite do sábado para o domingo, zero horas, vamos liberar lá no grupo do Discord todos esses projetos de

vocês para serem votados. E aí você vai poder compartilhar com seus amigos que estão fazendo a imersão também, com o pessoal lá, explicando para eles: Olha, eu fiz um projeto que faz isso, que é super legal por causa desse motivo. Vocês vão ter uma votação interna entre vocês sobre os projetos mais legais da comunidade. Isso é para fomentar vocês compartilharem e conversarem. Isso é uma coisa muito importante, né, Luciano e Val? Quando estamos dentro de uma comunidade de programação, nós fazermos parte dessa comunidade. Até tem as comunidades de código open source, que também são muito

grandes. Assim você aprende mais, faz um networking, colabora com outras pessoas. Isso é importantíssimo e queremos fomentar isso. Domingo, a partir de zero horas, até domingo mesmo, às 23h59, Vai ser o período de avaliação. Todos vocês vão ter exatamente o mesmo período. Se você terminar o código hoje, terminou o projeto, achou maravilhoso, mandou para nós lá no Google Forms, ninguém vai estar vendo ainda, ninguém vai estar votando ainda. Então a discrepância que tivemos, que aprendemos de outras imersões no passado, quando tinha uma discrepância de pessoas que tinham um nível mais alto de programação que outras.

Agora não vai ter isso. Estará todo mundo exatamente ao mesmo tempo. Só vai poder enviar o projeto para nós no sábado, E só vai estar liberado para fazer as votações no domingo, entre 0h do sábado para o domingo e 23h59 do próprio domingo. E é óbvio que queremos fomentar a colaboração, a comunidade entre vocês, mas não vai encher o saco do pessoal no privado para pedir voto, para falar "eu te dou não sei o que se você me der mais um voto". Sejam razoáveis. Vamos fazer organizadinho, bonitinho, explicar o que o seu projeto faz e

o pessoal vai ver, putz, realmente é um projeto legal. Fazer uma apresentação legal lá no repositório do seu GitHub, no seu README, isso conta bastante também. E vai ter o pessoal que vai querer fazer um vídeo de apresentação, Gravar ali no celular mesmo, ou gravar a tela do seu computador, jogar ali no Discord para o pessoal ver e putz, a pessoa gerou um vídeo, que legal, um projeto muito legal, se estiver rodando dentro do vídeo um projeto legal também. Então manerem no quanto você vai pedir e encher o saco de outras pessoas. Mas, como eu

falei, vamos avaliar esses projetos. Primeiro vai ter essa votação entre vocês, e os 30 projetos mais bem avaliados vão vir para nós, para uma banca seletiva interna nossa, da Alura, do Google, em que vamos rodar cada um desses projetos na mão para analisar quais foram os melhores. E dentre esses 30, vamos selecionar os 10 melhores Que vão ganhar os prêmios que estão lá na página de inscrição da imersão de IA. E eu falei bastante sobre a apresentação do projeto para vocês votarem entre si, para dar um destaque a mais para o seu projeto, mas sendo

transparente aqui com vocês sobre quais vão ser os pontos mais importantes que a banca avaliadora vai utilizar para realmente avaliar quais foram os melhores 10 projetos dentre esses 30, são quatro. O primeiro deles é a utilidade do seu projeto. Qual o problema real, seu, da sua família, da sociedade, ele vai resolver. Esse vai ser o primeiro ponto de avaliação. O segundo é a criatividade. Ou seja, um projeto útil mas em que você só fez um chatbotzinho básico, provavelmente vai perder pontos de criatividade. Então, talvez, o modo como você criou o seu prompt, o modo como

você exibiu, fez a construção do projeto, vai contar bastante, porque criatividade é o segundo ponto. O terceiro é a eficácia. O quão bem esse problema está sendo resolvido pelo seu código, pelo seu projeto, pela sua API Key, se você vai usar o seu agente, seja lá o que você for fazer no seu projeto. E o quarto deles, como eu falei antes, é a apresentação. Ou seja, a apresentação vai contar não só para você ganhar os votos lá atrás, dentre vocês da própria comunidade lá no Discord, Mas também para a banca avaliar e falar: esse projeto

está com um README muito bem feito. Claro, se todos estiverem bem feitos, eu imagino que a nota seja igual ou muito similar. Mas esse aqui também vai ser um dos 4 pontos que a banca avaliadora vai utilizar aqui. Então recapitulando tudo. Está dada a largada agora para vocês começarem a pensar nas ideias, a gerar API Keys para criar os seus próprios projetos. Vão criando até o sábado, vocês vão poder mandar apenas no sábado, entre meia noite e 23h59, e aí vocês vão poder votar, no próprio Discord, Apenas no domingo, entre meia noite e 23h59. Depois

os 30 melhores vão vir para a banca avaliadora interna nossa, e aí a banca avaliadora vai avaliar esses pontos de utilidade, criatividade, eficácia e apresentação desses 30 projetos. E os 10 melhores vão ser os vencedores que vão ser anunciados na live do dia 19 de maio, a live de encerramento dessa nossa imersão. Dia 19 de maio, segunda-feira, às 18h30. Então eu recomendo que você, se você fizer o projeto, você acompanhe lá para ver se você ganhou ou não. Se você não fez projeto, eu recomendo que você faça primeiro, mas se você não teve tempo e

não conseguiu fazer, acompanhe para ver, dar um suporte para as pessoas, ver os projetos, Os 10 melhores que foram criados pelo pessoal. Vai ser muito interessante. Na última imersão também foi maravilhoso acompanhar tudo isso junto com vocês. E qualquer dúvida que você tiver sobre tudo isso que eu acabei de falar, você vai ter acesso ao regulamento, tanto aqui embaixo quanto lá no guia de mergulho. Se você quiser ler, se você não quer ler, você copia e manda para o Gemini, faz pergunta para o Gemini, sobre algum ponto que você tiver alguma dúvida sobre o regulamento.

Mas é isso, pessoal. Muito boa sorte, espero que vocês aproveitem para se desenvolver também. Não é um projeto só para ganhar um prêmio, para ganhar uma bolsa, Mas você aprender uma habilidade nova, seja o Python, a programação, seja os agentes, alguma outra coisa por aí. Nos vemos aqui para a última aula dessa imersão de IA da Alura com o Google Gemini amanhã, para você aprender mais sobre agentes. Eba, vem aí! Até amanhã!